wok-6.x diff visualboyadvance/stuff/1.7.2-deprecatedsigc++.patch @ rev 19992

Up busybox (1.27.1) again
author Pascal Bellard <pascal.bellard@slitaz.org>
date Fri Jul 21 17:41:29 2017 +0200 (2017-07-21)
parents
children
line diff
     1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/visualboyadvance/stuff/1.7.2-deprecatedsigc++.patch	Fri Jul 21 17:41:29 2017 +0200
     1.3 @@ -0,0 +1,692 @@
     1.4 +--- src/gtk/sigccompat.h.old	2008-05-02 10:46:45.000000000 +0200
     1.5 ++++ src/gtk/sigccompat.h	2008-05-02 10:47:08.000000000 +0200
     1.6 +@@ -20,7 +20,7 @@
     1.7 + #ifndef __VBA_SIGCCOMPAT_H__
     1.8 + #define __VBA_SIGCCOMPAT_H__
     1.9 + 
    1.10 +-#undef LIBSIGC_DISABLE_DEPRECATED
    1.11 ++#define LIBSIGC_DISABLE_DEPRECATED
    1.12 + #include <sigc++/bind.h>
    1.13 + #include <sigc++/connection.h>
    1.14 + 
    1.15 +@@ -28,9 +28,679 @@
    1.16 + #include <sigc++/object.h>
    1.17 + #include <sigc++/functors/mem_fun.h>
    1.18 + 
    1.19 +-namespace SigC
    1.20 ++
    1.21 ++// From sigc++/bind.h
    1.22 ++namespace SigC {
    1.23 ++
    1.24 ++template <class T_bound1, class T_functor>
    1.25 ++inline ::sigc::bind_functor<-1, T_functor,
    1.26 ++                            typename ::sigc::unwrap_reference<T_bound1>::type>
    1.27 ++bind(const T_functor& _A_functor, T_bound1 _A_b1)
    1.28 ++{ return ::sigc::bind_functor<-1, T_functor,
    1.29 ++                              typename ::sigc::unwrap_reference<T_bound1>::type>
    1.30 ++                              (_A_functor, _A_b1);
    1.31 ++}
    1.32 ++
    1.33 ++template <class T_bound1, class T_bound2, class T_functor>
    1.34 ++inline ::sigc::bind_functor<-1, T_functor,
    1.35 ++                            typename ::sigc::unwrap_reference<T_bound1>::type,
    1.36 ++                            typename ::sigc::unwrap_reference<T_bound2>::type>
    1.37 ++bind(const T_functor& _A_functor, T_bound1 _A_b1, T_bound2 _A_b2)
    1.38 ++{ return ::sigc::bind_functor<-1, T_functor,
    1.39 ++                              typename ::sigc::unwrap_reference<T_bound1>::type,
    1.40 ++                              typename ::sigc::unwrap_reference<T_bound2>::type>
    1.41 ++                              (_A_functor, _A_b1, _A_b2); 
    1.42 ++}
    1.43 ++
    1.44 ++template <class T_bound1, class T_bound2, class T_bound3, class T_functor>
    1.45 ++inline ::sigc::bind_functor<-1, T_functor,
    1.46 ++                            typename ::sigc::unwrap_reference<T_bound1>::type,
    1.47 ++                            typename ::sigc::unwrap_reference<T_bound2>::type,
    1.48 ++                            typename ::sigc::unwrap_reference<T_bound3>::type>
    1.49 ++bind(const T_functor& _A_functor, T_bound1 _A_b1, T_bound2 _A_b2,T_bound3 _A_b3)
    1.50 ++{ return ::sigc::bind_functor<-1, T_functor,
    1.51 ++                              typename ::sigc::unwrap_reference<T_bound1>::type,
    1.52 ++                              typename ::sigc::unwrap_reference<T_bound2>::type,
    1.53 ++                              typename ::sigc::unwrap_reference<T_bound3>::type>
    1.54 ++                              (_A_functor, _A_b1, _A_b2, _A_b3);
    1.55 ++}
    1.56 ++
    1.57 ++}
    1.58 ++
    1.59 ++// From sigc++/connection.h
    1.60 ++namespace SigC {
    1.61 ++
    1.62 ++/** Convinience class for safe disconnection.
    1.63 ++ * Iterators must not be used beyond the lifetime of the list
    1.64 ++ * they work on. A connection object can be created from a
    1.65 ++ * slot list iterator and may safely be used to disconnect
    1.66 ++ * the referred slot at any time (disconnect()). If the slot
    1.67 ++ * has already been destroyed, disconnect() does nothing. empty() or
    1.68 ++ * operator bool() can be used to test whether the connection is
    1.69 ++ * still active. The connection can be blocked (block(), unblock()).
    1.70 ++ *
    1.71 ++ * This is possible because the connection object gets notified
    1.72 ++ * when the referred slot dies (notify()).
    1.73 ++ *
    1.74 ++ * @deprecated Use sigc::connection instead.
    1.75 ++ * @ingroup compat
    1.76 ++ */
    1.77 ++typedef ::sigc::connection Connection;
    1.78 ++
    1.79 ++}
    1.80 ++
    1.81 ++// From sigc++/slot.h
    1.82 ++namespace SigC {
    1.83 ++
    1.84 ++// SlotN
    1.85 ++/** Converts an arbitrary functor to a unified type which is opaque.
    1.86 ++ * Slot0 itself is a functor or to be more precise a closure. It contains
    1.87 ++ * a single, arbitrary functor (or closure) that is executed in operator()().
    1.88 ++ *
    1.89 ++ * The template arguments determine the function signature of operator()():
    1.90 ++ * - @e T_return The return type of operator()().
    1.91 ++ *
    1.92 ++ * To use simply assign the slot to the desired functor. If the functor
    1.93 ++ * is not compatible with the parameter list defined with the template
    1.94 ++ * arguments compiler errors are triggered. When called the slot
    1.95 ++ * will invoke the functor with minimal copies.
    1.96 ++ * block() and unblock() can be used to block the functor's invocation
    1.97 ++ * from operator()() temporarily.
    1.98 ++ *
    1.99 ++ * @par Example:
   1.100 ++ *   @code
   1.101 ++ *   #include <sigc++/slot.h>
   1.102 ++ *   void foo(int) {}
   1.103 ++ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
   1.104 ++ *   s(19);
   1.105 ++ *   @endcode
   1.106 ++ *
   1.107 ++ * @deprecated Use the unnumbered template sigc::slot instead.
   1.108 ++ * @ingroup compat
   1.109 ++ */
   1.110 ++template <class T_return>
   1.111 ++class Slot0
   1.112 ++  : public ::sigc::slot<T_return>
   1.113 ++{
   1.114 ++public:
   1.115 ++  typedef ::sigc::slot<T_return> parent_type;
   1.116 ++
   1.117 ++  /// Constructs an empty slot.
   1.118 ++  Slot0() {}
   1.119 ++
   1.120 ++  /** Constructs a slot from an arbitrary functor.
   1.121 ++   * @param _A_func The desired functor the new slot should be assigned to.
   1.122 ++   */
   1.123 ++  template <class T_functor>
   1.124 ++  Slot0(const T_functor& _A_func)
   1.125 ++    : ::sigc::slot<T_return>(_A_func) {}
   1.126 ++
   1.127 ++  /** Constructs a slot, copying an existing one.
   1.128 ++   * @param src The existing slot to copy.
   1.129 ++   */
   1.130 ++  Slot0(const parent_type& src)
   1.131 ++    : parent_type(src) {}
   1.132 ++
   1.133 ++  /** Overrides this slot making a copy from another slot.
   1.134 ++   * @param src The slot from which to make a copy.
   1.135 ++   * @return @p this.
   1.136 ++   */
   1.137 ++  Slot0& operator=(const parent_type& src)
   1.138 ++    { parent_type::operator=(src); return *this; }
   1.139 ++};
   1.140 ++
   1.141 ++/** Converts an arbitrary functor to a unified type which is opaque.
   1.142 ++ * Slot1 itself is a functor or to be more precise a closure. It contains
   1.143 ++ * a single, arbitrary functor (or closure) that is executed in operator()().
   1.144 ++ *
   1.145 ++ * The template arguments determine the function signature of operator()():
   1.146 ++ * - @e T_return The return type of operator()().
   1.147 ++ * - @e T_arg1 Argument type used in the definition of operator()().
   1.148 ++ *
   1.149 ++ * To use simply assign the slot to the desired functor. If the functor
   1.150 ++ * is not compatible with the parameter list defined with the template
   1.151 ++ * arguments compiler errors are triggered. When called the slot
   1.152 ++ * will invoke the functor with minimal copies.
   1.153 ++ * block() and unblock() can be used to block the functor's invocation
   1.154 ++ * from operator()() temporarily.
   1.155 ++ *
   1.156 ++ * @par Example:
   1.157 ++ *   @code
   1.158 ++ *   #include <sigc++/slot.h>
   1.159 ++ *   void foo(int) {}
   1.160 ++ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
   1.161 ++ *   s(19);
   1.162 ++ *   @endcode
   1.163 ++ *
   1.164 ++ * @deprecated Use the unnumbered template sigc::slot instead.
   1.165 ++ * @ingroup compat
   1.166 ++ */
   1.167 ++template <class T_return, class T_arg1>
   1.168 ++class Slot1
   1.169 ++  : public ::sigc::slot<T_return, T_arg1>
   1.170 ++{
   1.171 ++public:
   1.172 ++  typedef ::sigc::slot<T_return, T_arg1> parent_type;
   1.173 ++
   1.174 ++  /// Constructs an empty slot.
   1.175 ++  Slot1() {}
   1.176 ++
   1.177 ++  /** Constructs a slot from an arbitrary functor.
   1.178 ++   * @param _A_func The desired functor the new slot should be assigned to.
   1.179 ++   */
   1.180 ++  template <class T_functor>
   1.181 ++  Slot1(const T_functor& _A_func)
   1.182 ++    : ::sigc::slot<T_return, T_arg1>(_A_func) {}
   1.183 ++
   1.184 ++  /** Constructs a slot, copying an existing one.
   1.185 ++   * @param src The existing slot to copy.
   1.186 ++   */
   1.187 ++  Slot1(const parent_type& src)
   1.188 ++    : parent_type(src) {}
   1.189 ++
   1.190 ++  /** Overrides this slot making a copy from another slot.
   1.191 ++   * @param src The slot from which to make a copy.
   1.192 ++   * @return @p this.
   1.193 ++   */
   1.194 ++  Slot1& operator=(const parent_type& src)
   1.195 ++    { parent_type::operator=(src); return *this; }
   1.196 ++};
   1.197 ++
   1.198 ++/** Converts an arbitrary functor to a unified type which is opaque.
   1.199 ++ * Slot2 itself is a functor or to be more precise a closure. It contains
   1.200 ++ * a single, arbitrary functor (or closure) that is executed in operator()().
   1.201 ++ *
   1.202 ++ * The template arguments determine the function signature of operator()():
   1.203 ++ * - @e T_return The return type of operator()().
   1.204 ++ * - @e T_arg1 Argument type used in the definition of operator()().
   1.205 ++ * - @e T_arg2 Argument type used in the definition of operator()().
   1.206 ++ *
   1.207 ++ * To use simply assign the slot to the desired functor. If the functor
   1.208 ++ * is not compatible with the parameter list defined with the template
   1.209 ++ * arguments compiler errors are triggered. When called the slot
   1.210 ++ * will invoke the functor with minimal copies.
   1.211 ++ * block() and unblock() can be used to block the functor's invocation
   1.212 ++ * from operator()() temporarily.
   1.213 ++ *
   1.214 ++ * @par Example:
   1.215 ++ *   @code
   1.216 ++ *   #include <sigc++/slot.h>
   1.217 ++ *   void foo(int) {}
   1.218 ++ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
   1.219 ++ *   s(19);
   1.220 ++ *   @endcode
   1.221 ++ *
   1.222 ++ * @deprecated Use the unnumbered template sigc::slot instead.
   1.223 ++ * @ingroup compat
   1.224 ++ */
   1.225 ++template <class T_return, class T_arg1,class T_arg2>
   1.226 ++class Slot2
   1.227 ++  : public ::sigc::slot<T_return, T_arg1,T_arg2>
   1.228 ++{
   1.229 ++public:
   1.230 ++  typedef ::sigc::slot<T_return, T_arg1,T_arg2> parent_type;
   1.231 ++
   1.232 ++  /// Constructs an empty slot.
   1.233 ++  Slot2() {}
   1.234 ++
   1.235 ++  /** Constructs a slot from an arbitrary functor.
   1.236 ++   * @param _A_func The desired functor the new slot should be assigned to.
   1.237 ++   */
   1.238 ++  template <class T_functor>
   1.239 ++  Slot2(const T_functor& _A_func)
   1.240 ++    : ::sigc::slot<T_return, T_arg1,T_arg2>(_A_func) {}
   1.241 ++
   1.242 ++  /** Constructs a slot, copying an existing one.
   1.243 ++   * @param src The existing slot to copy.
   1.244 ++   */
   1.245 ++  Slot2(const parent_type& src)
   1.246 ++    : parent_type(src) {}
   1.247 ++
   1.248 ++  /** Overrides this slot making a copy from another slot.
   1.249 ++   * @param src The slot from which to make a copy.
   1.250 ++   * @return @p this.
   1.251 ++   */
   1.252 ++  Slot2& operator=(const parent_type& src)
   1.253 ++    { parent_type::operator=(src); return *this; }
   1.254 ++};
   1.255 ++
   1.256 ++/** Converts an arbitrary functor to a unified type which is opaque.
   1.257 ++ * Slot3 itself is a functor or to be more precise a closure. It contains
   1.258 ++ * a single, arbitrary functor (or closure) that is executed in operator()().
   1.259 ++ *
   1.260 ++ * The template arguments determine the function signature of operator()():
   1.261 ++ * - @e T_return The return type of operator()().
   1.262 ++ * - @e T_arg1 Argument type used in the definition of operator()().
   1.263 ++ * - @e T_arg2 Argument type used in the definition of operator()().
   1.264 ++ * - @e T_arg3 Argument type used in the definition of operator()().
   1.265 ++ *
   1.266 ++ * To use simply assign the slot to the desired functor. If the functor
   1.267 ++ * is not compatible with the parameter list defined with the template
   1.268 ++ * arguments compiler errors are triggered. When called the slot
   1.269 ++ * will invoke the functor with minimal copies.
   1.270 ++ * block() and unblock() can be used to block the functor's invocation
   1.271 ++ * from operator()() temporarily.
   1.272 ++ *
   1.273 ++ * @par Example:
   1.274 ++ *   @code
   1.275 ++ *   #include <sigc++/slot.h>
   1.276 ++ *   void foo(int) {}
   1.277 ++ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
   1.278 ++ *   s(19);
   1.279 ++ *   @endcode
   1.280 ++ *
   1.281 ++ * @deprecated Use the unnumbered template sigc::slot instead.
   1.282 ++ * @ingroup compat
   1.283 ++ */
   1.284 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3>
   1.285 ++class Slot3
   1.286 ++  : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3>
   1.287 ++{
   1.288 ++public:
   1.289 ++  typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3> parent_type;
   1.290 ++
   1.291 ++  /// Constructs an empty slot.
   1.292 ++  Slot3() {}
   1.293 ++
   1.294 ++  /** Constructs a slot from an arbitrary functor.
   1.295 ++   * @param _A_func The desired functor the new slot should be assigned to.
   1.296 ++   */
   1.297 ++  template <class T_functor>
   1.298 ++  Slot3(const T_functor& _A_func)
   1.299 ++    : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3>(_A_func) {}
   1.300 ++
   1.301 ++  /** Constructs a slot, copying an existing one.
   1.302 ++   * @param src The existing slot to copy.
   1.303 ++   */
   1.304 ++  Slot3(const parent_type& src)
   1.305 ++    : parent_type(src) {}
   1.306 ++
   1.307 ++  /** Overrides this slot making a copy from another slot.
   1.308 ++   * @param src The slot from which to make a copy.
   1.309 ++   * @return @p this.
   1.310 ++   */
   1.311 ++  Slot3& operator=(const parent_type& src)
   1.312 ++    { parent_type::operator=(src); return *this; }
   1.313 ++};
   1.314 ++
   1.315 ++/** Converts an arbitrary functor to a unified type which is opaque.
   1.316 ++ * Slot4 itself is a functor or to be more precise a closure. It contains
   1.317 ++ * a single, arbitrary functor (or closure) that is executed in operator()().
   1.318 ++ *
   1.319 ++ * The template arguments determine the function signature of operator()():
   1.320 ++ * - @e T_return The return type of operator()().
   1.321 ++ * - @e T_arg1 Argument type used in the definition of operator()().
   1.322 ++ * - @e T_arg2 Argument type used in the definition of operator()().
   1.323 ++ * - @e T_arg3 Argument type used in the definition of operator()().
   1.324 ++ * - @e T_arg4 Argument type used in the definition of operator()().
   1.325 ++ *
   1.326 ++ * To use simply assign the slot to the desired functor. If the functor
   1.327 ++ * is not compatible with the parameter list defined with the template
   1.328 ++ * arguments compiler errors are triggered. When called the slot
   1.329 ++ * will invoke the functor with minimal copies.
   1.330 ++ * block() and unblock() can be used to block the functor's invocation
   1.331 ++ * from operator()() temporarily.
   1.332 ++ *
   1.333 ++ * @par Example:
   1.334 ++ *   @code
   1.335 ++ *   #include <sigc++/slot.h>
   1.336 ++ *   void foo(int) {}
   1.337 ++ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
   1.338 ++ *   s(19);
   1.339 ++ *   @endcode
   1.340 ++ *
   1.341 ++ * @deprecated Use the unnumbered template sigc::slot instead.
   1.342 ++ * @ingroup compat
   1.343 ++ */
   1.344 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   1.345 ++class Slot4
   1.346 ++  : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
   1.347 ++{
   1.348 ++public:
   1.349 ++  typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4> parent_type;
   1.350 ++
   1.351 ++  /// Constructs an empty slot.
   1.352 ++  Slot4() {}
   1.353 ++
   1.354 ++  /** Constructs a slot from an arbitrary functor.
   1.355 ++   * @param _A_func The desired functor the new slot should be assigned to.
   1.356 ++   */
   1.357 ++  template <class T_functor>
   1.358 ++  Slot4(const T_functor& _A_func)
   1.359 ++    : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(_A_func) {}
   1.360 ++
   1.361 ++  /** Constructs a slot, copying an existing one.
   1.362 ++   * @param src The existing slot to copy.
   1.363 ++   */
   1.364 ++  Slot4(const parent_type& src)
   1.365 ++    : parent_type(src) {}
   1.366 ++
   1.367 ++  /** Overrides this slot making a copy from another slot.
   1.368 ++   * @param src The slot from which to make a copy.
   1.369 ++   * @return @p this.
   1.370 ++   */
   1.371 ++  Slot4& operator=(const parent_type& src)
   1.372 ++    { parent_type::operator=(src); return *this; }
   1.373 ++};
   1.374 ++
   1.375 ++/** Converts an arbitrary functor to a unified type which is opaque.
   1.376 ++ * Slot5 itself is a functor or to be more precise a closure. It contains
   1.377 ++ * a single, arbitrary functor (or closure) that is executed in operator()().
   1.378 ++ *
   1.379 ++ * The template arguments determine the function signature of operator()():
   1.380 ++ * - @e T_return The return type of operator()().
   1.381 ++ * - @e T_arg1 Argument type used in the definition of operator()().
   1.382 ++ * - @e T_arg2 Argument type used in the definition of operator()().
   1.383 ++ * - @e T_arg3 Argument type used in the definition of operator()().
   1.384 ++ * - @e T_arg4 Argument type used in the definition of operator()().
   1.385 ++ * - @e T_arg5 Argument type used in the definition of operator()().
   1.386 ++ *
   1.387 ++ * To use simply assign the slot to the desired functor. If the functor
   1.388 ++ * is not compatible with the parameter list defined with the template
   1.389 ++ * arguments compiler errors are triggered. When called the slot
   1.390 ++ * will invoke the functor with minimal copies.
   1.391 ++ * block() and unblock() can be used to block the functor's invocation
   1.392 ++ * from operator()() temporarily.
   1.393 ++ *
   1.394 ++ * @par Example:
   1.395 ++ *   @code
   1.396 ++ *   #include <sigc++/slot.h>
   1.397 ++ *   void foo(int) {}
   1.398 ++ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
   1.399 ++ *   s(19);
   1.400 ++ *   @endcode
   1.401 ++ *
   1.402 ++ * @deprecated Use the unnumbered template sigc::slot instead.
   1.403 ++ * @ingroup compat
   1.404 ++ */
   1.405 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   1.406 ++class Slot5
   1.407 ++  : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
   1.408 ++{
   1.409 ++public:
   1.410 ++  typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> parent_type;
   1.411 ++
   1.412 ++  /// Constructs an empty slot.
   1.413 ++  Slot5() {}
   1.414 ++
   1.415 ++  /** Constructs a slot from an arbitrary functor.
   1.416 ++   * @param _A_func The desired functor the new slot should be assigned to.
   1.417 ++   */
   1.418 ++  template <class T_functor>
   1.419 ++  Slot5(const T_functor& _A_func)
   1.420 ++    : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_func) {}
   1.421 ++
   1.422 ++  /** Constructs a slot, copying an existing one.
   1.423 ++   * @param src The existing slot to copy.
   1.424 ++   */
   1.425 ++  Slot5(const parent_type& src)
   1.426 ++    : parent_type(src) {}
   1.427 ++
   1.428 ++  /** Overrides this slot making a copy from another slot.
   1.429 ++   * @param src The slot from which to make a copy.
   1.430 ++   * @return @p this.
   1.431 ++   */
   1.432 ++  Slot5& operator=(const parent_type& src)
   1.433 ++    { parent_type::operator=(src); return *this; }
   1.434 ++};
   1.435 ++
   1.436 ++/** Converts an arbitrary functor to a unified type which is opaque.
   1.437 ++ * Slot6 itself is a functor or to be more precise a closure. It contains
   1.438 ++ * a single, arbitrary functor (or closure) that is executed in operator()().
   1.439 ++ *
   1.440 ++ * The template arguments determine the function signature of operator()():
   1.441 ++ * - @e T_return The return type of operator()().
   1.442 ++ * - @e T_arg1 Argument type used in the definition of operator()().
   1.443 ++ * - @e T_arg2 Argument type used in the definition of operator()().
   1.444 ++ * - @e T_arg3 Argument type used in the definition of operator()().
   1.445 ++ * - @e T_arg4 Argument type used in the definition of operator()().
   1.446 ++ * - @e T_arg5 Argument type used in the definition of operator()().
   1.447 ++ * - @e T_arg6 Argument type used in the definition of operator()().
   1.448 ++ *
   1.449 ++ * To use simply assign the slot to the desired functor. If the functor
   1.450 ++ * is not compatible with the parameter list defined with the template
   1.451 ++ * arguments compiler errors are triggered. When called the slot
   1.452 ++ * will invoke the functor with minimal copies.
   1.453 ++ * block() and unblock() can be used to block the functor's invocation
   1.454 ++ * from operator()() temporarily.
   1.455 ++ *
   1.456 ++ * @par Example:
   1.457 ++ *   @code
   1.458 ++ *   #include <sigc++/slot.h>
   1.459 ++ *   void foo(int) {}
   1.460 ++ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
   1.461 ++ *   s(19);
   1.462 ++ *   @endcode
   1.463 ++ *
   1.464 ++ * @deprecated Use the unnumbered template sigc::slot instead.
   1.465 ++ * @ingroup compat
   1.466 ++ */
   1.467 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   1.468 ++class Slot6
   1.469 ++  : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
   1.470 ++{
   1.471 ++public:
   1.472 ++  typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> parent_type;
   1.473 ++
   1.474 ++  /// Constructs an empty slot.
   1.475 ++  Slot6() {}
   1.476 ++
   1.477 ++  /** Constructs a slot from an arbitrary functor.
   1.478 ++   * @param _A_func The desired functor the new slot should be assigned to.
   1.479 ++   */
   1.480 ++  template <class T_functor>
   1.481 ++  Slot6(const T_functor& _A_func)
   1.482 ++    : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_func) {}
   1.483 ++
   1.484 ++  /** Constructs a slot, copying an existing one.
   1.485 ++   * @param src The existing slot to copy.
   1.486 ++   */
   1.487 ++  Slot6(const parent_type& src)
   1.488 ++    : parent_type(src) {}
   1.489 ++
   1.490 ++  /** Overrides this slot making a copy from another slot.
   1.491 ++   * @param src The slot from which to make a copy.
   1.492 ++   * @return @p this.
   1.493 ++   */
   1.494 ++  Slot6& operator=(const parent_type& src)
   1.495 ++    { parent_type::operator=(src); return *this; }
   1.496 ++};
   1.497 ++
   1.498 ++/** Converts an arbitrary functor to a unified type which is opaque.
   1.499 ++ * Slot7 itself is a functor or to be more precise a closure. It contains
   1.500 ++ * a single, arbitrary functor (or closure) that is executed in operator()().
   1.501 ++ *
   1.502 ++ * The template arguments determine the function signature of operator()():
   1.503 ++ * - @e T_return The return type of operator()().
   1.504 ++ * - @e T_arg1 Argument type used in the definition of operator()().
   1.505 ++ * - @e T_arg2 Argument type used in the definition of operator()().
   1.506 ++ * - @e T_arg3 Argument type used in the definition of operator()().
   1.507 ++ * - @e T_arg4 Argument type used in the definition of operator()().
   1.508 ++ * - @e T_arg5 Argument type used in the definition of operator()().
   1.509 ++ * - @e T_arg6 Argument type used in the definition of operator()().
   1.510 ++ * - @e T_arg7 Argument type used in the definition of operator()().
   1.511 ++ *
   1.512 ++ * To use simply assign the slot to the desired functor. If the functor
   1.513 ++ * is not compatible with the parameter list defined with the template
   1.514 ++ * arguments compiler errors are triggered. When called the slot
   1.515 ++ * will invoke the functor with minimal copies.
   1.516 ++ * block() and unblock() can be used to block the functor's invocation
   1.517 ++ * from operator()() temporarily.
   1.518 ++ *
   1.519 ++ * @par Example:
   1.520 ++ *   @code
   1.521 ++ *   #include <sigc++/slot.h>
   1.522 ++ *   void foo(int) {}
   1.523 ++ *   SigC::Slot1<void, long> s = SigC::slot(&foo);
   1.524 ++ *   s(19);
   1.525 ++ *   @endcode
   1.526 ++ *
   1.527 ++ * @deprecated Use the unnumbered template sigc::slot instead.
   1.528 ++ * @ingroup compat
   1.529 ++ */
   1.530 ++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>
   1.531 ++class Slot7
   1.532 ++  : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
   1.533 + {
   1.534 ++public:
   1.535 ++  typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> parent_type;
   1.536 ++
   1.537 ++  /// Constructs an empty slot.
   1.538 ++  Slot7() {}
   1.539 ++
   1.540 ++  /** Constructs a slot from an arbitrary functor.
   1.541 ++   * @param _A_func The desired functor the new slot should be assigned to.
   1.542 ++   */
   1.543 ++  template <class T_functor>
   1.544 ++  Slot7(const T_functor& _A_func)
   1.545 ++    : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(_A_func) {}
   1.546 ++
   1.547 ++  /** Constructs a slot, copying an existing one.
   1.548 ++   * @param src The existing slot to copy.
   1.549 ++   */
   1.550 ++  Slot7(const parent_type& src)
   1.551 ++    : parent_type(src) {}
   1.552 ++
   1.553 ++  /** Overrides this slot making a copy from another slot.
   1.554 ++   * @param src The slot from which to make a copy.
   1.555 ++   * @return @p this.
   1.556 ++   */
   1.557 ++  Slot7& operator=(const parent_type& src)
   1.558 ++    { parent_type::operator=(src); return *this; }
   1.559 ++};
   1.560 ++
   1.561 ++
   1.562 ++
   1.563 ++#ifndef DOXYGEN_SHOULD_SKIP_THIS
   1.564 ++/* gcc 3.2 reports a strange conflict between SigC::slot() and sigc::slot<>
   1.565 ++ * when "using namespace SigC" and later using a slot(obj,func) overload
   1.566 ++ * without the prefix "SigC::". Probably a compiler bug. I will investigate.
   1.567 ++ *
   1.568 ++ * This ugly hack avoids the error:
   1.569 ++ */
   1.570 ++// #define slot(...) make_slot(__VA_ARGS__) /* only works for gcc */
   1.571 ++#endif
   1.572 + 
   1.573 ++
   1.574 ++// slot()
   1.575 ++/** Creates a functor of type SigC::Slot0 that wraps an existing non-member function.
   1.576 ++ *
   1.577 ++ * @param _A_func Pointer to function that should be wrapped.
   1.578 ++ * @return Functor that executes _A_func on invokation.
   1.579 ++ *
   1.580 ++ * @deprecated Use sigc::ptr_fun() instead.
   1.581 ++ * @ingroup compat
   1.582 ++ */
   1.583 ++template <class T_return>
   1.584 ++inline Slot0<T_return>
   1.585 ++slot(T_return (*_A_func)())
   1.586 ++{ return Slot0<T_return>(_A_func); }
   1.587 ++
   1.588 ++/** Creates a functor of type SigC::Slot1 that wraps an existing non-member function.
   1.589 ++ *
   1.590 ++ * @param _A_func Pointer to function that should be wrapped.
   1.591 ++ * @return Functor that executes _A_func on invokation.
   1.592 ++ *
   1.593 ++ * @deprecated Use sigc::ptr_fun() instead.
   1.594 ++ * @ingroup compat
   1.595 ++ */
   1.596 ++template <class T_return, class T_arg1>
   1.597 ++inline Slot1<T_return, T_arg1>
   1.598 ++slot(T_return (*_A_func)(T_arg1))
   1.599 ++{ return Slot1<T_return, T_arg1>(_A_func); }
   1.600 ++
   1.601 ++/** Creates a functor of type SigC::Slot2 that wraps an existing non-member function.
   1.602 ++ *
   1.603 ++ * @param _A_func Pointer to function that should be wrapped.
   1.604 ++ * @return Functor that executes _A_func on invokation.
   1.605 ++ *
   1.606 ++ * @deprecated Use sigc::ptr_fun() instead.
   1.607 ++ * @ingroup compat
   1.608 ++ */
   1.609 ++template <class T_return, class T_arg1,class T_arg2>
   1.610 ++inline Slot2<T_return, T_arg1,T_arg2>
   1.611 ++slot(T_return (*_A_func)(T_arg1,T_arg2))
   1.612 ++{ return Slot2<T_return, T_arg1,T_arg2>(_A_func); }
   1.613 ++
   1.614 ++/** Creates a functor of type SigC::Slot3 that wraps an existing non-member function.
   1.615 ++ *
   1.616 ++ * @param _A_func Pointer to function that should be wrapped.
   1.617 ++ * @return Functor that executes _A_func on invokation.
   1.618 ++ *
   1.619 ++ * @deprecated Use sigc::ptr_fun() instead.
   1.620 ++ * @ingroup compat
   1.621 ++ */
   1.622 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3>
   1.623 ++inline Slot3<T_return, T_arg1,T_arg2,T_arg3>
   1.624 ++slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3))
   1.625 ++{ return Slot3<T_return, T_arg1,T_arg2,T_arg3>(_A_func); }
   1.626 ++
   1.627 ++/** Creates a functor of type SigC::Slot4 that wraps an existing non-member function.
   1.628 ++ *
   1.629 ++ * @param _A_func Pointer to function that should be wrapped.
   1.630 ++ * @return Functor that executes _A_func on invokation.
   1.631 ++ *
   1.632 ++ * @deprecated Use sigc::ptr_fun() instead.
   1.633 ++ * @ingroup compat
   1.634 ++ */
   1.635 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   1.636 ++inline Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
   1.637 ++slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4))
   1.638 ++{ return Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(_A_func); }
   1.639 ++
   1.640 ++/** Creates a functor of type SigC::Slot5 that wraps an existing non-member function.
   1.641 ++ *
   1.642 ++ * @param _A_func Pointer to function that should be wrapped.
   1.643 ++ * @return Functor that executes _A_func on invokation.
   1.644 ++ *
   1.645 ++ * @deprecated Use sigc::ptr_fun() instead.
   1.646 ++ * @ingroup compat
   1.647 ++ */
   1.648 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   1.649 ++inline Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
   1.650 ++slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5))
   1.651 ++{ return Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_func); }
   1.652 ++
   1.653 ++/** Creates a functor of type SigC::Slot6 that wraps an existing non-member function.
   1.654 ++ *
   1.655 ++ * @param _A_func Pointer to function that should be wrapped.
   1.656 ++ * @return Functor that executes _A_func on invokation.
   1.657 ++ *
   1.658 ++ * @deprecated Use sigc::ptr_fun() instead.
   1.659 ++ * @ingroup compat
   1.660 ++ */
   1.661 ++template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   1.662 ++inline Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
   1.663 ++slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6))
   1.664 ++{ return Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_func); }
   1.665 ++
   1.666 ++/** Creates a functor of type SigC::Slot7 that wraps an existing non-member function.
   1.667 ++ *
   1.668 ++ * @param _A_func Pointer to function that should be wrapped.
   1.669 ++ * @return Functor that executes _A_func on invokation.
   1.670 ++ *
   1.671 ++ * @deprecated Use sigc::ptr_fun() instead.
   1.672 ++ * @ingroup compat
   1.673 ++ */
   1.674 ++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>
   1.675 ++inline Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
   1.676 ++slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7))
   1.677 ++{ return Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(_A_func); }
   1.678 ++
   1.679 ++
   1.680 ++
   1.681 ++}
   1.682 ++
   1.683 ++// From sigc++/object.h
   1.684 ++namespace SigC {
   1.685 ++
   1.686 ++// Object
   1.687 ++typedef ::sigc::trackable Object;
   1.688 ++
   1.689 ++}
   1.690 ++
   1.691 ++namespace SigC
   1.692 ++{
   1.693 + template <class T_return, class T_obj1, class T_obj2>
   1.694 + inline Slot0<T_return>
   1.695 + slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)() )