Index: trunk/src/lib/graphics/text_engine/text_engine.cc
===================================================================
--- trunk/src/lib/graphics/text_engine/text_engine.cc	(revision 5778)
+++ trunk/src/lib/graphics/text_engine/text_engine.cc	(revision 5779)
@@ -64,31 +64,23 @@
 {
   // first remove all the remaining Texts (if any).
-  tList<BaseObject>* textList = ClassList::getList(CL_TEXT);
+  std::list<BaseObject*>* textList = ClassList::getList(CL_TEXT);
   if (textList != NULL)
   {
-    tIterator<BaseObject>* textIterator = textList->getIterator();
-    Text* text = dynamic_cast<Text*>(textIterator->firstElement());
-    while( text != NULL)
+    while(textList->size() > 0)
     {
-      delete text;
-      text = dynamic_cast<Text*>(textIterator->nextElement());
+      delete dynamic_cast<Text*>(textList->front());
     }
-    delete textIterator;
   }
   // delete all remaining fonts (There should not be Anything to do here)
-  tList<BaseObject>* fontList = ClassList::getList(CL_FONT);
+  std::list<BaseObject*>* fontList = ClassList::getList(CL_FONT);
   if (fontList != NULL)
   {
-    tIterator<BaseObject>* fontIterator = fontList->getIterator();
-    Font* font = dynamic_cast<Font*>(fontIterator->firstElement());
-    while( font != NULL)
+//    while (fontList->size() > 0)
     {
+      Font* font = dynamic_cast<Font*>(fontList->front());
       if (likely(font != Font::getDefaultFont()))
         ResourceManager::getInstance()->unload(font, RP_GAME);
-      font = dynamic_cast<Font*>(fontIterator->nextElement());
     }
-    delete fontIterator;
   }
-
   this->disableFonts();
 
@@ -133,5 +125,5 @@
 void TextEngine::debug() const
 {
-  tList<BaseObject>* textList = ClassList::getList(CL_TEXT);
+  list<BaseObject*>* textList = ClassList::getList(CL_TEXT);
   if (textList != NULL)
   {
@@ -139,14 +131,9 @@
     PRINT(0)("+ TEXT ENGINE DEBUG INFORMATION +\n");
     PRINT(0)("+-------------------------------+\n");
-    PRINT(0)("Reference: %p; Text Counts: %d\n", this, textList->getSize());
+    PRINT(0)("Reference: %p; Text Counts: %d\n", this, textList->size());
 
-    tIterator<BaseObject>* textIterator = textList->getIterator();
-    Text* text = dynamic_cast<Text*>(textIterator->firstElement());
-    while( text != NULL)
-      {
-        text->debug();
-        text = dynamic_cast<Text*>(textIterator->nextElement());
-      }
-    delete textIterator;
+    list<BaseObject*>::iterator text;
+    for ( text = textList->begin(); text != textList->end(); text++)
+      dynamic_cast<Text*>(*text)->debug();
     PRINT(0)("+---------------------------TE--+\n");
   }
Index: trunk/src/lib/lang/class_list.cc
===================================================================
--- trunk/src/lib/lang/class_list.cc	(revision 5778)
+++ trunk/src/lib/lang/class_list.cc	(revision 5779)
@@ -40,5 +40,4 @@
   this->className = className;
   this->classID = classID;
-  this->objectList = new tList<BaseObject>;
 
   ++ClassList::classCount;
@@ -50,10 +49,10 @@
 ClassList::~ClassList ()
 {
-  delete this->objectList;
-  if(ClassList::classList != NULL)
-  {
-    delete ClassList::classList;
-    ClassList::classList = NULL;
-  }
+  /// FIXME
+//   if(ClassList::classList != NULL)
+//   {
+//     delete ClassList::classList;
+//     ClassList::classList = NULL;
+//   }
   --ClassList::classCount;
 }
@@ -66,5 +65,5 @@
 
 //! a List of all strings of all classes, that have registered so far.
-tList<const char>* ClassList::classList = NULL;
+std::list<const char*> ClassList::classList;
 
 /**
@@ -100,5 +99,5 @@
     }
   }
-  regClass->objectList->add(objectPointer);
+  regClass->objectList.push_back(objectPointer);
 }
 
@@ -114,5 +113,5 @@
     if (objectPointer->isA(tmp->classID))
     {
-      tmp->objectList->remove(objectPointer);
+      tmp->objectList.remove(objectPointer);
     }
     tmp = tmp->next;
@@ -127,13 +126,8 @@
  * befor it changes anything.
  */
-const tList<const char>* ClassList::getClassList()
-{
-  if (unlikely(ClassList::classList != NULL && ClassList::classList->getSize() != ClassList::classCount))
-  {
-    delete ClassList::classList;
-    ClassList::classList = NULL;
-  }
-  if (unlikely(ClassList::classList == NULL))
-    ClassList::classList = new tList<const char>;
+const std::list<const char*>* ClassList::getClassList()
+{
+  if (ClassList::classList.size() != ClassList::classCount)
+    ClassList::classList.erase(ClassList::classList.begin(), ClassList::classList.end());
 
   if(likely(ClassList::first != NULL))
@@ -142,9 +136,9 @@
     while (likely(tmpCL != NULL))
     {
-      ClassList::classList->add(tmpCL->className);
-      tmpCL = tmpCL->next;
-    }
-  }
-  return ClassList::classList;
+      ClassList::classList.push_back(tmpCL->className);
+      tmpCL = tmpCL->next;
+    }
+  }
+  return &ClassList::classList;
 }
 
@@ -154,5 +148,5 @@
  * @return the List accessed by classID, or NULL if not found
  */
