[C++-sig] Derived classes problem

[hessiess at hessiess.com]

I am trying to create a python wrapper for the quad-ren graphics
engine, which relies heavily on derived classes. The problem is
that I cannot create derived classes in python and pass them
to the C++ objects without getting the following error:

Traceback (most recent call last):
  File "test.py", line 79, in <module>
    quad3.set_event_receiver(event)
Boost.Python.ArgumentError: Python argument types in
    qr_scene_node.set_event_receiver(qr_quad, ev_receiver)
did not match C++ signature:
    set_event_receiver(qr_scene_node {lvalue}, qr_event_receiver*)

====================================================================
C++
====================================================================
#include <boost/python.hpp>
#include <quad-ren/quad-ren.h>

using namespace boost::python;

struct qr_scene_node_w : qr_scene_node, wrapper<qr_scene_node>
{
    void on_register()
    {
        this->get_override("on_register")();
    }

    void on_render()
    {
        this->get_override("on_render")();
    }

    void on_drop()
    {
        this->get_override("on_drop")();
    }
};

struct qr_event_receiver_w : qr_event_receiver, wrapper<qr_event_receiver>
{
    bool on_event(qr_event *event, qr_scene_node *node, float time_delta)
    {
        this->get_override("on_event")();
    }
};

BOOST_PYTHON_MODULE(qrpy)
{
    class_<vector2d_i>("vector2d_i")
        .def(init<float, float>())
        .def_readwrite("X", &vector2d_i::X)
        .def_readwrite("Y", &vector2d_i::Y);

    class_<vector2d_f>("vector2d_f")
        .def(init<float, float>())
        .def_readwrite("X", &vector2d_f::X)
        .def_readwrite("Y", &vector2d_f::Y);

    class_<qr_resource_manager>("qr_resource_manager");

    class_<qr_renderer>("qr_renderer")
        .def(init<vector2d_i, float, bool, vector2d_i>())
        .def("get_resource_manager", &qr_renderer::get_resource_manager,
            return_value_policy<reference_existing_object>())
        .def("run",                  &qr_renderer::run)
        .def("drop",                 &qr_renderer::drop)
        .def("set_total_layers",     &qr_renderer::set_total_layers)
        .def("set_window_title",     &qr_renderer::set_window_title)
        .def("get_time_delta",       &qr_renderer::get_time_delta)
        .def("get_ticks",            &qr_renderer::get_ticks)
        .def("get_fps",              &qr_renderer::get_fps)
        .def("set_camera_location",  &qr_renderer::set_camera_location)
        .def("get_camera_location",  &qr_renderer::get_camera_location)
        .def("get_pix_size",         &qr_renderer::get_pix_size)
        .def("set_bg_sprite",        &qr_renderer::set_bg_sprite)
        .def("get_bg_sprite",        &qr_renderer::get_bg_sprite,
            return_value_policy<reference_existing_object>());

    class_<qr_scene_node_w, boost::noncopyable>("qr_scene_node", no_init)
        .def("register_node",      &qr_scene_node_w::register_node)
        .def("drop",               &qr_scene_node_w::drop)
        .def("set_location",       &qr_scene_node_w::set_location)
        .def("get_location",       &qr_scene_node_w::get_location)
        .def("set_size",           &qr_scene_node_w::set_size)
        .def("get_size",           &qr_scene_node_w::get_size)
        .def("set_rotation",       &qr_scene_node_w::set_rotation)
        .def("get_rotation",       &qr_scene_node_w::get_rotation)
        .def("set_layer",          &qr_scene_node_w::set_layer)
        .def("get_layer",          &qr_scene_node_w::get_layer)
        .def("set_sprite",         &qr_scene_node_w::set_sprite)
        .def("get_sprite",         &qr_scene_node_w::get_sprite,
            return_value_policy<reference_existing_object>())
        .def("set_event_receiver", &qr_scene_node_w::set_event_receiver)
        .def("get_event_receiver", &qr_scene_node_w::get_event_receiver,
            return_value_policy<reference_existing_object>())
        .def("set_frame",          &qr_scene_node_w::set_frame)
        .def("get_frame",          &qr_scene_node_w::get_frame)

        .def("add_polygon",        &qr_scene_node_w::add_polygon)
        .def("clear_mesh",         &qr_scene_node_w::clear_mesh)
        .def("on_register",        &qr_scene_node_w::on_register)
        .def("on_render",          &qr_scene_node_w::on_render)
        .def("on_drop",            &qr_scene_node_w::on_drop);

    class_<qr_event_receiver_w, boost::noncopyable>("qr_event_receiver",
no_init)
        .def("on_event",           &qr_event_receiver_w::on_event);

    class_<qr_quad, bases<qr_scene_node> >("qr_quad")
        .def(init<qr_resource_manager* , bool>());
}

====================================================================
Python
====================================================================
import qrpy
false = bool(0)
true  = bool(1)

#create renderer + get resource manager
renderer = qrpy.qr_renderer(qrpy.vector2d_i(4, 3),
    10, false, qrpy.vector2d_i(0, 0))
res_man = renderer.get_resource_manager()

#event receiver
class ev_receiver(qrpy.qr_event_receiver):
    def __init__(self):
        return

    def on_event(self, event, node, time_delta):
        print event

event = ev_receiver()

quad = qrpy.qr_quad(res_man, 0)
quad.set_event_receiver(event) #error