Creating a function pointer from a button click event?

I'm trying to do something similar to this in C++:

Code:

---

void ClickMe()
{
// do work here
}

btn.Init(wnd, "Click Me", 10, 10);
btn.OnClick(ClickMe); 
btn.Show();

---

Although the button object works fine, having something similar to OnClick() would be ideal for what I'm doing. Even if it's not possible, is there anything that might be similar?

There is SetWindowLong() but I'm not trying to throw the whole window procedure in a ClickMe() function. All I'm interested in is the click event.

Thanks.

I'm not sure I get your question? The above example works, so...

Well, this is pure Win32 API but just abstracted out. I would like to click a button and have it send a click event through a function pointer. My ideal way of doing it would be my own OnClick() method that obtains the address of the function I want it to go to.

So you want to use a function pointer so that when the window proc receives the message, it will automatically call your MyClick function?

If that's the easiest way to do it. It's like SetTimer() where it has its own function pointer arguement that is apart from the window procedure itself. You don't have to make a WM_TIMER code block within the window procedure. You can set the function apart from it, and every time the timer is called, the function you specified is called automatically. I'd like that for my mouse class using an OnClick method, if possible.

How about this...

Code:

---

typedef LRESULT (MessageCallbackPtr)(WPARAM, LPARAM);
std::map<int, MessageCallbackPtr*> mCallback;
LRESULT WindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
        // ...
        iterator iFunction;
        iFunction = mCallback.find(message);
        if ( iFunction != mCallback.end() )
                return iFunction->second(wParam, lParam);
        // ...
}

---

You can simply add a message to the map and then the function to which the message shall be redirected:

Code:

---

LRESULT MyClickHandler(WPARAM wParam, LPARAM lParam) { }
int main()
{
        // ...
        mCallback[WM_CLICK] = &MyClickHandler;
        // ...
}

---

Thanks, this will get me started. Is WindowProc the button's own window procedure, or the parent window? I don't know how to modify a window procedure of a predefined "button" class. And, WM_CLICK isn't being recognized. I'll just assume you mean WM_LBUTTONDOWN.

And, where // ... is, is that the normal switch and WM_COMMAND message?

I'm getting this too for...
btn.m_callBack[WM_LBUTTONDOWN] = &MyClickHandler;

error C2440: '=' : cannot convert from 'LRESULT (__cdecl *)(WPARAM,LPARAM)' to 'std::map<_Kty,_Ty>::mapped_type

I think every window has its own procedure? It's been a long time since I did pure Win32 programming. It might present additional problems if your button shares the same procedure as the parent window. I might be able to devise a solution to that using classes, though.

Quote:

---

Originally Posted by dxfoo

Thanks, this will get me started. Is WindowProc the button's own window procedure, or the parent window? And, WM_CLICK isn't being recognized. I'll just assume you mean WM_LBUTTONDOWN.

---

Yeah, whatever the message is. It's been long since I bothered with pure Win32.

Here's an updated code where you can mix several windows into one procedure.
The //... means whatever other code you need to put there.

Code:

---

typedef LRESULT (MessageCallbackPtr)(WPARAM, LPARAM);
typedef std::map<int, MessageCallbackPtr*> CallbackWindowMap;
typedef std::map<HWND, CallbackWindowMap> CallbackMap;
CallbackMap mCallback;
LRESULT WindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
        // ...
        CallbackMap::iterator iWindow;
        iWindow = mCallback.find(hwnd);
        if ( iWindow != mCallback.end() )
        {
                CallbackWindowMap::iterator iFunction;
                iFunction = iWindow->second.find(message);
                if ( iFunction != iWindow->second.end() )
                        return iFunction->second(wParam, lParam);
        }
        // ...
        return 0;
}

LRESULT MyClickHandler(WPARAM wParam, LPARAM lParam) { return 0; }
void Help()
{
        // ...
        mCallback[/*My window*/0x0][WM_LBUTTONDOWN] = &MyClickHandler;
        // ...
        //WindowProc(0x0, WM_LBUTTONDOWN, 0, 0);
}

---

Would it be too much of a pain to write a working example? Code for a blank window can be found here for starters: http://winprog.org/tutorial/simple_window.html

