// -*- c++ -*-
/* This is a generated file do not edit.  Generated from gtk--sigproxy.h.m4 */
#ifndef GTKMM_SIGPROXY
#define GTKMM_SIGPROXY

#include <gtk/gtksignal.h>
#include <gtk/gtkwidget.h>

#include <gtk--sigcommon.h>
#include <gtk--sigslot.h>
#include <gtk--sigcpp.h>
class Gtk_Object;
























    
    








class Signal_proxy_base 
  {
   public:
     const gchar *signal_name;
     Gtk_Object *sender;
     Signal_proxy_base(const gchar *sign,Gtk_Object *send) 
       : signal_name(sign), sender(send) {}
  };

/* signal_proxy_imp */


/* cm_signal_proxy_imp */


/* cf_signal_proxy_imp */


/* cs_signal_proxy_imp */





/********************************************************************
*****  Signal_Proxy with 0 Arguments
********************************************************************/
template<class GtkObjType>
  class Signal_proxy0 : public Signal_proxy_base
  {  void (*func)(GtkObjType* );
   public:
     Signal_proxy0 (const gchar *name, Gtk_Object *obj,
        void (*func_)(GtkObjType* )=0); 
     void operator()();
  };

template<class GtkObjType>
  void Signal_proxy0 <GtkObjType>::operator()()
  {int rval;
   if (func) 
      func((GtkObjType*)sender->gtkobj() ); 
    else 
      gtk_signal_emit_by_name(sender->gtkobj(),signal_name ,&rval); 
   
  }

template<class GtkObjType>
  Signal_proxy0 <GtkObjType>::Signal_proxy0
    (const gchar *name, Gtk_Object *obj, void (*func_)(GtkObjType* ))
    : Signal_proxy_base(name,obj), func(func_)
  {}


