As EasilyConfused points out, if you're to have one WndProc for all the windows (and this really is the easiest way), you'll need a way to determine the windows from each other.

I achieve this by having a static map of HWNDs to pointers-to-windows, so my WndProc can iterate through the whole list of HWNDs, find the window it belongs to, and call the appropriate function.

Not at all. If you take your existing WindowManager which maintains a list of Window classes, you can just do:

psuedocode

int WndProc(HWND Hw,MSG M,etc){    for_each(Window W in List)        {        if(W.Hw==Hw) W.OnMessage(M);        }}

Each window has its own message queue, maintained by the OS behind the scenes. However, your program only has one message loop regardless of how many windows there are.

When you call DispatchMessage(), Windows takes care of making sure that the message is sent to the correct WndProc for the window whose message it is.

I think that is what you were asking, anyway.

Quote:Original post by wijnand
allright, well I need to head to my parents,when I am there i will plug in my laptop and try to code what has been suggested although I have tro admit it sounds complicated. So basically all I have to do is keep track of each WNDPROC its memory address in a linked list for example?

So whenever I make a new WNDPROC class i just need to make sure before I register it that its assigned into the linked list so I can loop it through in the Messageloop?

Sorry. Didn't understand a word of that.

What is being suggested is that you could use the same WNDCLASSEX and the same WndProc for all the windows that you create. When you create a window, you thread it into a list of Window classes, as you do at the moment in your WindowManager's list.

You need this list to be statically visible to the WndProc function that you use, either by declaring a static WindowManager or having the WindowManager class use a static list outside of it.

Your WndProc can then go through this list, and compare the HWND first parameter to the HWND's stored for each Window class (again, you are already storing these).

When a match is found, you then know within the WndProc which of the windows the message is intended for and you can act upon it accordingly.

So, for a very simple, incomplete and bad example:



With the above, as a message is dispatched to the WndProc for a given window, the loop in the WndProc identifies which of your Window classes corresponds to the window being sent the message, then calls that Window's specific OnMessage member function, rather than processing the message for all the windows.

Quote:Original post by wijnand
Is it actually possible to make a console before a Windows program runs? I managed to get a messagebox to display but I will have to take look.

Yeah. I think (from memory) you just do

#include <windows.h>int main(int,const char **av){    HINSTANCE HIn=GetModuleHandle(NULL);    // now you have the HINSTANCE and can proceed as if this were a WinMain}

You need to compile as a console application as well, rather than a Windows application, so the linker looks for main instead of WinMain as the entry point and the OS will create a console at start up.

Obviously you'll get a console appearing before any of your windows, but this sounds like what you want in this case. You can get rid of the console later on with FreeConsole() if you want.

[EDIT]

Alternatively, you can just start with a WinMain as usual, but just call:

AllocConsole();

at the start. Sorry. Should have suggested that first. Getting too complicated.