C++ – global low level keyboard hook being called when SendInput is made. how to prevent it

cwinapi

I have a win 32 application written in c++ which sets the low level keyboard hook. now i want to sendInput to any app like word / notepad. how do i do this?

i have already done enough of using findwindow / sendmessage. for all these, i need to know edit controls. finding the edit control is very difficult.

since SendInput works for any windows application, i want to use it. the problem is i get a call to my callback function with the pressed key.

for e.g i pressed A and i want to send U+0BAF unicode character to the active applciation windows. in this case, assume it is notepad.

the problem is i get two characters U+0BAF and A in the notepad.

A is being sent because i am calling CallNextHookEx( NULL, nCode, wParam, lParam);

if i return 1 after sendInput, then nothing is sent to notepad.

any suggestion?

Best Answer

If I understood your problem correctly, you should ignore "injected" key events
in your hook procedure like this:

LRESULT CALLBACK
hook_proc( int code, WPARAM wParam, LPARAM lParam )
{
  KBDLLHOOKSTRUCT*  kbd = (KBDLLHOOKSTRUCT*)lParam;

  // Ignore injected events
  if (code < 0 || (kbd->flags & 0x10)) {
    return CallNextHookEx(kbdhook, code, wParam, lParam);
  }
  ...

Update: additionally you have to eat characters and notify some other routine
for a character press through Windows messages.

Example:

...
// Pseudocode
if (kbd->vkCode is character) {
  if (WM_KEYDOWN == wParam) {
    PostMessage(mainwnd, WM_MY_KEYDOWN, kbd->vkCode, 0);
    return 1; // eat the char, ie 'a'
  }
}
return CallNextHookEx(kbdhook, code, wParam, lParam);

And in some other module you handle WM_MY_KEYDOWN

ie, #define WM_MY_KEYDOWN (WM_USER + 1)

and call the appropriate routine that will generate new key events.

Related Solutions

C# – Low-level Keyboard Hooks/SendInput with Winkey+L possible? (workstation lockout is intercepted in Vista and higher)

I figured out a way to do this in C#. There are four states involved in a possible Win+L keypress sequence (None, Win, Win+L, L). Whenever the Win+L state is reached, set a flag ("winLSet" below). Whenever all of the keys have been released, we check for this flag and simulate the press if it's been set.

The final piece of the puzzle is to simulate the WinKey's KeyUp before the Ctrl-L (no KeyDown). I've tried similar approaches in AutoHotkey and it never worked, but it seems to work perfectly here.

The code is below. Please see explanatory notes at the bottom if you plan to use this code.

public partial class MainWindow : Window
{
    LowLevelKeyboardHook hook;

    bool winKeyDown;
    bool lKeyDown;
    bool winLSet;

    public MainWindow()
    {
        InitializeComponent();

        hook = new LowLevelKeyboardHook();

        hook.KeyDown += OnKeyDown;
        hook.KeyUp += OnKeyUp;
    }

    void OnKeyDown(object sender, LowLevelKeyEventArgs e)
    {
        e.EventHandled = true;

        switch (e.Key)
        {
            case Key.L:
                lKeyDown = true;
                UpdateWinLState();
                e.EventHandled = winKeyDown;
                break;

            case Key.LWin:
                winKeyDown = true;
                UpdateWinLState();
                InputSimulator.SimulateKeyDown(VirtualKeyCode.LCONTROL);
                break;

            case Key.LeftCtrl:
                InputSimulator.SimulateKeyDown(VirtualKeyCode.LWIN);
                break;

            default:
                e.EventHandled = false;
                break;
        }
    }

    void OnKeyUp(object sender, LowLevelKeyEventArgs e)
    {
        e.EventHandled = true;

        switch (e.Key)
        {
            case Key.L:
                lKeyDown = false;
                UpdateWinLState();
                e.EventHandled = winKeyDown;
                break;

            case Key.LWin:
                winKeyDown = false;
                UpdateWinLState();
                InputSimulator.SimulateKeyUp(VirtualKeyCode.LCONTROL);
                break;

            case Key.LeftCtrl:
                InputSimulator.SimulateKeyUp(VirtualKeyCode.LWIN);
                break;

            default:
                e.EventHandled = false;
                break;
        }
    }

    void UpdateWinLState()
    {
        if (winKeyDown && lKeyDown)
        {
            winLSet = true;
        }
        else if (!winKeyDown && !lKeyDown && winLSet)
        {
            winLSet = false;

            InputSimulator.SimulateKeyUp(VirtualKeyCode.LWIN);

            InputSimulator.SimulateModifiedKeyStroke(
                VirtualKeyCode.LCONTROL,
                (VirtualKeyCode)'L');
        }
    }
}

For posterity: please note that this code uses InputSimulator and LowLevelKeyboardHook, which are not from the .NET Framework. LowLevelKeyboardHook is a class I wrote a while back that exposes global KeyDown and KeyUp events as C# events. There are similar examples here, here, and a bunch can be found here.

Also notice that I'm using System.Windows.Input.Key, not System.Windows.Forms.Keys, which could confuse some people. System.Windows.Input.Key is the new enumeration of keys in .NET 3.0 and above, while System.Windows.Forms.Keys is the old enumeration from Windows Forms.

C++ – Windows: How to query state of modifier keys within low level keyboard hook

The documentation for LowLevelKeyboardProc says the following about the return value:

If the hook procedure processed the message, it may return a nonzero value to prevent the system from passing the message to the rest of the hook chain or the target window procedure.

So, return 1 says "I've processes the information, and there is nothing else that should be done with these keys".

I'm not certain how you fix the problem with detection of WIN key on it's own - I suspect the system just simply doesn't forward that has a keyboard event until the second key is pressed.

Best Answer

Related Solutions

C# – Low-level Keyboard Hooks/SendInput with Winkey+L possible? (workstation lockout is intercepted in Vista and higher)

C++ – Windows: How to query state of modifier keys within low level keyboard hook

Related Topic