Question

I’m making a Gui Api for games. The user can always use inheritance on the widget and override, but I want callbacks. I want to use a templated callback system:

so if they want to have one for the mouse they inherit from a version of the templated callback base with mouseargs:

So the base would look like this:

template <typename T>

class AguiEventCallback {

public:
virtual void callback(AguiWidget* sender, T arg) = 0;

};

Is it a good idea to mix templates with polymorphism like this? Would I be better off creating callbacks for each of the types I need (mouse, keyboard, gamepad, etc)?

Thanks

Answer 1

Have a look at boost::function and boost::bind. Accept a function object with a defined parameter list for particular events, and callers can do what they want.

This gives callback implementations lots of flexibility and the object generating the events requires even less knowledge of the callback implementation.

For example:

 typedef boost::function<void (AguiWidget* sender)> CallbackFunc;
 void register_callback(CallbackFunc const& f);

And the client:

class Caller {
    void do_register() { register_callback(bind(&Caller::event, this, 123, _1)); }

    void event(int arg, AguiWidget* sender) { ... }
};

Just showing function/bind, many other issues ignored; eg. memory management, object lifetime.