namespace boost { namespace dataflow { namespace vtk {

struct vtk_rendererwindow_consumer;

struct vtk_renderer_producer
    : public complemented_port_traits<ports::producer,
        dataflow::port_adapter<vtkRenderWindow, vtk_rendererwindow_consumer, tag>, tag>
{};

struct vtk_renderer_consumer
    : public port_traits<ports::consumer, tag>
{};

struct vtk_renderer_component_traits
    : public dataflow::fusion_component_traits<
        fusion::vector<
            dataflow::port_adapter<vtkRenderer, vtk_renderer_producer, tag>,
            dataflow::port_adapter<vtkRenderer, vtk_renderer_consumer, tag> >, 
        detail::default_map,
        tag>
{
    template<typename Component>
    static typename vtk_renderer_component_traits::fusion_ports get_ports(Component &c)
    {
        return typename vtk_renderer_component_traits::fusion_ports(c, c);
    }
};

struct vtk_rendererwindow_consumer
    : public complemented_port_traits<ports::consumer, 
        dataflow::port_adapter<vtkRenderer, vtk_renderer_producer, tag>, tag>
{};

struct vtk_renderer_window_component_traits
    : public dataflow::fusion_component_traits<
        fusion::vector<
            dataflow::port_adapter<vtkRenderWindow, vtk_rendererwindow_consumer, tag> >, 
        detail::consumer_only_map,
        tag>
{
    template<typename Component>
    static typename vtk_renderer_window_component_traits::fusion_ports get_ports(Component &c)
    {
        return typename vtk_renderer_window_component_traits::fusion_ports(fusion::vector1<Component &>(c));
    }
};

} } } // namespace boost::dataflow::vtk

DATAFLOW_TRAITS_ENABLE_IF(
    T,
    boost::is_base_of<vtkRenderer BOOST_PP_COMMA() T>,
    vtk::vtk_renderer_component_traits)

DATAFLOW_TRAITS_ENABLE_IF(
    T,
    boost::is_base_of<vtkRenderWindow BOOST_PP_COMMA() T>,
    vtk::vtk_renderer_window_component_traits)

namespace boost { namespace dataflow { namespace extension {

template<>
struct binary_operation_impl<vtk::vtk_actor_producer, vtk::vtk_renderer_consumer, operations::connect>
{
    typedef void result_type;

    template<typename Producer, typename Consumer>
    void operator()(Producer &producer, Consumer &consumer)
    {
        get_object(consumer).AddActor(&get_object(producer));
    }
};

template<>
struct binary_operation_impl<vtk::vtk_renderer_producer, vtk::vtk_rendererwindow_consumer, operations::connect>
{
    typedef void result_type;

    template<typename Producer, typename Consumer>
    void operator()(Producer &producer, Consumer &consumer)
    {
        get_object(consumer).AddRenderer(&get_object(producer));
    }
};

template<>
struct component_operation_impl<vtk::vtk_renderer_window_component_traits, operations::invoke>
{
    typedef void result_type;

    template<typename Component>
    void operator()(Component &component)
    {
        get_object(component).Render();
    }
};

} } } // namespace boost::dataflow::extension