-tList<BaseObject>* ClassList::getList(long classID)
+std::list<BaseObject*>* ClassList::getList(long classID)
 {
   if(unlikely(ClassList::first == NULL))
@@ -164,5 +158,5 @@
     {
       if (unlikely(tmpCL->classID == classID))
-        return tmpCL->objectList;
+        return &tmpCL->objectList;
       tmpCL = tmpCL->next;
     }
@@ -175,5 +169,6 @@
  * @param className the name of the class to get the list from
  * @return the List accessed by classID, or NULL if not found
- */tList<BaseObject>* ClassList::getList(const char* className)
+ */
+std::list<BaseObject*>* ClassList::getList(const char* className)
 {
   if(unlikely(ClassList::first == NULL))
@@ -185,5 +180,5 @@
     {
       if (unlikely(!strcmp(tmpCL->className, className)))
-        return tmpCL->objectList;
+        return &tmpCL->objectList;
       tmpCL = tmpCL->next;
     }
@@ -210,18 +205,8 @@
       if (tmp->classID == classID || classID == CL_NULL)
       {
-        tIterator<BaseObject>* iterator = tmp->objectList->getIterator();
-        BaseObject* enumBO = iterator->firstElement();
-        const char* tmpName;
-        while (enumBO != NULL)
-        {
-          tmpName = enumBO->getName();
-          if (tmpName && !strcmp(tmpName, name))
-          {
-            delete iterator;
-            return enumBO;
-          }
-          enumBO = iterator->nextElement();
-        }
-        delete iterator;
+        list<BaseObject*>::iterator bo;
+        for (bo = tmp->objectList.begin(); bo != tmp->objectList.end(); bo++)
+          if ((*bo)->getName() && !strcmp((*bo)->getName(), name))
+            return (*bo);
         break;
       }
@@ -251,20 +236,10 @@
       if (tmp->classID == classID || classID == CL_NULL)
       {
-        tIterator<BaseObject>* iterator = tmp->objectList->getIterator();
-        const BaseObject* enumBO = iterator->firstElement();
-        while (enumBO != NULL)
-        {
-          if (enumBO == object)
-          {
-            delete iterator;
+        list<BaseObject*>::iterator bo;
+        for (bo = tmp->objectList.begin(); bo != tmp->objectList.end(); bo++)
+          if ((*bo) == object)
             return true;
-          }
-          enumBO = iterator->nextElement();
-        }
         if (likely(tmp->classID == classID))
-        {
-          delete iterator;
           break;
-        }
       }
       tmp = tmp->next;
@@ -354,9 +329,9 @@
   while (likely(tmp != NULL))
   {
-    if ((debugLevel >= 1 || tmp->objectList->getSize() > 0 ) &&
+    if ((debugLevel >= 1 || tmp->objectList.size() > 0 ) &&
          (classID == CL_NULL || unlikely (classID == tmp->classID)))
     {
       lenCount = 1;
-      while (pow(10,lenCount) <= tmp->objectList->getSize())
+      while (pow(10, lenCount) <= tmp->objectList.size())
         ++lenCount;
       for (int i=0; i < 30-strlen(tmp->className) - lenCount; i++)
@@ -364,20 +339,17 @@
       niceString[30-strlen(tmp->className) - lenCount] = '\0';
 
-      PRINT(0)("| CLASS %s:%s %d\n", tmp->className, niceString, tmp->objectList->getSize());
-
-      if (debugLevel >=2 && tmp->objectList->getSize() > 0)
+      PRINT(0)("| CLASS %s:%s %d\n", tmp->className, niceString, tmp->objectList.size());
+
+      if (debugLevel >=2 && tmp->objectList.size() > 0)
       {
         PRINT(0)("|  Listing Instances:\n");
-        tIterator<BaseObject>* iterator = tmp->objectList->getIterator();
-        BaseObject* enumBO = iterator->firstElement();
-        while (enumBO)
+        list<BaseObject*>::const_iterator bo;
+        for (bo = tmp->objectList.begin(); bo != tmp->objectList.end(); bo++)
         {
-          PRINT(0)("|   (class %s): NAME(%s)->%p ", enumBO->getClassName(), enumBO->getName(), enumBO);
+          PRINT(0)("|   (class %s): NAME(%s)->%p ", (*bo)->getClassName(), (*bo)->getName(), (*bo));
           if (debugLevel == 3)
-            ClassList::whatIs(enumBO);
+            ClassList::whatIs(*bo);
           PRINT(0)("\n");
-          enumBO = iterator->nextElement();
         }
-        delete iterator;
       }
     }
Index: trunk/src/lib/lang/class_list.h
===================================================================
--- trunk/src/lib/lang/class_list.h	(revision 5778)
+++ trunk/src/lib/lang/class_list.h	(revision 5779)
@@ -9,9 +9,8 @@
 
 #include "class_id.h"
+#include <list>
 
 // FORWARD DECLARATION
 class BaseObject;
-template<class T> class tList;
-
 
 //! A class that handles Pointers to Objects of all type.
@@ -35,23 +34,24 @@
 
     // STATIC FUNCTIONS
-    static void                     addToClassList(BaseObject* objectPointer, const long& classID, const char* className);
-    static void                     removeFromClassList(BaseObject* objectPointer);
+    static void                          addToClassList(BaseObject* objectPointer, const long& classID, const char* className);
+    static void                          removeFromClassList(BaseObject* objectPointer);
 
-    static tList<BaseObject>*       getList(long classID = CL_NULL);
-    static tList<BaseObject>*       getList(const char* className);
-    static const tList<const char>* getClassList();
-    static BaseObject*              getObject(const char* name, long classID = CL_NULL);
-    static bool                     exists(const BaseObject* object, long classID = CL_NULL);
+    static std::list<BaseObject*>*       getList(long classID = CL_NULL);
+    static std::list<BaseObject*>*       getList(const char* className);
+    static const std::list<const char*>* getClassList();
+    static BaseObject*                   getObject(const char* name, long classID = CL_NULL);
+    static bool                          exists(const BaseObject* object, long classID = CL_NULL);
 
-    static void                     whatIs(const BaseObject* object);
+    static void                          whatIs(const BaseObject* object);
 
-    static const char*              IDToString(long classID = CL_NULL);
-    static long                     StringToID(const char* className);
-    static void                     debug(unsigned int debugLevel = 0, long classID = CL_NULL);
-    static void                     debugS(const char* className = 0x0, unsigned int debugLevel = 0);
+    static const char*                   IDToString(long classID = CL_NULL);
+    static long                          StringToID(const char* className);
+    static void                          debug(unsigned int debugLevel = 0, long classID = CL_NULL);
+    static void                          debugS(const char* className = 0x0, unsigned int debugLevel = 0);
+
 
 
   private:
-    tList<BaseObject>*              objectList;             //!< A list of Objects belonging to this Class
+    std::list<BaseObject*>          objectList;             //!< A list of Objects belonging to this Class
 
     long                            classID;                //!< ClassID stored in this ClassList \see ClassID
@@ -62,5 +62,5 @@
     // STATIC MEMBERS
     static ClassList*               first;                  //!< The first Class in the List
-    static tList<const char>*       classList;              //!< a List of all Names of all classes, that have registered so far.
+    static std::list<const char*>   classList;              //!< a List of all Names of all classes, that have registered so far.
     static unsigned int             classCount;             //!< The Count of classes that have been registered (should match the lower description)
 };
Index: trunk/src/lib/physics/physics_engine.cc
===================================================================
--- trunk/src/lib/physics/physics_engine.cc	(revision 5778)
+++ trunk/src/lib/physics/physics_engine.cc	(revision 5779)
@@ -131,17 +131,6 @@
 PhysicsInterface* PhysicsEngine::getPhysicsInterfaceByName(const char* physicsInterfaceName) const
 {
-  tIterator<BaseObject>* tmpIt = ClassList::getList(CL_PHYSICS_INTERFACE)->getIterator();
-  BaseObject* tmpInt = tmpIt->firstElement();
-  while(tmpInt)
-  {
-    if (!strcmp(physicsInterfaceName, tmpInt->getName()))
-    {
-      delete tmpIt;
-      return dynamic_cast<PhysicsInterface*>(tmpInt);
-    }
-    tmpInt = tmpIt->nextElement();
-  }
-  delete tmpIt;
-  return NULL;
+  BaseObject* interface = ClassList::getObject(physicsInterfaceName, CL_PHYSICS_INTERFACE);
+  return (interface != NULL)?  dynamic_cast<PhysicsInterface*>(interface) : NULL;
 }
 
@@ -237,13 +226,7 @@
   if (this->interfaces != NULL || (this->interfaces = ClassList::getList(CL_PHYSICS_INTERFACE)) != NULL)
   {
-    tIterator<BaseObject>* itPI = this->interfaces->getIterator();
-    PhysicsInterface* enumPI = dynamic_cast<PhysicsInterface*>(itPI->firstElement());
-    while (enumPI)
-    {
-       enumPI->tickPhys(dt);
-
-      enumPI = dynamic_cast<PhysicsInterface*>(itPI->nextElement());
-    }
-   delete itPI;
+    list<BaseObject*>::const_iterator tickPhys;
+    for (tickPhys = this->interfaces->begin(); tickPhys != this->interfaces->end(); tickPhys++)
+      dynamic_cast<PhysicsInterface*>(*tickPhys)->tickPhys(dt);
   }
 }
@@ -261,5 +244,5 @@
   PRINT(0)(" reference: %p\n", this);
   if (this->interfaces != NULL)
-    PRINT(0)(" number of Interfaces: %d\n", this->interfaces->getSize());
+    PRINT(0)(" number of Interfaces: %d\n", this->interfaces->size());
   PRINT(0)(" number of Fields: %d\n", this->fields.size());
   PRINT(0)(" number of Connections: %d\n", this->connections.size());
Index: trunk/src/lib/physics/physics_engine.h
===================================================================
--- trunk/src/lib/physics/physics_engine.h	(revision 5778)
+++ trunk/src/lib/physics/physics_engine.h	(revision 5779)
@@ -54,5 +54,5 @@
   std::list<Field*>             fields;               //!< a list of physicsl fields.
   std::list<PhysicsConnection*> connections;          //!< a list of physical connections.
-  const tList<BaseObject>*      interfaces;           //!< The list of physical interfaces.
+  const std::list<BaseObject*>* interfaces;           //!< The list of physical interfaces.
 };
 
Index: trunk/src/lib/shell/shell_command.cc
===================================================================
--- trunk/src/lib/shell/shell_command.cc	(revision 5778)
+++ trunk/src/lib/shell/shell_command.cc	(revision 5779)
@@ -47,5 +47,5 @@
   this->shellClass = ShellCommandClass::getCommandClass(className); //ClassList::IDToString(classID);
   if (this->shellClass != NULL)
-    this->shellClass->commandList->add(this);
+    this->shellClass->commandList.push_back(this);
 }
 
