UDefaultFunctions.h

#ifndef _UDEFAULTFUNCTIONS_H
#define _UDEFAULTFUNCTIONS_H
// -------------------------------------------------------------------------
#include <uniwidgets/UVoid.h>
#include <uniwidgets/UPixbufCache.h>
// -------------------------------------------------------------------------
class GuiPM;
// -------------------------------------------------------------------------
#define WRAPPED_TYPENAME( typename ) (std::string( g_type_name(typename) )+ "_uwrapped").c_str()
// -------------------------------------------------------------------------
template<class GtkParentClass>
class UDefaultFunctions : public GtkParentClass, public UVoid, public UPixbufCache
{
public:
    typedef GtkParentClass GtkmmBaseType;
    typedef UDefaultFunctions<GtkParentClass> BaseType;
    UDefaultFunctions() :
        Glib::ObjectBase(WRAPPED_TYPENAME(GtkParentClass::get_type()))
        ,UVoid(this)
        ,property_auto_connect_(*this, "auto-connect", true)
        ,property_disconnect_effect_(*this, "disconnect-effect", 1)
        ,property_lock_view_(*this, "lock-view", false)
    {}

    explicit UDefaultFunctions(typename GtkParentClass::BaseObjectType* o) :
        GtkParentClass(o)
        ,UVoid(this)
        ,property_auto_connect_(*this, "auto-connect", true)
        ,property_disconnect_effect_(*this, "disconnect-effect", 1)
        ,property_lock_view_(*this, "lock-view", false)
    {}

    virtual ~UDefaultFunctions() {}
    virtual void on_hierarchy_changed(Gtk::Widget* w);

    GuiPM* search_gpm();                    
    ConnectorRef get_connector_from_hierarchy();        
    virtual void add_lock(const Gtk::Widget& w);        
    virtual void unlock_current();              
private:
    Glib::Property<bool> property_auto_connect_;        
    Glib::Property<int> property_disconnect_effect_;    
    Glib::Property<bool> property_lock_view_;       
};
// -------------------------------------------------------------------------
inline Glib::PropertyProxy<bool>
UVoid::property_auto_connect()
{
    return Glib::PropertyProxy<bool>(obj_,"auto-connect");
}
// -------------------------------------------------------------------------
inline Glib::PropertyProxy_ReadOnly<bool>
UVoid::property_auto_connect() const
{
    return Glib::PropertyProxy_ReadOnly<bool>(obj_,"auto-connect");
}
// -------------------------------------------------------------------------
inline Glib::PropertyProxy<int>
UVoid::property_disconnect_effect()
{
    return Glib::PropertyProxy<int>(obj_,"disconnect-effect");
}
// -------------------------------------------------------------------------
inline Glib::PropertyProxy_ReadOnly<int>
UVoid::property_disconnect_effect() const
{
    return Glib::PropertyProxy_ReadOnly<int>(obj_,"disconnect-effect");
}
// -------------------------------------------------------------------------
inline Glib::PropertyProxy<bool>
UVoid::property_lock_view()
{
    return Glib::PropertyProxy<bool>(obj_,"lock-view");
}
// -------------------------------------------------------------------------
inline Glib::PropertyProxy_ReadOnly<bool>
UVoid::property_lock_view() const
{
    return Glib::PropertyProxy_ReadOnly<bool>(obj_,"lock-view");
}
// -------------------------------------------------------------------------
/* The template functions must be in header.
 * The compiler must able to see function implementation on instantiation.
 * For more details see http://www.parashift.com/c++-faq-lite/templates.html#faq-35.12 */
template<class T>
GuiPM* UDefaultFunctions<T>::search_gpm()
{
    Gtk::Widget* parent = reinterpret_cast<Gtk::Widget*>(T::get_parent());
    for (Gtk::Widget* p = parent; p != NULL; p = reinterpret_cast<Gtk::Widget*>(p->get_parent()))
        if ( UVoid* uv = dynamic_cast<UVoid*>(p) )// && uv->gpm != NULL)
            if ( uv->gpm != NULL) return uv->gpm;
    return NULL;
}
// -------------------------------------------------------------------------
template<class T> ConnectorRef
UDefaultFunctions<T>::get_connector_from_hierarchy()
{
    Gtk::Widget* parent = reinterpret_cast<Gtk::Widget*>(T::get_parent());
    while (parent != NULL) {
        if(UVoid* uv = dynamic_cast<UVoid*>(parent)) {
            ConnectorRef new_connector = uv->get_connector();
            return new_connector;
        }
        parent = reinterpret_cast<Gtk::Widget*>(parent->get_parent());
    }
    return ConnectorRef();
}
// -------------------------------------------------------------------------
template<class T> void
UDefaultFunctions<T>::on_hierarchy_changed(Gtk::Widget* w)
{
    GtkmmBaseType::on_hierarchy_changed(w);
    if ( !property_auto_connect_ )
        return;
    ConnectorRef connector = get_connector_from_hierarchy();
    set_connector(connector);
}
// -------------------------------------------------------------------------
template<class T>
void UDefaultFunctions<T>::add_lock(const Gtk::Widget& w)
{
    Gtk::Widget* prev = this;
    Gtk::Widget* next = reinterpret_cast<Gtk::Widget*>(T::get_parent());
    while (next != NULL) {
        if (UVoid* uv = dynamic_cast<UVoid*>(next)) {
            uv->add_lock(*prev);
            break;
        }

        prev = next;
        next = reinterpret_cast<Gtk::Widget*>(next->get_parent());
    }
}
// -------------------------------------------------------------------------
template<class T>
void UDefaultFunctions<T>::unlock_current()
{
    Gtk::Widget* parent = reinterpret_cast<Gtk::Widget*>(T::get_parent());
    for (Gtk::Widget* p = parent; p != NULL; p = reinterpret_cast<Gtk::Widget*>(p->get_parent()))
        if (UVoid* uv = dynamic_cast<UVoid*>(p)) {
            uv->unlock_current();
            break;
        }
}
// -------------------------------------------------------------------------
#endif