Index: trunk/src/lib/util/Makefile.am
===================================================================
--- trunk/src/lib/util/Makefile.am	(revision 9110)
+++ trunk/src/lib/util/Makefile.am	(revision 9406)
@@ -6,5 +6,4 @@
 libORXlibutil_a_SOURCES = \
 		substring.cc \
-		tokenizer.cc \
 		color.cc \
 		helper_functions.cc \
@@ -24,4 +23,5 @@
 		filesys/file.cc \
 		filesys/directory.cc \
+		filesys/net_link.cc \
 		\
 		preferences.cc \
@@ -32,5 +32,4 @@
 noinst_HEADERS = \
 		substring.h \
-		tokenizer.h \
 		multi_type.h \
 		color.h \
@@ -44,4 +43,5 @@
 		filesys/file.h \
 		filesys/directory.h \
+		filesys/net_link.h \
 		\
 		preferences.h \
Index: trunk/src/lib/util/executor/executor_functional.h
===================================================================
--- trunk/src/lib/util/executor/executor_functional.h	(revision 9110)
+++ trunk/src/lib/util/executor/executor_functional.h	(revision 9406)
@@ -179,5 +179,5 @@
   {
     (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
-      fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0)) );
+      (sub.size() > 0) ? fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0)) : (fromMulti<type0>(this->defaultValue[0])));
   };
 
@@ -222,6 +222,6 @@
   {
     (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
-      fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0)),
-      fromString<type1>(sub[1], getDefault<type1>(this->defaultValue, 1)));
+      (sub.size() > 0) ? fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0)) : (fromMulti<type0>(this->defaultValue[0])),
+      (sub.size() > 1) ? fromString<type1>(sub[1], getDefault<type1>(this->defaultValue, 1)) : (fromMulti<type1>(this->defaultValue[1])));
   };
 
@@ -276,7 +276,7 @@
   {
     (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
-      fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0)),
-      fromString<type1>(sub[1], getDefault<type1>(this->defaultValue, 1)),
-      fromString<type2>(sub[2], getDefault<type2>(this->defaultValue, 2)));
+      (sub.size() > 0) ? fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0)) : (fromMulti<type0>(this->defaultValue[0])),
+      (sub.size() > 1) ? fromString<type1>(sub[1], getDefault<type1>(this->defaultValue, 1)) : (fromMulti<type1>(this->defaultValue[1])),
+      (sub.size() > 2) ? fromString<type2>(sub[2], getDefault<type2>(this->defaultValue, 2)) : (fromMulti<type2>(this->defaultValue[2])));
   };
 
@@ -333,8 +333,8 @@
   {
     (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
-      fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0)),
-      fromString<type1>(sub[1], getDefault<type1>(this->defaultValue, 1)),
-      fromString<type2>(sub[2], getDefault<type2>(this->defaultValue, 2)),
-      fromString<type3>(sub[3], getDefault<type3>(this->defaultValue, 3)));
+      (sub.size() > 0) ? fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0)) : (fromMulti<type0>(this->defaultValue[0])),
+      (sub.size() > 1) ? fromString<type1>(sub[1], getDefault<type1>(this->defaultValue, 1)) : (fromMulti<type1>(this->defaultValue[1])),
+      (sub.size() > 2) ? fromString<type2>(sub[2], getDefault<type2>(this->defaultValue, 2)) : (fromMulti<type2>(this->defaultValue[2])),
+      (sub.size() > 3) ? fromString<type3>(sub[3], getDefault<type3>(this->defaultValue, 3)) : (fromMulti<type3>(this->defaultValue[3])));
   };
 
@@ -392,9 +392,9 @@
   {
     (__EXECUTOR_FUNCTIONAL_FUNCTION_EXEC)(
-      fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0)),
-      fromString<type1>(sub[1], getDefault<type1>(this->defaultValue, 1)),
-      fromString<type2>(sub[2], getDefault<type2>(this->defaultValue, 2)),
-      fromString<type3>(sub[3], getDefault<type3>(this->defaultValue, 3)),
-      fromString<type4>(sub[4], getDefault<type4>(this->defaultValue, 4)));
+      (sub.size() > 0) ? fromString<type0>(sub[0], getDefault<type0>(this->defaultValue, 0)) : (fromMulti<type0>(this->defaultValue[0])),
+      (sub.size() > 1) ? fromString<type1>(sub[1], getDefault<type1>(this->defaultValue, 1)) : (fromMulti<type1>(this->defaultValue[1])),
+      (sub.size() > 2) ? fromString<type2>(sub[2], getDefault<type2>(this->defaultValue, 2)) : (fromMulti<type2>(this->defaultValue[2])),
+      (sub.size() > 3) ? fromString<type3>(sub[3], getDefault<type3>(this->defaultValue, 3)) : (fromMulti<type3>(this->defaultValue[3])),
+      (sub.size() > 4) ? fromString<type4>(sub[4], getDefault<type4>(this->defaultValue, 4)) : (fromMulti<type4>(this->defaultValue[4])));
   };
 
Index: trunk/src/lib/util/executor/functor_list.h
===================================================================
--- trunk/src/lib/util/executor/functor_list.h	(revision 9110)
+++ trunk/src/lib/util/executor/functor_list.h	(revision 9406)
@@ -135,4 +135,5 @@
 
   //! mixed values:
+  FUNCTOR_LIST(2)(l_STRING, l_INT);
   FUNCTOR_LIST(2)(l_STRING, l_FLOAT);
   FUNCTOR_LIST(2)(l_UINT, l_LONG);
Index: trunk/src/lib/util/filesys/net_link.cc
===================================================================
--- trunk/src/lib/util/filesys/net_link.cc	(revision 9406)
+++ trunk/src/lib/util/filesys/net_link.cc	(revision 9406)
@@ -0,0 +1,83 @@
+/*
+   orxonox - the future of 3D-vertical-scrollers
+
+   Copyright (C) 2004 orx
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+### File Specific:
+   main-programmer: Benjamin Grauer
+   co-programmer: ...
+*/
+
+#include "net_link.h"
+#include "debug.h"
+
+
+#ifdef __OSX__
+#include <ApplicationServices/ApplicationServices.h>
+#elif defined __WIN32__
+//#include <shellapi.h>
+#endif
+
+
+NetLink::NetLink(const std::string& linkName)
+{
+  this->_link = linkName;
+}
+
+
+void NetLink::openInBrowser() const
+{
+  SDL_CreateThread(NetLink::openupInBrowser, (void*)&this->_link);
+}
+
+OrxThread::Mutex NetLink::_mutex;
+std::string NetLink::_defaultBrowser = "firefox";
+std::list<std::string> NetLink::_browserList = NetLink::buildBrowserList();
+
+
+
+
+int NetLink::openupInBrowser(void* url)
+{
+  OrxThread::MutexLock lock(&NetLink::_mutex);
+
+  std::string URL = *(std::string*)url;
+#ifdef __linux__
+  system ((std::string(NetLink::defaultBrowser()) + " " + URL).c_str());
+
+#elif defined __OSX__
+  CFURLRef url_handle = CFURLCreateWithBytes (NULL, (UInt8 *)URL.c_str(), URL.size(),
+                                              kCFStringEncodingASCII, NULL);
+  LSOpenCFURLRef (url_handle, NULL);
+  CFRelease (url_handle);
+
+#elif defined __WIN32__
+  /*  ShellExecute(GetActiveWindow(),
+               "open", URL.c_str(), NULL, NULL, SW_SHOWNORMAL);
+}*/
+#endif
+  PRINTF(3)("loaded external webpage %s\n", URL.c_str());
+
+  return 0;
+}
+
+void NetLink::setDefaultBrowser(const std::string& browserName)
+{
+  OrxThread::MutexLock lock(&NetLink::_mutex);
+  NetLink::_defaultBrowser = browserName;
+}
+
+std::list<std::string> NetLink::buildBrowserList()
+{
+  std::list<std::string> browserList;
+  browserList.push_back("firefox");
+  browserList.push_back("mozilla");
+  browserList.push_back("konqueror");
+
+  return  browserList;
+}
Index: trunk/src/lib/util/filesys/net_link.h
===================================================================
--- trunk/src/lib/util/filesys/net_link.h	(revision 9406)
+++ trunk/src/lib/util/filesys/net_link.h	(revision 9406)
@@ -0,0 +1,53 @@
+/*!
+ * @file net_link.h
+ * @brief Definition of a NetLink class
+ * NetLink is a File link to a page of file link to the Internet,
+ * or the local file-system
+ *
+ * Opening a link should be made easy through this class
+ *
+ * !! DANGER IT IS POSSIBLE TO EXECUTE ALL PROGRAMMS WITH USER'S RIGHTS
+ * !! ON THE DESIGNATED MACHINE
+ * !! THIS CLASS SHOULD BE USED WITH CAUTION WHEN USING OVER IN NETWORK
+ * !! MODE
+ */
+
+#ifndef __NET_LINK_H__
+#define __NET_LINK_H__
+
+#include <string>
+#include <list>
+
+#include "threading.h"
+
+//! NetLink is a File and Link executer for Internet Links
+/**
+ * @example: NetLink("http://www.orxonox.net").openInBrowser();
+ */
+class NetLink
+{
+public:
+  NetLink(const std::string& linkName);
+
+  void openInBrowser() const;
+
+  static void setDefaultBrowser(const std::string& browserName);
+  static const std::string& defaultBrowser() {  return NetLink::_defaultBrowser; };
+
+private:
+  static int openupInBrowser(void* url);
+
+  static std::list<std::string> buildBrowserList();
+
+
+private:
+  std::string                     _link;             //!< Linkname
+
+
+  // static lists.
+  static OrxThread::Mutex         _mutex;            //!< One mutex to lock them all.
+  static std::string              _defaultBrowser;   //!< The default Browser.
+  static std::list<std::string>   _browserList;
+};
+
+#endif /** __NET_LINK_H__ */
Index: trunk/src/lib/util/helper_functions.cc
===================================================================
--- trunk/src/lib/util/helper_functions.cc	(revision 9110)
+++ trunk/src/lib/util/helper_functions.cc	(revision 9406)
@@ -19,5 +19,5 @@
 #include "stdlibincl.h"
 