@@ -82,5 +82,6 @@
 void ShellCommand::unregisterCommand(const char* commandName, const char* className)
 {
-  if (ShellCommandClass::commandClassList == NULL)
+  /// FIXME
+/*  if (ShellCommandClass::commandClassList == NULL)
     ShellCommandClass::initCommandClassList();
 
@@ -89,24 +90,21 @@
  if (checkClass != NULL)
   {
-    tIterator<ShellCommand>* iterator = checkClass->commandList->getIterator();
-    ShellCommand* elem = iterator->firstElement();
-    while(elem != NULL)
-    {
-      if (!strcmp(commandName, elem->getName()))
-      {
-        checkClass->commandList->remove(elem);
-        delete elem;
+    std::list<ShellCommand*>::iterator elem;
+    for (elem = checkClass->commandList.begin(); elem != checkClass->commandList.end(); elem++)
+    {
+      if (!strcmp(commandName, (*elem)->getName()))
+      {
+        delete (*elem);
+        checkClass->commandList.remove(*elem);
         break;
       }
-      elem = iterator->nextElement();
-    }
-    delete iterator;
-
-    if (checkClass->commandList->getSize() == 0)
+    }
+
+    if (checkClass->commandList->size() == 0)
     {
       ShellCommandClass::commandClassList->remove(checkClass);
       delete checkClass;
     }
-  }
+  }*/
 }
 
@@ -132,17 +130,13 @@
   if (checkClass != NULL)
   {
-    tIterator<ShellCommand>* iterator = checkClass->commandList->getIterator();
-    ShellCommand* elem = iterator->firstElement();
-    while(elem != NULL)
-   {
-     if (!strcmp(commandName, elem->getName()))
-     {
-       PRINTF(2)("Command already registered\n");
-       delete iterator;
-       return true;
-      }
-     elem = iterator->nextElement();
-   }
-   delete iterator;
+    std::list<ShellCommand*>::const_iterator elem;
+    for (elem = checkClass->commandList.begin(); elem != checkClass->commandList.end(); elem++)
+    {
+      if (!strcmp(commandName, (*elem)->getName()))
+      {
+        PRINTF(2)("Command '%s::%s' already registered\n", className, commandName);
+        return true;
+      }
+    }
    return false;
   }
@@ -163,11 +157,11 @@
     return false;
 
-  long classID = CL_NULL;                 //< the classID retrieved from the Class.
-  ShellCommandClass* commandClass = NULL; //< the command class this command applies to.
-  tList<BaseObject>* objectList = NULL;   //< the list of Objects stored in classID
-  BaseObject* objectPointer = NULL;       //< a pointer to th Object to Execute the command on
-  bool emptyComplete = false;             //< if the completion input is empty string. e.g ""
-  unsigned int fktPos = 1;                //< the position of the function (needed for finding it)
-//  long completeType = SHELLC_NONE;      //< the Type we'd like to complete.
+  long classID = CL_NULL;                      //< the classID retrieved from the Class.
+  ShellCommandClass* commandClass = NULL;      //< the command class this command applies to.
+  std::list<BaseObject*>* objectList = NULL;   //< the list of Objects stored in classID
+  BaseObject* objectPointer = NULL;            //< a pointer to th Object to Execute the command on
+  bool emptyComplete = false;                  //< if the completion input is empty string. e.g ""
+  unsigned int fktPos = 1;                     //< the position of the function (needed for finding it)
+//  long completeType = SHELLC_NONE;           //< the Type we'd like to complete.
   SubString inputSplits(executionString, " \t\n,");
 