I'm just getting errors left and right. I'll keep playing around with it though.

Edit: I didn't see the updated code before posting this. I'll try it out.

I can't seem to get it working.

You need to post the code. I'm not psychic! :)

You're not? :)

I did a seperate project that has a blank window and a button.

Code:

---

#include <windows.h>
#include <map>
#include <iostream>
#include <string>

typedef LRESULT (MessageCallbackPtr)(WPARAM, LPARAM);
std::map<int, MessageCallbackPtr*> mCallback;

const char g_szClassName[] = "myWindowClass";

LRESULT MyClickHandler(WPARAM wParam, LPARAM lParam)
{
        MessageBox(NULL, "Got it", "Click!", MB_OK);
}


// Step 4: the Window Procedure
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch(msg)
    {
        case WM_CLOSE:
            DestroyWindow(hwnd);
        break;
        case WM_DESTROY:
            PostQuitMessage(0);
        break;

                case WM_COMMAND:
                {
                        std::iterator<int, MessageCallbackPtr *> iFunction;
                        iFunction = mCallback.find(msg);
                        if ( iFunction != mCallback.end() )
                                return iFunction->second(wParam, lParam);
                }
                break;

        default:
            return DefWindowProc(hwnd, msg, wParam, lParam);
    }
    return 0;
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
    LPSTR lpCmdLine, int nCmdShow)
{
    WNDCLASSEX wc;
    HWND hwnd, hWndButton;
    MSG Msg;

    //Step 1: Registering the Window Class
    wc.cbSize        = sizeof(WNDCLASSEX);
    wc.style        = 0;
    wc.lpfnWndProc  = WndProc;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;
    wc.hInstance    = hInstance;
    wc.hIcon        = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor      = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
    wc.lpszMenuName  = NULL;
    wc.lpszClassName = g_szClassName;
    wc.hIconSm      = LoadIcon(NULL, IDI_APPLICATION);

    if(!RegisterClassEx(&wc)) {
        return 0;
    }

    // Step 2: Creating the Window
    hwnd = CreateWindowEx(WS_EX_CLIENTEDGE, g_szClassName,
        "Win32 Practice",WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT, 800, 600,
        NULL, NULL, hInstance, NULL);
    if(hwnd == NULL) {
        return 0;
    }

        hWndButton = CreateWindowEx(NULL, "button", "Click Me",
                WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 50, 50, 100, 24, hwnd,
                (HMENU)(100), hInstance, NULL);
        if (hWndButton == NULL)
                return false;

        mCallback[WM_LBUTTONDOWN] = &MyClickHandler;

    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);

    // Step 3: The Message Loop
    while(GetMessage(&Msg, NULL, 0, 0) > 0)
    {
        TranslateMessage(&Msg);
        DispatchMessage(&Msg);
    }
    return (int) Msg.wParam;
}

---

Errors:

Code:

---

Compiling...
winmain.cpp
c:\Documents and Settings\Phil\My Documents\Visual Studio Projects\Win32 Practice\winmain.cpp(32) : error C2679: binary '=' : no operator found which takes a right-hand operand of type 'std::_Tree<_Traits>::iterator' (or there is no acceptable conversion)
        with
        [
            _Traits=std::_Tmap_traits<int,__w64 long (__cdecl *),std::less<int>,std::allocator<std::pair<const int,__w64 long (__cdecl *)>>,false>
        ]
c:\Documents and Settings\Phil\My Documents\Visual Studio Projects\Win32 Practice\winmain.cpp(33) : error C2678: binary '!=' : no operator found which takes a left-hand operand of type 'std::iterator<_Category,_Ty>' (or there is no acceptable conversion)
        with
        [
            _Category=int,
            _Ty=MessageCallbackPtr (__cdecl *)
        ]
c:\Documents and Settings\Phil\My Documents\Visual Studio Projects\Win32 Practice\winmain.cpp(34) : error C2819: type 'std::iterator<_Category,_Ty>' does not have an overloaded member 'operator ->'
        with
        [
            _Category=int,
            _Ty=MessageCallbackPtr (__cdecl *)
        ]
        did you intend to use '.' instead?
