Хитрая работа с Num Lock

#define WINVER          0x0501
#define _WIN32_WINNT    0x0501
#define _WIN32_WINDOWS  0x0501
#define _WIN32_IE       0x0600
 
 
 
#include <algorithm>
#include <string>
#include <vector>
#include <Windows.h>
#include <InitGuid.h>
 
#include <SetupAPI.h>
#pragma comment(lib, "setupapi.lib")
 
#include <strsafe.h>
 
 
 
namespace
{
 
 
 
//
// The declarations below are taken from ntddkbd.h (WDK 7.1)
// ----------------------------------------------------------
 
 
 
#define KEYBOARD_CAPS_LOCK_ON     4
#define KEYBOARD_NUM_LOCK_ON      2
#define KEYBOARD_SCROLL_LOCK_ON   1
 
 
 
typedef struct _KEYBOARD_INDICATOR_PARAMETERS {
 
    //
    // Unit identifier.  Specifies the device unit for which this
    // request is intended.
    //
 
    USHORT UnitId;
 
    //
    // LED indicator state.
    //
 
    USHORT    LedFlags;
 
} KEYBOARD_INDICATOR_PARAMETERS, *PKEYBOARD_INDICATOR_PARAMETERS;
 
 
 
//
// Keyboard device interface GUID.
//
DEFINE_GUID( GUID_DEVINTERFACE_KEYBOARD, 0x884b96c3, 0x56ef, 0x11d1, \
             0xbc, 0x8c, 0x00, 0xa0, 0xc9, 0x14, 0x05, 0xdd);
 
 
 
//
// IOCTL for set keyboard indicators.
//
// Input parameters:
//
//     Pointer to KEYBOARD_INDICATOR_PARAMETERS structure.
//
// Output parameters:
//
//     None.
//
#define IOCTL_KEYBOARD_SET_INDICATORS CTL_CODE(FILE_DEVICE_KEYBOARD, 0x0002, METHOD_BUFFERED, FILE_ANY_ACCESS)
 
 
 
__declspec(noreturn)
void
throw_exc(char const *pFormat, ...)
{
    va_list VaList;
    va_start(VaList, pFormat);
    size_t const BuffSize = 1000;
    char pBuffer[BuffSize];
    std::string ErrMsg;
 
    if (S_OK == StringCchVPrintfA(&pBuffer[0], BuffSize, pFormat, VaList))
    {
        ErrMsg = &pBuffer[0];
    }
 
    else
    {
        ErrMsg = pFormat;
    }
 
    throw (std::runtime_error(ErrMsg.c_str()));
}
 
 
 
std::wstring
_stdcall
GetDeviceSymLink(
    __in    HANDLE                          hDevInfo,
    __in    SP_DEVICE_INTERFACE_DATA      * pIfaceData,
    __in    DWORD                           Index
    )
{
    // Get symbolic link of the device.
 
    std::vector<byte> Buffer;
    Buffer.resize(sizeof (SP_DEVICE_INTERFACE_DETAIL_DATA_W));
 
    for (;;)
    {
        SP_DEVICE_INTERFACE_DETAIL_DATA_W *pDetail = (SP_DEVICE_INTERFACE_DETAIL_DATA_W *)&Buffer[0];
        pDetail->cbSize = sizeof (SP_DEVICE_INTERFACE_DETAIL_DATA_W);
        DWORD RequiredSize;
 
        if (FALSE != SetupDiGetDeviceInterfaceDetailW(
            hDevInfo,
            pIfaceData,
            pDetail,
            Buffer.size(),
            &RequiredSize,
            NULL // PSP_DEVINFO_DATA (optional).
            ))
        {
            return (&pDetail->DevicePath[0]);
        }
 
        DWORD const LastError = GetLastError();
 
        if (ERROR_INSUFFICIENT_BUFFER != LastError)
        {
            throw_exc(
                "%s: SetupDiGetDeviceInterfaceDetailW failed with last error 0x%.8lx (index = %lu).",
                __FUNCTION__,
                LastError,
                Index
                );
        }
 
        Buffer.resize(RequiredSize);
    }
}
 
 
 
bool
_stdcall
IsRdpKeyboard(std::wstring const &SymLink)
{
    // Convert to uppercase.
 
    std::wstring Temp   = SymLink;
    size_t const Length = Temp.length();
 
    for (size_t i = 0; i < Length; ++i)
    {
        wchar_t const Ch = Temp.at(i);
        Temp.at(i) = towupper(Ch);
    }
 
    return (NULL != wcsstr(Temp.c_str(), L"RDP_KBD"));
}
 
 
 
std::wstring
_stdcall
GetKeyboardSymLink()
{
    // Create information set for devices that
    // supports 'keyboard' interface.
 
    HANDLE const hDevInfo = SetupDiGetClassDevsW(
        &GUID_DEVINTERFACE_KEYBOARD,
        NULL, // Enumerator.
        NULL, // HWND of parent window.
        DIGCF_DEVICEINTERFACE | DIGCF_PRESENT
        );
 
    if (INVALID_HANDLE_VALUE == hDevInfo)
    {
        throw_exc(
            "%s: SetupDiGetClassDevsW failed with last error 0x%.8lx",
            __FUNCTION__,
            GetLastError()
            );
    }
 
    // Inline RAII wrapper for hDevInfo.
    // Resources will be deleted at exit.
 
    struct auto_handle
    {
        HANDLE hDevInfo;
 
        ~auto_handle()
        {
            SetupDiDestroyDeviceInfoList(hDevInfo);
        }
    } AutoHandle = {hDevInfo};
 
    // Enumerate devices.
 
    DWORD Index = 0;
 
    for (;;)
    {
        SP_DEVICE_INTERFACE_DATA IfaceData;
        IfaceData.cbSize = sizeof (SP_DEVICE_INTERFACE_DATA);
 
        if (FALSE == SetupDiEnumDeviceInterfaces(
            hDevInfo,
            NULL, // PSP_DEVINFO_DATA (optional).
            &GUID_DEVINTERFACE_KEYBOARD,
            Index,
            &IfaceData
            ))
        {
            DWORD const LastError = GetLastError();
 
            if (ERROR_NO_MORE_ITEMS == LastError)
            {
                throw_exc(
                    "%s: no keyboards found.",
                    __FUNCTION__
                    );
            }
 
            throw_exc(
                "%s: SetupDiEnumDeviceInterfaces failed with last error 0x%.8lx (index = %lu).",
                __FUNCTION__,
                LastError,
                Index
                );
        }
 
        // We must not use 'RDP keyboard'.
 
        std::wstring const SymLink = GetDeviceSymLink(hDevInfo, &IfaceData, Index);
 
        if (false == IsRdpKeyboard(SymLink))
        {
            return SymLink;
        }
 
        ++Index;
    }
}
 
 
 
void
_stdcall
FlashKbdIndicators()
{
    //
    // Find first symbolic link to real (not RDP) keyboard device.
    //
 
    std::wstring const SymLink = GetKeyboardSymLink();
    
    //
    // Open device.
    //
 
    HANDLE const hDevice = CreateFileW(
        SymLink.c_str(),
        GENERIC_WRITE,
        FILE_SHARE_READ | FILE_SHARE_WRITE,
        NULL,
        OPEN_EXISTING,
        0,
        NULL
        );
 
    if (INVALID_HANDLE_VALUE == hDevice)
    {
        throw_exc(
            "%s: CreateFileW failed with last error 0x%.8lx.",
            __FUNCTION__,
            GetLastError()
            );
    }
 
    //
    // Inline RAII wrapper for device handle.
    //
 
    struct auto_handle
    {
        HANDLE hDevice;
 
        ~auto_handle()
        {
            CloseHandle(hDevice);
        }
    } AutoHandle = {hDevice};
 
    USHORT const LedFlags[] =
    {
        KEYBOARD_CAPS_LOCK_ON,
        KEYBOARD_NUM_LOCK_ON,
        KEYBOARD_SCROLL_LOCK_ON
    };
 
    int const NumLedFlags = sizeof (LedFlags) / sizeof (LedFlags[0]);
 
    for (int NumRounds = 0; NumRounds < 25; ++NumRounds)
    {
        for (int Flag = 0; Flag < NumLedFlags; ++Flag)
        {
            KEYBOARD_INDICATOR_PARAMETERS Params;
            Params.UnitId = 0;
            Params.LedFlags = LedFlags[Flag];
 
            DWORD nBytes;
 
            DeviceIoControl(
                hDevice,
                IOCTL_KEYBOARD_SET_INDICATORS,
                &Params,
                sizeof (Params),
                NULL,
                0,
                &nBytes,
                NULL
                );
 
            Sleep(100);
        }
    }
}
 
 
 
} // namespace
 
 
 
int
_stdcall
WinMain(
    __in    HINSTANCE                   /* hInstance     */,
    __in    HINSTANCE                   /* hPrevInstance */,
    __in    LPSTR                       /* pCmdLine      */,
    __in    int                         /* fShow         */
    )
{
    using namespace std;
 
    try
    {
        if (IDYES == MessageBoxA(
            NULL,
            "Are you ready to flash keyboard indicators ?",
            "QUESTION - FlashKbdIndicators",
            MB_YESNO | MB_ICONQUESTION
            ))
        {
            FlashKbdIndicators();
        }
    }
 
    catch (exception const &Exc)
    {
        MessageBoxA(
            NULL,
            Exc.what(),
            "ERROR - FlashKbdIndicators",
            MB_ICONERROR
            );
 
        return EXIT_FAILURE;
    }
 
    return EXIT_SUCCESS;
}