hkl | Diffractometer computation library | Incremental Backup library

You could do something like this with your data:

I exported data from the registry (\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layouts) in Windows 10 and based on it created a table. And with the help of SHLoadIndirectString got the localized name of the keyboard.

If you call TranslateMessage in your message loop, this function will cause an additional WM_CHAR message to be created when a WM_KEYDOWN message is received. This WM_CHAR message will contain the typed character, taking into account whether the SHIFT key is pressed. For example, if the user types a b will holding the SHIFT key, then the WM_CHAR message will contain the character code for a B.

As stated above, TranslateMessage will do all the work for you. If, for some reason, you do not want to use this function, you could try using the functions ToAscii or ToUnicode instead. But, as stated in the documentation, these functions have the disadvantage that they are unable to handle dead keys properly. Therefore, I recommend using TranslateMessage.

The very first sentence of the ActivateKeyboardLayout function documentation states: "Sets the input locale identifier (formerly called the keyboard layout handle) for the calling thread or the current process.". Since you never read input in your program, you don't observe its effect. It does not change the keyboard layout of the system.

On Windows, each thread has its own keyboard layout. To change the keyboard layout for a specific window, you need to send the WM_INPUTLANGCHANGEREQUEST message to it:

how does one obtain a KLID from an HKL?

There seems no direct method out of box to achieve it.

A workaround is retrieving a list of HKLs, then active a layout via a HKL, then get its KLID. The following is an example:

When you use the writeScannedKey function, the following codes all write two bytes to the file

According to the documentation pages (MapVirtualKeyExA function and MapVirtualKeyExW function) the function returns an UINT and not a char:

What I have tried that DID NOT help:

'WarnAsError': 'false' should do the trick; however the error was reported for two different files (..\src\keyboard-layout-manager.cc and ..\src\keyboard-layout-manager-windows.cc) so you'd have to modify the build rules for both of them.

Disabling the warning should help too, but it'd have to be warning 4309 (not 2220) that you need to disable. Again, you'd have to do that for both files (or just for the entire compilation).

Are the old and new lines not theoretically the same? One shifted for 32 bits results in 0xFFFFFFFF?

No, 1 << 32 == 0x100000000 == 0xFFFFFFFF + 1).

What can I do to fix this issue?

• turning off 'WarnAsError' should help
• turning off warning 4309 should help
• reverting that one line in your local checkout should help
• using Clang instead of MSVC should help
• possibly using a different (newer?) version of MSVC would also help

and what could be the reason for this change?

V8 now allows TypedArrays with up to 2**32 elements, which is one more element than before.

Why is this problem only on Windows?

Because warnings are compiler-specific, and MSVC is only used on Windows.

The weird part is that you're seeing this error in the first place. You compile with --x64; if that does what it sounds like, you should be compiling a 64-bit build, where internal::kApiSystemPointerSize == 8 and size_t has 64 bits just like uint64_t, so in the expression static_cast(uint64_t{1} << 32); nothing gets truncated.

Even if for whatever reason this build tried to create a 32-bit build of V8, then the other branch should be taken (internal::kApiSystemPointerSize == 4) and the compiler should be smart enough not to warn about a branch that's statically dead anyway.

At any rate, this seems like a compiler bug/limitation. So appropriate workarounds are to either update your compiler, or disable the erroneous warning.

There's this small script used it to find entries in some very long and unnerving JSONs. not very beautifull und badly documented but maybe helps in your scenario.