Main Page Groups Namespaces

# Compatibility module

This set of types and functions provides an API that is compatible to libsigc++-1.2. More...

## Compounds
class | Signal0
| Signal declaration. More...
class | Signal1
| Signal declaration. More...
class | Signal2
| Signal declaration. More...
class | Signal3
| Signal declaration. More...
class | Signal4
| Signal declaration. More...
class | Signal5
| Signal declaration. More...
class | Signal6
| Signal declaration. More...
class | Signal7
| Signal declaration. More...
class | Slot0
| Converts an arbitrary functor to a unified type which is opaque. More...
class | Slot1
| Converts an arbitrary functor to a unified type which is opaque. More...
class | Slot2
| Converts an arbitrary functor to a unified type which is opaque. More...
class | Slot3
| Converts an arbitrary functor to a unified type which is opaque. More...
class | Slot4
| Converts an arbitrary functor to a unified type which is opaque. More...
class | Slot5
| Converts an arbitrary functor to a unified type which is opaque. More...
class | Slot6
| Converts an arbitrary functor to a unified type which is opaque. More...
class | Slot7
| Converts an arbitrary functor to a unified type which is opaque. More...
## Functions
template <class T_return, class T_obj> Slot0<T_return> | SigC::slot_class (T_obj& _A_obj, T_return(T_obj::* _A_func)())
| Creates a functor of type SigC::Slot0 that encapsulates a method and an object instance.
template <class T_return, class T_arg1, class T_obj> Slot1<T_return, T_arg1> | SigC::slot_class (T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1))
| Creates a functor of type SigC::Slot1 that encapsulates a method and an object instance.
template <class T_return, class T_arg1, class T_arg2, class T_obj> Slot2<T_return, T_arg1, T_arg2> | SigC::slot_class (T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2))
| Creates a functor of type SigC::Slot2 that encapsulates a method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj> Slot3< T_return, T_arg1, T_arg2, T_arg3 > | SigC::slot_class (T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3))
| Creates a functor of type SigC::Slot3 that encapsulates a method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj> Slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 > | SigC::slot_class (T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))
| Creates a functor of type SigC::Slot4 that encapsulates a method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj> Slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > | SigC::slot_class (T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))
| Creates a functor of type SigC::Slot5 that encapsulates a method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj> Slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > | SigC::slot_class (T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))
| Creates a functor of type SigC::Slot6 that encapsulates a method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_obj> Slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > | SigC::slot_class (T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))
| Creates a functor of type SigC::Slot7 that encapsulates a method and an object instance.
template <class T_return, class T_obj> Slot0<T_return> | SigC::slot_class (const T_obj& _A_obj, T_return(T_obj::* _A_func)() const)
| Creates a functor of type SigC::Slot0 that encapsulates a const method and an object instance.
template <class T_return, class T_arg1, class T_obj> Slot1<T_return, T_arg1> | SigC::slot_class (const T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1) const)
| Creates a functor of type SigC::Slot1 that encapsulates a const method and an object instance.
template <class T_return, class T_arg1, class T_arg2, class T_obj> Slot2<T_return, T_arg1, T_arg2> | SigC::slot_class (const T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2) const)
| Creates a functor of type SigC::Slot2 that encapsulates a const method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj> Slot3< T_return, T_arg1, T_arg2, T_arg3 > | SigC::slot_class (const T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3) const)
| Creates a functor of type SigC::Slot3 that encapsulates a const method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj> Slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 > | SigC::slot_class (const T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
| Creates a functor of type SigC::Slot4 that encapsulates a const method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj> Slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > | SigC::slot_class (const T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
| Creates a functor of type SigC::Slot5 that encapsulates a const method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj> Slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > | SigC::slot_class (const T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
| Creates a functor of type SigC::Slot6 that encapsulates a const method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_obj> Slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > | SigC::slot_class (const T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
| Creates a functor of type SigC::Slot7 that encapsulates a const method and an object instance.
template <class T_return, class T_obj> Slot0<T_return> | SigC::slot_class (T_obj& _A_obj, T_return(T_obj::* _A_func)() volatile)
| Creates a functor of type SigC::Slot0 that encapsulates a volatile method and an object instance.
template <class T_return, class T_arg1, class T_obj> Slot1<T_return, T_arg1> | SigC::slot_class (T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1) volatile)
| Creates a functor of type SigC::Slot1 that encapsulates a volatile method and an object instance.
template <class T_return, class T_arg1, class T_arg2, class T_obj> Slot2<T_return, T_arg1, T_arg2> | SigC::slot_class (T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2) volatile)
| Creates a functor of type SigC::Slot2 that encapsulates a volatile method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj> Slot3< T_return, T_arg1, T_arg2, T_arg3 > | SigC::slot_class (T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3) volatile)
| Creates a functor of type SigC::Slot3 that encapsulates a volatile method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj> Slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 > | SigC::slot_class (T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
| Creates a functor of type SigC::Slot4 that encapsulates a volatile method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj> Slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > | SigC::slot_class (T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
| Creates a functor of type SigC::Slot5 that encapsulates a volatile method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj> Slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > | SigC::slot_class (T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
| Creates a functor of type SigC::Slot6 that encapsulates a volatile method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_obj> Slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > | SigC::slot_class (T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
| Creates a functor of type SigC::Slot7 that encapsulates a volatile method and an object instance.
template <class T_return, class T_obj> Slot0<T_return> | SigC::slot_class (const T_obj& _A_obj, T_return(T_obj::* _A_func)() const volatile)
| Creates a functor of type SigC::Slot0 that encapsulates a const volatile method and an object instance.
template <class T_return, class T_arg1, class T_obj> Slot1<T_return, T_arg1> | SigC::slot_class (const T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1) const volatile)
| Creates a functor of type SigC::Slot1 that encapsulates a const volatile method and an object instance.
template <class T_return, class T_arg1, class T_arg2, class T_obj> Slot2<T_return, T_arg1, T_arg2> | SigC::slot_class (const T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2) const volatile)
| Creates a functor of type SigC::Slot2 that encapsulates a const volatile method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj> Slot3< T_return, T_arg1, T_arg2, T_arg3 > | SigC::slot_class (const T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3) const volatile)
| Creates a functor of type SigC::Slot3 that encapsulates a const volatile method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj> Slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 > | SigC::slot_class (const T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
| Creates a functor of type SigC::Slot4 that encapsulates a const volatile method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj> Slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > | SigC::slot_class (const T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
| Creates a functor of type SigC::Slot5 that encapsulates a const volatile method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj> Slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > | SigC::slot_class (const T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
| Creates a functor of type SigC::Slot6 that encapsulates a const volatile method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_obj> Slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > | SigC::slot_class (const T_obj& _A_obj, T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
| Creates a functor of type SigC::Slot7 that encapsulates a const volatile method and an object instance.
template <class T_return, class T_obj> Slot1<T_return, T_obj&> | SigC::slot (T_return(T_obj::* _A_func)())
| Creates a functor of type Sigc::Slot1 that wraps a method.
template<class T_return, class T_arg1, class T_obj> Slot2< T_return, T_obj &, T_arg1 > | SigC::slot (T_return(T_obj::* _A_func)(T_arg1))
| Creates a functor of type Sigc::Slot2 that wraps a method.
template<class T_return, class T_arg1, class T_arg2, class T_obj> Slot3< T_return, T_obj &, T_arg1, T_arg2 > | SigC::slot (T_return(T_obj::* _A_func)(T_arg1, T_arg2))
| Creates a functor of type Sigc::Slot3 that wraps a method.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj> Slot4< T_return, T_obj &, T_arg1, T_arg2, T_arg3 > | SigC::slot (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3))
| Creates a functor of type Sigc::Slot4 that wraps a method.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj> Slot5< T_return, T_obj &, T_arg1, T_arg2, T_arg3, T_arg4 > | SigC::slot (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))
| Creates a functor of type Sigc::Slot5 that wraps a method.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj> Slot6< T_return, T_obj &, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > | SigC::slot (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))
| Creates a functor of type Sigc::Slot6 that wraps a method.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj> Slot7< T_return, T_obj &, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > | SigC::slot (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))
| Creates a functor of type Sigc::Slot7 that wraps a method.
template <class T_return, class T_obj> Slot1<T_return, T_obj&> | SigC::slot (T_return(T_obj::* _A_func)() const)
| Creates a functor of type Sigc::Slot1 that wraps a const method.
template<class T_return, class T_arg1, class T_obj> Slot2< T_return, T_obj &, T_arg1 > | SigC::slot (T_return(T_obj::* _A_func)(T_arg1) const)
| Creates a functor of type Sigc::Slot2 that wraps a const method.
template<class T_return, class T_arg1, class T_arg2, class T_obj> Slot3< T_return, T_obj &, T_arg1, T_arg2 > | SigC::slot (T_return(T_obj::* _A_func)(T_arg1, T_arg2) const)
| Creates a functor of type Sigc::Slot3 that wraps a const method.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj> Slot4< T_return, T_obj &, T_arg1, T_arg2, T_arg3 > | SigC::slot (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3) const)
| Creates a functor of type Sigc::Slot4 that wraps a const method.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj> Slot5< T_return, T_obj &, T_arg1, T_arg2, T_arg3, T_arg4 > | SigC::slot (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
| Creates a functor of type Sigc::Slot5 that wraps a const method.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj> Slot6< T_return, T_obj &, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > | SigC::slot (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
| Creates a functor of type Sigc::Slot6 that wraps a const method.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj> Slot7< T_return, T_obj &, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > | SigC::slot (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
| Creates a functor of type Sigc::Slot7 that wraps a const method.
template <class T_return, class T_obj> Slot1<T_return, T_obj&> | SigC::slot (T_return(T_obj::* _A_func)() volatile)
| Creates a functor of type Sigc::Slot1 that wraps a const volatile method.
template<class T_return, class T_arg1, class T_obj> Slot2< T_return, T_obj &, T_arg1 > | SigC::slot (T_return(T_obj::* _A_func)(T_arg1) volatile)
| Creates a functor of type Sigc::Slot2 that wraps a const volatile method.
template<class T_return, class T_arg1, class T_arg2, class T_obj> Slot3< T_return, T_obj &, T_arg1, T_arg2 > | SigC::slot (T_return(T_obj::* _A_func)(T_arg1, T_arg2) volatile)
| Creates a functor of type Sigc::Slot3 that wraps a const volatile method.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj> Slot4< T_return, T_obj &, T_arg1, T_arg2, T_arg3 > | SigC::slot (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3) volatile)
| Creates a functor of type Sigc::Slot4 that wraps a const volatile method.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj> Slot5< T_return, T_obj &, T_arg1, T_arg2, T_arg3, T_arg4 > | SigC::slot (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
| Creates a functor of type Sigc::Slot5 that wraps a const volatile method.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj> Slot6< T_return, T_obj &, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > | SigC::slot (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
| Creates a functor of type Sigc::Slot6 that wraps a const volatile method.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj> Slot7< T_return, T_obj &, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > | SigC::slot (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
| Creates a functor of type Sigc::Slot7 that wraps a const volatile method.
template <class T_return, class T_obj1, class T_obj2> Slot0<T_return> | SigC::slot (T_obj1& _A_obj, T_return(T_obj2::* _A_func)())
| Creates a functor of type SigC::Slot0 that encapsulates a method and an object instance.
template <class T_return, class T_arg1, class T_obj1, class T_obj2> Slot1<T_return, T_arg1> | SigC::slot (T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1))
| Creates a functor of type SigC::Slot1 that encapsulates a method and an object instance.
template <class T_return, class T_arg1, class T_arg2, class T_obj1, class T_obj2> Slot2<T_return, T_arg1, T_arg2> | SigC::slot (T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2))
| Creates a functor of type SigC::Slot2 that encapsulates a method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj1, class T_obj2> Slot3< T_return, T_arg1, T_arg2, T_arg3 > | SigC::slot (T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3))
| Creates a functor of type SigC::Slot3 that encapsulates a method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj1, class T_obj2> Slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 > | SigC::slot (T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))
| Creates a functor of type SigC::Slot4 that encapsulates a method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj1, class T_obj2> Slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > | SigC::slot (T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))
| Creates a functor of type SigC::Slot5 that encapsulates a method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj1, class T_obj2> Slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > | SigC::slot (T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))
| Creates a functor of type SigC::Slot6 that encapsulates a method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_obj1, class T_obj2> Slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > | SigC::slot (T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))
| Creates a functor of type SigC::Slot7 that encapsulates a method and an object instance.
template <class T_return, class T_obj1, class T_obj2> Slot0<T_return> | SigC::slot (const T_obj1& _A_obj, T_return(T_obj2::* _A_func)() const)
| Creates a functor of type SigC::Slot0 that encapsulates a const method and an object instance.
template <class T_return, class T_arg1, class T_obj1, class T_obj2> Slot1<T_return, T_arg1> | SigC::slot (const T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1) const)
| Creates a functor of type SigC::Slot1 that encapsulates a const method and an object instance.
template <class T_return, class T_arg1, class T_arg2, class T_obj1, class T_obj2> Slot2<T_return, T_arg1, T_arg2> | SigC::slot (const T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) const)
| Creates a functor of type SigC::Slot2 that encapsulates a const method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj1, class T_obj2> Slot3< T_return, T_arg1, T_arg2, T_arg3 > | SigC::slot (const T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) const)
| Creates a functor of type SigC::Slot3 that encapsulates a const method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj1, class T_obj2> Slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 > | SigC::slot (const T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const)
| Creates a functor of type SigC::Slot4 that encapsulates a const method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj1, class T_obj2> Slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > | SigC::slot (const T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const)
| Creates a functor of type SigC::Slot5 that encapsulates a const method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj1, class T_obj2> Slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > | SigC::slot (const T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const)
| Creates a functor of type SigC::Slot6 that encapsulates a const method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_obj1, class T_obj2> Slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > | SigC::slot (const T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const)
| Creates a functor of type SigC::Slot7 that encapsulates a const method and an object instance.
template <class T_return, class T_obj1, class T_obj2> Slot0<T_return> | SigC::slot (T_obj1& _A_obj, T_return(T_obj2::* _A_func)() volatile)
| Creates a functor of type SigC::Slot0 that encapsulates a volatile method and an object instance.
template <class T_return, class T_arg1, class T_obj1, class T_obj2> Slot1<T_return, T_arg1> | SigC::slot (T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1) volatile)
| Creates a functor of type SigC::Slot1 that encapsulates a volatile method and an object instance.
template <class T_return, class T_arg1, class T_arg2, class T_obj1, class T_obj2> Slot2<T_return, T_arg1, T_arg2> | SigC::slot (T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) volatile)
| Creates a functor of type SigC::Slot2 that encapsulates a volatile method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj1, class T_obj2> Slot3< T_return, T_arg1, T_arg2, T_arg3 > | SigC::slot (T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) volatile)
| Creates a functor of type SigC::Slot3 that encapsulates a volatile method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj1, class T_obj2> Slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 > | SigC::slot (T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile)
| Creates a functor of type SigC::Slot4 that encapsulates a volatile method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj1, class T_obj2> Slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > | SigC::slot (T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile)
| Creates a functor of type SigC::Slot5 that encapsulates a volatile method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj1, class T_obj2> Slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > | SigC::slot (T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile)
| Creates a functor of type SigC::Slot6 that encapsulates a volatile method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_obj1, class T_obj2> Slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > | SigC::slot (T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile)
| Creates a functor of type SigC::Slot7 that encapsulates a volatile method and an object instance.
template <class T_return, class T_obj1, class T_obj2> Slot0<T_return> | SigC::slot (const T_obj1& _A_obj, T_return(T_obj2::* _A_func)() const volatile)
| Creates a functor of type SigC::Slot0 that encapsulates a const volatile method and an object instance.
template <class T_return, class T_arg1, class T_obj1, class T_obj2> Slot1<T_return, T_arg1> | SigC::slot (const T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1) const volatile)
| Creates a functor of type SigC::Slot1 that encapsulates a const volatile method and an object instance.
template <class T_return, class T_arg1, class T_arg2, class T_obj1, class T_obj2> Slot2<T_return, T_arg1, T_arg2> | SigC::slot (const T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2) const volatile)
| Creates a functor of type SigC::Slot2 that encapsulates a const volatile method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj1, class T_obj2> Slot3< T_return, T_arg1, T_arg2, T_arg3 > | SigC::slot (const T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3) const volatile)
| Creates a functor of type SigC::Slot3 that encapsulates a const volatile method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj1, class T_obj2> Slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 > | SigC::slot (const T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile)
| Creates a functor of type SigC::Slot4 that encapsulates a const volatile method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj1, class T_obj2> Slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > | SigC::slot (const T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile)
| Creates a functor of type SigC::Slot5 that encapsulates a const volatile method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj1, class T_obj2> Slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > | SigC::slot (const T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile)
| Creates a functor of type SigC::Slot6 that encapsulates a const volatile method and an object instance.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_obj1, class T_obj2> Slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > | SigC::slot (const T_obj1& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile)
| Creates a functor of type SigC::Slot7 that encapsulates a const volatile method and an object instance.
template <class T_return> Slot0<T_return> | SigC::slot (T_return(* _A_func)())
| Creates a functor of type SigC::Slot0 that wraps an existing non-member function.
template <class T_return, class T_arg1> Slot1<T_return, T_arg1> | SigC::slot (T_return(* _A_func)(T_arg1))
| Creates a functor of type SigC::Slot1 that wraps an existing non-member function.
template <class T_return, class T_arg1, class T_arg2> Slot2<T_return, T_arg1, T_arg2> | SigC::slot (T_return(* _A_func)(T_arg1, T_arg2))
| Creates a functor of type SigC::Slot2 that wraps an existing non-member function.
template<class T_return, class T_arg1, class T_arg2, class T_arg3> Slot3< T_return, T_arg1, T_arg2, T_arg3 > | SigC::slot (T_return(* _A_func)(T_arg1, T_arg2, T_arg3))
| Creates a functor of type SigC::Slot3 that wraps an existing non-member function.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4> Slot4< T_return, T_arg1, T_arg2, T_arg3, T_arg4 > | SigC::slot (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4))
| Creates a functor of type SigC::Slot4 that wraps an existing non-member function.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5> Slot5< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 > | SigC::slot (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5))
| Creates a functor of type SigC::Slot5 that wraps an existing non-member function.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6> Slot6< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 > | SigC::slot (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6))
| Creates a functor of type SigC::Slot6 that wraps an existing non-member function.
template<class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7> Slot7< T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > | SigC::slot (T_return(* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7))
| Creates a functor of type SigC::Slot7 that wraps an existing non-member function.