c:\Documents and Settings\Phil\My Documents\Visual Studio Projects\Win32 Practice\winmain.cpp(34) : error C2227: left of '->second' must point to class/struct/union
        type is 'std::iterator<_Category,_Ty>'
        with
        [
            _Category=int,
            _Ty=MessageCallbackPtr (__cdecl *)
        ]
        did you intend to use '.' instead?

Build log was saved at "file://c:\Documents and Settings\Phil\My Documents\Visual Studio Projects\Win32 Practice\Debug\BuildLog.htm"
Win32 Practice - 4 error(s), 0 warning(s)

---

Code:

---

LRESULT MyClickHandler(WPARAM wParam, LPARAM lParam)
{
        MessageBox(NULL, "Got it", "Click!", MB_OK);
        return 0; // All functions must return a value!
}

---

Code:

---

std::iterator<int, MessageCallbackPtr *> iFunction;

---

Oops. You did it wrong. It should be:

Code:

---

std::map<int, MessageCallbackPtr *>::iterator iFunction;

---

I also note you didn't use my second sample.

Simple code first :) Let me try this out...

Okay, here's the code, but the application doesn't recognize the button click. I'll try some debugging. Right now, MyClickHandler isn't being called correctly. Oh, and "if ( iFunction != mCallback.end() )" is skipping the next line.

Code:

---

#include <windows.h>
#include <iostream>
#include <string>
#include <map>

typedef LRESULT (MessageCallbackPtr)(WPARAM, LPARAM);
std::map<int, MessageCallbackPtr*> mCallback;

const char g_szClassName[] = "myWindowClass";

LRESULT MyClickHandler(WPARAM wParam, LPARAM lParam)
{
        MessageBox(NULL, "Got it", "Click!", MB_OK);
        return 0;
}


// Step 4: the Window Procedure
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch(msg)
    {
        case WM_CLOSE:
            DestroyWindow(hwnd);
        break;
        case WM_DESTROY:
            PostQuitMessage(0);
        break;

                case WM_COMMAND:
                {
                        std::map<int, MessageCallbackPtr *>::iterator iFunction;
                        iFunction = mCallback.find(msg);
                        if ( iFunction != mCallback.end() )
                                return iFunction->second(wParam, lParam);
                }
                break;

        default:
            return DefWindowProc(hwnd, msg, wParam, lParam);
    }
    return 0;
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
    LPSTR lpCmdLine, int nCmdShow)
{
    WNDCLASSEX wc;
    HWND hwnd, hWndButton;
    MSG Msg;

    //Step 1: Registering the Window Class
    wc.cbSize        = sizeof(WNDCLASSEX);
    wc.style        = 0;
    wc.lpfnWndProc  = WndProc;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;
    wc.hInstance    = hInstance;
    wc.hIcon        = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor      = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
    wc.lpszMenuName  = NULL;
    wc.lpszClassName = g_szClassName;
    wc.hIconSm      = LoadIcon(NULL, IDI_APPLICATION);

    if(!RegisterClassEx(&wc)) {
        return 0;
    }

    // Step 2: Creating the Window
    hwnd = CreateWindowEx(WS_EX_CLIENTEDGE, g_szClassName,
        "Win32 Practice",WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT, 800, 600,
        NULL, NULL, hInstance, NULL);
    if(hwnd == NULL) {
        return 0;
    }

        hWndButton = CreateWindowEx(NULL, "button", "Click Me",
                WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 50, 50, 100, 24, hwnd,
                (HMENU)(100), hInstance, NULL);
        if (hWndButton == NULL)
                return false;

        mCallback[WM_LBUTTONDOWN] = &MyClickHandler;

    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);

    // Step 3: The Message Loop
    while(GetMessage(&Msg, NULL, 0, 0) > 0)
    {
        TranslateMessage(&Msg);
        DispatchMessage(&Msg);
    }
    return (int) Msg.wParam;
}

---

Well, I don't know (remember) what message is sent.
So take a look at your window proc when a button is pressed and note the message. The message is what you need to use in the callback map.

