How to extract the character from WM_KEYDOWN in PreTranslateMessage(MSG*pMsg)

Question

In a MFC application within PreTranslateMessage(MSG *pMsg) inherited from a CView, I have this:

if (pMsg->message == WM_KEYDOWN) ...

The fields in a WM_KEYDOWN are documented here. The virtual key VK_ value is in pMsg->wParam and pMsg->lParam contains several field, of which bits 16-23 is the keyboard scan code.

So in my code I use:

const int virtualKey = pMsg->wParam;
const int hardwareScanCode = (pMsg->lParam >> 16) & 0x00ff; // bits 16-23

On my non-US keyboard for example, when I press the "#" character, I get the following:

virtualKey == 0xde --> VK_OEM_7 "Used for miscellaneous characters; it can vary by keyboard."
hardwareScanCode == 0x29 (41 decimal)

The character I'd like to "capture" or process differently is ASCII "#", 0x23 (35 decimal).

MY QUESTION

How do I translate the WM_KEYDOWN information to get something I can compare against, regardless of language or keyboard layout? I need to identify the # key whether the user has a standard US keyboard, or something different.

For example, I've been looking at the following functions such as:

MapVirtualKey(virtualkey, MAPVK_VSC_TO_VK);
// previous line is useless, the key VK_OEM_7 doesn't map to anything without the scan code

ToAscii(virtualKey, hardwareScanCode, nullptr, &word, 0);
// previous line returns zero, and zero is written to `word`

---

Edit:

Long story short: On a U.S. keyboard, SHIFT+3 = #, while on a French keyboard SHIFT+3 = /. So I don't want to look at individual keys, instead I want to know about the character.

When handling WM_KEYDOWN, how do I translate lParam and wParam (the "keys") to find out the character which the keyboard and Windows is about to generate?

Answer 1

I believe this is a better solution. This one was tested with both the standard U.S. keyboard layout and the Canadian-French keyboard layout.

const int wParam = pMsg->wParam;
const int lParam = pMsg->lParam;
const int keyboardScanCode = (lParam >> 16) & 0x00ff;
const int virtualKey = wParam;

BYTE keyboardState[256];
GetKeyboardState(keyboardState);

WORD ascii = 0;
const int len = ToAscii(virtualKey, keyboardScanCode, keyboardState, &ascii, 0);
if (len == 1 && ascii == '#')
{
    // ...etc...
}

Even though the help page seems to hint that keyboardState is optional for the call to ToAscii(), I found that it was required with the character I was trying to detect.

Answer 2

I'm not an MFC expert, but here's roughly what I believe its message loop looks like:

while (::GetMessage(&msg, NULL, 0, 0) > 0) {
    if (!app->PreTranslateMessage(&msg)) {    // the hook you want to use
        TranslateMessage(&msg);  // where WM_CHAR messages are generated
        DispatchMessage(&msg);  // where the original message is dispatched
    }
}

Suppose a U.S. user (for whom 3 and # are on the same key) presses that key.

The PreTranslateMessage hook will see the WM_KEYDOWN message.

If it allows the message to pass through, then TranslateMessage will generate a WM_CHAR message (or something from that family of messages) and dispatch it directly. PreTranslateMessage will never see the WM_CHAR.

Whether that WM_CHAR is a '3' or a '#' depends on the keyboard state, specifically whether a Shift key is currently pressed. But the WM_KEYDOWN message doesn't contain all the keyboard state. TranslateMessage keeps track of the state by taking notes on the keyboard messages that pass through it, so it knows whether the Shift (or Ctrl or Alt) is already down.

Then DispatchMessage will dispatch the original WM_KEYDOWN message.

If you want to catch only the '#' and not the '3's, then you have two options:

1. Make your PreTranslateMessage hook keep track of all the keyboard state (like TranslateMessage would normally do). It would have to watch for all of the keyboard messages to track the keyboard state and use that in conjunction with the keyboard layout to figure whether the current message would normally generate a '#'. You'd then have to manually dispatch the WM_KEYDOWN message and return TRUE (so that the normal translate/dispatch doesn't happen). You'd also have to be careful to also filter the corresponding WM_KEYUP messages so that you don't confuse TranslateMessage's internal state. That's a lot of work and lots to test.

2. Find a place to intercept the WM_CHAR messages that TranslateMessage generates.

For that second option, you could subclass the destination window, have it intercept WM_CHAR messages when the character is '#' and pass everything else through. That seems a lot simpler and well targeted.

Answer 3

Found the magic API call that gets me what I need: GetKeyNameText()

if (pMsg->message == WM_KEYDOWN)
{
    char buffer[20];
    const int len = GetKeyNameTextA(pMsg->lParam, buffer, sizeof(buffer));
    if (len == 1 && buffer[0] == '#')
    {
        // ...etc...
    }
}

Nope, that code only works on keyboard layouts that have an explicit '#' key. Doesn't work on layouts like the standard U.S. layout where '#' is a combination of other keys like SHIFT + 3.