-using namespace std;
+
 
 /**
Index: trunk/src/lib/util/loading/dynamic_loader.cc
===================================================================
--- trunk/src/lib/util/loading/dynamic_loader.cc	(revision 9110)
+++ trunk/src/lib/util/loading/dynamic_loader.cc	(revision 9406)
@@ -23,5 +23,5 @@
 
 
-using namespace std;
+
 
 
Index: trunk/src/lib/util/loading/factory.cc
===================================================================
--- trunk/src/lib/util/loading/factory.cc	(revision 9110)
+++ trunk/src/lib/util/loading/factory.cc	(revision 9406)
@@ -19,5 +19,5 @@
 //#include "shell_command.h"
 
-using namespace std;
+
 
 //SHELL_COMMAND(create, Factory, fabricate);
@@ -117,5 +117,5 @@
   if (factory != Factory::factoryList->end())
   {
-    PRINTF(2)("Create a new Object of type %s\n", (*factory)->getName());
+    PRINTF(2)("Create a new Object of type %s\n", (*factory)->getCName());
     return (*factory)->fabricateObject(root);
   }
@@ -145,5 +145,5 @@
   if (factory != Factory::factoryList->end())
   {
-    PRINTF(4)("Create a new Object of type %s\n", (*factory)->getName());
+    PRINTF(4)("Create a new Object of type %s\n", (*factory)->getCName());
     return (*factory)->fabricateObject(NULL);
   }
@@ -173,5 +173,5 @@
   if (factory != Factory::factoryList->end())
   {
-    PRINTF(4)("Create a new Object of type %s\n", (*factory)->getName());
+    PRINTF(4)("Create a new Object of type %s\n", (*factory)->getCName());
     return (*factory)->fabricateObject(NULL);
   }
Index: trunk/src/lib/util/loading/load_param.cc
===================================================================
--- trunk/src/lib/util/loading/load_param.cc	(revision 9110)
+++ trunk/src/lib/util/loading/load_param.cc	(revision 9406)
@@ -65,5 +65,5 @@
           ((this->executor->getType() & Executor_NoLoadString) == Executor_NoLoadString)))
     {
-      PRINTF(4)("Loading value '%s' with Parameters '%s' onto: %s::%s\n", this->paramName.c_str(), loadString.c_str(), this->object->getClassName(), this->object->getName());
+      PRINTF(4)("Loading value '%s' with Parameters '%s' onto: %s::%s\n", this->paramName.c_str(), loadString.c_str(), this->object->getClassCName(), this->object->getCName());
       (*this->executor)(this->object, SubString(loadString, ",", SubString::WhiteSpaces, false, '\\'));
     }
@@ -164,5 +164,5 @@
 {
     // locating the class
-    this->classDesc = LoadClassDescription::addClass(object->getClassName());
+    this->classDesc = LoadClassDescription::addClass(object->getClassCName());
 
     if ((this->paramDesc = this->classDesc->addParam(paramName)) != NULL)
Index: trunk/src/lib/util/loading/resource.cc
===================================================================
--- trunk/src/lib/util/loading/resource.cc	(revision 9110)
+++ trunk/src/lib/util/loading/resource.cc	(revision 9406)
@@ -18,5 +18,5 @@
 #include "resource.h"
 
-using namespace std;
+
 
 
Index: trunk/src/lib/util/loading/resource_manager.cc
===================================================================
--- trunk/src/lib/util/loading/resource_manager.cc	(revision 9110)
+++ trunk/src/lib/util/loading/resource_manager.cc	(revision 9406)
@@ -50,5 +50,5 @@
 #include <unistd.h>
 
-using namespace std;
+
 
 /**
Index: trunk/src/lib/util/multi_type.cc
===================================================================
--- trunk/src/lib/util/multi_type.cc	(revision 9110)
+++ trunk/src/lib/util/multi_type.cc	(revision 9406)
@@ -18,9 +18,4 @@
 #include "multi_type.h"
 
-//#include "stdincl.h"
-#include <stddef.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
 #include <sstream>
 
@@ -28,6 +23,4 @@
 #include "debug.h"
 #endif
-
-using namespace std;
 
 /**
Index: trunk/src/lib/util/sigslot/signal.h
===================================================================
--- trunk/src/lib/util/sigslot/signal.h	(revision 9406)
+++ trunk/src/lib/util/sigslot/signal.h	(revision 9406)
@@ -0,0 +1,2220 @@
+/**
+ * @file signal.h
+ * @adaption from the beautiful sigslot implementation of sarah Thompson
+ */
+
+// sigslot.h: Signal/Slot classes
+//
+// Written by Sarah Thompson (sarah@telergy.com) 2002.
+//
+// License: Public domain. You are free to use this code however you like, with the proviso that
+//          the author takes on no responsibility or liability for any use.
+//
+// QUICK DOCUMENTATION
+//
+//        (see also the full documentation at http://sigslot.sourceforge.net/)
+//
+// #define switches
+//     SIGSLOT_PURE_ISO                   - Define this to force ISO C++ compliance. This also disables
+//                                         all of the thread safety support on platforms where it is
+//                                         available.
+//
+//     SIGSLOT_USE_POSIX_THREADS          - Force use of Posix threads when using a C++ compiler other than
+//                                          gcc on a platform that supports Posix threads. (When using gcc,
+//                                          this is the default - use SIGSLOT_PURE_ISO to disable this if
+//                                          necessary)
+//
+//     SIGSLOT_DEFAULT_MT_POLICY          - Where thread support is enabled, this defaults to multi_threaded_global.
+//                                          Otherwise, the default is single_threaded. #define this yourself to
+//                                          override the default. In pure ISO mode, anything other than
+//                                          single_threaded will cause a compiler error.
+//
+// PLATFORM NOTES
+//
+//     Win32                              - On Win32, the WIN32 symbol must be #defined. Most mainstream
+//                                          compilers do this by default, but you may need to define it
+//                                          yourself if your build environment is less standard. This causes
+//                                          the Win32 thread support to be compiled in and used automatically.
+//
+//     Unix/Linux/BSD, etc.                - If you're using gcc, it is assumed that you have Posix threads
+//                                          available, so they are used automatically. You can override this
+//                                          (as under Windows) with the SIGSLOT_PURE_ISO switch. If you're using
+//                                          something other than gcc but still want to use Posix threads, you
+//                                          need to #define SIGSLOT_USE_POSIX_THREADS.
+//
+//     ISO C++                            - If none of the supported platforms are detected, or if
+//                                          SIGSLOT_PURE_ISO is defined, all multithreading support is turned off,
+//                                          along with any code that might cause a pure ISO C++ environment to
+//                                          complain. Before you ask, gcc -ansi -pedantic won't compile this
+//                                          library, but gcc -ansi is fine. Pedantic mode seems to throw a lot of
+//                                          errors that aren't really there. If you feel like investigating this,
+//                                          please contact the author.
+//
+//
+// THREADING MODES
+//
+//     single_threaded                    - Your program is assumed to be single threaded from the point of view
+//                                          of signal/slot usage (i.e. all objects using signals and slots are
+//                                          created and destroyed from a single thread). Behaviour if objects are
+//                                          destroyed concurrently is undefined (i.e. you'll get the occasional
+//                                          segmentation fault/memory exception).
+//
+//     multi_threaded_global              - Your program is assumed to be multi threaded. Objects using signals and
+//                                          slots can be safely created and destroyed from any thread, even when
+//                                          connections exist. In multi_threaded_global mode, this is achieved by a
+//                                          single global mutex (actually a critical section on Windows because they
+//                                          are faster). This option uses less OS resources, but results in more
+//                                          opportunities for contention, possibly resulting in more context switches
+//                                          than are strictly necessary.
+//
+//     multi_threaded_local               - Behaviour in this mode is essentially the same as multi_threaded_global,
+//                                          except that each signal, and each object that inherits has_slots, all
+//                                          have their own mutex/critical section. In practice, this means that
+//                                          mutex collisions (and hence context switches) only happen if they are
+//                                          absolutely essential. However, on some platforms, creating a lot of
+//                                          mutexes can slow down the whole OS, so use this option with care.
+//
+// USING THE LIBRARY
+//
+//        See the full documentation at http://sigslot.sourceforge.net/
+//
+//
+
+#ifndef SIGNAL_H__
+#define SIGNAL_H__
+
+#include <set>
+#include <list>
+
+#include "slot.h"
+
+
+namespace sigslot
+{
+  template<class mt_policy>
+  class _connection_base0
+  {
+  public:
+    virtual has_slots<mt_policy>* getdest() const = 0;
+    virtual void emit() = 0;
+    virtual _connection_base0* clone() = 0;
+    virtual _connection_base0* duplicate(has_slots<mt_policy>* pnewdest) = 0;
+  };
+
+  template<class arg1_type, class mt_policy>
+  class _connection_base1
+  {
+  public:
+    virtual has_slots<mt_policy>* getdest() const = 0;
+    virtual void emit(arg1_type) = 0;
+    virtual _connection_base1<arg1_type, mt_policy>* clone() = 0;
+    virtual _connection_base1<arg1_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
+  };
+
+  template<class arg1_type, class arg2_type, class mt_policy>
+  class _connection_base2
+  {
+  public:
+    virtual has_slots<mt_policy>* getdest() const = 0;
+    virtual void emit(arg1_type, arg2_type) = 0;
+    virtual _connection_base2<arg1_type, arg2_type, mt_policy>* clone() = 0;
+    virtual _connection_base2<arg1_type, arg2_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
+  };
+
+  template<class arg1_type, class arg2_type, class arg3_type, class mt_policy>
+  class _connection_base3
+  {
+  public:
+    virtual has_slots<mt_policy>* getdest() const = 0;
+    virtual void emit(arg1_type, arg2_type, arg3_type) = 0;
+    virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>* clone() = 0;
+    virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
+  };
+
+  template<class arg1_type, class arg2_type, class arg3_type, class arg4_type, class mt_policy>
+  class _connection_base4
+  {
+  public:
+    virtual has_slots<mt_policy>* getdest() const = 0;
+    virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type) = 0;
+    virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>* clone() = 0;
+    virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
+  };
+
+  template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
+  class arg5_type, class mt_policy>
+  class _connection_base5
+  {
+  public:
+    virtual has_slots<mt_policy>* getdest() const = 0;
+    virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type,
+                      arg5_type) = 0;
+    virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type,
+    arg5_type, mt_policy>* clone() = 0;
+    virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type,
+    arg5_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
+  };
+
+  template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
+  class arg5_type, class arg6_type, class mt_policy>
+  class _connection_base6
+  {
+  public:
+    virtual has_slots<mt_policy>* getdest() const = 0;
+    virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type,
+                      arg6_type) = 0;
+    virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type,
+    arg5_type, arg6_type, mt_policy>* clone() = 0;
+    virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type,
+    arg5_type, arg6_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
+  };
+
+  template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
+  class arg5_type, class arg6_type, class arg7_type, class mt_policy>
+  class _connection_base7
+  {
+  public:
+    virtual has_slots<mt_policy>* getdest() const = 0;
+    virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type,
+                      arg6_type, arg7_type) = 0;
+    virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type,
+    arg5_type, arg6_type, arg7_type, mt_policy>* clone() = 0;
+    virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type,
+    arg5_type, arg6_type, arg7_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
+  };
+
+  template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
+  class arg5_type, class arg6_type, class arg7_type, class arg8_type, class mt_policy>
+  class _connection_base8
+  {
+  public:
+    virtual has_slots<mt_policy>* getdest() const = 0;
+    virtual void emit(arg1_type, arg2_type, arg3_type, arg4_type, arg5_type,
+                      arg6_type, arg7_type, arg8_type) = 0;
+    virtual _connection_base8<arg1_type, arg2_type, arg3_type, arg4_type,
+    arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* clone() = 0;
+    virtual _connection_base8<arg1_type, arg2_type, arg3_type, arg4_type,
+    arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest) = 0;
+  };
+
+  template<class mt_policy>
+  class _signal_base0 : public _signal_base<mt_policy>
+  {
+  public:
+    typedef std::list<_connection_base0<mt_policy> *>  connections_list;
+
+    _signal_base0()
+    {
+      ;
+    }
+
+    _signal_base0(const _signal_base0& s)
+        : _signal_base<mt_policy>(s)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::const_iterator it = s.m_connected_slots.begin();
+      typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        (*it)->getdest()->signal_connect(this);
+        m_connected_slots.push_back((*it)->clone());
+
+        ++it;
+      }
+    }
+
+    ~_signal_base0()
+    {
+      disconnect_all();
+    }
+
+    void disconnect_all()
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::const_iterator it = m_connected_slots.begin();
+      typename connections_list::const_iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        (*it)->getdest()->signal_disconnect(this);
+        delete *it;
+
+        ++it;
+      }
+
+      m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
+    }
+
+    void disconnect(has_slots<mt_policy>* pclass)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        if((*it)->getdest() == pclass)
+        {
+          delete *it;
+          m_connected_slots.erase(it);
+          pclass->signal_disconnect(this);
+          return;
+        }
+
+        ++it;
+      }
+    }
+
+    void slot_disconnect(has_slots<mt_policy>* pslot)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        typename connections_list::iterator itNext = it;
+        ++itNext;
+
+        if((*it)->getdest() == pslot)
+        {
+          m_connected_slots.erase(it);
+          //                        delete *it;
+        }
+
+        it = itNext;
+      }
+    }
+
+    void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        if((*it)->getdest() == oldtarget)
+        {
+          m_connected_slots.push_back((*it)->duplicate(newtarget));
+        }
+
+        ++it;
+      }
+    }
+
+  protected:
+    connections_list m_connected_slots;
+  };
+
+  template<class arg1_type, class mt_policy>
+  class _signal_base1 : public _signal_base<mt_policy>
+  {
+  public:
+    typedef std::list<_connection_base1<arg1_type, mt_policy> *>  connections_list;
+
+    _signal_base1()
+    {
+      ;
+    }
+
+    _signal_base1(const _signal_base1<arg1_type, mt_policy>& s)
+        : _signal_base<mt_policy>(s)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::const_iterator it = s.m_connected_slots.begin();
+      typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        (*it)->getdest()->signal_connect(this);
+        m_connected_slots.push_back((*it)->clone());
+
+        ++it;
+      }
+    }
+
+    void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        if((*it)->getdest() == oldtarget)
+        {
+          m_connected_slots.push_back((*it)->duplicate(newtarget));
+        }
+
+        ++it;
+      }
+    }
+
+    ~_signal_base1()
+    {
+      disconnect_all();
+    }
+
+    void disconnect_all()
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::const_iterator it = m_connected_slots.begin();
+      typename connections_list::const_iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        (*it)->getdest()->signal_disconnect(this);
+        delete *it;
+
+        ++it;
+      }
+
+      m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
+    }
+
+    void disconnect(has_slots<mt_policy>* pclass)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        if((*it)->getdest() == pclass)
+        {
+          delete *it;
+          m_connected_slots.erase(it);
+          pclass->signal_disconnect(this);
+          return;
+        }
+
+        ++it;
+      }
+    }
+
+    void slot_disconnect(has_slots<mt_policy>* pslot)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        typename connections_list::iterator itNext = it;
+        ++itNext;
+
+        if((*it)->getdest() == pslot)
+        {
+          m_connected_slots.erase(it);
+          //                        delete *it;
+        }
+
+        it = itNext;
+      }
+    }
+
+
+  protected:
+    connections_list m_connected_slots;
+  };
+
+  template<class arg1_type, class arg2_type, class mt_policy>
+  class _signal_base2 : public _signal_base<mt_policy>
+  {
+  public:
+    typedef std::list<_connection_base2<arg1_type, arg2_type, mt_policy> *>
+    connections_list;
+
+    _signal_base2()
+    {
+      ;
+    }
+
+    _signal_base2(const _signal_base2<arg1_type, arg2_type, mt_policy>& s)
+        : _signal_base<mt_policy>(s)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::const_iterator it = s.m_connected_slots.begin();
+      typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        (*it)->getdest()->signal_connect(this);
+        m_connected_slots.push_back((*it)->clone());
+
+        ++it;
+      }
+    }
+
+    void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        if((*it)->getdest() == oldtarget)
+        {
+          m_connected_slots.push_back((*it)->duplicate(newtarget));
+        }
+
+        ++it;
+      }
+    }
+
+    ~_signal_base2()
+    {
+      disconnect_all();
+    }
+
+    void disconnect_all()
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::const_iterator it = m_connected_slots.begin();
+      typename connections_list::const_iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        (*it)->getdest()->signal_disconnect(this);
+        delete *it;
+
+        ++it;
+      }
+
+      m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
+    }
+
+    void disconnect(has_slots<mt_policy>* pclass)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        if((*it)->getdest() == pclass)
+        {
+          delete *it;
+          m_connected_slots.erase(it);
+          pclass->signal_disconnect(this);
+          return;
+        }
+
+        ++it;
+      }
+    }
+
+    void slot_disconnect(has_slots<mt_policy>* pslot)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        typename connections_list::iterator itNext = it;
+        ++itNext;
+
+        if((*it)->getdest() == pslot)
+        {
+          m_connected_slots.erase(it);
+          //                        delete *it;
+        }
+
+        it = itNext;
+      }
+    }
+
+  protected:
+    connections_list m_connected_slots;
+  };
+
+  template<class arg1_type, class arg2_type, class arg3_type, class mt_policy>
+  class _signal_base3 : public _signal_base<mt_policy>
+  {
+  public:
+    typedef std::list<_connection_base3<arg1_type, arg2_type, arg3_type, mt_policy> *>
+    connections_list;
+
+    _signal_base3()
+    {
+      ;
+    }
+
+    _signal_base3(const _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>& s)
+        : _signal_base<mt_policy>(s)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::const_iterator it = s.m_connected_slots.begin();
+      typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        (*it)->getdest()->signal_connect(this);
+        m_connected_slots.push_back((*it)->clone());
+
+        ++it;
+      }
+    }
+
+    void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        if((*it)->getdest() == oldtarget)
+        {
+          m_connected_slots.push_back((*it)->duplicate(newtarget));
+        }
+
+        ++it;
+      }
+    }
+
+    ~_signal_base3()
+    {
+      disconnect_all();
+    }
+
+    void disconnect_all()
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::const_iterator it = m_connected_slots.begin();
+      typename connections_list::const_iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        (*it)->getdest()->signal_disconnect(this);
+        delete *it;
+
+        ++it;
+      }
+
+      m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
+    }
+
+    void disconnect(has_slots<mt_policy>* pclass)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        if((*it)->getdest() == pclass)
+        {
+          delete *it;
+          m_connected_slots.erase(it);
+          pclass->signal_disconnect(this);
+          return;
+        }
+
+        ++it;
+      }
+    }
+
+    void slot_disconnect(has_slots<mt_policy>* pslot)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        typename connections_list::iterator itNext = it;
+        ++itNext;
+
+        if((*it)->getdest() == pslot)
+        {
+          m_connected_slots.erase(it);
+          //                        delete *it;
+        }
+
+        it = itNext;
+      }
+    }
+
+  protected:
+    connections_list m_connected_slots;
+  };
+
+  template<class arg1_type, class arg2_type, class arg3_type, class arg4_type, class mt_policy>
+  class _signal_base4 : public _signal_base<mt_policy>
+  {
+  public:
+    typedef std::list<_connection_base4<arg1_type, arg2_type, arg3_type,
+    arg4_type, mt_policy> *>  connections_list;
+
+    _signal_base4()
+    {
+      ;
+    }
+
+    _signal_base4(const _signal_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>& s)
+        : _signal_base<mt_policy>(s)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::const_iterator it = s.m_connected_slots.begin();
+      typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        (*it)->getdest()->signal_connect(this);
+        m_connected_slots.push_back((*it)->clone());
+
+        ++it;
+      }
+    }
+
+    void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        if((*it)->getdest() == oldtarget)
+        {
+          m_connected_slots.push_back((*it)->duplicate(newtarget));
+        }
+
+        ++it;
+      }
+    }
+
+    ~_signal_base4()
+    {
+      disconnect_all();
+    }
+
+    void disconnect_all()
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::const_iterator it = m_connected_slots.begin();
+      typename connections_list::const_iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        (*it)->getdest()->signal_disconnect(this);
+        delete *it;
+
+        ++it;
+      }
+
+      m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
+    }
+
+    void disconnect(has_slots<mt_policy>* pclass)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        if((*it)->getdest() == pclass)
+        {
+          delete *it;
+          m_connected_slots.erase(it);
+          pclass->signal_disconnect(this);
+          return;
+        }
+
+        ++it;
+      }
+    }
+
+    void slot_disconnect(has_slots<mt_policy>* pslot)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        typename connections_list::iterator itNext = it;
+        ++itNext;
+
+        if((*it)->getdest() == pslot)
+        {
+          m_connected_slots.erase(it);
+          //                        delete *it;
+        }
+
+        it = itNext;
+      }
+    }
+
+  protected:
+    connections_list m_connected_slots;
+  };
+
+  template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
+  class arg5_type, class mt_policy>
+  class _signal_base5 : public _signal_base<mt_policy>
+  {
+  public:
+    typedef std::list<_connection_base5<arg1_type, arg2_type, arg3_type,
+    arg4_type, arg5_type, mt_policy> *>  connections_list;
+
+    _signal_base5()
+    {
+      ;
+    }
+
+    _signal_base5(const _signal_base5<arg1_type, arg2_type, arg3_type, arg4_type,
+                  arg5_type, mt_policy>& s)
+        : _signal_base<mt_policy>(s)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::const_iterator it = s.m_connected_slots.begin();
+      typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        (*it)->getdest()->signal_connect(this);
+        m_connected_slots.push_back((*it)->clone());
+
+        ++it;
+      }
+    }
+
+    void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        if((*it)->getdest() == oldtarget)
+        {
+          m_connected_slots.push_back((*it)->duplicate(newtarget));
+        }
+
+        ++it;
+      }
+    }
+
+    ~_signal_base5()
+    {
+      disconnect_all();
+    }
+
+    void disconnect_all()
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::const_iterator it = m_connected_slots.begin();
+      typename connections_list::const_iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        (*it)->getdest()->signal_disconnect(this);
+        delete *it;
+
+        ++it;
+      }
+
+      m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
+    }
+
+    void disconnect(has_slots<mt_policy>* pclass)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        if((*it)->getdest() == pclass)
+        {
+          delete *it;
+          m_connected_slots.erase(it);
+          pclass->signal_disconnect(this);
+          return;
+        }
+
+        ++it;
+      }
+    }
+
+    void slot_disconnect(has_slots<mt_policy>* pslot)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        typename connections_list::iterator itNext = it;
+        ++itNext;
+
+        if((*it)->getdest() == pslot)
+        {
+          m_connected_slots.erase(it);
+          //                        delete *it;
+        }
+
+        it = itNext;
+      }
+    }
+
+  protected:
+    connections_list m_connected_slots;
+  };
+
+  template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
+  class arg5_type, class arg6_type, class mt_policy>
+  class _signal_base6 : public _signal_base<mt_policy>
+  {
+  public:
+    typedef std::list<_connection_base6<arg1_type, arg2_type, arg3_type,
+    arg4_type, arg5_type, arg6_type, mt_policy> *>  connections_list;
+
+    _signal_base6()
+    {
+      ;
+    }
+
+    _signal_base6(const _signal_base6<arg1_type, arg2_type, arg3_type, arg4_type,
+                  arg5_type, arg6_type, mt_policy>& s)
+        : _signal_base<mt_policy>(s)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::const_iterator it = s.m_connected_slots.begin();
+      typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        (*it)->getdest()->signal_connect(this);
+        m_connected_slots.push_back((*it)->clone());
+
+        ++it;
+      }
+    }
+
+    void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        if((*it)->getdest() == oldtarget)
+        {
+          m_connected_slots.push_back((*it)->duplicate(newtarget));
+        }
+
+        ++it;
+      }
+    }
+
+    ~_signal_base6()
+    {
+      disconnect_all();
+    }
+
+    void disconnect_all()
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::const_iterator it = m_connected_slots.begin();
+      typename connections_list::const_iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        (*it)->getdest()->signal_disconnect(this);
+        delete *it;
+
+        ++it;
+      }
+
+      m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
+    }
+
+    void disconnect(has_slots<mt_policy>* pclass)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        if((*it)->getdest() == pclass)
+        {
+          delete *it;
+          m_connected_slots.erase(it);
+          pclass->signal_disconnect(this);
+          return;
+        }
+
+        ++it;
+      }
+    }
+
+    void slot_disconnect(has_slots<mt_policy>* pslot)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        typename connections_list::iterator itNext = it;
+        ++itNext;
+
+        if((*it)->getdest() == pslot)
+        {
+          m_connected_slots.erase(it);
+          //                        delete *it;
+        }
+
+        it = itNext;
+      }
+    }
+
+  protected:
+    connections_list m_connected_slots;
+  };
+
+  template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
+  class arg5_type, class arg6_type, class arg7_type, class mt_policy>
+  class _signal_base7 : public _signal_base<mt_policy>
+  {
+  public:
+    typedef std::list<_connection_base7<arg1_type, arg2_type, arg3_type,
+    arg4_type, arg5_type, arg6_type, arg7_type, mt_policy> *>  connections_list;
+
+    _signal_base7()
+    {
+      ;
+    }
+
+    _signal_base7(const _signal_base7<arg1_type, arg2_type, arg3_type, arg4_type,
+                  arg5_type, arg6_type, arg7_type, mt_policy>& s)
+        : _signal_base<mt_policy>(s)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::const_iterator it = s.m_connected_slots.begin();
+      typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        (*it)->getdest()->signal_connect(this);
+        m_connected_slots.push_back((*it)->clone());
+
+        ++it;
+      }
+    }
+
+    void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        if((*it)->getdest() == oldtarget)
+        {
+          m_connected_slots.push_back((*it)->duplicate(newtarget));
+        }
+
+        ++it;
+      }
+    }
+
+    ~_signal_base7()
+    {
+      disconnect_all();
+    }
+
+    void disconnect_all()
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::const_iterator it = m_connected_slots.begin();
+      typename connections_list::const_iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        (*it)->getdest()->signal_disconnect(this);
+        delete *it;
+
+        ++it;
+      }
+
+      m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
+    }
+
+    void disconnect(has_slots<mt_policy>* pclass)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        if((*it)->getdest() == pclass)
+        {
+          delete *it;
+          m_connected_slots.erase(it);
+          pclass->signal_disconnect(this);
+          return;
+        }
+
+        ++it;
+      }
+    }
+
+    void slot_disconnect(has_slots<mt_policy>* pslot)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        typename connections_list::iterator itNext = it;
+        ++itNext;
+
+        if((*it)->getdest() == pslot)
+        {
+          m_connected_slots.erase(it);
+          //                        delete *it;
+        }
+
+        it = itNext;
+      }
+    }
+
+  protected:
+    connections_list m_connected_slots;
+  };
+
+  template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
+  class arg5_type, class arg6_type, class arg7_type, class arg8_type, class mt_policy>
+  class _signal_base8 : public _signal_base<mt_policy>
+  {
+  public:
+    typedef std::list<_connection_base8<arg1_type, arg2_type, arg3_type,
+    arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy> *>
+    connections_list;
+
+    _signal_base8()
+    {
+      ;
+    }
+
+    _signal_base8(const _signal_base8<arg1_type, arg2_type, arg3_type, arg4_type,
+                  arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>& s)
+        : _signal_base<mt_policy>(s)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::const_iterator it = s.m_connected_slots.begin();
+      typename connections_list::const_iterator itEnd = s.m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        (*it)->getdest()->signal_connect(this);
+        m_connected_slots.push_back((*it)->clone());
+
+        ++it;
+      }
+    }
+
+    void slot_duplicate(const has_slots<mt_policy>* oldtarget, has_slots<mt_policy>* newtarget)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        if((*it)->getdest() == oldtarget)
+        {
+          m_connected_slots.push_back((*it)->duplicate(newtarget));
+        }
+
+        ++it;
+      }
+    }
+
+    ~_signal_base8()
+    {
+      disconnect_all();
+    }
+
+    void disconnect_all()
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::const_iterator it = m_connected_slots.begin();
+      typename connections_list::const_iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        (*it)->getdest()->signal_disconnect(this);
+        delete *it;
+
+        ++it;
+      }
+
+      m_connected_slots.erase(m_connected_slots.begin(), m_connected_slots.end());
+    }
+
+    void disconnect(has_slots<mt_policy>* pclass)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        if((*it)->getdest() == pclass)
+        {
+          delete *it;
+          m_connected_slots.erase(it);
+          pclass->signal_disconnect(this);
+          return;
+        }
+
+        ++it;
+      }
+    }
+
+    void slot_disconnect(has_slots<mt_policy>* pslot)
+    {
+      lock_block<mt_policy> lock(this);
+      typename connections_list::iterator it = m_connected_slots.begin();
+      typename connections_list::iterator itEnd = m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        typename connections_list::iterator itNext = it;
+        ++itNext;
+
+        if((*it)->getdest() == pslot)
+        {
+          m_connected_slots.erase(it);
+          //                        delete *it;
+        }
+
+        it = itNext;
+      }
+    }
+
+  protected:
+    connections_list m_connected_slots;
+  };
+
+
+  template<class dest_type, class mt_policy>
+  class _connection0 : public _connection_base0<mt_policy>
+  {
+  public:
+    _connection0()
+    {
+      m_pobject = NULL;
+      m_pmemfun = NULL;
+    }
+
+    _connection0(dest_type* pobject, void (dest_type::*pmemfun)())
+    {
+      m_pobject = pobject;
+      m_pmemfun = pmemfun;
+    }
+
+    virtual _connection_base0<mt_policy>* clone()
+    {
+      return new _connection0<dest_type, mt_policy>(*this);
+    }
+
+    virtual _connection_base0<mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
+    {
+      return new _connection0<dest_type, mt_policy>(dynamic_cast<dest_type*>(pnewdest), m_pmemfun);
+    }
+
+    virtual void emit()
+    {
+      (m_pobject->*m_pmemfun)();
+    }
+
+    virtual has_slots<mt_policy>* getdest() const
+    {
+      return m_pobject;
+    }
+
+  private:
+    dest_type* m_pobject;
+    void (dest_type::* m_pmemfun)();
+  };
+
+  template<class dest_type, class arg1_type, class mt_policy>
+  class _connection1 : public _connection_base1<arg1_type, mt_policy>
+  {
+  public:
+    _connection1()
+    {
+      m_pobject = NULL;
+      m_pmemfun = NULL;
+    }
+
+    _connection1(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type))
+    {
+      m_pobject = pobject;
+      m_pmemfun = pmemfun;
+    }
+
+    virtual _connection_base1<arg1_type, mt_policy>* clone()
+    {
+      return new _connection1<dest_type, arg1_type, mt_policy>(*this);
+    }
+
+    virtual _connection_base1<arg1_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
+    {
+      return new _connection1<dest_type, arg1_type, mt_policy>(dynamic_cast<dest_type*>(pnewdest), m_pmemfun);
+    }
+
+    virtual void emit(arg1_type a1)
+    {
+      (m_pobject->*m_pmemfun)(a1);
+    }
+
+    virtual has_slots<mt_policy>* getdest() const
+    {
+      return m_pobject;
+    }
+
+  private:
+    dest_type* m_pobject;
+    void (dest_type::* m_pmemfun)(arg1_type);
+  };
+
+  template<class dest_type, class arg1_type, class arg2_type, class mt_policy>
+  class _connection2 : public _connection_base2<arg1_type, arg2_type, mt_policy>
+  {
+  public:
+    _connection2()
+    {
+      m_pobject = NULL;
+      m_pmemfun = NULL;
+    }
+
+    _connection2(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
+                 arg2_type))
+    {
+      m_pobject = pobject;
+      m_pmemfun = pmemfun;
+    }
+
+    virtual _connection_base2<arg1_type, arg2_type, mt_policy>* clone()
+    {
+      return new _connection2<dest_type, arg1_type, arg2_type, mt_policy>(*this);
+    }
+
+    virtual _connection_base2<arg1_type, arg2_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
+    {
+      return new _connection2<dest_type, arg1_type, arg2_type, mt_policy>(dynamic_cast<dest_type*>(pnewdest), m_pmemfun);
+    }
+
+    virtual void emit(arg1_type a1, arg2_type a2)
+    {
+      (m_pobject->*m_pmemfun)(a1, a2);
+    }
+
+    virtual has_slots<mt_policy>* getdest() const
+    {
+      return m_pobject;
+    }
+
+  private:
+    dest_type* m_pobject;
+    void (dest_type::* m_pmemfun)(arg1_type, arg2_type);
+  };
+
+  template<class dest_type, class arg1_type, class arg2_type, class arg3_type, class mt_policy>
+  class _connection3 : public _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>
+  {
+  public:
+    _connection3()
+    {
+      m_pobject = NULL;
+      m_pmemfun = NULL;
+    }
+
+    _connection3(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
+                 arg2_type, arg3_type))
+    {
+      m_pobject = pobject;
+      m_pmemfun = pmemfun;
+    }
+
+    virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>* clone()
+    {
+      return new _connection3<dest_type, arg1_type, arg2_type, arg3_type, mt_policy>(*this);
+    }
+
+    virtual _connection_base3<arg1_type, arg2_type, arg3_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
+    {
+      return new _connection3<dest_type, arg1_type, arg2_type, arg3_type, mt_policy>(dynamic_cast<dest_type*>(pnewdest), m_pmemfun);
+    }
+
+    virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3)
+    {
+      (m_pobject->*m_pmemfun)(a1, a2, a3);
+    }
+
+    virtual has_slots<mt_policy>* getdest() const
+    {
+      return m_pobject;
+    }
+
+  private:
+    dest_type* m_pobject;
+    void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type);
+  };
+
+  template<class dest_type, class arg1_type, class arg2_type, class arg3_type,
+  class arg4_type, class mt_policy>
+  class _connection4 : public _connection_base4<arg1_type, arg2_type,
+        arg3_type, arg4_type, mt_policy>
+  {
+  public:
+    _connection4()
+    {
+      m_pobject = NULL;
+      m_pmemfun = NULL;
+    }
+
+    _connection4(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
+                 arg2_type, arg3_type, arg4_type))
+    {
+      m_pobject = pobject;
+      m_pmemfun = pmemfun;
+    }
+
+    virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>* clone()
+    {
+      return new _connection4<dest_type, arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>(*this);
+    }
+
+    virtual _connection_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
+    {
+      return new _connection4<dest_type, arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>(dynamic_cast<dest_type*>(pnewdest), m_pmemfun);
+    }
+
+    virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3,
+                      arg4_type a4)
+    {
+      (m_pobject->*m_pmemfun)(a1, a2, a3, a4);
+    }
+
+    virtual has_slots<mt_policy>* getdest() const
+    {
+      return m_pobject;
+    }
+
+  private:
+    dest_type* m_pobject;
+    void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type,
+                                  arg4_type);
+  };
+
+  template<class dest_type, class arg1_type, class arg2_type, class arg3_type,
+  class arg4_type, class arg5_type, class mt_policy>
+  class _connection5 : public _connection_base5<arg1_type, arg2_type,
+        arg3_type, arg4_type, arg5_type, mt_policy>
+  {
+  public:
+    _connection5()
+    {
+      m_pobject = NULL;
+      m_pmemfun = NULL;
+    }
+
+    _connection5(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
+                 arg2_type, arg3_type, arg4_type, arg5_type))
+    {
+      m_pobject = pobject;
+      m_pmemfun = pmemfun;
+    }
+
+    virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type,
+    arg5_type, mt_policy>* clone()
+    {
+      return new _connection5<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
+             arg5_type, mt_policy>(*this);
+    }
+
+    virtual _connection_base5<arg1_type, arg2_type, arg3_type, arg4_type,
+    arg5_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
+    {
+      return new _connection5<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
+      arg5_type, mt_policy>(dynamic_cast<dest_type*>(pnewdest), m_pmemfun);
+    }
+
+    virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
+                      arg5_type a5)
+    {
+      (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5);
+    }
+
+    virtual has_slots<mt_policy>* getdest() const
+    {
+      return m_pobject;
+    }
+
+  private:
+    dest_type* m_pobject;
+    void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type,
+                                  arg5_type);
+  };
+
+  template<class dest_type, class arg1_type, class arg2_type, class arg3_type,
+  class arg4_type, class arg5_type, class arg6_type, class mt_policy>
+  class _connection6 : public _connection_base6<arg1_type, arg2_type,
+        arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>
+  {
+  public:
+    _connection6()
+    {
+      m_pobject = NULL;
+      m_pmemfun = NULL;
+    }
+
+    _connection6(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
+                 arg2_type, arg3_type, arg4_type, arg5_type, arg6_type))
+    {
+      m_pobject = pobject;
+      m_pmemfun = pmemfun;
+    }
+
+    virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type,
+    arg5_type, arg6_type, mt_policy>* clone()
+    {
+      return new _connection6<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
+             arg5_type, arg6_type, mt_policy>(*this);
+    }
+
+    virtual _connection_base6<arg1_type, arg2_type, arg3_type, arg4_type,
+    arg5_type, arg6_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
+    {
+      return new _connection6<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
+      arg5_type, arg6_type, mt_policy>(dynamic_cast<dest_type*>(pnewdest), m_pmemfun);
+    }
+
+    virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
+                      arg5_type a5, arg6_type a6)
+    {
+      (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5, a6);
+    }
+
+    virtual has_slots<mt_policy>* getdest() const
+    {
+      return m_pobject;
+    }
+
+  private:
+    dest_type* m_pobject;
+    void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type,
+                                  arg5_type, arg6_type);
+  };
+
+  template<class dest_type, class arg1_type, class arg2_type, class arg3_type,
+  class arg4_type, class arg5_type, class arg6_type, class arg7_type, class mt_policy>
+  class _connection7 : public _connection_base7<arg1_type, arg2_type,
+        arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>
+  {
+  public:
+    _connection7()
+    {
+      m_pobject = NULL;
+      m_pmemfun = NULL;
+    }
+
+    _connection7(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
+                 arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type))
+    {
+      m_pobject = pobject;
+      m_pmemfun = pmemfun;
+    }
+
+    virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type,
+    arg5_type, arg6_type, arg7_type, mt_policy>* clone()
+    {
+      return new _connection7<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
+             arg5_type, arg6_type, arg7_type, mt_policy>(*this);
+    }
+
+    virtual _connection_base7<arg1_type, arg2_type, arg3_type, arg4_type,
+    arg5_type, arg6_type, arg7_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
+    {
+      return new _connection7<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
+      arg5_type, arg6_type, arg7_type, mt_policy>(dynamic_cast<dest_type*>(pnewdest), m_pmemfun);
+    }
+
+    virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
+                      arg5_type a5, arg6_type a6, arg7_type a7)
+    {
+      (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5, a6, a7);
+    }
+
+    virtual has_slots<mt_policy>* getdest() const
+    {
+      return m_pobject;
+    }
+
+  private:
+    dest_type* m_pobject;
+    void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type,
+                                  arg5_type, arg6_type, arg7_type);
+  };
+
+  template<class dest_type, class arg1_type, class arg2_type, class arg3_type,
+  class arg4_type, class arg5_type, class arg6_type, class arg7_type,
+  class arg8_type, class mt_policy>
+  class _connection8 : public _connection_base8<arg1_type, arg2_type,
+        arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>
+  {
+  public:
+    _connection8()
+    {
+      m_pobject = NULL;
+      m_pmemfun = NULL;
+    }
+
+    _connection8(dest_type* pobject, void (dest_type::*pmemfun)(arg1_type,
+                 arg2_type, arg3_type, arg4_type, arg5_type, arg6_type,
+                 arg7_type, arg8_type))
+    {
+      m_pobject = pobject;
+      m_pmemfun = pmemfun;
+    }
+
+    virtual _connection_base8<arg1_type, arg2_type, arg3_type, arg4_type,
+    arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* clone()
+    {
+      return new _connection8<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
+             arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>(*this);
+    }
+
+    virtual _connection_base8<arg1_type, arg2_type, arg3_type, arg4_type,
+    arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* duplicate(has_slots<mt_policy>* pnewdest)
+    {
+      return new _connection8<dest_type, arg1_type, arg2_type, arg3_type, arg4_type,
+      arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>(dynamic_cast<dest_type*>(pnewdest), m_pmemfun);
+    }
+
+    virtual void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
+                      arg5_type a5, arg6_type a6, arg7_type a7, arg8_type a8)
+    {
+      (m_pobject->*m_pmemfun)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    virtual has_slots<mt_policy>* getdest() const
+    {
+      return m_pobject;
+    }
+
+  private:
+    dest_type* m_pobject;
+    void (dest_type::* m_pmemfun)(arg1_type, arg2_type, arg3_type, arg4_type,
+                                  arg5_type, arg6_type, arg7_type, arg8_type);
+  };
+
+  template<class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+  class signal0 : public _signal_base0<mt_policy>
+  {
+  public:
+    signal0()
+    {
+      ;
+    }
+
+    signal0(const signal0<mt_policy>& s)
+        : _signal_base0<mt_policy>(s)
+    {
+      ;
+    }
+
+    template<class desttype>
+    void connect(desttype* pclass, void (desttype::*pmemfun)())
+    {
+      lock_block<mt_policy> lock(this);
+      _connection0<desttype, mt_policy>* conn =
+        new _connection0<desttype, mt_policy>(pclass, pmemfun);
+      this->m_connected_slots.push_back(conn);
+      pclass->signal_connect(this);
+    }
+
+    void emit()
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base0<mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base0<mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit();
+
+        it = itNext;
+      }
+    }
+
+    void operator()()
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base0<mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base0<mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit();
+
+        it = itNext;
+      }
+    }
+  };
+
+  template<class arg1_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+  class signal1 : public _signal_base1<arg1_type, mt_policy>
+  {
+  public:
+    signal1()
+    {
+      ;
+    }
+
+    signal1(const signal1<arg1_type, mt_policy>& s)
+        : _signal_base1<arg1_type, mt_policy>(s)
+    {
+      ;
+    }
+
+    template<class desttype>
+    void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type))
+    {
+      lock_block<mt_policy> lock(this);
+      _connection1<desttype, arg1_type, mt_policy>* conn =
+        new _connection1<desttype, arg1_type, mt_policy>(pclass, pmemfun);
+      this->m_connected_slots.push_back(conn);
+      pclass->signal_connect(this);
+    }
+
+    void emit(arg1_type a1)
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base1<arg1_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base1<arg1_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1);
+
+        it = itNext;
+      }
+    }
+
+    void operator()(arg1_type a1)
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base1<arg1_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base1<arg1_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1);
+
+        it = itNext;
+      }
+    }
+  };
+
+  template<class arg1_type, class arg2_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+  class signal2 : public _signal_base2<arg1_type, arg2_type, mt_policy>
+  {
+  public:
+    signal2()
+    {
+      ;
+    }
+
+    signal2(const signal2<arg1_type, arg2_type, mt_policy>& s)
+        : _signal_base2<arg1_type, arg2_type, mt_policy>(s)
+    {
+      ;
+    }
+
+    template<class desttype>
+    void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
+                 arg2_type))
+    {
+      lock_block<mt_policy> lock(this);
+      _connection2<desttype, arg1_type, arg2_type, mt_policy>* conn = new
+          _connection2<desttype, arg1_type, arg2_type, mt_policy>(pclass, pmemfun);
+      this->m_connected_slots.push_back(conn);
+      pclass->signal_connect(this);
+    }
+
+    void emit(arg1_type a1, arg2_type a2)
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base2<arg1_type, arg2_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base2<arg1_type, arg2_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2);
+
+        it = itNext;
+      }
+    }
+
+    void operator()(arg1_type a1, arg2_type a2)
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base2<arg1_type, arg2_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base2<arg1_type, arg2_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2);
+
+        it = itNext;
+      }
+    }
+  };
+
+  template<class arg1_type, class arg2_type, class arg3_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+  class signal3 : public _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>
+  {
+  public:
+    signal3()
+    {
+      ;
+    }
+
+    signal3(const signal3<arg1_type, arg2_type, arg3_type, mt_policy>& s)
+        : _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>(s)
+    {
+      ;
+    }
+
+    template<class desttype>
+    void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
+                 arg2_type, arg3_type))
+    {
+      lock_block<mt_policy> lock(this);
+      _connection3<desttype, arg1_type, arg2_type, arg3_type, mt_policy>* conn =
+        new _connection3<desttype, arg1_type, arg2_type, arg3_type, mt_policy>(pclass,
+            pmemfun);
+      this->m_connected_slots.push_back(conn);
+      pclass->signal_connect(this);
+    }
+
+    void emit(arg1_type a1, arg2_type a2, arg3_type a3)
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2, a3);
+
+        it = itNext;
+      }
+    }
+
+    void operator()(arg1_type a1, arg2_type a2, arg3_type a3)
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base3<arg1_type, arg2_type, arg3_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2, a3);
+
+        it = itNext;
+      }
+    }
+  };
+
+  template<class arg1_type, class arg2_type, class arg3_type, class arg4_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+  class signal4 : public _signal_base4<arg1_type, arg2_type, arg3_type,
+        arg4_type, mt_policy>
+  {
+  public:
+    signal4()
+    {
+      ;
+    }
+
+    signal4(const signal4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>& s)
+        : _signal_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>(s)
+    {
+      ;
+    }
+
+    template<class desttype>
+    void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
+                 arg2_type, arg3_type, arg4_type))
+    {
+      lock_block<mt_policy> lock(this);
+      _connection4<desttype, arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>*
+      conn = new _connection4<desttype, arg1_type, arg2_type, arg3_type,
+             arg4_type, mt_policy>(pclass, pmemfun);
+      this->m_connected_slots.push_back(conn);
+      pclass->signal_connect(this);
+    }
+
+    void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4)
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2, a3, a4);
+
+        it = itNext;
+      }
+    }
+
+    void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4)
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base4<arg1_type, arg2_type, arg3_type, arg4_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2, a3, a4);
+
+        it = itNext;
+      }
+    }
+  };
+
+  template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
+  class arg5_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+  class signal5 : public _signal_base5<arg1_type, arg2_type, arg3_type,
+        arg4_type, arg5_type, mt_policy>
+  {
+  public:
+    signal5()
+    {
+      ;
+    }
+
+    signal5(const signal5<arg1_type, arg2_type, arg3_type, arg4_type,
+            arg5_type, mt_policy>& s)
+        : _signal_base5<arg1_type, arg2_type, arg3_type, arg4_type,
+        arg5_type, mt_policy>(s)
+    {
+      ;
+    }
+
+    template<class desttype>
+    void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
+                 arg2_type, arg3_type, arg4_type, arg5_type))
+    {
+      lock_block<mt_policy> lock(this);
+      _connection5<desttype, arg1_type, arg2_type, arg3_type, arg4_type,
+      arg5_type, mt_policy>* conn = new _connection5<desttype, arg1_type, arg2_type,
+                                    arg3_type, arg4_type, arg5_type, mt_policy>(pclass, pmemfun);
+      this->m_connected_slots.push_back(conn);
+      pclass->signal_connect(this);
+    }
+
+    void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
+              arg5_type a5)
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2, a3, a4, a5);
+
+        it = itNext;
+      }
+    }
+
+    void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
+                    arg5_type a5)
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base5<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2, a3, a4, a5);
+
+        it = itNext;
+      }
+    }
+  };
+
+
+  template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
+  class arg5_type, class arg6_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+  class signal6 : public _signal_base6<arg1_type, arg2_type, arg3_type,
+        arg4_type, arg5_type, arg6_type, mt_policy>
+  {
+  public:
+    signal6()
+    {
+      ;
+    }
+
+    signal6(const signal6<arg1_type, arg2_type, arg3_type, arg4_type,
+            arg5_type, arg6_type, mt_policy>& s)
+        : _signal_base6<arg1_type, arg2_type, arg3_type, arg4_type,
+        arg5_type, arg6_type, mt_policy>(s)
+    {
+      ;
+    }
+
+    template<class desttype>
+    void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
+                 arg2_type, arg3_type, arg4_type, arg5_type, arg6_type))
+    {
+      lock_block<mt_policy> lock(this);
+      _connection6<desttype, arg1_type, arg2_type, arg3_type, arg4_type,
+      arg5_type, arg6_type, mt_policy>* conn =
+        new _connection6<desttype, arg1_type, arg2_type, arg3_type,
+        arg4_type, arg5_type, arg6_type, mt_policy>(pclass, pmemfun);
+      this->m_connected_slots.push_back(conn);
+      pclass->signal_connect(this);
+    }
+
+    void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
+              arg5_type a5, arg6_type a6)
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2, a3, a4, a5, a6);
+
+        it = itNext;
+      }
+    }
+
+    void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
+                    arg5_type a5, arg6_type a6)
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base6<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2, a3, a4, a5, a6);
+
+        it = itNext;
+      }
+    }
+  };
+
+  template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
+  class arg5_type, class arg6_type, class arg7_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+  class signal7 : public _signal_base7<arg1_type, arg2_type, arg3_type,
+        arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>
+  {
+  public:
+    signal7()
+    {
+      ;
+    }
+
+    signal7(const signal7<arg1_type, arg2_type, arg3_type, arg4_type,
+            arg5_type, arg6_type, arg7_type, mt_policy>& s)
+        : _signal_base7<arg1_type, arg2_type, arg3_type, arg4_type,
+        arg5_type, arg6_type, arg7_type, mt_policy>(s)
+    {
+      ;
+    }
+
+    template<class desttype>
+    void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
+                 arg2_type, arg3_type, arg4_type, arg5_type, arg6_type,
+                 arg7_type))
+    {
+      lock_block<mt_policy> lock(this);
+      _connection7<desttype, arg1_type, arg2_type, arg3_type, arg4_type,
+      arg5_type, arg6_type, arg7_type, mt_policy>* conn =
+        new _connection7<desttype, arg1_type, arg2_type, arg3_type,
+        arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>(pclass, pmemfun);
+      this->m_connected_slots.push_back(conn);
+      pclass->signal_connect(this);
+    }
+
+    void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
+              arg5_type a5, arg6_type a6, arg7_type a7)
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2, a3, a4, a5, a6, a7);
+
+        it = itNext;
+      }
+    }
+
+    void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
+                    arg5_type a5, arg6_type a6, arg7_type a7)
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base7<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2, a3, a4, a5, a6, a7);
+
+        it = itNext;
+      }
+    }
+  };
+
+  template<class arg1_type, class arg2_type, class arg3_type, class arg4_type,
+  class arg5_type, class arg6_type, class arg7_type, class arg8_type, class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+  class signal8 : public _signal_base8<arg1_type, arg2_type, arg3_type,
+        arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>
+  {
+  public:
+    signal8()
+    {
+      ;
+    }
+
+    signal8(const signal8<arg1_type, arg2_type, arg3_type, arg4_type,
+            arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>& s)
+        : _signal_base8<arg1_type, arg2_type, arg3_type, arg4_type,
+        arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>(s)
+    {
+      ;
+    }
+
+    template<class desttype>
+    void connect(desttype* pclass, void (desttype::*pmemfun)(arg1_type,
+                 arg2_type, arg3_type, arg4_type, arg5_type, arg6_type,
+                 arg7_type, arg8_type))
+    {
+      lock_block<mt_policy> lock(this);
+      _connection8<desttype, arg1_type, arg2_type, arg3_type, arg4_type,
+      arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>* conn =
+        new _connection8<desttype, arg1_type, arg2_type, arg3_type,
+        arg4_type, arg5_type, arg6_type, arg7_type,
+        arg8_type, mt_policy>(pclass, pmemfun);
+      this->m_connected_slots.push_back(conn);
+      pclass->signal_connect(this);
+    }
+
+    void emit(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
+              arg5_type a5, arg6_type a6, arg7_type a7, arg8_type a8)
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base8<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base8<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2, a3, a4, a5, a6, a7, a8);
+
+        it = itNext;
+      }
+    }
+
+    void operator()(arg1_type a1, arg2_type a2, arg3_type a3, arg4_type a4,
+                    arg5_type a5, arg6_type a6, arg7_type a7, arg8_type a8)
+    {
+      lock_block<mt_policy> lock(this);
+      typename _signal_base8<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>::connections_list::const_iterator itNext, it = this->m_connected_slots.begin();
+      typename _signal_base8<arg1_type, arg2_type, arg3_type, arg4_type, arg5_type, arg6_type, arg7_type, arg8_type, mt_policy>::connections_list::const_iterator itEnd = this->m_connected_slots.end();
+
+      while(it != itEnd)
+      {
+        itNext = it;
+        ++itNext;
+
+        (*it)->emit(a1, a2, a3, a4, a5, a6, a7, a8);
+
+        it = itNext;
+      }
+    }
+  };
+
+}
+; // namespace sigslot
+
+#endif /* SIGNAL_H__ */
+
Index: trunk/src/lib/util/sigslot/slot.h
===================================================================
--- trunk/src/lib/util/sigslot/slot.h	(revision 9406)
+++ trunk/src/lib/util/sigslot/slot.h	(revision 9406)
@@ -0,0 +1,307 @@
+/**
+ * @file slot.h
+ * @brief Slots part of Signal Slot library from Sarah Thopson
+ * @see signal.h for more information and license.
+ */
+
+#ifndef SLOT_H__
+#define SLOT_H__
+
+#include <set>
+#include <list>
+
+
+#if defined(SIGSLOT_PURE_ISO) || (!defined(WIN32) && !defined(__GNUG__) && !defined(SIGSLOT_USE_POSIX_THREADS))
+#	define _SIGSLOT_SINGLE_THREADED
+#elif defined(WIN32)
+#	define _SIGSLOT_HAS_WIN32_THREADS
+#	include <windows.h>
+#elif defined(__GNUG__) || defined(SIGSLOT_USE_POSIX_THREADS)
+#	define _SIGSLOT_HAS_POSIX_THREADS
+#	include <pthread.h>
+#else
+#	define _SIGSLOT_SINGLE_THREADED
+#endif
+
+#ifndef SIGSLOT_DEFAULT_MT_POLICY
+#	ifdef _SIGSLOT_SINGLE_THREADED
+#		define SIGSLOT_DEFAULT_MT_POLICY single_threaded
+#	else
+#		define SIGSLOT_DEFAULT_MT_POLICY multi_threaded_local
+#	endif
+#endif
+
+namespace sigslot
+{
+
+  class single_threaded
+  {
+    public:
+      single_threaded()
+      {
+        ;
+      }
+
+      virtual ~single_threaded()
+      {
+        ;
+      }
+
+      virtual void lock()
+      {
+        ;
+      }
+
+      virtual void unlock()
+      {
+        ;
+      }
+  };
+
+#ifdef _SIGSLOT_HAS_WIN32_THREADS
+  // The multi threading policies only get compiled in if they are enabled.
+  class multi_threaded_global
+  {
+    public:
+      multi_threaded_global()
+      {
+        static bool isinitialised = false;
+
+        if(!isinitialised)
+        {
+          InitializeCriticalSection(get_critsec());
+          isinitialised = true;
+        }
+      }
+
+      multi_threaded_global(const multi_threaded_global&)
+      {
+        ;
+      }
+
+      virtual ~multi_threaded_global()
+      {
+        ;
+      }
+
+      virtual void lock()
+      {
+        EnterCriticalSection(get_critsec());
+      }
+
+      virtual void unlock()
+      {
+        LeaveCriticalSection(get_critsec());
+      }
+
+    private:
+      CRITICAL_SECTION* get_critsec()
+      {
+        static CRITICAL_SECTION g_critsec;
+        return &g_critsec;
+      }
+  };
+
+  class multi_threaded_local
+  {
+    public:
+      multi_threaded_local()
+      {
+        InitializeCriticalSection(&m_critsec);
+      }
+
+      multi_threaded_local(const multi_threaded_local&)
+      {
+        InitializeCriticalSection(&m_critsec);
+      }
+
+      virtual ~multi_threaded_local()
+      {
+        DeleteCriticalSection(&m_critsec);
+      }
+
+      virtual void lock()
+      {
+        EnterCriticalSection(&m_critsec);
+      }
+
+      virtual void unlock()
+      {
+        LeaveCriticalSection(&m_critsec);
+      }
+
+    private:
+      CRITICAL_SECTION m_critsec;
+  };
+#endif // _SIGSLOT_HAS_WIN32_THREADS
+
+#ifdef _SIGSLOT_HAS_POSIX_THREADS
+  // The multi threading policies only get compiled in if they are enabled.
+  class multi_threaded_global
+  {
+    public:
+      multi_threaded_global()
+      {
+        pthread_mutex_init(get_mutex(), NULL);
+      }
+
+      multi_threaded_global(const multi_threaded_global&)
+      {
+        ;
+      }
+
+      virtual ~multi_threaded_global()
+      {
+        ;
+      }
+
+      virtual void lock()
+      {
+        pthread_mutex_lock(get_mutex());
+      }
+
+      virtual void unlock()
+      {
+        pthread_mutex_unlock(get_mutex());
+      }
+
+    private:
+      pthread_mutex_t* get_mutex()
+      {
+        static pthread_mutex_t g_mutex;
+        return &g_mutex;
+      }
+  };
+
+  class multi_threaded_local
+  {
+    public:
+      multi_threaded_local()
+      {
+        pthread_mutex_init(&m_mutex, NULL);
+      }
+
+      multi_threaded_local(const multi_threaded_local&)
+      {
+        pthread_mutex_init(&m_mutex, NULL);
+      }
+
+      virtual ~multi_threaded_local()
+      {
+        pthread_mutex_destroy(&m_mutex);
+      }
+
+      virtual void lock()
+      {
+        pthread_mutex_lock(&m_mutex);
+      }
+
+      virtual void unlock()
+      {
+        pthread_mutex_unlock(&m_mutex);
+      }
+
+    private:
+      pthread_mutex_t m_mutex;
+  };
+#endif // _SIGSLOT_HAS_POSIX_THREADS
+
+  template<class mt_policy>
+  class lock_block
+  {
+    public:
+      mt_policy *m_mutex;
+
+      lock_block(mt_policy *mtx)
+          : m_mutex(mtx)
+      {
+        m_mutex->lock();
+      }
+
+      ~lock_block()
+      {
+        m_mutex->unlock();
+      }
+  };
+
+
+
+
+  template<class mt_policy>
+  class has_slots;
+
+
+  template<class mt_policy>
+  class _signal_base : public mt_policy
+  {
+    public:
+      virtual void slot_disconnect(has_slots<mt_policy>* pslot) = 0;
+      virtual void slot_duplicate(const has_slots<mt_policy>* poldslot, has_slots<mt_policy>* pnewslot) = 0;
+  };
+
+  template<class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+  class has_slots //: public mt_policy
+  {
+    private:
+      typedef std::set<_signal_base<mt_policy> *> sender_set;
+      typedef typename sender_set::const_iterator const_iterator;
+
+    public:
+      has_slots()
+      {
+        ;
+      }
+
+      has_slots(const has_slots& hs)
+//          : mt_policy(hs)
+      {
+        //lock_block<mt_policy> lock(this);
+        const_iterator it = hs.m_senders.begin();
+        const_iterator itEnd = hs.m_senders.end();
+
+        while(it != itEnd)
+        {
+          (*it)->slot_duplicate(&hs, this);
+          m_senders.insert(*it);
+          ++it;
+        }
+      }
+
+      void signal_connect(_signal_base<mt_policy>* sender)
+      {
+        //lock_block<mt_policy> lock(this);
+        m_senders.insert(sender);
+      }
+
+      void signal_disconnect(_signal_base<mt_policy>* sender)
+      {
+        //lock_block<mt_policy> lock(this);
+        m_senders.erase(sender);
+      }
+
+      virtual ~has_slots()
+      {
+        disconnect_all();
+      }
+
+      void disconnect_all()
+      {
+        //lock_block<mt_policy> lock(this);
+        const_iterator it = m_senders.begin();
+        const_iterator itEnd = m_senders.end();
+
+        while(it != itEnd)
+        {
+          (*it)->slot_disconnect(this);
+          ++it;
+        }
+
+        m_senders.erase(m_senders.begin(), m_senders.end());
+      }
+
+    private:
+      sender_set m_senders;
+  };
+}
+
+#endif /* SLOT_H__ */
Index: trunk/src/lib/util/substring.cc
===================================================================
--- trunk/src/lib/util/substring.cc	(revision 9110)
+++ trunk/src/lib/util/substring.cc	(revision 9406)
@@ -28,8 +28,4 @@
 #include "substring.h"
 
