Member functions as child window procedures

Hi all,

In the situation that you create a class to represent a child window, how do you deal with the windows procedure for the child class in an OOP sense?

The difficulty I am having is that I cannot use a member function from this class as the windows procedure. i.e.

Code:

---

class ChildWindow
{
    public:
        ChildWindow();
        LRESULT CALLBACK ChildWndProc(HWND, UINT, WPARAM, LPARAM);
};

---

So how is it done? Friend functions? or wha?

Cheers.

The class should have a static window procedure, which redirects to each window's instance window procedure.

Thanks for the quick reply, I just want to clarify what your saying! It seems to work..

So, you would have a static windows procedure as a member of my window class...

Code:

---

static LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    return ChildWndProc(hwnd, msg, wParam, lParam);
}

---

Which in turn calls another function that was declared at global scope.

Code:

---

LRESULT CALLBACK ChildWndProc(HWND, UINT, WPARAM, LPARAM)
{
    [...]
}

---

No, I meant letting your static member function redirect to each window's instance member function.

I'm not sure what your end-goal is though, so whatever I'm saying here might not apply.

Well, I was just trying to write a class that I could use to create a child window of a main parent window.

This child window has it's own windows procedure.

During the initialisation of the windows class, I was trying to set the windows procedure:

wcx.lpfnWndProc = WndProc;

where WndProc is a member function of the class - but that is not possible. So I guess I am asking, how do you do it?

I guess I am not getting this:

Quote:

---

instance member function.

---

:) What do you mean?

When you say "child" window, are you talking about a child window like a button or an edit control?

Or are you talking a window owned by the owner window, like a dialog box?

>> instance member function.

A class method that is not static.

>> where WndProc is a member function of the class - but that is not possible. So I guess I am asking, how do you do it?

Just use a static member function then. No need for it to call a global function.

Quote:

---

When you say "child" window, are you talking about a child window like a button or an edit control?

---

Not quite, it is another client area that sites on the surface. Think of how MS Paint splits the windows into different segments, or child windows. Each with its own message procedure. (See attached image - each side is it's own window - I was going to have buttons on the left client area, and render graphics to the right client area).

Quote:

---

>> where WndProc is a member function of the class - but that is not possible. So I guess I am asking, how do you do it?

Just use a static member function then. No need for it to call a global function.

---

Code:

---

LRESULT CALLBACK CChildWindow::MyProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
        switch(msg)
        {
        case WM_DESTROY:
                PostQuitMessage(0);
                return 0;
        }
        return DefWindowProc(hwnd, msg, wParam, lParam);
}

---

Well, this compiles - I am not sure why I didn't try this earlier. MyProc is declared as a static member function.. This would be the correct way to do this?

Thanks for all your help again. :)

Quote:

---

MyProc is declared as a static member function.. This would be the correct way to do this?

---

Yes. WNDPROC needs the address of the procedure to be a global or static one.

Sweet, thank you very much for your help / patience. ;)

So - just another question.

All member functions or objects within the class that are to be used within the static windows procedure would also have to be static?

I mean the answer is obvious, they would have to be. But is the best way to do it? How do other programmers out there do it? Would they instead use a global windows procedure for their child windows that wraps a method within the class?

Cheers,

FB

That's one way. A more common approach is to pass this as the last parameter of CreateWindowEx and set/retrieve it within the static wndproc and use it to forward messages to a non-static 'window procedure' member function.

Here's an offsite description but ignore the last couple of sentences because they're incorrect (GWL_USERDATA is available for dialog use; DWL_USER is just an 'extra' for dialogs).

