wok view visualboyadvance/stuff/1.7.2-deprecatedsigc++.patch @ rev 14457

Up: nagios-nrpe (2.14)
author Eric Joseph-Alexandre <erjo@slitaz.org>
date Sat Apr 27 02:50:36 2013 +0200 (2013-04-27)
parents
children
line source
1 --- src/gtk/sigccompat.h.old 2008-05-02 10:46:45.000000000 +0200
2 +++ src/gtk/sigccompat.h 2008-05-02 10:47:08.000000000 +0200
3 @@ -20,7 +20,7 @@
4 #ifndef __VBA_SIGCCOMPAT_H__
5 #define __VBA_SIGCCOMPAT_H__
6
7 -#undef LIBSIGC_DISABLE_DEPRECATED
8 +#define LIBSIGC_DISABLE_DEPRECATED
9 #include <sigc++/bind.h>
10 #include <sigc++/connection.h>
11
12 @@ -28,9 +28,679 @@
13 #include <sigc++/object.h>
14 #include <sigc++/functors/mem_fun.h>
15
16 -namespace SigC
17 +
18 +// From sigc++/bind.h
19 +namespace SigC {
20 +
21 +template <class T_bound1, class T_functor>
22 +inline ::sigc::bind_functor<-1, T_functor,
23 + typename ::sigc::unwrap_reference<T_bound1>::type>
24 +bind(const T_functor& _A_functor, T_bound1 _A_b1)
25 +{ return ::sigc::bind_functor<-1, T_functor,
26 + typename ::sigc::unwrap_reference<T_bound1>::type>
27 + (_A_functor, _A_b1);
28 +}
29 +
30 +template <class T_bound1, class T_bound2, class T_functor>
31 +inline ::sigc::bind_functor<-1, T_functor,
32 + typename ::sigc::unwrap_reference<T_bound1>::type,
33 + typename ::sigc::unwrap_reference<T_bound2>::type>
34 +bind(const T_functor& _A_functor, T_bound1 _A_b1, T_bound2 _A_b2)
35 +{ return ::sigc::bind_functor<-1, T_functor,
36 + typename ::sigc::unwrap_reference<T_bound1>::type,
37 + typename ::sigc::unwrap_reference<T_bound2>::type>
38 + (_A_functor, _A_b1, _A_b2);
39 +}
40 +
41 +template <class T_bound1, class T_bound2, class T_bound3, class T_functor>
42 +inline ::sigc::bind_functor<-1, T_functor,
43 + typename ::sigc::unwrap_reference<T_bound1>::type,
44 + typename ::sigc::unwrap_reference<T_bound2>::type,
45 + typename ::sigc::unwrap_reference<T_bound3>::type>
46 +bind(const T_functor& _A_functor, T_bound1 _A_b1, T_bound2 _A_b2,T_bound3 _A_b3)
47 +{ return ::sigc::bind_functor<-1, T_functor,
48 + typename ::sigc::unwrap_reference<T_bound1>::type,
49 + typename ::sigc::unwrap_reference<T_bound2>::type,
50 + typename ::sigc::unwrap_reference<T_bound3>::type>
51 + (_A_functor, _A_b1, _A_b2, _A_b3);
52 +}
53 +
54 +}
55 +
56 +// From sigc++/connection.h
57 +namespace SigC {
58 +
59 +/** Convinience class for safe disconnection.
60 + * Iterators must not be used beyond the lifetime of the list
61 + * they work on. A connection object can be created from a
62 + * slot list iterator and may safely be used to disconnect
63 + * the referred slot at any time (disconnect()). If the slot
64 + * has already been destroyed, disconnect() does nothing. empty() or
65 + * operator bool() can be used to test whether the connection is
66 + * still active. The connection can be blocked (block(), unblock()).
67 + *
68 + * This is possible because the connection object gets notified
69 + * when the referred slot dies (notify()).
70 + *
71 + * @deprecated Use sigc::connection instead.
72 + * @ingroup compat
73 + */
74 +typedef ::sigc::connection Connection;
75 +
76 +}
77 +
78 +// From sigc++/slot.h
79 +namespace SigC {
80 +
81 +// SlotN
82 +/** Converts an arbitrary functor to a unified type which is opaque.
83 + * Slot0 itself is a functor or to be more precise a closure. It contains
84 + * a single, arbitrary functor (or closure) that is executed in operator()().
85 + *
86 + * The template arguments determine the function signature of operator()():
87 + * - @e T_return The return type of operator()().
88 + *
89 + * To use simply assign the slot to the desired functor. If the functor
90 + * is not compatible with the parameter list defined with the template
91 + * arguments compiler errors are triggered. When called the slot
92 + * will invoke the functor with minimal copies.
93 + * block() and unblock() can be used to block the functor's invocation
94 + * from operator()() temporarily.
95 + *
96 + * @par Example:
97 + * @code
98 + * #include <sigc++/slot.h>
99 + * void foo(int) {}
100 + * SigC::Slot1<void, long> s = SigC::slot(&foo);
101 + * s(19);
102 + * @endcode
103 + *
104 + * @deprecated Use the unnumbered template sigc::slot instead.
105 + * @ingroup compat
106 + */
107 +template <class T_return>
108 +class Slot0
109 + : public ::sigc::slot<T_return>
110 +{
111 +public:
112 + typedef ::sigc::slot<T_return> parent_type;
113 +
114 + /// Constructs an empty slot.
115 + Slot0() {}
116 +
117 + /** Constructs a slot from an arbitrary functor.
118 + * @param _A_func The desired functor the new slot should be assigned to.
119 + */
120 + template <class T_functor>
121 + Slot0(const T_functor& _A_func)
122 + : ::sigc::slot<T_return>(_A_func) {}
123 +
124 + /** Constructs a slot, copying an existing one.
125 + * @param src The existing slot to copy.
126 + */
127 + Slot0(const parent_type& src)
128 + : parent_type(src) {}
129 +
130 + /** Overrides this slot making a copy from another slot.
131 + * @param src The slot from which to make a copy.
132 + * @return @p this.
133 + */
134 + Slot0& operator=(const parent_type& src)
135 + { parent_type::operator=(src); return *this; }
136 +};
137 +
138 +/** Converts an arbitrary functor to a unified type which is opaque.
139 + * Slot1 itself is a functor or to be more precise a closure. It contains
140 + * a single, arbitrary functor (or closure) that is executed in operator()().
141 + *
142 + * The template arguments determine the function signature of operator()():
143 + * - @e T_return The return type of operator()().
144 + * - @e T_arg1 Argument type used in the definition of operator()().
145 + *
146 + * To use simply assign the slot to the desired functor. If the functor
147 + * is not compatible with the parameter list defined with the template
148 + * arguments compiler errors are triggered. When called the slot
149 + * will invoke the functor with minimal copies.
150 + * block() and unblock() can be used to block the functor's invocation
151 + * from operator()() temporarily.
152 + *
153 + * @par Example:
154 + * @code
155 + * #include <sigc++/slot.h>
156 + * void foo(int) {}
157 + * SigC::Slot1<void, long> s = SigC::slot(&foo);
158 + * s(19);
159 + * @endcode
160 + *
161 + * @deprecated Use the unnumbered template sigc::slot instead.
162 + * @ingroup compat
163 + */
164 +template <class T_return, class T_arg1>
165 +class Slot1
166 + : public ::sigc::slot<T_return, T_arg1>
167 +{
168 +public:
169 + typedef ::sigc::slot<T_return, T_arg1> parent_type;
170 +
171 + /// Constructs an empty slot.
172 + Slot1() {}
173 +
174 + /** Constructs a slot from an arbitrary functor.
175 + * @param _A_func The desired functor the new slot should be assigned to.
176 + */
177 + template <class T_functor>
178 + Slot1(const T_functor& _A_func)
179 + : ::sigc::slot<T_return, T_arg1>(_A_func) {}
180 +
181 + /** Constructs a slot, copying an existing one.
182 + * @param src The existing slot to copy.
183 + */
184 + Slot1(const parent_type& src)
185 + : parent_type(src) {}
186 +
187 + /** Overrides this slot making a copy from another slot.
188 + * @param src The slot from which to make a copy.
189 + * @return @p this.
190 + */
191 + Slot1& operator=(const parent_type& src)
192 + { parent_type::operator=(src); return *this; }
193 +};
194 +
195 +/** Converts an arbitrary functor to a unified type which is opaque.
196 + * Slot2 itself is a functor or to be more precise a closure. It contains
197 + * a single, arbitrary functor (or closure) that is executed in operator()().
198 + *
199 + * The template arguments determine the function signature of operator()():
200 + * - @e T_return The return type of operator()().
201 + * - @e T_arg1 Argument type used in the definition of operator()().
202 + * - @e T_arg2 Argument type used in the definition of operator()().
203 + *
204 + * To use simply assign the slot to the desired functor. If the functor
205 + * is not compatible with the parameter list defined with the template
206 + * arguments compiler errors are triggered. When called the slot
207 + * will invoke the functor with minimal copies.
208 + * block() and unblock() can be used to block the functor's invocation
209 + * from operator()() temporarily.
210 + *
211 + * @par Example:
212 + * @code
213 + * #include <sigc++/slot.h>
214 + * void foo(int) {}
215 + * SigC::Slot1<void, long> s = SigC::slot(&foo);
216 + * s(19);
217 + * @endcode
218 + *
219 + * @deprecated Use the unnumbered template sigc::slot instead.
220 + * @ingroup compat
221 + */
222 +template <class T_return, class T_arg1,class T_arg2>
223 +class Slot2
224 + : public ::sigc::slot<T_return, T_arg1,T_arg2>
225 +{
226 +public:
227 + typedef ::sigc::slot<T_return, T_arg1,T_arg2> parent_type;
228 +
229 + /// Constructs an empty slot.
230 + Slot2() {}
231 +
232 + /** Constructs a slot from an arbitrary functor.
233 + * @param _A_func The desired functor the new slot should be assigned to.
234 + */
235 + template <class T_functor>
236 + Slot2(const T_functor& _A_func)
237 + : ::sigc::slot<T_return, T_arg1,T_arg2>(_A_func) {}
238 +
239 + /** Constructs a slot, copying an existing one.
240 + * @param src The existing slot to copy.
241 + */
242 + Slot2(const parent_type& src)
243 + : parent_type(src) {}
244 +
245 + /** Overrides this slot making a copy from another slot.
246 + * @param src The slot from which to make a copy.
247 + * @return @p this.
248 + */
249 + Slot2& operator=(const parent_type& src)
250 + { parent_type::operator=(src); return *this; }
251 +};
252 +
253 +/** Converts an arbitrary functor to a unified type which is opaque.
254 + * Slot3 itself is a functor or to be more precise a closure. It contains
255 + * a single, arbitrary functor (or closure) that is executed in operator()().
256 + *
257 + * The template arguments determine the function signature of operator()():
258 + * - @e T_return The return type of operator()().
259 + * - @e T_arg1 Argument type used in the definition of operator()().
260 + * - @e T_arg2 Argument type used in the definition of operator()().
261 + * - @e T_arg3 Argument type used in the definition of operator()().
262 + *
263 + * To use simply assign the slot to the desired functor. If the functor
264 + * is not compatible with the parameter list defined with the template
265 + * arguments compiler errors are triggered. When called the slot
266 + * will invoke the functor with minimal copies.
267 + * block() and unblock() can be used to block the functor's invocation
268 + * from operator()() temporarily.
269 + *
270 + * @par Example:
271 + * @code
272 + * #include <sigc++/slot.h>
273 + * void foo(int) {}
274 + * SigC::Slot1<void, long> s = SigC::slot(&foo);
275 + * s(19);
276 + * @endcode
277 + *
278 + * @deprecated Use the unnumbered template sigc::slot instead.
279 + * @ingroup compat
280 + */
281 +template <class T_return, class T_arg1,class T_arg2,class T_arg3>
282 +class Slot3
283 + : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3>
284 +{
285 +public:
286 + typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3> parent_type;
287 +
288 + /// Constructs an empty slot.
289 + Slot3() {}
290 +
291 + /** Constructs a slot from an arbitrary functor.
292 + * @param _A_func The desired functor the new slot should be assigned to.
293 + */
294 + template <class T_functor>
295 + Slot3(const T_functor& _A_func)
296 + : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3>(_A_func) {}
297 +
298 + /** Constructs a slot, copying an existing one.
299 + * @param src The existing slot to copy.
300 + */
301 + Slot3(const parent_type& src)
302 + : parent_type(src) {}
303 +
304 + /** Overrides this slot making a copy from another slot.
305 + * @param src The slot from which to make a copy.
306 + * @return @p this.
307 + */
308 + Slot3& operator=(const parent_type& src)
309 + { parent_type::operator=(src); return *this; }
310 +};
311 +
312 +/** Converts an arbitrary functor to a unified type which is opaque.
313 + * Slot4 itself is a functor or to be more precise a closure. It contains
314 + * a single, arbitrary functor (or closure) that is executed in operator()().
315 + *
316 + * The template arguments determine the function signature of operator()():
317 + * - @e T_return The return type of operator()().
318 + * - @e T_arg1 Argument type used in the definition of operator()().
319 + * - @e T_arg2 Argument type used in the definition of operator()().
320 + * - @e T_arg3 Argument type used in the definition of operator()().
321 + * - @e T_arg4 Argument type used in the definition of operator()().
322 + *
323 + * To use simply assign the slot to the desired functor. If the functor
324 + * is not compatible with the parameter list defined with the template
325 + * arguments compiler errors are triggered. When called the slot
326 + * will invoke the functor with minimal copies.
327 + * block() and unblock() can be used to block the functor's invocation
328 + * from operator()() temporarily.
329 + *
330 + * @par Example:
331 + * @code
332 + * #include <sigc++/slot.h>
333 + * void foo(int) {}
334 + * SigC::Slot1<void, long> s = SigC::slot(&foo);
335 + * s(19);
336 + * @endcode
337 + *
338 + * @deprecated Use the unnumbered template sigc::slot instead.
339 + * @ingroup compat
340 + */
341 +template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
342 +class Slot4
343 + : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
344 +{
345 +public:
346 + typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4> parent_type;
347 +
348 + /// Constructs an empty slot.
349 + Slot4() {}
350 +
351 + /** Constructs a slot from an arbitrary functor.
352 + * @param _A_func The desired functor the new slot should be assigned to.
353 + */
354 + template <class T_functor>
355 + Slot4(const T_functor& _A_func)
356 + : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(_A_func) {}
357 +
358 + /** Constructs a slot, copying an existing one.
359 + * @param src The existing slot to copy.
360 + */
361 + Slot4(const parent_type& src)
362 + : parent_type(src) {}
363 +
364 + /** Overrides this slot making a copy from another slot.
365 + * @param src The slot from which to make a copy.
366 + * @return @p this.
367 + */
368 + Slot4& operator=(const parent_type& src)
369 + { parent_type::operator=(src); return *this; }
370 +};
371 +
372 +/** Converts an arbitrary functor to a unified type which is opaque.
373 + * Slot5 itself is a functor or to be more precise a closure. It contains
374 + * a single, arbitrary functor (or closure) that is executed in operator()().
375 + *
376 + * The template arguments determine the function signature of operator()():
377 + * - @e T_return The return type of operator()().
378 + * - @e T_arg1 Argument type used in the definition of operator()().
379 + * - @e T_arg2 Argument type used in the definition of operator()().
380 + * - @e T_arg3 Argument type used in the definition of operator()().
381 + * - @e T_arg4 Argument type used in the definition of operator()().
382 + * - @e T_arg5 Argument type used in the definition of operator()().
383 + *
384 + * To use simply assign the slot to the desired functor. If the functor
385 + * is not compatible with the parameter list defined with the template
386 + * arguments compiler errors are triggered. When called the slot
387 + * will invoke the functor with minimal copies.
388 + * block() and unblock() can be used to block the functor's invocation
389 + * from operator()() temporarily.
390 + *
391 + * @par Example:
392 + * @code
393 + * #include <sigc++/slot.h>
394 + * void foo(int) {}
395 + * SigC::Slot1<void, long> s = SigC::slot(&foo);
396 + * s(19);
397 + * @endcode
398 + *
399 + * @deprecated Use the unnumbered template sigc::slot instead.
400 + * @ingroup compat
401 + */
402 +template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
403 +class Slot5
404 + : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
405 +{
406 +public:
407 + typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> parent_type;
408 +
409 + /// Constructs an empty slot.
410 + Slot5() {}
411 +
412 + /** Constructs a slot from an arbitrary functor.
413 + * @param _A_func The desired functor the new slot should be assigned to.
414 + */
415 + template <class T_functor>
416 + Slot5(const T_functor& _A_func)
417 + : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_func) {}
418 +
419 + /** Constructs a slot, copying an existing one.
420 + * @param src The existing slot to copy.
421 + */
422 + Slot5(const parent_type& src)
423 + : parent_type(src) {}
424 +
425 + /** Overrides this slot making a copy from another slot.
426 + * @param src The slot from which to make a copy.
427 + * @return @p this.
428 + */
429 + Slot5& operator=(const parent_type& src)
430 + { parent_type::operator=(src); return *this; }
431 +};
432 +
433 +/** Converts an arbitrary functor to a unified type which is opaque.
434 + * Slot6 itself is a functor or to be more precise a closure. It contains
435 + * a single, arbitrary functor (or closure) that is executed in operator()().
436 + *
437 + * The template arguments determine the function signature of operator()():
438 + * - @e T_return The return type of operator()().
439 + * - @e T_arg1 Argument type used in the definition of operator()().
440 + * - @e T_arg2 Argument type used in the definition of operator()().
441 + * - @e T_arg3 Argument type used in the definition of operator()().
442 + * - @e T_arg4 Argument type used in the definition of operator()().
443 + * - @e T_arg5 Argument type used in the definition of operator()().
444 + * - @e T_arg6 Argument type used in the definition of operator()().
445 + *
446 + * To use simply assign the slot to the desired functor. If the functor
447 + * is not compatible with the parameter list defined with the template
448 + * arguments compiler errors are triggered. When called the slot
449 + * will invoke the functor with minimal copies.
450 + * block() and unblock() can be used to block the functor's invocation
451 + * from operator()() temporarily.
452 + *
453 + * @par Example:
454 + * @code
455 + * #include <sigc++/slot.h>
456 + * void foo(int) {}
457 + * SigC::Slot1<void, long> s = SigC::slot(&foo);
458 + * s(19);
459 + * @endcode
460 + *
461 + * @deprecated Use the unnumbered template sigc::slot instead.
462 + * @ingroup compat
463 + */
464 +template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
465 +class Slot6
466 + : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
467 +{
468 +public:
469 + typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> parent_type;
470 +
471 + /// Constructs an empty slot.
472 + Slot6() {}
473 +
474 + /** Constructs a slot from an arbitrary functor.
475 + * @param _A_func The desired functor the new slot should be assigned to.
476 + */
477 + template <class T_functor>
478 + Slot6(const T_functor& _A_func)
479 + : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_func) {}
480 +
481 + /** Constructs a slot, copying an existing one.
482 + * @param src The existing slot to copy.
483 + */
484 + Slot6(const parent_type& src)
485 + : parent_type(src) {}
486 +
487 + /** Overrides this slot making a copy from another slot.
488 + * @param src The slot from which to make a copy.
489 + * @return @p this.
490 + */
491 + Slot6& operator=(const parent_type& src)
492 + { parent_type::operator=(src); return *this; }
493 +};
494 +
495 +/** Converts an arbitrary functor to a unified type which is opaque.
496 + * Slot7 itself is a functor or to be more precise a closure. It contains
497 + * a single, arbitrary functor (or closure) that is executed in operator()().
498 + *
499 + * The template arguments determine the function signature of operator()():
500 + * - @e T_return The return type of operator()().
501 + * - @e T_arg1 Argument type used in the definition of operator()().
502 + * - @e T_arg2 Argument type used in the definition of operator()().
503 + * - @e T_arg3 Argument type used in the definition of operator()().
504 + * - @e T_arg4 Argument type used in the definition of operator()().
505 + * - @e T_arg5 Argument type used in the definition of operator()().
506 + * - @e T_arg6 Argument type used in the definition of operator()().
507 + * - @e T_arg7 Argument type used in the definition of operator()().
508 + *
509 + * To use simply assign the slot to the desired functor. If the functor
510 + * is not compatible with the parameter list defined with the template
511 + * arguments compiler errors are triggered. When called the slot
512 + * will invoke the functor with minimal copies.
513 + * block() and unblock() can be used to block the functor's invocation
514 + * from operator()() temporarily.
515 + *
516 + * @par Example:
517 + * @code
518 + * #include <sigc++/slot.h>
519 + * void foo(int) {}
520 + * SigC::Slot1<void, long> s = SigC::slot(&foo);
521 + * s(19);
522 + * @endcode
523 + *
524 + * @deprecated Use the unnumbered template sigc::slot instead.
525 + * @ingroup compat
526 + */
527 +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>
528 +class Slot7
529 + : public ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
530 {
531 +public:
532 + typedef ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> parent_type;
533 +
534 + /// Constructs an empty slot.
535 + Slot7() {}
536 +
537 + /** Constructs a slot from an arbitrary functor.
538 + * @param _A_func The desired functor the new slot should be assigned to.
539 + */
540 + template <class T_functor>
541 + Slot7(const T_functor& _A_func)
542 + : ::sigc::slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(_A_func) {}
543 +
544 + /** Constructs a slot, copying an existing one.
545 + * @param src The existing slot to copy.
546 + */
547 + Slot7(const parent_type& src)
548 + : parent_type(src) {}
549 +
550 + /** Overrides this slot making a copy from another slot.
551 + * @param src The slot from which to make a copy.
552 + * @return @p this.
553 + */
554 + Slot7& operator=(const parent_type& src)
555 + { parent_type::operator=(src); return *this; }
556 +};
557 +
558 +
559 +
560 +#ifndef DOXYGEN_SHOULD_SKIP_THIS
561 +/* gcc 3.2 reports a strange conflict between SigC::slot() and sigc::slot<>
562 + * when "using namespace SigC" and later using a slot(obj,func) overload
563 + * without the prefix "SigC::". Probably a compiler bug. I will investigate.
564 + *
565 + * This ugly hack avoids the error:
566 + */
567 +// #define slot(...) make_slot(__VA_ARGS__) /* only works for gcc */
568 +#endif
569
570 +
571 +// slot()
572 +/** Creates a functor of type SigC::Slot0 that wraps an existing non-member function.
573 + *
574 + * @param _A_func Pointer to function that should be wrapped.
575 + * @return Functor that executes _A_func on invokation.
576 + *
577 + * @deprecated Use sigc::ptr_fun() instead.
578 + * @ingroup compat
579 + */
580 +template <class T_return>
581 +inline Slot0<T_return>
582 +slot(T_return (*_A_func)())
583 +{ return Slot0<T_return>(_A_func); }
584 +
585 +/** Creates a functor of type SigC::Slot1 that wraps an existing non-member function.
586 + *
587 + * @param _A_func Pointer to function that should be wrapped.
588 + * @return Functor that executes _A_func on invokation.
589 + *
590 + * @deprecated Use sigc::ptr_fun() instead.
591 + * @ingroup compat
592 + */
593 +template <class T_return, class T_arg1>
594 +inline Slot1<T_return, T_arg1>
595 +slot(T_return (*_A_func)(T_arg1))
596 +{ return Slot1<T_return, T_arg1>(_A_func); }
597 +
598 +/** Creates a functor of type SigC::Slot2 that wraps an existing non-member function.
599 + *
600 + * @param _A_func Pointer to function that should be wrapped.
601 + * @return Functor that executes _A_func on invokation.
602 + *
603 + * @deprecated Use sigc::ptr_fun() instead.
604 + * @ingroup compat
605 + */
606 +template <class T_return, class T_arg1,class T_arg2>
607 +inline Slot2<T_return, T_arg1,T_arg2>
608 +slot(T_return (*_A_func)(T_arg1,T_arg2))
609 +{ return Slot2<T_return, T_arg1,T_arg2>(_A_func); }
610 +
611 +/** Creates a functor of type SigC::Slot3 that wraps an existing non-member function.
612 + *
613 + * @param _A_func Pointer to function that should be wrapped.
614 + * @return Functor that executes _A_func on invokation.
615 + *
616 + * @deprecated Use sigc::ptr_fun() instead.
617 + * @ingroup compat
618 + */
619 +template <class T_return, class T_arg1,class T_arg2,class T_arg3>
620 +inline Slot3<T_return, T_arg1,T_arg2,T_arg3>
621 +slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3))
622 +{ return Slot3<T_return, T_arg1,T_arg2,T_arg3>(_A_func); }
623 +
624 +/** Creates a functor of type SigC::Slot4 that wraps an existing non-member function.
625 + *
626 + * @param _A_func Pointer to function that should be wrapped.
627 + * @return Functor that executes _A_func on invokation.
628 + *
629 + * @deprecated Use sigc::ptr_fun() instead.
630 + * @ingroup compat
631 + */
632 +template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
633 +inline Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
634 +slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4))
635 +{ return Slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>(_A_func); }
636 +
637 +/** Creates a functor of type SigC::Slot5 that wraps an existing non-member function.
638 + *
639 + * @param _A_func Pointer to function that should be wrapped.
640 + * @return Functor that executes _A_func on invokation.
641 + *
642 + * @deprecated Use sigc::ptr_fun() instead.
643 + * @ingroup compat
644 + */
645 +template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
646 +inline Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
647 +slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5))
648 +{ return Slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(_A_func); }
649 +
650 +/** Creates a functor of type SigC::Slot6 that wraps an existing non-member function.
651 + *
652 + * @param _A_func Pointer to function that should be wrapped.
653 + * @return Functor that executes _A_func on invokation.
654 + *
655 + * @deprecated Use sigc::ptr_fun() instead.
656 + * @ingroup compat
657 + */
658 +template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
659 +inline Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
660 +slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6))
661 +{ return Slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(_A_func); }
662 +
663 +/** Creates a functor of type SigC::Slot7 that wraps an existing non-member function.
664 + *
665 + * @param _A_func Pointer to function that should be wrapped.
666 + * @return Functor that executes _A_func on invokation.
667 + *
668 + * @deprecated Use sigc::ptr_fun() instead.
669 + * @ingroup compat
670 + */
671 +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>
672 +inline Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
673 +slot(T_return (*_A_func)(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7))
674 +{ return Slot7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(_A_func); }
675 +
676 +
677 +
678 +}
679 +
680 +// From sigc++/object.h
681 +namespace SigC {
682 +
683 +// Object
684 +typedef ::sigc::trackable Object;
685 +
686 +}
687 +
688 +namespace SigC
689 +{
690 template <class T_return, class T_obj1, class T_obj2>
691 inline Slot0<T_return>
692 slot( T_obj1& _A_obj, T_return (T_obj2::*_A_func)() )