## Detailed Description

This set of types and functions provides an API that is compatible to libsigc++-1.2.

Some internal structures of libsigc++-1.2 are not available.

All types and functions that are defined in namespace SigC are deprecated. Use the new libsigc++2 API that is defined in namespace sigc.

## Function Documentation

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> slot | ( | T_return(* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) | ) | `[inline]`

  | Creates a functor of type SigC::Slot7 that wraps an existing non-member function. This function is part of the compatibility module and therefore deprecated. Use sigc::ptr_fun() instead. Parameters:
  _A_func | Pointer to function that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::ptr_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot | ( | T_return(* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) | ) | `[inline]`

  | Creates a functor of type SigC::Slot6 that wraps an existing non-member function. This function is part of the compatibility module and therefore deprecated. Use sigc::ptr_fun() instead. Parameters:
  _A_func | Pointer to function that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::ptr_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot | ( | T_return(* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) | ) | `[inline]`

  | Creates a functor of type SigC::Slot5 that wraps an existing non-member function. This function is part of the compatibility module and therefore deprecated. Use sigc::ptr_fun() instead. Parameters:
  _A_func | Pointer to function that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::ptr_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> slot | ( | T_return(* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) | ) | `[inline]`

  | Creates a functor of type SigC::Slot4 that wraps an existing non-member function. This function is part of the compatibility module and therefore deprecated. Use sigc::ptr_fun() instead. Parameters:
  _A_func | Pointer to function that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::ptr_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3>
