UDefaultFunctions.h

#ifndef _UDEFAULTFUNCTIONS_H
#define _UDEFAULTFUNCTIONS_H
// -------------------------------------------------------------------------
#include <UVoid.h>
#include <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)
  {}
  
  UDefaultFunctions(const BaseType& p) :
    UVoid(this)
    ,property_auto_connect_(*this, "auto-connect", p.property_auto_connect_)
    ,property_disconnect_effect_(*this, "disconnect-effect", p.property_disconnect_effect_)
    ,property_lock_view_(*this, "lock-view", p.property_lock_view_)
  {}

  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