My Window Class

Hey all,

I wrote a sort of wrapper class for creating a skeleton window. I'll post the code first, and then discuss it:

Main.cpp

Code:

---

#define WIN32_LEAN_AND_MEAN

#include <Windows.h>
#include "cWindow.h"

//PROTOTYPE FOR OUR MISC. MESSAGE HANDLING FUNCTION
long __stdcall MessageProc(HWND hWnd, unsigned int Msg, WPARAM wParam, LPARAM lParam);

//OUR MAIN ENTRY POINT
int __stdcall WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
        MSG Msg;        //RECEIVES OUR MESSAGES
        bool bRunning;        //KEEPS TRACK OF WHETHER WE'RE STILL RUNNING OR NOT

        cWindow* MainWindow;                //OUR WINDOW OBJECT
        MainWindow = new cWindow;        //CREATE THE WINDOW OBJECT

        //INITIALIZE OUR WINDOW
        bRunning = MainWindow->Init((HBRUSH)GetStockObject(LTGRAY_BRUSH), &hInstance, &MessageProc, CS_OWNDC, WS_POPUP, 200, 300);

        if(bRunning == true) //IF WE SUCCEEDED
        {
                //ACTIVATE THE WINDOW
                MainWindow->FocusOnMe();
                MainWindow->ShowMe();
                MainWindow->UpdateMe();

                while(bRunning == true) //MAKE SURE WE'RE STILL RUNNING
                {
                        if(PeekMessage(&Msg, NULL, 0, 0, PM_REMOVE) != 0) //DO WE HAVE ANY MESSAGES WAITING
                        {
                                //CHECK WHAT THE MESSAGE IS
                                //
                                //IT IS EASIER TO MANIPULATE OUR VARIABLES (bRunning, MainWindow, etc.)
                                //BY KEEPING THE MESSAGE HANDLER OUT HERE
                                switch(Msg.message)
                                {
                                case WM_KEYDOWN:                //A KEY WAS PRESSED
                                        bRunning = false;        //EXIT
                                default:
                                        TranslateMessage(&Msg);        //CONVERT OUR VIRTUAL-KEY MESSAGE INTO A CHARACTER MESSAGE
                                        DispatchMessage(&Msg);        //SEND THE MESSAGE TO OUR MISC. MESSAGE HANDLER
                                }
                        }
                        else
                        {
                                //THERE WAS NO MESSAGE
                                //
                                //UPDATE THE WINDOW
                                MainWindow->UpdateMe();
                        }
                }
        }

        //DESTROY OUR WINDOW
        bRunning = MainWindow->Kill(&hInstance);

        //CLEAN UP THE OBJECT
        delete MainWindow;
        MainWindow = NULL;

        return 0;
}

//long __stdcall MessageProc()
//
//THIS FUNCTION HANDLES ANY MESSAGES PASSED TO IT BY DispatchMessage()
//THAT WERE NOT HANDLED IN OUR WinMain() FUNCTION
long __stdcall MessageProc(HWND hWnd, unsigned int Msg, WPARAM wParam, LPARAM lParam)
{
        switch(Msg) //CHECK WHAT THE MESSAGE IS
        {
        case WM_CLOSE: //CLOSE THE WINDOW
                PostQuitMessage(0); //LET THE PROGRAM KNOW WE'RE QUITTING
                return 0;
        case WM_DESTROY: //DESTROY THE WINDOW
                PostQuitMessage(0); //LET THE PROGRAM KNOW WE'RE QUITTING
                return 0;
        }
        return(DefWindowProc(hWnd, Msg, wParam, lParam));
}

---

cWindow.h

Code:

---

#ifndef CWINDOW_H
#define CWINDOW_H

#include <Windows.h>
#include <String.h>

class cWindow
{
public:
        cWindow();
        virtual ~cWindow();

        //INITIALIZES OUR WINDOW
        bool Init(HBRUSH Colour, HINSTANCE *hInstance, long (__stdcall *MP)(HWND hWnd, unsigned int Msg, WPARAM wParam, LPARAM lParam),
                unsigned int ClassStyles, unsigned long WindowStyles, unsigned int Width, unsigned int Height);
        //DESTROYS OUR WINDOW
        bool Kill(HINSTANCE *hInstance);
       
