16 files changed, 9424 insertions, 0 deletions
diff --git a/libs/sigc++2/sigc++/adaptors/adaptor_trait.h b/libs/sigc++2/sigc++/adaptors/adaptor_trait.h
new file mode 100644
index 0000000000..8b618d7450
--- /dev/null
+++ b/libs/sigc++2/sigc++/adaptors/adaptor_trait.h
@@ -0,0 +1,362 @@
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_ADAPTORS_MACROS_ADAPTOR_TRAITHM4_
+#define _SIGC_ADAPTORS_MACROS_ADAPTOR_TRAITHM4_
+#include <sigc++config.h> //To get SIGC_TEMPLATE_KEYWORD_OPERATOR_OVERLOAD
+#include <sigc++/visit_each.h>
+#include <sigc++/functors/functor_trait.h>
+#include <sigc++/functors/ptr_fun.h>
+#include <sigc++/functors/mem_fun.h>
+#include <sigc++/adaptors/deduce_result_type.h>
+
+namespace sigc {
+
+// Call either operator()<>() or sun_forte_workaround<>(),
+// depending on the compiler:
+#ifdef SIGC_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  #define SIGC_WORKAROUND_OPERATOR_PARENTHESES template operator()
+  #define SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+#else
+  #ifdef SIGC_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+    #define SIGC_WORKAROUND_OPERATOR_PARENTHESES operator()
+    #define SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  #else
+    #define SIGC_WORKAROUND_OPERATOR_PARENTHESES sun_forte_workaround
+  #endif
+#endif
+
+
+template <class T_functor> struct adapts;
+
+/** @defgroup adaptors Adaptors
+ * Adaptors are functors that alter the signature of a functor's
+ * operator()().
+ *
+ * The adaptor types libsigc++ provides
+ * are created with bind(), bind_return(), hide(), hide_return(),
+ * retype_return(), retype(), compose(), exception_catch() and group().
+ *
+ * You can easily derive your own adaptor type from sigc::adapts.
+ */
+
+/** Converts an arbitrary functor into an adaptor type.
+ * All adaptor tyes in libsigc++ are unnumbered and have
+ * a <tt>template operator()</tt> member of every argument count
+ * they support. These functions in turn invoke a stored adaptor's
+ * <tt>template operator()</tt> processing the arguments and return
+ * value in a characteristic manner. Explicit function template
+ * instantiation is used to pass type hints thus saving copy costs.
+ *
+ * adaptor_functor is a glue between adaptors and arbitrary functors
+ * that just passes on the arguments. You won't use this type directly.
+ *
+ * The template argument @e T_functor determines the type of stored
+ * functor.
+ *
+ * @ingroup adaptors
+ */
+template <class T_functor>
+struct adaptor_functor : public adaptor_base
+{
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename sigc::deduce_result_type<T_functor, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type type; };
+  typedef typename functor_trait<T_functor>::result_type result_type;
+
+  /** Invokes the wrapped functor passing on the arguments.
+   * @return The return value of the functor invocation.
+   */
+  result_type
+  operator()() const;
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  result_type sun_forte_workaround() const
+    { return operator(); }
+  #endif
+  
+  /** Invokes the wrapped functor passing on the arguments.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator()(T_arg1 _A_arg1) const
+    { return functor_(_A_arg1); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  sun_forte_workaround(T_arg1 _A_arg1) const
+    { //Just calling operator() tries to copy the argument:
+      return functor_(_A_arg1);
+    }
+  #endif
+  
+  /** Invokes the wrapped functor passing on the arguments.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2) const
+    { return functor_(_A_arg1,_A_arg2); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2) const
+    { //Just calling operator() tries to copy the argument:
+      return functor_(_A_arg1,_A_arg2);
+    }
+  #endif
+  
+  /** Invokes the wrapped functor passing on the arguments.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3) const
+    { return functor_(_A_arg1,_A_arg2,_A_arg3); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3) const
+    { //Just calling operator() tries to copy the argument:
+      return functor_(_A_arg1,_A_arg2,_A_arg3);
+    }
+  #endif
+  
+  /** Invokes the wrapped functor passing on the arguments.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4) const
+    { return functor_(_A_arg1,_A_arg2,_A_arg3,_A_arg4); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4) const
+    { //Just calling operator() tries to copy the argument:
+      return functor_(_A_arg1,_A_arg2,_A_arg3,_A_arg4);
+    }
+  #endif
+  
+  /** Invokes the wrapped functor passing on the arguments.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5) const
+    { return functor_(_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5) const
+    { //Just calling operator() tries to copy the argument:
+      return functor_(_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5);
+    }
+  #endif
+  
+  /** Invokes the wrapped functor passing on the arguments.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6) const
+    { return functor_(_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6) const
+    { //Just calling operator() tries to copy the argument:
+      return functor_(_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6);
+    }
+  #endif
+  
+  /** Invokes the wrapped functor passing on the arguments.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @param _A_arg7 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6,T_arg7 _A_arg7) const
+    { return functor_(_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6,_A_arg7); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6,T_arg7 _A_arg7) const
+    { //Just calling operator() tries to copy the argument:
+      return functor_(_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6,_A_arg7);
+    }
+  #endif
+  
+  /// Constructs an invalid functor.
+  adaptor_functor()
+    {}
+
+  /** Constructs an adaptor_functor object that wraps the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   */
+  explicit adaptor_functor(const T_functor& _A_functor)
+    : functor_(_A_functor)
+    {}
+
+  /** Constructs an adaptor_functor object that wraps the passed (member)
+   * function pointer.
+   * @param _A_type Pointer to function or class method to invoke from operator()().
+   */
+  template <class T_type>
+  explicit adaptor_functor(const T_type& _A_type)
+    : functor_(_A_type)
+    {}
+
+  /// Functor that is invoked from operator()().
+  mutable T_functor functor_;
+};
+
+template <class T_functor>
+typename adaptor_functor<T_functor>::result_type
+adaptor_functor<T_functor>::operator()() const
+  { return functor_(); }
+
+
+/** Performs a functor on each of the targets of a functor.
+ * The function overload for sigc::adaptor_functor performs a functor
+ * on the functor stored in the sigc::adaptor_functor object.
+ *
+ * @ingroup adaptors
+ */
+template <class T_action, class T_functor>
+void visit_each(const T_action& _A_action,
+                const adaptor_functor<T_functor>& _A_target)
+{
+  visit_each(_A_action, _A_target.functor_);
+}
+
+
+/** Trait that specifies what is the adaptor version of a functor type.
+ * Template specializations for sigc::adaptor_base derived functors,
+ * for function pointers and for class methods are provided.
+ *
+ * The template argument @e T_functor is the functor type to convert.
+ * @e I_isadaptor indicates whether @e T_functor inherits from sigc::adaptor_base.
+ *
+ * @ingroup adaptors
+ */
+template <class T_functor, bool I_isadaptor = is_base_and_derived<adaptor_base, T_functor>::value> struct adaptor_trait;
+
+/** Trait that specifies what is the adaptor version of a functor type.
+ * This template specialization is used for types that inherit from adaptor_base.
+ * adaptor_type is equal to @p T_functor in this case.
+ */
+template <class T_functor> 
+struct adaptor_trait<T_functor, true>
+{
+  typedef typename T_functor::result_type result_type;
+  typedef T_functor functor_type;
+  typedef T_functor adaptor_type;
+};
+
+/** Trait that specifies what is the adaptor version of a functor type.
+ * This template specialization is used for arbitrary functors,
+ * for function pointers and for class methods are provided.
+ * The latter are converted into @p pointer_functor or @p mem_functor types.
+ * adaptor_type is equal to @p adaptor_functor<functor_type>.
+ */
+template <class T_functor>
+struct adaptor_trait<T_functor, false>
+{
+  typedef typename functor_trait<T_functor>::result_type result_type;
+  typedef typename functor_trait<T_functor>::functor_type functor_type;
+  typedef adaptor_functor<functor_type> adaptor_type;
+};
+
+
+/** Base type for adaptors.
+ * adapts wraps adaptors, functors, function pointers and class methods.
+ * It contains a single member functor which is always a sigc::adaptor_base.
+ * The typedef adaptor_type defines the exact type that is used
+ * to store the adaptor, functor, function pointer or class method passed
+ * into the constructor. It differs from @e T_functor unless @e T_functor
+ * inherits from sigc::adaptor_base.
+ *
+ * @par Example of a simple adaptor:
+ *   @code
+ *   template <T_functor>
+ *   struct my_adpator : public sigc::adapts<T_functor>
+ *   {
+ *     template <class T_arg1=void, class T_arg2=void>
+ *     struct deduce_result_type
+ *     { typedef typename sigc::deduce_result_type<T_functor, T_arg1, T_arg2>::type type; };
+ *     typedef typename sigc::functor_trait<T_functor>::result_type result_type;
+ *
+ *     result_type
+ *     operator()() const;
+ *
+ *     template <class T_arg1>
+ *     typename deduce_result_type<T_arg1>::type
+ *     operator()(T_arg1 _A_arg1) const;
+ *
+ *     template <class T_arg1, class T_arg2>
+ *     typename deduce_result_type<T_arg1, T_arg2>::type
+ *     operator()(T_arg1 _A_arg1, class T_arg2) const;
+ *
+ *     explicit adaptor_functor(const T_functor& _A_functor) // Constructs a my_functor object that wraps the passed functor.
+ *       : sigc::adapts<T_functor>(_A_functor) {}
+ *
+ *     mutable T_functor functor_; // Functor that is invoked from operator()().
+ *   };
+ *   @endcode
+ *
+ * @ingroup adaptors
+ */
+template <class T_functor>
+struct adapts : public adaptor_base
+{
+  typedef typename adaptor_trait<T_functor>::result_type  result_type;
+  typedef typename adaptor_trait<T_functor>::adaptor_type adaptor_type;
+
+  /** Constructs an adaptor that wraps the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   */
+  explicit adapts(const T_functor& _A_functor)
+    : functor_(_A_functor)
+    {}
+
+  /// Adaptor that is invoked from operator()().
+  mutable adaptor_type functor_;
+};
+
+} /* namespace sigc */
+#endif /* _SIGC_ADAPTORS_MACROS_ADAPTOR_TRAITHM4_ */
diff --git a/libs/sigc++2/sigc++/adaptors/adaptors.h b/libs/sigc++2/sigc++/adaptors/adaptors.h
new file mode 100644
index 0000000000..950063b122
--- /dev/null
+++ b/libs/sigc++2/sigc++/adaptors/adaptors.h
@@ -0,0 +1,32 @@
+// -*- c++ -*-
+/*
+ * Copyright 2002, The libsigc++ Development Team
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+#ifndef _SIGC_ADAPTOR_HPP_
+#define _SIGC_ADAPTOR_HPP_
+
+#include <sigc++/adaptors/bind.h>
+#include <sigc++/adaptors/bind_return.h>
+#include <sigc++/adaptors/hide.h>
+#include <sigc++/adaptors/retype_return.h>
+#include <sigc++/adaptors/retype.h>
+#include <sigc++/adaptors/compose.h>
+#include <sigc++/adaptors/exception_catch.h>
+#include <sigc++/adaptors/lambda/lambda.h>
+
+#endif /* _SIGC_ADAPTOR_HPP_ */
diff --git a/libs/sigc++2/sigc++/adaptors/bind.h b/libs/sigc++2/sigc++/adaptors/bind.h
new file mode 100644
index 0000000000..81edaf7934
--- /dev/null
+++ b/libs/sigc++2/sigc++/adaptors/bind.h
@@ -0,0 +1,2262 @@
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_ADAPTORS_MACROS_BINDHM4_
+#define _SIGC_ADAPTORS_MACROS_BINDHM4_
+#include <sigc++/adaptors/adaptor_trait.h>
+
+namespace sigc { 
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+namespace internal {
+
+template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+struct count_void
+  { static const int value=0; };
+template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+struct count_void<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,void>
+  { static const int value=1; };
+template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+struct count_void<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,void,void>
+  { static const int value=2; };
+template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+struct count_void<T_arg1,T_arg2,T_arg3,T_arg4,void,void,void>
+  { static const int value=3; };
+template <class T_arg1,class T_arg2,class T_arg3>
+struct count_void<T_arg1,T_arg2,T_arg3,void,void,void,void>
+  { static const int value=4; };
+template <class T_arg1,class T_arg2>
+struct count_void<T_arg1,T_arg2,void,void,void,void,void>
+  { static const int value=5; };
+template <class T_arg1>
+struct count_void<T_arg1,void,void,void,void,void,void>
+  { static const int value=6; };
+template <>
+struct count_void<void,void,void,void,void,void,void>
+  { static const int value=7; };
+
+} /* namespace internal */
+
+#endif /*DOXYGEN_SHOULD_SKIP_THIS*/
+
+
+/** @defgroup bind bind(), bind_return()
+ * sigc::bind() alters an arbitrary functor by fixing arguments to certain values.
+ * Up to 7 arguments can be bound at a time.
+ * For single argument binding overloads of sigc::bind() are provided that let you
+ * specify the zero-based position of the argument to fix with the first template parameter.
+ * (A value of @p -1 fixes the last argument so sigc::bind<-1>() gives the same result as sigc::bind().)
+ * The types of the arguments can optionally be specified if not deduced.
+ *
+ * @par Examples:
+ *   @code
+ *   void foo(int, int, int);
+ *   // single argument binding ...
+ *   sigc::bind(&foo,1)(2,3);     //fixes the last (third) argument and calls foo(2,3,1)
+ *   sigc::bind<-1>(&foo,1)(2,3); //same as bind(&foo,1)(2,3) (calls foo(2,3,1))
+ *   sigc::bind<0>(&foo,1)(2,3);  //fixes the first argument and calls foo(1,2,3)
+ *   sigc::bind<1>(&foo,1)(2,3);  //fixes the second argument and calls foo(2,1,3)
+ *   sigc::bind<2>(&foo,1)(2,3);  //fixes the third argument and calls foo(2,3,1)
+ *   // multi argument binding ...
+ *   sigc::bind(&foo,1,2)(3);     //fixes the last two arguments and calls foo(3,1,2)
+ *   sigc::bind(&foo,1,2,3)();    //fixes all three arguments and calls foo(1,2,3)
+ *   @endcode
+ *
+ * The functor sigc::bind() returns can be passed into
+ * sigc::signal::connect() directly.
+ *
+ * @par Example:
+ *   @code
+ *   sigc::signal<void> some_signal;
+ *   void foo(int);
+ *   some_signal.connect(sigc::bind(&foo,1));
+ *   @endcode
+ *
+ * sigc::bind_return() alters an arbitrary functor by
+ * fixing its return value to a certain value.
+ *
+ * @par Example:
+ *   @code
+ *   void foo();
+ *   std::cout << sigc::bind_return(&foo, 5)(); // calls foo() and returns 5
+ *   @endcode
+ *
+ * You can bind references to functors by passing the objects through
+ * the sigc::ref() helper function.
+ *
+ * @par Example:
+ *   @code
+ *   int some_int;
+ *   sigc::signal<void> some_signal;
+ *   void foo(int&);
+ *   some_signal.connect(sigc::bind(&foo,sigc::ref(some_int)));
+ *   @endcode
+ *
+ * If you bind an object of a sigc::trackable derived type to a functor
+ * by reference, a slot assigned to the bind adaptor is cleared automatically
+ * when the object goes out of scope.
+ *
+ * @par Example:
+ *   @code
+ *   struct bar : public sigc::trackable {} some_bar;
+ *   sigc::signal<void> some_signal;
+ *   void foo(bar&);
+ *   some_signal.connect(sigc::bind(&foo,sigc::ref(some_bar)));
+ *     // disconnected automatically if some_bar goes out of scope
+ *   @endcode
+ *
+ * For a more powerful version of this functionality see the lambda
+ * library adaptor sigc::group() which can bind, hide and reorder
+ * arguments arbitrarily.  Although sigc::group() is more flexible,
+ * sigc::bind() provides a means of binding parameters when then total
+ * number of parameters called is variable.
+ *
+ * @ingroup adaptors
+ */
+
+/** Adaptor that binds an argument to the wrapped functor.
+ * Use the convenience function sigc::bind() to create an instance of sigc::bind_functor.
+ *
+ * The following template arguments are used:
+ * - @e I_location Zero-based position of the argument to fix (@p -1 for the last argument).
+
+ * - @e T_type1 Type of the 1st bound argument.
+ * - @e T_type2 Type of the 2st bound argument.
+ * - @e T_type3 Type of the 3st bound argument.
+ * - @e T_type4 Type of the 4st bound argument.
+ * - @e T_type5 Type of the 5st bound argument.
+ * - @e T_type6 Type of the 6st bound argument.
+ * - @e T_type7 Type of the 7st bound argument.
+ * - @e T_functor Type of the functor to wrap.
+ *
+ * @ingroup bind
+ */
+template <int I_location, class T_functor, class T_type1=nil,class T_type2=nil,class T_type3=nil,class T_type4=nil,class T_type5=nil,class T_type6=nil,class T_type7=nil>
+struct bind_functor;
+
+/** Adaptor that binds an argument to the wrapped functor.
+ * This template specialization fixes the 1th argument of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_bound>
+struct bind_functor<0, T_functor, T_bound> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor passing on the bound argument only.
+   * @return The return value of the functor invocation.
+   */
+  result_type
+  operator()();
+
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 1th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator()(T_arg1 _A_arg1)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass>
+        (bound_, _A_arg1);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  sun_forte_workaround(T_arg1 _A_arg1)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass>
+        (bound_, _A_arg1);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 1th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
+        (bound_, _A_arg1, _A_arg2);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
+        (bound_, _A_arg1, _A_arg2);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 1th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
+        (bound_, _A_arg1, _A_arg2, _A_arg3);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
+        (bound_, _A_arg1, _A_arg2, _A_arg3);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 1th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+        (bound_, _A_arg1, _A_arg2, _A_arg3, _A_arg4);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+        (bound_, _A_arg1, _A_arg2, _A_arg3, _A_arg4);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 1th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (bound_, _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (bound_, _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 1th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (bound_, _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (bound_, _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+    }
+  #endif
+    
+  /** Constructs a bind_functor object that binds an argument to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   * @param _A_bound Argument to bind to the functor.
+   */
+  bind_functor(typename type_trait<T_functor>::take _A_func, typename type_trait<T_bound>::take _A_bound)
+    : adapts<T_functor>(_A_func), bound_(_A_bound)
+    {}
+
+  /// The argument bound to the functor.
+  T_bound bound_;
+};
+
+template <class T_functor, class T_bound>
+typename bind_functor<0, T_functor, T_bound>::result_type
+bind_functor<0, T_functor, T_bound>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass> (bound_); }
+
+/** Adaptor that binds an argument to the wrapped functor.
+ * This template specialization fixes the 2th argument of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_bound>
+struct bind_functor<1, T_functor, T_bound> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor passing on the bound argument only.
+   * @return The return value of the functor invocation.
+   */
+  result_type
+  operator()();
+
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 2th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator()(T_arg1 _A_arg1)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1, bound_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  sun_forte_workaround(T_arg1 _A_arg1)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1, bound_);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 2th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass>
+        (_A_arg1, bound_, _A_arg2);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass>
+        (_A_arg1, bound_, _A_arg2);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 2th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
+        (_A_arg1, bound_, _A_arg2, _A_arg3);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
+        (_A_arg1, bound_, _A_arg2, _A_arg3);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 2th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+        (_A_arg1, bound_, _A_arg2, _A_arg3, _A_arg4);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+        (_A_arg1, bound_, _A_arg2, _A_arg3, _A_arg4);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 2th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_arg1, bound_, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_arg1, bound_, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 2th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_arg1, bound_, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_arg1, bound_, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+    }
+  #endif
+    
+  /** Constructs a bind_functor object that binds an argument to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   * @param _A_bound Argument to bind to the functor.
+   */
+  bind_functor(typename type_trait<T_functor>::take _A_func, typename type_trait<T_bound>::take _A_bound)
+    : adapts<T_functor>(_A_func), bound_(_A_bound)
+    {}
+
+  /// The argument bound to the functor.
+  T_bound bound_;
+};
+
+template <class T_functor, class T_bound>
+typename bind_functor<1, T_functor, T_bound>::result_type
+bind_functor<1, T_functor, T_bound>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass> (bound_); }
+
+/** Adaptor that binds an argument to the wrapped functor.
+ * This template specialization fixes the 3th argument of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_bound>
+struct bind_functor<2, T_functor, T_bound> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor passing on the bound argument only.
+   * @return The return value of the functor invocation.
+   */
+  result_type
+  operator()();
+
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 3th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1,_A_arg2, bound_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1,_A_arg2, bound_);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 3th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass>
+        (_A_arg1,_A_arg2, bound_, _A_arg3);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass>
+        (_A_arg1,_A_arg2, bound_, _A_arg3);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 3th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+        (_A_arg1,_A_arg2, bound_, _A_arg3, _A_arg4);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+        (_A_arg1,_A_arg2, bound_, _A_arg3, _A_arg4);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 3th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_arg1,_A_arg2, bound_, _A_arg3, _A_arg4, _A_arg5);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_arg1,_A_arg2, bound_, _A_arg3, _A_arg4, _A_arg5);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 3th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_arg1,_A_arg2, bound_, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_arg1,_A_arg2, bound_, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+    }
+  #endif
+    
+  /** Constructs a bind_functor object that binds an argument to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   * @param _A_bound Argument to bind to the functor.
+   */
+  bind_functor(typename type_trait<T_functor>::take _A_func, typename type_trait<T_bound>::take _A_bound)
+    : adapts<T_functor>(_A_func), bound_(_A_bound)
+    {}
+
+  /// The argument bound to the functor.
+  T_bound bound_;
+};
+
+template <class T_functor, class T_bound>
+typename bind_functor<2, T_functor, T_bound>::result_type
+bind_functor<2, T_functor, T_bound>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass> (bound_); }
+
+/** Adaptor that binds an argument to the wrapped functor.
+ * This template specialization fixes the 4th argument of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_bound>
+struct bind_functor<3, T_functor, T_bound> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor passing on the bound argument only.
+   * @return The return value of the functor invocation.
+   */
+  result_type
+  operator()();
+
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 4th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound_);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 4th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg4>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound_, _A_arg4);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg4>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound_, _A_arg4);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 4th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound_, _A_arg4, _A_arg5);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound_, _A_arg4, _A_arg5);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 4th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound_, _A_arg4, _A_arg5, _A_arg6);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound_, _A_arg4, _A_arg5, _A_arg6);
+    }
+  #endif
+    
+  /** Constructs a bind_functor object that binds an argument to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   * @param _A_bound Argument to bind to the functor.
+   */
+  bind_functor(typename type_trait<T_functor>::take _A_func, typename type_trait<T_bound>::take _A_bound)
+    : adapts<T_functor>(_A_func), bound_(_A_bound)
+    {}
+
+  /// The argument bound to the functor.
+  T_bound bound_;
+};
+
+template <class T_functor, class T_bound>
+typename bind_functor<3, T_functor, T_bound>::result_type
+bind_functor<3, T_functor, T_bound>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass> (bound_); }
+
+/** Adaptor that binds an argument to the wrapped functor.
+ * This template specialization fixes the 5th argument of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_bound>
+struct bind_functor<4, T_functor, T_bound> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor passing on the bound argument only.
+   * @return The return value of the functor invocation.
+   */
+  result_type
+  operator()();
+
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 5th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 5th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg5>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_, _A_arg5);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg5>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_, _A_arg5);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 5th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_, _A_arg5, _A_arg6);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_, _A_arg5, _A_arg6);
+    }
+  #endif
+    
+  /** Constructs a bind_functor object that binds an argument to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   * @param _A_bound Argument to bind to the functor.
+   */
+  bind_functor(typename type_trait<T_functor>::take _A_func, typename type_trait<T_bound>::take _A_bound)
+    : adapts<T_functor>(_A_func), bound_(_A_bound)
+    {}
+
+  /// The argument bound to the functor.
+  T_bound bound_;
+};
+
+template <class T_functor, class T_bound>
+typename bind_functor<4, T_functor, T_bound>::result_type
+bind_functor<4, T_functor, T_bound>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass> (bound_); }
+
+/** Adaptor that binds an argument to the wrapped functor.
+ * This template specialization fixes the 6th argument of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_bound>
+struct bind_functor<5, T_functor, T_bound> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg6>::pass>::type type; };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor passing on the bound argument only.
+   * @return The return value of the functor invocation.
+   */
+  result_type
+  operator()();
+
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 6th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound_);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 6th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg6>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound_, _A_arg6);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg6>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound_, _A_arg6);
+    }
+  #endif
+    
+  /** Constructs a bind_functor object that binds an argument to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   * @param _A_bound Argument to bind to the functor.
+   */
+  bind_functor(typename type_trait<T_functor>::take _A_func, typename type_trait<T_bound>::take _A_bound)
+    : adapts<T_functor>(_A_func), bound_(_A_bound)
+    {}
+
+  /// The argument bound to the functor.
+  T_bound bound_;
+};
+
+template <class T_functor, class T_bound>
+typename bind_functor<5, T_functor, T_bound>::result_type
+bind_functor<5, T_functor, T_bound>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass> (bound_); }
+
+/** Adaptor that binds an argument to the wrapped functor.
+ * This template specialization fixes the 7th argument of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_bound>
+struct bind_functor<6, T_functor, T_bound> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<T_bound>::pass>::type type; };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor passing on the bound argument only.
+   * @return The return value of the functor invocation.
+   */
+  result_type
+  operator()();
+
+  /** Invokes the wrapped functor passing on the arguments.
+   * bound_ is passed as the 7th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6, bound_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6, bound_);
+    }
+  #endif
+    
+  /** Constructs a bind_functor object that binds an argument to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   * @param _A_bound Argument to bind to the functor.
+   */
+  bind_functor(typename type_trait<T_functor>::take _A_func, typename type_trait<T_bound>::take _A_bound)
+    : adapts<T_functor>(_A_func), bound_(_A_bound)
+    {}
+
+  /// The argument bound to the functor.
+  T_bound bound_;
+};
+
+template <class T_functor, class T_bound>
+typename bind_functor<6, T_functor, T_bound>::result_type
+bind_functor<6, T_functor, T_bound>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass> (bound_); }
+
+/** Performs a functor on each of the targets of a functor.
+ * The function overload for sigc::bind_functor performs a functor on the
+ * functor and on the object instances stored in the sigc::bind_functor object.
+ *
+ * @ingroup bind
+ */
+template <class T_action, int T_loc, class T_functor, class T_bound>
+void visit_each(const T_action& _A_action,
+                const bind_functor<T_loc, T_functor, T_bound>& _A_target)
+{
+  visit_each(_A_action, _A_target.functor_);
+  visit_each(_A_action, _A_target.bound_);
+}
+
+/** Adaptor that binds 1 argument(s) to the wrapped functor.
+ * This template specialization fixes the last 1 argument(s) of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_type1>
+struct bind_functor<-1, T_functor, T_type1> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  template <int count, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<T_type1>::pass>::type type; };
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal<2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_type1>::pass>::type type; };
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal<3, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass>::type type; };
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal<4, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass>::type type; };
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal<5, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass>::type type; };
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal<6, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass>::type type; };
+#endif /*DOXYGEN_SHOULD_SKIP_THIS*/
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type {
+    typedef typename deduce_result_type_internal<internal::count_void<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::value,
+                                                 T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type type;
+  };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor passing on the bound argument only.
+   * @return The return value of the functor invocation.
+   */
+  result_type
+  operator()();
+
+  /** Invokes the wrapped functor passing on the arguments.
+   * The last 1 argument(s) are fixed.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator()(T_arg1 _A_arg1)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1, bound1_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  sun_forte_workaround(T_arg1 _A_arg1)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1, bound1_);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * The last 1 argument(s) are fixed.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1,_A_arg2, bound1_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1,_A_arg2, bound1_);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * The last 1 argument(s) are fixed.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound1_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound1_);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * The last 1 argument(s) are fixed.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * The last 1 argument(s) are fixed.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound1_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound1_);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * The last 1 argument(s) are fixed.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6, bound1_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6, bound1_);
+    }
+  #endif
+    
+  /** Constructs a bind_functor object that binds an argument to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   * @param _A_bound Argument to bind to the functor.
+   */
+  bind_functor(typename type_trait<T_functor>::take _A_func, typename type_trait<T_type1>::take _A_bound1)
+    : adapts<T_functor>(_A_func), bound1_(_A_bound1)
+    {}
+
+  /// The argument bound to the functor.
+  T_type1 bound1_;
+};
+
+template <class T_functor, class T_type1>
+typename bind_functor<-1, T_functor, T_type1>::result_type
+bind_functor<-1, T_functor, T_type1>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::pass> (bound1_); }
+
+/** Performs a functor on each of the targets of a functor.
+ * The function overload for sigc::bind_functor performs a functor on the
+ * functor and on the object instances stored in the sigc::bind_functor object.
+ *
+ * @ingroup bind
+ */
+template <class T_action, class T_functor, class T_type1>
+void visit_each(const T_action& _A_action,
+                const bind_functor<-1, T_functor, T_type1>& _A_target)
+{
+  visit_each(_A_action, _A_target.functor_);
+  visit_each(_A_action, _A_target.bound1_);
+}
+
+/** Adaptor that binds 2 argument(s) to the wrapped functor.
+ * This template specialization fixes the last 2 argument(s) of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_type1,class T_type2>
+struct bind_functor<-1, T_functor, T_type1,T_type2> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  template <int count, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>::type type; };
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal<3, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>::type type; };
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal<4, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>::type type; };
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal<5, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>::type type; };
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal<6, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>::type type; };
+#endif /*DOXYGEN_SHOULD_SKIP_THIS*/
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type {
+    typedef typename deduce_result_type_internal<internal::count_void<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::value,
+                                                 T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type type;
+  };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor passing on the bound argument only.
+   * @return The return value of the functor invocation.
+   */
+  result_type
+  operator()();
+
+  /** Invokes the wrapped functor passing on the arguments.
+   * The last 2 argument(s) are fixed.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator()(T_arg1 _A_arg1)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
+        (_A_arg1, bound1_,bound2_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  sun_forte_workaround(T_arg1 _A_arg1)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
+        (_A_arg1, bound1_,bound2_);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * The last 2 argument(s) are fixed.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
+        (_A_arg1,_A_arg2, bound1_,bound2_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
+        (_A_arg1,_A_arg2, bound1_,bound2_);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * The last 2 argument(s) are fixed.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound1_,bound2_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound1_,bound2_);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * The last 2 argument(s) are fixed.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_,bound2_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_,bound2_);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * The last 2 argument(s) are fixed.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound1_,bound2_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound1_,bound2_);
+    }
+  #endif
+    
+  /** Constructs a bind_functor object that binds an argument to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   * @param _A_bound Argument to bind to the functor.
+   */
+  bind_functor(typename type_trait<T_functor>::take _A_func, typename type_trait<T_type1>::take _A_bound1,typename type_trait<T_type2>::take _A_bound2)
+    : adapts<T_functor>(_A_func), bound1_(_A_bound1),bound2_(_A_bound2)
+    {}
+
+  /// The argument bound to the functor.
+  T_type1 bound1_;
+  T_type2 bound2_;
+};
+
+template <class T_functor, class T_type1,class T_type2>
+typename bind_functor<-1, T_functor, T_type1,T_type2>::result_type
+bind_functor<-1, T_functor, T_type1,T_type2>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass> (bound1_,bound2_); }
+
+/** Performs a functor on each of the targets of a functor.
+ * The function overload for sigc::bind_functor performs a functor on the
+ * functor and on the object instances stored in the sigc::bind_functor object.
+ *
+ * @ingroup bind
+ */
+template <class T_action, class T_functor, class T_type1,class T_type2>
+void visit_each(const T_action& _A_action,
+                const bind_functor<-1, T_functor, T_type1,T_type2>& _A_target)
+{
+  visit_each(_A_action, _A_target.functor_);
+  visit_each(_A_action, _A_target.bound1_);
+  visit_each(_A_action, _A_target.bound2_);
+}
+
+/** Adaptor that binds 3 argument(s) to the wrapped functor.
+ * This template specialization fixes the last 3 argument(s) of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_type1,class T_type2,class T_type3>
+struct bind_functor<-1, T_functor, T_type1,T_type2,T_type3> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  template <int count, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>::type type; };
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal<4, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>::type type; };
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal<5, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>::type type; };
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal<6, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>::type type; };
+#endif /*DOXYGEN_SHOULD_SKIP_THIS*/
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type {
+    typedef typename deduce_result_type_internal<internal::count_void<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::value,
+                                                 T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type type;
+  };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor passing on the bound argument only.
+   * @return The return value of the functor invocation.
+   */
+  result_type
+  operator()();
+
+  /** Invokes the wrapped functor passing on the arguments.
+   * The last 3 argument(s) are fixed.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator()(T_arg1 _A_arg1)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
+        (_A_arg1, bound1_,bound2_,bound3_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  sun_forte_workaround(T_arg1 _A_arg1)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
+        (_A_arg1, bound1_,bound2_,bound3_);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * The last 3 argument(s) are fixed.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
+        (_A_arg1,_A_arg2, bound1_,bound2_,bound3_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
+        (_A_arg1,_A_arg2, bound1_,bound2_,bound3_);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * The last 3 argument(s) are fixed.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound1_,bound2_,bound3_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound1_,bound2_,bound3_);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * The last 3 argument(s) are fixed.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_,bound2_,bound3_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_,bound2_,bound3_);
+    }
+  #endif
+    
+  /** Constructs a bind_functor object that binds an argument to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   * @param _A_bound Argument to bind to the functor.
+   */
+  bind_functor(typename type_trait<T_functor>::take _A_func, typename type_trait<T_type1>::take _A_bound1,typename type_trait<T_type2>::take _A_bound2,typename type_trait<T_type3>::take _A_bound3)
+    : adapts<T_functor>(_A_func), bound1_(_A_bound1),bound2_(_A_bound2),bound3_(_A_bound3)
+    {}
+
+  /// The argument bound to the functor.
+  T_type1 bound1_;
+  T_type2 bound2_;
+  T_type3 bound3_;
+};
+
+template <class T_functor, class T_type1,class T_type2,class T_type3>
+typename bind_functor<-1, T_functor, T_type1,T_type2,T_type3>::result_type
+bind_functor<-1, T_functor, T_type1,T_type2,T_type3>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass> (bound1_,bound2_,bound3_); }
+
+/** Performs a functor on each of the targets of a functor.
+ * The function overload for sigc::bind_functor performs a functor on the
+ * functor and on the object instances stored in the sigc::bind_functor object.
+ *
+ * @ingroup bind
+ */
+template <class T_action, class T_functor, class T_type1,class T_type2,class T_type3>
+void visit_each(const T_action& _A_action,
+                const bind_functor<-1, T_functor, T_type1,T_type2,T_type3>& _A_target)
+{
+  visit_each(_A_action, _A_target.functor_);
+  visit_each(_A_action, _A_target.bound1_);
+  visit_each(_A_action, _A_target.bound2_);
+  visit_each(_A_action, _A_target.bound3_);
+}
+
+/** Adaptor that binds 4 argument(s) to the wrapped functor.
+ * This template specialization fixes the last 4 argument(s) of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4>
+struct bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  template <int count, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>::type type; };
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal<5, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>::type type; };
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal<6, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>::type type; };
+#endif /*DOXYGEN_SHOULD_SKIP_THIS*/
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type {
+    typedef typename deduce_result_type_internal<internal::count_void<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::value,
+                                                 T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type type;
+  };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor passing on the bound argument only.
+   * @return The return value of the functor invocation.
+   */
+  result_type
+  operator()();
+
+  /** Invokes the wrapped functor passing on the arguments.
+   * The last 4 argument(s) are fixed.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator()(T_arg1 _A_arg1)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>
+        (_A_arg1, bound1_,bound2_,bound3_,bound4_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  sun_forte_workaround(T_arg1 _A_arg1)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>
+        (_A_arg1, bound1_,bound2_,bound3_,bound4_);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * The last 4 argument(s) are fixed.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>
+        (_A_arg1,_A_arg2, bound1_,bound2_,bound3_,bound4_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>
+        (_A_arg1,_A_arg2, bound1_,bound2_,bound3_,bound4_);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * The last 4 argument(s) are fixed.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound1_,bound2_,bound3_,bound4_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound1_,bound2_,bound3_,bound4_);
+    }
+  #endif
+    
+  /** Constructs a bind_functor object that binds an argument to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   * @param _A_bound Argument to bind to the functor.
+   */
+  bind_functor(typename type_trait<T_functor>::take _A_func, typename type_trait<T_type1>::take _A_bound1,typename type_trait<T_type2>::take _A_bound2,typename type_trait<T_type3>::take _A_bound3,typename type_trait<T_type4>::take _A_bound4)
+    : adapts<T_functor>(_A_func), bound1_(_A_bound1),bound2_(_A_bound2),bound3_(_A_bound3),bound4_(_A_bound4)
+    {}
+
+  /// The argument bound to the functor.
+  T_type1 bound1_;
+  T_type2 bound2_;
+  T_type3 bound3_;
+  T_type4 bound4_;
+};
+
+template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4>
+typename bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4>::result_type
+bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass> (bound1_,bound2_,bound3_,bound4_); }
+
+/** Performs a functor on each of the targets of a functor.
+ * The function overload for sigc::bind_functor performs a functor on the
+ * functor and on the object instances stored in the sigc::bind_functor object.
+ *
+ * @ingroup bind
+ */
+template <class T_action, class T_functor, class T_type1,class T_type2,class T_type3,class T_type4>
+void visit_each(const T_action& _A_action,
+                const bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4>& _A_target)
+{
+  visit_each(_A_action, _A_target.functor_);
+  visit_each(_A_action, _A_target.bound1_);
+  visit_each(_A_action, _A_target.bound2_);
+  visit_each(_A_action, _A_target.bound3_);
+  visit_each(_A_action, _A_target.bound4_);
+}
+
+/** Adaptor that binds 5 argument(s) to the wrapped functor.
+ * This template specialization fixes the last 5 argument(s) of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5>
+struct bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  template <int count, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass>::type type; };
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal<6, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass>::type type; };
+#endif /*DOXYGEN_SHOULD_SKIP_THIS*/
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type {
+    typedef typename deduce_result_type_internal<internal::count_void<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::value,
+                                                 T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type type;
+  };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor passing on the bound argument only.
+   * @return The return value of the functor invocation.
+   */
+  result_type
+  operator()();
+
+  /** Invokes the wrapped functor passing on the arguments.
+   * The last 5 argument(s) are fixed.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator()(T_arg1 _A_arg1)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass>
+        (_A_arg1, bound1_,bound2_,bound3_,bound4_,bound5_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  sun_forte_workaround(T_arg1 _A_arg1)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass>
+        (_A_arg1, bound1_,bound2_,bound3_,bound4_,bound5_);
+    }
+  #endif
+    
+  /** Invokes the wrapped functor passing on the arguments.
+   * The last 5 argument(s) are fixed.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass>
+        (_A_arg1,_A_arg2, bound1_,bound2_,bound3_,bound4_,bound5_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass>
+        (_A_arg1,_A_arg2, bound1_,bound2_,bound3_,bound4_,bound5_);
+    }
+  #endif
+    
+  /** Constructs a bind_functor object that binds an argument to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   * @param _A_bound Argument to bind to the functor.
+   */
+  bind_functor(typename type_trait<T_functor>::take _A_func, typename type_trait<T_type1>::take _A_bound1,typename type_trait<T_type2>::take _A_bound2,typename type_trait<T_type3>::take _A_bound3,typename type_trait<T_type4>::take _A_bound4,typename type_trait<T_type5>::take _A_bound5)
+    : adapts<T_functor>(_A_func), bound1_(_A_bound1),bound2_(_A_bound2),bound3_(_A_bound3),bound4_(_A_bound4),bound5_(_A_bound5)
+    {}
+
+  /// The argument bound to the functor.
+  T_type1 bound1_;
+  T_type2 bound2_;
+  T_type3 bound3_;
+  T_type4 bound4_;
+  T_type5 bound5_;
+};
+
+template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5>
+typename bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5>::result_type
+bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass> (bound1_,bound2_,bound3_,bound4_,bound5_); }
+
+/** Performs a functor on each of the targets of a functor.
+ * The function overload for sigc::bind_functor performs a functor on the
+ * functor and on the object instances stored in the sigc::bind_functor object.
+ *
+ * @ingroup bind
+ */
+template <class T_action, class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5>
+void visit_each(const T_action& _A_action,
+                const bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5>& _A_target)
+{
+  visit_each(_A_action, _A_target.functor_);
+  visit_each(_A_action, _A_target.bound1_);
+  visit_each(_A_action, _A_target.bound2_);
+  visit_each(_A_action, _A_target.bound3_);
+  visit_each(_A_action, _A_target.bound4_);
+  visit_each(_A_action, _A_target.bound5_);
+}
+
+/** Adaptor that binds 6 argument(s) to the wrapped functor.
+ * This template specialization fixes the last 6 argument(s) of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6>
+struct bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  template <int count, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass,typename type_trait<T_type6>::pass>::type type; };
+#endif /*DOXYGEN_SHOULD_SKIP_THIS*/
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type {
+    typedef typename deduce_result_type_internal<internal::count_void<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::value,
+                                                 T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type type;
+  };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor passing on the bound argument only.
+   * @return The return value of the functor invocation.
+   */
+  result_type
+  operator()();
+
+  /** Invokes the wrapped functor passing on the arguments.
+   * The last 6 argument(s) are fixed.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator()(T_arg1 _A_arg1)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass,typename type_trait<T_type6>::pass>
+        (_A_arg1, bound1_,bound2_,bound3_,bound4_,bound5_,bound6_);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  sun_forte_workaround(T_arg1 _A_arg1)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass,typename type_trait<T_type6>::pass>
+        (_A_arg1, bound1_,bound2_,bound3_,bound4_,bound5_,bound6_);
+    }
+  #endif
+    
+  /** Constructs a bind_functor object that binds an argument to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   * @param _A_bound Argument to bind to the functor.
+   */
+  bind_functor(typename type_trait<T_functor>::take _A_func, typename type_trait<T_type1>::take _A_bound1,typename type_trait<T_type2>::take _A_bound2,typename type_trait<T_type3>::take _A_bound3,typename type_trait<T_type4>::take _A_bound4,typename type_trait<T_type5>::take _A_bound5,typename type_trait<T_type6>::take _A_bound6)
+    : adapts<T_functor>(_A_func), bound1_(_A_bound1),bound2_(_A_bound2),bound3_(_A_bound3),bound4_(_A_bound4),bound5_(_A_bound5),bound6_(_A_bound6)
+    {}
+
+  /// The argument bound to the functor.
+  T_type1 bound1_;
+  T_type2 bound2_;
+  T_type3 bound3_;
+  T_type4 bound4_;
+  T_type5 bound5_;
+  T_type6 bound6_;
+};
+
+template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6>
+typename bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6>::result_type
+bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass,typename type_trait<T_type6>::pass> (bound1_,bound2_,bound3_,bound4_,bound5_,bound6_); }
+
+/** Performs a functor on each of the targets of a functor.
+ * The function overload for sigc::bind_functor performs a functor on the
+ * functor and on the object instances stored in the sigc::bind_functor object.
+ *
+ * @ingroup bind
+ */
+template <class T_action, class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6>
+void visit_each(const T_action& _A_action,
+                const bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6>& _A_target)
+{
+  visit_each(_A_action, _A_target.functor_);
+  visit_each(_A_action, _A_target.bound1_);
+  visit_each(_A_action, _A_target.bound2_);
+  visit_each(_A_action, _A_target.bound3_);
+  visit_each(_A_action, _A_target.bound4_);
+  visit_each(_A_action, _A_target.bound5_);
+  visit_each(_A_action, _A_target.bound6_);
+}
+
+/** Adaptor that binds 7 argument(s) to the wrapped functor.
+ * This template specialization fixes the last 7 argument(s) of the wrapped functor.
+ *
+ * @ingroup bind
+ */
+template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6,class T_type7>
+struct bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+  template <int count, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  struct deduce_result_type_internal
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass,typename type_trait<T_type6>::pass,typename type_trait<T_type7>::pass>::type type; };
+#endif /*DOXYGEN_SHOULD_SKIP_THIS*/
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type {
+    typedef typename deduce_result_type_internal<internal::count_void<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::value,
+                                                 T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type type;
+  };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor passing on the bound argument only.
+   * @return The return value of the functor invocation.
+   */
+  result_type
+  operator()();
+
+  /** Constructs a bind_functor object that binds an argument to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   * @param _A_bound Argument to bind to the functor.
+   */
+  bind_functor(typename type_trait<T_functor>::take _A_func, typename type_trait<T_type1>::take _A_bound1,typename type_trait<T_type2>::take _A_bound2,typename type_trait<T_type3>::take _A_bound3,typename type_trait<T_type4>::take _A_bound4,typename type_trait<T_type5>::take _A_bound5,typename type_trait<T_type6>::take _A_bound6,typename type_trait<T_type7>::take _A_bound7)
+    : adapts<T_functor>(_A_func), bound1_(_A_bound1),bound2_(_A_bound2),bound3_(_A_bound3),bound4_(_A_bound4),bound5_(_A_bound5),bound6_(_A_bound6),bound7_(_A_bound7)
+    {}
+
+  /// The argument bound to the functor.
+  T_type1 bound1_;
+  T_type2 bound2_;
+  T_type3 bound3_;
+  T_type4 bound4_;
+  T_type5 bound5_;
+  T_type6 bound6_;
+  T_type7 bound7_;
+};
+
+template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6,class T_type7>
+typename bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>::result_type
+bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass,typename type_trait<T_type6>::pass,typename type_trait<T_type7>::pass> (bound1_,bound2_,bound3_,bound4_,bound5_,bound6_,bound7_); }
+
+/** Performs a functor on each of the targets of a functor.
+ * The function overload for sigc::bind_functor performs a functor on the
+ * functor and on the object instances stored in the sigc::bind_functor object.
+ *
+ * @ingroup bind
+ */
+template <class T_action, class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6,class T_type7>
+void visit_each(const T_action& _A_action,
+                const bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>& _A_target)
+{
+  visit_each(_A_action, _A_target.functor_);
+  visit_each(_A_action, _A_target.bound1_);
+  visit_each(_A_action, _A_target.bound2_);
+  visit_each(_A_action, _A_target.bound3_);
+  visit_each(_A_action, _A_target.bound4_);
+  visit_each(_A_action, _A_target.bound5_);
+  visit_each(_A_action, _A_target.bound6_);
+  visit_each(_A_action, _A_target.bound7_);
+}
+
+
+/** Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor.
+ * The optional template argument @e I_location specifies the zero-based
+ * position of the argument to be fixed (@p -1 stands for the last argument).
+ *
+ * @param _A_func Functor that should be wrapped.
+ * @param _A_b1 Argument to bind to @e _A_func.
+ * @return Adaptor that executes @e _A_func with the bound argument on invokation.
+ *
+ * @ingroup bind
+ */
+template <int I_location, class T_bound1, class T_functor>
+inline bind_functor<I_location, T_functor, typename unwrap_reference<T_bound1>::type>
+bind(const T_functor& _A_func, T_bound1 _A_b1)
+{ 
+  return bind_functor<I_location, T_functor, typename unwrap_reference<T_bound1>::type>
+           (_A_func, _A_b1);
+}
+
+/** Creates an adaptor of type sigc::bind_functor which fixes the last 1 argument(s) of the passed functor.
+ * This function overload fixes the last 1 argument(s) of @e _A_func.
+ *
+ * @param _A_func Functor that should be wrapped.
+ * @param _A_b1 Argument to bind to @e _A_func.
+ * @return Adaptor that executes _A_func with the bound argument on invokation.
+ *
+ * @ingroup bind
+ */
+template <class T_type1, class T_functor>
+inline bind_functor<-1, T_functor,
+                    typename unwrap_reference<T_type1>::type>
+bind(const T_functor& _A_func, T_type1 _A_b1)
+{ return bind_functor<-1, T_functor,
+                    typename unwrap_reference<T_type1>::type>
+                    (_A_func, _A_b1);
+}
+
+/** Creates an adaptor of type sigc::bind_functor which fixes the last 2 argument(s) of the passed functor.
+ * This function overload fixes the last 2 argument(s) of @e _A_func.
+ *
+ * @param _A_func Functor that should be wrapped.
+ * @param _A_b1 Argument to bind to @e _A_func.
+ * @param _A_b2 Argument to bind to @e _A_func.
+ * @return Adaptor that executes _A_func with the bound argument on invokation.
+ *
+ * @ingroup bind
+ */
+template <class T_type1,class T_type2, class T_functor>
+inline bind_functor<-1, T_functor,
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type>
+bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2)
+{ return bind_functor<-1, T_functor,
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type>
+                    (_A_func, _A_b1,_A_b2);
+}
+
+/** Creates an adaptor of type sigc::bind_functor which fixes the last 3 argument(s) of the passed functor.
+ * This function overload fixes the last 3 argument(s) of @e _A_func.
+ *
+ * @param _A_func Functor that should be wrapped.
+ * @param _A_b1 Argument to bind to @e _A_func.
+ * @param _A_b2 Argument to bind to @e _A_func.
+ * @param _A_b3 Argument to bind to @e _A_func.
+ * @return Adaptor that executes _A_func with the bound argument on invokation.
+ *
+ * @ingroup bind
+ */
+template <class T_type1,class T_type2,class T_type3, class T_functor>
+inline bind_functor<-1, T_functor,
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type,
+                    typename unwrap_reference<T_type3>::type>
+bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2,T_type3 _A_b3)
+{ return bind_functor<-1, T_functor,
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type,
+                    typename unwrap_reference<T_type3>::type>
+                    (_A_func, _A_b1,_A_b2,_A_b3);
+}
+
+/** Creates an adaptor of type sigc::bind_functor which fixes the last 4 argument(s) of the passed functor.
+ * This function overload fixes the last 4 argument(s) of @e _A_func.
+ *
+ * @param _A_func Functor that should be wrapped.
+ * @param _A_b1 Argument to bind to @e _A_func.
+ * @param _A_b2 Argument to bind to @e _A_func.
+ * @param _A_b3 Argument to bind to @e _A_func.
+ * @param _A_b4 Argument to bind to @e _A_func.
+ * @return Adaptor that executes _A_func with the bound argument on invokation.
+ *
+ * @ingroup bind
+ */
+template <class T_type1,class T_type2,class T_type3,class T_type4, class T_functor>
+inline bind_functor<-1, T_functor,
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type,
+                    typename unwrap_reference<T_type3>::type,
+                    typename unwrap_reference<T_type4>::type>
+bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2,T_type3 _A_b3,T_type4 _A_b4)
+{ return bind_functor<-1, T_functor,
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type,
+                    typename unwrap_reference<T_type3>::type,
+                    typename unwrap_reference<T_type4>::type>
+                    (_A_func, _A_b1,_A_b2,_A_b3,_A_b4);
+}
+
+/** Creates an adaptor of type sigc::bind_functor which fixes the last 5 argument(s) of the passed functor.
+ * This function overload fixes the last 5 argument(s) of @e _A_func.
+ *
+ * @param _A_func Functor that should be wrapped.
+ * @param _A_b1 Argument to bind to @e _A_func.
+ * @param _A_b2 Argument to bind to @e _A_func.
+ * @param _A_b3 Argument to bind to @e _A_func.
+ * @param _A_b4 Argument to bind to @e _A_func.
+ * @param _A_b5 Argument to bind to @e _A_func.
+ * @return Adaptor that executes _A_func with the bound argument on invokation.
+ *
+ * @ingroup bind
+ */
+template <class T_type1,class T_type2,class T_type3,class T_type4,class T_type5, class T_functor>
+inline bind_functor<-1, T_functor,
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type,
+                    typename unwrap_reference<T_type3>::type,
+                    typename unwrap_reference<T_type4>::type,
+                    typename unwrap_reference<T_type5>::type>
+bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2,T_type3 _A_b3,T_type4 _A_b4,T_type5 _A_b5)
+{ return bind_functor<-1, T_functor,
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type,
+                    typename unwrap_reference<T_type3>::type,
+                    typename unwrap_reference<T_type4>::type,
+                    typename unwrap_reference<T_type5>::type>
+                    (_A_func, _A_b1,_A_b2,_A_b3,_A_b4,_A_b5);
+}
+
+/** Creates an adaptor of type sigc::bind_functor which fixes the last 6 argument(s) of the passed functor.
+ * This function overload fixes the last 6 argument(s) of @e _A_func.
+ *
+ * @param _A_func Functor that should be wrapped.
+ * @param _A_b1 Argument to bind to @e _A_func.
+ * @param _A_b2 Argument to bind to @e _A_func.
+ * @param _A_b3 Argument to bind to @e _A_func.
+ * @param _A_b4 Argument to bind to @e _A_func.
+ * @param _A_b5 Argument to bind to @e _A_func.
+ * @param _A_b6 Argument to bind to @e _A_func.
+ * @return Adaptor that executes _A_func with the bound argument on invokation.
+ *
+ * @ingroup bind
+ */
+template <class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6, class T_functor>
+inline bind_functor<-1, T_functor,
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type,
+                    typename unwrap_reference<T_type3>::type,
+                    typename unwrap_reference<T_type4>::type,
+                    typename unwrap_reference<T_type5>::type,
+                    typename unwrap_reference<T_type6>::type>
+bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2,T_type3 _A_b3,T_type4 _A_b4,T_type5 _A_b5,T_type6 _A_b6)
+{ return bind_functor<-1, T_functor,
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type,
+                    typename unwrap_reference<T_type3>::type,
+                    typename unwrap_reference<T_type4>::type,
+                    typename unwrap_reference<T_type5>::type,
+                    typename unwrap_reference<T_type6>::type>
+                    (_A_func, _A_b1,_A_b2,_A_b3,_A_b4,_A_b5,_A_b6);
+}
+
+/** Creates an adaptor of type sigc::bind_functor which fixes the last 7 argument(s) of the passed functor.
+ * This function overload fixes the last 7 argument(s) of @e _A_func.
+ *
+ * @param _A_func Functor that should be wrapped.
+ * @param _A_b1 Argument to bind to @e _A_func.
+ * @param _A_b2 Argument to bind to @e _A_func.
+ * @param _A_b3 Argument to bind to @e _A_func.
+ * @param _A_b4 Argument to bind to @e _A_func.
+ * @param _A_b5 Argument to bind to @e _A_func.
+ * @param _A_b6 Argument to bind to @e _A_func.
+ * @param _A_b7 Argument to bind to @e _A_func.
+ * @return Adaptor that executes _A_func with the bound argument on invokation.
+ *
+ * @ingroup bind
+ */
+template <class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6,class T_type7, class T_functor>
+inline bind_functor<-1, T_functor,
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type,
+                    typename unwrap_reference<T_type3>::type,
+                    typename unwrap_reference<T_type4>::type,
+                    typename unwrap_reference<T_type5>::type,
+                    typename unwrap_reference<T_type6>::type,
+                    typename unwrap_reference<T_type7>::type>
+bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2,T_type3 _A_b3,T_type4 _A_b4,T_type5 _A_b5,T_type6 _A_b6,T_type7 _A_b7)
+{ return bind_functor<-1, T_functor,
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type,
+                    typename unwrap_reference<T_type3>::type,
+                    typename unwrap_reference<T_type4>::type,
+                    typename unwrap_reference<T_type5>::type,
+                    typename unwrap_reference<T_type6>::type,
+                    typename unwrap_reference<T_type7>::type>
+                    (_A_func, _A_b1,_A_b2,_A_b3,_A_b4,_A_b5,_A_b6,_A_b7);
+}
+
+
+} /* namespace sigc */
+#endif /* _SIGC_ADAPTORS_MACROS_BINDHM4_ */
diff --git a/libs/sigc++2/sigc++/adaptors/bind_return.h b/libs/sigc++2/sigc++/adaptors/bind_return.h
new file mode 100644
index 0000000000..40e3524090
--- /dev/null
+++ b/libs/sigc++2/sigc++/adaptors/bind_return.h
@@ -0,0 +1,204 @@
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_ADAPTORS_MACROS_BIND_RETURNHM4_
+#define _SIGC_ADAPTORS_MACROS_BIND_RETURNHM4_
+#include <sigc++/adaptors/adaptor_trait.h>
+
+namespace sigc {
+
+/** Adaptor that fixes the return value of the wrapped functor.
+ * Use the convenience function sigc::bind_return() to create an instance of sigc::bind_return_functor.
+ *
+ * The following template arguments are used:
+ * - @e T_return Type of the fixed return value.
+ * - @e T_functor Type of the functor to wrap.
+ *
+ * @ingroup bind
+ */
+template <class T_return, class T_functor>
+struct bind_return_functor : public adapts<T_functor>
+{
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef T_return type; };
+  typedef T_return result_type;
+
+  /** Invokes the wrapped functor dropping its return value.
+   * @return The fixed return value.
+   */
+  T_return operator()();
+
+  /** Invokes the wrapped functor passing on the arguments.,
+   * @param _A_arg%1 Argument to be passed on to the functor.)
+   * @return The fixed return value.
+   */
+  template <class T_arg1>
+  inline T_return operator()(T_arg1 _A_a1)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+        (_A_a1); return ret_value_;
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  inline T_return sun_forte_workaround(T_arg1 _A_a1)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+        (_A_a1); return ret_value_;
+    }
+  #endif
+
+  /** Invokes the wrapped functor passing on the arguments.,
+   * @param _A_arg%1 Argument to be passed on to the functor.)
+   * @return The fixed return value.
+   */
+  template <class T_arg1,class T_arg2>
+  inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
+        (_A_a1,_A_a2); return ret_value_;
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
+        (_A_a1,_A_a2); return ret_value_;
+    }
+  #endif
+
+  /** Invokes the wrapped functor passing on the arguments.,
+   * @param _A_arg%1 Argument to be passed on to the functor.)
+   * @return The fixed return value.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3>
+  inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
+        (_A_a1,_A_a2,_A_a3); return ret_value_;
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
+        (_A_a1,_A_a2,_A_a3); return ret_value_;
+    }
+  #endif
+
+  /** Invokes the wrapped functor passing on the arguments.,
+   * @param _A_arg%1 Argument to be passed on to the functor.)
+   * @return The fixed return value.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4); return ret_value_;
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4); return ret_value_;
+    }
+  #endif
+
+  /** Invokes the wrapped functor passing on the arguments.,
+   * @param _A_arg%1 Argument to be passed on to the functor.)
+   * @return The fixed return value.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); return ret_value_;
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); return ret_value_;
+    }
+  #endif
+
+  /** Invokes the wrapped functor passing on the arguments.,
+   * @param _A_arg%1 Argument to be passed on to the functor.)
+   * @return The fixed return value.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); return ret_value_;
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); return ret_value_;
+    }
+  #endif
+
+  /** Invokes the wrapped functor passing on the arguments.,
+   * @param _A_arg%1 Argument to be passed on to the functor.)
+   * @return The fixed return value.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); return ret_value_;
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); return ret_value_;
+    }
+  #endif
+
+
+  /** Constructs a bind_return_functor object that fixes the return value to @p _A_ret_value.
+   * @param _A_functor Functor to invoke from operator()().
+   * @param _A_ret_value Value to return from operator()().
+   */
+  bind_return_functor(typename type_trait<T_functor>::take _A_functor, typename type_trait<T_return>::take _A_ret_value)
+    : adapts<T_functor>(_A_functor), ret_value_(_A_ret_value)
+    {}
+
+  /// The fixed return value.
+  T_return ret_value_; // public, so that visit_each() can access it
+};
+
+template <class T_return, class T_functor>
+T_return bind_return_functor<T_return, T_functor>::operator()()
+  { this->functor_(); return ret_value_; }
+
+
+/** Performs a functor on each of the targets of a functor.
+ * The function overload for sigc::bind_return_functor performs a functor on the
+ * functor and on the object instance stored in the sigc::bind_return_functor object.
+ *
+ * @ingroup bind
+ */
+template <class T_action, class T_return, class T_functor>
+void visit_each(const T_action& _A_action,
+                const bind_return_functor<T_return, T_functor>& _A_target)
+{
+  visit_each(_A_action, _A_target.ret_value_);
+  visit_each(_A_action, _A_target.functor_);
+}
+
+
+/** Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed functor to the passed argument.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @param _A_ret_value Argument to fix the return value of @e _A_functor to.
+ * @return Adaptor that executes @e _A_functor on invokation and returns @e _A_ret_value.
+ *
+ * @ingroup bind
+ */
+template <class T_return, class T_functor>
+inline bind_return_functor<typename unwrap_reference<T_return>::type, T_functor>
+bind_return(const T_functor& _A_functor, T_return _A_ret_value)
+{ return bind_return_functor<typename unwrap_reference<T_return>::type, T_functor>(_A_functor, _A_ret_value); }
+
+} /* namespace sigc */
+#endif /* _SIGC_ADAPTORS_MACROS_BIND_RETURNHM4_ */
diff --git a/libs/sigc++2/sigc++/adaptors/compose.h b/libs/sigc++2/sigc++/adaptors/compose.h
new file mode 100644
index 0000000000..0f098ff2df
--- /dev/null
+++ b/libs/sigc++2/sigc++/adaptors/compose.h
@@ -0,0 +1,294 @@
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+
+#ifndef _SIGC_ADAPTORS_MACROS_COMPOSEHM4_
+#define _SIGC_ADAPTORS_MACROS_COMPOSEHM4_
+#include <sigc++/adaptors/adaptor_trait.h>
+
+namespace sigc {
+
+/** @defgroup compose compose()
+ * sigc::compose() combines two or three arbitrary functors.
+ * On invokation parameters are passed on to one or two getter functor(s).
+ * The return value(s) are then passed on to the setter function.
+ *
+ * @par Examples:
+ *   @code
+ *   float square_root(float a)  { return sqrtf(a); }
+ *   float sum(float a, float b) { return a+b; }
+ *   std::cout << sigc::compose(&square_root, &sum)(9, 16); // calls square_root(sum(3,6))
+ *   std::cout << sigc::compose(&sum, &square_root, &square_root)(9); // calls sum(square_root(9), square_root(9))
+ *   @endcode
+ *
+ * The functor sigc::compose() returns can be passed into
+ * sigc::signal::connect() directly.
+ *
+ * @par Example:
+ *   @code
+ *   sigc::signal<float,float,float> some_signal;
+ *   some_signal.connect(sigc::compose(&square_root, &sum));
+ *   @endcode
+ *
+ * For a more powerful version of this functionality see the lambda
+ * library adaptor sigc::group() which can bind, hide and reorder
+ * arguments arbitrarily.  Although sigc::group() is more flexible,
+ * sigc::bind() provides a means of binding parameters when then total
+ * number of parameters called is variable.
+ *
+ * @ingroup adaptors
+ */
+
+/** Adaptor that combines two functors.
+ * Use the convenience function sigc::compose() to create an instance of sigc::compose1_functor.
+ *
+ * The following template arguments are used:
+ * - @e T_setter Type of the setter functor to wrap.
+ * - @e T_getter Type of the getter functor to wrap.
+ *
+ * @ingroup compose
+ */
+template <class T_setter, class T_getter>
+struct compose1_functor : public adapts<T_setter>
+{
+  typedef typename adapts<T_setter>::adaptor_type adaptor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename adaptor_type::template deduce_result_type<
+        typename sigc::deduce_result_type<T_getter, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+          >::type type; };
+  typedef typename adaptor_type::result_type  result_type;
+
+  result_type
+  operator()();
+
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator()(T_arg1 _A_a1)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename sigc::deduce_result_type<T_getter, T_arg1>::type>
+        (get_(_A_a1));
+    }
+
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename sigc::deduce_result_type<T_getter, T_arg1,T_arg2>::type>
+        (get_(_A_a1,_A_a2));
+    }
+
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename sigc::deduce_result_type<T_getter, T_arg1,T_arg2,T_arg3>::type>
+        (get_(_A_a1,_A_a2,_A_a3));
+    }
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename sigc::deduce_result_type<T_getter, T_arg1,T_arg2,T_arg3,T_arg4>::type>
+        (get_(_A_a1,_A_a2,_A_a3,_A_a4));
+    }
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename sigc::deduce_result_type<T_getter, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type>
+        (get_(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5));
+    }
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename sigc::deduce_result_type<T_getter, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type>
+        (get_(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6));
+    }
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename sigc::deduce_result_type<T_getter, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type>
+        (get_(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7));
+    }
+
+
+  /** Constructs a compose1_functor object that combines the passed functors.
+   * @param _A_setter Functor that receives the return values of the invokation of @e _A_getter1 and @e _A_getter2.
+   * @param _A_getter1 Functor to invoke from operator()().
+   * @param _A_getter2 Functor to invoke from operator()().
+   */
+  compose1_functor(const T_setter& _A_setter, const T_getter& _A_getter)
+    : adapts<T_setter>(_A_setter), get_(_A_getter)
+    {}
+
+  T_getter get_; // public, so that visit_each() can access it
+};
+
+template <class T_setter, class T_getter>
+typename compose1_functor<T_setter, T_getter>::result_type
+compose1_functor<T_setter, T_getter>::operator()()
+  { return this->functor_(get_()); }
+
+/** Adaptor that combines three functors.
+ * Use the convenience function sigc::compose() to create an instance of sigc::compose2_functor.
+ *
+ * The following template arguments are used:
+ * - @e T_setter Type of the setter functor to wrap.
+ * - @e T_getter1 Type of the first getter functor to wrap.
+ * - @e T_getter2 Type of the second getter functor to wrap.
+ *
+ * @ingroup compose
+ */
+template <class T_setter, class T_getter1, class T_getter2>
+struct compose2_functor : public adapts<T_setter>
+{
+  typedef typename adapts<T_setter>::adaptor_type adaptor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename adaptor_type::template deduce_result_type<
+        typename sigc::deduce_result_type<T_getter1, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type,
+        typename sigc::deduce_result_type<T_getter2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+          >::type result_type; };
+  typedef typename adaptor_type::result_type  result_type;
+
+  result_type
+  operator()();
+
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator()(T_arg1 _A_a1)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename sigc::deduce_result_type<T_getter1, T_arg1>::type,
+                                                         typename sigc::deduce_result_type<T_getter2, T_arg1>::type>
+        (get1_(_A_a1), get2_(_A_a1));
+    }
+
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename sigc::deduce_result_type<T_getter1, T_arg1,T_arg2>::type,
+                                                         typename sigc::deduce_result_type<T_getter2, T_arg1,T_arg2>::type>
+        (get1_(_A_a1,_A_a2), get2_(_A_a1,_A_a2));
+    }
+
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename sigc::deduce_result_type<T_getter1, T_arg1,T_arg2,T_arg3>::type,
+                                                         typename sigc::deduce_result_type<T_getter2, T_arg1,T_arg2,T_arg3>::type>
+        (get1_(_A_a1,_A_a2,_A_a3), get2_(_A_a1,_A_a2,_A_a3));
+    }
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename sigc::deduce_result_type<T_getter1, T_arg1,T_arg2,T_arg3,T_arg4>::type,
+                                                         typename sigc::deduce_result_type<T_getter2, T_arg1,T_arg2,T_arg3,T_arg4>::type>
+        (get1_(_A_a1,_A_a2,_A_a3,_A_a4), get2_(_A_a1,_A_a2,_A_a3,_A_a4));
+    }
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename sigc::deduce_result_type<T_getter1, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type,
+                                                         typename sigc::deduce_result_type<T_getter2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type>
+        (get1_(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5), get2_(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5));
+    }
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename sigc::deduce_result_type<T_getter1, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type,
+                                                         typename sigc::deduce_result_type<T_getter2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type>
+        (get1_(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6), get2_(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6));
+    }
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename sigc::deduce_result_type<T_getter1, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type,
+                                                         typename sigc::deduce_result_type<T_getter2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type>
+        (get1_(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7), get2_(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7));
+    }
+
+
+  /** Constructs a compose2_functor object that combines the passed functors.
+   * @param _A_setter Functor that receives the return values of the invokation of @e _A_getter1 and @e _A_getter2.
+   * @param _A_getter1 Functor to invoke from operator()().
+   * @param _A_getter2 Functor to invoke from operator()().
+   */
+  compose2_functor(const T_setter& _A_setter,
+                   const T_getter1& _A_getter1,
+                   const T_getter2& _A_getter2)
+    : adapts<T_setter>(_A_setter), get1_(_A_getter1), get2_(_A_getter2)
+    {}
+
+  T_getter1 get1_; // public, so that visit_each() can access it
+  T_getter2 get2_; // public, so that visit_each() can access it
+};
+
+template <class T_setter, class T_getter1, class T_getter2>
+typename compose2_functor<T_setter, T_getter1, T_getter2>::result_type
+compose2_functor<T_setter, T_getter1, T_getter2>::operator()()
+  { return this->functor_(get1_(), get2_()); }
+
+
+/** Performs a functor on each of the targets of a functor.
+ * The function overload for sigc::compose1_functor performs a functor on the
+ * functors stored in the sigc::compose1_functor object.
+ *
+ * @ingroup compose
+ */
+template <class T_action, class T_setter, class T_getter>
+void visit_each(const T_action& _A_action,
+                const compose1_functor<T_setter, T_getter>& _A_target)
+{
+  visit_each(_A_action, _A_target.functor_);
+  visit_each(_A_action, _A_target.get_);
+}
+
+/** Performs a functor on each of the targets of a functor.
+ * The function overload for sigc::compose2_functor performs a functor on the
+ * functors stored in the sigc::compose2_functor object.
+ *
+ * @ingroup compose
+ */
+template <class T_action, class T_setter, class T_getter1, class T_getter2>
+void visit_each(const T_action& _A_action,
+                const compose2_functor<T_setter, T_getter1, T_getter2>& _A_target)
+{
+  visit_each(_A_action, _A_target.functor_);
+  visit_each(_A_action, _A_target.get1_);
+  visit_each(_A_action, _A_target.get2_);
+}
+
+
+/** Creates an adaptor of type sigc::compose1_functor which combines two functors.
+ *
+ * @param _A_setter Functor that receives the return value of the invokation of @e _A_getter.
+ * @param _A_getter Functor to invoke from operator()().
+ * @return Adaptor that executes @e _A_setter with the value returned from invokation of @e _A_getter.
+ *
+ * @ingroup compose
+ */
+template <class T_setter, class T_getter>
+inline compose1_functor<T_setter, T_getter>
+compose(const T_setter& _A_setter, const T_getter& _A_getter)
+  { return compose1_functor<T_setter, T_getter>(_A_setter, _A_getter); }
+
+/** Creates an adaptor of type sigc::compose2_functor which combines three functors.
+ *
+ * @param _A_setter Functor that receives the return values of the invokation of @e _A_getter1 and @e _A_getter2.
+ * @param _A_getter1 Functor to invoke from operator()().
+ * @param _A_getter2 Functor to invoke from operator()().
+ * @return Adaptor that executes @e _A_setter with the values return from invokation of @e _A_getter1 and @e _A_getter2.
+ *
+ * @ingroup compose
+ */
+template <class T_setter, class T_getter1, class T_getter2>
+inline compose2_functor<T_setter, T_getter1, T_getter2>
+compose(const T_setter& _A_setter, const T_getter1& _A_getter1, const T_getter2& _A_getter2)
+  { return compose2_functor<T_setter, T_getter1, T_getter2>(_A_setter, _A_getter1, _A_getter2); }
+
+} /* namespace sigc */
+#endif /* _SIGC_ADAPTORS_MACROS_COMPOSEHM4_ */
diff --git a/libs/sigc++2/sigc++/adaptors/deduce_result_type.h b/libs/sigc++2/sigc++/adaptors/deduce_result_type.h
new file mode 100644
index 0000000000..397bb50ff7
--- /dev/null
+++ b/libs/sigc++2/sigc++/adaptors/deduce_result_type.h
@@ -0,0 +1,121 @@
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+/*
+*/
+#ifndef _SIGC_ADAPTORS_MACROS_DEDUCE_RESULT_TYPEHM4_
+#define _SIGC_ADAPTORS_MACROS_DEDUCE_RESULT_TYPEHM4_
+#include <sigc++/functors/functor_trait.h>
+
+
+namespace sigc {
+
+/** A hint to the compiler.
+ * Functors which have all methods based on templates
+ * should publicly inherit from this hint and define 
+ * a nested template class @p deduce_result_type that
+ * can be used to deduce the methods' return types.
+ *
+ * adaptor_base inherits from the functor_base hint so
+ * derived types should also have a result_type defined.
+ *
+ * Adaptors don't inherit from this type directly. They use
+ * use sigc::adapts as a base type instead. sigc::adaptors
+ * wraps arbitrary functor types as well as function pointers
+ * and class methods.
+ *
+ * @ingroup adaptors
+ */
+struct adaptor_base : public functor_base {};
+
+
+/** Deduce the return type of a functor.
+ * <tt>typename deduce_result_type<functor_type, list of arg_types>::type</tt>
+ * deduces a functor's result type if @p functor_type inherits from
+ * sigc::functor_base and defines @p result_type or if @p functor_type
+ * is actually a (member) function type. Multi-type functors are not
+ * supported.
+ *
+ * sigc++ adaptors use
+ * <tt>typename deduce_result_type<functor_type, list of arg_types>::type</tt>
+ * to determine the return type of their <tt>templated operator()</tt> overloads.
+ *
+ * Adaptors in turn define a nested template class @p deduce_result_type
+ * that is used by template specializations of the global deduce_result_type
+ * template to correctly deduce the return types of the adaptor's suitable
+ * <tt>template operator()</tt> overload.
+ *
+ * @ingroup adaptors
+ */
+template <class T_functor,
+          class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void,
+          bool I_derives_adaptor_base=is_base_and_derived<adaptor_base,T_functor>::value>
+struct deduce_result_type
+  { typedef typename functor_trait<T_functor>::result_type type; };
+
+/** Deduce the return type of a functor.
+ * This is the template specialization of the sigc::deduce_result_type template
+ * for 0 arguments.
+ */
+template <class T_functor>
+struct deduce_result_type<T_functor, void,void,void,void,void,void,void, true>
+  { typedef typename T_functor::template deduce_result_type<>::type type; };
+
+/** Deduce the return type of a functor.
+ * This is the template specialization of the sigc::deduce_result_type template
+ * for 1 arguments.
+ */
+template <class T_functor, class T_arg1>
+struct deduce_result_type<T_functor, T_arg1, void,void,void,void,void,void, true>
+  { typedef typename T_functor::template deduce_result_type<T_arg1>::type type; };
+
+/** Deduce the return type of a functor.
+ * This is the template specialization of the sigc::deduce_result_type template
+ * for 2 arguments.
+ */
+template <class T_functor, class T_arg1,class T_arg2>
+struct deduce_result_type<T_functor, T_arg1,T_arg2, void,void,void,void,void, true>
+  { typedef typename T_functor::template deduce_result_type<T_arg1,T_arg2>::type type; };
+
+/** Deduce the return type of a functor.
+ * This is the template specialization of the sigc::deduce_result_type template
+ * for 3 arguments.
+ */
+template <class T_functor, class T_arg1,class T_arg2,class T_arg3>
+struct deduce_result_type<T_functor, T_arg1,T_arg2,T_arg3, void,void,void,void, true>
+  { typedef typename T_functor::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type type; };
+
+/** Deduce the return type of a functor.
+ * This is the template specialization of the sigc::deduce_result_type template
+ * for 4 arguments.
+ */
+template <class T_functor, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+struct deduce_result_type<T_functor, T_arg1,T_arg2,T_arg3,T_arg4, void,void,void, true>
+  { typedef typename T_functor::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type type; };
+
+/** Deduce the return type of a functor.
+ * This is the template specialization of the sigc::deduce_result_type template
+ * for 5 arguments.
+ */
+template <class T_functor, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+struct deduce_result_type<T_functor, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, void,void, true>
+  { typedef typename T_functor::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type type; };
+
+/** Deduce the return type of a functor.
+ * This is the template specialization of the sigc::deduce_result_type template
+ * for 6 arguments.
+ */
+template <class T_functor, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+struct deduce_result_type<T_functor, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, void, true>
+  { typedef typename T_functor::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type type; };
+
+/** Deduce the return type of a functor.
+ * This is the template specialization of the sigc::deduce_result_type template
+ * for 7 arguments.
+ */
+template <class T_functor, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+struct deduce_result_type<T_functor, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7, true>
+  { typedef typename T_functor::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type type; };
+
+
+} /* namespace sigc */
+#endif /* _SIGC_ADAPTORS_MACROS_DEDUCE_RESULT_TYPEHM4_ */
diff --git a/libs/sigc++2/sigc++/adaptors/exception_catch.h b/libs/sigc++2/sigc++/adaptors/exception_catch.h
new file mode 100644
index 0000000000..cd7c41e67d
--- /dev/null
+++ b/libs/sigc++2/sigc++/adaptors/exception_catch.h
@@ -0,0 +1,319 @@
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_ADAPTORS_MACROS_EXCEPTION_CATCHHM4_
+#define _SIGC_ADAPTORS_MACROS_EXCEPTION_CATCHHM4_
+#include <sigc++/adaptors/adaptor_trait.h>
+
+namespace sigc {
+
+/*
+   functor adaptor:  exception_catch(functor, catcher)
+
+   usage:
+
+
+   Future directions:
+     The catcher should be told what type of return it needs to
+   return for multiple type functors,  to do this the user
+   will need to derive from catcher_base.
+*/
+/** @defgroup exception_catch exception_catch()
+ * sigc::exception_catch() catches an exception thrown from within 
+ * the wrapped functor and directs it to a catcher functor.
+ * This catcher can then rethrow the exception and catch it with the proper type.
+ *
+ * Note that the catcher is expected to return the same type
+ * as the wrapped functor so that normal flow can continue.
+ *
+ * Catchers can be cascaded to catch multiple types because uncaught
+ * rethrown exceptions proceed to the next catcher adaptor.
+ *
+ * @par Examples:
+ *   @code
+ *   struct my_catch
+ *   {
+ *     int operator()()
+ *     {
+ *       try { throw; }
+ *       catch (std::range_error e) // catch what types we know
+ *         { std::cerr << "caught " << e.what() << std::endl; }
+ *       return 1;
+ *     }
+ *   }
+ *   int foo(); // throws std::range_error
+ *   sigc::exception_catch(&foo, my_catch())();
+ *   @endcode
+ *
+ * The functor sigc::execption_catch() returns can be passed into
+ * sigc::signal::connect() directly.
+ *
+ * @par Example:
+ *   @code
+ *   sigc::signal<int> some_signal;
+ *   some_signal.connect(sigc::exception_catch(&foo, my_catch));
+ *   @endcode
+ *
+ * @ingroup adaptors
+ */
+
+template <class T_functor, class T_catcher, class T_return = typename adapts<T_functor>::result_type>
+struct exception_catch_functor : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::type type; };
+  typedef T_return result_type;
+
+  result_type
+  operator()();
+
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator()(T_arg1 _A_a1)
+    { 
+      try
+        {
+          return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+            (_A_a1);
+        } 
+      catch (...)
+        { return catcher_(); }
+    }
+
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2)
+    { 
+      try
+        {
+          return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
+            (_A_a1,_A_a2);
+        } 
+      catch (...)
+        { return catcher_(); }
+    }
+
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+    { 
+      try
+        {
+          return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
+            (_A_a1,_A_a2,_A_a3);
+        } 
+      catch (...)
+        { return catcher_(); }
+    }
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { 
+      try
+        {
+          return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
+            (_A_a1,_A_a2,_A_a3,_A_a4);
+        } 
+      catch (...)
+        { return catcher_(); }
+    }
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { 
+      try
+        {
+          return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
+            (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
+        } 
+      catch (...)
+        { return catcher_(); }
+    }
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { 
+      try
+        {
+          return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
+            (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
+        } 
+      catch (...)
+        { return catcher_(); }
+    }
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { 
+      try
+        {
+          return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
+            (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
+        } 
+      catch (...)
+        { return catcher_(); }
+    }
+
+  exception_catch_functor(const T_functor& _A_func,
+                          const T_catcher& _A_catcher)
+    : adapts<T_functor>(_A_func), catcher_(_A_catcher)
+    {}
+
+  protected: 
+    T_catcher catcher_; 
+};
+
+template <class T_functor, class T_catcher, class T_return>
+typename exception_catch_functor<T_functor, T_catcher, T_return>::result_type
+exception_catch_functor<T_functor, T_catcher, T_return>::operator()()
+  { 
+    try
+      { return this->functor_(); }
+    catch (...)
+      { return catcher_(); }
+  }
+
+// void specialization
+template <class T_functor, class T_catcher>
+struct exception_catch_functor<T_functor, T_catcher, void> : public adapts<T_functor>
+{
+  typedef void result_type;
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+  void
+  operator()();
+
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator()(T_arg1 _A_a1)
+    { 
+      try
+        {
+          return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+            (_A_a1);
+        } 
+      catch (...)
+        { return catcher_(); }
+    }
+
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2)
+    { 
+      try
+        {
+          return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
+            (_A_a1,_A_a2);
+        } 
+      catch (...)
+        { return catcher_(); }
+    }
+
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+    { 
+      try
+        {
+          return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
+            (_A_a1,_A_a2,_A_a3);
+        } 
+      catch (...)
+        { return catcher_(); }
+    }
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { 
+      try
+        {
+          return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
+            (_A_a1,_A_a2,_A_a3,_A_a4);
+        } 
+      catch (...)
+        { return catcher_(); }
+    }
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { 
+      try
+        {
+          return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
+            (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
+        } 
+      catch (...)
+        { return catcher_(); }
+    }
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { 
+      try
+        {
+          return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
+            (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
+        } 
+      catch (...)
+        { return catcher_(); }
+    }
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { 
+      try
+        {
+          return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
+            (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
+        } 
+      catch (...)
+        { return catcher_(); }
+    }
+
+  exception_catch_functor() {}
+  exception_catch_functor(const T_functor& _A_func,
+                          const T_catcher& _A_catcher)
+    : adapts<T_functor>(_A_func), catcher_(_A_catcher)
+    {}
+  ~exception_catch_functor() {}
+
+  protected: 
+    T_catcher catcher_; 
+};
+
+template <class T_functor, class T_catcher>
+void exception_catch_functor<T_functor, T_catcher, void>::operator()()
+  { 
+    try
+      { this->functor_(); } // I don't understand why void return doesn't work here (Martin)
+    catch (...)
+      { this->catcher_(); }
+  }
+
+
+template <class T_action, class T_functor, class T_catcher, class T_return>
+void visit_each(const T_action& _A_action,
+                const exception_catch_functor<T_functor, T_catcher, T_return>& _A_target)
+{
+  visit_each(_A_action, _A_target.functor_);
+  visit_each(_A_action, _A_target.catcher_);
+}
+
+
+template <class T_functor, class T_catcher>
+inline exception_catch_functor<T_functor, T_catcher>
+exception_catch(const T_functor& _A_func, const T_catcher& _A_catcher)
+  { return exception_catch_functor<T_functor, T_catcher>(_A_func, _A_catcher); }
+
+} /* namespace sigc */
+#endif /* _SIGC_ADAPTORS_MACROS_EXCEPTION_CATCHHM4_ */
diff --git a/libs/sigc++2/sigc++/adaptors/hide.h b/libs/sigc++2/sigc++/adaptors/hide.h
new file mode 100644
index 0000000000..1b820fea6b
--- /dev/null
+++ b/libs/sigc++2/sigc++/adaptors/hide.h
@@ -0,0 +1,1063 @@
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_ADAPTORS_MACROS_HIDEHM4_
+#define _SIGC_ADAPTORS_MACROS_HIDEHM4_
+#include <sigc++/adaptors/adaptor_trait.h>
+
+namespace sigc { 
+
+/** @defgroup hide hide(), hide_return()
+ * sigc::hide() alters an arbitrary functor in that it adds a parameter
+ * whose value is ignored on invocation of the returned functor.
+ * Thus you can discard one or more of the arguments of a signal.
+ *
+ * You may optionally specify the zero-based position of the parameter
+ * to ignore as a template argument. The default is to ignore the last
+ * parameter.
+ * (A value of @p -1 adds a parameter at the end so sigc::hide<-1>() gives the same result as sigc::hide().)
+ *
+ * The type of the parameter can optionally be specified if not deduced.
+ *
+ * @par Examples:
+ *   @code
+ *   void foo(int, int);
+ *   // single argument hiding ...
+ *   sigc::hide(&foo)(1,2,3);     // adds a dummy parameter at the back and calls foo(1,2)
+ *   sigc::hide<-1>(&foo)(1,2,3); // same as sigc::hide(&foo)(1,2,3) (calls foo(1,2))
+ *   sigc::hide<0>(&foo)(1,2,3);  // adds a dummy parameter at the beginning and calls foo(2,3)
+ *   sigc::hide<1>(&foo)(1,2,3);  // adds a dummy parameter in the middle and calls foo(1,3)
+ *   sigc::hide<2>(&foo)(1,2,3);  // adds a dummy parameter at the back and calls foo(1,2)
+ *   // multiple argument hiding ...
+ *   sigc::hide(sigc::hide(&foo))(1,2,3,4); // adds two dummy parameters at the back and calls foo(1,2)
+ *   @endcode
+ *
+ * The functor sigc::hide() returns can be passed into
+ * sigc::signal::connect() directly.
+ *
+ * @par Example:
+ *   @code
+ *   sigc::signal<void,int> some_signal;
+ *   void foo();
+ *   some_signal.connect(sigc::hide(&foo));
+ *   @endcode
+ *
+ * sigc::hide_return() alters an arbitrary functor by
+ * dropping its return value, thus converting it to a void functor.
+ *
+ * For a more powerful version of this functionality see the lambda
+ * library adaptor sigc::group() which can bind, hide and reorder
+ * arguments arbitrarily.  Although sigc::group() is more flexible,
+ * sigc::hide() provides a means of hiding parameters when then total
+ * number of parameters called is variable.
+ *
+ * @ingroup adaptors
+ */
+
+/** Adaptor that adds a dummy parameter to the wrapped functor.
+ * Use the convenience function sigc::hide() to create an instance of sigc::hide_functor.
+ *
+ * The following template arguments are used:
+ * - @e I_location Zero-based position of the dummy parameter (@p -1 for the last parameter).
+ * - @e T_type Type of the dummy parameter.
+ * - @e T_functor Type of the functor to wrap.
+ *
+ * @ingroup hide
+ */
+template <int I_location, class T_functor>
+struct hide_functor;
+
+/** Adaptor that adds a dummy parameter to the wrapped functor.
+ * This template specialization ignores the value of the last parameter in operator()().
+ *
+ * @ingroup hide
+ */
+template <class T_functor>
+struct hide_functor <-1, T_functor> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>::type type; };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor ignoring the only argument.
+   * @param _A_arg%1 Argument to be ignored.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator()(T_arg1 _A_a1)
+    { return this->functor_(); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  sun_forte_workaround(T_arg1 _A_a1)
+    { return this->functor_(); }
+  #endif
+
+  /** Invokes the wrapped functor ignoring the last argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be ignored.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+        (_A_a1); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+        (_A_a1); }
+  #endif
+
+  /** Invokes the wrapped functor ignoring the last argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be ignored.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
+        (_A_a1, _A_a2); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
+        (_A_a1, _A_a2); }
+  #endif
+
+  /** Invokes the wrapped functor ignoring the last argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be ignored.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
+        (_A_a1, _A_a2, _A_a3); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
+        (_A_a1, _A_a2, _A_a3); }
+  #endif
+
+  /** Invokes the wrapped functor ignoring the last argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be ignored.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a4); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a4); }
+  #endif
+
+  /** Invokes the wrapped functor ignoring the last argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be ignored.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+  #endif
+
+  /** Invokes the wrapped functor ignoring the last argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @param _A_arg7 Argument to be ignored.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+  #endif
+
+
+  /** Constructs a hide_functor object that adds a dummy parameter to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   */
+  explicit hide_functor(const T_functor& _A_func)
+    : adapts<T_functor>(_A_func)
+    {}
+};
+
+/** Adaptor that adds a dummy parameter to the wrapped functor.
+ * This template specialization ignores the value of the 0th parameter in operator()().
+ *
+ * @ingroup hide
+ */
+template <class T_functor>
+struct hide_functor <0, T_functor> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>::type type; };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor ignoring the only argument.
+   * @param _A_arg%1 Argument to be ignored.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator()(T_arg1 _A_a1)
+    { return this->functor_(); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  sun_forte_workaround(T_arg1 _A_a1)
+    { return this->functor_(); }
+  #endif
+
+  /** Invokes the wrapped functor ignoring the 1th argument.
+   * @param _A_arg1 Argument to be ignored.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass>
+        (_A_a2); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass>
+        (_A_a2); }
+  #endif
+    
+  /** Invokes the wrapped functor ignoring the 1th argument.
+   * @param _A_arg1 Argument to be ignored.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
+        (_A_a2, _A_a3); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
+        (_A_a2, _A_a3); }
+  #endif
+    
+  /** Invokes the wrapped functor ignoring the 1th argument.
+   * @param _A_arg1 Argument to be ignored.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+        (_A_a2, _A_a3, _A_a4); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+        (_A_a2, _A_a3, _A_a4); }
+  #endif
+    
+  /** Invokes the wrapped functor ignoring the 1th argument.
+   * @param _A_arg1 Argument to be ignored.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_a2, _A_a3, _A_a4, _A_a5); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_a2, _A_a3, _A_a4, _A_a5); }
+  #endif
+    
+  /** Invokes the wrapped functor ignoring the 1th argument.
+   * @param _A_arg1 Argument to be ignored.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+  #endif
+    
+  /** Invokes the wrapped functor ignoring the 1th argument.
+   * @param _A_arg1 Argument to be ignored.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @param _A_arg7 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
+        (_A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
+        (_A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+  #endif
+    
+
+  /** Constructs a hide_functor object that adds a dummy parameter to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   */
+  explicit hide_functor(const T_functor& _A_func)
+    : adapts<T_functor>(_A_func)
+    {}
+};
+
+/** Adaptor that adds a dummy parameter to the wrapped functor.
+ * This template specialization ignores the value of the 1th parameter in operator()().
+ *
+ * @ingroup hide
+ */
+template <class T_functor>
+struct hide_functor <1, T_functor> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>::type type; };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor ignoring the 2th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be ignored.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+        (_A_a1); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+        (_A_a1); }
+  #endif
+    
+  /** Invokes the wrapped functor ignoring the 2th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be ignored.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass>
+        (_A_a1, _A_a3); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass>
+        (_A_a1, _A_a3); }
+  #endif
+    
+  /** Invokes the wrapped functor ignoring the 2th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be ignored.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+        (_A_a1, _A_a3, _A_a4); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+        (_A_a1, _A_a3, _A_a4); }
+  #endif
+    
+  /** Invokes the wrapped functor ignoring the 2th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be ignored.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_a1, _A_a3, _A_a4, _A_a5); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_a1, _A_a3, _A_a4, _A_a5); }
+  #endif
+    
+  /** Invokes the wrapped functor ignoring the 2th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be ignored.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_a1, _A_a3, _A_a4, _A_a5, _A_a6); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_a1, _A_a3, _A_a4, _A_a5, _A_a6); }
+  #endif
+    
+  /** Invokes the wrapped functor ignoring the 2th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be ignored.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @param _A_arg7 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
+        (_A_a1, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
+        (_A_a1, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
+  #endif
+    
+
+  /** Constructs a hide_functor object that adds a dummy parameter to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   */
+  explicit hide_functor(const T_functor& _A_func)
+    : adapts<T_functor>(_A_func)
+    {}
+};
+
+/** Adaptor that adds a dummy parameter to the wrapped functor.
+ * This template specialization ignores the value of the 2th parameter in operator()().
+ *
+ * @ingroup hide
+ */
+template <class T_functor>
+struct hide_functor <2, T_functor> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>::type type; };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor ignoring the 3th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be ignored.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
+        (_A_a1, _A_a2); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
+        (_A_a1, _A_a2); }
+  #endif
+    
+  /** Invokes the wrapped functor ignoring the 3th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be ignored.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass>
+        (_A_a1, _A_a2, _A_a4); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass>
+        (_A_a1, _A_a2, _A_a4); }
+  #endif
+    
+  /** Invokes the wrapped functor ignoring the 3th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be ignored.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_a1, _A_a2, _A_a4, _A_a5); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_a1, _A_a2, _A_a4, _A_a5); }
+  #endif
+    
+  /** Invokes the wrapped functor ignoring the 3th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be ignored.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_a1, _A_a2, _A_a4, _A_a5, _A_a6); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_a1, _A_a2, _A_a4, _A_a5, _A_a6); }
+  #endif
+    
+  /** Invokes the wrapped functor ignoring the 3th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be ignored.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @param _A_arg7 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
+        (_A_a1, _A_a2, _A_a4, _A_a5, _A_a6, _A_a7); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
+        (_A_a1, _A_a2, _A_a4, _A_a5, _A_a6, _A_a7); }
+  #endif
+    
+
+  /** Constructs a hide_functor object that adds a dummy parameter to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   */
+  explicit hide_functor(const T_functor& _A_func)
+    : adapts<T_functor>(_A_func)
+    {}
+};
+
+/** Adaptor that adds a dummy parameter to the wrapped functor.
+ * This template specialization ignores the value of the 3th parameter in operator()().
+ *
+ * @ingroup hide
+ */
+template <class T_functor>
+struct hide_functor <3, T_functor> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>::type type; };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor ignoring the 4th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be ignored.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
+        (_A_a1, _A_a2, _A_a3); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
+        (_A_a1, _A_a2, _A_a3); }
+  #endif
+    
+  /** Invokes the wrapped functor ignoring the 4th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be ignored.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a5); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a5); }
+  #endif
+    
+  /** Invokes the wrapped functor ignoring the 4th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be ignored.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a5, _A_a6); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a5, _A_a6); }
+  #endif
+    
+  /** Invokes the wrapped functor ignoring the 4th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be ignored.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @param _A_arg7 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a5, _A_a6, _A_a7); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a5, _A_a6, _A_a7); }
+  #endif
+    
+
+  /** Constructs a hide_functor object that adds a dummy parameter to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   */
+  explicit hide_functor(const T_functor& _A_func)
+    : adapts<T_functor>(_A_func)
+    {}
+};
+
+/** Adaptor that adds a dummy parameter to the wrapped functor.
+ * This template specialization ignores the value of the 4th parameter in operator()().
+ *
+ * @ingroup hide
+ */
+template <class T_functor>
+struct hide_functor <4, T_functor> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>::type type; };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor ignoring the 5th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be ignored.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a4); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a4); }
+  #endif
+    
+  /** Invokes the wrapped functor ignoring the 5th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be ignored.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg6>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a4, _A_a6); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg6>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a4, _A_a6); }
+  #endif
+    
+  /** Invokes the wrapped functor ignoring the 5th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be ignored.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @param _A_arg7 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a4, _A_a6, _A_a7); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a4, _A_a6, _A_a7); }
+  #endif
+    
+
+  /** Constructs a hide_functor object that adds a dummy parameter to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   */
+  explicit hide_functor(const T_functor& _A_func)
+    : adapts<T_functor>(_A_func)
+    {}
+};
+
+/** Adaptor that adds a dummy parameter to the wrapped functor.
+ * This template specialization ignores the value of the 5th parameter in operator()().
+ *
+ * @ingroup hide
+ */
+template <class T_functor>
+struct hide_functor <5, T_functor> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_arg7>::pass>::type type; };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor ignoring the 6th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be ignored.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
+  #endif
+    
+  /** Invokes the wrapped functor ignoring the 6th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be ignored.
+   * @param _A_arg7 Argument to be passed on to the functor.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg7>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a7); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg7>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a7); }
+  #endif
+    
+
+  /** Constructs a hide_functor object that adds a dummy parameter to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   */
+  explicit hide_functor(const T_functor& _A_func)
+    : adapts<T_functor>(_A_func)
+    {}
+};
+
+/** Adaptor that adds a dummy parameter to the wrapped functor.
+ * This template specialization ignores the value of the 6th parameter in operator()().
+ *
+ * @ingroup hide
+ */
+template <class T_functor>
+struct hide_functor <6, T_functor> : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>::type type; };
+  typedef typename adaptor_type::result_type  result_type;
+
+  /** Invokes the wrapped functor ignoring the 7th argument.
+   * @param _A_arg1 Argument to be passed on to the functor.
+   * @param _A_arg2 Argument to be passed on to the functor.
+   * @param _A_arg3 Argument to be passed on to the functor.
+   * @param _A_arg4 Argument to be passed on to the functor.
+   * @param _A_arg5 Argument to be passed on to the functor.
+   * @param _A_arg6 Argument to be passed on to the functor.
+   * @param _A_arg7 Argument to be ignored.
+   * @return The return value of the functor invocation.
+   */
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
+  #endif
+    
+
+  /** Constructs a hide_functor object that adds a dummy parameter to the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   */
+  explicit hide_functor(const T_functor& _A_func)
+    : adapts<T_functor>(_A_func)
+    {}
+};
+
+
+/** Performs a functor on each of the targets of a functor.
+ * The function overload for sigc::hide_functor performs a functor on the
+ * functor stored in the sigc::hide_functor object.
+ *
+ * @ingroup hide
+ */
+template <class T_action, int I_location, class T_functor>
+void visit_each(const T_action& _A_action,
+                const hide_functor<I_location, T_functor>& _A_target)
+{
+  visit_each(_A_action, _A_target.functor_);
+}
+
+
+/** Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed functor.
+ * The optional template argument @e I_location specifies the zero-based
+ * position of the dummy parameter in the returned functor (@p -1 stands for the last parameter).
+ *
+ * @param _A_func Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_func ignoring the value of the dummy parameter.
+ *
+ * @ingroup hide
+ */
+template <int I_location, class T_functor>
+inline hide_functor<I_location, T_functor>
+hide(const T_functor& _A_func)
+  { return hide_functor<I_location, T_functor>(_A_func); }
+
+/** Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed functor.
+ * This overload adds a dummy parameter at the back of the functor's parameter list.
+ *
+ * @param _A_func Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_func ignoring the value of the last parameter.
+ *
+ * @ingroup hide
+ */
+template <class T_functor>
+inline hide_functor<-1, T_functor>
+hide(const T_functor& _A_func)
+  { return hide_functor<-1, T_functor> (_A_func); }
+
+} /* namespace sigc */
+#endif /* _SIGC_ADAPTORS_MACROS_HIDEHM4_ */
diff --git a/libs/sigc++2/sigc++/adaptors/lambda/base.h b/libs/sigc++2/sigc++/adaptors/lambda/base.h
new file mode 100644
index 0000000000..6a2c402c89
--- /dev/null
+++ b/libs/sigc++2/sigc++/adaptors/lambda/base.h
@@ -0,0 +1,392 @@
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_LAMBDA_BASE_HPP_
+#define _SIGC_LAMBDA_BASE_HPP_
+#include <sigc++/adaptors/adaptor_trait.h>
+
+namespace sigc {
+
+/** @defgroup lambdas Lambdas
+ * libsigc++ ships with basic lambda functionality and the sigc::group adaptor that uses lambdas to transform a functor's parameter list.
+ *
+ * The lambda selectors sigc::_1, sigc::_2, ..., sigc::_9 are used to select the
+ * first, second, ..., nineth argument from a list.
+ *
+ * @par Examples:
+ *   @code
+ *   std::cout << sigc::_1(10,20,30); // returns 10
+ *   std::cout << sigc::_2(10,20,30); // returns 20
+ *   ...
+ *   @endcode
+ *
+ * Operators are defined so that lambda selectors can be used e.g. as placeholders in
+ * arithmetic expressions.
+ *
+ * @par Examples:
+ *   @code
+ *   std::cout << (sigc::_1 + 5)(3); // returns (3 + 5)
+ *   std::cout << (sigc::_1 * sigc::_2)(7,10); // returns (7 * 10)
+ *   @endcode
+ */
+
+/** A hint to the compiler.
+ * All lambda types publically inherit from this hint.
+ *
+ * @ingroup lambdas
+ */
+struct lambda_base : public adaptor_base {};
+
+// Forward declaration of lambda.
+template <class T_type> struct lambda;
+
+
+namespace internal {
+
+/** Abstracts lambda functionality.
+ * Objects of this type store a value that may be of type lambda itself.
+ * In this case, operator()() executes the lambda (a lambda is always a functor at the same time).
+ * Otherwise, operator()() simply returns the stored value.
+ */
+template <class T_type, bool I_islambda = is_base_and_derived<lambda_base, T_type>::value> struct lambda_core;
+
+/// Abstracts lambda functionality (template specialization for lambda values).
+template <class T_type>
+struct lambda_core<T_type, true> : public lambda_base
+{
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename T_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::type type; };
+  typedef typename T_type::result_type result_type;
+  typedef T_type lambda_type;
+
+  result_type
+  operator()() const;
+
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator ()(T_arg1 _A_1) const 
+    { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+             (_A_1); 
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  sun_forte_workaround(T_arg1 _A_1) const
+    { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+             (_A_1); 
+    }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2) const 
+    { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
+             (_A_1,_A_2); 
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const
+    { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
+             (_A_1,_A_2); 
+    }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const 
+    { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
+             (_A_1,_A_2,_A_3); 
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const
+    { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
+             (_A_1,_A_2,_A_3); 
+    }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const 
+    { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
+             (_A_1,_A_2,_A_3,_A_4); 
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const
+    { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
+             (_A_1,_A_2,_A_3,_A_4); 
+    }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const 
+    { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
+             (_A_1,_A_2,_A_3,_A_4,_A_5); 
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const
+    { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
+             (_A_1,_A_2,_A_3,_A_4,_A_5); 
+    }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const 
+    { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
+             (_A_1,_A_2,_A_3,_A_4,_A_5,_A_6); 
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const
+    { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
+             (_A_1,_A_2,_A_3,_A_4,_A_5,_A_6); 
+    }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const 
+    { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
+             (_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7); 
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const
+    { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
+             (_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7); 
+    }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  lambda_core() {}
+
+  explicit lambda_core(const T_type& v)
+    : value_(v) {}
+
+  T_type value_;
+};
+
+template <class T_type>
+typename lambda_core<T_type, true>::result_type
+lambda_core<T_type, true>::operator()() const
+  { return value_(); }
+
+
+/// Abstracts lambda functionality (template specialization for other value types).
+template <class T_type>
+struct lambda_core<T_type, false> : public lambda_base
+{
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef T_type type; };
+  typedef T_type result_type; // all operator() overloads return T_type.
+  typedef lambda<T_type> lambda_type;
+
+  result_type operator()() const;
+
+  template <class T_arg1>
+  result_type operator ()(T_arg1 _A_1) const 
+    { return value_; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  result_type sun_forte_workaround(T_arg1 _A_1) const
+    { return value_; }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2>
+  result_type operator ()(T_arg1 _A_1,T_arg2 _A_2) const 
+    { return value_; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  result_type sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const
+    { return value_; }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3>
+  result_type operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const 
+    { return value_; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  result_type sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const
+    { return value_; }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  result_type operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const 
+    { return value_; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  result_type sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const
+    { return value_; }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  result_type operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const 
+    { return value_; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  result_type sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const
+    { return value_; }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  result_type operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const 
+    { return value_; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  result_type sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const
+    { return value_; }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  result_type operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const 
+    { return value_; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  result_type sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const
+    { return value_; }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  explicit lambda_core(typename type_trait<T_type>::take v)
+    : value_(v) {}
+
+  T_type value_;
+};
+
+template <class T_type>
+typename lambda_core<T_type, false>::result_type lambda_core<T_type, false>::operator()() const
+  { return value_; }
+
+} /* namespace internal */
+
+
+template <class T_action, class T_functor, bool I_islambda>
+void visit_each(const T_action& _A_action,
+                const internal::lambda_core<T_functor, I_islambda>& _A_target)
+{
+  visit_each(_A_action, _A_target.value_);
+}
+
+
+// forward declarations for lambda operators other<subscript> and other<assign>
+template <class T_type>
+struct other;
+struct subscript;
+struct assign;
+
+template <class T_action, class T_type1, class T_type2>
+struct lambda_operator;
+
+template <class T_type>
+struct unwrap_lambda_type;
+
+
+/** Lambda type.
+ * Objects of this type store a value that may be of type lambda itself.
+ * In this case, operator()() executes the lambda (a lambda is always a functor at the same time).
+ * Otherwise, operator()() simply returns the stored value.
+ * The assign and subscript operators are defined to return a lambda operator.
+ *
+ * @ingroup lambdas
+ */
+template <class T_type>
+struct lambda : public internal::lambda_core<T_type>
+{
+  typedef lambda<T_type> self;
+
+  lambda()
+    {}
+
+  lambda(typename type_trait<T_type>::take v)
+    : internal::lambda_core<T_type>(v) 
+    {}
+
+  // operators for other<subscript>
+  template <class T_arg>
+  lambda<lambda_operator<other<subscript>, self, typename unwrap_lambda_type<T_arg>::type> >
+  operator [] (const T_arg& a) const
+    { typedef lambda_operator<other<subscript>, self, typename unwrap_lambda_type<T_arg>::type> lambda_operator_type;
+      return lambda<lambda_operator_type>(lambda_operator_type(this->value_, unwrap_lambda_value(a))); }
+
+  // operators for other<assign>
+  template <class T_arg>
+  lambda<lambda_operator<other<assign>, self, typename unwrap_lambda_type<T_arg>::type> >
+  operator = (const T_arg& a) const
+    { typedef lambda_operator<other<assign>, self, typename unwrap_lambda_type<T_arg>::type> lambda_operator_type;
+      return lambda<lambda_operator_type>(lambda_operator_type(this->value_, unwrap_lambda_value(a))); }
+};
+
+
+template <class T_action, class T_type>
+void visit_each(const T_action& _A_action,
+                const lambda<T_type>& _A_target)
+{
+  visit_each(_A_action, _A_target.value_);
+}
+
+
+/// Converts a reference into a lambda object.
+template <class T_type>
+lambda<T_type&> var(T_type& v)
+{ return lambda<T_type&>(v); }
+
+/// Converts a constant reference into a lambda object.
+template <class T_type>
+lambda<const T_type&> var(const T_type& v)
+{ return lambda<const T_type&>(v); }
+
+
+/** Deduces the type of the object stored in an object of the passed lambda type.
+ * If the type passed as template argument is no lambda type,
+ * type is defined to unwrap_reference<T_type>::type.
+ */
+template <class T_type>
+struct unwrap_lambda_type
+{ typedef typename unwrap_reference<T_type>::type type; };
+
+template <class T_type>
+struct unwrap_lambda_type<lambda<T_type> >
+{ typedef T_type type; };
+
+
+/** Gets the object stored inside a lambda object.
+ * Returns the object passed as argument if it is not of type lambda.
+ */
+template <class T_type>
+T_type& unwrap_lambda_value(T_type& a)
+{ return a; }
+
+template <class T_type>
+const T_type& unwrap_lambda_value(const T_type& a)
+{ return a; }
+
+template <class T_type>
+const T_type& unwrap_lambda_value(const lambda<T_type>& a)
+{ return a.value_; }
+
+} /* namespace sigc */
+
+#endif /* _SIGC_LAMBDA_BASE_HPP_ */
diff --git a/libs/sigc++2/sigc++/adaptors/lambda/group.h b/libs/sigc++2/sigc++/adaptors/lambda/group.h
new file mode 100644
index 0000000000..7b7525dc41
--- /dev/null
+++ b/libs/sigc++2/sigc++/adaptors/lambda/group.h
@@ -0,0 +1,734 @@
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_ADAPTORS_LAMBDA_MACROS_GROUPHM4_
+#define _SIGC_ADAPTORS_LAMBDA_MACROS_GROUPHM4_
+#include <sigc++/adaptors/lambda/base.h>
+
+/** @defgroup group_ group()
+ * sigc::group() alters an arbitrary functor by rebuilding its arguments from one or more lambda expressions.
+ * For each parameter that should be passed to the wrapped functor one lambda expression
+ * has to be passed into group(). Lambda selectors can be used as placeholders for the
+ * arguments passed into the new functor. Arguments that don't have a placeholder in one
+ * of the lambda expressions are dropped.
+ *
+ * @par Examples:
+ *   @code
+ *   void foo(int, int);
+ *   int bar(int);
+ *   // argument binding ...
+ *   sigc::group(&foo,10,sigc::_1)(20); //fixes the first argument and calls foo(10,20)
+ *   sigc::group(&foo,sigc::_1,30)(40); //fixes the second argument and calls foo(40,30)
+ *   // argument reordering ...
+ *   sigc::group(&foo,sigc::_2,sigc::_1)(1,2); //calls foo(2,1)
+ *   // argument hiding ...
+ *   sigc::group(&foo,sigc::_1,sigc::_2)(1,2,3); //calls foo(1,2)
+ *   // functor composition ...
+ *   sigc::group(&foo,sigc::_1,sigc::group(&bar,sigc::_2))(1,2); //calls foo(1,bar(2))
+ *   // algebraic expressions ...
+ *   sigc::group(&foo,sigc::_1*sigc::_2,sigc::_1/sigc::_2)(6,3); //calls foo(6*3,6/3)
+ *   @endcode
+ *
+ * The functor sigc::group() returns can be passed into
+ * sigc::signal::connect() directly.
+ *
+ * @par Example:
+ *   @code
+ *   sigc::signal<void,int,int> some_signal;
+ *   void foo(int);
+ *   some_signal.connect(sigc::group(&foo,sigc::_2));
+ *   @endcode
+ *
+ * Like in sigc::bind() you can bind references to functors by passing the objects
+ * through the sigc::ref() helper function.
+ *
+ * @par Example:
+ *   @code
+ *   int some_int;
+ *   sigc::signal<void> some_signal;
+ *   void foo(int&);
+ *   some_signal.connect(sigc::group(&foo,sigc::ref(some_int)));
+ *   @endcode
+ *
+ * If you bind an object of a sigc::trackable derived type to a functor
+ * by reference, a slot assigned to the group adaptor is cleared automatically
+ * when the object goes out of scope.
+ *
+ * @par Example:
+ *   @code
+ *   struct bar : public sigc::trackable {} some_bar;
+ *   sigc::signal<void> some_signal;
+ *   void foo(bar&);
+ *   some_signal.connect(sigc::group(&foo,sigc::ref(some_bar)));
+ *     // disconnected automatically if some_bar goes out of scope
+ *   @endcode
+ *
+ * @ingroup adaptors, lambdas
+ */
+
+namespace sigc {
+
+template <class T_functor, class T_type1>
+struct lambda_group1 : public lambda_base
+{
+  typedef typename functor_trait<T_functor>::result_type result_type;
+  typedef typename lambda<T_type1>::lambda_type   value1_type;
+  typedef typename adaptor_trait<T_functor>::adaptor_type functor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename functor_type::template deduce_result_type<
+          typename value1_type::template deduce_result_type<
+            typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::type
+        >::type type; };
+
+  result_type
+  operator ()() const;
+
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator() (T_arg1 _A_1) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass>(_A_1)); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  sun_forte_workaround (T_arg1 _A_1) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass>(_A_1)); }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator() (T_arg1 _A_1,T_arg2 _A_2) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_A_1,_A_2)); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  sun_forte_workaround (T_arg1 _A_1,T_arg2 _A_2) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_A_1,_A_2)); }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator() (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_A_1,_A_2,_A_3)); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  sun_forte_workaround (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_A_1,_A_2,_A_3)); }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator() (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_A_1,_A_2,_A_3,_A_4)); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_A_1,_A_2,_A_3,_A_4)); }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator() (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5)); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5)); }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator() (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6)); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6)); }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  operator() (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7)); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  sun_forte_workaround (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7)); }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  lambda_group1(typename type_trait<T_functor>::take _A_func, typename type_trait<T_type1>::take _A_1)
+    : value1_(_A_1), func_(_A_func) {}
+
+  value1_type value1_;
+  mutable functor_type func_;
+};
+
+template <class T_functor, class T_type1>
+typename lambda_group1<T_functor, T_type1>::result_type
+lambda_group1<T_functor, T_type1>::operator ()() const
+  { return func_(value1_()); }
+
+
+template <class T_action, class T_functor, class T_type1>
+void visit_each(const T_action& _A_action,
+                const lambda_group1<T_functor, T_type1>& _A_target)
+{
+  visit_each(_A_action, _A_target.value1_);
+  visit_each(_A_action, _A_target.func_);
+}
+
+
+template <class T_functor, class T_type1,class T_type2>
+struct lambda_group2 : public lambda_base
+{
+  typedef typename functor_trait<T_functor>::result_type result_type;
+  typedef typename lambda<T_type1>::lambda_type   value1_type;
+  typedef typename lambda<T_type2>::lambda_type   value2_type;
+  typedef typename adaptor_trait<T_functor>::adaptor_type functor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename functor_type::template deduce_result_type<
+          typename value1_type::template deduce_result_type<
+            typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::type,
+          typename value2_type::template deduce_result_type<
+            typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::type
+        >::type type; };
+
+  result_type
+  operator ()() const;
+
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator() (T_arg1 _A_1) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1>::type,
+          typename value2_type::template deduce_result_type<T_arg1>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass>(_A_1),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass>(_A_1)); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  sun_forte_workaround (T_arg1 _A_1) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1>::type,
+          typename value2_type::template deduce_result_type<T_arg1>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass>(_A_1),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass>(_A_1)); }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator() (T_arg1 _A_1,T_arg2 _A_2) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_A_1,_A_2),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_A_1,_A_2)); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  sun_forte_workaround (T_arg1 _A_1,T_arg2 _A_2) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_A_1,_A_2),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_A_1,_A_2)); }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator() (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_A_1,_A_2,_A_3),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_A_1,_A_2,_A_3)); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  sun_forte_workaround (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_A_1,_A_2,_A_3),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_A_1,_A_2,_A_3)); }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator() (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_A_1,_A_2,_A_3,_A_4),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_A_1,_A_2,_A_3,_A_4)); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_A_1,_A_2,_A_3,_A_4),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_A_1,_A_2,_A_3,_A_4)); }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator() (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5)); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5)); }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator() (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6)); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6)); }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  operator() (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7)); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  sun_forte_workaround (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7)); }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  lambda_group2(typename type_trait<T_functor>::take _A_func, typename type_trait<T_type1>::take _A_1,typename type_trait<T_type2>::take _A_2)
+    : value1_(_A_1),value2_(_A_2), func_(_A_func) {}
+
+  value1_type value1_;
+  value2_type value2_;
+  mutable functor_type func_;
+};
+
+template <class T_functor, class T_type1,class T_type2>
+typename lambda_group2<T_functor, T_type1,T_type2>::result_type
+lambda_group2<T_functor, T_type1,T_type2>::operator ()() const
+  { return func_(value1_(),value2_()); }
+
+
+template <class T_action, class T_functor, class T_type1,class T_type2>
+void visit_each(const T_action& _A_action,
+                const lambda_group2<T_functor, T_type1,T_type2>& _A_target)
+{
+  visit_each(_A_action, _A_target.value1_);
+  visit_each(_A_action, _A_target.value2_);
+  visit_each(_A_action, _A_target.func_);
+}
+
+
+template <class T_functor, class T_type1,class T_type2,class T_type3>
+struct lambda_group3 : public lambda_base
+{
+  typedef typename functor_trait<T_functor>::result_type result_type;
+  typedef typename lambda<T_type1>::lambda_type   value1_type;
+  typedef typename lambda<T_type2>::lambda_type   value2_type;
+  typedef typename lambda<T_type3>::lambda_type   value3_type;
+  typedef typename adaptor_trait<T_functor>::adaptor_type functor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename functor_type::template deduce_result_type<
+          typename value1_type::template deduce_result_type<
+            typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::type,
+          typename value2_type::template deduce_result_type<
+            typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::type,
+          typename value3_type::template deduce_result_type<
+            typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::type
+        >::type type; };
+
+  result_type
+  operator ()() const;
+
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator() (T_arg1 _A_1) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1>::type,
+          typename value2_type::template deduce_result_type<T_arg1>::type,
+          typename value3_type::template deduce_result_type<T_arg1>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass>(_A_1),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass>(_A_1),
+        this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass>(_A_1)); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  sun_forte_workaround (T_arg1 _A_1) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1>::type,
+          typename value2_type::template deduce_result_type<T_arg1>::type,
+          typename value3_type::template deduce_result_type<T_arg1>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass>(_A_1),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass>(_A_1),
+        this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass>(_A_1)); }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator() (T_arg1 _A_1,T_arg2 _A_2) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2>::type,
+          typename value3_type::template deduce_result_type<T_arg1,T_arg2>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_A_1,_A_2),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_A_1,_A_2),
+        this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_A_1,_A_2)); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  sun_forte_workaround (T_arg1 _A_1,T_arg2 _A_2) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2>::type,
+          typename value3_type::template deduce_result_type<T_arg1,T_arg2>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_A_1,_A_2),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_A_1,_A_2),
+        this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>(_A_1,_A_2)); }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator() (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type,
+          typename value3_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_A_1,_A_2,_A_3),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_A_1,_A_2,_A_3),
+        this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_A_1,_A_2,_A_3)); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  sun_forte_workaround (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type,
+          typename value3_type::template deduce_result_type<T_arg1,T_arg2,T_arg3>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_A_1,_A_2,_A_3),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_A_1,_A_2,_A_3),
+        this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>(_A_1,_A_2,_A_3)); }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator() (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type,
+          typename value3_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_A_1,_A_2,_A_3,_A_4),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_A_1,_A_2,_A_3,_A_4),
+        this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_A_1,_A_2,_A_3,_A_4)); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type,
+          typename value3_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_A_1,_A_2,_A_3,_A_4),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_A_1,_A_2,_A_3,_A_4),
+        this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>(_A_1,_A_2,_A_3,_A_4)); }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator() (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type,
+          typename value3_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5),
+        this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5)); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type,
+          typename value3_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5),
+        this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5)); }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator() (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type,
+          typename value3_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6),
+        this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6)); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type,
+          typename value3_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6),
+        this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6)); }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  operator() (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type,
+          typename value3_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7),
+        this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7)); }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  sun_forte_workaround (T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const
+    { return this->func_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename value1_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type,
+          typename value2_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type,
+          typename value3_type::template deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type>(
+        this->value1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7),
+        this->value2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7),
+        this->value3_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<
+          typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>(_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7)); }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  lambda_group3(typename type_trait<T_functor>::take _A_func, typename type_trait<T_type1>::take _A_1,typename type_trait<T_type2>::take _A_2,typename type_trait<T_type3>::take _A_3)
+    : value1_(_A_1),value2_(_A_2),value3_(_A_3), func_(_A_func) {}
+
+  value1_type value1_;
+  value2_type value2_;
+  value3_type value3_;
+  mutable functor_type func_;
+};
+
+template <class T_functor, class T_type1,class T_type2,class T_type3>
+typename lambda_group3<T_functor, T_type1,T_type2,T_type3>::result_type
+lambda_group3<T_functor, T_type1,T_type2,T_type3>::operator ()() const
+  { return func_(value1_(),value2_(),value3_()); }
+
+
+template <class T_action, class T_functor, class T_type1,class T_type2,class T_type3>
+void visit_each(const T_action& _A_action,
+                const lambda_group3<T_functor, T_type1,T_type2,T_type3>& _A_target)
+{
+  visit_each(_A_action, _A_target.value1_);
+  visit_each(_A_action, _A_target.value2_);
+  visit_each(_A_action, _A_target.value3_);
+  visit_each(_A_action, _A_target.func_);
+}
+
+
+
+template <class T_functor, class T_type1>
+lambda<lambda_group1<T_functor, typename unwrap_reference<T_type1>::type> >
+group(const T_functor& _A_func, T_type1 _A_1)
+{
+  typedef lambda_group1<T_functor, typename unwrap_reference<T_type1>::type> T_lambda;
+  return lambda<T_lambda>(T_lambda(_A_func, _A_1));
+}
+
+template <class T_functor, class T_type1,class T_type2>
+lambda<lambda_group2<T_functor, typename unwrap_reference<T_type1>::type,typename unwrap_reference<T_type2>::type> >
+group(const T_functor& _A_func, T_type1 _A_1,T_type2 _A_2)
+{
+  typedef lambda_group2<T_functor, typename unwrap_reference<T_type1>::type,typename unwrap_reference<T_type2>::type> T_lambda;
+  return lambda<T_lambda>(T_lambda(_A_func, _A_1,_A_2));
+}
+
+template <class T_functor, class T_type1,class T_type2,class T_type3>
+lambda<lambda_group3<T_functor, typename unwrap_reference<T_type1>::type,typename unwrap_reference<T_type2>::type,typename unwrap_reference<T_type3>::type> >
+group(const T_functor& _A_func, T_type1 _A_1,T_type2 _A_2,T_type3 _A_3)
+{
+  typedef lambda_group3<T_functor, typename unwrap_reference<T_type1>::type,typename unwrap_reference<T_type2>::type,typename unwrap_reference<T_type3>::type> T_lambda;
+  return lambda<T_lambda>(T_lambda(_A_func, _A_1,_A_2,_A_3));
+}
+
+
+
+} /* namespace sigc */
+#endif /* _SIGC_ADAPTORS_LAMBDA_MACROS_GROUPHM4_ */
diff --git a/libs/sigc++2/sigc++/adaptors/lambda/lambda.cc b/libs/sigc++2/sigc++/adaptors/lambda/lambda.cc
new file mode 100644
index 0000000000..78fd516df2
--- /dev/null
+++ b/libs/sigc++2/sigc++/adaptors/lambda/lambda.cc
@@ -0,0 +1,15 @@
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#include <sigc++/adaptors/lambda/select.h>
+
+namespace sigc {
+
+const lambda<internal::lambda_select1> _1;
+const lambda<internal::lambda_select2> _2;
+const lambda<internal::lambda_select3> _3;
+const lambda<internal::lambda_select4> _4;
+const lambda<internal::lambda_select5> _5;
+const lambda<internal::lambda_select6> _6;
+const lambda<internal::lambda_select7> _7;
+
+} /* namespace sigc */
diff --git a/libs/sigc++2/sigc++/adaptors/lambda/lambda.h b/libs/sigc++2/sigc++/adaptors/lambda/lambda.h
new file mode 100644
index 0000000000..487522ad10
--- /dev/null
+++ b/libs/sigc++2/sigc++/adaptors/lambda/lambda.h
@@ -0,0 +1,28 @@
+// -*- c++ -*-
+/*
+ * Copyright 2002, The libsigc++ Development Team
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+#ifndef _SIGC_LAMBDA_HPP_
+#define _SIGC_LAMBDA_HPP_
+
+#include <sigc++/adaptors/lambda/base.h>
+#include <sigc++/adaptors/lambda/select.h>
+#include <sigc++/adaptors/lambda/operator.h>
+#include <sigc++/adaptors/lambda/group.h>
+
+#endif /* _SIGC_LAMBDA_HPP_ */
diff --git a/libs/sigc++2/sigc++/adaptors/lambda/operator.h b/libs/sigc++2/sigc++/adaptors/lambda/operator.h
new file mode 100644
index 0000000000..5d9e00bcde
--- /dev/null
+++ b/libs/sigc++2/sigc++/adaptors/lambda/operator.h
@@ -0,0 +1,1697 @@
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_LAMBDA_OPERATOR_HPP_
+#define _SIGC_LAMBDA_OPERATOR_HPP_
+#include <sigc++/adaptors/lambda/base.h>
+
+namespace sigc {
+
+/** Deduces the base type of a reference or a pointer.
+ * @ingroup internal
+ */
+template <class T_type>
+struct dereference_trait
+  { typedef void type; };
+
+template <class T_type>
+struct dereference_trait<T_type*>
+  { typedef T_type type; };
+
+template <class T_type>
+struct dereference_trait<const T_type*>
+  { typedef const T_type type; };
+
+template <class T_type>
+struct dereference_trait<T_type*&>
+  { typedef T_type type; };
+
+template <class T_type>
+struct dereference_trait<const T_type*&>
+  { typedef const T_type type; };
+
+template <class T_type>
+struct dereference_trait<T_type* const&>
+  { typedef T_type type; };
+
+template <class T_type>
+struct dereference_trait<const T_type* const&>
+  { typedef const T_type type; };
+
+template <class T_type>
+struct arithmetic {};
+
+template <class T_type>
+struct bitwise {};
+
+template <class T_type>
+struct logical {};
+
+template <class T_type>
+struct relational {};
+
+template <class T_type>
+struct arithmetic_assign {};
+
+template <class T_type>
+struct bitwise_assign {};
+
+template <class T_type>
+struct other {};
+
+template <class T_type>
+struct unary_arithmetic {};
+
+template <class T_type>
+struct unary_bitwise {};
+
+template <class T_type>
+struct unary_logical {};
+
+template <class T_type>
+struct unary_other {};
+
+template <class T_type>
+struct cast_ {};
+
+struct plus {};
+struct minus {};
+struct multiplies {};
+struct divides {};
+struct modulus {};
+struct leftshift {};
+struct rightshift {};
+struct and_ {};
+struct or_ {};
+struct xor_ {};
+struct less {};
+struct greater {};
+struct less_equal {};
+struct greater_equal {};
+struct equal_to {};
+struct not_equal_to {};
+struct subscript {};
+struct assign {};
+struct pre_increment {};
+struct pre_decrement {};
+struct negate {};
+struct not_ {};
+struct address {};
+struct dereference {};
+struct reinterpret_ {};
+struct static_ {};
+struct dynamic_ {};
+
+template <class T_action, class T_test1, class T_test2>
+struct lambda_action_deduce_result_type
+  { typedef typename type_trait<T_test1>::type type; }; // TODO: e.g. T_test1=int, T_test2=double yields int but it should yield double !
+
+template <class T_action, class T_test1, class T_test2>
+struct lambda_action_deduce_result_type<logical<T_action>, T_test1, T_test2>
+  { typedef bool type; };
+
+template <class T_action, class T_test1, class T_test2>
+struct lambda_action_deduce_result_type<relational<T_action>, T_test1, T_test2>
+  { typedef bool type; };
+
+template <class T_action, class T_test1, class T_test2>
+struct lambda_action_deduce_result_type<arithmetic_assign<T_action>, T_test1, T_test2>
+  { typedef T_test1 type; };
+
+template <class T_action, class T_test1, class T_test2>
+struct lambda_action_deduce_result_type<bitwise_assign<T_action>, T_test1, T_test2>
+  { typedef T_test1 type; };
+
+template <class T_test1, class T_test2>
+struct lambda_action_deduce_result_type<other<subscript>, T_test1, T_test2>
+  { typedef typename type_trait<typename dereference_trait<T_test1>::type>::pass type; };
+
+template <class T_action, class T_test>
+struct lambda_action_unary_deduce_result_type
+  { typedef typename type_trait<T_test>::type type; };
+
+template <class T_action, class T_type, class T_test>
+struct lambda_action_convert_deduce_result_type
+  { typedef typename type_trait<T_type>::type type; };
+
+template <class T_action, class T_test>
+struct lambda_action_unary_deduce_result_type<unary_logical<T_action>, T_test>
+  { typedef bool type; };
+
+template <class T_test>
+struct lambda_action_unary_deduce_result_type<unary_other<address>, T_test>
+  { typedef typename type_trait<T_test>::pointer type; };
+
+template <class T_test>
+struct lambda_action_unary_deduce_result_type<unary_other<dereference>, T_test>
+  { typedef typename type_trait<typename dereference_trait<T_test>::type>::pass type; };
+
+
+
+template <class T_action>
+struct lambda_action {};
+
+template <class T_action>
+struct lambda_action_unary {};
+
+template <class T_action, class T_type>
+struct lambda_action_convert {};
+
+template <>
+struct lambda_action<arithmetic<plus> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<arithmetic<plus>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 + _A_2; }
+};
+
+template <>
+struct lambda_action<arithmetic<minus> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<arithmetic<minus>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 - _A_2; }
+};
+
+template <>
+struct lambda_action<arithmetic<multiplies> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<arithmetic<multiplies>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 * _A_2; }
+};
+
+template <>
+struct lambda_action<arithmetic<divides> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<arithmetic<divides>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 / _A_2; }
+};
+
+template <>
+struct lambda_action<arithmetic<modulus> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<arithmetic<modulus>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 % _A_2; }
+};
+
+template <>
+struct lambda_action<bitwise<leftshift> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<bitwise<leftshift>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 << _A_2; }
+};
+
+template <>
+struct lambda_action<bitwise<rightshift> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<bitwise<rightshift>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 >> _A_2; }
+};
+
+template <>
+struct lambda_action<bitwise<and_> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<bitwise<and_>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 & _A_2; }
+};
+
+template <>
+struct lambda_action<bitwise<or_> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<bitwise<or_>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 | _A_2; }
+};
+
+template <>
+struct lambda_action<bitwise<xor_> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<bitwise<xor_>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 ^ _A_2; }
+};
+
+template <>
+struct lambda_action<logical<and_> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<logical<and_>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 && _A_2; }
+};
+
+template <>
+struct lambda_action<logical<or_> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<logical<or_>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 || _A_2; }
+};
+
+template <>
+struct lambda_action<relational<less> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<relational<less>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 < _A_2; }
+};
+
+template <>
+struct lambda_action<relational<greater> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<relational<greater>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 > _A_2; }
+};
+
+template <>
+struct lambda_action<relational<less_equal> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<relational<less_equal>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 <= _A_2; }
+};
+
+template <>
+struct lambda_action<relational<greater_equal> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<relational<greater_equal>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 >= _A_2; }
+};
+
+template <>
+struct lambda_action<relational<equal_to> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<relational<equal_to>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 == _A_2; }
+};
+
+template <>
+struct lambda_action<relational<not_equal_to> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<relational<not_equal_to>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 != _A_2; }
+};
+
+template <>
+struct lambda_action<arithmetic_assign<plus> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<arithmetic_assign<plus>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 += _A_2; }
+};
+
+template <>
+struct lambda_action<arithmetic_assign<minus> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<arithmetic_assign<minus>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 -= _A_2; }
+};
+
+template <>
+struct lambda_action<arithmetic_assign<multiplies> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<arithmetic_assign<multiplies>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 *= _A_2; }
+};
+
+template <>
+struct lambda_action<arithmetic_assign<divides> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<arithmetic_assign<divides>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 /= _A_2; }
+};
+
+template <>
+struct lambda_action<arithmetic_assign<modulus> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<arithmetic_assign<modulus>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 %= _A_2; }
+};
+
+template <>
+struct lambda_action<bitwise_assign<leftshift> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<bitwise_assign<leftshift>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 <<= _A_2; }
+};
+
+template <>
+struct lambda_action<bitwise_assign<rightshift> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<bitwise_assign<rightshift>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 >>= _A_2; }
+};
+
+template <>
+struct lambda_action<bitwise_assign<and_> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<bitwise_assign<and_>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 &= _A_2; }
+};
+
+template <>
+struct lambda_action<bitwise_assign<or_> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<bitwise_assign<or_>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 |= _A_2; }
+};
+
+template <>
+struct lambda_action<bitwise_assign<xor_> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<bitwise_assign<xor_>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 ^= _A_2; }
+};
+
+template <>
+struct lambda_action<other<subscript> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<other<subscript>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1[_A_2]; }
+};
+
+template <>
+struct lambda_action<other<assign> >
+{
+  template <class T_arg1, class T_arg2>
+  static typename lambda_action_deduce_result_type<other<assign>, T_arg1, T_arg2>::type
+  do_action(T_arg1 _A_1, T_arg2 _A_2)
+    { return _A_1 = _A_2; }
+};
+
+template <>
+struct lambda_action_unary<unary_arithmetic<pre_increment> >
+{
+  template <class T_arg>
+  static typename lambda_action_unary_deduce_result_type<unary_arithmetic<pre_increment>, T_arg>::type
+  do_action(T_arg _Aa)
+    { return ++_Aa; }
+};
+
+template <>
+struct lambda_action_unary<unary_arithmetic<pre_decrement> >
+{
+  template <class T_arg>
+  static typename lambda_action_unary_deduce_result_type<unary_arithmetic<pre_decrement>, T_arg>::type
+  do_action(T_arg _Aa)
+    { return --_Aa; }
+};
+
+template <>
+struct lambda_action_unary<unary_arithmetic<negate> >
+{
+  template <class T_arg>
+  static typename lambda_action_unary_deduce_result_type<unary_arithmetic<negate>, T_arg>::type
+  do_action(T_arg _Aa)
+    { return -_Aa; }
+};
+
+template <>
+struct lambda_action_unary<unary_bitwise<not_> >
+{
+  template <class T_arg>
+  static typename lambda_action_unary_deduce_result_type<unary_bitwise<not_>, T_arg>::type
+  do_action(T_arg _Aa)
+    { return ~_Aa; }
+};
+
+template <>
+struct lambda_action_unary<unary_logical<not_> >
+{
+  template <class T_arg>
+  static typename lambda_action_unary_deduce_result_type<unary_logical<not_>, T_arg>::type
+  do_action(T_arg _Aa)
+    { return !_Aa; }
+};
+
+template <>
+struct lambda_action_unary<unary_other<address> >
+{
+  template <class T_arg>
+  static typename lambda_action_unary_deduce_result_type<unary_other<address>, T_arg>::type
+  do_action(T_arg _Aa)
+    { return &_Aa; }
+};
+
+template <>
+struct lambda_action_unary<unary_other<dereference> >
+{
+  template <class T_arg>
+  static typename lambda_action_unary_deduce_result_type<unary_other<dereference>, T_arg>::type
+  do_action(T_arg _Aa)
+    { return *_Aa; }
+};
+
+template <class T_type>
+struct lambda_action_convert<cast_<reinterpret_>, T_type>
+{
+  template <class T_arg>
+  static typename lambda_action_convert_deduce_result_type<cast_<reinterpret_>, T_type, T_arg>::type
+  do_action(T_arg _Aa)
+    { return reinterpret_cast<T_type>(_Aa); }
+};
+
+template <class T_type>
+struct lambda_action_convert<cast_<static_>, T_type>
+{
+  template <class T_arg>
+  static typename lambda_action_convert_deduce_result_type<cast_<static_>, T_type, T_arg>::type
+  do_action(T_arg _Aa)
+    { return static_cast<T_type>(_Aa); }
+};
+
+template <class T_type>
+struct lambda_action_convert<cast_<dynamic_>, T_type>
+{
+  template <class T_arg>
+  static typename lambda_action_convert_deduce_result_type<cast_<dynamic_>, T_type, T_arg>::type
+  do_action(T_arg _Aa)
+    { return dynamic_cast<T_type>(_Aa); }
+};
+
+
+
+template <class T_action, class T_type1, class T_type2>
+struct lambda_operator : public lambda_base
+{
+  typedef typename lambda<T_type1>::lambda_type arg1_type;
+  typedef typename lambda<T_type2>::lambda_type arg2_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename arg1_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::type left_type;
+      typedef typename arg2_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::type right_type;
+      typedef typename lambda_action_deduce_result_type<T_action, left_type, right_type>::type type;
+    };
+  typedef typename lambda_action_deduce_result_type<
+      T_action,
+      typename arg1_type::result_type,
+      typename arg2_type::result_type
+    >::type result_type;
+
+  result_type
+  operator ()() const;
+
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator ()(T_arg1 _A_1) const
+    {
+      return lambda_action<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass>::left_type,
+            typename deduce_result_type<typename type_trait<T_arg1>::pass>::right_type>
+        (arg1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+            (_A_1),
+         arg2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+            (_A_1));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  sun_forte_workaround(T_arg1 _A_1) const
+    {
+      return lambda_action<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass>::left_type,
+            typename deduce_result_type<typename type_trait<T_arg1>::pass>::right_type>
+        (arg1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+            (_A_1),
+         arg2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+            (_A_1));
+    }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2) const
+    {
+      return lambda_action<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>::left_type,
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>::right_type>
+        (arg1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
+            (_A_1,_A_2),
+         arg2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
+            (_A_1,_A_2));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const
+    {
+      return lambda_action<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>::left_type,
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>::right_type>
+        (arg1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
+            (_A_1,_A_2),
+         arg2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
+            (_A_1,_A_2));
+    }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const
+    {
+      return lambda_action<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>::left_type,
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>::right_type>
+        (arg1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
+            (_A_1,_A_2,_A_3),
+         arg2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
+            (_A_1,_A_2,_A_3));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const
+    {
+      return lambda_action<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>::left_type,
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>::right_type>
+        (arg1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
+            (_A_1,_A_2,_A_3),
+         arg2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
+            (_A_1,_A_2,_A_3));
+    }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const
+    {
+      return lambda_action<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>::left_type,
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>::right_type>
+        (arg1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
+            (_A_1,_A_2,_A_3,_A_4),
+         arg2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
+            (_A_1,_A_2,_A_3,_A_4));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const
+    {
+      return lambda_action<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>::left_type,
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>::right_type>
+        (arg1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
+            (_A_1,_A_2,_A_3,_A_4),
+         arg2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
+            (_A_1,_A_2,_A_3,_A_4));
+    }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const
+    {
+      return lambda_action<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>::left_type,
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>::right_type>
+        (arg1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5),
+         arg2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const
+    {
+      return lambda_action<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>::left_type,
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>::right_type>
+        (arg1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5),
+         arg2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5));
+    }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const
+    {
+      return lambda_action<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>::left_type,
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>::right_type>
+        (arg1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5,_A_6),
+         arg2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5,_A_6));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const
+    {
+      return lambda_action<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>::left_type,
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>::right_type>
+        (arg1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5,_A_6),
+         arg2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5,_A_6));
+    }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const
+    {
+      return lambda_action<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::left_type,
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::right_type>
+        (arg1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7),
+         arg2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const
+    {
+      return lambda_action<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::left_type,
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::right_type>
+        (arg1_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7),
+         arg2_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7));
+    }
+  #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+
+  lambda_operator(typename type_trait<T_type1>::take a1, typename type_trait<T_type2>::take a2 )
+    : arg1_(a1), arg2_(a2) {}
+
+  arg1_type arg1_;
+  arg2_type arg2_;
+};
+
+template <class T_action, class T_type1, class T_type2>
+typename lambda_operator<T_action, T_type1, T_type2>::result_type
+lambda_operator<T_action, T_type1, T_type2>::operator ()() const
+  { return lambda_action<T_action>::template do_action<
+      typename arg1_type::result_type,
+      typename arg2_type::result_type>
+      (arg1_(), arg2_()); }
+
+template <class T_action, class T_lambda_action, class T_arg1, class T_arg2>
+void visit_each(const T_action& _A_action,
+                const lambda_operator<T_lambda_action, T_arg1, T_arg2>& _A_target)
+{
+  visit_each(_A_action, _A_target.arg1_);
+  visit_each(_A_action, _A_target.arg2_);
+}
+
+
+template <class T_action, class T_type>
+struct lambda_operator_unary : public lambda_base
+{
+  typedef typename lambda<T_type>::lambda_type arg_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename arg_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::type operand_type;
+      typedef typename lambda_action_unary_deduce_result_type<T_action, operand_type>::type type;
+    };
+  typedef typename lambda_action_unary_deduce_result_type<
+      T_action,
+      typename arg_type::result_type
+    >::type result_type;
+
+  result_type
+  operator ()() const;
+
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator ()(T_arg1 _A_1) const
+    {
+      return lambda_action_unary<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+            (_A_1));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  sun_forte_workaround(T_arg1 _A_1) const
+    {
+      return lambda_action_unary<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+            (_A_1));
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2) const
+    {
+      return lambda_action_unary<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
+            (_A_1,_A_2));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const
+    {
+      return lambda_action_unary<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
+            (_A_1,_A_2));
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const
+    {
+      return lambda_action_unary<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
+            (_A_1,_A_2,_A_3));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const
+    {
+      return lambda_action_unary<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
+            (_A_1,_A_2,_A_3));
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const
+    {
+      return lambda_action_unary<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
+            (_A_1,_A_2,_A_3,_A_4));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const
+    {
+      return lambda_action_unary<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
+            (_A_1,_A_2,_A_3,_A_4));
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const
+    {
+      return lambda_action_unary<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const
+    {
+      return lambda_action_unary<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5));
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const
+    {
+      return lambda_action_unary<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5,_A_6));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const
+    {
+      return lambda_action_unary<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5,_A_6));
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const
+    {
+      return lambda_action_unary<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const
+    {
+      return lambda_action_unary<T_action>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7));
+    }
+  #endif
+
+  lambda_operator_unary(typename type_trait<T_type>::take a)
+    : arg_(a) {}
+
+  arg_type arg_;
+};
+
+template <class T_action, class T_type>
+typename lambda_operator_unary<T_action, T_type>::result_type
+lambda_operator_unary<T_action, T_type>::operator ()() const
+  { return lambda_action_unary<T_action>::template do_action<
+      typename arg_type::result_type>
+      (arg_()); }
+
+template <class T_action, class T_lambda_action, class T_arg>
+void visit_each(const T_action& _A_action,
+                const lambda_operator_unary<T_lambda_action, T_arg>& _A_target)
+{
+  visit_each(_A_action, _A_target.arg_);
+}
+
+
+template <class T_action, class T_type, class T_arg>
+struct lambda_operator_convert : public lambda_base
+{
+  typedef typename lambda<T_arg>::lambda_type arg_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename arg_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::type operand_type;
+      typedef typename lambda_action_convert_deduce_result_type<T_action, T_type, operand_type>::type type;
+    };
+  typedef typename lambda_action_convert_deduce_result_type<
+      T_action, T_type,
+      typename arg_type::result_type
+    >::type result_type;
+
+  result_type
+  operator ()() const;
+
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator ()(T_arg1 _A_1) const
+    {
+      return lambda_action_convert<T_action, T_type>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+            (_A_1));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  sun_forte_workaround(T_arg1 _A_1) const
+    {
+      return lambda_action_convert<T_action, T_type>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+            (_A_1));
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2) const
+    {
+      return lambda_action_convert<T_action, T_type>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
+            (_A_1,_A_2));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const
+    {
+      return lambda_action_convert<T_action, T_type>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
+            (_A_1,_A_2));
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const
+    {
+      return lambda_action_convert<T_action, T_type>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
+            (_A_1,_A_2,_A_3));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const
+    {
+      return lambda_action_convert<T_action, T_type>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
+            (_A_1,_A_2,_A_3));
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const
+    {
+      return lambda_action_convert<T_action, T_type>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
+            (_A_1,_A_2,_A_3,_A_4));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const
+    {
+      return lambda_action_convert<T_action, T_type>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
+            (_A_1,_A_2,_A_3,_A_4));
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const
+    {
+      return lambda_action_convert<T_action, T_type>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const
+    {
+      return lambda_action_convert<T_action, T_type>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5));
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const
+    {
+      return lambda_action_convert<T_action, T_type>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5,_A_6));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const
+    {
+      return lambda_action_convert<T_action, T_type>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5,_A_6));
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const
+    {
+      return lambda_action_convert<T_action, T_type>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const
+    {
+      return lambda_action_convert<T_action, T_type>::template do_action<
+            typename deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::operand_type>
+        (arg_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
+            (_A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7));
+    }
+  #endif
+
+  lambda_operator_convert(typename type_trait<T_arg>::take a)
+    : arg_(a) {}
+
+  arg_type arg_;
+};
+
+template <class T_action, class T_type, class T_arg>
+typename lambda_operator_convert<T_action, T_type, T_arg>::result_type
+lambda_operator_convert<T_action, T_type, T_arg>::operator ()() const
+  { return lambda_action_convert<T_action, T_type>::template do_action<
+      typename arg_type::result_type>
+      (arg_()); }
+
+template <class T_action, class T_lambda_action, class T_type, class T_arg>
+void visit_each(const T_action& _A_action,
+                const lambda_operator_convert<T_lambda_action, T_type, T_arg>& _A_target)
+{
+  visit_each(_A_action, _A_target.arg_);
+}
+
+
+// Operators for lambda action arithmetic<plus>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic<plus>, T_arg1, T_arg2> >
+operator + (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<arithmetic<plus>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic<plus>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator + (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<arithmetic<plus>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic<plus>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator + (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<arithmetic<plus>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action arithmetic<minus>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic<minus>, T_arg1, T_arg2> >
+operator - (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<arithmetic<minus>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic<minus>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator - (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<arithmetic<minus>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic<minus>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator - (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<arithmetic<minus>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action arithmetic<multiplies>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic<multiplies>, T_arg1, T_arg2> >
+operator * (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<arithmetic<multiplies>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic<multiplies>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator * (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<arithmetic<multiplies>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic<multiplies>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator * (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<arithmetic<multiplies>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action arithmetic<divides>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic<divides>, T_arg1, T_arg2> >
+operator / (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<arithmetic<divides>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic<divides>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator / (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<arithmetic<divides>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic<divides>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator / (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<arithmetic<divides>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action arithmetic<modulus>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic<modulus>, T_arg1, T_arg2> >
+operator % (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<arithmetic<modulus>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic<modulus>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator % (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<arithmetic<modulus>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic<modulus>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator % (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<arithmetic<modulus>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action bitwise<leftshift>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise<leftshift>, T_arg1, T_arg2> >
+operator << (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<bitwise<leftshift>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise<leftshift>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator << (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<bitwise<leftshift>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise<leftshift>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator << (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<bitwise<leftshift>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action bitwise<rightshift>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise<rightshift>, T_arg1, T_arg2> >
+operator >> (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<bitwise<rightshift>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise<rightshift>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator >> (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<bitwise<rightshift>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise<rightshift>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator >> (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<bitwise<rightshift>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action bitwise<and_>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise<and_>, T_arg1, T_arg2> >
+operator & (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<bitwise<and_>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise<and_>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator & (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<bitwise<and_>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise<and_>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator & (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<bitwise<and_>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action bitwise<or_>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise<or_>, T_arg1, T_arg2> >
+operator | (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<bitwise<or_>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise<or_>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator | (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<bitwise<or_>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise<or_>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator | (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<bitwise<or_>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action bitwise<xor_>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise<xor_>, T_arg1, T_arg2> >
+operator ^ (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<bitwise<xor_>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise<xor_>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator ^ (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<bitwise<xor_>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise<xor_>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator ^ (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<bitwise<xor_>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action logical<and_>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<logical<and_>, T_arg1, T_arg2> >
+operator && (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<logical<and_>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<logical<and_>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator && (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<logical<and_>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<logical<and_>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator && (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<logical<and_>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action logical<or_>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<logical<or_>, T_arg1, T_arg2> >
+operator || (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<logical<or_>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<logical<or_>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator || (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<logical<or_>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<logical<or_>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator || (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<logical<or_>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action relational<less>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<relational<less>, T_arg1, T_arg2> >
+operator < (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<relational<less>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<relational<less>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator < (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<relational<less>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<relational<less>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator < (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<relational<less>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action relational<greater>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<relational<greater>, T_arg1, T_arg2> >
+operator > (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<relational<greater>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<relational<greater>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator > (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<relational<greater>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<relational<greater>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator > (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<relational<greater>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action relational<less_equal>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<relational<less_equal>, T_arg1, T_arg2> >
+operator <= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<relational<less_equal>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<relational<less_equal>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator <= (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<relational<less_equal>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<relational<less_equal>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator <= (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<relational<less_equal>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action relational<greater_equal>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<relational<greater_equal>, T_arg1, T_arg2> >
+operator >= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<relational<greater_equal>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<relational<greater_equal>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator >= (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<relational<greater_equal>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<relational<greater_equal>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator >= (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<relational<greater_equal>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action relational<equal_to>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<relational<equal_to>, T_arg1, T_arg2> >
+operator == (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<relational<equal_to>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<relational<equal_to>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator == (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<relational<equal_to>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<relational<equal_to>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator == (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<relational<equal_to>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action relational<not_equal_to>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<relational<not_equal_to>, T_arg1, T_arg2> >
+operator != (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<relational<not_equal_to>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<relational<not_equal_to>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator != (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<relational<not_equal_to>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<relational<not_equal_to>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator != (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<relational<not_equal_to>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action arithmetic_assign<plus>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic_assign<plus>, T_arg1, T_arg2> >
+operator += (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<arithmetic_assign<plus>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic_assign<plus>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator += (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<arithmetic_assign<plus>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic_assign<plus>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator += (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<arithmetic_assign<plus>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action arithmetic_assign<minus>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic_assign<minus>, T_arg1, T_arg2> >
+operator -= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<arithmetic_assign<minus>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic_assign<minus>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator -= (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<arithmetic_assign<minus>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic_assign<minus>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator -= (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<arithmetic_assign<minus>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action arithmetic_assign<multiplies>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic_assign<multiplies>, T_arg1, T_arg2> >
+operator *= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<arithmetic_assign<multiplies>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic_assign<multiplies>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator *= (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<arithmetic_assign<multiplies>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic_assign<multiplies>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator *= (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<arithmetic_assign<multiplies>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action arithmetic_assign<divides>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic_assign<divides>, T_arg1, T_arg2> >
+operator /= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<arithmetic_assign<divides>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic_assign<divides>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator /= (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<arithmetic_assign<divides>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic_assign<divides>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator /= (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<arithmetic_assign<divides>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action arithmetic_assign<modulus>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic_assign<modulus>, T_arg1, T_arg2> >
+operator %= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<arithmetic_assign<modulus>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic_assign<modulus>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator %= (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<arithmetic_assign<modulus>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<arithmetic_assign<modulus>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator %= (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<arithmetic_assign<modulus>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action bitwise_assign<leftshift>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise_assign<leftshift>, T_arg1, T_arg2> >
+operator <<= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<bitwise_assign<leftshift>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise_assign<leftshift>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator <<= (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<bitwise_assign<leftshift>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise_assign<leftshift>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator <<= (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<bitwise_assign<leftshift>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action bitwise_assign<rightshift>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise_assign<rightshift>, T_arg1, T_arg2> >
+operator >>= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<bitwise_assign<rightshift>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise_assign<rightshift>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator >>= (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<bitwise_assign<rightshift>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise_assign<rightshift>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator >>= (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<bitwise_assign<rightshift>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action bitwise_assign<and_>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise_assign<and_>, T_arg1, T_arg2> >
+operator &= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<bitwise_assign<and_>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise_assign<and_>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator &= (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<bitwise_assign<and_>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise_assign<and_>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator &= (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<bitwise_assign<and_>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action bitwise_assign<or_>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise_assign<or_>, T_arg1, T_arg2> >
+operator |= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<bitwise_assign<or_>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise_assign<or_>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator |= (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<bitwise_assign<or_>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise_assign<or_>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator |= (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<bitwise_assign<or_>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operators for lambda action bitwise_assign<xor_>. At least one of the arguments needs to be of type lamdba, hence the overloads.
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise_assign<xor_>, T_arg1, T_arg2> >
+operator ^= (const lambda<T_arg1>& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<bitwise_assign<xor_>, T_arg1, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2.value_)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise_assign<xor_>, T_arg1, typename unwrap_reference<T_arg2>::type> >
+operator ^= (const lambda<T_arg1>& a1, const T_arg2& a2)
+{ typedef lambda_operator<bitwise_assign<xor_>, T_arg1, typename unwrap_reference<T_arg2>::type> operator_type;
+  return lambda<operator_type>(operator_type(a1.value_,a2)); }
+template <class T_arg1, class T_arg2>
+lambda<lambda_operator<bitwise_assign<xor_>, typename unwrap_reference<T_arg1>::type, T_arg2> >
+operator ^= (const T_arg1& a1, const lambda<T_arg2>& a2)
+{ typedef lambda_operator<bitwise_assign<xor_>, typename unwrap_reference<T_arg1>::type, T_arg2> operator_type;
+  return lambda<operator_type>(operator_type(a1,a2.value_)); }
+
+// Operator for lambda action unary_arithmetic<pre_increment>.
+template <class T_arg>
+lambda<lambda_operator_unary<unary_arithmetic<pre_increment>, T_arg> >
+operator ++ (const lambda<T_arg>& a)
+{ typedef lambda_operator_unary<unary_arithmetic<pre_increment>, T_arg> operator_type;
+  return lambda<operator_type>(operator_type(a.value_)); }
+
+// Operator for lambda action unary_arithmetic<pre_decrement>.
+template <class T_arg>
+lambda<lambda_operator_unary<unary_arithmetic<pre_decrement>, T_arg> >
+operator -- (const lambda<T_arg>& a)
+{ typedef lambda_operator_unary<unary_arithmetic<pre_decrement>, T_arg> operator_type;
+  return lambda<operator_type>(operator_type(a.value_)); }
+
+// Operator for lambda action unary_arithmetic<negate>.
+template <class T_arg>
+lambda<lambda_operator_unary<unary_arithmetic<negate>, T_arg> >
+operator - (const lambda<T_arg>& a)
+{ typedef lambda_operator_unary<unary_arithmetic<negate>, T_arg> operator_type;
+  return lambda<operator_type>(operator_type(a.value_)); }
+
+// Operator for lambda action unary_bitwise<not_>.
+template <class T_arg>
+lambda<lambda_operator_unary<unary_bitwise<not_>, T_arg> >
+operator ~ (const lambda<T_arg>& a)
+{ typedef lambda_operator_unary<unary_bitwise<not_>, T_arg> operator_type;
+  return lambda<operator_type>(operator_type(a.value_)); }
+
+// Operator for lambda action unary_logical<not_>.
+template <class T_arg>
+lambda<lambda_operator_unary<unary_logical<not_>, T_arg> >
+operator ! (const lambda<T_arg>& a)
+{ typedef lambda_operator_unary<unary_logical<not_>, T_arg> operator_type;
+  return lambda<operator_type>(operator_type(a.value_)); }
+
+// Operator for lambda action unary_other<address>.
+template <class T_arg>
+lambda<lambda_operator_unary<unary_other<address>, T_arg> >
+operator & (const lambda<T_arg>& a)
+{ typedef lambda_operator_unary<unary_other<address>, T_arg> operator_type;
+  return lambda<operator_type>(operator_type(a.value_)); }
+
+// Operator for lambda action unary_other<dereference>.
+template <class T_arg>
+lambda<lambda_operator_unary<unary_other<dereference>, T_arg> >
+operator * (const lambda<T_arg>& a)
+{ typedef lambda_operator_unary<unary_other<dereference>, T_arg> operator_type;
+  return lambda<operator_type>(operator_type(a.value_)); }
+
+// Creators for lambda action cast_<reinterpret_>.
+template <class T_type, class T_arg>
+lambda<lambda_operator_convert<cast_<reinterpret_>, T_type, typename unwrap_lambda_type<T_arg>::type> >
+reinterpret_cast_(const T_arg& a)
+{ typedef lambda_operator_convert<cast_<reinterpret_>, T_type, typename unwrap_lambda_type<T_arg>::type> operator_type;
+  return lambda<operator_type>(operator_type(unwrap_lambda_value(a))); }
+
+// Creators for lambda action cast_<static_>.
+template <class T_type, class T_arg>
+lambda<lambda_operator_convert<cast_<static_>, T_type, typename unwrap_lambda_type<T_arg>::type> >
+static_cast_(const T_arg& a)
+{ typedef lambda_operator_convert<cast_<static_>, T_type, typename unwrap_lambda_type<T_arg>::type> operator_type;
+  return lambda<operator_type>(operator_type(unwrap_lambda_value(a))); }
+
+// Creators for lambda action cast_<dynamic_>.
+template <class T_type, class T_arg>
+lambda<lambda_operator_convert<cast_<dynamic_>, T_type, typename unwrap_lambda_type<T_arg>::type> >
+dynamic_cast_(const T_arg& a)
+{ typedef lambda_operator_convert<cast_<dynamic_>, T_type, typename unwrap_lambda_type<T_arg>::type> operator_type;
+  return lambda<operator_type>(operator_type(unwrap_lambda_value(a))); }
+
+
+} /* namespace sigc */
+
+#endif /* _SIGC_LAMBDA_OPERATOR_HPP_ */
diff --git a/libs/sigc++2/sigc++/adaptors/lambda/select.h b/libs/sigc++2/sigc++/adaptors/lambda/select.h
new file mode 100644
index 0000000000..7cbf3eccfb
--- /dev/null
+++ b/libs/sigc++2/sigc++/adaptors/lambda/select.h
@@ -0,0 +1,346 @@
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_LAMBDA_SELECT_HPP_
+#define _SIGC_LAMBDA_SELECT_HPP_
+#include <sigc++/adaptors/lambda/base.h>
+
+namespace sigc {
+
+namespace internal {
+struct lambda_select1 : public lambda_base
+{
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef T_arg1 type; };
+  typedef void result_type; // no operator ()() overload
+
+  void operator ()() const; // not implemented
+  template <class T_arg1>
+  T_arg1 operator ()(T_arg1 _A_1) const { return _A_1; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1) const { return operator()( _A_1 ); }
+  T_arg1 sun_forte_workaround(T_arg1 _A_1) const { return _A_1; }
+  #endif
+  
+  template <class T_arg1,class T_arg2>
+  T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2) const { return _A_1; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const { return operator()( _A_1,_A_2 ); }
+  T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const { return _A_1; }
+  #endif
+  
+  template <class T_arg1,class T_arg2,class T_arg3>
+  T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_1; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return operator()( _A_1,_A_2,_A_3 ); }
+  T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_1; }
+  #endif
+  
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_1; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return operator()( _A_1,_A_2,_A_3,_A_4 ); }
+  T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_1; }
+  #endif
+  
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_1; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
+  T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_1; }
+  #endif
+  
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_1; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
+  T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_1; }
+  #endif
+  
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_1; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
+  T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_1; }
+  #endif
+  
+};
+
+struct lambda_select2 : public lambda_base
+{
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef T_arg2 type; };
+  typedef void result_type; // no operator ()() overload
+
+  void operator ()() const; // not implemented
+  template <class T_arg1,class T_arg2>
+  T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2) const { return _A_2; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const { return operator()( _A_1,_A_2 ); }
+  T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const { return _A_2; }
+  #endif
+  
+  template <class T_arg1,class T_arg2,class T_arg3>
+  T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_2; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return operator()( _A_1,_A_2,_A_3 ); }
+  T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_2; }
+  #endif
+  
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_2; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return operator()( _A_1,_A_2,_A_3,_A_4 ); }
+  T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_2; }
+  #endif
+  
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_2; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
+  T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_2; }
+  #endif
+  
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_2; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
+  T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_2; }
+  #endif
+  
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_2; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
+  T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_2; }
+  #endif
+  
+};
+
+struct lambda_select3 : public lambda_base
+{
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef T_arg3 type; };
+  typedef void result_type; // no operator ()() overload
+
+  void operator ()() const; // not implemented
+  template <class T_arg1,class T_arg2,class T_arg3>
+  T_arg3 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_3; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  //Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return operator()( _A_1,_A_2,_A_3 ); }
+  T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_3; }
+  #endif
+  
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  T_arg3 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_3; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  //Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return operator()( _A_1,_A_2,_A_3,_A_4 ); }
+  T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_3; }
+  #endif
+  
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  T_arg3 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_3; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  //Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
+  T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_3; }
+  #endif
+  
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  T_arg3 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_3; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  //Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
+  T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_3; }
+  #endif
+  
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  T_arg3 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_3; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  //Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
+  T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_3; }
+  #endif
+  
+};
+
+struct lambda_select4 : public lambda_base
+{
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef T_arg4 type; };
+  typedef void result_type; // no operator ()() overload
+
+  void operator ()() const; // not implemented
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  T_arg4 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_4; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  //Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return operator()( _A_1,_A_2,_A_3,_A_4 ); }
+  T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_4; }
+  #endif
+  
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  T_arg4 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_4; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  //Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
+  T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_4; }
+  #endif
+  
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  T_arg4 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_4; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  //Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
+  T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_4; }
+  #endif
+  
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  T_arg4 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_4; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  //Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
+  T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_4; }
+  #endif
+  
+};
+
+struct lambda_select5 : public lambda_base
+{
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef T_arg5 type; };
+  typedef void result_type; // no operator ()() overload
+
+  void operator ()() const; // not implemented
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  T_arg5 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_5; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  //Does not work: T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
+  T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_5; }
+  #endif
+  
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  T_arg5 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_5; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  //Does not work: T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
+  T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_5; }
+  #endif
+  
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  T_arg5 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_5; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  //Does not work: T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
+  T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_5; }
+  #endif
+  
+};
+
+struct lambda_select6 : public lambda_base
+{
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef T_arg6 type; };
+  typedef void result_type; // no operator ()() overload
+
+  void operator ()() const; // not implemented
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  T_arg6 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_6; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  //Does not work: T_arg6 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
+  T_arg6 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_6; }
+  #endif
+  
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  T_arg6 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_6; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  //Does not work: T_arg6 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
+  T_arg6 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_6; }
+  #endif
+  
+};
+
+struct lambda_select7 : public lambda_base
+{
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef T_arg7 type; };
+  typedef void result_type; // no operator ()() overload
+
+  void operator ()() const; // not implemented
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  T_arg7 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_7; }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  //Does not work: T_arg7 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
+  T_arg7 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_7; }
+  #endif
+  
+};
+
+
+} /* namespace internal */
+
+extern SIGC_API const lambda<internal::lambda_select1> _1;
+extern SIGC_API const lambda<internal::lambda_select2> _2;
+extern SIGC_API const lambda<internal::lambda_select3> _3;
+extern SIGC_API const lambda<internal::lambda_select4> _4;
+extern SIGC_API const lambda<internal::lambda_select5> _5;
+extern SIGC_API const lambda<internal::lambda_select6> _6;
+extern SIGC_API const lambda<internal::lambda_select7> _7;
+
+
+} /* namespace sigc */
+
+#endif /* _SIGC_LAMBDA_SELECT_HPP_ */
diff --git a/libs/sigc++2/sigc++/adaptors/retype.h b/libs/sigc++2/sigc++/adaptors/retype.h
new file mode 100644
index 0000000000..502959d3cd
--- /dev/null
+++ b/libs/sigc++2/sigc++/adaptors/retype.h
@@ -0,0 +1,1247 @@
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_ADAPTORS_MACROS_RETYPEHM4_
+#define _SIGC_ADAPTORS_MACROS_RETYPEHM4_
+#include <sigc++/adaptors/adaptor_trait.h>
+#include <sigc++/functors/ptr_fun.h>
+#include <sigc++/functors/mem_fun.h>
+#include <sigc++/functors/slot.h>
+
+namespace sigc {
+
+/** @defgroup retype retype(), retype_return()
+ * sigc::retype() alters a sigc::pointer_functor, a sigc::mem_functor or a sigc::slot
+ * in that it makes C-style casts to the functor's parameter types
+ * of all parameters passed through operator()().
+ *
+ * Use this adaptor for inline conversion between numeric or other simple types.
+ * @par Example:
+ *   @code
+ *   void foo(int);
+ *   sigc::retype(sigc::ptr_fun(&foo))(5.7F); // calls foo(5)
+ *   @endcode
+ *
+ * The functor sigc::retype() returns can be passed into
+ * sigc::signal::connect() directly.
+ *
+ * @par Example:
+ *   @code
+ *   sigc::signal<void,float> some_signal;
+ *   void foo(int);
+ *   some_signal.connect(sigc::retype(sigc::ptr_fun(&foo)));
+ *   @endcode
+ *
+ * This adaptor builds an exception in that it only works on sig::pointer_functor,
+ * sigc::mem_functor and sigc::slot because it needs sophisticated information about
+ * the parameter types that cannot be deduced from arbitrary functor types.
+ *
+ * sigc::retype_return() alters the return type of an arbitrary functor.
+ * Like in sigc::retype() a C-style cast is preformed. Usage sigc::retype_return() is
+ * not restricted to libsigc++ functor types but you need to
+ * specify the new return type as a template parameter.
+ *
+ * @par Example:
+ *   @code
+ *   float foo();
+ *   std::cout << sigc::retype_return<int>(&foo)(); // converts foo's return value to an integer
+ *   @endcode
+ *
+ * @ingroup adaptors
+ */
+
+/** Adaptor that performs C-style casts on the parameters passed on to the functor.
+ * Use the convenience function sigc::retype() to create an instance of retype_functor.
+ *
+ * The following template arguments are used:
+ * - @e T_functor Type of the functor to wrap.
+ * - @e T_type1 Type of @e T_functor's 1th argument.
+ * - @e T_type2 Type of @e T_functor's 2th argument.
+ * - @e T_type3 Type of @e T_functor's 3th argument.
+ * - @e T_type4 Type of @e T_functor's 4th argument.
+ * - @e T_type5 Type of @e T_functor's 5th argument.
+ * - @e T_type6 Type of @e T_functor's 6th argument.
+ * - @e T_type7 Type of @e T_functor's 7th argument.
+ *
+ * @ingroup retype
+ */
+template <class T_functor, class T_type1=nil,class T_type2=nil,class T_type3=nil,class T_type4=nil,class T_type5=nil,class T_type6=nil,class T_type7=nil>
+struct retype_functor
+  : public adapts<T_functor>
+{
+  typedef typename adapts<T_functor>::adaptor_type adaptor_type;
+
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>::type type; };
+  typedef typename adapts<T_functor>::result_type result_type;
+
+  result_type operator()();
+    
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  operator()(T_arg1 _A_a1)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take>
+        ((T_type1)_A_a1);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  typename deduce_result_type<T_arg1>::type
+  sun_forte_workaround(T_arg1 _A_a1)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take>
+        ((T_type1)_A_a1);
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take>
+        ((T_type1)_A_a1,(T_type2)_A_a2);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  typename deduce_result_type<T_arg1,T_arg2>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take>
+        ((T_type1)_A_a1,(T_type2)_A_a2);
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take>
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take>
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3);
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take>
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take>
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4);
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take>
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take>
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5);
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take,typename type_trait<T_type6>::take>
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take,typename type_trait<T_type6>::take>
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6);
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take,typename type_trait<T_type6>::take,typename type_trait<T_type7>::take>
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6,(T_type7)_A_a7);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take,typename type_trait<T_type6>::take,typename type_trait<T_type7>::take>
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6,(T_type7)_A_a7);
+    }
+  #endif
+
+
+  /** Constructs a retype_functor object that performs C-style casts on the parameters passed on to the functor.
+   * @param _A_functor Functor to invoke from operator()().
+   */
+  explicit retype_functor(typename type_trait<T_functor>::take _A_functor)
+    : adapts<T_functor>(_A_functor)
+    {}
+};
+
+template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6,class T_type7>
+typename retype_functor<T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>::result_type
+retype_functor<T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>::operator()()
+  { return this->functor_(); }
+
+
+/** Performs a functor on each of the targets of a functor.
+ * The function overload for sigc::retype_functor performs a functor on the
+ * functor stored in the sigc::retype_functor object.
+ *
+ * @ingroup retype
+ */
+template <class T_action, class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6,class T_type7>
+void visit_each(const T_action& _A_action,
+                const retype_functor<T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>& _A_target)
+{
+  visit_each(_A_action, _A_target.functor_);
+}
+
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::slot.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+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 retype_functor<slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
+retype(const slot<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_functor)
+{ return retype_functor<slot<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
+    (_A_functor); }
+
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::pointer_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return>
+inline retype_functor<pointer_functor0<T_return> >
+retype(const pointer_functor0<T_return>& _A_functor)
+{ return retype_functor<pointer_functor0<T_return> >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::pointer_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_arg1, class T_return>
+inline retype_functor<pointer_functor1<T_arg1, T_return>, T_arg1 >
+retype(const pointer_functor1<T_arg1, T_return>& _A_functor)
+{ return retype_functor<pointer_functor1<T_arg1, T_return>, T_arg1 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::pointer_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_arg1,class T_arg2, class T_return>
+inline retype_functor<pointer_functor2<T_arg1, T_arg2, T_return>, T_arg1,T_arg2 >
+retype(const pointer_functor2<T_arg1,T_arg2, T_return>& _A_functor)
+{ return retype_functor<pointer_functor2<T_arg1, T_arg2, T_return>, T_arg1,T_arg2 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::pointer_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_arg1,class T_arg2,class T_arg3, class T_return>
+inline retype_functor<pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>, T_arg1,T_arg2,T_arg3 >
+retype(const pointer_functor3<T_arg1,T_arg2,T_arg3, T_return>& _A_functor)
+{ return retype_functor<pointer_functor3<T_arg1, T_arg2, T_arg3, T_return>, T_arg1,T_arg2,T_arg3 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::pointer_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_arg1,class T_arg2,class T_arg3,class T_arg4, class T_return>
+inline retype_functor<pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return>, T_arg1,T_arg2,T_arg3,T_arg4 >
+retype(const pointer_functor4<T_arg1,T_arg2,T_arg3,T_arg4, T_return>& _A_functor)
+{ return retype_functor<pointer_functor4<T_arg1, T_arg2, T_arg3, T_arg4, T_return>, T_arg1,T_arg2,T_arg3,T_arg4 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::pointer_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5, class T_return>
+inline retype_functor<pointer_functor5<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
+retype(const pointer_functor5<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, T_return>& _A_functor)
+{ return retype_functor<pointer_functor5<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_return>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::pointer_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6, class T_return>
+inline retype_functor<pointer_functor6<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
+retype(const pointer_functor6<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, T_return>& _A_functor)
+{ return retype_functor<pointer_functor6<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_return>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::pointer_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7, class T_return>
+inline retype_functor<pointer_functor7<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
+retype(const pointer_functor7<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7, T_return>& _A_functor)
+{ return retype_functor<pointer_functor7<T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7, T_return>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
+    (_A_functor); }
+
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj>
+inline retype_functor<mem_functor0<T_return, T_obj> >
+retype(const mem_functor0<T_return, T_obj>& _A_functor)
+{ return retype_functor<mem_functor0<T_return, T_obj> >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1>
+inline retype_functor<mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+retype(const mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
+{ return retype_functor<mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2>
+inline retype_functor<mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
+retype(const mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
+{ return retype_functor<mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
+inline retype_functor<mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
+retype(const mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
+{ return retype_functor<mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+inline retype_functor<mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
+retype(const mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
+{ return retype_functor<mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+inline retype_functor<mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
+retype(const mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
+{ return retype_functor<mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+inline retype_functor<mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
+retype(const mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
+{ return retype_functor<mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+inline retype_functor<mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
+retype(const mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_functor)
+{ return retype_functor<mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::const_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj>
+inline retype_functor<const_mem_functor0<T_return, T_obj> >
+retype(const const_mem_functor0<T_return, T_obj>& _A_functor)
+{ return retype_functor<const_mem_functor0<T_return, T_obj> >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::const_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1>
+inline retype_functor<const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+retype(const const_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
+{ return retype_functor<const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::const_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2>
+inline retype_functor<const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
+retype(const const_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
+{ return retype_functor<const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::const_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
+inline retype_functor<const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
+retype(const const_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
+{ return retype_functor<const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::const_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+inline retype_functor<const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
+retype(const const_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
+{ return retype_functor<const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::const_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+inline retype_functor<const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
+retype(const const_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
+{ return retype_functor<const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::const_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+inline retype_functor<const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
+retype(const const_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
+{ return retype_functor<const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::const_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+inline retype_functor<const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
+retype(const const_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_functor)
+{ return retype_functor<const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj>
+inline retype_functor<volatile_mem_functor0<T_return, T_obj> >
+retype(const volatile_mem_functor0<T_return, T_obj>& _A_functor)
+{ return retype_functor<volatile_mem_functor0<T_return, T_obj> >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1>
+inline retype_functor<volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+retype(const volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
+{ return retype_functor<volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2>
+inline retype_functor<volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
+retype(const volatile_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
+{ return retype_functor<volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
+inline retype_functor<volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
+retype(const volatile_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
+{ return retype_functor<volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+inline retype_functor<volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
+retype(const volatile_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
+{ return retype_functor<volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+inline retype_functor<volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
+retype(const volatile_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
+{ return retype_functor<volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+inline retype_functor<volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
+retype(const volatile_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
+{ return retype_functor<volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+inline retype_functor<volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
+retype(const volatile_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_functor)
+{ return retype_functor<volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::const_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj>
+inline retype_functor<const_volatile_mem_functor0<T_return, T_obj> >
+retype(const const_volatile_mem_functor0<T_return, T_obj>& _A_functor)
+{ return retype_functor<const_volatile_mem_functor0<T_return, T_obj> >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::const_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1>
+inline retype_functor<const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+retype(const const_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
+{ return retype_functor<const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::const_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2>
+inline retype_functor<const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
+retype(const const_volatile_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
+{ return retype_functor<const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::const_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
+inline retype_functor<const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
+retype(const const_volatile_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
+{ return retype_functor<const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::const_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+inline retype_functor<const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
+retype(const const_volatile_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
+{ return retype_functor<const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::const_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+inline retype_functor<const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
+retype(const const_volatile_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
+{ return retype_functor<const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::const_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+inline retype_functor<const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
+retype(const const_volatile_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
+{ return retype_functor<const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::const_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+inline retype_functor<const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
+retype(const const_volatile_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_functor)
+{ return retype_functor<const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj>
+inline retype_functor<bound_mem_functor0<T_return, T_obj> >
+retype(const bound_mem_functor0<T_return, T_obj>& _A_functor)
+{ return retype_functor<bound_mem_functor0<T_return, T_obj> >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1>
+inline retype_functor<bound_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+retype(const bound_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
+{ return retype_functor<bound_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2>
+inline retype_functor<bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
+retype(const bound_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
+{ return retype_functor<bound_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
+inline retype_functor<bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
+retype(const bound_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
+{ return retype_functor<bound_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+inline retype_functor<bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
+retype(const bound_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
+{ return retype_functor<bound_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+inline retype_functor<bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
+retype(const bound_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
+{ return retype_functor<bound_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+inline retype_functor<bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
+retype(const bound_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
+{ return retype_functor<bound_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+inline retype_functor<bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
+retype(const bound_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_functor)
+{ return retype_functor<bound_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_const_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj>
+inline retype_functor<bound_const_mem_functor0<T_return, T_obj> >
+retype(const bound_const_mem_functor0<T_return, T_obj>& _A_functor)
+{ return retype_functor<bound_const_mem_functor0<T_return, T_obj> >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_const_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1>
+inline retype_functor<bound_const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+retype(const bound_const_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
+{ return retype_functor<bound_const_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_const_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2>
+inline retype_functor<bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
+retype(const bound_const_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
+{ return retype_functor<bound_const_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_const_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
+inline retype_functor<bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
+retype(const bound_const_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
+{ return retype_functor<bound_const_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_const_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+inline retype_functor<bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
+retype(const bound_const_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
+{ return retype_functor<bound_const_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_const_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+inline retype_functor<bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
+retype(const bound_const_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
+{ return retype_functor<bound_const_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_const_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+inline retype_functor<bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
+retype(const bound_const_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
+{ return retype_functor<bound_const_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_const_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+inline retype_functor<bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
+retype(const bound_const_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_functor)
+{ return retype_functor<bound_const_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj>
+inline retype_functor<bound_volatile_mem_functor0<T_return, T_obj> >
+retype(const bound_volatile_mem_functor0<T_return, T_obj>& _A_functor)
+{ return retype_functor<bound_volatile_mem_functor0<T_return, T_obj> >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1>
+inline retype_functor<bound_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+retype(const bound_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
+{ return retype_functor<bound_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2>
+inline retype_functor<bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
+retype(const bound_volatile_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
+{ return retype_functor<bound_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
+inline retype_functor<bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
+retype(const bound_volatile_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
+{ return retype_functor<bound_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+inline retype_functor<bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
+retype(const bound_volatile_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
+{ return retype_functor<bound_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+inline retype_functor<bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
+retype(const bound_volatile_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
+{ return retype_functor<bound_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+inline retype_functor<bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
+retype(const bound_volatile_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
+{ return retype_functor<bound_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+inline retype_functor<bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
+retype(const bound_volatile_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_functor)
+{ return retype_functor<bound_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_const_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj>
+inline retype_functor<bound_const_volatile_mem_functor0<T_return, T_obj> >
+retype(const bound_const_volatile_mem_functor0<T_return, T_obj>& _A_functor)
+{ return retype_functor<bound_const_volatile_mem_functor0<T_return, T_obj> >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_const_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1>
+inline retype_functor<bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+retype(const bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_functor)
+{ return retype_functor<bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>, T_arg1 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_const_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2>
+inline retype_functor<bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
+retype(const bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_functor)
+{ return retype_functor<bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1, T_arg2>, T_arg1,T_arg2 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_const_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3>
+inline retype_functor<bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
+retype(const bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_functor)
+{ return retype_functor<bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1, T_arg2, T_arg3>, T_arg1,T_arg2,T_arg3 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_const_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+inline retype_functor<bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
+retype(const bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_functor)
+{ return retype_functor<bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>, T_arg1,T_arg2,T_arg3,T_arg4 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_const_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+inline retype_functor<bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
+retype(const bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_functor)
+{ return retype_functor<bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_const_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+inline retype_functor<bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
+retype(const bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_functor)
+{ return retype_functor<bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6 >
+    (_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor.
+ * This function template specialization works on sigc::bound_const_volatile_mem_functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_obj, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+inline retype_functor<bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
+retype(const bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_functor)
+{ return retype_functor<bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7 >
+    (_A_functor); }
+
+
+} /* namespace sigc */
+#endif /* _SIGC_ADAPTORS_MACROS_RETYPEHM4_ */
diff --git a/libs/sigc++2/sigc++/adaptors/retype_return.h b/libs/sigc++2/sigc++/adaptors/retype_return.h
new file mode 100644
index 0000000000..ea413a0b30
--- /dev/null
+++ b/libs/sigc++2/sigc++/adaptors/retype_return.h
@@ -0,0 +1,308 @@
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+#ifndef _SIGC_ADAPTORS_MACROS_RETYPE_RETURNHM4_
+#define _SIGC_ADAPTORS_MACROS_RETYPE_RETURNHM4_
+#include <sigc++/adaptors/adaptor_trait.h>
+
+namespace sigc {
+
+/** Adaptor that perform a C-style cast on the return value of a functor.
+ * Use the convenience function sigc::retype_return() to create an instance of retype_return_functor.
+ *
+ * The following template arguments are used:
+ * - @e T_return Target type of the C-style cast.
+ * - @e T_functor Type of the functor to wrap.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_functor>
+struct retype_return_functor : public adapts<T_functor>
+{
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef T_return type; };
+  typedef T_return result_type;
+
+  T_return operator()();
+
+  template <class T_arg1>
+  inline T_return operator()(T_arg1 _A_a1)
+    { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+        (_A_a1));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  inline T_return sun_forte_workaround(T_arg1 _A_a1)
+    { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+        (_A_a1));
+    }
+  #endif
+    
+  template <class T_arg1,class T_arg2>
+  inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2)
+    { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
+        (_A_a1,_A_a2));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
+    { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
+        (_A_a1,_A_a2));
+    }
+  #endif
+    
+  template <class T_arg1,class T_arg2,class T_arg3>
+  inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+    { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
+        (_A_a1,_A_a2,_A_a3));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+    { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
+        (_A_a1,_A_a2,_A_a3));
+    }
+  #endif
+    
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4));
+    }
+  #endif
+    
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5));
+    }
+  #endif
+    
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6));
+    }
+  #endif
+    
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7));
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7));
+    }
+  #endif
+    
+  retype_return_functor() {}
+
+  /** Constructs a retype_return_functor object that perform a C-style cast on the return value of the passed functor.
+   * @param _A_functor Functor to invoke from operator()().
+   */
+  explicit retype_return_functor(typename type_trait<T_functor>::take _A_functor)
+    : adapts<T_functor>(_A_functor)
+    {}
+};
+
+template <class T_return, class T_functor>
+T_return retype_return_functor<T_return, T_functor>::operator()()
+  { return T_return(this->functor_()); }
+
+
+/** Adaptor that perform a C-style cast on the return value of a functor.
+ * This template specialization is for a void return. It drops the return value of the functor it invokes.
+ * Use the convenience function sigc::hide_return() to create an instance of sigc::retype_return_functor<void>.
+ *
+ * @ingroup retype
+ */
+/* The void specialization needed because of explicit cast to T_return.
+ */
+template <class T_functor>
+struct retype_return_functor<void, T_functor> : public adapts<T_functor>
+{
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+  struct deduce_result_type
+    { typedef void type; };
+  typedef void result_type;
+
+  void operator()();
+
+  template <class T_arg1>
+  inline void operator()(T_arg1 _A_a1)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+        (_A_a1);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1>
+  inline void sun_forte_workaround(T_arg1 _A_a1)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
+        (_A_a1);
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2>
+  inline void operator()(T_arg1 _A_a1,T_arg2 _A_a2)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
+        (_A_a1,_A_a2);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2>
+  inline void sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
+        (_A_a1,_A_a2);
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2,class T_arg3>
+  inline void operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
+        (_A_a1,_A_a2,_A_a3);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3>
+  inline void sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
+        (_A_a1,_A_a2,_A_a3);
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  inline void operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
+  inline void sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4);
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  inline void operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
+  inline void sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  inline void operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
+  inline void sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
+    }
+  #endif
+
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  inline void operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
+    }
+
+  #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+  template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
+  inline void sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+    { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
+    }
+  #endif
+
+  retype_return_functor() {}
+  retype_return_functor(typename type_trait<T_functor>::take _A_functor)
+    : adapts<T_functor>(_A_functor)
+    {}
+};
+
+template <class T_functor>
+void retype_return_functor<void, T_functor>::operator()()
+  { this->functor_(); }
+
+
+/** Performs a functor on each of the targets of a functor.
+ * The function overload for sigc::retype_return_functor performs a functor on the
+ * functor stored in the sigc::retype_return_functor object.
+ *
+ * @ingroup retype
+ */
+template <class T_action, class T_return, class T_functor>
+void visit_each(const T_action& _A_action,
+                const retype_return_functor<T_return, T_functor>& _A_target)
+{
+  visit_each(_A_action, _A_target.functor_);
+}
+
+
+/** Creates an adaptor of type sigc::retype_return_functor which performs a C-style cast on the return value of the passed functor.
+ * The template argument @e T_return specifies the target type of the cast.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor performing a C-style casts on the return value.
+ *
+ * @ingroup retype
+ */
+template <class T_return, class T_functor>
+inline retype_return_functor<T_return, T_functor>
+retype_return(const T_functor& _A_functor)
+  { return retype_return_functor<T_return, T_functor>(_A_functor); }
+
+/** Creates an adaptor of type sigc::retype_return_functor which drops the return value of the passed functor.
+ *
+ * @param _A_functor Functor that should be wrapped.
+ * @return Adaptor that executes @e _A_functor dropping its return value.
+ *
+ * @ingroup hide
+ */
+template <class T_functor>
+inline retype_return_functor<void, T_functor>
+hide_return(const T_functor& _A_functor)
+  { return retype_return_functor<void, T_functor>(_A_functor); }
+
+} /* namespace sigc */
+#endif /* _SIGC_ADAPTORS_MACROS_RETYPE_RETURNHM4_ */