-#include <string.h>
-#include <cassert>
-
-
 /**
  * @brief default constructor
@@ -108,5 +104,5 @@
 
 /** @brief An empty String */
-const std::string SubString::emptyString = "";
+// const std::string SubString::emptyString = "";
 /** @brief Helper that gets you a String consisting of all White Spaces */
 const std::string SubString::WhiteSpaces = " \n\t";
@@ -238,5 +234,8 @@
   }
   else
-    return SubString::emptyString;
+  {
+    static std::string empty;
+    return empty;
+  }
 }
 
@@ -250,5 +249,5 @@
  * SubString::SubString(const SubString& subString, unsigned int subSetBegin)
  */
-SubString SubString::getSubSet(unsigned int subSetBegin) const
+SubString SubString::subSet(unsigned int subSetBegin) const
 {
   return SubString(*this, subSetBegin);
@@ -265,5 +264,5 @@
  * SubString::SubString(const SubString& subString, unsigned int subSetBegin)
  */
-SubString SubString::getSubSet(unsigned int subSetBegin, unsigned int subSetEnd) const
+SubString SubString::subSet(unsigned int subSetBegin, unsigned int subSetEnd) const
 {
   return SubString(*this, subSetBegin, subSetEnd);
@@ -289,6 +288,4 @@
  * Supports delimiters, escape characters,
  * ignores special  characters between safemode_char and between comment_char and linend '\n'.
- *
- *
  */
 SubString::SPLIT_LINE_STATE
Index: trunk/src/lib/util/substring.h
===================================================================
--- trunk/src/lib/util/substring.h	(revision 9110)
+++ trunk/src/lib/util/substring.h	(revision 9406)
@@ -2,8 +2,22 @@
  * @file substring.h
  * @brief a small class to get the parts of a string separated by commas
+ *
+ * This class is also identified as a Tokenizer. It splits up one long
+ * String into multiple small ones by a designated Delimiter.
+ *
+ * Substring is Advanced, and it is possible, to split a string by ','
+ * but also removing leading and trailing spaces around the comma.
+ *
+ * @example
+ * Split the String std::string st = "1345, The new empire   , is , orxonox"
+ * is splitted with:
+ * SubString(st, ',', " \n\t")
+ * into
+ * "1345", "The new empire", "is", "orxonox"
+ * As you can see, the useless spaces around ',' were removed.
  */
 
-#ifndef _SUBSTRING_H
-#define _SUBSTRING_H
+#ifndef __SUBSTRING_H__
+#define __SUBSTRING_H__
 
 #include <vector>
@@ -61,6 +75,6 @@
 
   // retrieve a SubSet from the String
-  SubString getSubSet(unsigned int subSetBegin) const;
-  SubString getSubSet(unsigned int subSetBegin, unsigned int subSetEnd) const;
+  SubString subSet(unsigned int subSetBegin) const;
+  SubString subSet(unsigned int subSetBegin, unsigned int subSetEnd) const;
 
   // retrieve Information from within
@@ -70,7 +84,13 @@
   inline unsigned int size() const { return this->strings.size(); };
   /** @param i the i'th String @returns the i'th string from the subset of Strings */
-  inline const std::string& operator[](unsigned int i) const { return (i < this->strings.size()) ? this->strings[i] : emptyString; };
+  inline const std::string& operator[](unsigned int i) const { return this->strings[i]; };
   /** @param i the i'th String @returns the i'th string from the subset of Strings */
   inline const std::string& getString(unsigned int i) const { return (*this)[i]; };
+  /** @returns the front of the StringList. */
+  inline const std::string& front() const { return this->strings.front(); };
+  /** @returns the back of the StringList. */
+  inline const std::string& back() const { return this->strings.back(); };
+  /** @brief removes the back of the strings list. */
+  inline void pop_back() { this->strings.pop_back(); };
 
   // the almighty algorithm.
@@ -93,7 +113,5 @@
 private:
   std::vector<std::string>  strings;                      //!< strings produced from a single string splitted in multiple strings
-
-  static const std::string emptyString;
 };
 
-#endif /* _SUBSTRING_H */
+#endif /* __SUBSTRING_H__ */
Index: trunk/src/lib/util/threading.cc
===================================================================
--- trunk/src/lib/util/threading.cc	(revision 9110)
+++ trunk/src/lib/util/threading.cc	(revision 9406)
@@ -18,5 +18,5 @@
 #include "threading.h"
 
-using namespace std;
+
 
 namespace OrxThread
Index: trunk/src/lib/util/tokenizer.cc
===================================================================
--- trunk/src/lib/util/tokenizer.cc	(revision 9110)
+++ 	(revision )
@@ -1,29 +1,0 @@
-/**
- * @file tokenizer.cc
- * @brief a tokenizer class
- *
- */
-
-#include "tokenizer.h"
-
-
-/**
- * tokenize a string
- */
-void Tokenizer::tokenize(const std::string& str, std::vector<std::string>& tokens, const std::string& delimiters)
-{
-    // Skip delimiters at beginning.
-  std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
-    // Find first "non-delimiter".
-  std::string::size_type pos     = str.find_first_of(delimiters, lastPos);
-
-  while (std::string::npos != pos || std::string::npos != lastPos)
-  {
-        // Found a token, add it to the vector.
-    tokens.push_back(str.substr(lastPos, pos - lastPos));
-        // Skip delimiters.  Note the "not_of"
-    lastPos = str.find_first_not_of(delimiters, pos);
-        // Find next "non-delimiter"
-    pos = str.find_first_of(delimiters, lastPos);
-  }
-}
Index: trunk/src/lib/util/tokenizer.h
===================================================================
--- trunk/src/lib/util/tokenizer.h	(revision 9110)
+++ 	(revision )
@@ -1,26 +1,0 @@
-
-/*!
- * @file tokenzier.h
- * @brief Definition of Tokenizer
- *
- */
-
-#ifndef _TOKENIZER_H
-#define _TOKENIZER_H
-
-
-#include <vector>
-#include <string>
-
-
-//! A class to handle time itself
-class Tokenizer
-{
-
-  public:
-    static void tokenize(const std::string& str, std::vector<std::string>& tokens, const std::string& delimiters = " ");
-
-
-};
-
-#endif /* _TOKENIZER_H */