@@ -179,94 +173,76 @@
     if (ShellCommandClass::aliasList != NULL)
     {
-      tIterator<ShellCommandAlias>* itAL = ShellCommandClass::aliasList->getIterator();
-      ShellCommandAlias* elemAL = itAL->firstElement();
-      while(elemAL != NULL)
-      {
-        if (elemAL->getName() != NULL && !strcmp(elemAL->getName(), inputSplits.getString(0)) && elemAL->getCommand() != NULL &&
-            elemAL->getCommand()->shellClass != NULL )
+      list<ShellCommandAlias*>::iterator alias;
+      for (alias = ShellCommandClass::aliasList->begin(); alias != ShellCommandClass::aliasList->end(); alias++ )
+      {
+        if ((*alias)->getName() != NULL && !strcmp((*alias)->getName(), inputSplits.getString(0)) && (*alias)->getCommand() != NULL &&
+            (*alias)->getCommand()->shellClass != NULL )
         {
-          objectList = ClassList::getList(elemAL->getCommand()->shellClass->getName());
+          objectList = ClassList::getList((*alias)->getCommand()->shellClass->getName());
           if (objectList != NULL)
           {
             if (inputSplits.getCount() > 1)
-              elemAL->getCommand()->executor->execute(objectList->firstElement(), executionString+inputSplits.getOffset(1));
+              (*alias)->getCommand()->executor->execute(objectList->front(), executionString+inputSplits.getOffset(1));
             else
-              elemAL->getCommand()->executor->execute(objectList->firstElement(), "");
-            delete itAL;
+              (*alias)->getCommand()->executor->execute(objectList->front(), "");
+           return true;
+          }
+        }
+      }
+    }
+    // looking for a Matching Class
+    if (likely(ShellCommandClass::commandClassList != NULL))
+    {
+      list<ShellCommandClass*>::iterator commandClassIT;
+      for (commandClassIT = ShellCommandClass::commandClassList->begin(); commandClassIT != ShellCommandClass::commandClassList->end(); commandClassIT++)
+      {
+        if ((*commandClassIT)->getName() && !strcasecmp(inputSplits.getString(0), (*commandClassIT)->getName()))
+        {
+          //elemCL->getName();
+          classID = ClassList::StringToID((*commandClassIT)->getName());
+          commandClass = (*commandClassIT);
+          objectList = ClassList::getList(classID);
+          break;
+        }
+      }
+    }
+
+    if (commandClass != NULL && inputSplits.getCount() >= 2)
+    {
+      if (objectList != NULL)
+      {
+        // Checking for a Match in the Objects of classID (else take the first)
+        list<BaseObject*>::const_iterator object;
+        for (object = objectList->begin(); object != objectList->end(); object++)
+        {
+          if ((*object)->getName() != NULL && !strcasecmp((*object)->getName(), inputSplits.getString(1)))
+          {
+            objectPointer = (*object);
+            fktPos = 2;
+            break;
+          }
+         }
+
+      //
+        if (objectPointer == NULL)
+          objectPointer = objectList->front();
+      }
+      // match a function.
+      if (commandClass != NULL && (fktPos == 1 || (fktPos == 2 && inputSplits.getCount() >= 3)))
+      {
+        list<ShellCommand*>::iterator cmdIT;
+        for (cmdIT = commandClass->commandList.begin(); cmdIT != commandClass->commandList.end(); cmdIT++)
+        {
+          if (!strcmp((*cmdIT)->getName(), inputSplits.getString(fktPos)))
+          {
+            if (objectPointer == NULL && (*cmdIT)->executor->getType() & Executor_Objective)
+              return false;
+            if (inputSplits.getCount() > fktPos+1)
+              (*cmdIT)->executor->execute(objectPointer, executionString+inputSplits.getOffset(fktPos +1));
+            else
+              (*cmdIT)->executor->execute(objectPointer, "");
             return true;
           }
         }
-        elemAL = itAL->nextElement();
-      }
-      delete itAL;
-    }
-    // looking for a Matching Class
-    if (likely(ShellCommandClass::commandClassList != NULL))
-    {
-      tIterator<ShellCommandClass>* itCL = ShellCommandClass::commandClassList->getIterator();
-      ShellCommandClass* elemCL = itCL->firstElement();
-      while(elemCL != NULL)
-      {
-        if (elemCL->getName() && !strcasecmp(inputSplits.getString(0), elemCL->getName()))
-        {
-          //elemCL->getName();
-          classID = ClassList::StringToID(elemCL->getName());
-          commandClass = elemCL;
-          objectList = ClassList::getList(classID);
-          break;
-        }
-        elemCL = itCL->nextElement();
-      }
-      delete itCL;
-    }
-
-    if (commandClass != NULL && inputSplits.getCount() >= 2)
-    {
-      if (objectList != NULL)
-      {
-        // Checking for a Match in the Objects of classID (else take the first)
-        tIterator<BaseObject>* itBO = objectList->getIterator();
-        BaseObject* enumBO = itBO->firstElement();
-        while(enumBO)
-        {
-          if (enumBO->getName() != NULL && !strcasecmp(enumBO->getName(), inputSplits.getString(1)))
-          {
-            objectPointer = enumBO;
-            fktPos = 2;
-            break;
-          }
-          enumBO = itBO->nextElement();
-         }
-         delete itBO;
-
-      //
-        if (objectPointer == NULL)
-          objectPointer = objectList->firstElement();
-      }
-      // match a function.
-      if (commandClass != NULL && (fktPos == 1 || (fktPos == 2 && inputSplits.getCount() >= 3)))
-      {
-        tIterator<ShellCommand>* itCMD = commandClass->commandList->getIterator();
-        ShellCommand* enumCMD = itCMD->firstElement();
-        while (enumCMD != NULL)
-        {
-          if (!strcmp(enumCMD->getName(), inputSplits.getString(fktPos)))
-          {
-            if (objectPointer == NULL && enumCMD->executor->getType() & Executor_Objective)
-            {
-              delete itCMD;
-              return false;
-            }
-            if (inputSplits.getCount() > fktPos+1)
-              enumCMD->executor->execute(objectPointer, executionString+inputSplits.getOffset(fktPos +1));
-            else
-              enumCMD->executor->execute(objectPointer, "");
-            delete itCMD;
-            return true;
-          }
-
-          enumCMD = itCMD->nextElement();
-        }
-        delete itCMD;
       }
     }
@@ -306,8 +282,8 @@
   {
     if (ShellCommandClass::aliasList == NULL)
-      ShellCommandClass::aliasList = new tList<ShellCommandAlias>;
+      ShellCommandClass::aliasList = new std::list<ShellCommandAlias*>;
 
     ShellCommandAlias* aliasCMD = new ShellCommandAlias(alias, this);
-    ShellCommandClass::aliasList->add(aliasCMD);
+    ShellCommandClass::aliasList->push_back(aliasCMD);
     this->alias = aliasCMD;
   }
@@ -348,27 +324,22 @@
   }
 