        //SETS THE FOCUS ONTO OUR WINDOW
        void FocusOnMe(void);
        //SHOWS THE WINDOW
        void ShowMe(void);
        //UPDATES THE WINDOW
        void UpdateMe(void);
       
private:
        HWND hWnd;                //THE HANDLE TO OUR WINDOW
        char ClassName[10];        //THE NAME OF OUR CLASS
};

#endif

---

cWindow.cpp

Code:

---

#include "cWindow.h"       

//cWindow::cWindow() (a.k.a. Constructor)
//
//PARAMETERS: None
//RETURNS: None
//
//DESCRIPTION:
//This function just makes sure our handle starts off as NULL and sets a name for our class
cWindow::cWindow()
{
        hWnd = NULL;
        strcpy(ClassName, "MyClass");
}

//cWindow::~cWindow() (a.k.a. Destructor)
//
//PARAMETERS: None
//RETURNS: None
//
//DESCRIPTION:
//This function does nothing because it assumes the programmer has already called the cWindow::Kill() function
//to clean everything up.
cWindow::~cWindow()
{}

//bool cWindow::Init()
//
//PARAMETERS:
//The colour for our background
//A pointer to the HINSTANCE generated by our WinMain() function
//A pointer to the misc. message handling function
//The styles for the class
//The sytles for the window
//The width of the window
//The height of the window
//RETURNS:
//Whether or not the window is created with success
//
//DESCRIPTION:
//This function is a wrapper for creating a window in the centre of the screen.
bool cWindow::Init(HBRUSH Colour, HINSTANCE *hInstance, long (__stdcall *MP)(HWND hWnd, unsigned int Msg, WPARAM wParam, LPARAM lParam),
                unsigned int ClassStyles, unsigned long WindowStyles, unsigned int Width, unsigned int Height)
{
        WNDCLASS WCL;                        //OUR CLASS OBJECT
        unsigned short Registration; //KEEPS TRACK OF THE SUCCESS OF THE RegisterClass() FUNCTION

        //INITIALIZE OUR WINDOW CLASS
        WCL.cbClsExtra                = 0;                                                        //SET ASIDE 0 EXTRA BYTES FOR THE CLASS
        WCL.cbWndExtra                = 0;                                                        //SET ASIDE 0 EXTRA BYTES FOR THE WINDOW
        WCL.hbrBackground        = Colour;                                                //APPLY OUR COLOUR
        WCL.hCursor                = LoadCursor(NULL, IDC_ARROW);                                //MAKE OUR CURSOR THE STANDARD ARROW
        WCL.hIcon                = LoadIcon(NULL, IDI_APPLICATION);                        //CHOOSE THE STANDARD APPLICATION ICON
        WCL.hInstance                = *hInstance;                                                //PASS THE HINSTANCE FROM WinMain()
        WCL.lpfnWndProc                = *MP;                                                        //PASS OUR MISC. MESSAGE HANDLER
        WCL.lpszClassName        = ClassName;                                                //THE NAME OF OUR CLASS
        WCL.lpszMenuName        = NULL;                                                        //NO DEFAULT MENU
        WCL.style                = ClassStyles;                                                //APPLY OUR CLASS STYLES

        Registration = RegisterClass(&WCL);        //ATTEMPT TO REGISTER THE CLASS
        if(Registration == false)
                return false;

        //CREATE OUR WINDOW
        hWnd = CreateWindow(
                ClassName,                                                //OUR CLASS NAME
                "Game",                                                        //THE TITLE FOR OUR WINDOW
                WindowStyles,                                                //APPLY OUR STYLES
                (GetSystemMetrics(SM_CXSCREEN) / 2) - (Width / 2),        //PLACE IN THE HORIZONTAL CENTRE
                (GetSystemMetrics(SM_CYSCREEN) / 2) - (Height / 2),        //PLACE IN THE VERTICAL CENTRE
                Width,                                                        //WIDTH OF THE WINDOW
                Height,                                                        //HEIGHT OF THE WINDOW
                NULL,
                NULL,
                *hInstance,                                                //OUR HINSTANCE
                NULL);

        if(hWnd == NULL) //CHECK IF OUR hWnd WAS INITIALIZED
                return false;

        return true; //SUCCESS
}