/*** connect_to_method 0 args ***/
template<class GtkObjType,class T>
  Connection connect_to_method(
    Signal_proxy0 <GtkObjType> &proxy,
    T *receiver,void (T::*method)()  )
  {Connection_impl* slot = 
     new Slot0<T>(receiver,method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot0<T>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_method 0 args,cbdata ***/
template<class GtkObjType,class T,class E>
  Connection connect_to_method(
    Signal_proxy0 <GtkObjType> &proxy,
    T *receiver,void (T::*method)(E) ,E arg )
  {Connection_impl* slot = 
     new Slot0cb<T,E>(receiver,method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot0cb<T,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 0 args ***/
template<class GtkObjType>
  Connection connect_to_function(
    Signal_proxy0 <GtkObjType> &proxy, 
    void (*method)() )
  { Connection_impl* slot=
      new Concretegtkslot0<void (*)()>(method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot0<void (*)()>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 0 args,cbdata ***/
template<class GtkObjType,class E>
  Connection connect_to_function(
    Signal_proxy0 <GtkObjType> &proxy, 
    void (*method)(E) ,E arg)
  { Connection_impl* slot=
      new Concretegtkslot0cb<void (*)(E),E>(method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot0cb<void (*)(E),E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_signal 0 args ***/
template<class GtkObjType,class M>
  Connection connect_to_signal(
    Signal_proxy0 <GtkObjType> &proxy,
    M &func )
  { Connection_impl* slot = 
      new Concretegtkslot0<M&>(func );
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot0<M&>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }


/*** connect_to_signal 0 args,cbdata ***/
template<class GtkObjType,class M,class E>
  Connection connect_to_signal(
    Signal_proxy0 <GtkObjType> &proxy,
    M &func ,E arg)
  { Connection_impl* slot = 
      new Concretegtkslot0cb<M&,E>(func ,arg);
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot0cb<M&,E>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }


/********************************************************************
*****  Signal_Proxy with 0 Arguments,return type
********************************************************************/
template<class rettype,class GtkObjType>
  class Signal_proxy0_r : public Signal_proxy_base
  {  rettype (*func)(GtkObjType* );
   public:
     Signal_proxy0_r (const gchar *name, Gtk_Object *obj,
        rettype (*func_)(GtkObjType* )=0); 
     rettype operator()();
  };

template<class rettype,class GtkObjType>
  rettype Signal_proxy0_r <rettype,GtkObjType>::operator()()
  {rettype rval;
   if (func) 
      rval=func((GtkObjType*)sender->gtkobj() ); 
    else 
      gtk_signal_emit_by_name(sender->gtkobj(),signal_name ,&rval); 
   return rval;
  }

template<class rettype,class GtkObjType>
  Signal_proxy0_r <rettype,GtkObjType>::Signal_proxy0_r
    (const gchar *name, Gtk_Object *obj, rettype (*func_)(GtkObjType* ))
    : Signal_proxy_base(name,obj), func(func_)
  {}


/*** connect_to_method 0 args,return type ***/
template<class rettype,class GtkObjType,class T>
  Connection connect_to_method(
    Signal_proxy0_r <rettype,GtkObjType> &proxy,
    T *receiver,rettype (T::*method)()  )
  {Connection_impl* slot = 
     new Slot0_r<rettype,T>(receiver,method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot0_r<rettype,T>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_method 0 args,cbdata,return type ***/
template<class rettype,class GtkObjType,class T,class E>
  Connection connect_to_method(
    Signal_proxy0_r <rettype,GtkObjType> &proxy,
    T *receiver,rettype (T::*method)(E) ,E arg )
  {Connection_impl* slot = 
     new Slot0cb_r<rettype,T,E>(receiver,method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot0cb_r<rettype,T,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 0 args,return type ***/
template<class rettype,class GtkObjType>
  Connection connect_to_function(
    Signal_proxy0_r <rettype,GtkObjType> &proxy, 
    rettype (*method)() )
  { Connection_impl* slot=
      new Concretegtkslot0_r<rettype,rettype (*)()>(method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot0_r<rettype,rettype (*)()>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 0 args,cbdata,return type ***/
template<class rettype,class GtkObjType,class E>
  Connection connect_to_function(
    Signal_proxy0_r <rettype,GtkObjType> &proxy, 
    rettype (*method)(E) ,E arg)
  { Connection_impl* slot=
      new Concretegtkslot0cb_r<rettype,rettype (*)(E),E>(method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot0cb_r<rettype,rettype (*)(E),E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_signal 0 args,return type ***/
template<class rettype,class GtkObjType,class M>
  Connection connect_to_signal(
    Signal_proxy0_r <rettype,GtkObjType> &proxy,
    M &func )
  { Connection_impl* slot = 
      new Concretegtkslot0_r<rettype,M&>(func );
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot0_r<rettype,M&>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }


/*** connect_to_signal 0 args,cbdata,return type ***/
template<class rettype,class GtkObjType,class M,class E>
  Connection connect_to_signal(
    Signal_proxy0_r <rettype,GtkObjType> &proxy,
    M &func ,E arg)
  { Connection_impl* slot = 
      new Concretegtkslot0cb_r<rettype,M&,E>(func ,arg);
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot0cb_r<rettype,M&,E>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }




/********************************************************************
*****  Signal_Proxy with 1 Arguments
********************************************************************/
template<class GtkObjType,class P1>
  class Signal_proxy1 : public Signal_proxy_base
  {  void (*func)(GtkObjType* ,P1);
   public:
     Signal_proxy1 (const gchar *name, Gtk_Object *obj,
        void (*func_)(GtkObjType* ,P1)=0); 
     void operator()(P1 p1);
  };

template<class GtkObjType,class P1>
  void Signal_proxy1 <GtkObjType,P1>::operator()(P1 p1)
  {int rval;
   if (func) 
      func((GtkObjType*)sender->gtkobj() ,p1); 
    else 
      gtk_signal_emit_by_name(sender->gtkobj(),signal_name ,p1,&rval); 
   
  }

template<class GtkObjType,class P1>
  Signal_proxy1 <GtkObjType,P1>::Signal_proxy1
    (const gchar *name, Gtk_Object *obj, void (*func_)(GtkObjType* ,P1))
    : Signal_proxy_base(name,obj), func(func_)
  {}


/*** connect_to_method 1 args ***/
template<class GtkObjType,class T,class P1>
  Connection connect_to_method(
    Signal_proxy1 <GtkObjType,P1> &proxy,
    T *receiver,void (T::*method)(P1)  )
  {Connection_impl* slot = 
     new Slot1<T,P1>(receiver,method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot1<T,P1>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_method 1 args,cbdata ***/
template<class GtkObjType,class T,class P1,class E>
  Connection connect_to_method(
    Signal_proxy1 <GtkObjType,P1> &proxy,
    T *receiver,void (T::*method)(P1,E) ,E arg )
  {Connection_impl* slot = 
     new Slot1cb<T,P1,E>(receiver,method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot1cb<T,P1,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 1 args ***/
template<class GtkObjType,class P1>
  Connection connect_to_function(
    Signal_proxy1 <GtkObjType,P1> &proxy, 
    void (*method)(P1) )
  { Connection_impl* slot=
      new Concretegtkslot1<void (*)(P1),P1>(method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot1<void (*)(P1),P1>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 1 args,cbdata ***/
template<class GtkObjType,class P1,class E>
  Connection connect_to_function(
    Signal_proxy1 <GtkObjType,P1> &proxy, 
    void (*method)(P1,E) ,E arg)
  { Connection_impl* slot=
      new Concretegtkslot1cb<void (*)(P1,E),P1,E>(method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot1cb<void (*)(P1,E),P1,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_signal 1 args ***/
template<class GtkObjType,class M,class P1>
  Connection connect_to_signal(
    Signal_proxy1 <GtkObjType,P1> &proxy,
    M &func )
  { Connection_impl* slot = 
      new Concretegtkslot1<M&,P1>(func );
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot1<M&,P1>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }


/*** connect_to_signal 1 args,cbdata ***/
template<class GtkObjType,class M,class P1,class E>
  Connection connect_to_signal(
    Signal_proxy1 <GtkObjType,P1> &proxy,
    M &func ,E arg)
  { Connection_impl* slot = 
      new Concretegtkslot1cb<M&,P1,E>(func ,arg);
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot1cb<M&,P1,E>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }


/********************************************************************
*****  Signal_Proxy with 1 Arguments,return type
********************************************************************/
template<class rettype,class GtkObjType,class P1>
  class Signal_proxy1_r : public Signal_proxy_base
  {  rettype (*func)(GtkObjType* ,P1);
   public:
     Signal_proxy1_r (const gchar *name, Gtk_Object *obj,
        rettype (*func_)(GtkObjType* ,P1)=0); 
     rettype operator()(P1 p1);
  };

template<class rettype,class GtkObjType,class P1>
  rettype Signal_proxy1_r <rettype,GtkObjType,P1>::operator()(P1 p1)
  {rettype rval;
   if (func) 
      rval=func((GtkObjType*)sender->gtkobj() ,p1); 
    else 
      gtk_signal_emit_by_name(sender->gtkobj(),signal_name ,p1,&rval); 
   return rval;
  }

template<class rettype,class GtkObjType,class P1>
  Signal_proxy1_r <rettype,GtkObjType,P1>::Signal_proxy1_r
    (const gchar *name, Gtk_Object *obj, rettype (*func_)(GtkObjType* ,P1))
    : Signal_proxy_base(name,obj), func(func_)
  {}


/*** connect_to_method 1 args,return type ***/
template<class rettype,class GtkObjType,class T,class P1>
  Connection connect_to_method(
    Signal_proxy1_r <rettype,GtkObjType,P1> &proxy,
    T *receiver,rettype (T::*method)(P1)  )
  {Connection_impl* slot = 
     new Slot1_r<rettype,T,P1>(receiver,method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot1_r<rettype,T,P1>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_method 1 args,cbdata,return type ***/
template<class rettype,class GtkObjType,class T,class P1,class E>
  Connection connect_to_method(
    Signal_proxy1_r <rettype,GtkObjType,P1> &proxy,
    T *receiver,rettype (T::*method)(P1,E) ,E arg )
  {Connection_impl* slot = 
     new Slot1cb_r<rettype,T,P1,E>(receiver,method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot1cb_r<rettype,T,P1,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 1 args,return type ***/
template<class rettype,class GtkObjType,class P1>
  Connection connect_to_function(
    Signal_proxy1_r <rettype,GtkObjType,P1> &proxy, 
    rettype (*method)(P1) )
  { Connection_impl* slot=
      new Concretegtkslot1_r<rettype,rettype (*)(P1),P1>(method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot1_r<rettype,rettype (*)(P1),P1>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 1 args,cbdata,return type ***/
template<class rettype,class GtkObjType,class P1,class E>
  Connection connect_to_function(
    Signal_proxy1_r <rettype,GtkObjType,P1> &proxy, 
    rettype (*method)(P1,E) ,E arg)
  { Connection_impl* slot=
      new Concretegtkslot1cb_r<rettype,rettype (*)(P1,E),P1,E>(method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot1cb_r<rettype,rettype (*)(P1,E),P1,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_signal 1 args,return type ***/
template<class rettype,class GtkObjType,class M,class P1>
  Connection connect_to_signal(
    Signal_proxy1_r <rettype,GtkObjType,P1> &proxy,
    M &func )
  { Connection_impl* slot = 
      new Concretegtkslot1_r<rettype,M&,P1>(func );
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot1_r<rettype,M&,P1>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }


/*** connect_to_signal 1 args,cbdata,return type ***/
template<class rettype,class GtkObjType,class M,class P1,class E>
  Connection connect_to_signal(
    Signal_proxy1_r <rettype,GtkObjType,P1> &proxy,
    M &func ,E arg)
  { Connection_impl* slot = 
      new Concretegtkslot1cb_r<rettype,M&,P1,E>(func ,arg);
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot1cb_r<rettype,M&,P1,E>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }




/********************************************************************
*****  Signal_Proxy with 2 Arguments
********************************************************************/
template<class GtkObjType,class P1,class P2>
  class Signal_proxy2 : public Signal_proxy_base
  {  void (*func)(GtkObjType* ,P1,P2);
   public:
     Signal_proxy2 (const gchar *name, Gtk_Object *obj,
        void (*func_)(GtkObjType* ,P1,P2)=0); 
     void operator()(P1 p1,P2 p2);
  };

template<class GtkObjType,class P1,class P2>
  void Signal_proxy2 <GtkObjType,P1,P2>::operator()(P1 p1,P2 p2)
  {int rval;
   if (func) 
      func((GtkObjType*)sender->gtkobj() ,p1,p2); 
    else 
      gtk_signal_emit_by_name(sender->gtkobj(),signal_name ,p1,p2,&rval); 
   
  }

template<class GtkObjType,class P1,class P2>
  Signal_proxy2 <GtkObjType,P1,P2>::Signal_proxy2
    (const gchar *name, Gtk_Object *obj, void (*func_)(GtkObjType* ,P1,P2))
    : Signal_proxy_base(name,obj), func(func_)
  {}


/*** connect_to_method 2 args ***/
template<class GtkObjType,class T,class P1,class P2>
  Connection connect_to_method(
    Signal_proxy2 <GtkObjType,P1,P2> &proxy,
    T *receiver,void (T::*method)(P1,P2)  )
  {Connection_impl* slot = 
     new Slot2<T,P1,P2>(receiver,method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot2<T,P1,P2>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_method 2 args,cbdata ***/
template<class GtkObjType,class T,class P1,class P2,class E>
  Connection connect_to_method(
    Signal_proxy2 <GtkObjType,P1,P2> &proxy,
    T *receiver,void (T::*method)(P1,P2,E) ,E arg )
  {Connection_impl* slot = 
     new Slot2cb<T,P1,P2,E>(receiver,method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot2cb<T,P1,P2,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 2 args ***/
template<class GtkObjType,class P1,class P2>
  Connection connect_to_function(
    Signal_proxy2 <GtkObjType,P1,P2> &proxy, 
    void (*method)(P1,P2) )
  { Connection_impl* slot=
      new Concretegtkslot2<void (*)(P1,P2),P1,P2>(method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot2<void (*)(P1,P2),P1,P2>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 2 args,cbdata ***/
template<class GtkObjType,class P1,class P2,class E>
  Connection connect_to_function(
    Signal_proxy2 <GtkObjType,P1,P2> &proxy, 
    void (*method)(P1,P2,E) ,E arg)
  { Connection_impl* slot=
      new Concretegtkslot2cb<void (*)(P1,P2,E),P1,P2,E>(method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot2cb<void (*)(P1,P2,E),P1,P2,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_signal 2 args ***/
template<class GtkObjType,class M,class P1,class P2>
  Connection connect_to_signal(
    Signal_proxy2 <GtkObjType,P1,P2> &proxy,
    M &func )
  { Connection_impl* slot = 
      new Concretegtkslot2<M&,P1,P2>(func );
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot2<M&,P1,P2>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }


/*** connect_to_signal 2 args,cbdata ***/
template<class GtkObjType,class M,class P1,class P2,class E>
  Connection connect_to_signal(
    Signal_proxy2 <GtkObjType,P1,P2> &proxy,
    M &func ,E arg)
  { Connection_impl* slot = 
      new Concretegtkslot2cb<M&,P1,P2,E>(func ,arg);
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot2cb<M&,P1,P2,E>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }


/********************************************************************
*****  Signal_Proxy with 2 Arguments,return type
********************************************************************/
template<class rettype,class GtkObjType,class P1,class P2>
  class Signal_proxy2_r : public Signal_proxy_base
  {  rettype (*func)(GtkObjType* ,P1,P2);
   public:
     Signal_proxy2_r (const gchar *name, Gtk_Object *obj,
        rettype (*func_)(GtkObjType* ,P1,P2)=0); 
     rettype operator()(P1 p1,P2 p2);
  };

template<class rettype,class GtkObjType,class P1,class P2>
  rettype Signal_proxy2_r <rettype,GtkObjType,P1,P2>::operator()(P1 p1,P2 p2)
  {rettype rval;
   if (func) 
      rval=func((GtkObjType*)sender->gtkobj() ,p1,p2); 
    else 
      gtk_signal_emit_by_name(sender->gtkobj(),signal_name ,p1,p2,&rval); 
   return rval;
  }

template<class rettype,class GtkObjType,class P1,class P2>
  Signal_proxy2_r <rettype,GtkObjType,P1,P2>::Signal_proxy2_r
    (const gchar *name, Gtk_Object *obj, rettype (*func_)(GtkObjType* ,P1,P2))
    : Signal_proxy_base(name,obj), func(func_)
  {}


/*** connect_to_method 2 args,return type ***/
template<class rettype,class GtkObjType,class T,class P1,class P2>
  Connection connect_to_method(
    Signal_proxy2_r <rettype,GtkObjType,P1,P2> &proxy,
    T *receiver,rettype (T::*method)(P1,P2)  )
  {Connection_impl* slot = 
     new Slot2_r<rettype,T,P1,P2>(receiver,method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot2_r<rettype,T,P1,P2>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_method 2 args,cbdata,return type ***/
template<class rettype,class GtkObjType,class T,class P1,class P2,class E>
  Connection connect_to_method(
    Signal_proxy2_r <rettype,GtkObjType,P1,P2> &proxy,
    T *receiver,rettype (T::*method)(P1,P2,E) ,E arg )
  {Connection_impl* slot = 
     new Slot2cb_r<rettype,T,P1,P2,E>(receiver,method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot2cb_r<rettype,T,P1,P2,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 2 args,return type ***/
template<class rettype,class GtkObjType,class P1,class P2>
  Connection connect_to_function(
    Signal_proxy2_r <rettype,GtkObjType,P1,P2> &proxy, 
    rettype (*method)(P1,P2) )
  { Connection_impl* slot=
      new Concretegtkslot2_r<rettype,rettype (*)(P1,P2),P1,P2>(method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot2_r<rettype,rettype (*)(P1,P2),P1,P2>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 2 args,cbdata,return type ***/
template<class rettype,class GtkObjType,class P1,class P2,class E>
  Connection connect_to_function(
    Signal_proxy2_r <rettype,GtkObjType,P1,P2> &proxy, 
    rettype (*method)(P1,P2,E) ,E arg)
  { Connection_impl* slot=
      new Concretegtkslot2cb_r<rettype,rettype (*)(P1,P2,E),P1,P2,E>(method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot2cb_r<rettype,rettype (*)(P1,P2,E),P1,P2,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_signal 2 args,return type ***/
template<class rettype,class GtkObjType,class M,class P1,class P2>
  Connection connect_to_signal(
    Signal_proxy2_r <rettype,GtkObjType,P1,P2> &proxy,
    M &func )
  { Connection_impl* slot = 
      new Concretegtkslot2_r<rettype,M&,P1,P2>(func );
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot2_r<rettype,M&,P1,P2>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }


/*** connect_to_signal 2 args,cbdata,return type ***/
template<class rettype,class GtkObjType,class M,class P1,class P2,class E>
  Connection connect_to_signal(
    Signal_proxy2_r <rettype,GtkObjType,P1,P2> &proxy,
    M &func ,E arg)
  { Connection_impl* slot = 
      new Concretegtkslot2cb_r<rettype,M&,P1,P2,E>(func ,arg);
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot2cb_r<rettype,M&,P1,P2,E>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }




/********************************************************************
*****  Signal_Proxy with 3 Arguments
********************************************************************/
template<class GtkObjType,class P1,class P2,class P3>
  class Signal_proxy3 : public Signal_proxy_base
  {  void (*func)(GtkObjType* ,P1,P2,P3);
   public:
     Signal_proxy3 (const gchar *name, Gtk_Object *obj,
        void (*func_)(GtkObjType* ,P1,P2,P3)=0); 
     void operator()(P1 p1,P2 p2,P3 p3);
  };

template<class GtkObjType,class P1,class P2,class P3>
  void Signal_proxy3 <GtkObjType,P1,P2,P3>::operator()(P1 p1,P2 p2,P3 p3)
  {int rval;
   if (func) 
      func((GtkObjType*)sender->gtkobj() ,p1,p2,p3); 
    else 
      gtk_signal_emit_by_name(sender->gtkobj(),signal_name ,p1,p2,p3,&rval); 
   
  }

template<class GtkObjType,class P1,class P2,class P3>
  Signal_proxy3 <GtkObjType,P1,P2,P3>::Signal_proxy3
    (const gchar *name, Gtk_Object *obj, void (*func_)(GtkObjType* ,P1,P2,P3))
    : Signal_proxy_base(name,obj), func(func_)
  {}


/*** connect_to_method 3 args ***/
template<class GtkObjType,class T,class P1,class P2,class P3>
  Connection connect_to_method(
    Signal_proxy3 <GtkObjType,P1,P2,P3> &proxy,
    T *receiver,void (T::*method)(P1,P2,P3)  )
  {Connection_impl* slot = 
     new Slot3<T,P1,P2,P3>(receiver,method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot3<T,P1,P2,P3>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_method 3 args,cbdata ***/
template<class GtkObjType,class T,class P1,class P2,class P3,class E>
  Connection connect_to_method(
    Signal_proxy3 <GtkObjType,P1,P2,P3> &proxy,
    T *receiver,void (T::*method)(P1,P2,P3,E) ,E arg )
  {Connection_impl* slot = 
     new Slot3cb<T,P1,P2,P3,E>(receiver,method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot3cb<T,P1,P2,P3,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 3 args ***/
template<class GtkObjType,class P1,class P2,class P3>
  Connection connect_to_function(
    Signal_proxy3 <GtkObjType,P1,P2,P3> &proxy, 
    void (*method)(P1,P2,P3) )
  { Connection_impl* slot=
      new Concretegtkslot3<void (*)(P1,P2,P3),P1,P2,P3>(method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot3<void (*)(P1,P2,P3),P1,P2,P3>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 3 args,cbdata ***/
template<class GtkObjType,class P1,class P2,class P3,class E>
  Connection connect_to_function(
    Signal_proxy3 <GtkObjType,P1,P2,P3> &proxy, 
    void (*method)(P1,P2,P3,E) ,E arg)
  { Connection_impl* slot=
      new Concretegtkslot3cb<void (*)(P1,P2,P3,E),P1,P2,P3,E>(method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot3cb<void (*)(P1,P2,P3,E),P1,P2,P3,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_signal 3 args ***/
template<class GtkObjType,class M,class P1,class P2,class P3>
  Connection connect_to_signal(
    Signal_proxy3 <GtkObjType,P1,P2,P3> &proxy,
    M &func )
  { Connection_impl* slot = 
      new Concretegtkslot3<M&,P1,P2,P3>(func );
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot3<M&,P1,P2,P3>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }


/*** connect_to_signal 3 args,cbdata ***/
template<class GtkObjType,class M,class P1,class P2,class P3,class E>
  Connection connect_to_signal(
    Signal_proxy3 <GtkObjType,P1,P2,P3> &proxy,
    M &func ,E arg)
  { Connection_impl* slot = 
      new Concretegtkslot3cb<M&,P1,P2,P3,E>(func ,arg);
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot3cb<M&,P1,P2,P3,E>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }


/********************************************************************
*****  Signal_Proxy with 3 Arguments,return type
********************************************************************/
template<class rettype,class GtkObjType,class P1,class P2,class P3>
  class Signal_proxy3_r : public Signal_proxy_base
  {  rettype (*func)(GtkObjType* ,P1,P2,P3);
   public:
     Signal_proxy3_r (const gchar *name, Gtk_Object *obj,
        rettype (*func_)(GtkObjType* ,P1,P2,P3)=0); 
     rettype operator()(P1 p1,P2 p2,P3 p3);
  };

template<class rettype,class GtkObjType,class P1,class P2,class P3>
  rettype Signal_proxy3_r <rettype,GtkObjType,P1,P2,P3>::operator()(P1 p1,P2 p2,P3 p3)
  {rettype rval;
   if (func) 
      rval=func((GtkObjType*)sender->gtkobj() ,p1,p2,p3); 
    else 
      gtk_signal_emit_by_name(sender->gtkobj(),signal_name ,p1,p2,p3,&rval); 
   return rval;
  }

template<class rettype,class GtkObjType,class P1,class P2,class P3>
  Signal_proxy3_r <rettype,GtkObjType,P1,P2,P3>::Signal_proxy3_r
    (const gchar *name, Gtk_Object *obj, rettype (*func_)(GtkObjType* ,P1,P2,P3))
    : Signal_proxy_base(name,obj), func(func_)
  {}


/*** connect_to_method 3 args,return type ***/
template<class rettype,class GtkObjType,class T,class P1,class P2,class P3>
  Connection connect_to_method(
    Signal_proxy3_r <rettype,GtkObjType,P1,P2,P3> &proxy,
    T *receiver,rettype (T::*method)(P1,P2,P3)  )
  {Connection_impl* slot = 
     new Slot3_r<rettype,T,P1,P2,P3>(receiver,method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot3_r<rettype,T,P1,P2,P3>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_method 3 args,cbdata,return type ***/
template<class rettype,class GtkObjType,class T,class P1,class P2,class P3,class E>
  Connection connect_to_method(
    Signal_proxy3_r <rettype,GtkObjType,P1,P2,P3> &proxy,
    T *receiver,rettype (T::*method)(P1,P2,P3,E) ,E arg )
  {Connection_impl* slot = 
     new Slot3cb_r<rettype,T,P1,P2,P3,E>(receiver,method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot3cb_r<rettype,T,P1,P2,P3,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 3 args,return type ***/
template<class rettype,class GtkObjType,class P1,class P2,class P3>
  Connection connect_to_function(
    Signal_proxy3_r <rettype,GtkObjType,P1,P2,P3> &proxy, 
    rettype (*method)(P1,P2,P3) )
  { Connection_impl* slot=
      new Concretegtkslot3_r<rettype,rettype (*)(P1,P2,P3),P1,P2,P3>(method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot3_r<rettype,rettype (*)(P1,P2,P3),P1,P2,P3>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 3 args,cbdata,return type ***/
template<class rettype,class GtkObjType,class P1,class P2,class P3,class E>
  Connection connect_to_function(
    Signal_proxy3_r <rettype,GtkObjType,P1,P2,P3> &proxy, 
    rettype (*method)(P1,P2,P3,E) ,E arg)
  { Connection_impl* slot=
      new Concretegtkslot3cb_r<rettype,rettype (*)(P1,P2,P3,E),P1,P2,P3,E>(method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot3cb_r<rettype,rettype (*)(P1,P2,P3,E),P1,P2,P3,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_signal 3 args,return type ***/
template<class rettype,class GtkObjType,class M,class P1,class P2,class P3>
  Connection connect_to_signal(
    Signal_proxy3_r <rettype,GtkObjType,P1,P2,P3> &proxy,
    M &func )
  { Connection_impl* slot = 
      new Concretegtkslot3_r<rettype,M&,P1,P2,P3>(func );
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot3_r<rettype,M&,P1,P2,P3>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }


/*** connect_to_signal 3 args,cbdata,return type ***/
template<class rettype,class GtkObjType,class M,class P1,class P2,class P3,class E>
  Connection connect_to_signal(
    Signal_proxy3_r <rettype,GtkObjType,P1,P2,P3> &proxy,
    M &func ,E arg)
  { Connection_impl* slot = 
      new Concretegtkslot3cb_r<rettype,M&,P1,P2,P3,E>(func ,arg);
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot3cb_r<rettype,M&,P1,P2,P3,E>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }




/********************************************************************
*****  Signal_Proxy with 4 Arguments
********************************************************************/
template<class GtkObjType,class P1,class P2,class P3,class P4>
  class Signal_proxy4 : public Signal_proxy_base
  {  void (*func)(GtkObjType* ,P1,P2,P3,P4);
   public:
     Signal_proxy4 (const gchar *name, Gtk_Object *obj,
        void (*func_)(GtkObjType* ,P1,P2,P3,P4)=0); 
     void operator()(P1 p1,P2 p2,P3 p3,P4 p4);
  };

template<class GtkObjType,class P1,class P2,class P3,class P4>
  void Signal_proxy4 <GtkObjType,P1,P2,P3,P4>::operator()(P1 p1,P2 p2,P3 p3,P4 p4)
  {int rval;
   if (func) 
      func((GtkObjType*)sender->gtkobj() ,p1,p2,p3,p4); 
    else 
      gtk_signal_emit_by_name(sender->gtkobj(),signal_name ,p1,p2,p3,p4,&rval); 
   
  }

template<class GtkObjType,class P1,class P2,class P3,class P4>
  Signal_proxy4 <GtkObjType,P1,P2,P3,P4>::Signal_proxy4
    (const gchar *name, Gtk_Object *obj, void (*func_)(GtkObjType* ,P1,P2,P3,P4))
    : Signal_proxy_base(name,obj), func(func_)
  {}


/*** connect_to_method 4 args ***/
template<class GtkObjType,class T,class P1,class P2,class P3,class P4>
  Connection connect_to_method(
    Signal_proxy4 <GtkObjType,P1,P2,P3,P4> &proxy,
    T *receiver,void (T::*method)(P1,P2,P3,P4)  )
  {Connection_impl* slot = 
     new Slot4<T,P1,P2,P3,P4>(receiver,method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot4<T,P1,P2,P3,P4>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_method 4 args,cbdata ***/
template<class GtkObjType,class T,class P1,class P2,class P3,class P4,class E>
  Connection connect_to_method(
    Signal_proxy4 <GtkObjType,P1,P2,P3,P4> &proxy,
    T *receiver,void (T::*method)(P1,P2,P3,P4,E) ,E arg )
  {Connection_impl* slot = 
     new Slot4cb<T,P1,P2,P3,P4,E>(receiver,method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot4cb<T,P1,P2,P3,P4,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 4 args ***/
template<class GtkObjType,class P1,class P2,class P3,class P4>
  Connection connect_to_function(
    Signal_proxy4 <GtkObjType,P1,P2,P3,P4> &proxy, 
    void (*method)(P1,P2,P3,P4) )
  { Connection_impl* slot=
      new Concretegtkslot4<void (*)(P1,P2,P3,P4),P1,P2,P3,P4>(method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot4<void (*)(P1,P2,P3,P4),P1,P2,P3,P4>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 4 args,cbdata ***/
template<class GtkObjType,class P1,class P2,class P3,class P4,class E>
  Connection connect_to_function(
    Signal_proxy4 <GtkObjType,P1,P2,P3,P4> &proxy, 
    void (*method)(P1,P2,P3,P4,E) ,E arg)
  { Connection_impl* slot=
      new Concretegtkslot4cb<void (*)(P1,P2,P3,P4,E),P1,P2,P3,P4,E>(method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot4cb<void (*)(P1,P2,P3,P4,E),P1,P2,P3,P4,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_signal 4 args ***/
template<class GtkObjType,class M,class P1,class P2,class P3,class P4>
  Connection connect_to_signal(
    Signal_proxy4 <GtkObjType,P1,P2,P3,P4> &proxy,
    M &func )
  { Connection_impl* slot = 
      new Concretegtkslot4<M&,P1,P2,P3,P4>(func );
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot4<M&,P1,P2,P3,P4>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }


/*** connect_to_signal 4 args,cbdata ***/
template<class GtkObjType,class M,class P1,class P2,class P3,class P4,class E>
  Connection connect_to_signal(
    Signal_proxy4 <GtkObjType,P1,P2,P3,P4> &proxy,
    M &func ,E arg)
  { Connection_impl* slot = 
      new Concretegtkslot4cb<M&,P1,P2,P3,P4,E>(func ,arg);
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot4cb<M&,P1,P2,P3,P4,E>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }


/********************************************************************
*****  Signal_Proxy with 4 Arguments,return type
********************************************************************/
template<class rettype,class GtkObjType,class P1,class P2,class P3,class P4>
  class Signal_proxy4_r : public Signal_proxy_base
  {  rettype (*func)(GtkObjType* ,P1,P2,P3,P4);
   public:
     Signal_proxy4_r (const gchar *name, Gtk_Object *obj,
        rettype (*func_)(GtkObjType* ,P1,P2,P3,P4)=0); 
     rettype operator()(P1 p1,P2 p2,P3 p3,P4 p4);
  };

template<class rettype,class GtkObjType,class P1,class P2,class P3,class P4>
  rettype Signal_proxy4_r <rettype,GtkObjType,P1,P2,P3,P4>::operator()(P1 p1,P2 p2,P3 p3,P4 p4)
  {rettype rval;
   if (func) 
      rval=func((GtkObjType*)sender->gtkobj() ,p1,p2,p3,p4); 
    else 
      gtk_signal_emit_by_name(sender->gtkobj(),signal_name ,p1,p2,p3,p4,&rval); 
   return rval;
  }

template<class rettype,class GtkObjType,class P1,class P2,class P3,class P4>
  Signal_proxy4_r <rettype,GtkObjType,P1,P2,P3,P4>::Signal_proxy4_r
    (const gchar *name, Gtk_Object *obj, rettype (*func_)(GtkObjType* ,P1,P2,P3,P4))
    : Signal_proxy_base(name,obj), func(func_)
  {}


/*** connect_to_method 4 args,return type ***/
template<class rettype,class GtkObjType,class T,class P1,class P2,class P3,class P4>
  Connection connect_to_method(
    Signal_proxy4_r <rettype,GtkObjType,P1,P2,P3,P4> &proxy,
    T *receiver,rettype (T::*method)(P1,P2,P3,P4)  )
  {Connection_impl* slot = 
     new Slot4_r<rettype,T,P1,P2,P3,P4>(receiver,method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot4_r<rettype,T,P1,P2,P3,P4>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_method 4 args,cbdata,return type ***/
template<class rettype,class GtkObjType,class T,class P1,class P2,class P3,class P4,class E>
  Connection connect_to_method(
    Signal_proxy4_r <rettype,GtkObjType,P1,P2,P3,P4> &proxy,
    T *receiver,rettype (T::*method)(P1,P2,P3,P4,E) ,E arg )
  {Connection_impl* slot = 
     new Slot4cb_r<rettype,T,P1,P2,P3,P4,E>(receiver,method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot4cb_r<rettype,T,P1,P2,P3,P4,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 4 args,return type ***/
template<class rettype,class GtkObjType,class P1,class P2,class P3,class P4>
  Connection connect_to_function(
    Signal_proxy4_r <rettype,GtkObjType,P1,P2,P3,P4> &proxy, 
    rettype (*method)(P1,P2,P3,P4) )
  { Connection_impl* slot=
      new Concretegtkslot4_r<rettype,rettype (*)(P1,P2,P3,P4),P1,P2,P3,P4>(method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot4_r<rettype,rettype (*)(P1,P2,P3,P4),P1,P2,P3,P4>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 4 args,cbdata,return type ***/
template<class rettype,class GtkObjType,class P1,class P2,class P3,class P4,class E>
  Connection connect_to_function(
    Signal_proxy4_r <rettype,GtkObjType,P1,P2,P3,P4> &proxy, 
    rettype (*method)(P1,P2,P3,P4,E) ,E arg)
  { Connection_impl* slot=
      new Concretegtkslot4cb_r<rettype,rettype (*)(P1,P2,P3,P4,E),P1,P2,P3,P4,E>(method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot4cb_r<rettype,rettype (*)(P1,P2,P3,P4,E),P1,P2,P3,P4,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_signal 4 args,return type ***/
template<class rettype,class GtkObjType,class M,class P1,class P2,class P3,class P4>
  Connection connect_to_signal(
    Signal_proxy4_r <rettype,GtkObjType,P1,P2,P3,P4> &proxy,
    M &func )
  { Connection_impl* slot = 
      new Concretegtkslot4_r<rettype,M&,P1,P2,P3,P4>(func );
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot4_r<rettype,M&,P1,P2,P3,P4>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }


/*** connect_to_signal 4 args,cbdata,return type ***/
template<class rettype,class GtkObjType,class M,class P1,class P2,class P3,class P4,class E>
  Connection connect_to_signal(
    Signal_proxy4_r <rettype,GtkObjType,P1,P2,P3,P4> &proxy,
    M &func ,E arg)
  { Connection_impl* slot = 
      new Concretegtkslot4cb_r<rettype,M&,P1,P2,P3,P4,E>(func ,arg);
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot4cb_r<rettype,M&,P1,P2,P3,P4,E>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }




/********************************************************************
*****  Signal_Proxy with 5 Arguments
********************************************************************/
template<class GtkObjType,class P1,class P2,class P3,class P4,class P5>
  class Signal_proxy5 : public Signal_proxy_base
  {  void (*func)(GtkObjType* ,P1,P2,P3,P4,P5);
   public:
     Signal_proxy5 (const gchar *name, Gtk_Object *obj,
        void (*func_)(GtkObjType* ,P1,P2,P3,P4,P5)=0); 
     void operator()(P1 p1,P2 p2,P3 p3,P4 p4,P5 p5);
  };

template<class GtkObjType,class P1,class P2,class P3,class P4,class P5>
  void Signal_proxy5 <GtkObjType,P1,P2,P3,P4,P5>::operator()(P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
  {int rval;
   if (func) 
      func((GtkObjType*)sender->gtkobj() ,p1,p2,p3,p4,p5); 
    else 
      gtk_signal_emit_by_name(sender->gtkobj(),signal_name ,p1,p2,p3,p4,p5,&rval); 
   
  }

template<class GtkObjType,class P1,class P2,class P3,class P4,class P5>
  Signal_proxy5 <GtkObjType,P1,P2,P3,P4,P5>::Signal_proxy5
    (const gchar *name, Gtk_Object *obj, void (*func_)(GtkObjType* ,P1,P2,P3,P4,P5))
    : Signal_proxy_base(name,obj), func(func_)
  {}


/*** connect_to_method 5 args ***/
template<class GtkObjType,class T,class P1,class P2,class P3,class P4,class P5>
  Connection connect_to_method(
    Signal_proxy5 <GtkObjType,P1,P2,P3,P4,P5> &proxy,
    T *receiver,void (T::*method)(P1,P2,P3,P4,P5)  )
  {Connection_impl* slot = 
     new Slot5<T,P1,P2,P3,P4,P5>(receiver,method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot5<T,P1,P2,P3,P4,P5>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_method 5 args,cbdata ***/
template<class GtkObjType,class T,class P1,class P2,class P3,class P4,class P5,class E>
  Connection connect_to_method(
    Signal_proxy5 <GtkObjType,P1,P2,P3,P4,P5> &proxy,
    T *receiver,void (T::*method)(P1,P2,P3,P4,P5,E) ,E arg )
  {Connection_impl* slot = 
     new Slot5cb<T,P1,P2,P3,P4,P5,E>(receiver,method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot5cb<T,P1,P2,P3,P4,P5,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 5 args ***/
template<class GtkObjType,class P1,class P2,class P3,class P4,class P5>
  Connection connect_to_function(
    Signal_proxy5 <GtkObjType,P1,P2,P3,P4,P5> &proxy, 
    void (*method)(P1,P2,P3,P4,P5) )
  { Connection_impl* slot=
      new Concretegtkslot5<void (*)(P1,P2,P3,P4,P5),P1,P2,P3,P4,P5>(method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot5<void (*)(P1,P2,P3,P4,P5),P1,P2,P3,P4,P5>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 5 args,cbdata ***/
template<class GtkObjType,class P1,class P2,class P3,class P4,class P5,class E>
  Connection connect_to_function(
    Signal_proxy5 <GtkObjType,P1,P2,P3,P4,P5> &proxy, 
    void (*method)(P1,P2,P3,P4,P5,E) ,E arg)
  { Connection_impl* slot=
      new Concretegtkslot5cb<void (*)(P1,P2,P3,P4,P5,E),P1,P2,P3,P4,P5,E>(method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot5cb<void (*)(P1,P2,P3,P4,P5,E),P1,P2,P3,P4,P5,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_signal 5 args ***/
template<class GtkObjType,class M,class P1,class P2,class P3,class P4,class P5>
  Connection connect_to_signal(
    Signal_proxy5 <GtkObjType,P1,P2,P3,P4,P5> &proxy,
    M &func )
  { Connection_impl* slot = 
      new Concretegtkslot5<M&,P1,P2,P3,P4,P5>(func );
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot5<M&,P1,P2,P3,P4,P5>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }


/*** connect_to_signal 5 args,cbdata ***/
template<class GtkObjType,class M,class P1,class P2,class P3,class P4,class P5,class E>
  Connection connect_to_signal(
    Signal_proxy5 <GtkObjType,P1,P2,P3,P4,P5> &proxy,
    M &func ,E arg)
  { Connection_impl* slot = 
      new Concretegtkslot5cb<M&,P1,P2,P3,P4,P5,E>(func ,arg);
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot5cb<M&,P1,P2,P3,P4,P5,E>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }


/********************************************************************
*****  Signal_Proxy with 5 Arguments,return type
********************************************************************/
template<class rettype,class GtkObjType,class P1,class P2,class P3,class P4,class P5>
  class Signal_proxy5_r : public Signal_proxy_base
  {  rettype (*func)(GtkObjType* ,P1,P2,P3,P4,P5);
   public:
     Signal_proxy5_r (const gchar *name, Gtk_Object *obj,
        rettype (*func_)(GtkObjType* ,P1,P2,P3,P4,P5)=0); 
     rettype operator()(P1 p1,P2 p2,P3 p3,P4 p4,P5 p5);
  };

template<class rettype,class GtkObjType,class P1,class P2,class P3,class P4,class P5>
  rettype Signal_proxy5_r <rettype,GtkObjType,P1,P2,P3,P4,P5>::operator()(P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
  {rettype rval;
   if (func) 
      rval=func((GtkObjType*)sender->gtkobj() ,p1,p2,p3,p4,p5); 
    else 
      gtk_signal_emit_by_name(sender->gtkobj(),signal_name ,p1,p2,p3,p4,p5,&rval); 
   return rval;
  }

template<class rettype,class GtkObjType,class P1,class P2,class P3,class P4,class P5>
  Signal_proxy5_r <rettype,GtkObjType,P1,P2,P3,P4,P5>::Signal_proxy5_r
    (const gchar *name, Gtk_Object *obj, rettype (*func_)(GtkObjType* ,P1,P2,P3,P4,P5))
    : Signal_proxy_base(name,obj), func(func_)
  {}


/*** connect_to_method 5 args,return type ***/
template<class rettype,class GtkObjType,class T,class P1,class P2,class P3,class P4,class P5>
  Connection connect_to_method(
    Signal_proxy5_r <rettype,GtkObjType,P1,P2,P3,P4,P5> &proxy,
    T *receiver,rettype (T::*method)(P1,P2,P3,P4,P5)  )
  {Connection_impl* slot = 
     new Slot5_r<rettype,T,P1,P2,P3,P4,P5>(receiver,method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot5_r<rettype,T,P1,P2,P3,P4,P5>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_method 5 args,cbdata,return type ***/
template<class rettype,class GtkObjType,class T,class P1,class P2,class P3,class P4,class P5,class E>
  Connection connect_to_method(
    Signal_proxy5_r <rettype,GtkObjType,P1,P2,P3,P4,P5> &proxy,
    T *receiver,rettype (T::*method)(P1,P2,P3,P4,P5,E) ,E arg )
  {Connection_impl* slot = 
     new Slot5cb_r<rettype,T,P1,P2,P3,P4,P5,E>(receiver,method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot5cb_r<rettype,T,P1,P2,P3,P4,P5,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 5 args,return type ***/
template<class rettype,class GtkObjType,class P1,class P2,class P3,class P4,class P5>
  Connection connect_to_function(
    Signal_proxy5_r <rettype,GtkObjType,P1,P2,P3,P4,P5> &proxy, 
    rettype (*method)(P1,P2,P3,P4,P5) )
  { Connection_impl* slot=
      new Concretegtkslot5_r<rettype,rettype (*)(P1,P2,P3,P4,P5),P1,P2,P3,P4,P5>(method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot5_r<rettype,rettype (*)(P1,P2,P3,P4,P5),P1,P2,P3,P4,P5>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 5 args,cbdata,return type ***/
template<class rettype,class GtkObjType,class P1,class P2,class P3,class P4,class P5,class E>
  Connection connect_to_function(
    Signal_proxy5_r <rettype,GtkObjType,P1,P2,P3,P4,P5> &proxy, 
    rettype (*method)(P1,P2,P3,P4,P5,E) ,E arg)
  { Connection_impl* slot=
      new Concretegtkslot5cb_r<rettype,rettype (*)(P1,P2,P3,P4,P5,E),P1,P2,P3,P4,P5,E>(method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot5cb_r<rettype,rettype (*)(P1,P2,P3,P4,P5,E),P1,P2,P3,P4,P5,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_signal 5 args,return type ***/
template<class rettype,class GtkObjType,class M,class P1,class P2,class P3,class P4,class P5>
  Connection connect_to_signal(
    Signal_proxy5_r <rettype,GtkObjType,P1,P2,P3,P4,P5> &proxy,
    M &func )
  { Connection_impl* slot = 
      new Concretegtkslot5_r<rettype,M&,P1,P2,P3,P4,P5>(func );
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot5_r<rettype,M&,P1,P2,P3,P4,P5>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }


/*** connect_to_signal 5 args,cbdata,return type ***/
template<class rettype,class GtkObjType,class M,class P1,class P2,class P3,class P4,class P5,class E>
  Connection connect_to_signal(
    Signal_proxy5_r <rettype,GtkObjType,P1,P2,P3,P4,P5> &proxy,
    M &func ,E arg)
  { Connection_impl* slot = 
      new Concretegtkslot5cb_r<rettype,M&,P1,P2,P3,P4,P5,E>(func ,arg);
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot5cb_r<rettype,M&,P1,P2,P3,P4,P5,E>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }




/********************************************************************
*****  Signal_Proxy with 6 Arguments
********************************************************************/
template<class GtkObjType,class P1,class P2,class P3,class P4,class P5,class P6>
  class Signal_proxy6 : public Signal_proxy_base
  {  void (*func)(GtkObjType* ,P1,P2,P3,P4,P5,P6);
   public:
     Signal_proxy6 (const gchar *name, Gtk_Object *obj,
        void (*func_)(GtkObjType* ,P1,P2,P3,P4,P5,P6)=0); 
     void operator()(P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6);
  };

template<class GtkObjType,class P1,class P2,class P3,class P4,class P5,class P6>
  void Signal_proxy6 <GtkObjType,P1,P2,P3,P4,P5,P6>::operator()(P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
  {int rval;
   if (func) 
      func((GtkObjType*)sender->gtkobj() ,p1,p2,p3,p4,p5,p6); 
    else 
      gtk_signal_emit_by_name(sender->gtkobj(),signal_name ,p1,p2,p3,p4,p5,p6,&rval); 
   
  }

template<class GtkObjType,class P1,class P2,class P3,class P4,class P5,class P6>
  Signal_proxy6 <GtkObjType,P1,P2,P3,P4,P5,P6>::Signal_proxy6
    (const gchar *name, Gtk_Object *obj, void (*func_)(GtkObjType* ,P1,P2,P3,P4,P5,P6))
    : Signal_proxy_base(name,obj), func(func_)
  {}


/*** connect_to_method 6 args ***/
template<class GtkObjType,class T,class P1,class P2,class P3,class P4,class P5,class P6>
  Connection connect_to_method(
    Signal_proxy6 <GtkObjType,P1,P2,P3,P4,P5,P6> &proxy,
    T *receiver,void (T::*method)(P1,P2,P3,P4,P5,P6)  )
  {Connection_impl* slot = 
     new Slot6<T,P1,P2,P3,P4,P5,P6>(receiver,method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot6<T,P1,P2,P3,P4,P5,P6>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_method 6 args,cbdata ***/
template<class GtkObjType,class T,class P1,class P2,class P3,class P4,class P5,class P6,class E>
  Connection connect_to_method(
    Signal_proxy6 <GtkObjType,P1,P2,P3,P4,P5,P6> &proxy,
    T *receiver,void (T::*method)(P1,P2,P3,P4,P5,P6,E) ,E arg )
  {Connection_impl* slot = 
     new Slot6cb<T,P1,P2,P3,P4,P5,P6,E>(receiver,method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot6cb<T,P1,P2,P3,P4,P5,P6,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 6 args ***/
template<class GtkObjType,class P1,class P2,class P3,class P4,class P5,class P6>
  Connection connect_to_function(
    Signal_proxy6 <GtkObjType,P1,P2,P3,P4,P5,P6> &proxy, 
    void (*method)(P1,P2,P3,P4,P5,P6) )
  { Connection_impl* slot=
      new Concretegtkslot6<void (*)(P1,P2,P3,P4,P5,P6),P1,P2,P3,P4,P5,P6>(method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot6<void (*)(P1,P2,P3,P4,P5,P6),P1,P2,P3,P4,P5,P6>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 6 args,cbdata ***/
template<class GtkObjType,class P1,class P2,class P3,class P4,class P5,class P6,class E>
  Connection connect_to_function(
    Signal_proxy6 <GtkObjType,P1,P2,P3,P4,P5,P6> &proxy, 
    void (*method)(P1,P2,P3,P4,P5,P6,E) ,E arg)
  { Connection_impl* slot=
      new Concretegtkslot6cb<void (*)(P1,P2,P3,P4,P5,P6,E),P1,P2,P3,P4,P5,P6,E>(method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot6cb<void (*)(P1,P2,P3,P4,P5,P6,E),P1,P2,P3,P4,P5,P6,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_signal 6 args ***/
template<class GtkObjType,class M,class P1,class P2,class P3,class P4,class P5,class P6>
  Connection connect_to_signal(
    Signal_proxy6 <GtkObjType,P1,P2,P3,P4,P5,P6> &proxy,
    M &func )
  { Connection_impl* slot = 
      new Concretegtkslot6<M&,P1,P2,P3,P4,P5,P6>(func );
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot6<M&,P1,P2,P3,P4,P5,P6>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }


/*** connect_to_signal 6 args,cbdata ***/
template<class GtkObjType,class M,class P1,class P2,class P3,class P4,class P5,class P6,class E>
  Connection connect_to_signal(
    Signal_proxy6 <GtkObjType,P1,P2,P3,P4,P5,P6> &proxy,
    M &func ,E arg)
  { Connection_impl* slot = 
      new Concretegtkslot6cb<M&,P1,P2,P3,P4,P5,P6,E>(func ,arg);
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot6cb<M&,P1,P2,P3,P4,P5,P6,E>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }


/********************************************************************
*****  Signal_Proxy with 6 Arguments,return type
********************************************************************/
template<class rettype,class GtkObjType,class P1,class P2,class P3,class P4,class P5,class P6>
  class Signal_proxy6_r : public Signal_proxy_base
  {  rettype (*func)(GtkObjType* ,P1,P2,P3,P4,P5,P6);
   public:
     Signal_proxy6_r (const gchar *name, Gtk_Object *obj,
        rettype (*func_)(GtkObjType* ,P1,P2,P3,P4,P5,P6)=0); 
     rettype operator()(P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6);
  };

template<class rettype,class GtkObjType,class P1,class P2,class P3,class P4,class P5,class P6>
  rettype Signal_proxy6_r <rettype,GtkObjType,P1,P2,P3,P4,P5,P6>::operator()(P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
  {rettype rval;
   if (func) 
      rval=func((GtkObjType*)sender->gtkobj() ,p1,p2,p3,p4,p5,p6); 
    else 
      gtk_signal_emit_by_name(sender->gtkobj(),signal_name ,p1,p2,p3,p4,p5,p6,&rval); 
   return rval;
  }

template<class rettype,class GtkObjType,class P1,class P2,class P3,class P4,class P5,class P6>
  Signal_proxy6_r <rettype,GtkObjType,P1,P2,P3,P4,P5,P6>::Signal_proxy6_r
    (const gchar *name, Gtk_Object *obj, rettype (*func_)(GtkObjType* ,P1,P2,P3,P4,P5,P6))
    : Signal_proxy_base(name,obj), func(func_)
  {}


/*** connect_to_method 6 args,return type ***/
template<class rettype,class GtkObjType,class T,class P1,class P2,class P3,class P4,class P5,class P6>
  Connection connect_to_method(
    Signal_proxy6_r <rettype,GtkObjType,P1,P2,P3,P4,P5,P6> &proxy,
    T *receiver,rettype (T::*method)(P1,P2,P3,P4,P5,P6)  )
  {Connection_impl* slot = 
     new Slot6_r<rettype,T,P1,P2,P3,P4,P5,P6>(receiver,method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot6_r<rettype,T,P1,P2,P3,P4,P5,P6>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_method 6 args,cbdata,return type ***/
template<class rettype,class GtkObjType,class T,class P1,class P2,class P3,class P4,class P5,class P6,class E>
  Connection connect_to_method(
    Signal_proxy6_r <rettype,GtkObjType,P1,P2,P3,P4,P5,P6> &proxy,
    T *receiver,rettype (T::*method)(P1,P2,P3,P4,P5,P6,E) ,E arg )
  {Connection_impl* slot = 
     new Slot6cb_r<rettype,T,P1,P2,P3,P4,P5,P6,E>(receiver,method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()), const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Slot6cb_r<rettype,T,P1,P2,P3,P4,P5,P6,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 6 args,return type ***/
template<class rettype,class GtkObjType,class P1,class P2,class P3,class P4,class P5,class P6>
  Connection connect_to_function(
    Signal_proxy6_r <rettype,GtkObjType,P1,P2,P3,P4,P5,P6> &proxy, 
    rettype (*method)(P1,P2,P3,P4,P5,P6) )
  { Connection_impl* slot=
      new Concretegtkslot6_r<rettype,rettype (*)(P1,P2,P3,P4,P5,P6),P1,P2,P3,P4,P5,P6>(method );
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot6_r<rettype,rettype (*)(P1,P2,P3,P4,P5,P6),P1,P2,P3,P4,P5,P6>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_function 6 args,cbdata,return type ***/
template<class rettype,class GtkObjType,class P1,class P2,class P3,class P4,class P5,class P6,class E>
  Connection connect_to_function(
    Signal_proxy6_r <rettype,GtkObjType,P1,P2,P3,P4,P5,P6> &proxy, 
    rettype (*method)(P1,P2,P3,P4,P5,P6,E) ,E arg)
  { Connection_impl* slot=
      new Concretegtkslot6cb_r<rettype,rettype (*)(P1,P2,P3,P4,P5,P6,E),P1,P2,P3,P4,P5,P6,E>(method ,arg);
   proxy.sender->insert_connection(slot);
   gint conn;
   conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),const_cast<gchar*>(proxy.signal_name), 
     GtkSignalFunc(Concretegtkslot6cb_r<rettype,rettype (*)(P1,P2,P3,P4,P5,P6,E),P1,P2,P3,P4,P5,P6,E>::callback),slot);
   slot->setgtkconnection(proxy.sender->gtkobj(),conn);
   return Connection(slot);
  }


/*** connect_to_signal 6 args,return type ***/
template<class rettype,class GtkObjType,class M,class P1,class P2,class P3,class P4,class P5,class P6>
  Connection connect_to_signal(
    Signal_proxy6_r <rettype,GtkObjType,P1,P2,P3,P4,P5,P6> &proxy,
    M &func )
  { Connection_impl* slot = 
      new Concretegtkslot6_r<rettype,M&,P1,P2,P3,P4,P5,P6>(func );
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot6_r<rettype,M&,P1,P2,P3,P4,P5,P6>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }


/*** connect_to_signal 6 args,cbdata,return type ***/
template<class rettype,class GtkObjType,class M,class P1,class P2,class P3,class P4,class P5,class P6,class E>
  Connection connect_to_signal(
    Signal_proxy6_r <rettype,GtkObjType,P1,P2,P3,P4,P5,P6> &proxy,
    M &func ,E arg)
  { Connection_impl* slot = 
      new Concretegtkslot6cb_r<rettype,M&,P1,P2,P3,P4,P5,P6,E>(func ,arg);
    proxy.sender->insert_connection(slot);
    gint conn;
    conn=gtk_signal_connect(GTK_OBJECT(proxy.sender->gtkobj()),proxy.signal_name, 
      GtkSignalFunc(Concretegtkslot6cb_r<rettype,M&,P1,P2,P3,P4,P5,P6,E>::callback),slot);
    slot->setgtkconnection(proxy.sender->gtkobj(),conn);
    return Connection(slot);
  }




#endif