-  tIterator<ShellCommandClass>* iteratorCL = ShellCommandClass::commandClassList->getIterator();
-  ShellCommandClass* elemCL = iteratorCL->firstElement();
-  while(elemCL != NULL)
-  {
-    PRINT(0)("Class:'%s' registered %d commands: \n", elemCL->className, elemCL->commandList->getSize());
-    tIterator<ShellCommand>* iterator = elemCL->commandList->getIterator();
-    const ShellCommand* elem = iterator->firstElement();
-    while(elem != NULL)
-    {
-      PRINT(0)("  command:'%s' : params:%d: ", elem->getName(), elem->executor->getParamCount());
+  list<ShellCommandClass*>::iterator classIT;
+  for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
+  {
+    PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className, (*classIT)->commandList.size());
+
+    list<ShellCommand*>::iterator cmdIT;
+    for (cmdIT = (*classIT)->commandList.begin(); cmdIT != (*classIT)->commandList.end(); cmdIT++)
+    {
+      PRINT(0)("  command:'%s' : params:%d: ", (*cmdIT)->getName(), (*cmdIT)->executor->getParamCount());
       /// FIXME
       /*      for (unsigned int i = 0; i< elem->paramCount; i++)
        printf("%s ", ShellCommand::paramToString(elem->parameters[i]));*/
-      if (elem->description != NULL)
-       printf("- %s", elem->description);
+      if ((*cmdIT)->description != NULL)
+       printf("- %s", (*cmdIT)->description);
       printf("\n");
 
-      elem = iterator->nextElement();
-    }
-    delete iterator;
-    elemCL = iteratorCL->nextElement();
-  }
-  delete iteratorCL;
+    }
+  }
 }
 
Index: trunk/src/lib/shell/shell_command.h
===================================================================
--- trunk/src/lib/shell/shell_command.h	(revision 5778)
+++ trunk/src/lib/shell/shell_command.h	(revision 5779)
@@ -108,5 +108,5 @@
 
   private:
-    const char*         aliasName;       //!< the name of the Alias
+    const char*     aliasName;       //!< the name of the Alias
     ShellCommand*   command;         //!< a pointer to the command, this alias executes.
 };
Index: trunk/src/lib/shell/shell_command_class.cc
===================================================================
--- trunk/src/lib/shell/shell_command_class.cc	(revision 5778)
+++ trunk/src/lib/shell/shell_command_class.cc	(revision 5779)
@@ -29,6 +29,6 @@
 using namespace std;
 
-tList<ShellCommandClass>* ShellCommandClass::commandClassList = NULL;
-tList<ShellCommandAlias>* ShellCommandClass::aliasList = NULL;
+std::list<ShellCommandClass*>* ShellCommandClass::commandClassList = NULL;
+std::list<ShellCommandAlias*>* ShellCommandClass::aliasList = NULL;
 
 /**
@@ -43,7 +43,6 @@
   this->className = className;
   this->classID = CL_NULL;
-  this->commandList = new tList<ShellCommand>;
-
-  ShellCommandClass::commandClassList->add(this);
+
+  ShellCommandClass::commandClassList->push_back(this);
 }
 
@@ -53,13 +52,9 @@
 ShellCommandClass::~ShellCommandClass()
 {
-  tIterator<ShellCommand>* iterator = this->commandList->getIterator();
-  ShellCommand* elem = iterator->firstElement();
-  while(elem != NULL)
-  {
-    delete elem;
-    elem = iterator->nextElement();
-  }
-  delete iterator;
-  delete this->commandList;
+  while(this->commandList.size() > 0)
+  {
+    delete this->commandList.front();
+    this->commandList.pop_front();
+  }
 }
 
@@ -70,28 +65,19 @@
  * @returns true on success, false otherwise
  */
-bool ShellCommandClass::getCommandListOfClass(const char* className, tList<const char>* stringList)
+bool ShellCommandClass::getCommandListOfClass(const char* className, std::list<const char*>* stringList)
 {
   if (stringList == NULL || className == NULL)
     return false;
 
-  tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator();
-  ShellCommandClass* elem = iterator->firstElement();
-  while(elem != NULL)
-  {
-    if (!strcmp (elem->getName(), className))
-    {
-      tIterator<ShellCommand>* itFkt = elem->commandList->getIterator();
-      ShellCommand* command = itFkt->firstElement();
-      while (command != NULL)
-      {
-        stringList->add(command->getName());
-        command = itFkt->nextElement();
-      }
-      delete itFkt;
-    }
-
-    elem = iterator->nextElement();
-  }
-  delete iterator;
+  list<ShellCommandClass*>::iterator elem;
+  for(elem = ShellCommandClass::commandClassList->begin(); elem != ShellCommandClass::commandClassList->end(); elem++)
+  {
+    if (!strcmp ((*elem)->getName(), className))
+    {
+      list<ShellCommand*>::iterator command;
+      for(command = (*elem)->commandList.begin(); command != (*elem)->commandList.end(); command++)
+        stringList->push_back((*command)->getName());
+    }
+  }
   return true;
 }
@@ -102,18 +88,13 @@
  * @returns true on success, false otherwise
  */
-bool ShellCommandClass::getCommandListOfAlias(tList<const char>* stringList)
+bool ShellCommandClass::getCommandListOfAlias(std::list<const char*>* stringList)
 {
   if (stringList == NULL || ShellCommandClass::aliasList == NULL)
     return false;
 
-  tIterator<ShellCommandAlias>* iterator = ShellCommandClass::aliasList->getIterator();
-   ShellCommandAlias* elem = iterator->firstElement();
-   while(elem != NULL)
-   {
-     stringList->add(elem->getName());
-     elem = iterator->nextElement();
-   }
-   delete iterator;
-   return true;
+  list<ShellCommandAlias*>::iterator alias;
+  for (alias = ShellCommandClass::aliasList->begin(); alias != ShellCommandClass::aliasList->end(); alias++)
+    stringList->push_back((*alias)->getName());
+  return true;
 }
 
@@ -123,5 +104,7 @@
 void ShellCommandClass::unregisterAllCommands()
 {
-  if (ShellCommandClass::commandClassList != NULL)
+  /// FIXME
+
+  /*  if (ShellCommandClass::commandClassList != NULL)
   {
     // unregister all commands
@@ -153,5 +136,5 @@
     delete ShellCommandClass::aliasList;
     ShellCommandClass::aliasList = NULL;
-  }
+  }*/
 }
 
@@ -166,19 +149,15 @@
     initCommandClassList();
 
-  tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator();
-  ShellCommandClass* elem = iterator->firstElement();
-  while(elem != NULL)
-  {
-    if (!strcmp(className, elem->className))
-    {
-      if (elem->classID == CL_NULL)
-        elem->classID = ClassList::StringToID(className);
-
-      delete iterator;
-      return elem;
-    }
-    elem = iterator->nextElement();
-  }
-  delete iterator;
+  list<ShellCommandClass*>::const_iterator classIT;
+  for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
+  {
+    if (!strcmp(className, (*classIT)->className))
+    {
+      if ((*classIT)->classID == CL_NULL)
+        (*classIT)->classID = ClassList::StringToID(className);
+
+      return (*classIT);
+    }
+  }
   return NULL;
 }
@@ -194,16 +173,12 @@
     initCommandClassList();
 
