windows-pr | Windows functions , constants and macros

As @JonathanPotter pointed out, when hitting Windows + D or the Show Desktop button, the event WM_WINDOWPOSCHANGING gets fired, and the window gets moved to -32 000, -32 000 (its size also gets changed)

NOTE : a window without the style WS_MINIMIZEBOX seems not receiving WINDOWPOSCHANGING event when hitting Windows + D. Thus, no -32 000 coordinates detection in that case... Also noticed the same issue when using the ex style WS_EX_TOOLWINDOW (as this one gets rid of the minimize box, even if you set the style flag WS_MINIMIZEBOX). Didn't find a solution for that case, so I'm sticking to an overlapped window.

To prevent this movement, just set the flags SWP_NOMOVE and SWP_NOSIZE on the WINDOWPOS structure passed in the lParam

So as a final result, to achieve the wanted behaviour (i.e always behind every other window but always in front of the desktop), the only needed code to add to the doc's sample is the following, placed in the window procedure WindowProc's switch statement :

EDIT : the best place to force the Z order with HWND_BOTTOM thus ensuring the window is always on bottom is also in the WM_WINDOWPOSCHANGING event. Indeed, calling SetWindowPos to force it in the WM_SIZE event when dragging the window over, as I was doing previously, causes some flickering on the window when resizing it, whereas no flickering occurs when setting directly the hwndInsertAfter property of the WINDOWPOS structure in WM_WINDOWPOSCHANGING.

user32.lib is required to link as @dxiv pointed out.

You can try the following command line:

Okay, just this once, I will translate for you but you need to find an on line converter that you like. Many examples are available in C#. Also please take the tour to learn how to ask a proper question.

in the line

The reason you run the program the window opens and collapses immediately is that you did not create a message loop. The message loop is not just the WindowProc function you mentioned. You also need to add a message processing loop function.

According to the MSDN document:

1. wWinMain is the program entry point. When the program starts, it registers some information about the behavior of the application window. One of the most important items is the address of a function, named WindowProc in this example. This function defines the behavior of the window—its appearance, how it interacts with the user, and so forth.

2. Next, the program creates the window and receives a handle that uniquely identifies the window.

3. If the window is created successfully, the program enters a while loop. The program remains in this loop until the user closes the window and exits the application.

Notice that the program does not explicitly call the WindowProc function, even though we said this is where most of the application logic is defined. Windows communicates with your program by passing it a series of messages. The code inside the while loop drives this process. Each time the program calls the DispatchMessage function, it indirectly causes Windows to invoke the WindowProc function, once for each message.

Then you can create a button through CreateWindow as the following code(But you need to set a unique identifier for subsequent operations):

You need to set SubSystem to "Windows (/SUBSYSTEM:WINDOWS)" instead of "Console (/SUBSYSTEM:CONSOLE)".

CONSOLE programs use _main() as their entry point (which does some setup and then calls your main() function)

WINDOWS programs use WinMain or wWinMain as their entry point (depending on whether they are being compile for ANSI or UNICODE respectively).

Your guide had you make a wWinMain function so you need to make sure the compiler settings are set for a WINDOWS subsystem and UNICODE encoding.

Have a look at the instructions here: https://codeyarns.com/2010/12/02/visual-c-windows-and-console-subsystems/

For anyone else who is attempting the same thing, or something similar I got a hint from the Docker Desktop for Windows Community on GitHub that helped me find a solution. In a nutshell the recommendation was to simply change the settings file directly. What I found worked was to:

1. Stop the Docker Services (There are 2 of them)
2. Update the settings file (@ ~\AppData\Roaming\Docker\settings.json)
3. Start the Docker Services
4. Switch the Daemon Context to Linux (Same as it was before, but it appears to need a nudge to pick things up after restarting the services).

Here's the PowerShell:

To instantiate a class via WinRT (the class you made in C++/CX), you need to declare it in your manifest or otherwise Windows will not know which .dll file to look in (and that will result in REGDB_E_CLASSNOTREG HRESULT/ClassNotRegistered exception).

Up until recently, this was only available to UWP applications and they had to declare these dependencies in their AppXManifest.xml file. However, recent Windows versions support declaring these dependencies in Win32 manifest. This is how you do it:

undefined reference to `WinMain'

It tries to find WinMain and failed. So you need use WinMain instead of wWinMain.

Another possible issue is

error: conflicting declaration of C function 'int WinMain(HINSTANCE, HINSTANCE, PWSTR, int)' int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, PWSTR pCmdLine, int nCmdShow) ^~~~~~~ In file included from c:\mingw\include\windows.h:44:0, from test.cpp:5: c:\mingw\include\winbase.h:1263:14: note: previous declaration 'int WinMain(HINSTANCE, HINSTANCE, LPSTR, int)' int APIENTRY WinMain (HINSTANCE, HINSTANCE, LPSTR, int);

So you need use LPSTR instead of PWSTR.

Then the entry point will like this:

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR pCmdLine, int nCmdShow)

Above is ANSI version entry point.