//bool cWindow::KILL()
//
//PARAMETERS:
//A pointer to the HINSTANCE from WinMain()
//RETURNS:
//Whether or not everything was removed
//
//DESCRIPTION:
//This function cleans up our window variables
bool cWindow::Kill(HINSTANCE *hInstance)
{
        MSG Msg;          //CYCLES THROUGH OUR MESSAGES
        int Destroyed;        //KEEPS TRACK OF SUCCESS FOR DestroyWindow()
        int Unregistered; //KEEPS TRACK OF SUCCESS FOR UnregisterClass()

        if(hWnd != NULL) //MAKE SURE THERE'S SOMETHING TO REMOVE
        {
                Destroyed = DestroyWindow(hWnd); //DESTROY THE WINDOW
                if(Destroyed != false)
                {
                        //REMOVE ALL MESSAGES
                        while(PeekMessage(&Msg, NULL, 0, 0, PM_REMOVE));
                        {
                                DispatchMessage(&Msg);
                        }
                }
                hWnd = NULL; //CLEAR THE HANDLE TO OUR WINDOW
        }

        //UNREGISTER OUR CLASS
        Unregistered = UnregisterClass(ClassName, *hInstance);

        if((Destroyed == false)||(Unregistered == false)) //IF EITHER FAILED...
                return false; //...RETURN FAILURE

        return true; //RETURN SUCCESS
}

//void cWindow::FocusOnMe()
//
//PARAMETERS: None
//RETURNS: None
//
//DESCRIPTION:
//Sets the focus to our window
void cWindow::FocusOnMe(void)
{
        SetFocus(hWnd);
}

//void cWindow::ShowMe()
//
//PARAMETERS: None
//RETURNS: None
//
//DESCRIPTION:
//Show our window
void cWindow::ShowMe(void)
{
        ShowWindow(hWnd, SW_SHOW);
}

//void cWindow::UpdateMe()
//
//PARAMETERS: None
//RETURNS: None
//
//DESCRIPTION:
//Redraws our window
void cWindow::UpdateMe(void)
{
        UpdateWindow(hWnd);
}

---

The problem with trying to make a class for a window (as far as I know) is getting that default message handling function assigned. It can't be a member function of the class since it must be statically declared (this is going on what I heard a couple of years back when I was trying this, so it may sound like I'm talking out of my...especially if you know the real terminology).

Now, the way I usually do the message loop in my programs is like what you see in my WinMain() function. So, all in all, I find the MessageProc() very useless. But, when creating a window, you DO need a MessageProc() function to handle messages (as far as I know). The reason I wrote it like that is so I can manipulate/make calls to my objects (I.e. MainWindow->UpdateMe) or something when necessary, say on a keypress. Hope you get the idea. However, with a bit of tinkering, I'm sure anyone who's written a skeleton window like this will be able to adjust the MessageProc() to handle ALL messages, if that's what they desire.

Note that the MessageProc() is defined in Main.cpp, and the Class uses the prototpye as one of its parameters. I think this is an okay mix, and wouldn't really have any issues if somebody tried to re-write the program from scratch, using the class, since there is only one way (as far as I know) to declare the default MessageProc() and its parameters.

The three "files" above will compile and run as an example of how the class is used.

Feel free to try it out, but more importantly, I'm hoping for some feedback. Are there any aspects that you think can be improved/written better? Any issues? Or just any comments?

Thanks for the read.

You could try passing a function pointer that points at the desired message handling function for the dialog in the constructor for this class. That way, each dialog can have its own procedure, etc, easily.

Perhaps I misunderstood, but I think what you suggested is happening in my cWindow::Init() function already...

I like to keep things out of the constructor other than simple init stuff (no gobs of code). Right now, my cWindow::Init() function takes a pointer to a message handling function of the form:
long (__stdcall *MP)(HWND hWnd, unsigned int Msg, WPARAM wParam, LPARAM lParam)

The problem is that any message handling function you wish to use must be declared in Main.cpp. You can't use a member function of the class (I.e. cWindow::MessageProc()) for the WCL.lpfnWndProc variable (it has something to do with not being static? Again, I was told this about 3 years ago so my terminology may be off). Either way, it's next to impossible (I remember hearing of people who pulled it off, but it seemed too crazy for me at the time) to use a class's member function for the default message handler.

Right now, the message handling procedure is declared in Main.cpp and passed into the class through the cWindow::Init() function. Sorry, I got side-tracked a little bit in there. But is this what you meant?