C++ Win32 API Simple GUI Wrapper

How would you like to write your Windows Graphical (Win32 GUI) software as EASY as this?

toc_collapse=0;
Contents 

• Simple C++ Win32 API Wrapper Tutorial
• The Problem
• Window Wrapper
• The Window Class Wrapper
• Your New Simple WinMain

Simple C++ Win32 API Wrapper Tutorial

You should understand C++ class inheritance and polymorphism, that is, abstract classes, virtual functions, pure virtual functions.

You should know that this tutorial assumes you have a thorough understanding of C++ and a basic understanding of Win32 API.

You'll notice the use of the C++ scope resolution operator when calling Win32 API functions such as ::CreateWindowEX () or ::RegisterWindowEx(). That's just a habit of mine when calling these kind of functions, basically it tells C++ to search the functions in the global namespace.

How would you like to write your Win32 programs like this?

Everyone knows that creating a window is not an simple task but a rather tedious one, so I'm going to try and make it easier. This method is very similar to Qt, Java, or WxWidgets.

The Problem

If you ever tried wrapping a window's functionality I bet the first thing you asked yourself was: "What am I going to do with the window procedure?". I also bet this was the first answer that crossed your mind: "I'm just going to declare it as a member function within my window wrapper class and then I'm gonna pass it to the WNDCLASSEX structure as the lpfnWndProc field."
Well, unfortunately that won't work. Why? Because member functions have an additional hidden parameter, the this pointer, so instead of LRESULT CALLBACK wndProc (HWND, UINT, WPARAM, LPARAM) your member function will be LRESULT CALLBACK memberWndProc (YourClassName *this, HWND, UINT, WPARAM, LPARAM).
Obviously you won't be able to do the assignment wcx.lpfnWndProc = memberWndProc because the two function pointers are of different types.

So how do we solve this? We'll use a static member function that will act as a message router. A static member function can be called without creating an instance of the class, therefore it doesn't have the this pointer in its parameter list, allowing us to pass it as the lpfnWndProc member in WNDCLASSEX.

Message router you say? Yes, because the window procedure is going to be a static member function, we can't redefine its behavior in derived classes so we're gonna use a little hack. We're gonna declare another window procedure function that will be implemented in derived clasess and will do the actual message processing particular to each window. The static message router is going to determine which instance's window procedure to call by associating the window's HWND handle with a pointer to the derived class instance. This will be explained later.

Window Wrapper

First we create an abstract window class, let's call it AbstractWindow. Later, we are going to create our own windows by deriving this class and defining some of its member functions.

Notice the pure virtual function wndProc, this is the actual window procedure that will be implemented in derived classes, the static msgRouter function only determines the instance of AbstractWindow to send the message to and calls its wndProc. How?

1. In the AbstractWindow::Create () method, we're gonna pass the this pointer as the last parameter of CreateWindowEx().
2. Then, CreateWindowEx() sends it to msgRouter through a WM_NCCREATE message. (Details: the pointer is stored in the LPARAM parameter as a LPCREATESTRUCT structure, in the lpCreateParams field. Not important)
3. We then handle the WM_NCCREATE message and associate the AbstractWindow pointer with the window's HWND using SetWindowLong ().
4. Then, we retrieve the AbstractWindow pointer using GetWindowLong () and call its wndProc method that will do the actual processing.

So basically that is what will happen for every newly created window. For an existing one, when messages arrive in msgRouter, we'll have the window's handle which we'll use to retrieve the pointer to its AbstractWindow object that contains its window procedure, then we'll forward the message there.

Here's the code:

Now the only thing left is to derive a class from AbstractWindow and define its wndProc method. Before doing that I'm gonna show you how to wrap the WNDCLASSEX structure so you can easily create a Window Class that uses the AbstractWindow::msgRouter as its window procedure.

The Window Class Wrapper

Before creating a window we must first create a Window Class. I'm hoping that by this time you know what I mean by a Window Class. The following C++ class will wrap a Window Class more precisely the WNDCLASSEX structure, the other one above wrapped a window.
There are several ways of doing this, but the only thing each implementation must have in common is setting the lpfnWndProc field of WNDCLASSEX to AbstractWindow::msgRouter, because that's the place we want all the messages for our windows to go.

So let's call this class SimpleWindowClass. Basically, the only input the class' constructor needs is the application's HINSTANCE and the Window Class name.
This would be one way of implementing it:

The class inherits from the WNDCLASSEX structure, has a virtual member function that retrieves the Window Class' name, a Register() member function that calls the RegisterClassEx() Win32 function to register the window class, and a constructor that will fill in the WNDCLASSEX structure.
Here's the implementation:

Great! We've just simplified the Window Class creation from manually filling a WNDCLASSEX structure and calling RegisterClassEx() to declaring a SimpleWindowClass object and calling its Register() member function.
Now let's create a SimpleWindow class that will inherit from AbstractWindow and implement the wndProc member function allowing our window to "work".

4. Create windows by subclassing AbstractWindow

The only thing left to do now is to inherit from AbstractWindow and create our window's behavior by defining the wndProc pure virtual function.
Let's start:

Now we're gonna define the constructor and the window procedure. In this case the constructor is just going to set default values for CreateWindowEx()'s parameters.

By this time we've drastically reduced WinMain's size.

Your New Simple WinMain

In the new WinMain we'll just create a Window Class by creating a SimpleWindowClass object and calling its Register() member function, then we're gonna create a window by creating a SimpleWindow object, and calling its Create() and Show() member functions. Of course we're also going to need a message loop.

That's all there is to it. From now on there are endless possibilities. You can modify your window wrapper or your Window Class wrapper the way you want them to work.
An interesting thing you could do is add message handlers, such as OnCommand (), OnCreate (), OnPaint () and so on. You would need to define their default behavior in the AbstractWindow class and then in the msgRouter you would forward each message to its handler. Then in your derived classes you would only define handlers for the messages you'd like to handle, the rest will be handled by the base class, that is, AbstractWindow. The final result would be an MFC-like window class, with member functions for each message, this way you would get rid of the window procedure for ever.
Let me show you what I mean:

In your derived class instead of defining the old long window procedure you will only define handlers for the messages you'd like to handle, the rest of the messages will either be handled by their default handler implementation in AbstractWindow or by DefWindowProc() in msgRouter.

Enjoy!