-  tIterator<ShellCommandClass>* iterator = ShellCommandClass::commandClassList->getIterator();
-  ShellCommandClass* elem = iterator->firstElement();
-  while(elem != NULL)
-  {
-    if (!strcmp(className, elem->className))
-    {
-      delete iterator;
-      return elem;
-    }
-    elem = iterator->nextElement();
-  }
-  delete iterator;
+  list<ShellCommandClass*>::iterator classIT;
+  for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
+  {
+    if (!strcmp(className, (*classIT)->className))
+    {
+      return (*classIT);
+    }
+  }
   return new ShellCommandClass(className);
 }
@@ -216,5 +191,5 @@
   if (ShellCommandClass::commandClassList == NULL)
   {
-    ShellCommandClass::commandClassList = new tList<ShellCommandClass>;
+    ShellCommandClass::commandClassList = new std::list<ShellCommandClass*>;
     ShellCommand::registerCommand("debug", "ShellCommand", ExecutorStatic<ShellCommand>(ShellCommand::debug));
   }
@@ -231,32 +206,24 @@
   if (likely(ShellCommandClass::commandClassList != NULL))
   {
-    tIterator<ShellCommandClass>* itCL = ShellCommandClass::commandClassList->getIterator();
-    ShellCommandClass* elemCL = itCL->firstElement();
-    while(elemCL != NULL)
-    {
-      if (elemCL->className && !strcasecmp(className, elemCL->className))
+    list<ShellCommandClass*>::iterator classIT;
+    for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
+    {
+      if ((*classIT)->className && !strcasecmp(className, (*classIT)->className))
       {
-        PRINT(0)("Class:'%s' registered %d commands: \n", elemCL->className, elemCL->commandList->getSize());
-        tIterator<ShellCommand>* iterator = elemCL->commandList->getIterator();
-        const ShellCommand* elem = iterator->firstElement();
-        while(elem != NULL)
+        PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className, (*classIT)->commandList.size());
+        list<ShellCommand*>::const_iterator cmdIT;
+        for (cmdIT = (*classIT)->commandList.begin(); cmdIT != (*classIT)->commandList.end(); cmdIT++)
         {
-          PRINT(0)("  command:'%s' : params:%d: ", elem->getName(), elem->executor->getParamCount());
+          PRINT(0)("  command:'%s' : params:%d: ", (*cmdIT)->getName(), (*cmdIT)->executor->getParamCount());
           /// FIXME
           /*          for (unsigned int i = 0; i< elem->paramCount; i++)
             PRINT(0)("%s ", ShellCommand::paramToString(elem->parameters[i]));*/
-          if (elem->description != NULL)
-            PRINT(0)("- %s", elem->description);
+          if ((*cmdIT)->description != NULL)
+            PRINT(0)("- %s", (*cmdIT)->description);
           PRINT(0)("\n");
-          elem = iterator->nextElement();
         }
-        delete iterator;
-
-        delete itCL;
         return;
       }
-      elemCL = itCL->nextElement();
-    }
-    delete itCL;
+    }
     PRINTF(3)("Class %s not found in Command's classes\n", className);
   }
Index: trunk/src/lib/shell/shell_command_class.h
===================================================================
--- trunk/src/lib/shell/shell_command_class.h	(revision 5778)
+++ trunk/src/lib/shell/shell_command_class.h	(revision 5779)
@@ -8,4 +8,5 @@
 
 #include "base_object.h"
+#include <list>
 
 
@@ -26,7 +27,7 @@
   public:
     /** @returns the CommandClassList */
-    static const tList<ShellCommandClass>* getCommandClassList() { return ShellCommandClass::commandClassList; };
-    static bool getCommandListOfClass(const char* className, tList<const char>* stringList);
-    static bool getCommandListOfAlias(tList<const char>* aliasList);
+    static const std::list<ShellCommandClass*>* getCommandClassList() { return ShellCommandClass::commandClassList; };
+    static bool getCommandListOfClass(const char* className, std::list<const char*>* stringList);
+    static bool getCommandListOfAlias(std::list<const char*>* aliasList);
 
     static ShellCommandClass* getCommandClass(const char* className);
@@ -43,9 +44,9 @@
 
   private:
-    const char*                      className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
-    long                             classID;                   //!< The classID of this Class
-    tList<ShellCommand>*             commandList;               //!< A list of Commands from this Class
-    static tList<ShellCommandClass>* commandClassList;          //!< A list of Classes
-    static tList<ShellCommandAlias>* aliasList;                 //!< An Alias to A Command. (only for classes with one Instance)
+    const char*                            className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
+    long                                   classID;                   //!< The classID of this Class
+    std::list<ShellCommand*>               commandList;               //!< A list of Commands from this Class
+    static std::list<ShellCommandClass*>*  commandClassList;          //!< A list of Classes
+    static std::list<ShellCommandAlias*>*  aliasList;                 //!< An Alias to A Command. (only for classes with one Instance)
 };
 