This topic has been discussed quite a lot here in the past and a review of some of those discussions may also be of some interest to you (I haven't checked them all for relevance):

http://cboard.cprogramming.com/showt...ghlight=static
http://cboard.cprogramming.com/showt...ghlight=static
http://cboard.cprogramming.com/showt...ghlight=static
http://cboard.cprogramming.com/showt...ghlight=static
thread contains very simple example
http://cboard.cprogramming.com/showt...ghlight=static
http://cboard.cprogramming.com/showt...ghlight=static
http://cboard.cprogramming.com/showt...ghlight=static
http://cboard.cprogramming.com/showt...ghlight=static
http://cboard.cprogramming.com/showt...ghlight=static

Thanks for the links.. look, i've been through this a hundred times and I just can't see what i am doing wrong.

I create the window...

Code:

---

hwnd = CreateWindowEx(0,
                              TEXT("ChildClass"),
                              TEXT(""),
                              WS_CHILDWINDOW | WS_VISIBLE,
                              0, 0,
                              100, 100,
                              hParent,
                              NULL,
                              hInstance,
                              this);

---

And then I try to get the data.. in the WM_CREATE message, WM_NCCREATE, prior to processing any messages. It doesn't matter how I go about it I just can't get the pointer to the class! Any ideas?

Code:

---

        CChild *child = 0;
        child = (CChild *)GetWindowLong(hwnd, GWL_USERDATA);

---

Looking under the debugger, child is not set - I have tried everything but I can't get the value back. Any ideas...

>>CChild *child = 0;

For a start, you are going to want to make this static or global. Otherwise the variable will fall out of scope as soon as another message is processed

Yes true, but it doesn't make a difference in this case since I have also tried setting the value of child and then using it immediately after while the variable is still in scope...

I just can't wrap my head around this. Is there some kind of trick to doing this? Can you obtain the pointer while processing any message and using GetWindowLong?

Quote:

---

Originally posted by filler_bunny
Thanks for the links.. look, i've been through this a hundred times and I just can't see what i am doing wrong.

---

That's easy - you're not reading up on the information provided to you :p Those links I suggested, in particular the 'offsite description' and the 'simple example', should have given you more than enough information to both recognise and solve your latest problem. :)

Still, it may be that you just can't see the wood for the trees just now so...

1. Passing this as CreateWindowEx just makes this available - it doesn't magically associate it with the window. You have to do that yourself.

2. If the result of GetWindowLongPtr is NULL then you need to use SetWindowLongPtr to associate this with your window. This is typically done in WM_NCCREATE (or WM_INITDIALOG for a dialog)as it's the first place you have access to this through the CREATESTRUCT passed as the LPARAM to your (static) window procedure.

3. If GetWindowLongPtr returns a non-NULL value you can cast it to your c++ class pointer and use that pointer accordingly.

ie

Code:

---

CChild *child = (CChild *)GetWindowLongPtr(hwnd, GWL_USERDATA);
if (!child)
  {
  /*need to attach 'this' to window*/
  /*assuming WM_NCCREATE msg:*/
  CREATESTRUCT *cs=(CREATESTRUCT*)lParam;
  child=(CChild*)cs->lpCreateParams;
  /* next step is the one you're missing*/
  SetWindowLongPtr(hwnd, GWL_USERDATA, (LONG_PTR) child);
  }
else
  {
  /* ptr's good so do stuff normally */
  }

---

I'm so embarrased. I must have read those links a hundred times and not understood it.. It has now fallen into place.

Thanks so much. I can go on living now! :)

Thanks for the patience and time. You have no idea how much I appreciate it! ;)

FB

Hi, I've been trying to figure this out as well, in the book I've got you have to use windowclass.cbWndExtra in the windowclass to store a pointer, also (as you guys said), you have to use a this pointer as well. Is the bit about storing a pointer in windowclass.cbWndExtra right?

Actually I'll keep this short by just asking about the bit I most don't understand :) , I'll read up about the other links as well.

[code]

//declare your window
CMYWINDOW myWindow;

myWindow.create("Title");//create
myWindow.show();//show