Whatever it is, it's 273! Thanks! You're brilliant even when you're away from Win32 these days haha...

Edit: I looked into 273, it ended up being 0x111, otherwise, WM_COMMAND. So, I gotta do this...

mCallback[WM_COMMAND] = &MyClickHandler;

WM_COMMAND isn't really clear as of what I'm specifying. But still, it works, but it would be nice to be more specific if possible. It only accepts left button clicks, though, so I guess this is a good thing :) Anyway, thanks for the help tonight.

Here's a better suggestion:

Code:

---

#include <windows.h>
#include <iostream>
#include <string>
#include <map>

typedef LRESULT (MessageCallbackPtr)(WPARAM, LPARAM);
std::map<int, MessageCallbackPtr*> mCallback;

const char g_szClassName[] = "myWindowClass";

LRESULT MyClickHandler(WPARAM wParam, LPARAM lParam)
{
        MessageBox(NULL, "Got it", "Click!", MB_OK);
        return 0;
}


// Step 4: the Window Procedure
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch(msg)
    {
        case WM_CLOSE:
            DestroyWindow(hwnd);
        break;
        case WM_DESTROY:
            PostQuitMessage(0);
        break;

                case WM_COMMAND:
                {
                        std::map<int, MessageCallbackPtr *>::iterator iFunction;
                        iFunction = mCallback.find( LOWORD(wParam) );
                        if ( iFunction != mCallback.end() )
                                return iFunction->second(wParam, lParam);
                }
                break;

        default:
            return DefWindowProc(hwnd, msg, wParam, lParam);
    }
    return 0;
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
    LPSTR lpCmdLine, int nCmdShow)
{
    WNDCLASSEX wc;
    HWND hwnd, hWndButton;
    MSG Msg;

    //Step 1: Registering the Window Class
    wc.cbSize        = sizeof(WNDCLASSEX);
    wc.style        = 0;
    wc.lpfnWndProc  = WndProc;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;
    wc.hInstance    = hInstance;
    wc.hIcon        = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor      = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
    wc.lpszMenuName  = NULL;
    wc.lpszClassName = g_szClassName;
    wc.hIconSm      = LoadIcon(NULL, IDI_APPLICATION);

    if(!RegisterClassEx(&wc)) {
        return 0;
    }

    // Step 2: Creating the Window
    hwnd = CreateWindowEx(WS_EX_CLIENTEDGE, g_szClassName,
        "Win32 Practice",WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT, 800, 600,
        NULL, NULL, hInstance, NULL);
    if(hwnd == NULL) {
        return 0;
    }

        hWndButton = CreateWindowEx(NULL, "button", "Click Me",
                WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 50, 50, 100, 24, hwnd,
                (HMENU)(100), hInstance, NULL);
        if (hWndButton == NULL)
                return false;

        mCallback[/* Control ID here, as is sent by the low word of the wParam */] = &MyClickHandler;

    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);

    // Step 3: The Message Loop
    while(GetMessage(&Msg, NULL, 0, 0) > 0)
    {
        TranslateMessage(&Msg);
        DispatchMessage(&Msg);
    }
    return (int) Msg.wParam;
}

---

If you use the control identifier instead, it should only react for that control. Or you could use the window handle instead. But I don't know if the control's handle is sent via the hwnd argument in the window proc when a control notifies its window.

I'm not used to Pure Win32 programming nowadays. I typically use MFC.
Just add a button to the dialog, give it an ID and double-click it to create an event handler. Handy, isn't it? That's why I remember so little about this mess.

Definitely. I use Win32 for game programming and .Net for the job :) I'm trying to build a slim win32 GUI classes for my library, and MFC is just 100x more powerful than I need for games. .Net 3.5 has 200mb of runtime crap too :) Win32 is managable. But yeah... if I was building a game editor I'd consider MFC or C++/CLI.

Oh yeah, the best part of my code:

Code:

---

void OnClick(MessageCallbackPtr clickEvent)
{
        mCallback[WM_COMMAND] = &clickEvent;
}

---

Well, as you know, WM_COMMAND isn't the best message to use for it.
It's better to use the button's specific ID so it won't call the handler for whatever menu or button you click!