Index: trunk/src/lib/shell/shell_completion.cc
===================================================================
--- trunk/src/lib/shell/shell_completion.cc	(revision 5778)
+++ trunk/src/lib/shell/shell_completion.cc	(revision 5779)
@@ -63,11 +63,11 @@
 bool ShellCompletion::autoComplete(ShellInput* input)
 {
-  const char* completionLine;      //< the inputLine we complete.
-
-  long classID;                    //< the classID retrieved from the Class.
-  tList<BaseObject>* objectList;   //< the list of Objects stored in classID
-  bool emptyComplete = false;      //< if the completion input is empty string. e.g ""
-  long completeType = SHELLC_NONE; //< the Type we'd like to complete.
-  const char* completeString;      //< the string to complete.
+  const char* completionLine;           //< the inputLine we complete.
+
+  long classID;                         //< the classID retrieved from the Class.
+  std::list<BaseObject*>* objectList;   //< the list of Objects stored in classID
+  bool emptyComplete = false;           //< if the completion input is empty string. e.g ""
+  long completeType = SHELLC_NONE;      //< the Type we'd like to complete.
+  const char* completeString;           //< the string to complete.
 
 
@@ -159,5 +159,5 @@
   if (unlikely(classBegin == NULL))
     return false;
-  const tList<const char>* clList = ClassList::getClassList();
+  const std::list<const char*>* clList = ClassList::getClassList();
   if (clList != NULL)
   {
@@ -180,5 +180,5 @@
   if (unlikely(objectBegin == NULL))
     return false;
-  const tList<BaseObject>* boList = ClassList::getList(classID);
+  const std::list<BaseObject*>* boList = ClassList::getList(classID);
   if (boList != NULL)
   {
@@ -203,5 +203,5 @@
   if (unlikely(functionBegin == NULL))
     return false;
-  tList<const char> fktList;
+  std::list<const char*> fktList;
   ShellCommandClass::getCommandListOfClass(className, &fktList);
   //printf("%s\n", boList->firstElement()->getName());
@@ -220,5 +220,5 @@
   if (unlikely(aliasBegin == NULL))
     return false;
-  tList<const char> aliasList;
+  std::list<const char*> aliasList;
   ShellCommandClass::getCommandListOfAlias(&aliasList);
   //printf("%s\n", boList->firstElement()->getName());
@@ -241,8 +241,8 @@
   if (completionList == NULL || this->input == NULL )
     return false;
-  if (completionList->getSize() == 0)
-    return false;
-
-  ShellC_Element* addElem = completionList->firstElement();
+  if (completionList->size() == 0)
+    return false;
+
+  ShellC_Element* addElem = completionList->front();
   const char* addString = addElem->name;
   unsigned int addLength = 0;
@@ -252,26 +252,24 @@
   if (addString != NULL)
     addLength = strlen(addString);
-  tIterator<ShellC_Element>* charIterator = completionList->getIterator();
-  ShellC_Element* charElem = charIterator->firstElement();
+
   SHELLC_TYPE changeType = SHELLC_NONE;
-  while (charElem != NULL)
-  {
-    if (charElem->type != changeType)
+  list<ShellC_Element*>::iterator charIT;
+  for (charIT = completionList->begin(); charIT != completionList->end(); charIT++)
+  {
+    if ((*charIT)->type != changeType)
     {
       if (changeType != SHELLC_NONE)
         PRINT(0)("\n");
-      PRINT(0)("%s: ", ShellCompletion::typeToString(charElem->type));
-      changeType = charElem->type;
-    }
-    PRINTF(0)("%s ", charElem->name);
+      PRINT(0)("%s: ", ShellCompletion::typeToString((*charIT)->type));
+      changeType = (*charIT)->type;
+    }
+    PRINTF(0)("%s ", (*charIT)->name);
     for (unsigned int i = inputLenght; i < addLength; i++)
-      if (addString[i] != charElem->name[i])
+      if (addString[i] != (*charIT)->name[i])
       {
        addLength = i;
 //       break;
       }
-    charElem = charIterator->nextElement();
-  }
-  delete charIterator;
+  }
   PRINT(0)("\n");
 
@@ -287,5 +285,5 @@
      this->input->addCharacters(adder);
 
-      if (completionList->getSize() == 1)
+      if (completionList->size() == 1)
       {
         if ( addBack != NULL )
@@ -305,5 +303,5 @@
  * !! The strings MUST NOT be deleted !!
  */
-bool ShellCompletion::addToCompleteList(const tList<const char>* inputList, const char* completionBegin, SHELLC_TYPE type)
+bool ShellCompletion::addToCompleteList(const std::list<const char*>* inputList, const char* completionBegin, SHELLC_TYPE type)
 {
   if (inputList == NULL || completionBegin == NULL)
@@ -311,21 +309,17 @@
   unsigned int searchLength = strlen(completionBegin);
 
-  tIterator<const char>* iterator = inputList->getIterator();
-  const char* enumString = iterator->firstElement();
-  while (enumString != NULL)
-  {
-    if (strlen(enumString) >= searchLength &&
-        !strncasecmp(enumString, completionBegin, searchLength))
-    {
-      printf("%s\n", enumString);
+  list<const char*>::const_iterator string;
+  for (string = inputList->begin(); string != inputList->end(); string++)
+  {
+    if (strlen(*string) >= searchLength &&
+        !strncasecmp(*string, completionBegin, searchLength))
+    {
+      printf("%s\n", *string);
       ShellC_Element* newElem = new ShellC_Element;
-      newElem->name = enumString;
+      newElem->name = *string;
       newElem->type = type;
-      this->completionList->add(newElem);
-    }
-    enumString = iterator->nextElement();
-  }
-  delete iterator;
-
+      this->completionList->push_back(newElem);
+    }
+  }
   return true;
 }
@@ -337,5 +331,5 @@
  * !! The strings MUST NOT be deleted !!
  */
-bool ShellCompletion::addToCompleteList(const tList<BaseObject>* inputList, const char* completionBegin, SHELLC_TYPE type)
+bool ShellCompletion::addToCompleteList(const std::list<BaseObject*>* inputList, const char* completionBegin, SHELLC_TYPE type)
 {
   if (inputList == NULL || completionBegin == NULL)
@@ -343,20 +337,17 @@
   unsigned int searchLength = strlen(completionBegin);
 
-  tIterator<BaseObject>* iterator = inputList->getIterator();
-  BaseObject* enumBO = iterator->firstElement();
-  while (enumBO != NULL)
-  {
-    if (enumBO->getName() != NULL &&
-        strlen(enumBO->getName()) >= searchLength &&
-        !strncasecmp(enumBO->getName(), completionBegin, searchLength))
+  list<BaseObject*>::const_iterator bo;
+  for(bo = inputList->begin(); bo != inputList->end(); bo++)
+  {
+    if ((*bo)->getName() != NULL &&
+        strlen((*bo)->getName()) >= searchLength &&
+        !strncasecmp((*bo)->getName(), completionBegin, searchLength))
     {
       ShellC_Element* newElem = new ShellC_Element;
-      newElem->name = enumBO->getName();
+      newElem->name = (*bo)->getName();
       newElem->type = type;
-      this->completionList->add(newElem);
-    }
-    enumBO = iterator->nextElement();
-  }
-  delete iterator;
+      this->completionList->push_back(newElem);
+    }
+  }
 
   return true;
@@ -372,14 +363,10 @@
   if (this->completionList != NULL)
   {
-    tIterator<ShellC_Element>* elemIT = this->completionList->getIterator();
-    ShellC_Element* elem = elemIT->firstElement();
-    while (elem != NULL)
-    {
-      delete elem;
-      elem = elemIT->nextElement();
-    }
-    delete this->completionList;
-  }
-  this->completionList = new tList<ShellC_Element>;
+    while (this->completionList->size() > 0)
+    {
+      delete this->completionList->front();
+      this->completionList->pop_front();
+    }
+  }
 }
 
Index: trunk/src/lib/shell/shell_completion.h
===================================================================
--- trunk/src/lib/shell/shell_completion.h	(revision 5778)
+++ trunk/src/lib/shell/shell_completion.h	(revision 5779)
@@ -9,4 +9,6 @@
 #ifndef _SHELL_COMPLETION_H
 #define _SHELL_COMPLETION_H
+
+#include <list>
 
 // FORWARD DECLARATION
@@ -51,6 +53,6 @@
   bool generalComplete(const char* begin, const char* displayAs = "%s", const char* addBack = NULL, const char* addFront = NULL);
 
-  bool addToCompleteList(const tList<const char>* inputList, const char* completionBegin, SHELLC_TYPE type);
-  bool addToCompleteList(const tList<BaseObject>* inputList, const char* completionBegin, SHELLC_TYPE type);
+  bool addToCompleteList(const std::list<const char*>* inputList, const char* completionBegin, SHELLC_TYPE type);
+  bool addToCompleteList(const std::list<BaseObject*>* inputList, const char* completionBegin, SHELLC_TYPE type);
   void emptyCompletionList();
 
@@ -58,6 +60,6 @@
 
  private:
-   tList<ShellC_Element>*   completionList;          //!< A list of completions, that are io.
-   ShellInput*              input;                   //!< the input this completion works on.
+   std::list<ShellC_Element*>*  completionList;          //!< A list of completions, that are io.
+   ShellInput*                  input;                   //!< the input this completion works on.
 };
 