LRESULT CALLBACK//included in the class as a freind
WindowProc(HWND myWindow,UINT message,
WPARAM wparam,LPARAM lparam)
{
if (message== WM_CREATE)
{
CREATESTRUCT* createstruct;//this is a pointer to a
//CREATESTRUCT type.

//what does this mean? :(
createstruct = (CREATESTRUCT*)lparam;

SetWindowLong (myWindow, 0, (LONG) (createstruct->
lpcreateparams)) ;
return 0;

CMYWINDOW* object = (CMYWINDOW)GetWindowLong
(myWindow,0);

if (object)//I think the rest is just the normal message processing.
{
if (message == WM_DESTROY)
return object-> Destroy(myWindow,message,wparam,lparam);
//Destroy is the destroy method from the class
//...

return DefWindowProc(... )
}
[code]

Thanks anyone.

Quote:

---

Originally posted by Stevo
Is the bit about storing a pointer in windowclass.cbWndExtra right?

---

No. That's just for specifying extra bytes you want to store with windows of that registered class. Use SetWindowLongPtr/GetWindowLongPtr to set and get those extra bytes; GWL_USERDATA is 'free' in this regard ie you don't have to do anything extra to use it.

Take a look at the relevant descriptions on msdn for clarification:
WNDCLASSEX
GetWindowLongPtr
SetWindowLongPtr

Quote:

---

Originally posted by Stevo
//what does this mean?
createstruct = (CREATESTRUCT*)lparam;

---

That's type-casting - casting, in this case, the value of lParam to a CREATESTRUCT pointer so you can use it and access the members of the CREATESTRUCT struct.

Thanks Ken, I'll look up the answers you already gave to filter as well.
Thanks

You ain't cool, less'n you is thunk'n!

gg

Well, thankee kindly. :D

That's a very interesting read but the technique seems to carry its own subset of problems.

True.
It's compiler and architecture dependant. I use this technique on ARM, SH3, MIPS, and x86 processors (and so does ATL).

All the architecture #define's come from the project/makefile. Shouldn't be too hard to port the code in that article using g++ compiler directives.

If you own VisualStudio and have ATL installed, take a look at your ...\ATL\Include\atlwin.h header file to see how Microsoft does it :)

gg

Quote:

---

Originally posted by Codeplug
Shouldn't be too hard to port the code in that article using g++ compiler directives.

---

If anyone sends me such I'll add it to the article as an appendix, giving due credit of course.

>>Shouldn't be too hard to port the code in that article using g++ compiler directives. <<

Haha! Famous last words. ;)

>>If you own VisualStudio and have ATL installed, take a look at your ...\ATL\Include\atlwin.h header file to see how Microsoft does it<<

Ok.

Thanks again. :)

Quote:

---

You ain't cool, less'n you is thunk'n!

---

That article just simply blew my mind.

Quote:

---

Originally posted by Dante Shamest
That article just simply blew my mind.

---

Gosh, thanks (assuming you meant it in a good way).

I was bored.....

Code:

---

/*---------------------------------------------------------------------------*/

#if defined (_MSC_VER) // VC++ compiler
  #if !defined (_M_IX86) // x86 architecture
    #error Only X86 supported
  #endif
#elif defined (__GNUC__) // GNU compiler
  #if !defined (_X86_)  // x86 architecture
    #error Only X86 supported
  #endif
#endif

/*---------------------------------------------------------------------------*/

#if defined (_MSC_VER) // VC++ compiler
    #pragma warning(push)
    #pragma warning(disable:4355) //'this' used in base member initializer list
    #pragma pack(push,1)
#endif

/*---------------------------------------------------------------------------*/

class WndProcThunk
{
    const DWORD m_mov;    // mov ecx, pThis
    const DWORD m_this;    // pThis
    const BYTE  m_jmp;    // jmp WndProc
    const DWORD m_relproc; // relative jmp
   
    WndProcThunk(); // private default constructor (no implementation)

public:
    explicit WndProcThunk(WNDPROC proc, void *pThis) :
        m_mov(0x042444C7),
        m_this((DWORD)pThis),
        m_jmp(0xE9),
        m_relproc((int)proc - ((int)this + sizeof(WndProcThunk)))
    {
        ::FlushInstructionCache(GetCurrentProcess(), this,
                                sizeof(WndProcThunk));
    }//constructor
}//<-- no semicolon yet...

/*---------------------------------------------------------------------------*/

#if defined (__GNUC__) // GNU compiler
  __attribute__ ((packed))
#endif

; //<-- semicolon to close WndProcThunk

#if defined (_MSC_VER) // VC++ compiler
    #pragma warning(pop)
    #pragma pack(pop)
#endif

/*---------------------------------------------------------------------------*/

---

I've attached full source that compiles and runs under both MinGW and VC++ 6.0

gg

Quote:

---

Originally posted by Codeplug
I was bored.....

---

Cool. You mind if I append it to the article on HackCraft?
If so how you you like to be referred to as, "Codeplug?" or another name, or what?

Codeplug on Cprogramming.com (or something like that) is fine :)

Feel free to use your original "winThunk" implementation as well.

gg