Slot3<T_return, T_arg1,T_arg2,T_arg3> slot | ( | T_return(* | _A_func)(T_arg1, T_arg2, T_arg3) | ) | `[inline]`

  | Creates a functor of type SigC::Slot3 that wraps an existing non-member function. This function is part of the compatibility module and therefore deprecated. Use sigc::ptr_fun() instead. Parameters:
  _A_func | Pointer to function that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::ptr_fun() instead.

template <class T_return, class T_arg1, class T_arg2>
Slot2<T_return, T_arg1,T_arg2> slot | ( | T_return(* | _A_func)(T_arg1, T_arg2) | ) | `[inline]`

  | Creates a functor of type SigC::Slot2 that wraps an existing non-member function. This function is part of the compatibility module and therefore deprecated. Use sigc::ptr_fun() instead. Parameters:
  _A_func | Pointer to function that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::ptr_fun() instead.

template <class T_return, class T_arg1>
Slot1<T_return, T_arg1> slot | ( | T_return(* | _A_func)(T_arg1) | ) | `[inline]`

  | Creates a functor of type SigC::Slot1 that wraps an existing non-member function. This function is part of the compatibility module and therefore deprecated. Use sigc::ptr_fun() instead. Parameters:
  _A_func | Pointer to function that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::ptr_fun() instead.

template <class T_return>
Slot0<T_return> slot | ( | T_return(* | _A_func)() | ) | `[inline]`

  | Creates a functor of type SigC::Slot0 that wraps an existing non-member function. This function is part of the compatibility module and therefore deprecated. Use sigc::ptr_fun() instead. Parameters:
  _A_func | Pointer to function that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::ptr_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_obj1, class T_obj2>
Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> slot | ( | const T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot7 that encapsulates a const volatile method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj1, class T_obj2>
Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot | ( | const T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot6 that encapsulates a const volatile method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj1, class T_obj2>
Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot | ( | const T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot5 that encapsulates a const volatile method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj1, class T_obj2>
Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> slot | ( | const T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot4 that encapsulates a const volatile method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj1, class T_obj2>
Slot3<T_return, T_arg1,T_arg2,T_arg3> slot | ( | const T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2, T_arg3) const volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot3 that encapsulates a const volatile method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_obj1, class T_obj2>
Slot2<T_return, T_arg1,T_arg2> slot | ( | const T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2) const volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot2 that encapsulates a const volatile method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_obj1, class T_obj2>
Slot1<T_return, T_arg1> slot | ( | const T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1) const volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot1 that encapsulates a const volatile method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_obj1, class T_obj2>
Slot0<T_return> slot | ( | const T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)() const volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot0 that encapsulates a const volatile method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_obj1, class T_obj2>
Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> slot | ( | T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot7 that encapsulates a volatile method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj1, class T_obj2>
Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot | ( | T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot6 that encapsulates a volatile method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj1, class T_obj2>
Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot | ( | T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot5 that encapsulates a volatile method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj1, class T_obj2>
Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> slot | ( | T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot4 that encapsulates a volatile method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj1, class T_obj2>
Slot3<T_return, T_arg1,T_arg2,T_arg3> slot | ( | T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2, T_arg3) volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot3 that encapsulates a volatile method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_obj1, class T_obj2>
Slot2<T_return, T_arg1,T_arg2> slot | ( | T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2) volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot2 that encapsulates a volatile method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_obj1, class T_obj2>
Slot1<T_return, T_arg1> slot | ( | T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1) volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot1 that encapsulates a volatile method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_obj1, class T_obj2>
Slot0<T_return> slot | ( | T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)() volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot0 that encapsulates a volatile method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_obj1, class T_obj2>
Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> slot | ( | const T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const
| ) | `[inline]`

  | Creates a functor of type SigC::Slot7 that encapsulates a const method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj1, class T_obj2>
Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot | ( | const T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const
| ) | `[inline]`

  | Creates a functor of type SigC::Slot6 that encapsulates a const method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj1, class T_obj2>
Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot | ( | const T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const
| ) | `[inline]`

  | Creates a functor of type SigC::Slot5 that encapsulates a const method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj1, class T_obj2>
Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> slot | ( | const T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const
| ) | `[inline]`

  | Creates a functor of type SigC::Slot4 that encapsulates a const method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj1, class T_obj2>
Slot3<T_return, T_arg1,T_arg2,T_arg3> slot | ( | const T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2, T_arg3) const
| ) | `[inline]`

  | Creates a functor of type SigC::Slot3 that encapsulates a const method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_obj1, class T_obj2>
Slot2<T_return, T_arg1,T_arg2> slot | ( | const T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2) const
| ) | `[inline]`

  | Creates a functor of type SigC::Slot2 that encapsulates a const method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_obj1, class T_obj2>
Slot1<T_return, T_arg1> slot | ( | const T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1) const
| ) | `[inline]`

  | Creates a functor of type SigC::Slot1 that encapsulates a const method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_obj1, class T_obj2>
Slot0<T_return> slot | ( | const T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)() const
| ) | `[inline]`

  | Creates a functor of type SigC::Slot0 that encapsulates a const method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_obj1, class T_obj2>
Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> slot | ( | T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)
| ) | `[inline]`

  | Creates a functor of type SigC::Slot7 that encapsulates a method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj1, class T_obj2>
Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot | ( | T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)
| ) | `[inline]`

  | Creates a functor of type SigC::Slot6 that encapsulates a method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj1, class T_obj2>
Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot | ( | T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)
| ) | `[inline]`

  | Creates a functor of type SigC::Slot5 that encapsulates a method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj1, class T_obj2>
Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> slot | ( | T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4)
| ) | `[inline]`

  | Creates a functor of type SigC::Slot4 that encapsulates a method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj1, class T_obj2>
Slot3<T_return, T_arg1,T_arg2,T_arg3> slot | ( | T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2, T_arg3)
| ) | `[inline]`

  | Creates a functor of type SigC::Slot3 that encapsulates a method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_obj1, class T_obj2>
Slot2<T_return, T_arg1,T_arg2> slot | ( | T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1, T_arg2)
| ) | `[inline]`

  | Creates a functor of type SigC::Slot2 that encapsulates a method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_obj1, class T_obj2>
Slot1<T_return, T_arg1> slot | ( | T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)(T_arg1)
| ) | `[inline]`

  | Creates a functor of type SigC::Slot1 that encapsulates a method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_obj1, class T_obj2>
Slot0<T_return> slot | ( | T_obj1& | _A_obj,
|  | T_return(T_obj2::* | _A_func)()
| ) | `[inline]`

  | Creates a functor of type SigC::Slot0 that encapsulates a method and an object instance. _A_obj must be of a type that inherits SigC::Object. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj>
Slot7<T_return, T_obj &, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> SigC::slot | ( | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile | ) | `[inline]`

  | Creates a functor of type Sigc::Slot7 that wraps a const volatile method. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj>
Slot6<T_return, T_obj &, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> SigC::slot | ( | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile | ) | `[inline]`

  | Creates a functor of type Sigc::Slot6 that wraps a const volatile method. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj>
Slot5<T_return, T_obj &, T_arg1, T_arg2, T_arg3, T_arg4> SigC::slot | ( | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile | ) | `[inline]`

  | Creates a functor of type Sigc::Slot5 that wraps a const volatile method. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj>
Slot4<T_return, T_obj &, T_arg1, T_arg2, T_arg3> SigC::slot | ( | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3) volatile | ) | `[inline]`

  | Creates a functor of type Sigc::Slot4 that wraps a const volatile method. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation.

template <class T_return, class T_arg1, class T_arg2, class T_obj>
Slot3<T_return, T_obj &, T_arg1, T_arg2> SigC::slot | ( | T_return(T_obj::* | _A_func)(T_arg1, T_arg2) volatile | ) | `[inline]`

  | Creates a functor of type Sigc::Slot3 that wraps a const volatile method. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation.

template <class T_return, class T_arg1, class T_obj>
Slot2<T_return, T_obj &, T_arg1> SigC::slot | ( | T_return(T_obj::* | _A_func)(T_arg1) volatile | ) | `[inline]`

  | Creates a functor of type Sigc::Slot2 that wraps a const volatile method. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation.

template <class T_return, class T_obj>
Slot1<T_return, T_obj&> SigC::slot | ( | T_return(T_obj::* | _A_func)() volatile | ) | `[inline]`

  | Creates a functor of type Sigc::Slot1 that wraps a const volatile method. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj>
Slot7<T_return, T_obj&, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot | ( | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const | ) | `[inline]`

  | Creates a functor of type Sigc::Slot7 that wraps a const method. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj>
Slot6<T_return, T_obj&, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot | ( | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const | ) | `[inline]`

  | Creates a functor of type Sigc::Slot6 that wraps a const method. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj>
Slot5<T_return, T_obj&, T_arg1,T_arg2,T_arg3,T_arg4> slot | ( | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const | ) | `[inline]`

  | Creates a functor of type Sigc::Slot5 that wraps a const method. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj>
Slot4<T_return, T_obj&, T_arg1,T_arg2,T_arg3> slot | ( | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3) const | ) | `[inline]`

  | Creates a functor of type Sigc::Slot4 that wraps a const method. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation.

template <class T_return, class T_arg1, class T_arg2, class T_obj>
Slot3<T_return, T_obj&, T_arg1,T_arg2> slot | ( | T_return(T_obj::* | _A_func)(T_arg1, T_arg2) const | ) | `[inline]`

  | Creates a functor of type Sigc::Slot3 that wraps a const method. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation.

template <class T_return, class T_arg1, class T_obj>
Slot2<T_return, T_obj&, T_arg1> slot | ( | T_return(T_obj::* | _A_func)(T_arg1) const | ) | `[inline]`

  | Creates a functor of type Sigc::Slot2 that wraps a const method. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation.

template <class T_return, class T_obj>
Slot1<T_return, T_obj&> slot | ( | T_return(T_obj::* | _A_func)() const | ) | `[inline]`

  | Creates a functor of type Sigc::Slot1 that wraps a const method. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj>
Slot7<T_return, T_obj&, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot | ( | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) | ) | `[inline]`

  | Creates a functor of type Sigc::Slot7 that wraps a method. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj>
Slot6<T_return, T_obj&, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot | ( | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) | ) | `[inline]`

  | Creates a functor of type Sigc::Slot6 that wraps a method. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj>
Slot5<T_return, T_obj&, T_arg1,T_arg2,T_arg3,T_arg4> slot | ( | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) | ) | `[inline]`

  | Creates a functor of type Sigc::Slot5 that wraps a method. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj>
Slot4<T_return, T_obj&, T_arg1,T_arg2,T_arg3> slot | ( | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3) | ) | `[inline]`

  | Creates a functor of type Sigc::Slot4 that wraps a method. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation.

template <class T_return, class T_arg1, class T_arg2, class T_obj>
Slot3<T_return, T_obj&, T_arg1,T_arg2> slot | ( | T_return(T_obj::* | _A_func)(T_arg1, T_arg2) | ) | `[inline]`

  | Creates a functor of type Sigc::Slot3 that wraps a method. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation.

template <class T_return, class T_arg1, class T_obj>
Slot2<T_return, T_obj&, T_arg1> slot | ( | T_return(T_obj::* | _A_func)(T_arg1) | ) | `[inline]`

  | Creates a functor of type Sigc::Slot2 that wraps a method. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation.