Index: trunk/src/lib/sound/sound_engine.cc
===================================================================
--- trunk/src/lib/sound/sound_engine.cc	(revision 5778)
+++ trunk/src/lib/sound/sound_engine.cc	(revision 5779)
@@ -63,12 +63,6 @@
   if(this->sourceList != NULL)
   {
-    tIterator<BaseObject>* sourceIterator = this->sourceList->getIterator();
-    SoundSource* enumSource = (SoundSource*)sourceIterator->firstElement();
-    while (enumSource)
-    {
-        delete enumSource;
-        enumSource = (SoundSource*)sourceIterator->nextElement();
-    }
-    delete sourceIterator;
+    while (this->sourceList->size() > 0)
+      delete dynamic_cast<SoundSource*>(this->sourceList->front());
   }
 
@@ -76,12 +70,6 @@
   if (this->bufferList != NULL)
   {
-    tIterator<BaseObject>* bufferIterator = this->bufferList->getIterator();
-    SoundBuffer* enumBuffer = (SoundBuffer*)bufferIterator->firstElement();
-    while (enumBuffer)
-    {
-      ResourceManager::getInstance()->unload(enumBuffer);
-      enumBuffer = (SoundBuffer*)bufferIterator->nextElement();
-    }
-    delete bufferIterator;
+    while(this->bufferList->size() > 0)
+      ResourceManager::getInstance()->unload(dynamic_cast<SoundBuffer*>(this->bufferList->front()));
   }
 
@@ -148,13 +136,13 @@
 {
   // look if there are any sources that have the buffer still loaded
-  tIterator<BaseObject>* sourceIterator = this->sourceList->getIterator();
-  SoundSource* enumSource = (SoundSource*)sourceIterator->firstElement();
-  while (enumSource)
-    {
-      if (buffer == enumSource->getBuffer())
-        delete enumSource;
-      enumSource = (SoundSource*)sourceIterator->nextElement();
+  if (this->sourceList != NULL)
+  {
+    list<BaseObject*>::iterator source;
+    for (source = this->sourceList->begin(); source != this->sourceList->end(); source++)
+    {
+      if (buffer == static_cast<SoundSource*>(*source)->getBuffer())
+        delete (*source);
     }
-  delete sourceIterator;
+  }
 }
 
@@ -195,22 +183,21 @@
   if (likely(this->sourceList != NULL))
   {
-    tIterator<BaseObject>* iterator = this->sourceList->getIterator();
-    SoundSource* enumSource = (SoundSource*)iterator->firstElement();
-    while (enumSource)
-    {
-      if (likely(enumSource->getNode() != NULL))
+    list<BaseObject*>::iterator sourceIT;
+    SoundSource* source;
+    for (sourceIT = this->sourceList->begin(); sourceIT != this->sourceList->end(); sourceIT++)
+    {
+      source = static_cast<SoundSource*>(*sourceIT);
+      if (likely(source->getNode() != NULL))
       {
-        alSource3f(enumSource->getID(), AL_POSITION,
-                   enumSource->getNode()->getAbsCoor().x,
-                   enumSource->getNode()->getAbsCoor().y,
-                   enumSource->getNode()->getAbsCoor().z);
-        alSource3f(enumSource->getID(), AL_VELOCITY,
-                   enumSource->getNode()->getVelocity().x,
-                   enumSource->getNode()->getVelocity().y,
-                   enumSource->getNode()->getVelocity().z);
+        alSource3f(source->getID(), AL_POSITION,
+                   source->getNode()->getAbsCoor().x,
+                   source->getNode()->getAbsCoor().y,
+                   source->getNode()->getAbsCoor().z);
+        alSource3f(source->getID(), AL_VELOCITY,
+                   source->getNode()->getVelocity().x,
+                   source->getNode()->getVelocity().y,
+                   source->getNode()->getVelocity().z);
       }
-      enumSource = (SoundSource*)iterator->nextElement();
     }
-    delete iterator;
   }
 }
@@ -221,5 +208,5 @@
 void SoundEngine::flushUnusedBuffers()
 {
-  if(this->sourceList && this->bufferList)
+/*  if(this->sourceList && this->bufferList)
   {
     tIterator<BaseObject>* bufferIterator = this->bufferList->getIterator();
@@ -241,5 +228,5 @@
     }
     delete bufferIterator;
-  }
+}*/ /// FIXME
 }
 
@@ -252,12 +239,6 @@
   if (this->bufferList)
   {
-    tIterator<BaseObject>* bufferIterator = this->bufferList->getIterator();
-    SoundBuffer* enumBuffer = (SoundBuffer*)bufferIterator->firstElement();
-    while (enumBuffer)
-    {
-      ResourceManager::getInstance()->unload(enumBuffer, RP_LEVEL);
-      enumBuffer = (SoundBuffer*)bufferIterator->nextElement();
-    }
-    delete bufferIterator;
+    while (this->bufferList->size() > 0)
+      ResourceManager::getInstance()->unload(static_cast<SoundBuffer*>(this->bufferList->front()), RP_LEVEL);
   }
 }
@@ -270,12 +251,6 @@
   if (this->sourceList)
   {
-    tIterator<BaseObject>* Iterator = this->sourceList->getIterator();
-    SoundSource* enumSource = (SoundSource*)Iterator->firstElement();
-    while (enumSource)
-    {
-      delete enumSource;
-      enumSource = (SoundSource*)Iterator->nextElement();
-    }
-    delete Iterator;
+    while(this->sourceList->size() > 0)
+      delete this->sourceList->front();
   }
 }
Index: trunk/src/lib/sound/sound_engine.h
===================================================================
--- trunk/src/lib/sound/sound_engine.h	(revision 5778)
+++ trunk/src/lib/sound/sound_engine.h	(revision 5779)
@@ -13,4 +13,6 @@
 #include "sound_source.h"
 
+#include <list>
+
 #define SOUND_DOPPLER_FACTOR       0.001          //!< A factor for the audible doppler effect
 #define SOUND_DOPPLER_VELOCITY     5000000        //!< A factor for the TravelSpeed of sound
@@ -18,5 +20,4 @@
 // FORWARD DECLARATION
 class PNode;
-template<class T> class tList;
 class IniParser;
 
@@ -70,6 +71,6 @@
     float                    effectsVolume;            //!< the maximum volume of sound-effects in % (0f,1f]
     PNode*                   listener;                 //!< The listener of the Scene
-    tList<BaseObject>*       bufferList;               //!< A list of buffers
-    tList<BaseObject>*       sourceList;               //!< A list for all the sources in the scene.
+    std::list<BaseObject*>*  bufferList;               //!< A list of buffers
+    std::list<BaseObject*>*  sourceList;               //!< A list for all the sources in the scene.
 
 };
