Sun Feb 10 01:12:35 PST 2013

1 files changed, 0 insertions, 692 deletions

diff --git a/community/visualboyadvance/1.7.2-deprecatedsigc++.patch b/community/visualboyadvance/1.7.2-deprecatedsigc++.patch
deleted file mode 100644
index 4bb1787cb..000000000
--- a/community/visualboyadvance/1.7.2-deprecatedsigc++.patch
+++ /dev/null
@@ -1,692 +0,0 @@
---- src/gtk/sigccompat.h.old	2008-05-02 10:46:45.000000000 +0200
-+++ src/gtk/sigccompat.h	2008-05-02 10:47:08.000000000 +0200
-@@ -20,7 +20,7 @@
- #ifndef __VBA_SIGCCOMPAT_H__
- #define __VBA_SIGCCOMPAT_H__
- 
--#undef LIBSIGC_DISABLE_DEPRECATED
-+#define LIBSIGC_DISABLE_DEPRECATED
- #include <sigc++/bind.h>
- #include <sigc++/connection.h>
- 
-@@ -28,9 +28,679 @@
- #include <sigc++/object.h>
- #include <sigc++/functors/mem_fun.h>
- 
--namespace SigC
-+
-+// From sigc++/bind.h
-+namespace SigC {
-+
-+template <class T_bound1, class T_functor>
-+inline ::sigc::bind_functor<-1, T_functor,
-+                            typename ::sigc::unwrap_reference<T_bound1>::type>
-+bind(const T_functor& _A_functor, T_bound1 _A_b1)
-+{ return ::sigc::bind_functor<-1, T_functor,
-+                              typename ::sigc::unwrap_reference<T_bound1>::type>
-+                              (_A_functor, _A_b1);
-+}
-+
-+template <class T_bound1, class T_bound2, class T_functor>
-+inline ::sigc::bind_functor<-1, T_functor,
-+                            typename ::sigc::unwrap_reference<T_bound1>::type,
-+                            typename ::sigc::unwrap_reference<T_bound2>::type>
-+bind(const T_functor& _A_functor, T_bound1 _A_b1, T_bound2 _A_b2)
-+{ return ::sigc::bind_functor<-1, T_functor,
-+                              typename ::sigc::unwrap_reference<T_bound1>::type,
-+                              typename ::sigc::unwrap_reference<T_bound2>::type>
-+                              (_A_functor, _A_b1, _A_b2); 
-+}
-+
-+template <class T_bound1, class T_bound2, class T_bound3, class T_functor>
-+inline ::sigc::bind_functor<-1, T_functor,
-+                            typename ::sigc::unwrap_reference<T_bound1>::type,
-+                            typename ::sigc::unwrap_reference<T_bound2>::type,
-+                            typename ::sigc::unwrap_reference<T_bound3>::type>
-+bind(const T_functor& _A_functor, T_bound1 _A_b1, T_bound2 _A_b2,T_bound3 _A_b3)
-+{ return ::sigc::bind_functor<-1, T_functor,
-+                              typename ::sigc::unwrap_reference<T_bound1>::type,
-+                              typename ::sigc::unwrap_reference<T_bound2>::type,
-+                              typename ::sigc::unwrap_reference<T_bound3>::type>
-+                              (_A_functor, _A_b1, _A_b2, _A_b3);
-+}
-+
-+}
-+
-+// From sigc++/connection.h
-+namespace SigC {
-+
-+/** Convinience class for safe disconnection.
-+ * Iterators must not be used beyond the lifetime of the list
-+ * they work on. A connection object can be created from a
-+ * slot list iterator and may safely be used to disconnect
-+ * the referred slot at any time (disconnect()). If the slot
-+ * has already been destroyed, disconnect() does nothing. empty() or
-+ * operator bool() can be used to test whether the connection is
-+ * still active. The connection can be blocked (block(), unblock()).
-+ *
-+ * This is possible because the connection object gets notified
-+ * when the referred slot dies (notify()).
-+ *
-+ * @deprecated Use sigc::connection instead.
-+ * @ingroup compat
-+ */
-+typedef ::sigc::connection Connection;
-+
-+}
-+
-+// From sigc++/slot.h
-+namespace SigC {
-+
-+// SlotN
-+/** Converts an arbitrary functor to a unified type which is opaque.
-+ * Slot0 itself is a functor or to be more precise a closure. It contains
-+ * a single, arbitrary functor (or closure) that is executed in operator()().
-+ *
-+ * The template arguments determine the function signature of operator()():
-+ * - @e T_return The return type of operator()().
-+ *
-+ * To use simply assign the slot to the desired functor. If the functor
-+ * is not compatible with the parameter list defined with the template
-+ * arguments compiler errors are triggered. When called the slot
-+ * will invoke the functor with minimal copies.
-+ * block() and unblock() can be used to block the functor's invocation
-+ * from operator()() temporarily.
-+ *
-+ * @par Example:
-+ *   @code
-+ *   #include <sigc++/slot.h>
-+ *   void foo(int) {}
-+ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
-+ *   s(19);
-+ *   @endcode
-+ *
-+ * @deprecated Use the unnumbered template sigc::slot instead.
-+ * @ingroup compat
-+ */
-+template <class T_return>
-+class Slot0
-+  : public ::sigc::slot<T_return>
-+{
-+public:
-+  typedef ::sigc::slot<T_return> parent_type;
-+
-+  /// Constructs an empty slot.
-+  Slot0() {}
-+
-+  /** Constructs a slot from an arbitrary functor.
-+   * @param _A_func The desired functor the new slot should be assigned to.
-+   */
-+  template <class T_functor>
-+  Slot0(const T_functor& _A_func)
-+    : ::sigc::slot<T_return>(_A_func) {}
-+
-+  /** Constructs a slot, copying an existing one.
-+   * @param src The existing slot to copy.
-+   */
-+  Slot0(const parent_type& src)
-+    : parent_type(src) {}
-+
-+  /** Overrides this slot making a copy from another slot.
-+   * @param src The slot from which to make a copy.
-+   * @return @p this.
-+   */
-+  Slot0& operator=(const parent_type& src)
-+    { parent_type::operator=(src); return *this; }
-+};
-+
-+/** Converts an arbitrary functor to a unified type which is opaque.
-+ * Slot1 itself is a functor or to be more precise a closure. It contains
-+ * a single, arbitrary functor (or closure) that is executed in operator()().
-+ *
-+ * The template arguments determine the function signature of operator()():
-+ * - @e T_return The return type of operator()().
-+ * - @e T_arg1 Argument type used in the definition of operator()().
-+ *
-+ * To use simply assign the slot to the desired functor. If the functor
-+ * is not compatible with the parameter list defined with the template
-+ * arguments compiler errors are triggered. When called the slot
-+ * will invoke the functor with minimal copies.
-+ * block() and unblock() can be used to block the functor's invocation
-+ * from operator()() temporarily.
-+ *
-+ * @par Example:
-+ *   @code
-+ *   #include <sigc++/slot.h>
-+ *   void foo(int) {}
-+ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
-+ *   s(19);
-+ *   @endcode
-+ *
-+ * @deprecated Use the unnumbered template sigc::slot instead.
-+ * @ingroup compat
-+ */
-+template <class T_return, class T_arg1>
-+class Slot1
-+  : public ::sigc::slot<T_return, T_arg1>
-+{
-+public:
-+  typedef ::sigc::slot<T_return, T_arg1> parent_type;
-+
-+  /// Constructs an empty slot.
-+  Slot1() {}
-+
-+  /** Constructs a slot from an arbitrary functor.
-+   * @param _A_func The desired functor the new slot should be assigned to.
-+   */
-+  template <class T_functor>
-+  Slot1(const T_functor& _A_func)
-+    : ::sigc::slot<T_return, T_arg1>(_A_func) {}
-+
-+  /** Constructs a slot, copying an existing one.
-+   * @param src The existing slot to copy.
-+   */
-+  Slot1(const parent_type& src)
-+    : parent_type(src) {}
-+
-+  /** Overrides this slot making a copy from another slot.
-+   * @param src The slot from which to make a copy.
-+   * @return @p this.
-+   */
-+  Slot1& operator=(const parent_type& src)
-+    { parent_type::operator=(src); return *this; }
-+};
-+
-+/** Converts an arbitrary functor to a unified type which is opaque.
-+ * Slot2 itself is a functor or to be more precise a closure. It contains
-+ * a single, arbitrary functor (or closure) that is executed in operator()().
-+ *
-+ * The template arguments determine the function signature of operator()():
-+ * - @e T_return The return type of operator()().
-+ * - @e T_arg1 Argument type used in the definition of operator()().
-+ * - @e T_arg2 Argument type used in the definition of operator()().
-+ *
-+ * To use simply assign the slot to the desired functor. If the functor
-+ * is not compatible with the parameter list defined with the template
-+ * arguments compiler errors are triggered. When called the slot
-+ * will invoke the functor with minimal copies.
-+ * block() and unblock() can be used to block the functor's invocation
-+ * from operator()() temporarily.
-+ *
-+ * @par Example:
-+ *   @code
-+ *   #include <sigc++/slot.h>
-+ *   void foo(int) {}
-+ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
-+ *   s(19);
-+ *   @endcode
-+ *
-+ * @deprecated Use the unnumbered template sigc::slot instead.
-+ * @ingroup compat
-+ */
-+template <class T_return, class T_arg1,class T_arg2>
-+class Slot2
-+  : public ::sigc::slot<T_return, T_arg1,T_arg2>
-+{
-+public:
-+  typedef ::sigc::slot<T_return, T_arg1,T_arg2> parent_type;
-+
-+  /// Constructs an empty slot.
-+  Slot2() {}
-+
-+  /** Constructs a slot from an arbitrary functor.
-+   * @param _A_func The desired functor the new slot should be assigned to.
-+   */
-+  template <class T_functor>
-+  Slot2(const T_functor& _A_func)
-+    : ::sigc::slot<T_return, T_arg1,T_arg2>(_A_func) {}
-+
-+  /** Constructs a slot, copying an existing one.
-+   * @param src The existing slot to copy.
-+   */
-+  Slot2(const parent_type& src)
-+    : parent_type(src) {}
-+
-+  /** Overrides this slot making a copy from another slot.
-+   * @param src The slot from which to make a copy.
-+   * @return @p this.
-+   */
-+  Slot2& operator=(const parent_type& src)
-+    { parent_type::operator=(src); return *this; }
-+};
-+
-+/** Converts an arbitrary functor to a unified type which is opaque.
-+ * Slot3 itself is a functor or to be more precise a closure. It contains
-+ * a single, arbitrary functor (or closure) that is executed in operator()().
-+ *
-+ * The template arguments determine the function signature of operator()():
-+ * - @e T_return The return type of operator()().
-+ * - @e T_arg1 Argument type used in the definition of operator()().
-+ * - @e T_arg2 Argument type used in the definition of operator()().
-+ * - @e T_arg3 Argument type used in the definition of operator()().
-+ *
-+ * To use simply assign the slot to the desired functor. If the functor
-+ * is not compatible with the parameter list defined with the template
-+ * arguments compiler errors are triggered. When called the slot
-+ * will invoke the functor with minimal copies.
-+ * block() and unblock() can be used to block the functor's invocation
-+ * from operator()() temporarily.
-+ *
-+ * @par Example:
-+ *   @code
-+ *   #include <sigc++/slot.h>
-+ *   void foo(int) {}
-+ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
-+ *   s(19);
-+ *   @endcode
-+ *
-+ * @deprecated Use the unnumbered template sigc::slot instead.
-+ * @ingroup compat
-+ */
-+template <class T_return, class T_arg1,class T_arg2,class T_arg3>
-+class Slot3
-+  : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3>
-+{
-+public:
-+  typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3> parent_type;
-+
-+  /// Constructs an empty slot.
-+  Slot3() {}
-+
-+  /** Constructs a slot from an arbitrary functor.
-+   * @param _A_func The desired functor the new slot should be assigned to.
-+   */
-+  template <class T_functor>
-+  Slot3(const T_functor& _A_func)
-+    : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3>(_A_func) {}
-+
-+  /** Constructs a slot, copying an existing one.
-+   * @param src The existing slot to copy.
-+   */
-+  Slot3(const parent_type& src)
-+    : parent_type(src) {}
-+
-+  /** Overrides this slot making a copy from another slot.
-+   * @param src The slot from which to make a copy.
-+   * @return @p this.
-+   */
-+  Slot3& operator=(const parent_type& src)
-+    { parent_type::operator=(src); return *this; }
-+};
-+
-+/** Converts an arbitrary functor to a unified type which is opaque.
-+ * Slot4 itself is a functor or to be more precise a closure. It contains
-+ * a single, arbitrary functor (or closure) that is executed in operator()().
-+ *
-+ * The template arguments determine the function signature of operator()():
-+ * - @e T_return The return type of operator()().
-+ * - @e T_arg1 Argument type used in the definition of operator()().
-+ * - @e T_arg2 Argument type used in the definition of operator()().
-+ * - @e T_arg3 Argument type used in the definition of operator()().
-+ * - @e T_arg4 Argument type used in the definition of operator()().
-+ *
-+ * To use simply assign the slot to the desired functor. If the functor
-+ * is not compatible with the parameter list defined with the template
-+ * arguments compiler errors are triggered. When called the slot
-+ * will invoke the functor with minimal copies.
-+ * block() and unblock() can be used to block the functor's invocation
-+ * from operator()() temporarily.
-+ *
-+ * @par Example:
-+ *   @code
-+ *   #include <sigc++/slot.h>
-+ *   void foo(int) {}
-+ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
-+ *   s(19);
-+ *   @endcode
-+ *
-+ * @deprecated Use the unnumbered template sigc::slot instead.
-+ * @ingroup compat
-+ */
-+template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
-+class Slot4
-+  : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
-+{
-+public:
-+  typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4> parent_type;
-+
-+  /// Constructs an empty slot.
-+  Slot4() {}
-+
-+  /** Constructs a slot from an arbitrary functor.
-+   * @param _A_func The desired functor the new slot should be assigned to.
-+   */
-+  template <class T_functor>
-+  Slot4(const T_functor& _A_func)
-+    : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(_A_func) {}
-+
-+  /** Constructs a slot, copying an existing one.
-+   * @param src The existing slot to copy.
-+   */
-+  Slot4(const parent_type& src)
-+    : parent_type(src) {}
-+
-+  /** Overrides this slot making a copy from another slot.
-+   * @param src The slot from which to make a copy.
-+   * @return @p this.
-+   */
-+  Slot4& operator=(const parent_type& src)
-+    { parent_type::operator=(src); return *this; }
-+};
-+
-+/** Converts an arbitrary functor to a unified type which is opaque.
-+ * Slot5 itself is a functor or to be more precise a closure. It contains
-+ * a single, arbitrary functor (or closure) that is executed in operator()().
-+ *
-+ * The template arguments determine the function signature of operator()():
-+ * - @e T_return The return type of operator()().
-+ * - @e T_arg1 Argument type used in the definition of operator()().
-+ * - @e T_arg2 Argument type used in the definition of operator()().
-+ * - @e T_arg3 Argument type used in the definition of operator()().
-+ * - @e T_arg4 Argument type used in the definition of operator()().
-+ * - @e T_arg5 Argument type used in the definition of operator()().
-+ *
-+ * To use simply assign the slot to the desired functor. If the functor
-+ * is not compatible with the parameter list defined with the template
-+ * arguments compiler errors are triggered. When called the slot
-+ * will invoke the functor with minimal copies.
-+ * block() and unblock() can be used to block the functor's invocation
-+ * from operator()() temporarily.
-+ *
-+ * @par Example:
-+ *   @code
-+ *   #include <sigc++/slot.h>
-+ *   void foo(int) {}
-+ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
-+ *   s(19);
-+ *   @endcode
-+ *
-+ * @deprecated Use the unnumbered template sigc::slot instead.
-+ * @ingroup compat
-+ */
-+template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
-+class Slot5
-+  : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
-+{
-+public:
-+  typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> parent_type;
-+
-+  /// Constructs an empty slot.
-+  Slot5() {}
-+
-+  /** Constructs a slot from an arbitrary functor.
-+   * @param _A_func The desired functor the new slot should be assigned to.
-+   */
-+  template <class T_functor>
-+  Slot5(const T_functor& _A_func)
-+    : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_func) {}
-+
-+  /** Constructs a slot, copying an existing one.
-+   * @param src The existing slot to copy.
-+   */
-+  Slot5(const parent_type& src)
-+    : parent_type(src) {}
-+
-+  /** Overrides this slot making a copy from another slot.
-+   * @param src The slot from which to make a copy.
-+   * @return @p this.
-+   */
-+  Slot5& operator=(const parent_type& src)
-+    { parent_type::operator=(src); return *this; }
-+};
-+
-+/** Converts an arbitrary functor to a unified type which is opaque.
-+ * Slot6 itself is a functor or to be more precise a closure. It contains
-+ * a single, arbitrary functor (or closure) that is executed in operator()().
-+ *
-+ * The template arguments determine the function signature of operator()():
-+ * - @e T_return The return type of operator()().
-+ * - @e T_arg1 Argument type used in the definition of operator()().
-+ * - @e T_arg2 Argument type used in the definition of operator()().
-+ * - @e T_arg3 Argument type used in the definition of operator()().
-+ * - @e T_arg4 Argument type used in the definition of operator()().
-+ * - @e T_arg5 Argument type used in the definition of operator()().
-+ * - @e T_arg6 Argument type used in the definition of operator()().
-+ *
-+ * To use simply assign the slot to the desired functor. If the functor
-+ * is not compatible with the parameter list defined with the template
-+ * arguments compiler errors are triggered. When called the slot
-+ * will invoke the functor with minimal copies.
-+ * block() and unblock() can be used to block the functor's invocation
-+ * from operator()() temporarily.
-+ *
-+ * @par Example:
-+ *   @code
-+ *   #include <sigc++/slot.h>
-+ *   void foo(int) {}
-+ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
-+ *   s(19);
-+ *   @endcode
-+ *
-+ * @deprecated Use the unnumbered template sigc::slot instead.
-+ * @ingroup compat
-+ */
-+template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
-+class Slot6
-+  : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
-+{
-+public:
-+  typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> parent_type;
-+
-+  /// Constructs an empty slot.
-+  Slot6() {}
-+
-+  /** Constructs a slot from an arbitrary functor.
-+   * @param _A_func The desired functor the new slot should be assigned to.
-+   */
-+  template <class T_functor>
-+  Slot6(const T_functor& _A_func)
-+    : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_func) {}
-+
-+  /** Constructs a slot, copying an existing one.
-+   * @param src The existing slot to copy.
-+   */
-+  Slot6(const parent_type& src)
-+    : parent_type(src) {}
-+
-+  /** Overrides this slot making a copy from another slot.
-+   * @param src The slot from which to make a copy.
-+   * @return @p this.
-+   */
-+  Slot6& operator=(const parent_type& src)
-+    { parent_type::operator=(src); return *this; }
-+};
-+
-+/** Converts an arbitrary functor to a unified type which is opaque.
-+ * Slot7 itself is a functor or to be more precise a closure. It contains
-+ * a single, arbitrary functor (or closure) that is executed in operator()().
-+ *
-+ * The template arguments determine the function signature of operator()():
-+ * - @e T_return The return type of operator()().
-+ * - @e T_arg1 Argument type used in the definition of operator()().
-+ * - @e T_arg2 Argument type used in the definition of operator()().
-+ * - @e T_arg3 Argument type used in the definition of operator()().
-+ * - @e T_arg4 Argument type used in the definition of operator()().
-+ * - @e T_arg5 Argument type used in the definition of operator()().
-+ * - @e T_arg6 Argument type used in the definition of operator()().
-+ * - @e T_arg7 Argument type used in the definition of operator()().
-+ *
-+ * To use simply assign the slot to the desired functor. If the functor
-+ * is not compatible with the parameter list defined with the template
-+ * arguments compiler errors are triggered. When called the slot
-+ * will invoke the functor with minimal copies.
-+ * block() and unblock() can be used to block the functor's invocation
-+ * from operator()() temporarily.
-+ *
-+ * @par Example:
-+ *   @code
-+ *   #include <sigc++/slot.h>
-+ *   void foo(int) {}
-+ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
-+ *   s(19);
-+ *   @endcode
-+ *
-+ * @deprecated Use the unnumbered template sigc::slot instead.
-+ * @ingroup compat
-+ */
-+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 Slot7
-+  : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
- {
-+public:
-+  typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> parent_type;
-+
-+  /// Constructs an empty slot.
-+  Slot7() {}
-+
-+  /** Constructs a slot from an arbitrary functor.
-+   * @param _A_func The desired functor the new slot should be assigned to.
-+   */
-+  template <class T_functor>
-+  Slot7(const T_functor& _A_func)
-+    : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(_A_func) {}
-+
-+  /** Constructs a slot, copying an existing one.
-+   * @param src The existing slot to copy.
-+   */
-+  Slot7(const parent_type& src)
-+    : parent_type(src) {}
-+
-+  /** Overrides this slot making a copy from another slot.
-+   * @param src The slot from which to make a copy.
-+   * @return @p this.
-+   */
-+  Slot7& operator=(const parent_type& src)
-+    { parent_type::operator=(src); return *this; }
-+};
-+
-+
-+
-+#ifndef DOXYGEN_SHOULD_SKIP_THIS
-+/* gcc 3.2 reports a strange conflict between SigC::slot() and sigc::slot<>
-+ * when "using namespace SigC" and later using a slot(obj,func) overload
-+ * without the prefix "SigC::". Probably a compiler bug. I will investigate.
-+ *
-+ * This ugly hack avoids the error:
-+ */
-+// #define slot(...) make_slot(__VA_ARGS__) /* only works for gcc */
-+#endif
- 
-+
-+// slot()
-+/** Creates a functor of type SigC::Slot0 that wraps an existing non-member function.
-+ *
-+ * @param _A_func Pointer to function that should be wrapped.
-+ * @return Functor that executes _A_func on invokation.
-+ *
-+ * @deprecated Use sigc::ptr_fun() instead.
-+ * @ingroup compat
-+ */
-+template <class T_return>
-+inline Slot0<T_return>
-+slot(T_return (*_A_func)())
-+{ return Slot0<T_return>(_A_func); }
-+
-+/** Creates a functor of type SigC::Slot1 that wraps an existing non-member function.
-+ *
-+ * @param _A_func Pointer to function that should be wrapped.
-+ * @return Functor that executes _A_func on invokation.
-+ *
-+ * @deprecated Use sigc::ptr_fun() instead.
-+ * @ingroup compat
-+ */
-+template <class T_return, class T_arg1>
-+inline Slot1<T_return, T_arg1>
-+slot(T_return (*_A_func)(T_arg1))
-+{ return Slot1<T_return, T_arg1>(_A_func); }
-+
-+/** Creates a functor of type SigC::Slot2 that wraps an existing non-member function.
-+ *
-+ * @param _A_func Pointer to function that should be wrapped.
-+ * @return Functor that executes _A_func on invokation.
-+ *
-+ * @deprecated Use sigc::ptr_fun() instead.
-+ * @ingroup compat
-+ */
-+template <class T_return, class T_arg1,class T_arg2>
-+inline Slot2<T_return, T_arg1,T_arg2>
-+slot(T_return (*_A_func)(T_arg1,T_arg2))
-+{ return Slot2<T_return, T_arg1,T_arg2>(_A_func); }
-+
-+/** Creates a functor of type SigC::Slot3 that wraps an existing non-member function.
-+ *
-+ * @param _A_func Pointer to function that should be wrapped.
-+ * @return Functor that executes _A_func on invokation.
-+ *
-+ * @deprecated Use sigc::ptr_fun() instead.
-+ * @ingroup compat
-+ */
-+template <class T_return, class T_arg1,class T_arg2,class T_arg3>
-+inline Slot3<T_return, T_arg1,T_arg2,T_arg3>
-+slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3))
-+{ return Slot3<T_return, T_arg1,T_arg2,T_arg3>(_A_func); }
-+
-+/** Creates a functor of type SigC::Slot4 that wraps an existing non-member function.
-+ *
-+ * @param _A_func Pointer to function that should be wrapped.
-+ * @return Functor that executes _A_func on invokation.
-+ *
-+ * @deprecated Use sigc::ptr_fun() instead.
-+ * @ingroup compat
-+ */
-+template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
-+inline Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
-+slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4))
-+{ return Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(_A_func); }
-+
-+/** Creates a functor of type SigC::Slot5 that wraps an existing non-member function.
-+ *
-+ * @param _A_func Pointer to function that should be wrapped.
-+ * @return Functor that executes _A_func on invokation.
-+ *
-+ * @deprecated Use sigc::ptr_fun() instead.
-+ * @ingroup compat
-+ */
-+template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
-+inline 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))
-+{ return Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_func); }
-+
-+/** Creates a functor of type SigC::Slot6 that wraps an existing non-member function.
-+ *
-+ * @param _A_func Pointer to function that should be wrapped.
-+ * @return Functor that executes _A_func on invokation.
-+ *
-+ * @deprecated Use sigc::ptr_fun() instead.
-+ * @ingroup compat
-+ */
-+template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
-+inline 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))
-+{ return Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_func); }
-+
-+/** Creates a functor of type SigC::Slot7 that wraps an existing non-member function.
-+ *
-+ * @param _A_func Pointer to function that should be wrapped.
-+ * @return Functor that executes _A_func on invokation.
-+ *
-+ * @deprecated Use sigc::ptr_fun() instead.
-+ * @ingroup compat
-+ */
-+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>
-+inline 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))
-+{ return Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(_A_func); }
-+
-+
-+
-+}
-+
-+// From sigc++/object.h
-+namespace SigC {
-+
-+// Object
-+typedef ::sigc::trackable Object;
-+
-+}
-+
-+namespace SigC
-+{
- template <class T_return, class T_obj1, class T_obj2>
- inline Slot0<T_return>
- slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)() )