template <class T_return, class T_obj>
Slot1<T_return, T_obj&> slot | ( | T_return(T_obj::* | _A_func)() | ) | `[inline]`

  | Creates a functor of type Sigc::Slot1 that wraps a method. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_obj>
Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> slot_class | ( | const T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot7 that encapsulates a const volatile method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj>
Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot_class | ( | const T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot6 that encapsulates a const volatile method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj>
Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot_class | ( | const T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot5 that encapsulates a const volatile method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj>
Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> slot_class | ( | const T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot4 that encapsulates a const volatile method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj>
Slot3<T_return, T_arg1,T_arg2,T_arg3> slot_class | ( | const T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3) const volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot3 that encapsulates a const volatile method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_obj>
Slot2<T_return, T_arg1,T_arg2> slot_class | ( | const T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2) const volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot2 that encapsulates a const volatile method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_obj>
Slot1<T_return, T_arg1> slot_class | ( | const T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1) const volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot1 that encapsulates a const volatile method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_obj>
Slot0<T_return> slot_class | ( | const T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)() const volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot0 that encapsulates a const volatile method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_obj>
Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> slot_class | ( | T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot7 that encapsulates a volatile method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj>
Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot_class | ( | T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot6 that encapsulates a volatile method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj>
Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot_class | ( | T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot5 that encapsulates a volatile method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj>
Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> slot_class | ( | T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot4 that encapsulates a volatile method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj>
Slot3<T_return, T_arg1,T_arg2,T_arg3> slot_class | ( | T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3) volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot3 that encapsulates a volatile method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_obj>
Slot2<T_return, T_arg1,T_arg2> slot_class | ( | T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2) volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot2 that encapsulates a volatile method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_obj>
Slot1<T_return, T_arg1> slot_class | ( | T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1) volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot1 that encapsulates a volatile method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_obj>
Slot0<T_return> slot_class | ( | T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)() volatile
| ) | `[inline]`

  | Creates a functor of type SigC::Slot0 that encapsulates a volatile method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_obj>
Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> slot_class | ( | const T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const
| ) | `[inline]`

  | Creates a functor of type SigC::Slot7 that encapsulates a const method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj>
Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot_class | ( | const T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const
| ) | `[inline]`

  | Creates a functor of type SigC::Slot6 that encapsulates a const method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj>
Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot_class | ( | const T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5) const
| ) | `[inline]`

  | Creates a functor of type SigC::Slot5 that encapsulates a const method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj>
Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> slot_class | ( | const T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4) const
| ) | `[inline]`

  | Creates a functor of type SigC::Slot4 that encapsulates a const method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj>
Slot3<T_return, T_arg1,T_arg2,T_arg3> slot_class | ( | const T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3) const
| ) | `[inline]`

  | Creates a functor of type SigC::Slot3 that encapsulates a const method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_obj>
Slot2<T_return, T_arg1,T_arg2> slot_class | ( | const T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2) const
| ) | `[inline]`

  | Creates a functor of type SigC::Slot2 that encapsulates a const method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_obj>
Slot1<T_return, T_arg1> slot_class | ( | const T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1) const
| ) | `[inline]`

  | Creates a functor of type SigC::Slot1 that encapsulates a const method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_obj>
Slot0<T_return> slot_class | ( | const T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)() const
| ) | `[inline]`

  | Creates a functor of type SigC::Slot0 that encapsulates a const method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7, class T_obj>
Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> slot_class | ( | T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)
| ) | `[inline]`

  | Creates a functor of type SigC::Slot7 that encapsulates a method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_obj>
Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> slot_class | ( | T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6)
| ) | `[inline]`

  | Creates a functor of type SigC::Slot6 that encapsulates a method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_obj>
Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> slot_class | ( | T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5)
| ) | `[inline]`

  | Creates a functor of type SigC::Slot5 that encapsulates a method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_obj>
Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4> slot_class | ( | T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3, T_arg4)
| ) | `[inline]`

  | Creates a functor of type SigC::Slot4 that encapsulates a method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_arg3, class T_obj>
Slot3<T_return, T_arg1,T_arg2,T_arg3> slot_class | ( | T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2, T_arg3)
| ) | `[inline]`

  | Creates a functor of type SigC::Slot3 that encapsulates a method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_arg2, class T_obj>
Slot2<T_return, T_arg1,T_arg2> slot_class | ( | T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1, T_arg2)
| ) | `[inline]`

  | Creates a functor of type SigC::Slot2 that encapsulates a method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_arg1, class T_obj>
Slot1<T_return, T_arg1> slot_class | ( | T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)(T_arg1)
| ) | `[inline]`

  | Creates a functor of type SigC::Slot1 that encapsulates a method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.

template <class T_return, class T_obj>
Slot0<T_return> slot_class | ( | T_obj& | _A_obj,
|  | T_return(T_obj::* | _A_func)()
| ) | `[inline]`

  | Creates a functor of type SigC::Slot0 that encapsulates a method and an object instance. This function is part of the compatibility module and therefore deprecated. Use sigc::mem_fun() instead. Parameters:
  _A_obj | Reference to object instance the functor should operate on.
  _A_func | Pointer to method that should be wrapped.
Returns: Functor that executes _A_func on invokation. Deprecated: Use sigc::mem_fun() instead.