winapi

The rules are simple: You include the header files you need. The documentation for any API call includes information on which header to include.

I don't know whether it is always an error to include both and . You would have to consult the documentation for every symbol used by the code to verify.

As noted, though, the Windows SDK header files aren't exclusively used by a C or C++ compiler. The Resource Compiler is another client of those header files. Including after is potentially not even superfluous in this case.

Reading documentation at https://docs.microsoft.com/en-us/windows/win32/winmsg/wm-quit:

The WM_QUIT message is not associated with a window and therefore will never be received through a window's window procedure. It is retrieved only by the GetMessage or PeekMessage functions.

Do not post the WM_QUIT message using the PostMessage function; use PostQuitMessage.

=== Portion after this was added after answer accepted for further clarification ===

As others have noted, there are sort of two things going on in the original code submitted. In the message map, there is a switch case entry for WM_QUIT. The documentation I quoted shows that the message is not for windows and so the case statement will never get processed.

However, there is another issue going on. Look at the message pumping:

One benefit has been explained in the following Remarks.

Set the KEYEVENTF_SCANCODE flag to define keyboard input in terms of the scan code. This is useful to simulate a physical keystroke regardless of which keyboard is currently being used. The virtual key value of a key may alter depending on the current keyboard layout or what other keys were pressed, but the scan code will always be the same.

Your mapping of a pointer as the second argument, while technically correct, requires you to do a lot more overhead with writing it. It is better to simply put the structure type as an argument. Structures are treated as .ByReference when used as function/method arguments, and handle all of the auto-read and write for you. So if you do this, you can omit your write() call:

We effectively set the proc, that was in place when first hooking, as the topmost WndProc. This means, that all WndProcs, that have been added after myWndProc (e.g. all kinds of Overlays), suddenly won't be called anymore. Furthermore all hooks that are added afterwards point to invalid memory with their oldProc.

This means, hooks done that way can't be properly unloaded without messing something up. While this would be fixable if all WndProcs belong to the same (our) codebase, this is not fixable with external code.

But you forget that hwnd is your window, created by your process, so it is under your control. It means you must design your module to properly restore the chain of window procs. There is no "external code" that can set your window proc to something else.

The emphasis is on "your window."

EDIT

Putting back the WndProc pointer will never affect the chain of window procedures. It is just that after putting it back, your procedure will not be called anymore, but the next one is called directly, which is exactly what you want.

You are creating instances of your classes, and then manually calling getPointer() on them to allocate native memory to give to the Win32 API to populate, but you are not read()'ing that native memory back into your class members afterwards, which is why the members remain all zeros after the functions have exited.

Per the getPointer() documentation:

Return a Pointer object to this structure. Note that if you use the structure's pointer as a function argument, you are responsible for calling write() prior to the call and read() after the call. These calls are normally handled automatically by the Function object when it encounters a Structure argument or return value. The returned pointer may not have meaning for Structure.ByValue structure representations.

For example:

I've figured out how to query the registry now, although i'm still not printing values succesfully. There were many different issues with the original code.

To query the registry i first had to use RegOpenKeyEx and then query the values individually with RegEnumValue, finally close the key handle with RegCloseKey.

There was another issue with the RRF_RT_ANY type values, explained more RegOpenKeyEx returning error code 2

I'm not printing the values correctly yet but when running the while loop for RegEnumValue it iterates n times for registry values with n keys so i'm fairly confident that should be working correctly.

In Visual Studio, then change Project-> Properties-> Configuration Properties-> General-> Configuration Type from Application (.exe) to Dynamic Library (.dll)(Don't forget to choose the corresponding platform, your project is x64.)

A solution based on IMessageFilter does the work: