Index: trunk/src/lib/Makefile.am
===================================================================
--- trunk/src/lib/Makefile.am	(revision 7201)
+++ trunk/src/lib/Makefile.am	(revision 7221)
@@ -55,4 +55,5 @@
 
 SUBDIRS = \
+	. \
 	math \
 	graphics \
@@ -65,4 +66,3 @@
 	parser \
 	shell \
-	gui \
-	.
+	gui
Index: trunk/src/lib/coord/p_node.cc
===================================================================
--- trunk/src/lib/coord/p_node.cc	(revision 7201)
+++ trunk/src/lib/coord/p_node.cc	(revision 7221)
@@ -540,5 +540,5 @@
  * @param childName the name of the child to add to this PNode
  */
-void PNode::addChild (const char* childName)
+void PNode::addChild (const std::string& childName)
 {
   PNode* childNode = dynamic_cast<PNode*>(ClassList::getObject(childName, CL_PARENT_NODE));
@@ -624,5 +624,5 @@
  * @param parentName the name of the Parent to set to this PNode
  */
-void PNode::setParent (const char* parentName)
+void PNode::setParent (const std::string& parentName)
 {
   PNode* parentNode = dynamic_cast<PNode*>(ClassList::getObject(parentName, CL_PARENT_NODE));
@@ -631,5 +631,5 @@
   else
     PRINTF(2)("Not Found PNode's (%s::%s) new Parent by Name: %s\n",
-              this->getClassName(), this->getName(), parentName);
+        this->getClassName(), this->getName(), parentName.c_str());
 }
 
@@ -680,5 +680,5 @@
  * @param bias the speed to iterate to this new Positions
  */
-void PNode::setParentSoft(const char* parentName, float bias)
+void PNode::setParentSoft(const std::string& parentName, float bias)
 {
   PNode* parentNode = dynamic_cast<PNode*>(ClassList::getObject(parentName, CL_PARENT_NODE));
@@ -699,7 +699,7 @@
  * @param parentMode a String representing this parentingMode
  */
-void PNode::setParentMode (const char* parentingMode)
-{
-  this->setParentMode(PNode::charToParentingMode(parentingMode));
+void PNode::setParentMode (const std::string& parentingMode)
+{
+  this->setParentMode(PNode::stringToParentingMode(parentingMode));
 }
 
@@ -927,5 +927,5 @@
            this->getAbsDirV().y,
            this->getAbsDirV().z,
-           this->parentingModeToChar(parentMode),
+           this->parentingModeToString(parentMode),
            childNodeCount);
   if (depth >= 2 || depth == 0)
@@ -1049,5 +1049,5 @@
  * @return the converted string
  */
-const char* PNode::parentingModeToChar(int parentingMode)
+const char* PNode::parentingModeToString(int parentingMode)
 {
   if (parentingMode == PNODE_LOCAL_ROTATE)
@@ -1068,15 +1068,15 @@
  * @return the int corresponding to the named parentingMode
  */
-PARENT_MODE PNode::charToParentingMode(const char* parentingMode)
-{
-  if (!strcmp(parentingMode, "local-rotate"))
+PARENT_MODE PNode::stringToParentingMode(const std::string& parentingMode)
+{
+  if (parentingMode == "local-rotate")
     return (PNODE_LOCAL_ROTATE);
-  else  if (!strcmp(parentingMode, "rotate-movement"))
+  else  if (parentingMode == "rotate-movement")
     return (PNODE_ROTATE_MOVEMENT);
-  else  if (!strcmp(parentingMode, "movement"))
+  else  if (parentingMode == "movement")
     return (PNODE_MOVEMENT);
-  else  if (!strcmp(parentingMode, "all"))
+  else  if (parentingMode == "all")
     return (PNODE_ALL);
-  else  if (!strcmp(parentingMode, "rotate-and-move"))
+  else  if (parentingMode == "rotate-and-move")
     return (PNODE_ROTATE_AND_MOVE);
 }
Index: trunk/src/lib/coord/p_node.h
===================================================================
--- trunk/src/lib/coord/p_node.h	(revision 7201)
+++ trunk/src/lib/coord/p_node.h	(revision 7221)
@@ -143,5 +143,5 @@
   // PARENTING //
   void addChild (PNode* child);
-  void addChild (const char* childName);
+  void addChild (const std::string& childName);
   void removeChild (PNode* child);
   void removeNode();
@@ -151,5 +151,5 @@
   /** @param parent the new parent of this node */
   inline void setParent (PNode* parent) { parent->addChild(this); };
-  void setParent (const char* parentName);
+  void setParent (const std::string& parentName);
   /** @returns the parent of this PNode */
   inline PNode* getParent () const { return this->parent; };
@@ -158,9 +158,9 @@
 
   void setParentSoft(PNode* parentNode, float bias = 1.0);
-  void setParentSoft(const char* parentName, float bias = 1.0);
+  void setParentSoft(const std::string& parentName, float bias = 1.0);
 
   // PARENTING_MODE AND OTHER FLAGS //
   void setParentMode (PARENT_MODE parentMode);
-  void setParentMode (const char* parentingMode);
+  void setParentMode (const std::string& parentingMode);
   /** @returns the Parenting mode of this node */
   int getParentMode() const { return 0x000f & this->parentMode; };
@@ -183,6 +183,6 @@
 
   // HELPER_FUNCTIONS //
-  static const char* parentingModeToChar(int parentingMode);
-  static PARENT_MODE charToParentingMode(const char* parentingMode);
+  static const char* parentingModeToString(int parentingMode);
+  static PARENT_MODE stringToParentingMode(const std::string& parentingMode);
   float distance(const PNode* node) const { return (this->getAbsCoor() - node->getAbsCoor()).len(); };
 
Index: trunk/src/lib/event/key_mapper.cc
===================================================================
--- trunk/src/lib/event/key_mapper.cc	(revision 7201)
+++ trunk/src/lib/event/key_mapper.cc	(revision 7221)
@@ -129,5 +129,5 @@
  * @param filename: The path and name of the file to load the bindings from
 */
-void KeyMapper::loadKeyBindings (const char* fileName)
+void KeyMapper::loadKeyBindings (const std::string& fileName)
 {
   IniParser parser(fileName);
@@ -145,5 +145,5 @@
 
   iniParser->firstVar();
-  while(iniParser->getCurrentName())
+  while(iniParser->getCurrentName() != "")
   {
     PRINTF(3)("Keys: Parsing %s, %s now.\n", iniParser->getCurrentName(), iniParser->getCurrentValue());
@@ -164,5 +164,5 @@
 
   iniParser->firstVar();
-  while(iniParser->getCurrentName())
+  while(iniParser->getCurrentName() != "")
   {
     PRINTF(3)("MISC: Parsing %s, %s now.\n", iniParser->getCurrentName(), iniParser->getCurrentValue());
@@ -177,5 +177,5 @@
  * @param the name of the button
 */
-int* KeyMapper::nameToIndex (const char* name)
+int* KeyMapper::nameToIndex (const std::string& name)
 {
   coord[0] = -1;
@@ -199,9 +199,9 @@
  * @param id of the key
 */
-void KeyMapper::mapKeys(const char* name, int* index)
+void KeyMapper::mapKeys(const std::string& name, int* index)
 {
   for( int i = 0; map[i].pValue != NULL; ++i )
     {
-      if( !strcmp (name, map[i].pName))
+      if( name == map[i].pName)
       {
         if( index[0] == 0)
Index: trunk/src/lib/event/key_mapper.h
===================================================================
--- trunk/src/lib/event/key_mapper.h	(revision 7201)
+++ trunk/src/lib/event/key_mapper.h	(revision 7221)
@@ -29,5 +29,5 @@
   virtual ~KeyMapper();
 
-  void loadKeyBindings(const char* fileName = NULL);
+  void loadKeyBindings(const std::string& fileName = "" );
   void loadKeyBindings(IniParser* iniParser);
 
@@ -35,6 +35,6 @@
 
  private:
-  int* nameToIndex (const char* name);
-  void mapKeys(const char* name, int* index);
+  int* nameToIndex (const std::string& name);
+  void mapKeys(const std::string& name, int* index);
 
  public:
Index: trunk/src/lib/event/key_names.cc
===================================================================
--- trunk/src/lib/event/key_names.cc	(revision 7201)
+++ trunk/src/lib/event/key_names.cc	(revision 7221)
@@ -23,11 +23,11 @@
 using namespace std;
 
-int buttonnameToSDLB(const char* name)
+int buttonnameToSDLB(const std::string& name)
 {
-        if( !strcmp (name, "BUTTON_LEFT")) return EV_MOUSE_BUTTON_LEFT;
-        if( !strcmp (name, "BUTTON_MIDDLE")) return EV_MOUSE_BUTTON_MIDDLE;
-        if( !strcmp (name, "BUTTON_RIGHT")) return EV_MOUSE_BUTTON_RIGHT;
-        if( !strcmp (name, "BUTTON_WHEELUP")) return EV_MOUSE_BUTTON_WHEELUP;
-        if( !strcmp (name, "BUTTON_WHEELDOWN")) return EV_MOUSE_BUTTON_WHEELDOWN;
+        if((name == "BUTTON_LEFT")) return EV_MOUSE_BUTTON_LEFT;
+        if((name == "BUTTON_MIDDLE")) return EV_MOUSE_BUTTON_MIDDLE;
+        if((name == "BUTTON_RIGHT")) return EV_MOUSE_BUTTON_RIGHT;
+        if((name == "BUTTON_WHEELUP")) return EV_MOUSE_BUTTON_WHEELUP;
+        if((name == "BUTTON_WHEELDOWN")) return EV_MOUSE_BUTTON_WHEELDOWN;
         return -1;
 }
@@ -43,143 +43,143 @@
 }
 
-int keynameToSDLK(const char* name)
+int keynameToSDLK(const std::string& name)
 {
-        if( !strcmp (name, "BACKSPACE")) return SDLK_BACKSPACE;
-        if( !strcmp (name, "TAB")) return SDLK_TAB;
-        if( !strcmp (name, "CLEAR")) return SDLK_CLEAR;
-        if( !strcmp (name, "RETURN")) return SDLK_RETURN;
-        if( !strcmp (name, "ESCAPE")) return SDLK_ESCAPE;
-        if( !strcmp (name, "SPACE")) return SDLK_SPACE;
-        if( !strcmp (name, "EXCLAIM")) return SDLK_EXCLAIM;
-        if( !strcmp (name, "QUOTEDBL")) return SDLK_QUOTEDBL;
-        if( !strcmp (name, "HASH")) return SDLK_HASH;
-        if( !strcmp (name, "PAUSE")) return SDLK_PAUSE;
-        if( !strcmp (name, "DOLLAR")) return SDLK_DOLLAR;
-        if( !strcmp (name, "AMPERSAND")) return SDLK_AMPERSAND;
-        if( !strcmp (name, "QUOTE")) return SDLK_QUOTE;
-        if( !strcmp (name, "LEFTPAREN")) return SDLK_LEFTPAREN;
-        if( !strcmp (name, "RIGHTPAREN")) return SDLK_RIGHTPAREN;
-        if( !strcmp (name, "ASTERISK")) return SDLK_ASTERISK;
-        if( !strcmp (name, "PLUS")) return SDLK_PLUS;
-        if( !strcmp (name, "COMMA")) return SDLK_COMMA;
-        if( !strcmp (name, "MINUS")) return SDLK_MINUS;
-        if( !strcmp (name, "PERIOD")) return SDLK_PERIOD;
-        if( !strcmp (name, "SLASH")) return SDLK_SLASH;
-        if( !strcmp (name, "0")) return SDLK_0;
-        if( !strcmp (name, "1")) return SDLK_1;
-        if( !strcmp (name, "2")) return SDLK_2;
-        if( !strcmp (name, "3")) return SDLK_3;
-        if( !strcmp (name, "4")) return SDLK_4;
-        if( !strcmp (name, "5")) return SDLK_5;
-        if( !strcmp (name, "6")) return SDLK_6;
-        if( !strcmp (name, "7")) return SDLK_7;
-        if( !strcmp (name, "8")) return SDLK_8;
-        if( !strcmp (name, "9")) return SDLK_9;
-        if( !strcmp (name, "COLON")) return SDLK_COLON;
-        if( !strcmp (name, "SEMICOLON")) return SDLK_SEMICOLON;
-        if( !strcmp (name, "LESS")) return SDLK_LESS;
-        if( !strcmp (name, "EQUALS")) return SDLK_EQUALS;
-        if( !strcmp (name, "GREATER")) return SDLK_GREATER;
-        if( !strcmp (name, "QUESTION")) return SDLK_QUESTION;
-        if( !strcmp (name, "AT")) return SDLK_AT;
-        if( !strcmp (name, "LEFTBRACKET")) return SDLK_LEFTBRACKET;
-        if( !strcmp (name, "BACKSLASH")) return SDLK_BACKSLASH;
-        if( !strcmp (name, "RIGHTBRACKET")) return SDLK_RIGHTBRACKET;
-        if( !strcmp (name, "CARET")) return SDLK_CARET;
-        if( !strcmp (name, "UNDERSCORE")) return SDLK_UNDERSCORE;
-        if( !strcmp (name, "BACKQUOTE")) return SDLK_BACKQUOTE;
-        if( !strcmp (name, "a")) return SDLK_a;
-        if( !strcmp (name, "b")) return SDLK_b;
-        if( !strcmp (name, "c")) return SDLK_c;
-        if( !strcmp (name, "d")) return SDLK_d;
-        if( !strcmp (name, "e")) return SDLK_e;
-        if( !strcmp (name, "f")) return SDLK_f;
-        if( !strcmp (name, "g")) return SDLK_g;
-        if( !strcmp (name, "h")) return SDLK_h;
-        if( !strcmp (name, "i")) return SDLK_i;
-        if( !strcmp (name, "j")) return SDLK_j;
-        if( !strcmp (name, "k")) return SDLK_k;
-        if( !strcmp (name, "l")) return SDLK_l;
-        if( !strcmp (name, "m")) return SDLK_m;
-        if( !strcmp (name, "n")) return SDLK_n;
-        if( !strcmp (name, "o")) return SDLK_o;
-        if( !strcmp (name, "p")) return SDLK_p;
-        if( !strcmp (name, "q")) return SDLK_q;
-        if( !strcmp (name, "r")) return SDLK_r;
-        if( !strcmp (name, "s")) return SDLK_s;
-        if( !strcmp (name, "t")) return SDLK_t;
-        if( !strcmp (name, "u")) return SDLK_u;
-        if( !strcmp (name, "v")) return SDLK_v;
-        if( !strcmp (name, "w")) return SDLK_w;
-        if( !strcmp (name, "x")) return SDLK_x;
-        if( !strcmp (name, "y")) return SDLK_y;
-        if( !strcmp (name, "z")) return SDLK_z;
-        if( !strcmp (name, "DELETE")) return SDLK_DELETE;
-        if( !strcmp (name, "KP0")) return SDLK_KP0;
-        if( !strcmp (name, "KP1")) return SDLK_KP1;
-        if( !strcmp (name, "KP2")) return SDLK_KP2;
-        if( !strcmp (name, "KP3")) return SDLK_KP3;
-        if( !strcmp (name, "KP4")) return SDLK_KP4;
-        if( !strcmp (name, "KP5")) return SDLK_KP5;
-        if( !strcmp (name, "KP6")) return SDLK_KP6;
-        if( !strcmp (name, "KP7")) return SDLK_KP7;
-        if( !strcmp (name, "KP8")) return SDLK_KP8;
-        if( !strcmp (name, "KP9")) return SDLK_KP9;
-        if( !strcmp (name, "KP_PERIOD")) return SDLK_KP_PERIOD;
-        if( !strcmp (name, "KP_DIVIDE")) return SDLK_KP_DIVIDE;
-        if( !strcmp (name, "KP_MULTIPLY")) return SDLK_KP_MULTIPLY;
-        if( !strcmp (name, "KP_MINUS")) return SDLK_KP_MINUS;
-        if( !strcmp (name, "KP_PLUS")) return SDLK_KP_PLUS;
-        if( !strcmp (name, "KP_ENTER")) return SDLK_KP_ENTER;
-        if( !strcmp (name, "KP_EQUALS")) return SDLK_KP_EQUALS;
-        if( !strcmp (name, "UP")) return SDLK_UP;
-        if( !strcmp (name, "DOWN")) return SDLK_DOWN;
-        if( !strcmp (name, "RIGHT")) return SDLK_RIGHT;
-        if( !strcmp (name, "LEFT")) return SDLK_LEFT;
-        if( !strcmp (name, "INSERT")) return SDLK_INSERT;
-        if( !strcmp (name, "HOME")) return SDLK_HOME;
-        if( !strcmp (name, "END")) return SDLK_END;
-        if( !strcmp (name, "PAGEUP")) return SDLK_PAGEUP;
-        if( !strcmp (name, "PAGEDOWN")) return SDLK_PAGEDOWN;
-        if( !strcmp (name, "F1")) return SDLK_F1;
-        if( !strcmp (name, "F2")) return SDLK_F2;
-        if( !strcmp (name, "F3")) return SDLK_F3;
-        if( !strcmp (name, "F4")) return SDLK_F4;
-        if( !strcmp (name, "F5")) return SDLK_F5;
-        if( !strcmp (name, "F6")) return SDLK_F6;
-        if( !strcmp (name, "F7")) return SDLK_F7;
-        if( !strcmp (name, "F8")) return SDLK_F8;
-        if( !strcmp (name, "F9")) return SDLK_F9;
-        if( !strcmp (name, "F10")) return SDLK_F10;
-        if( !strcmp (name, "F11")) return SDLK_F11;
-        if( !strcmp (name, "F12")) return SDLK_F12;
-        if( !strcmp (name, "F13")) return SDLK_F13;
-        if( !strcmp (name, "F14")) return SDLK_F14;
-        if( !strcmp (name, "F15")) return SDLK_F15;
-        if( !strcmp (name, "NUMLOCK")) return SDLK_NUMLOCK;
-        if( !strcmp (name, "CAPSLOCK")) return SDLK_CAPSLOCK;
-        if( !strcmp (name, "SCROLLOCK")) return SDLK_SCROLLOCK;
-        if( !strcmp (name, "RSHIFT")) return SDLK_RSHIFT;
-        if( !strcmp (name, "LSHIFT")) return SDLK_LSHIFT;
-        if( !strcmp (name, "RCTRL")) return SDLK_RCTRL;
-        if( !strcmp (name, "LCTRL")) return SDLK_LCTRL;
-        if( !strcmp (name, "RALT")) return SDLK_RALT;
-        if( !strcmp (name, "LALT")) return SDLK_LALT;
-        if( !strcmp (name, "RMETA")) return SDLK_RMETA;
-        if( !strcmp (name, "LMETA")) return SDLK_LMETA;
-        if( !strcmp (name, "LSUPER")) return SDLK_LSUPER;
-        if( !strcmp (name, "RSUPER")) return SDLK_RSUPER;
-        if( !strcmp (name, "MODE")) return SDLK_MODE;
-        if( !strcmp (name, "HELP")) return SDLK_HELP;
-        if( !strcmp (name, "PRINT")) return SDLK_PRINT;
-        if( !strcmp (name, "SYSREQ")) return SDLK_SYSREQ;
-        if( !strcmp (name, "BREAK")) return SDLK_BREAK;
-        if( !strcmp (name, "MENU")) return SDLK_MENU;
-        if( !strcmp (name, "POWER")) return SDLK_POWER;
-        if( !strcmp (name, "EURO")) return SDLK_EURO;
+        if((name == "BACKSPACE")) return SDLK_BACKSPACE;
+        if((name == "TAB")) return SDLK_TAB;
+        if((name == "CLEAR")) return SDLK_CLEAR;
+        if((name == "RETURN")) return SDLK_RETURN;
+        if((name == "ESCAPE")) return SDLK_ESCAPE;
+        if((name == "SPACE")) return SDLK_SPACE;
+        if((name == "EXCLAIM")) return SDLK_EXCLAIM;
+        if((name == "QUOTEDBL")) return SDLK_QUOTEDBL;
+        if((name == "HASH")) return SDLK_HASH;
+        if((name == "PAUSE")) return SDLK_PAUSE;
+        if((name == "DOLLAR")) return SDLK_DOLLAR;
+        if((name == "AMPERSAND")) return SDLK_AMPERSAND;
+        if((name == "QUOTE")) return SDLK_QUOTE;
+        if((name == "LEFTPAREN")) return SDLK_LEFTPAREN;
+        if((name == "RIGHTPAREN")) return SDLK_RIGHTPAREN;
+        if((name == "ASTERISK")) return SDLK_ASTERISK;
+        if((name == "PLUS")) return SDLK_PLUS;
+        if((name == "COMMA")) return SDLK_COMMA;
+        if((name == "MINUS")) return SDLK_MINUS;
+        if((name == "PERIOD")) return SDLK_PERIOD;
+        if((name == "SLASH")) return SDLK_SLASH;
+        if((name == "0")) return SDLK_0;
+        if((name == "1")) return SDLK_1;
+        if((name == "2")) return SDLK_2;
+        if((name == "3")) return SDLK_3;
+        if((name == "4")) return SDLK_4;
+        if((name == "5")) return SDLK_5;
+        if((name == "6")) return SDLK_6;
+        if((name == "7")) return SDLK_7;
+        if((name == "8")) return SDLK_8;
+        if((name == "9")) return SDLK_9;
+        if((name == "COLON")) return SDLK_COLON;
+        if((name == "SEMICOLON")) return SDLK_SEMICOLON;
+        if((name == "LESS")) return SDLK_LESS;
+        if((name == "EQUALS")) return SDLK_EQUALS;
+        if((name == "GREATER")) return SDLK_GREATER;
+        if((name == "QUESTION")) return SDLK_QUESTION;
+        if((name == "AT")) return SDLK_AT;
+        if((name == "LEFTBRACKET")) return SDLK_LEFTBRACKET;
+        if((name == "BACKSLASH")) return SDLK_BACKSLASH;
+        if((name == "RIGHTBRACKET")) return SDLK_RIGHTBRACKET;
+        if((name == "CARET")) return SDLK_CARET;
+        if((name == "UNDERSCORE")) return SDLK_UNDERSCORE;
+        if((name == "BACKQUOTE")) return SDLK_BACKQUOTE;
+        if((name == "a")) return SDLK_a;
+        if((name == "b")) return SDLK_b;
+        if((name == "c")) return SDLK_c;
+        if((name == "d")) return SDLK_d;
+        if((name == "e")) return SDLK_e;
+        if((name == "f")) return SDLK_f;
+        if((name == "g")) return SDLK_g;
+        if((name == "h")) return SDLK_h;
+        if((name == "i")) return SDLK_i;
+        if((name == "j")) return SDLK_j;
+        if((name == "k")) return SDLK_k;
+        if((name == "l")) return SDLK_l;
+        if((name == "m")) return SDLK_m;
+        if((name == "n")) return SDLK_n;
+        if((name == "o")) return SDLK_o;
+        if((name == "p")) return SDLK_p;
+        if((name == "q")) return SDLK_q;
+        if((name == "r")) return SDLK_r;
+        if((name == "s")) return SDLK_s;
+        if((name == "t")) return SDLK_t;
+        if((name == "u")) return SDLK_u;
+        if((name == "v")) return SDLK_v;
+        if((name == "w")) return SDLK_w;
+        if((name == "x")) return SDLK_x;
+        if((name == "y")) return SDLK_y;
+        if((name == "z")) return SDLK_z;
+        if((name == "DELETE")) return SDLK_DELETE;
+        if((name == "KP0")) return SDLK_KP0;
+        if((name == "KP1")) return SDLK_KP1;
+        if((name == "KP2")) return SDLK_KP2;
+        if((name == "KP3")) return SDLK_KP3;
+        if((name == "KP4")) return SDLK_KP4;
+        if((name == "KP5")) return SDLK_KP5;
+        if((name == "KP6")) return SDLK_KP6;
+        if((name == "KP7")) return SDLK_KP7;
+        if((name == "KP8")) return SDLK_KP8;
+        if((name == "KP9")) return SDLK_KP9;
+        if((name == "KP_PERIOD")) return SDLK_KP_PERIOD;
+        if((name == "KP_DIVIDE")) return SDLK_KP_DIVIDE;
+        if((name == "KP_MULTIPLY")) return SDLK_KP_MULTIPLY;
+        if((name == "KP_MINUS")) return SDLK_KP_MINUS;
+        if((name == "KP_PLUS")) return SDLK_KP_PLUS;
+        if((name == "KP_ENTER")) return SDLK_KP_ENTER;
+        if((name == "KP_EQUALS")) return SDLK_KP_EQUALS;
+        if((name == "UP")) return SDLK_UP;
+        if((name == "DOWN")) return SDLK_DOWN;
+        if((name == "RIGHT")) return SDLK_RIGHT;
+        if((name == "LEFT")) return SDLK_LEFT;
+        if((name == "INSERT")) return SDLK_INSERT;
+        if((name == "HOME")) return SDLK_HOME;
+        if((name == "END")) return SDLK_END;
+        if((name == "PAGEUP")) return SDLK_PAGEUP;
+        if((name == "PAGEDOWN")) return SDLK_PAGEDOWN;
+        if((name == "F1")) return SDLK_F1;
+        if((name == "F2")) return SDLK_F2;
+        if((name == "F3")) return SDLK_F3;
+        if((name == "F4")) return SDLK_F4;
+        if((name == "F5")) return SDLK_F5;
+        if((name == "F6")) return SDLK_F6;
+        if((name == "F7")) return SDLK_F7;
+        if((name == "F8")) return SDLK_F8;
+        if((name == "F9")) return SDLK_F9;
+        if((name == "F10")) return SDLK_F10;
+        if((name == "F11")) return SDLK_F11;
+        if((name == "F12")) return SDLK_F12;
+        if((name == "F13")) return SDLK_F13;
+        if((name == "F14")) return SDLK_F14;
+        if((name == "F15")) return SDLK_F15;
+        if((name == "NUMLOCK")) return SDLK_NUMLOCK;
+        if((name == "CAPSLOCK")) return SDLK_CAPSLOCK;
+        if((name == "SCROLLOCK")) return SDLK_SCROLLOCK;
+        if((name == "RSHIFT")) return SDLK_RSHIFT;
+        if((name == "LSHIFT")) return SDLK_LSHIFT;
+        if((name == "RCTRL")) return SDLK_RCTRL;
+        if((name == "LCTRL")) return SDLK_LCTRL;
+        if((name == "RALT")) return SDLK_RALT;
+        if((name == "LALT")) return SDLK_LALT;
+        if((name == "RMETA")) return SDLK_RMETA;
+        if((name == "LMETA")) return SDLK_LMETA;
+        if((name == "LSUPER")) return SDLK_LSUPER;
+        if((name == "RSUPER")) return SDLK_RSUPER;
+        if((name == "MODE")) return SDLK_MODE;
+        if((name == "HELP")) return SDLK_HELP;
+        if((name == "PRINT")) return SDLK_PRINT;
+        if((name == "SYSREQ")) return SDLK_SYSREQ;
+        if((name == "BREAK")) return SDLK_BREAK;
+        if((name == "MENU")) return SDLK_MENU;
+        if((name == "POWER")) return SDLK_POWER;
+        if((name == "EURO")) return SDLK_EURO;
         return -1;
 }
 
-const char* SDLKToKeyname( int key)
+const char* SDLKToKeyname(int key)
 {
         if( key == SDLK_BACKSPACE) return "BACKSPACE";
Index: trunk/src/lib/event/key_names.h
===================================================================
--- trunk/src/lib/event/key_names.h	(revision 7201)
+++ trunk/src/lib/event/key_names.h	(revision 7221)
@@ -1,37 +1,39 @@
 /*!
  * @file keynames.h
-  *  Key/button naming functions
-
-                Converts strings to SDLK/SDL_BUTTON values and vice versa
-*/
+ *  Key/button naming functions
+ *
+ * Converts strings to SDLK/SDL_BUTTON values and vice versa
+ */
 #ifndef _KEY_NAMES_H
 #define _KEY_NAMES_H
 
-/**
-      *  converts a button name string to a integer representing the corresponding SDL mouse button identifier
-      * @param name: the name of the mouse button
-      * @return an int containing the SDL identifier of the mouse button or -1 if the button name is not valid
-*/
-int buttonnameToSDLB(const char* name);
+#include <string>
 
 /**
-      *  converst a SDL mouse button identifier to a name string
-      * @param button: an SDL mouse button identifier
-      * @return a pointer to a string containing the name of the mouse button
-*/
+ *  converts a button name string to a integer representing the corresponding SDL mouse button identifier
+ * @param name: the name of the mouse button
+ * @return an int containing the SDL identifier of the mouse button or -1 if the button name is not valid
+ */
+int buttonnameToSDLB(const std::string& name);
+
+/**
+ *  converst a SDL mouse button identifier to a name string
+ * @param button: an SDL mouse button identifier
+ * @return a pointer to a string containing the name of the mouse button
+ */
 const char* SDLBToButtonname( int button);
 
 /**
-      *  converts a key name string to a integer representing the corresponding SDLK sym
-      * @param name: the name of the key
-      * @return the SDLK sym of the named key or -1 if the key name is not valid
-*/
-int keynameToSDLK(const char* name);
+ *  converts a key name string to a integer representing the corresponding SDLK sym
+ * @param name: the name of the key
+ * @return the SDLK sym of the named key or -1 if the key name is not valid
+ */
+int keynameToSDLK(const std::string& name);
 
 /**
-      *  converts an SDLK sym to a name string
-      * @param key: the SDLK sym
-      * @return a pointer to a string containig the name of the key
-*/
+ *  converts an SDLK sym to a name string
+ * @param key: the SDLK sym
+ * @return a pointer to a string containig the name of the key
+ */
 const char* SDLKToKeyname( int key);
 
Index: trunk/src/lib/graphics/effects/fog_effect.cc
===================================================================
--- trunk/src/lib/graphics/effects/fog_effect.cc	(revision 7201)
+++ trunk/src/lib/graphics/effects/fog_effect.cc	(revision 7221)
@@ -126,11 +126,11 @@
  * @param mode the mode character
  */
-GLint FogEffect::charToFogMode(const char* mode)
+GLint FogEffect::stringToFogMode(const std::string& mode)
 {
-  if( !strcmp( "GL_LINEAR", mode))
+  if(mode == "GL_LINEAR")
     return GL_LINEAR;
-  else if( !strcmp("GL_EXP", mode))
+  else if(mode == "GL_EXP")
     return GL_EXP;
-  else if(!strcmp("GL_EXP2", mode) )
+  else if(mode == "GL_EXP2" )
     return GL_EXP2;
   else
Index: trunk/src/lib/graphics/effects/fog_effect.h
===================================================================
--- trunk/src/lib/graphics/effects/fog_effect.h	(revision 7201)
+++ trunk/src/lib/graphics/effects/fog_effect.h	(revision 7221)
@@ -26,5 +26,5 @@
     virtual bool deactivate();
 
-    inline void setFogMode(const char* mode) { this->fogMode = this->charToFogMode(mode); }
+    inline void setFogMode(const std::string& mode) { this->fogMode = this->stringToFogMode(mode); }
     inline void setFogDensity(float density) { this->fogDensity = density; }
     inline void setFogRange(float start, float end) { this->fogStart = start; this->fogEnd = end; }
@@ -33,5 +33,5 @@
 
   private:
-    GLint charToFogMode(const char* mode);
+    GLint stringToFogMode(const std::string& mode);
 
 
Index: trunk/src/lib/graphics/effects/lense_flare.cc
===================================================================
--- trunk/src/lib/graphics/effects/lense_flare.cc	(revision 7201)
+++ trunk/src/lib/graphics/effects/lense_flare.cc	(revision 7221)
@@ -131,5 +131,5 @@
  * @param mode the mode character
  */
-GLint LenseFlare::charToFogMode(const char* mode)
+GLint LenseFlare::stringToFogMode(const std::string& mode)
 {}
 
@@ -147,5 +147,5 @@
  *  7th: Texture of the third burst
  */
-void LenseFlare::addFlare(const char* textureName)
+void LenseFlare::addFlare(const std::string& textureName)
 {
   if( this->flares.size() > LF_MAX_FLARES)
@@ -159,5 +159,5 @@
   bb->setSize(50, 50);
   this->flares.push_back(bb);
-  PRINTF(0)("Added a Lenseflare Billboard with texture %s\n", textureName);
+  PRINTF(4)("Added a Lenseflare Billboard with texture %s\n", textureName.c_str());
 
   // the first flare belongs to the light source
@@ -167,5 +167,5 @@
     bb->setVisibility(true);
   }
-  PRINTF(0)("Finished adding\n", textureName);
+  PRINTF(4)("Finished adding\n");
 }
 
Index: trunk/src/lib/graphics/effects/lense_flare.h
===================================================================
--- trunk/src/lib/graphics/effects/lense_flare.h	(revision 7201)
+++ trunk/src/lib/graphics/effects/lense_flare.h	(revision 7221)
@@ -39,9 +39,9 @@
     virtual void tick(float dt);
 
-    void addFlare(const char* textureName);
+    void addFlare(const std::string& textureName);
 
 
   private:
-    GLint charToFogMode(const char* mode);
+    GLint stringToFogMode(const std::string& mode);
     void setSourceVisibility(bool visibility) ;
 
Index: trunk/src/lib/graphics/graphics_engine.cc
===================================================================
--- trunk/src/lib/graphics/graphics_engine.cc	(revision 7201)
+++ trunk/src/lib/graphics/graphics_engine.cc	(revision 7221)
@@ -78,11 +78,4 @@
   this->screen = NULL;
 
-
-  // Hardware
-  this->hwRenderer = NULL;
-  this->hwVendor = NULL;
-  this->hwVersion = NULL;
-  this->hwExtensions = NULL;
-
   // initialize the Modules
   TextEngine::getInstance();
@@ -103,9 +96,4 @@
   // delete what has to be deleted here
   this->displayFPS( false );
-
-  delete[] this->hwRenderer;
-  delete[] this->hwVendor;
-  delete[] this->hwVersion;
-  delete this->hwExtensions;
 
   //TextEngine
@@ -169,20 +157,20 @@
 {
   // looking if we are in fullscreen-mode
-  const char* fullscreen = iniParser->getVar(CONFIG_NAME_FULLSCREEN, CONFIG_SECTION_VIDEO, "0");
-  if (strchr(fullscreen, '1') || !strcasecmp(fullscreen, "true"))
+  const std::string fullscreen = iniParser->getVar(CONFIG_NAME_FULLSCREEN, CONFIG_SECTION_VIDEO, "0");
+  if (fullscreen[0] == '1' || fullscreen == "true")
     this->fullscreenFlag = SDL_FULLSCREEN;
 
   // looking if we are in fullscreen-mode
-  const char* textures = iniParser->getVar(CONFIG_NAME_TEXTURES, CONFIG_SECTION_VIDEO_ADVANCED, "0");
-  if (strchr(textures, '1') || !strcasecmp(textures, "true"))
-    Texture::setTextureEnableState( true);
+  const std::string textures = iniParser->getVar(CONFIG_NAME_TEXTURES, CONFIG_SECTION_VIDEO_ADVANCED, "0");
+  if (textures[0] == '1' || textures == "true")
+    Texture::setTextureEnableState(true);
   else
     Texture::setTextureEnableState(false);
 
   // searching for a usefull resolution
-  SubString resolution(iniParser->getVar(CONFIG_NAME_RESOLUTION, CONFIG_SECTION_VIDEO, "640x480"), 'x');
+  SubString resolution(iniParser->getVar(CONFIG_NAME_RESOLUTION, CONFIG_SECTION_VIDEO, "640x480").c_str(), 'x'); ///FIXME
   //resolution.debug();
-
-  this->initVideo(atoi(resolution.getString(0)), atoi(resolution.getString(1)), 16);
+  MultiType x = resolution.getString(0), y = resolution.getString(1);
+  this->initVideo(x.getInt(), y.getInt(), 16);
 
   //   GraphicsEffect* fe = new FogEffect(NULL);
@@ -262,16 +250,16 @@
  * @param icon The name of the Icon on the Disc
  */
-void GraphicsEngine::setWindowName(const char* windowName, const char* icon)
-{
-  SDL_Surface* iconSurf = SDL_LoadBMP(icon);
+void GraphicsEngine::setWindowName(const std::string& windowName, const std::string& icon)
+{
+  SDL_Surface* iconSurf = SDL_LoadBMP(icon.c_str());
   if (iconSurf != NULL)
   {
     Uint32 colorkey = SDL_MapRGB(iconSurf->format, 0, 0, 0);
     SDL_SetColorKey(iconSurf, SDL_SRCCOLORKEY, colorkey);
-    SDL_WM_SetIcon(iconSurf,NULL);
+    SDL_WM_SetIcon(iconSurf, NULL);
     SDL_FreeSurface(iconSurf);
   }
 
-  SDL_WM_SetCaption (windowName, icon);
+  SDL_WM_SetCaption (windowName.c_str(), icon.c_str());
 }
 
@@ -312,28 +300,24 @@
   //  printf("%s %s %s\n %s", renderer, vendor, version, extensions);
 
-  if (this->hwRenderer == NULL && renderer != NULL)
-  {
-    this->hwRenderer = new char[strlen(renderer)+1];
-    strcpy(this->hwRenderer, renderer);
-  }
-  if (this->hwVendor == NULL && vendor != NULL)
-  {
-    this->hwVendor = new char[strlen(vendor)+1];
-    strcpy(this->hwVendor, vendor);
-  }
-  if (this->hwVersion == NULL && version != NULL)
-  {
-    this->hwVersion = new char[strlen(version)+11];
-    strcpy(this->hwVersion, version);
-  }
-
-  if (this->hwExtensions == NULL && extensions != NULL)
-    this->hwExtensions = new SubString((char*)glGetString(GL_EXTENSIONS), " \n\t,");
+  if (renderer != NULL)
+  {
+    this->hwRenderer == renderer;
+  }
+  if (vendor != NULL)
+  {
+    this->hwVendor == vendor;
+  }
+  if (version != NULL)
+  {
+    this->hwVersion == version;
+  }
+
+  if (extensions != NULL)
+    this->hwExtensions.split(extensions, " \n\t,");
 
   PRINT(4)("Running on : vendor: %s,  renderer: %s,  version:%s\n", vendor, renderer, version);
   PRINT(4)("Extensions:\n");
-  if (this->hwExtensions != NULL)
-    for (unsigned int i = 0; i < this->hwExtensions->getCount(); i++)
-      PRINT(4)("%d: %s\n", i, this->hwExtensions->getString(i));
+  for (unsigned int i = 0; i < this->hwExtensions.getCount(); i++)
+    PRINT(4)("%d: %s\n", i, this->hwExtensions.getString(i).c_str());
 
 
@@ -529,10 +513,9 @@
  * @return true if it is, false otherwise
  */
-bool GraphicsEngine::hwSupportsEXT(const char* extension)
-{
-  if (this->hwExtensions != NULL)
-    for (unsigned int i = 0; i < this->hwExtensions->getCount(); i++)
-      if (!strcmp(extension, this->hwExtensions->getString(i)))
-        return true;
+bool GraphicsEngine::hwSupportsEXT(const std::string& extension)
+{
+  for (unsigned int i = 0; i < this->hwExtensions.getCount(); i++)
+    if ( this->hwExtensions.getString(i) == extension)
+      return true;
   return false;
 }
@@ -587,5 +570,5 @@
 void GraphicsEngine::draw() const
 {
-//  LightManager::getInstance()->draw();
+  //  LightManager::getInstance()->draw();
 
   GraphicsEngine::storeMatrices();
@@ -668,7 +651,7 @@
   switch (event.type)
   {
-      case EV_VIDEO_RESIZE:
-      this->resolutionChanged(event.resize);
-      break;
-  }
-}
+  case EV_VIDEO_RESIZE:
+    this->resolutionChanged(event.resize);
+    break;
+  }
+}
Index: trunk/src/lib/graphics/graphics_engine.h
===================================================================
--- trunk/src/lib/graphics/graphics_engine.h	(revision 7201)
+++ trunk/src/lib/graphics/graphics_engine.h	(revision 7221)
@@ -14,11 +14,11 @@
 #include "sdlincl.h"
 #include "glincl.h"
+#include <list>
 
-#include <list>
+#include "substring.h"
 
 // Forward Declaration
 class Text;
 class IniParser;
-class SubString;
 class WorldEntity;
 class GraphicsEffect;
@@ -41,5 +41,5 @@
     int initFromIniFile(IniParser* iniParser);
 
-    void setWindowName(const char* windowName, const char* icon);
+    void setWindowName(const std::string& windowName, const std::string& icon);
 
     int setResolution(int width, int height, int bpp);
@@ -74,5 +74,5 @@
 
     void listModes();
-    bool hwSupportsEXT(const char* extension);
+    bool hwSupportsEXT(const std::string& extension);
 
     /** @brief swaps the GL_BUFFERS */
@@ -116,8 +116,8 @@
 
     // HARDWARE-Settings:
-    char*                      hwRenderer;         //!< HW-renderer-string
-    char*                      hwVendor;           //!< HW-vendor-string
-    char*                      hwVersion;          //!< HW-version-string
-    SubString*                 hwExtensions;       //!< All suported Extensions.
+    std::string                hwRenderer;         //!< HW-renderer-string
+    std::string                hwVendor;           //!< HW-vendor-string
+    std::string                hwVersion;          //!< HW-version-string
+    SubString                  hwExtensions;       //!< All suported Extensions.
 
     // FPS-related
Index: trunk/src/lib/graphics/importer/height_map.cc
===================================================================
--- trunk/src/lib/graphics/importer/height_map.cc	(revision 7201)
+++ trunk/src/lib/graphics/importer/height_map.cc	(revision 7221)
@@ -333,11 +333,12 @@
 }
 
-HeightMap::HeightMap(const char* height_map_name = NULL) : VertexArrayModel()
+HeightMap::HeightMap(const std::string& height_map_name = "")
+  : VertexArrayModel()
 {
    this->setClassID(CL_HEIGHT_MAP, "HeightMap");
-   heightMap =  IMG_Load(height_map_name);
+   heightMap =  IMG_Load(height_map_name.c_str());
    if(heightMap!=NULL) {
 
-                 PRINTF(0)("loading Image %s\n", height_map_name);
+     PRINTF(0)("loading Image %s\n", height_map_name.c_str());
                  PRINTF(0)("width : %i\n", heightMap->w);
                  PRINTF(0)("height : %i\n", heightMap->h);
@@ -350,5 +351,5 @@
                 }
 
-     else       PRINTF(4)("oops! couldn't load %s for some reason.\n", height_map_name);
+                else       PRINTF(4)("oops! couldn't load %s for some reason.\n", height_map_name.c_str());
 
 
@@ -361,12 +362,13 @@
 }
 
-HeightMap::HeightMap(const char* height_map_name = NULL, const char* colour_map_name = NULL) : VertexArrayModel()
+HeightMap::HeightMap(const std::string& height_map_name = NULL, const std::string& colour_map_name = NULL)
+  : VertexArrayModel()
 {
 this->setClassID(CL_HEIGHT_MAP, "HeightMap");
 
-   heightMap =  IMG_Load(height_map_name);
+   heightMap =  IMG_Load(height_map_name.c_str());
    if(heightMap!=NULL) {
 
-                 PRINTF(0)("loading Image %s\n", height_map_name);
+     PRINTF(0)("loading Image %s\n", height_map_name.c_str());
                  PRINTF(0)("width : %i\n", heightMap->w);
                  PRINTF(0)("height : %i\n", heightMap->h);
@@ -379,5 +381,5 @@
                 }
 
-     else       PRINTF(4)("oops! couldn't load %s for some reason.\n", height_map_name);
+                else       PRINTF(4)("oops! couldn't load %s for some reason.\n", height_map_name.c_str());
 
 
@@ -385,12 +387,12 @@
 
   colourMap=NULL;
-  if(colour_map_name != NULL)
+  if(colour_map_name != "")
   {
-  colourMap = IMG_Load(colour_map_name);
+    colourMap = IMG_Load(colour_map_name.c_str());
   }
 
   if(colourMap != NULL)
                 {
-                 PRINTF(0)("loading Image %s\n", colour_map_name);
+                  PRINTF(0)("loading Image %s\n", colour_map_name.c_str());
                  PRINTF(0)("width : %i\n", colourMap->w);
                  PRINTF(0)("height : %i\n", colourMap->h);
Index: trunk/src/lib/graphics/importer/height_map.h
===================================================================
--- trunk/src/lib/graphics/importer/height_map.h	(revision 7201)
+++ trunk/src/lib/graphics/importer/height_map.h	(revision 7221)
@@ -59,5 +59,5 @@
 void load();
 void load(int Mode);
-void load(const char*, int Mode);
+void load(const std::string&, int Mode);
 void scale( Vector V);
 void setAbsCoor(Vector V);
@@ -65,6 +65,6 @@
 float getNormal(float x, float y);
 HeightMap();
-HeightMap(const char*);
-HeightMap(const char*, const char*);
+HeightMap(const std::string&);
+HeightMap(const std::string&, const std::string&);
 virtual ~HeightMap();
 
Index: trunk/src/lib/graphics/importer/material.cc
===================================================================
--- trunk/src/lib/graphics/importer/material.cc	(revision 7201)
+++ trunk/src/lib/graphics/importer/material.cc	(revision 7221)
@@ -34,5 +34,5 @@
  * @param mtlName Name of the Material to be added to the Material List
  */
-Material::Material (const char* mtlName)
+Material::Material (const std::string& mtlName)
 {
   this->setClassID(CL_MATERIAL, "Material");
@@ -278,5 +278,5 @@
  * @param pathName The Path to add.
 */
-void Material::addTexturePath(const char* pathName)
+void Material::addTexturePath(const std::string& pathName)
 {
   ResourceManager::getInstance()->addImageDir(pathName);
@@ -289,5 +289,5 @@
  * @param dMap the Name of the Image to Use
 */
-void Material::setDiffuseMap(const char* dMap, GLenum target)
+void Material::setDiffuseMap(const std::string& dMap, GLenum target)
 {
   PRINTF(5)("setting Diffuse Map %s\n", dMap);
@@ -297,5 +297,5 @@
   //! @todo check if RESOURCE MANAGER is availiable
   //! @todo Textures from .mtl-file need special care.
-  if (dMap != NULL)
+  if (!dMap.empty())
     this->diffuseTexture = (Texture*)ResourceManager::getInstance()->load(dMap, IMAGE, RP_GAME, (int)target);
   else
@@ -308,5 +308,5 @@
    @todo implement this
 */
-void Material::setAmbientMap(const char* aMap, GLenum target)
+void Material::setAmbientMap(const std::string& aMap, GLenum target)
 {
   SDL_Surface* ambientMap;
@@ -319,5 +319,5 @@
    @todo implement this
 */
-void Material::setSpecularMap(const char* sMap, GLenum target)
+void Material::setSpecularMap(const std::string& sMap, GLenum target)
 {
   SDL_Surface* specularMap;
@@ -330,6 +330,6 @@
    @todo implemet this
 */
-void Material::setBump(const char* bump)
-{
-
-}
+void Material::setBump(const std::string& bump)
+{
+
+}
Index: trunk/src/lib/graphics/importer/material.h
===================================================================
--- trunk/src/lib/graphics/importer/material.h	(revision 7201)
+++ trunk/src/lib/graphics/importer/material.h	(revision 7221)
@@ -26,5 +26,5 @@
 {
  public:
-  Material (const char* mtlName = NULL);
+  Material (const std::string& mtlName = "");
   virtual ~Material ();
 
@@ -49,11 +49,11 @@
 
  // MAPPING //
-  void setDiffuseMap(const char* dMap, GLenum target = GL_TEXTURE_2D);
-  void setAmbientMap(const char* aMap, GLenum target = GL_TEXTURE_2D);
-  void setSpecularMap(const char* sMap, GLenum target = GL_TEXTURE_2D);
-  void setBump(const char* bump);
+  void setDiffuseMap(const std::string& dMap, GLenum target = GL_TEXTURE_2D);
+  void setAmbientMap(const std::string& aMap, GLenum target = GL_TEXTURE_2D);
+  void setSpecularMap(const std::string& sMap, GLenum target = GL_TEXTURE_2D);
+  void setBump(const std::string& bump);
   GLuint getDiffuseTexture() const { return (this->diffuseTexture)? this->diffuseTexture->getTexture() : 0; };
 
-  static void addTexturePath(const char* pathName);
+  static void addTexturePath(const std::string& pathName);
 
   private:
Index: trunk/src/lib/graphics/importer/md2Model.cc
===================================================================
--- trunk/src/lib/graphics/importer/md2Model.cc	(revision 7201)
+++ trunk/src/lib/graphics/importer/md2Model.cc	(revision 7221)
@@ -75,9 +75,10 @@
   \brief simple constructor initializing all variables
 */
-MD2Model::MD2Model(const char* modelFileName, const char* skinFileName, float scale)
+MD2Model::MD2Model(const std::string& modelFileName, const std::string& skinFileName, float scale)
 {
   this->setClassID(CL_MD2_MODEL, "MD2Model");
   /* this creates the data container via ressource manager */
-  this->data = (MD2Data*)ResourceManager::getInstance()->load(modelFileName, MD2, RP_GAME, skinFileName, scale);
+  if (!modelFileName.empty())
+    this->data = (MD2Data*)ResourceManager::getInstance()->load(modelFileName, MD2, RP_GAME, skinFileName, scale);
   if( unlikely(this->data == NULL))
     PRINTF(0)("The model was not found, MD2Model Loader finished abnormaly. Update the data-repos\n");
@@ -352,6 +353,6 @@
 {
   PRINT(0)("\n==========================| MD2Model::debug() |===\n");
-  PRINT(0)("=  Model FileName:\t%s\n", this->data->fileName);
-  PRINT(0)("=  Skin FileName:\t%s\n", this->data->skinFileName);
+  PRINT(0)("=  Model FileName:\t%s\n", this->data->fileName.c_str());
+  PRINT(0)("=  Skin FileName:\t%s\n", this->data->skinFileName.c_str());
   PRINT(0)("=  Size in Memory:\t%i Bytes\n", this->data->header->frameSize * this->data->header->numFrames + 64); // 64bytes is the header size
   PRINT(0)("=  Number of Vertices:\t%i\n", this->data->header->numVertices);
@@ -370,5 +371,5 @@
   \brief simple constructor
 */
-MD2Data::MD2Data(const char* modelFileName, const char* skinFileName, float scale)
+MD2Data::MD2Data(const std::string& modelFileName, const std::string& skinFileName, float scale)
 {
   scale *= 0.1f;
@@ -387,6 +388,6 @@
   this->scaleFactor = scale;
 
-  this->fileName = NULL;
-  this->skinFileName = NULL;
+  this->fileName = "";
+  this->skinFileName = "";
   this->loadModel(modelFileName);
   this->loadSkin(skinFileName);
@@ -401,6 +402,4 @@
 MD2Data::~MD2Data()
 {
-  delete [] this->fileName;
-  delete [] this->skinFileName;
   delete this->header;
 
@@ -419,5 +418,5 @@
   \return true if success
 */
-bool MD2Data::loadModel(const char* fileName)
+bool MD2Data::loadModel(const std::string& fileName)
 {
   FILE *pFile;                            //file stream
@@ -428,8 +427,8 @@
 
   //! @todo this chek should include deleting a loaded model (eventually)
-  if (fileName == NULL)
+  if (fileName.empty())
     return false;
 
-  pFile = fopen(fileName, "rb");
+  pFile = fopen(fileName.c_str(), "rb");
   if( unlikely(!pFile))
     {
@@ -442,10 +441,9 @@
   if( unlikely(this->header->version != MD2_VERSION) && unlikely(this->header->ident != MD2_IDENT))
     {
-      PRINTF(1)("Couldn't load file %s: invalid file format: stop loading\n", fileName);
+      PRINTF(1)("Couldn't load file %s: invalid file format: stop loading\n", fileName.c_str());
       return false;
     }
 
-  this->fileName = new char[strlen(fileName)+1];
-  strcpy(this->fileName, fileName);
+  this->fileName =fileName;
   /* got the data: map it to locals */
   this->numFrames = this->header->numFrames;
@@ -507,14 +505,13 @@
   \return true if success
 */
-bool MD2Data::loadSkin(const char* fileName)
-{
-  if( fileName == NULL)
-    {
-      this->skinFileName = NULL;
+bool MD2Data::loadSkin(const std::string& fileName)
+{
+  if( fileName.empty())
+    {
+      this->skinFileName = "";
       return false;
     }
 
-  this->skinFileName = new char[strlen(fileName)+1];
-  strcpy(this->skinFileName, fileName);
+  this->skinFileName = fileName;
 
   this->material.setName("md2ModelMaterial");
Index: trunk/src/lib/graphics/importer/md2Model.h
===================================================================
--- trunk/src/lib/graphics/importer/md2Model.h	(revision 7201)
+++ trunk/src/lib/graphics/importer/md2Model.h	(revision 7221)
@@ -189,10 +189,10 @@
 {
  public:
-   MD2Data(const char* modelFileName, const char* skinFileName, float scale = 1.0f);
+   MD2Data(const std::string& modelFileName, const std::string& skinFileName, float scale = 1.0f);
   virtual ~MD2Data();
 
  private:
-  bool loadModel(const char* fileName);
-  bool loadSkin(const char* fileName = NULL);
+   bool loadModel(const std::string& fileName);
+   bool loadSkin(const std::string& fileName = "");
 
  public:
@@ -202,6 +202,6 @@
   int                numTexCoor;            //!< number of texture coordinates
   int                numGLCommands;         //!< number of gl commands in the glList (tells how to draw)
-  char*              fileName;              //!< file name of the model File
-  char*              skinFileName;          //!< file name of the skin file
+  std::string        fileName;              //!< file name of the model File
+  std::string        skinFileName;          //!< file name of the skin file
   MD2Header*         header;                //!< the header file
 
@@ -223,5 +223,5 @@
 
 public:
-  MD2Model(const char* modelFileName, const char* skinFileName = NULL, float scale = 1.0f);
+  MD2Model(const std::string& modelFileName, const std::string& skinFileName = "", float scale = 1.0f);
   virtual ~MD2Model();
 
Index: trunk/src/lib/graphics/importer/media_container.cc
===================================================================
--- trunk/src/lib/graphics/importer/media_container.cc	(revision 7201)
+++ trunk/src/lib/graphics/importer/media_container.cc	(revision 7221)
@@ -34,5 +34,5 @@
  * Default constructor
  */
-MediaContainer::MediaContainer(const char* filename)
+MediaContainer::MediaContainer(const std::string& filename)
 {
   // set the class id for the base object
@@ -41,6 +41,6 @@
   fps = 0;
   mediaLoaded = false;
-
-  this->loadMedia(filename);
+  if (!filename.empty())
+    this->loadMedia(filename);
 }
 
@@ -84,14 +84,14 @@
 }
 
-bool MediaContainer::loadMedia(const char* filename)
+bool MediaContainer::loadMedia(const std::string& filename)
 {
   this->unloadMedia();
 
-  if(filename == NULL)
+  if(filename.empty())
     return false;
   // check whether file exists
   if(!ResourceManager::isInDataDir(filename))
   {
-    PRINTF(1)("Could not find %s\n", filename);
+    PRINTF(1)("Could not find %s\n", filename.c_str());
     return false;
   }
@@ -101,7 +101,7 @@
 
   // Open video file
-  if (av_open_input_file(&format_context, ResourceManager::getFullName(filename), NULL, 0, NULL) !=0 )
-  {
-    PRINTF(1)("Could not open %s\n", ResourceManager::getFullName(filename));
+  if (av_open_input_file(&format_context, ResourceManager::getFullName(filename).c_str(), NULL, 0, NULL) !=0 )
+  {
+    PRINTF(1)("Could not open %s\n", ResourceManager::getFullName(filename).c_str());
     return false;
   }
@@ -110,5 +110,5 @@
   if (av_find_stream_info(format_context) < 0)
   {
-    PRINTF(1)("Could not find stream information in %s\n", ResourceManager::getFullName(filename));
+    PRINTF(1)("Could not find stream information in %s\n", ResourceManager::getFullName(filename).c_str());
     return false;
   }
@@ -116,8 +116,8 @@
   // Find the first video stream and take it
   video_stream = av_find_default_stream_index(format_context);
-  
+
   if(video_stream == -1)
   {
-    PRINTF(1)("Could not find a video stream in %s\n", ResourceManager::getFullName(filename));
+    PRINTF(1)("Could not find a video stream in %s\n", ResourceManager::getFullName(filename).c_str());
     return false;
   }
@@ -202,5 +202,5 @@
       // Free the packet that was allocated by av_read_frame
       av_free_packet(&packet);
-      
+
       // Did we get a video frame?
       if(frame_finished)
@@ -216,5 +216,5 @@
           memcpy(&data[i*codec_context->width*3],
                  ((AVPicture*)RGB_frame)->data[0]+i *
-                 ((AVPicture*)RGB_frame)->linesize[0], 
+                 ((AVPicture*)RGB_frame)->linesize[0],
                   codec_context->width*sizeof(uint8_t)*3);
 
@@ -258,4 +258,4 @@
   }
   else
-    return NULL;
-}
+    return 0;
+}
Index: trunk/src/lib/graphics/importer/media_container.h
===================================================================
--- trunk/src/lib/graphics/importer/media_container.h	(revision 7201)
+++ trunk/src/lib/graphics/importer/media_container.h	(revision 7221)
@@ -44,8 +44,8 @@
 public:
 
-  MediaContainer(const char* filename = NULL);
+  MediaContainer(const std::string& filename = "");
   virtual ~MediaContainer();
 
-  bool loadMedia(const char* filename);
+  bool loadMedia(const std::string& filename);
   void loadFrames();
 
Index: trunk/src/lib/graphics/importer/movie_player.cc
===================================================================
--- trunk/src/lib/graphics/importer/movie_player.cc	(revision 7201)
+++ trunk/src/lib/graphics/importer/movie_player.cc	(revision 7221)
@@ -31,5 +31,5 @@
 
 
-MoviePlayer::MoviePlayer(const char* filename)
+MoviePlayer::MoviePlayer(const std::string& filename)
 {
   // set the class id for the base object
@@ -42,6 +42,6 @@
   mediaLoaded = false;
 
-  this->loadMovie(filename);
-
+  if (!filename.empty())
+    this->loadMovie(filename);
 }
 
@@ -83,14 +83,14 @@
 
 
-bool MoviePlayer::loadMovie(const char* filename)
+bool MoviePlayer::loadMovie(const std::string& filename)
 {
   this->unloadMedia();
 
-  if(filename == NULL)
+  if(filename.empty())
     return false;
   // check whether file exists
   if(!ResourceManager::isInDataDir(filename))
   {
-    PRINTF(1)("Could not find %s\n", filename);
+    PRINTF(1)("Could not find %s\n", filename.c_str());
     return false;
   }
@@ -100,7 +100,7 @@
 
   // Open video file
-  if (av_open_input_file(&format_context, ResourceManager::getFullName(filename), NULL, 0, NULL) !=0 )
-  {
-    PRINTF(1)("Could not open %s\n", ResourceManager::getFullName(filename));
+  if (av_open_input_file(&format_context, ResourceManager::getFullName(filename).c_str(), NULL, 0, NULL) !=0 )
+  {
+    PRINTF(1)("Could not open %s\n", ResourceManager::getFullName(filename).c_str());
     return false;
   }
@@ -109,5 +109,5 @@
   if (av_find_stream_info(format_context) < 0)
   {
-    PRINTF(1)("Could not find stream information in %s\n", ResourceManager::getFullName(filename));
+    PRINTF(1)("Could not find stream information in %s\n", ResourceManager::getFullName(filename).c_str());
     return false;
   }
@@ -118,5 +118,5 @@
   if(video_stream == -1)
   {
-    PRINTF(1)("Could not find a video stream in %s\n", ResourceManager::getFullName(filename));
+    PRINTF(1)("Could not find a video stream in %s\n", ResourceManager::getFullName(filename).c_str());
     return false;
   }
Index: trunk/src/lib/graphics/importer/movie_player.h
===================================================================
--- trunk/src/lib/graphics/importer/movie_player.h	(revision 7201)
+++ trunk/src/lib/graphics/importer/movie_player.h	(revision 7221)
@@ -58,8 +58,8 @@
 public:
 
-  MoviePlayer(const char* filename = NULL);
+  MoviePlayer(const std::string& filename = "");
   virtual ~MoviePlayer();
 
-  bool loadMovie(const char* filename);
+  bool loadMovie(const std::string& filename);
 
   void start(float start_time);
Index: trunk/src/lib/graphics/importer/objModel.cc
===================================================================
--- trunk/src/lib/graphics/importer/objModel.cc	(revision 7201)
+++ trunk/src/lib/graphics/importer/objModel.cc	(revision 7221)
@@ -32,5 +32,6 @@
  * @param scaling The factor that the model will be scaled with.
 */
-OBJModel::OBJModel(const char* fileName, float scaling) : StaticModel(fileName)
+OBJModel::OBJModel(const std::string& fileName, float scaling)
+  : StaticModel(fileName)
 {
   this->setClassID(CL_OBJ_MODEL, "OBJModel");
@@ -51,9 +52,5 @@
 */
 OBJModel::~OBJModel()
-{
-  PRINTF(4)("Deleting the obj-names\n");
-  if (this->objPath)
-    delete []this->objPath;
-}
+{ }
 
 /**
@@ -63,6 +60,7 @@
    Splits the FileName from the DirectoryName
 */
-bool OBJModel::importFile (const char* fileName)
-{
+bool OBJModel::importFile (const std::string& fileNameInput)
+{
+  const char* fileName = fileNameInput.c_str();
   PRINTF(4)("preparing to read in file: %s\n", fileName);
   // splitting the
@@ -74,6 +72,6 @@
     {
       int len = split - fileName+1;
-      this->objPath = new char[len +2];
-      strncpy(this->objPath, fileName, len);
+      this->objPath =  fileName;
+      this->objPath.erase(len, this->objPath.size());
       this->objPath[len] = '\0';
       PRINTF(4)("Resolved file %s to Path %s.\n", fileName, this->objPath);
@@ -91,10 +89,10 @@
    This function does read the file, parses it for the occurence of things like vertices, faces and so on, and executes the specific tasks
 */
-bool OBJModel::readFromObjFile(const char* fileName)
+bool OBJModel::readFromObjFile(const std::string& fileName)
 {
   FILE* stream;
-  if( (stream = fopen (fileName, "r")) == NULL)
-    {
-      PRINTF(2)("Object File Could not be Opened %s\n", fileName);
+  if( (stream = fopen (fileName.c_str(), "r")) == NULL)
+    {
+      PRINTF(2)("Object File Could not be Opened %s\n", fileName.c_str());
       return false;
     }
@@ -162,14 +160,12 @@
  * that a material does not have to be able to read itself in from a File.
  */
-bool OBJModel::readMtlLib (const char* mtlFile)
-{
-  char* fileName = new char [strlen(this->objPath) + strlen(mtlFile)+1];
-  sprintf(fileName, "%s%s", this->objPath, mtlFile);
+bool OBJModel::readMtlLib (const std::string& mtlFile)
+{
+  std::string fileName = this->objPath + mtlFile;
 
   FILE* stream;
-  if( (stream = fopen (fileName, "r")) == NULL)
-    {
-      PRINTF(2)("MaterialLibrary could not be opened %s\n", fileName);
-      delete[] fileName;
+  if( (stream = fopen (fileName.c_str(), "r")) == NULL)
+    {
+      PRINTF(2)("MaterialLibrary could not be opened %s\n", fileName.c_str());
       return false;
     }
@@ -258,5 +254,4 @@
     }
   fclose(stream);
-  delete []fileName;
   return true;
 }
Index: trunk/src/lib/graphics/importer/objModel.h
===================================================================
--- trunk/src/lib/graphics/importer/objModel.h	(revision 7201)
+++ trunk/src/lib/graphics/importer/objModel.h	(revision 7221)
@@ -13,15 +13,15 @@
 {
  public:
-  OBJModel(const char* fileName, float scaling = 1.0);
+   OBJModel(const std::string& fileName, float scaling = 1.0);
   virtual ~OBJModel();
 
  private:
   ///// readin /////
-  bool importFile (const char* fileName);
-  bool readFromObjFile (const char* fileName);
-  bool readMtlLib (const char* matFile);
+   bool importFile (const std::string& fileName);
+   bool readFromObjFile (const std::string& fileName);
+   bool readMtlLib (const std::string& matFile);
 
  private:
-  char*       objPath;     //!< The Path where the obj and mtl-file are located.
+   std::string       objPath;     //!< The Path where the obj and mtl-file are located.
 };
 
Index: trunk/src/lib/graphics/importer/static_model.cc
===================================================================
--- trunk/src/lib/graphics/importer/static_model.cc	(revision 7201)
+++ trunk/src/lib/graphics/importer/static_model.cc	(revision 7221)
@@ -23,6 +23,4 @@
 #include <stdarg.h>
 
-#include "vector.h"
-
 using namespace std;
 
@@ -86,5 +84,5 @@
 {
   PRINTF(4)("Adding new Group\n");
-  this->name = NULL;
+  this->name = "";
   this->faceMode = -1;
   this->faceCount = 0;
@@ -109,7 +107,4 @@
   if (this->listNumber != 0)
     glDeleteLists(this->listNumber, 1);
-
-  if (this->name != NULL)
-    delete[] this->name;
 
   if (this->next !=NULL)
@@ -142,5 +137,5 @@
  * assigns it a Name and a Type
  */
-StaticModel::StaticModel(const char* modelName)
+StaticModel::StaticModel(const std::string& modelName)
 {
   this->setClassID(CL_STATIC_MODEL, "StaticModel");
@@ -230,9 +225,9 @@
   ModelGroup* tmpGroup = this->firstGroup;
   while (tmpGroup != NULL)
-    {
-      PRINTF(5)("Drawing model %s\n", tmpGroup->name);
-      glCallList (tmpGroup->listNumber);
-      tmpGroup = tmpGroup->next;
-    }
+  {
+    PRINTF(5)("Drawing model %s\n", tmpGroup->name);
+    glCallList (tmpGroup->listNumber);
+    tmpGroup = tmpGroup->next;
+  }
 }
 
@@ -247,22 +242,22 @@
 {
   if (unlikely(groupNumber >= this->groupCount))
-    {
-      PRINTF(2)("You requested model number %i, but this File only contains of %i Models.\n", groupNumber-1, this->groupCount);
-      return;
-    }
+  {
+    PRINTF(2)("You requested model number %i, but this File only contains of %i Models.\n", groupNumber-1, this->groupCount);
+    return;
+  }
   PRINTF(4)("drawing the requested 3D-Models if found.\n");
   ModelGroup* tmpGroup = this->firstGroup;
   int counter = 0;
   while (tmpGroup != NULL)
+  {
+    if (counter == groupNumber)
     {
-      if (counter == groupNumber)
-        {
-          PRINTF(4)("Drawing model number %i named %s\n", counter, tmpGroup->name);
-          glCallList (tmpGroup->listNumber);
-          return;
-        }
-      ++counter;
-      tmpGroup = tmpGroup->next;
+      PRINTF(4)("Drawing model number %i named %s\n", counter, tmpGroup->name);
+      glCallList (tmpGroup->listNumber);
+      return;
     }
+    ++counter;
+    tmpGroup = tmpGroup->next;
+  }
   PRINTF(2)("Model number %i in %s not Found.\n", groupNumber, this->getName());
   return;
@@ -276,21 +271,19 @@
  * It does this by just calling the List that must have been created earlier.
  */
-void StaticModel::draw (char* groupName) const
-{
-  if (groupName == NULL)
-     return;
+void StaticModel::draw (const std::string& groupName) const
+{
   PRINTF(4)("drawing the requested 3D-Models if found.\n");
   ModelGroup* tmpGroup = this->firstGroup;
   while (tmpGroup != NULL)
+  {
+    if (tmpGroup->name == groupName)
     {
-      if (tmpGroup->name != NULL && !strcmp(tmpGroup->name, groupName))
-        {
-          PRINTF(4)("Drawing model %s\n", tmpGroup->name);
-          glCallList (tmpGroup->listNumber);
-          return;
-        }
-      tmpGroup = tmpGroup->next;
+      PRINTF(4)("Drawing model %s\n", tmpGroup->name.c_str());
+      glCallList (tmpGroup->listNumber);
+      return;
     }
-  PRINTF(2)("Model Named %s in %s not Found.\n", groupName, this->getName());
+    tmpGroup = tmpGroup->next;
+  }
+  PRINTF(2)("Model Named %s in %s not Found.\n", groupName.c_str(), this->getName());
   return;
 }
@@ -341,5 +334,5 @@
  * @returns the added material
  */
-Material* StaticModel::addMaterial(const char* materialName)
+Material* StaticModel::addMaterial(const std::string& materialName)
 {
   ModelMaterial* modMat = new ModelMaterial;
@@ -357,9 +350,9 @@
  * @returns the Material if found, NULL otherwise
  */
-Material* StaticModel::findMaterialByName(const char* materialName)
+Material* StaticModel::findMaterialByName(const std::string& materialName)
 {
   list<ModelMaterial*>::iterator modMat;
   for  (modMat = this->materialList.begin(); modMat != this->materialList.end(); modMat++)
-    if (!strcmp((*modMat)->material->getName(), materialName))
+    if (materialName == (*modMat)->material->getName())
       return (*modMat)->material;
   return NULL;
@@ -373,18 +366,17 @@
  * With it you should be able to create Models with more than one SubModel inside
  */
-bool StaticModel::addGroup(const char* groupString)
+bool StaticModel::addGroup(const std::string& groupString)
 {
   PRINTF(5)("Read Group: %s.\n", groupString);
   if (this->groupCount != 0 && this->currentGroup->faceCount > 0)
-    {
-      // finalizeGroup(currentGroup);
-      this->currentGroup = this->currentGroup->next = new ModelGroup;
-    }
+  {
+    // finalizeGroup(currentGroup);
+    this->currentGroup = this->currentGroup->next = new ModelGroup;
+  }
   // setting the group name if not default.
-  if (strcmp(groupString, "default"))
-    {
-      this->currentGroup->name = new char [strlen(groupString)+1];
-      strcpy(this->currentGroup->name, groupString);
-    }
+  if (groupString == "default")
+  {
+    this->currentGroup->name = groupString;
+  }
   ++this->groupCount;
 }
@@ -396,10 +388,10 @@
  *  If a vertex line is found this function will inject it into the vertex-Array
  */
-bool StaticModel::addVertex (const char* vertexString)
+bool StaticModel::addVertex (const std::string& vertexString)
 {
   float subbuffer1;
   float subbuffer2;
   float subbuffer3;
-  sscanf (vertexString, "%f %f %f", &subbuffer1, &subbuffer2, &subbuffer3);
+  sscanf (vertexString.c_str(), "%f %f %f", &subbuffer1, &subbuffer2, &subbuffer3);
   this->vertices.push_back(subbuffer1*scaleFactor);
   this->vertices.push_back(subbuffer2*scaleFactor);
@@ -431,10 +423,10 @@
  * If a vertexNormal line is found this function will inject it into the vertexNormal-Array
  */
-bool StaticModel::addVertexNormal (const char* normalString)
+bool StaticModel::addVertexNormal (const std::string& normalString)
 {
   float subbuffer1;
   float subbuffer2;
   float subbuffer3;
-  sscanf (normalString, "%f %f %f", &subbuffer1, &subbuffer2, &subbuffer3);
+  sscanf (normalString.c_str(), "%f %f %f", &subbuffer1, &subbuffer2, &subbuffer3);
   this->normals.push_back(subbuffer1);
   this->normals.push_back(subbuffer2);
@@ -471,9 +463,9 @@
  * !! WARNING THIS IS DIFFERNT FROM addVervexTexture(float, float); because it changes the second entry to 1-v !!
  */
-bool StaticModel::addVertexTexture (const char* vTextureString)
+bool StaticModel::addVertexTexture (const std::string& vTextureString)
 {
   float subbuffer1;
   float subbuffer2;
-  sscanf (vTextureString, "%f %f", &subbuffer1, &subbuffer2);
+  sscanf (vTextureString.c_str(), "%f %f", &subbuffer1, &subbuffer2);
   this->vTexture.push_back(subbuffer1);
   this->vTexture.push_back(1 - subbuffer2);
@@ -507,7 +499,10 @@
  * String is different from the argument addFace,
  * in this, that the first Vertex/Normal/Texcoord is 1 instead of 0
- */
-bool StaticModel::addFace (const char* faceString)
-{
+ *
+ * @TODO make it std::string conform
+ */
+bool StaticModel::addFace (const std::string& faceStringInput)
+{
+  const char* faceString = faceStringInput.c_str();
   if (this->currentGroup->faceCount >0)
     this->currentGroup->currentFace = this->currentGroup->currentFace->next = new ModelFace;
@@ -516,42 +511,42 @@
   tmpElem->next = NULL;
   while(strcmp (faceString, "\0"))
+  {
+    if (this->currentGroup->currentFace->vertexCount>0)
+      tmpElem = tmpElem->next = new ModelFaceElement;
+    tmpElem->next = NULL;
+
+    char tmpValue [50];
+    int tmpLen;
+    char* vertex = NULL;
+    char* texture = NULL;
+    char* normal = NULL;
+
+    sscanf (faceString, "%s", tmpValue);
+    tmpLen = strlen(tmpValue);
+    vertex = tmpValue;
+
+    if ((texture = strstr (vertex, "/")) != NULL)
     {
-      if (this->currentGroup->currentFace->vertexCount>0)
-          tmpElem = tmpElem->next = new ModelFaceElement;
-      tmpElem->next = NULL;
-
-      char tmpValue [50];
-      int tmpLen;
-      char* vertex = NULL;
-      char* texture = NULL;
-      char* normal = NULL;
-
-      sscanf (faceString, "%s", tmpValue);
-      tmpLen = strlen(tmpValue);
-      vertex = tmpValue;
-
-      if ((texture = strstr (vertex, "/")) != NULL)
-        {
-          texture[0] = '\0';
-          texture ++;
-
-          if ((normal = strstr (texture, "/")) !=NULL)
-            {
-              normal[0] = '\0';
-              normal ++;
-            }
-        }
-      if (vertex)
-        tmpElem->vertexNumber = atoi(vertex)-1;
-      if (texture)
-        tmpElem->texCoordNumber = atoi(texture)-1;
-      if (normal)
-        tmpElem->normalNumber = atoi(normal)-1;
-
-      faceString += tmpLen;
-      if (strcmp (faceString, "\0"))
-        faceString++;
-      this->currentGroup->currentFace->vertexCount++;
+      texture[0] = '\0';
+      texture ++;
+
+      if ((normal = strstr (texture, "/")) !=NULL)
+      {
+        normal[0] = '\0';
+        normal ++;
+      }
     }
+    if (vertex)
+      tmpElem->vertexNumber = atoi(vertex)-1;
+    if (texture)
+      tmpElem->texCoordNumber = atoi(texture)-1;
+    if (normal)
+      tmpElem->normalNumber = atoi(normal)-1;
+
+    faceString += tmpLen;
+    if (strcmp (faceString, "\0"))
+      faceString++;
+    this->currentGroup->currentFace->vertexCount++;
+  }
 
   this->currentGroup->faceCount += this->currentGroup->currentFace->vertexCount -2;
@@ -575,15 +570,15 @@
 
   for (int i = 0; i < faceElemCount; i++)
-    {
-      if (this->currentGroup->currentFace->vertexCount > 0)
-        tmpElem = tmpElem->next = new ModelFaceElement;
-
-      tmpElem->vertexNumber = va_arg (itemlist, int);
-      if (type & TEXCOORD)
-        tmpElem->texCoordNumber = va_arg (itemlist, int);
-      if (type & NORMAL)
-        tmpElem->normalNumber = va_arg(itemlist, int);
-      this->currentGroup->currentFace->vertexCount++;
-    }
+  {
+    if (this->currentGroup->currentFace->vertexCount > 0)
+      tmpElem = tmpElem->next = new ModelFaceElement;
+
+    tmpElem->vertexNumber = va_arg (itemlist, int);
+    if (type & TEXCOORD)
+      tmpElem->texCoordNumber = va_arg (itemlist, int);
+    if (type & NORMAL)
+      tmpElem->normalNumber = va_arg(itemlist, int);
+    this->currentGroup->currentFace->vertexCount++;
+  }
   va_end(itemlist);
 
@@ -596,5 +591,5 @@
  * @param matString the Material that will be set.
 */
-bool StaticModel::setMaterial(const char* matString)
+bool StaticModel::setMaterial(const std::string& matString)
 {
   if (this->currentGroup->faceCount > 0)
@@ -647,60 +642,60 @@
   ModelGroup* tmpGroup = firstGroup;
   while (tmpGroup != NULL)
+  {
+    ModelFace* tmpFace = tmpGroup->firstFace;
+    while (tmpFace != NULL)
     {
-      ModelFace* tmpFace = tmpGroup->firstFace;
-      while (tmpFace != NULL)
+      if (tmpFace->firstElem != NULL)
+      {
+        ModelFaceElement* firstElem = tmpFace->firstElem;
+        ModelFaceElement* prevElem;
+        ModelFaceElement* curElem = firstElem;
+        ModelFaceElement* nextElem;
+        ModelFaceElement* lastElem;
+        // find last Element of the Chain. !! IMPORTANT:the last Element of the Chain must point to NULL, or it will resolv into an infinity-loop.
+        while (curElem != NULL)
         {
-          if (tmpFace->firstElem != NULL)
-            {
-              ModelFaceElement* firstElem = tmpFace->firstElem;
-              ModelFaceElement* prevElem;
-              ModelFaceElement* curElem = firstElem;
-              ModelFaceElement* nextElem;
-              ModelFaceElement* lastElem;
-              // find last Element of the Chain. !! IMPORTANT:the last Element of the Chain must point to NULL, or it will resolv into an infinity-loop.
-              while (curElem != NULL)
-                {
-                  prevElem = curElem;
-                  curElem = curElem->next;
-                }
-              lastElem = prevElem;
-
-              curElem = firstElem;
-              for (int j=0; j<tmpFace->vertexCount; j++)
-                {
-                  if (!(nextElem = curElem->next))
-                    nextElem = firstElem;
-                  curElem->normalNumber = curElem->vertexNumber;
-
-                  curV = Vector (this->vertices[curElem->vertexNumber*3],
-				 this->vertices[curElem->vertexNumber*3+1],
-				 this->vertices[curElem->vertexNumber*3+2]);
-
-                  prevV = Vector (this->vertices[prevElem->vertexNumber*3],
-				  this->vertices[prevElem->vertexNumber*3+1],
-				  this->vertices[prevElem->vertexNumber*3+2]) - curV;
-
-                  nextV = Vector (this->vertices[nextElem->vertexNumber*3],
-				  this->vertices[nextElem->vertexNumber*3+1],
-				  this->vertices[nextElem->vertexNumber*3+2]) - curV;
-                  normArray[curElem->vertexNumber] = normArray[curElem->vertexNumber] + nextV.cross(prevV);
-
-                  prevElem = curElem;
-                  curElem = curElem->next;
-                }
-            }
-          tmpFace = tmpFace->next;
+          prevElem = curElem;
+          curElem = curElem->next;
         }
-      tmpGroup = tmpGroup->next;
+        lastElem = prevElem;
+
+        curElem = firstElem;
+        for (int j=0; j<tmpFace->vertexCount; j++)
+        {
+          if (!(nextElem = curElem->next))
+            nextElem = firstElem;
+          curElem->normalNumber = curElem->vertexNumber;
+
+          curV = Vector (this->vertices[curElem->vertexNumber*3],
+                         this->vertices[curElem->vertexNumber*3+1],
+                         this->vertices[curElem->vertexNumber*3+2]);
+
+          prevV = Vector (this->vertices[prevElem->vertexNumber*3],
+                          this->vertices[prevElem->vertexNumber*3+1],
+                          this->vertices[prevElem->vertexNumber*3+2]) - curV;
+
+          nextV = Vector (this->vertices[nextElem->vertexNumber*3],
+                          this->vertices[nextElem->vertexNumber*3+1],
+                          this->vertices[nextElem->vertexNumber*3+2]) - curV;
+          normArray[curElem->vertexNumber] = normArray[curElem->vertexNumber] + nextV.cross(prevV);
+
+          prevElem = curElem;
+          curElem = curElem->next;
+        }
+      }
+      tmpFace = tmpFace->next;
     }
+    tmpGroup = tmpGroup->next;
+  }
 
   for (int i=0; i < this->vertices.size()/3;i++)
-    {
-      normArray[i].normalize();
-      PRINTF(5)("Found Normale number %d: (%f; %f, %f).\n", i, normArray[i].x, normArray[i].y, normArray[i].z);
-
-      this->addVertexNormal(normArray[i].x, normArray[i].y, normArray[i].z);
-
-    }
+  {
+    normArray[i].normalize();
+    PRINTF(5)("Found Normale number %d: (%f; %f, %f).\n", i, normArray[i].x, normArray[i].y, normArray[i].z);
+
+    this->addVertexNormal(normArray[i].x, normArray[i].y, normArray[i].z);
+
+  }
   delete[] normArray;
 }
@@ -721,79 +716,79 @@
 
   while (this->currentGroup != NULL)
+  {
+
+    // creating a glList for the Group
+    if ((this->currentGroup->listNumber = glGenLists(1)) == 0)
     {
-
-      // creating a glList for the Group
-      if ((this->currentGroup->listNumber = glGenLists(1)) == 0)
+      PRINTF(2)("glList could not be created for this Model\n");
+      return false;
+    }
+    glNewList (this->currentGroup->listNumber, GL_COMPILE);
+
+    // Putting Faces to GL
+    ModelFace* tmpFace = this->currentGroup->firstFace;
+    while (tmpFace != NULL)
+    {
+      if (tmpFace->vertexCount == 0 && tmpFace->material != NULL)
+      {
+        if (this->currentGroup->faceMode != -1)
+          glEnd();
+        this->currentGroup->faceMode = 0;
+        Material* tmpMat;
+        if (tmpFace->material != NULL)
         {
-          PRINTF(2)("glList could not be created for this Model\n");
-          return false;
+          tmpFace->material->select();
+          PRINTF(5)("using material %s for coming Faces.\n", tmpFace->material->getName());
         }
-      glNewList (this->currentGroup->listNumber, GL_COMPILE);
-
-      // Putting Faces to GL
-      ModelFace* tmpFace = this->currentGroup->firstFace;
-      while (tmpFace != NULL)
+      }
+
+      else if (tmpFace->vertexCount == 3)
+      {
+        if (this->currentGroup->faceMode != 3)
         {
-          if (tmpFace->vertexCount == 0 && tmpFace->material != NULL)
-            {
-              if (this->currentGroup->faceMode != -1)
-                glEnd();
-              this->currentGroup->faceMode = 0;
-              Material* tmpMat;
-              if (tmpFace->material != NULL)
-                {
-                  tmpFace->material->select();
-                  PRINTF(5)("using material %s for coming Faces.\n", tmpFace->material->getName());
-                }
-            }
-
-          else if (tmpFace->vertexCount == 3)
-            {
-              if (this->currentGroup->faceMode != 3)
-                {
-                  if (this->currentGroup->faceMode != -1)
-                    glEnd();
-                  glBegin(GL_TRIANGLES);
-                }
-
-              this->currentGroup->faceMode = 3;
-              PRINTF(5)("found triag.\n");
-            }
-
-          else if (tmpFace->vertexCount == 4)
-            {
-              if (this->currentGroup->faceMode != 4)
-                {
-                  if (this->currentGroup->faceMode != -1)
-                    glEnd();
-                  glBegin(GL_QUADS);
-                }
-              this->currentGroup->faceMode = 4;
-              PRINTF(5)("found quad.\n");
-            }
-
-          else if (tmpFace->vertexCount > 4)
-            {
-              if (this->currentGroup->faceMode != -1)
-                glEnd();
-              glBegin(GL_POLYGON);
-              PRINTF(5)("Polygon with %i faces found.", tmpFace->vertexCount);
-              this->currentGroup->faceMode = tmpFace->vertexCount;
-            }
-
-          ModelFaceElement* tmpElem = tmpFace->firstElem;
-          while (tmpElem != NULL)
-            {
-              //      PRINTF(2)("%s\n", tmpElem->value);
-              this->addGLElement(tmpElem);
-              tmpElem = tmpElem->next;
-            }
-          tmpFace = tmpFace->next;
+          if (this->currentGroup->faceMode != -1)
+            glEnd();
+          glBegin(GL_TRIANGLES);
         }
-      glEnd();
-      glEndList();
-
-      this->currentGroup = this->currentGroup->next;
+
+        this->currentGroup->faceMode = 3;
+        PRINTF(5)("found triag.\n");
+      }
+
+      else if (tmpFace->vertexCount == 4)
+      {
+        if (this->currentGroup->faceMode != 4)
+        {
+          if (this->currentGroup->faceMode != -1)
+            glEnd();
+          glBegin(GL_QUADS);
+        }
+        this->currentGroup->faceMode = 4;
+        PRINTF(5)("found quad.\n");
+      }
+
+      else if (tmpFace->vertexCount > 4)
+      {
+        if (this->currentGroup->faceMode != -1)
+          glEnd();
+        glBegin(GL_POLYGON);
+        PRINTF(5)("Polygon with %i faces found.", tmpFace->vertexCount);
+        this->currentGroup->faceMode = tmpFace->vertexCount;
+      }
+
+      ModelFaceElement* tmpElem = tmpFace->firstElem;
+      while (tmpElem != NULL)
+      {
+        //      PRINTF(2)("%s\n", tmpElem->value);
+        this->addGLElement(tmpElem);
+        tmpElem = tmpElem->next;
+      }
+      tmpFace = tmpFace->next;
     }
+    glEnd();
+    glEndList();
+
+    this->currentGroup = this->currentGroup->next;
+  }
 }
 
@@ -814,4 +809,6 @@
   ModelFace* tmpFace;              //!< the temporary face referece
 
+  bool warned = false;
+
   /* count the number of triangles */
   /* now iterate through all groups and build up the triangle list */
@@ -834,6 +831,10 @@
       else if( tmpFace->vertexCount > 4)
       {
-        PRINTF(1)("This model (%s) got over 4 vertices per face <=> conflicts in the CD engine!\n", this->getName());
-      //exit(0);
+        if (!warned)
+        {
+          PRINTF(2)("This model (%s) got over 4 vertices per face <=> conflicts in the CD engine!\n", this->getName());
+          warned = true;
+        }
+        //exit(0);
       }
       tmpFace = tmpFace->next;
@@ -858,5 +859,5 @@
   while( this->currentGroup != NULL)
   {
-      // Putting Faces to GL
+    // Putting Faces to GL
     tmpFace = this->currentGroup->firstFace;
     while( tmpFace != NULL)
@@ -931,27 +932,27 @@
 
   if (elem->texCoordNumber != -1)
-    {
-      if (likely(elem->texCoordNumber < this->pModelInfo.numTexCoor))
-        glTexCoord2fv(&this->vTexture[0] + elem->texCoordNumber * 2);
-      else
-        PRINTF(2)("TextureCoordinate %d is not in the List (max: %d)\nThe Model might be incomplete\n",
-                  elem->texCoordNumber, this->pModelInfo.numTexCoor);
-    }
+  {
+    if (likely(elem->texCoordNumber < this->pModelInfo.numTexCoor))
+      glTexCoord2fv(&this->vTexture[0] + elem->texCoordNumber * 2);
+    else
+      PRINTF(2)("TextureCoordinate %d is not in the List (max: %d)\nThe Model might be incomplete\n",
+                elem->texCoordNumber, this->pModelInfo.numTexCoor);
+  }
   if (elem->normalNumber != -1)
-    {
+  {
     if (likely(elem->normalNumber < this->pModelInfo.numNormals))
       glNormal3fv(&this->normals[0] + elem->normalNumber * 3);
     else
-        PRINTF(2)("Normal %d is not in the List (max: %d)\nThe Model might be incomplete",
-                  elem->normalNumber, this->pModelInfo.numNormals);
-    }
+      PRINTF(2)("Normal %d is not in the List (max: %d)\nThe Model might be incomplete",
+                elem->normalNumber, this->pModelInfo.numNormals);
+  }
   if (elem->vertexNumber != -1)
-    {
-      if (likely(elem->vertexNumber < this->pModelInfo.numVertices))
-          glVertex3fv(&this->vertices[0]+ elem->vertexNumber * 3);
-      else
-        PRINTF(2)("Vertex %d is not in the List (max: %d)\nThe Model might be incomplete",
-                  elem->vertexNumber, this->pModelInfo.numVertices);
-    }
+  {
+    if (likely(elem->vertexNumber < this->pModelInfo.numVertices))
+      glVertex3fv(&this->vertices[0]+ elem->vertexNumber * 3);
+    else
+      PRINTF(2)("Vertex %d is not in the List (max: %d)\nThe Model might be incomplete",
+                elem->vertexNumber, this->pModelInfo.numVertices);
+  }
 
 }
Index: trunk/src/lib/graphics/importer/static_model.h
===================================================================
--- trunk/src/lib/graphics/importer/static_model.h	(revision 7201)
+++ trunk/src/lib/graphics/importer/static_model.h	(revision 7221)
@@ -13,7 +13,4 @@
 #include <vector>
 #include <list>
-
-// FORWARD DECLARATION //
-template<class T> class tArray;
 
 // definition of different modes for setting up Faces
@@ -70,5 +67,5 @@
   void cleanup();
 
-  char*        name;           //!< the Name of the Group. this is an identifier, that can be accessed via the draw (char* name) function.
+  std::string  name;           //!< the Name of the Group. this is an identifier, that can be accessed via the draw (std::string name) function.
   GLubyte*     indices;        //!< The indices of the Groups. Needed for vertex-arrays
   GLuint       listNumber;     //!< The number of the GL-List this Group gets.
@@ -98,31 +95,31 @@
 {
  public:
-  StaticModel(const char* modelName = NULL);
+  StaticModel(const std::string& modelName = "");
   virtual ~StaticModel();
 
   virtual void draw() const;
   void draw(int groupNumber) const;
-  void draw(char* groupName) const;
+  void draw(const std::string& groupName) const;
 
   void rebuild();
 
   Material* addMaterial(Material* material);
-  Material* addMaterial(const char* materialName);
+  Material* addMaterial(const std::string& materialName);
 
-  bool addGroup(const char* groupString);
+  bool addGroup(const std::string& groupString);
 
-  bool addVertex(const char* vertexString);
+  bool addVertex(const std::string& vertexString);
   bool addVertex(float x, float y, float z);
 
-  bool addFace(const char* faceString);
+  bool addFace(const std::string& faceString);
   bool addFace(int faceElemCount, VERTEX_FORMAT type, ...);
 
-  bool addVertexNormal(const char* normalString);
+  bool addVertexNormal(const std::string& normalString);
   bool addVertexNormal(float x, float y, float z);
 
-  bool addVertexTexture(const char* vTextureString);
+  bool addVertexTexture(const std::string& vTextureString);
   bool addVertexTexture(float u, float v);
 
-  bool setMaterial(const char* mtlString);
+  bool setMaterial(const std::string& mtlString);
   bool setMaterial(Material* mtl);
 
@@ -133,5 +130,5 @@
   void cubeModel();
 
-  Material* findMaterialByName(const char* materialName);
+  Material* findMaterialByName(const std::string& materialName);
 
  protected:
Index: trunk/src/lib/graphics/importer/texture.cc
===================================================================
--- trunk/src/lib/graphics/importer/texture.cc	(revision 7201)
+++ trunk/src/lib/graphics/importer/texture.cc	(revision 7221)
@@ -32,5 +32,5 @@
  *  Constructor for a Texture
 */
-Texture::Texture(const char* imageName, GLenum target)
+Texture::Texture(const std::string& imageName, GLenum target)
 {
   this->setClassID(CL_TEXTURE, "Texture");
@@ -41,5 +41,5 @@
   this->priority = 0.5;
 
-  if (imageName != NULL)
+  if (!imageName.empty())
   {
     this->setName(imageName);
@@ -67,5 +67,5 @@
  * @param imageName The image to load
 */
-bool Texture::loadImage(const char* imageName, GLenum target)
+bool Texture::loadImage(const std::string& imageName, GLenum target)
 {
   if (Texture::texturesEnabled)
@@ -81,5 +81,5 @@
       this->texture = 0;
     }
-    if (imageName != NULL)
+    if (!imageName.empty())
     {
       SDL_Surface* tmpSurf;
@@ -87,5 +87,5 @@
         glDeleteTextures(1, &this->texture);
       // load the new Image to memory
-      tmpSurf = IMG_Load(imageName);
+      tmpSurf = IMG_Load(imageName.c_str());
       if(tmpSurf != NULL)
       {
Index: trunk/src/lib/graphics/importer/texture.h
===================================================================
--- trunk/src/lib/graphics/importer/texture.h	(revision 7201)
+++ trunk/src/lib/graphics/importer/texture.h	(revision 7221)
@@ -18,9 +18,9 @@
   {
     public:
-      Texture(const char* imageName = NULL, GLenum target = GL_TEXTURE_2D);
+      Texture(const std::string& imageName = "", GLenum target = GL_TEXTURE_2D);
   //  Texture(TEXTURE_TYPE type, int resolution);
       virtual ~Texture();
 
-      bool loadImage(const char* imageName, GLenum target = GL_TEXTURE_2D);
+      bool loadImage(const std::string& imageName, GLenum target = GL_TEXTURE_2D);
       virtual bool rebuild();
 
Index: trunk/src/lib/graphics/importer/texture_sequence.cc
===================================================================
--- trunk/src/lib/graphics/importer/texture_sequence.cc	(revision 7201)
+++ trunk/src/lib/graphics/importer/texture_sequence.cc	(revision 7221)
@@ -124,10 +124,7 @@
  * @returns true on success
  */
-bool TextureSequence::addFrame(const char* imageName)
+bool TextureSequence::addFrame(const std::string& imageName)
 {
-  if (imageName == NULL)
-    return false;
-
-  SDL_Surface* addSurface = IMG_Load(imageName);
+  SDL_Surface* addSurface = IMG_Load(imageName.c_str());
   bool success = this->addFrame(addSurface);
   delete addSurface;
Index: trunk/src/lib/graphics/importer/texture_sequence.h
===================================================================
--- trunk/src/lib/graphics/importer/texture_sequence.h	(revision 7201)
+++ trunk/src/lib/graphics/importer/texture_sequence.h	(revision 7221)
@@ -23,5 +23,5 @@
     bool loadImageSeries(unsigned int count, ...);
     bool loadImageSeries(unsigned int count, va_list textureNames);
-    bool addFrame(const char* image);
+    bool addFrame(const std::string& image);
     bool addFrame(SDL_Surface* surface);
     bool addFrame(GLuint texture);
Index: trunk/src/lib/graphics/render2D/billboard.cc
===================================================================
--- trunk/src/lib/graphics/render2D/billboard.cc	(revision 7201)
+++ trunk/src/lib/graphics/render2D/billboard.cc	(revision 7221)
@@ -78,5 +78,5 @@
 void Billboard::loadParams(const TiXmlElement* root)
 {
-  LoadParam(root, "texture", this, Billboard, setTexture)
+  LoadParam(root, "texture", this->material, Material, setDiffuseMap)
       .describe("the texture-file to load onto the Billboard");
 
@@ -100,5 +100,5 @@
  * @param textureFile The texture-file to load onto the crosshair
  */
-void Billboard::setTexture(const char* textureFile)
+void Billboard::setTexture(const std::string& textureFile)
 {
   this->material->setDiffuseMap(textureFile);
Index: trunk/src/lib/graphics/render2D/billboard.h
===================================================================
--- trunk/src/lib/graphics/render2D/billboard.h	(revision 7201)
+++ trunk/src/lib/graphics/render2D/billboard.h	(revision 7221)
@@ -30,5 +30,5 @@
 
     void setSize(float sizeX, float sizeY);
-    void setTexture(const char* textureFile);
+    void setTexture(const std::string& textureFile);
     void attachTo(PNode* pnode);
 
Index: trunk/src/lib/graphics/render2D/element_2d.cc
===================================================================
--- trunk/src/lib/graphics/render2D/element_2d.cc	(revision 7201)
+++ trunk/src/lib/graphics/render2D/element_2d.cc	(revision 7221)
@@ -180,13 +180,13 @@
  * @param alignment the alignment @see loadParams
 */
-void Element2D::setAlignment(const char* alignment)
-{
-  if (!strcmp(alignment, "center"))
+void Element2D::setAlignment(const std::string& alignment)
+{
+  if (alignment == "center")
     this->setAlignment(E2D_ALIGN_CENTER);
-  else if (!strcmp(alignment, "left"))
+  else if (alignment == "left")
     this->setAlignment(E2D_ALIGN_LEFT);
-  else if (!strcmp(alignment, "right"))
+  else if (alignment == "right")
     this->setAlignment(E2D_ALIGN_RIGHT);
-  else if (!strcmp(alignment, "screen-center"))
+  else if (alignment == "screen-center")
     this->setAlignment(E2D_ALIGN_SCREEN_CENTER);
 }
@@ -213,7 +213,7 @@
 /**
  * sets the layer onto which this 2D-element is projected to.
- * @param layer the layer @see loadParams @see Element2D::charToLayer2D(const char* layer)
- */
-void Element2D::setLayer(const char* layer)
+ * @param layer the layer @see loadParams @see Element2D::charToLayer2D(const std::string& layer)
+ */
+void Element2D::setLayer(const std::string& layer)
 {
   this->setLayer(Element2D::charToLayer2D(layer));
@@ -235,5 +235,5 @@
  * @param bindNode the name of the Node (should be existing)
  */
-void Element2D::setBindNode(const char* bindNode)
+void Element2D::setBindNode(const std::string& bindNode)
 {
   const PNode* tmpBindNode = dynamic_cast<const PNode*>(ClassList::getObject(bindNode, CL_PARENT_NODE));
@@ -572,5 +572,5 @@
  * @param childName the name of the child to add to this PNode
  */
-void Element2D::addChild2D (const char* childName)
+void Element2D::addChild2D (const std::string& childName)
 {
   Element2D* childNode = dynamic_cast<Element2D*>(ClassList::getObject(childName, CL_ELEMENT_2D));
@@ -651,5 +651,5 @@
  * @param parentName the name of the Parent to set to this Element2D
  */
-void Element2D::setParent2D (const char* parentName)
+void Element2D::setParent2D (const std::string& parentName)
 {
   Element2D* parentNode = dynamic_cast<Element2D*>(ClassList::getObject(parentName, CL_ELEMENT_2D));
@@ -658,5 +658,5 @@
   else
     PRINTF(2)("Not Found Element2D's (%s::%s) new Parent by Name: %s\n",
-                this->getClassName(), this->getName(), parentName);
+                this->getClassName(), this->getName(), parentName.c_str());
 }
 
@@ -704,5 +704,5 @@
  * @param bias the speed to iterate to this new Positions
  */
-void Element2D::setParentSoft2D(const char* parentName, float bias)
+void Element2D::setParentSoft2D(const std::string& parentName, float bias)
 {
   Element2D* parentNode = dynamic_cast<Element2D*>(ClassList::getObject(parentName, CL_ELEMENT_2D));
@@ -724,7 +724,7 @@
  * @param parentMode a String representing this parentingMode
  */
-void Element2D::setParentMode2D (const char* parentingMode)
-{
-  this->setParentMode2D(Element2D::charToParentingMode2D(parentingMode));
+void Element2D::setParentMode2D (const std::string& parentingMode)
+{
+  this->setParentMode2D(Element2D::stringToParentingMode2D(parentingMode));
 }
 
@@ -952,5 +952,5 @@
             this->relCoordinate.y,
             this->getAbsDir2D(),
-            Element2D::parentingModeToChar2D(parentMode),
+            Element2D::parentingModeToString2D(parentMode),
             Element2D::layer2DToChar(this->layer));
 
@@ -1074,5 +1074,5 @@
  * @return the converted string
  */
-const char* Element2D::parentingModeToChar2D(int parentingMode)
+const char* Element2D::parentingModeToString2D(int parentingMode)
 {
   if (parentingMode == E2D_PARENT_LOCAL_ROTATE)
@@ -1093,15 +1093,15 @@
  * @return the int corresponding to the named parentingMode
  */
-E2D_PARENT_MODE Element2D::charToParentingMode2D(const char* parentingMode)
-{
-  if (!strcmp(parentingMode, "local-rotate"))
+E2D_PARENT_MODE Element2D::stringToParentingMode2D(const std::string& parentingMode)
+{
+  if (parentingMode == "local-rotate")
     return (E2D_PARENT_LOCAL_ROTATE);
-  else  if (!strcmp(parentingMode, "rotate-movement"))
+  else  if (parentingMode == "rotate-movement")
     return (E2D_PARENT_ROTATE_MOVEMENT);
-  else  if (!strcmp(parentingMode, "movement"))
+  else  if (parentingMode == "movement")
     return (E2D_PARENT_MOVEMENT);
-  else  if (!strcmp(parentingMode, "all"))
+  else  if (parentingMode == "all")
     return (E2D_PARENT_ALL);
-  else  if (!strcmp(parentingMode, "rotate-and-move"))
+  else  if (parentingMode == "rotate-and-move")
     return (E2D_PARENT_ROTATE_AND_MOVE);
 }
@@ -1139,13 +1139,13 @@
  * @returns the E2D_LAYER on success, E2D_DEFAULT_LAYER on error.
  */
-E2D_LAYER Element2D::charToLayer2D(const char* layer)
-{
-  if (!strcmp(layer, "top"))
+E2D_LAYER Element2D::charToLayer2D(const std::string& layer)
+{
+  if (layer =="top")
     return (E2D_LAYER_TOP);
-  else  if (!strcmp(layer, "medium"))
+  else  if (layer == "medium")
     return (E2D_LAYER_MEDIUM);
-  else  if (!strcmp(layer, "bottom"))
+  else  if (layer == "bottom")
     return (E2D_LAYER_BOTTOM);
-  else  if (!strcmp(layer, "below-all"))
+  else  if (layer == "below-all")
     return (E2D_LAYER_BELOW_ALL);
   else
Index: trunk/src/lib/graphics/render2D/element_2d.h
===================================================================
--- trunk/src/lib/graphics/render2D/element_2d.h	(revision 7201)
+++ trunk/src/lib/graphics/render2D/element_2d.h	(revision 7221)
@@ -102,10 +102,10 @@
     /** @param alignment the new Alignment of the 2D-Element */
     inline void setAlignment(E2D_ALIGNMENT alignment) { this->alignment = alignment; };
-    void setAlignment(const char* alignment);
+    void setAlignment(const std::string& alignment);
     inline E2D_ALIGNMENT getAlignment() const { return this->alignment; };
 
     // LAYERING //
     void setLayer(E2D_LAYER layer);
-    void setLayer(const char* layer);
+    void setLayer(const std::string& layer);
     /** @returns the Layer this Element is drawn to */
     inline E2D_LAYER getLayer() const { return this->layer; };
@@ -121,5 +121,5 @@
     /** @param bindNode the Node this 2D-element should follow. if NULL the Element will not follow anything */
     inline void setBindNode(const PNode* bindNode) { this->bindNode = bindNode; };
-    void setBindNode(const char* bindNode);
+    void setBindNode(const std::string& bindNode);
     inline const PNode* getBindNode() const { return this->bindNode; };
 
@@ -181,5 +181,5 @@
 
     void addChild2D (Element2D* child);
-    void addChild2D (const char* childName);
+    void addChild2D (const std::string& childName);
     void removeChild2D (Element2D* child);
     void remove2D();
@@ -187,5 +187,5 @@
     /** @param parent the new parent of this Element2D */
     void setParent2D (Element2D* parent) { parent->addChild2D(this); };
-    void setParent2D (const char* parentName);
+    void setParent2D (const std::string& parentName);
     /** @returns the parent of this Element2D */
     inline Element2D* getParent2D () const { return this->parent; };
@@ -194,8 +194,8 @@
 
     void setParentSoft2D(Element2D* parentNode, float bias = 1.0);
-    void setParentSoft2D(const char* parentName, float bias = 1.0);
+    void setParentSoft2D(const std::string& parentName, float bias = 1.0);
 
     void setParentMode2D (E2D_PARENT_MODE parentMode);
-    void setParentMode2D (const char* parentingMode);
+    void setParentMode2D (const std::string& parentingMode);
     /** @returns the Parenting mode of this node */
     int getParentMode2D() const { return this->parentMode; };
@@ -212,9 +212,9 @@
 
     // helper functions //
-    static const char* parentingModeToChar2D(int parentingMode);
-    static E2D_PARENT_MODE charToParentingMode2D(const char* parentingMode);
+    static const char* parentingModeToString2D(int parentingMode);
+    static E2D_PARENT_MODE stringToParentingMode2D(const std::string& parentingMode);
 
     static const char* layer2DToChar(E2D_LAYER layer);
-    static E2D_LAYER charToLayer2D(const char* layer);
+    static E2D_LAYER charToLayer2D(const std::string& layer);
 
   private:
Index: trunk/src/lib/graphics/shader.cc
===================================================================
--- trunk/src/lib/graphics/shader.cc	(revision 7201)
+++ trunk/src/lib/graphics/shader.cc	(revision 7221)
@@ -36,10 +36,10 @@
  * standard constructor
 */
-Shader::Shader (const char* vertexShaderFile, const char* fragmentShaderFile)
+Shader::Shader (const std::string& vertexShaderFile, const std::string& fragmentShaderFile)
 {
    this->setClassID(CL_SHADER, "Shader");
 
-   this->fragmentShaderFile = NULL;
-   this->vertexShaderFile = NULL;
+   this->fragmentShaderFile = "";
+   this->vertexShaderFile = "";
    this->shaderProgram = 0;
    this->vertexShader = 0;
@@ -52,7 +52,7 @@
        this->shaderProgram = glCreateProgramObjectARB();
 
-       if (vertexShaderFile != NULL)
+       if (!vertexShaderFile.empty())
          this->loadShaderProgramm(SHADER_VERTEX, vertexShaderFile);
-       if (fragmentShaderFile != NULL)
+       if (!fragmentShaderFile.empty())
          this->loadShaderProgramm(SHADER_FRAGMENT, fragmentShaderFile);
        glLinkProgramARB(this->shaderProgram);
@@ -103,5 +103,5 @@
 }
 
-Shader* Shader::getShader(const char* vertexShaderFile, const char* fragmentShaderFile)
+Shader* Shader::getShader(const std::string& vertexShaderFile, const std::string& fragmentShaderFile)
 {
   return (Shader*)ResourceManager::getInstance()->load(vertexShaderFile, SHADER,  RP_LEVEL, fragmentShaderFile);
@@ -116,5 +116,5 @@
 
 
-bool Shader::loadShaderProgramm(SHADER_TYPE type, const char* fileName)
+bool Shader::loadShaderProgramm(SHADER_TYPE type, const std::string& fileName)
 {
   GLhandleARB shader = 0;
@@ -129,6 +129,5 @@
   if (type == SHADER_VERTEX && GLEW_ARB_vertex_shader)
   {
-    this->vertexShaderFile = new char[strlen(fileName)+1];
-    strcpy(this->vertexShaderFile, fileName);
+    this->vertexShaderFile = fileName;
 
     shader = this->vertexShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
@@ -137,6 +136,5 @@
   if (type == SHADER_FRAGMENT && GLEW_ARB_fragment_shader)
   {
-    this->fragmentShaderFile = new char[strlen(fileName)+1];
-    strcpy(this->fragmentShaderFile, fileName);
+    this->fragmentShaderFile = fileName;
 
     shader = this->fragmentShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
@@ -146,5 +144,6 @@
   {
     GLint status = 0;
-    glShaderSourceARB(shader, program->size(), (const char**)&(*program)[0], NULL);
+    /// FIXME do it back
+    //    glShaderSourceARB(shader, program->size(), (const std::string&)&(*program)[0], NULL);
     glCompileShaderARB(shader);
     // checking on error.
@@ -160,5 +159,5 @@
 }
 
-char* Shader::fileRead(const char* fileName)
+char* Shader::fileRead(const std::string& fileName)
 {
   FILE* fileHandle;
@@ -167,8 +166,8 @@
   int count = 0;
 
-  if (fileName == NULL)
+  if (fileName.empty())
     return NULL;
 
-  fileHandle = fopen(fileName, "rt");
+  fileHandle = fopen(fileName.c_str(), "rt");
 
   if (fileHandle == NULL)
@@ -187,11 +186,11 @@
 
 
-std::vector<char*>* Shader::fileReadArray(const char* fileName)
+std::vector<char*>* Shader::fileReadArray(const std::string& fileName)
 {
   FILE*    stream;           //< The stream we use to read the file.
 
-  if( (stream = fopen (fileName, "rt")) == NULL)
-  {
-    PRINTF(1)("Shader could not open %s\n", fileName);
+  if( (stream = fopen (fileName.c_str(), "rt")) == NULL)
+  {
+    PRINTF(1)("Shader could not open %s\n", fileName.c_str());
     return NULL;
   }
@@ -234,6 +233,5 @@
   if (type == SHADER_VERTEX && this->vertexShader != 0)
   {
-    delete[] this->vertexShaderFile;
-    this->vertexShaderFile = NULL;
+    this->vertexShaderFile = "";
     glDetachObjectARB(this->shaderProgram, this->vertexShader);
     glDeleteObjectARB(this->vertexShader);
@@ -245,6 +243,5 @@
   else if (type == SHADER_FRAGMENT && this->fragmentShader != 0)
   {
-    delete[] this->fragmentShaderFile;
-    this->fragmentShaderFile = NULL;
+    this->fragmentShaderFile = "";
     glDetachObjectARB(this->shaderProgram, this->fragmentShader);
     glDeleteObjectARB(this->fragmentShader);
Index: trunk/src/lib/graphics/shader.h
===================================================================
--- trunk/src/lib/graphics/shader.h	(revision 7201)
+++ trunk/src/lib/graphics/shader.h	(revision 7221)
@@ -27,16 +27,16 @@
 
   public:
-  Shader(const char* vertexShaderFile = NULL, const char* fragmentShaderFile = NULL);
+  Shader(const std::string& vertexShaderFile = "", const std::string& fragmentShaderFile = "");
   virtual ~Shader();
-  static Shader* getShader(const char* vertexShaderFile, const char* fragmentShaderFile);
+  static Shader* getShader(const std::string& vertexShaderFile, const std::string& fragmentShaderFile);
   static bool unload(Shader* shader);
 
-  bool loadShaderProgramm(SHADER_TYPE type, const char* fileName);
+  bool loadShaderProgramm(SHADER_TYPE type, const std::string& fileName);
   void activateShader();
   static void deactivateShader();
   void deleteProgram(SHADER_TYPE type);
 
-  char* fileRead(const char* fileName);
-  std::vector<char*>* fileReadArray(const char* fileName);
+  char* fileRead(const std::string& fileName);
+  std::vector<char*>* fileReadArray(const std::string& fileName);
 
   static bool checkShaderAbility();
@@ -54,6 +54,6 @@
 
  private:
-   char*                  fragmentShaderFile;
-   char*                  vertexShaderFile;
+   std::string            fragmentShaderFile;
+   std::string            vertexShaderFile;
    GLhandleARB            shaderProgram;
    GLhandleARB            vertexShader;
Index: trunk/src/lib/graphics/text_engine/font.cc
===================================================================
--- trunk/src/lib/graphics/text_engine/font.cc	(revision 7201)
+++ trunk/src/lib/graphics/text_engine/font.cc	(revision 7221)
@@ -37,5 +37,5 @@
  * @param fontSize the Size of the Font in Pixels
  */
-Font::Font(const char* fontFile, unsigned int renderSize)
+Font::Font(const std::string& fontFile, unsigned int renderSize)
 {
   this->init();
@@ -44,5 +44,5 @@
   this->setStyle("c");
 
-  if (fontFile != NULL)
+  if (!fontFile.empty())
     this->loadFontFromTTF(fontFile);
 }
@@ -52,5 +52,5 @@
  * @param imageFile the ImageFile to load the Font From.
  */
-Font::Font(const char* imageFile)
+Font::Font(const std::string& imageFile)
 {
   this->init();
@@ -58,6 +58,6 @@
   //  this->setSize(fontSize);
   SDL_Surface* image = NULL;
-  if (imageFile != NULL)
-    image = IMG_Load(imageFile);
+  if (!imageFile.empty())
+    image = IMG_Load(imageFile.c_str());
   else
     return;
@@ -68,5 +68,5 @@
   }
   else
-    PRINTF(1)("loading from surface %s failed: %s\n", imageFile, IMG_GetError());
+    PRINTF(1)("loading from surface %s failed: %s\n", imageFile.c_str(), IMG_GetError());
 }
 
@@ -114,7 +114,7 @@
 
   //! @todo check if we really do not need to delete the fastTextureID here.
-//   if (this->fastTextureID != 0)
-//     if(glIsTexture(this->fastTextureID))
-//       glDeleteTextures(1, &this->fastTextureID);
+  //   if (this->fastTextureID != 0)
+  //     if(glIsTexture(this->fastTextureID))
+  //       glDeleteTextures(1, &this->fastTextureID);
 
   // erease this font out of the memory.
@@ -140,5 +140,5 @@
  * @returns true if loaded, false if something went wrong, or if a font was loaded before.
  */
-bool Font::loadFontFromTTF(const char* fontFile)
+bool Font::loadFontFromTTF(const std::string& fontFile)
 {
   // checking for existent Font.
@@ -222,20 +222,21 @@
  *   i: italic, b: bold, u, underline
  */
-void Font::setStyle(const char* renderStyle)
+void Font::setStyle(const std::string& renderStyle)
 {
   this->renderStyle = TTF_STYLE_NORMAL;
 
-  for (int i = 0; i < strlen(renderStyle); i++)
-    if (strncmp(renderStyle+i, "b", 1) == 0)
+  for (int i = 0; i < renderStyle.size(); i++)
+  {
+    if (renderStyle[i] == 'b')
       this->renderStyle |= TTF_STYLE_BOLD;
-  else if (strncmp(renderStyle+i, "i", 1) == 0)
-    this->renderStyle |= TTF_STYLE_ITALIC;
-  else if (strncmp(renderStyle+i, "u", 1) == 0)
-    this->renderStyle |= TTF_STYLE_UNDERLINE;
-
+    else if (renderStyle[i] == 'i')
+      this->renderStyle |= TTF_STYLE_ITALIC;
+    else if (renderStyle[i] == 'u')
+      this->renderStyle |= TTF_STYLE_UNDERLINE;
+  }
   if (likely(this->fontTTF != NULL))
     TTF_SetFontStyle(this->fontTTF, this->renderStyle);
-//  else
-//    PRINTF(2)("Font was not initialized, please do so before setting the Font-Style.\n");
+  //  else
+  //    PRINTF(2)("Font was not initialized, please do so before setting the Font-Style.\n");
 }
 
@@ -247,5 +248,5 @@
  * @param fileName the File to write the image into.
  */
-void Font::createAsciiImage(const char* fileName, unsigned int size) const
+void Font::createAsciiImage(const std::string& fileName, unsigned int size) const
 {
   if (this->fontTTF == NULL)
@@ -258,16 +259,16 @@
   SDL_Rect tmpRect; // this represents a Rectangle for blitting.
   SDL_Surface* tmpSurf =  SDL_CreateRGBSurface(SDL_SWSURFACE,
-                                               height*size, height*size,
-                                               32,
+                          height*size, height*size,
+                          32,
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN /* OpenGL RGBA masks */
-                                               0x000000FF,
-                                               0x0000FF00,
-                                               0x00FF0000,
-                                               0xFF000000
+                          0x000000FF,
+                          0x0000FF00,
+                          0x00FF0000,
+                          0xFF000000
 #else
-                                               0xFF000000,
-                                               0x00FF0000,
-                                               0x0000FF00,
-                                               0x000000FF
+                          0xFF000000,
+                          0x00FF0000,
+                          0x0000FF00,
+                          0x000000FF
 #endif
                                               );
@@ -299,5 +300,5 @@
     }
   }
-  SDL_SaveBMP(tmpSurf, fileName);
+  SDL_SaveBMP(tmpSurf, fileName.c_str());
   SDL_FreeSurface(tmpSurf);
 }
@@ -409,5 +410,5 @@
 
   this->initGlyphs(32, numberOfGlyphs);
-//  this->glyphArray[32]->width = .5f; //!< @todo find out the real size of a Space
+  //  this->glyphArray[32]->width = .5f; //!< @todo find out the real size of a Space
 
   int rectSize = this->findOptimalFastTextureSize();
@@ -418,16 +419,16 @@
   SDL_Rect tmpRect; // this represents a Rectangle for blitting.
   SDL_Surface* tmpSurf =  SDL_CreateRGBSurface(SDL_SWSURFACE,
-                                               rectSize, rectSize,
-                                               32,
+                          rectSize, rectSize,
+                          32,
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN /* OpenGL RGBA masks */
-                                               0x000000FF,
-                                               0x0000FF00,
-                                               0x00FF0000,
-                                               0xFF000000
+                          0x000000FF,
+                          0x0000FF00,
+                          0x00FF0000,
+                          0xFF000000
 #else
-                                               0xFF000000,
-                                               0x00FF0000,
-                                               0x0000FF00,
-                                               0x000000FF
+                          0xFF000000,
+                          0x00FF0000,
+                          0x0000FF00,
+                          0x000000FF
 #endif
                                               );
@@ -457,5 +458,5 @@
         break;
       }
-          // reading in the new Glyph
+      // reading in the new Glyph
       if (likely(this->fontTTF != NULL))
       {
@@ -521,5 +522,5 @@
   for (int i = from; i <= lastGlyph; i++)
   {
-      // setting up all the Glyphs we like.
+    // setting up all the Glyphs we like.
     glyphArray[i] = getGlyphMetrics(i);
   }
@@ -555,5 +556,5 @@
       if((tmpGlyph = this->glyphArray[i]) != NULL)
       {
-              // getting the height of the highest Glyph in the Line.
+        // getting the height of the highest Glyph in the Line.
         if (tmpGlyph->height*this->renderSize > maxLineHeight)
           maxLineHeight = (int)(tmpGlyph->height*this->renderSize);
@@ -563,5 +564,5 @@
           x = 0;
           y = y + maxLineHeight;
-                  //maxLineHeight = 0;
+          //maxLineHeight = 0;
         }
         if (y + maxLineHeight + 1 > size)
@@ -592,5 +593,6 @@
   if(style==TTF_STYLE_NORMAL)
     PRINTF(0)(" normal");
-  else {
+  else
+  {
     if(style&TTF_STYLE_BOLD)
       PRINTF(0)(" bold");
Index: trunk/src/lib/graphics/text_engine/font.h
===================================================================
--- trunk/src/lib/graphics/text_engine/font.h	(revision 7201)
+++ trunk/src/lib/graphics/text_engine/font.h	(revision 7221)
@@ -55,7 +55,7 @@
 {
   public:
-    Font(const char* fontFile,
+    Font(const std::string& fontFile,
          unsigned int renderSize);
-    Font(const char* imageFile);
+    Font(const std::string& imageFile);
     Font(char** xpmArray);
     virtual ~Font();
@@ -64,8 +64,8 @@
 
   //  font
-    bool loadFontFromTTF(const char* fontFile);
+    bool loadFontFromTTF(const std::string& fontFile);
     bool loadFontFromSDL_Surface(SDL_Surface* surface);
 
-    void setStyle(const char* renderStyle);
+    void setStyle(const std::string& renderStyle);
 
     /** @returns a Pointer to the Array of Glyphs */
@@ -78,5 +78,5 @@
     inline static Font* getDefaultFont() { if (Font::defaultFont == NULL) initDefaultFont(); return Font::defaultFont; };
 
-    void createAsciiImage(const char* fileName, unsigned int size) const;
+    void createAsciiImage(const std::string& fileName, unsigned int size) const;
     static void initDefaultFont();
     static void removeDefaultFont();
Index: trunk/src/lib/graphics/text_engine/text.cc
===================================================================
--- trunk/src/lib/graphics/text_engine/text.cc	(revision 7201)
+++ trunk/src/lib/graphics/text_engine/text.cc	(revision 7221)
@@ -32,9 +32,9 @@
  * @param type The renderType to display this font in
  */
-Text::Text(const char* fontFile, unsigned int textSize)
+Text::Text(const std::string& fontFile, unsigned int textSize)
 {
   this->init();
 
-  if (fontFile != NULL)
+  if (!fontFile.empty())
     this->setFont(fontFile, FONT_DEFAULT_RENDER_SIZE);
   this->setSizeY2D(textSize);
@@ -50,7 +50,4 @@
   if (this->font != NULL && this->font != Font::getDefaultFont())
     ResourceManager::getInstance()->unload(this->font);
-
-  if (this->text)
-    delete[] this->text;
 }
 
@@ -64,11 +61,10 @@
   // initialize this Text
   this->font = NULL;
-  this->text = NULL;
-  this->externText = NULL;
+  this->text = "";
   this->setAlignment(TEXT_DEFAULT_ALIGNMENT);
   this->blending = TEXT_DEFAULT_BLENDING;
   this->color = TEXT_DEFAULT_COLOR;
   this->setSize(TEXT_DEFAULT_SIZE);
-  this->setText(NULL);
+  this->setText("");
 }
 
@@ -78,5 +74,5 @@
  * @param fontSize the Size of the Font
  */
-void Text::setFont(const char* fontFile, unsigned int fontSize)
+void Text::setFont(const std::string& fontFile, unsigned int fontSize)
 {
   Font* tmpFont;
@@ -90,5 +86,5 @@
 
   // load a new Font
-  if (fontFile != NULL)
+  if (!fontFile.empty())
   {
     tmpFont = (Font*)ResourceManager::getInstance()->load(fontFile, TTF, RP_GAME, (int)fontSize);
@@ -96,5 +92,5 @@
       this->font = tmpFont;
     else
-      PRINTF(2)("Font %s could not be loaded, probably file not found\n", fontFile);
+      PRINTF(2)("Font %s could not be loaded, probably file not found\n", fontFile.c_str());
   }
 }
@@ -104,29 +100,7 @@
  * @param text the new text to set
  */
-void Text::setText(const char* text, bool isExtern)
-{
-  if (isExtern)
-  {
-    this->externText = text;
-
-    if (unlikely(this->text != NULL))
-    {
-      delete[] this->text;
-      this->text = NULL;
-    }
-  }
-  else
-  {
-    this->externText = NULL;
-    if (this->text)
-      delete[] this->text;
-    if (text != NULL)
-    {
-      this->text = new char[strlen(text)+1];
-      strcpy(this->text, text);
-    }
-    else
-      this->text = NULL;
-  }
+void Text::setText(const std::string& text)
+{
+  this->text = text;
 
   // setting up the Text-Width if DYNAMIC
@@ -138,16 +112,12 @@
 
     float width = 0;
-    const char* tmpText = this->externText;
-    if (this->externText == NULL)
-      tmpText = this->text;
-    if (tmpText != NULL)
+    if (!this->text.empty())
     {
-      while (*tmpText != '\0')
+      for (unsigned int i = 0; i < this->text.size(); i++)
       {
-        if(glyphArray[*tmpText] != NULL)
+        if(glyphArray[this->text[i]] != NULL)
         {
-          width += glyphArray[*tmpText]->advance;
+          width += glyphArray[this->text[i]]->advance;
         }
-        tmpText++;
       }
       this->setSizeX2D(width *this->getSizeY2D());
@@ -190,8 +160,5 @@
     glBindTexture(GL_TEXTURE_2D, Font::getDefaultFont()->getTexture());
   }
-  const char* tmpText = this->externText;
-  if (this->externText == NULL)
-    tmpText = this->text;
-  if (likely(tmpText != NULL))
+  if (likely(!this->text.empty()))
   {
     glTranslatef(getAbsCoor2D().x, getAbsCoor2D().y, 0);
@@ -201,7 +168,7 @@
 
     glBegin(GL_QUADS);
-    while (likely(*tmpText != '\0'))
+    for (unsigned int i = 0; i < this->text.size(); i++)
     {
-      if(likely((tmpGlyph = glyphArray[*tmpText]) != NULL))
+      if(likely((tmpGlyph = glyphArray[this->text[i]]) != NULL))
       {
         glTexCoord2f(tmpGlyph->texCoord[1], tmpGlyph->texCoord[2]);
@@ -219,5 +186,4 @@
         posX += tmpGlyph->advance * this->getSizeY2D();
       }
-      ++tmpText;
     }
     glEnd();
@@ -232,8 +198,5 @@
 void Text::debug() const
 {
-  if (this->externText == NULL)
-    PRINT(0)("=== TEXT: %s ===\n", this->text);
-  else
-    PRINT(0)("=== TEXT: %s ===\n", this->externText);
+  PRINT(0)("=== TEXT: %s ===\n", this->text.c_str());
 
   if (this->getBindNode())
Index: trunk/src/lib/graphics/text_engine/text.h
===================================================================
--- trunk/src/lib/graphics/text_engine/text.h	(revision 7201)
+++ trunk/src/lib/graphics/text_engine/text.h	(revision 7221)
@@ -39,14 +39,14 @@
 {
   public:
-    Text(const char* fontFile = NULL, unsigned int fontSize = TEXT_DEFAULT_SIZE);
+    Text(const std::string& fontFile = "", unsigned int fontSize = TEXT_DEFAULT_SIZE);
     virtual ~Text();
     void init();
 
-    void setFont(const char* fontFile, unsigned int renderSize);
+    void setFont(const std::string& fontFile, unsigned int renderSize);
 
-    void setText(const char* text, bool isExtern = false);
+    void setText(const std::string& text);
 
     /** @returns the String this Text displays */
-    inline const char* getText() const { return (externText == NULL)?this->text:this->externText; };
+    inline const std::string& getText() const { return this->text; };
     /** @param blending the blending intensity to set (between 0.0 and 1.0) */
     inline void setBlending(float blending) { this->blending = blending; };
@@ -69,6 +69,5 @@
     Font*             font;           //!< Font of this text
 
-    char*             text;           //!< The text to display
-    const char*       externText;     //!< the text to Display from an external Source.
+    std::string       text;           //!< The text to display
     Vector            color;          //!< The color of the font.
     float             blending;       //!< The blending intensity.
Index: trunk/src/lib/gui/gl_gui/glgui_button.cc
===================================================================
--- trunk/src/lib/gui/gl_gui/glgui_button.cc	(revision 7201)
+++ trunk/src/lib/gui/gl_gui/glgui_button.cc	(revision 7221)
@@ -54,5 +54,5 @@
 }
 
-void GLGuiButton::setLabel(const char* label)
+void GLGuiButton::setLabel(const std::string& label)
 {
   this->label->setText(label);
Index: trunk/src/lib/gui/gl_gui/glgui_button.h
===================================================================
--- trunk/src/lib/gui/gl_gui/glgui_button.h	(revision 7201)
+++ trunk/src/lib/gui/gl_gui/glgui_button.h	(revision 7221)
@@ -35,5 +35,5 @@
 
    void init();
-   void setLabel(const char* label);
+   void setLabel(const std::string& label);
 
    virtual void draw() const;
Index: trunk/src/lib/gui/gl_gui/glgui_menu.h
===================================================================
--- trunk/src/lib/gui/gl_gui/glgui_menu.h	(revision 7201)
+++ trunk/src/lib/gui/gl_gui/glgui_menu.h	(revision 7221)
@@ -24,8 +24,8 @@
   void init();
 
-  void addItem(const char* itemName);
-  void removeItem(const char* itemName);
+  void addItem(const std::string& itemName);
+  void removeItem(const std::string& itemName);
   void removeItem(unsigned int itemNumber);
-  void selectItem(const char* itemName);
+  void selectItem(const std::string& itemName);
   void selectItem(unsigned int itemNumber);
 
Index: trunk/src/lib/gui/gl_gui/glgui_widget.h
===================================================================
--- trunk/src/lib/gui/gl_gui/glgui_widget.h	(revision 7201)
+++ trunk/src/lib/gui/gl_gui/glgui_widget.h	(revision 7221)
@@ -47,5 +47,5 @@
     virtual char* save() {};
     /** loads options of the Widget. @param loadString a string containing the Options */
-    virtual void load(const char* loadString) {};
+    virtual void load(const std::string& loadString) {};
 
     void show();
Index: trunk/src/lib/gui/gl_gui/glmenu/glmenu_imagescreen.cc
===================================================================
--- trunk/src/lib/gui/gl_gui/glmenu/glmenu_imagescreen.cc	(revision 7201)
+++ trunk/src/lib/gui/gl_gui/glmenu/glmenu_imagescreen.cc	(revision 7221)
@@ -13,5 +13,5 @@
    ### File Specific:
    main-programmer: Patrick Boenzli
-   co-programmer:
+   co-programmer: Benjamin GRauer
 */
 
@@ -84,8 +84,8 @@
 
 /**
-  *  sets the background image name
+  * @brief sets the background image name
   * @param backImageName name of the backgroun-image
  */
-void GLMenuImageScreen::setBackgroundImage (const char* backImageName)
+void GLMenuImageScreen::setBackgroundImage (const std::string& backImageName)
 {
   this->backMat->setDiffuseMap(backImageName);
@@ -93,5 +93,5 @@
 
 /**
- *  sets position of the ImageScreen
+ * @brief sets position of the ImageScreen
  * @param offsetX offset from the top left corner in percent(0-1) of the screensize
  * @param offsetY offset from the top left corner in percent(0-1) of the screensize
@@ -104,5 +104,5 @@
 
 /**
-  \brief sets size of the ImageScreen
+ * @brief sets size of the ImageScreen
  * @param scaleX the scaleing of the image into the x-direction (in percent (0-1))
  * @param scaleY the scaleing of the image into the y-direction (in percent (0-1))
@@ -115,9 +115,9 @@
 
 /**
-  \brief sets position and size of the ImageScreen
-* @param offsetX offset from the top left corner in percent(0-1) of the screensize
-* @param offsetY offset from the top left corner in percent(0-1) of the screensize
-* @param scaleX the scaleing of the image into the x-direction (in percent (0-1))
-* @param scaleY the scaleing of the image into the y-direction (in percent (0-1))
+ * @brief sets position and size of the ImageScreen
+ * @param offsetX offset from the top left corner in percent(0-1) of the screensize
+ * @param offsetY offset from the top left corner in percent(0-1) of the screensize
+ * @param scaleX the scaleing of the image into the x-direction (in percent (0-1))
+ * @param scaleY the scaleing of the image into the y-direction (in percent (0-1))
 */
 void GLMenuImageScreen::setPosScale(float offsetX, float offsetY, float scaleX, float scaleY)
@@ -130,5 +130,5 @@
  * @param barImage An image for the Bar
 */
-void GLMenuImageScreen::setBarImage(const char* barImage)
+void GLMenuImageScreen::setBarImage(const std::string& barImage)
 {
   this->barMat->setDiffuseMap(barImage);
@@ -136,5 +136,5 @@
 
 /**
- *  sets the Position and the Size of the bar
+ * @brief sets the Position and the Size of the bar
  * @param barX The Position in the x-direction in percent of the screen (0-1)
  * @param barY The Position in the y-direction in percent of the screen (0-1)
@@ -152,5 +152,5 @@
 
 /**
- *  set the maximum of countable steps
+ * @brief set the maximum of countable steps
  * @param maxValue of steps
 */
@@ -161,5 +161,5 @@
 
 /**
- *  set current value
+ * @brief set current value
  * @param currentValue value to set
 */
@@ -172,5 +172,5 @@
 
 /**
- *  get the current value
+ * @brief get the current value
  */
 int GLMenuImageScreen::getValue()
@@ -181,7 +181,7 @@
 
 /**
-  *  call this to trigger a progress event
-
-    this has to redraw the progress bar and the whole image
+ * @brief call this to trigger a progress event
+ *
+ * this has to redraw the progress bar and the whole image
  */
 void GLMenuImageScreen::step ()
@@ -199,5 +199,5 @@
 
 /**
- *  draws the ImageScreen to the screenbuffer
+ * @brief draws the ImageScreen to the screenbuffer
 */
 void GLMenuImageScreen::draw ()
Index: trunk/src/lib/gui/gl_gui/glmenu/glmenu_imagescreen.h
===================================================================
--- trunk/src/lib/gui/gl_gui/glmenu/glmenu_imagescreen.h	(revision 7201)
+++ trunk/src/lib/gui/gl_gui/glmenu/glmenu_imagescreen.h	(revision 7221)
@@ -13,7 +13,8 @@
 
 //! A class to display a loadScreen
-class GLMenuImageScreen : public BaseObject {
+class GLMenuImageScreen : public BaseObject
+{
 
- public:
+public:
   GLMenuImageScreen (const TiXmlElement* root = NULL);
   virtual void loadParams(const TiXmlElement* root);
@@ -22,10 +23,10 @@
   void draw();
 
-  void setBackgroundImage(const char* backImageName);
+  void setBackgroundImage(const std::string& backImageName);
   void setPosition(float offsetX, float offsetY);
   void setScale (float scaleX, float scaleY);
   void setPosScale(float offsetX, float offsetY, float scaleX, float scaleY);
 
-  void setBarImage(const char* barImage);
+  void setBarImage(const std::string& barImage);
   void setBarPosScale(float barX, float barY, float barW, float barH);
 
@@ -39,7 +40,7 @@
 
 
- private:
+private:
   // background image
-  char*         backImageName;       //!< the name of the file of the background image
+  std::string         backImageName;       //!< the name of the file of the background image
   float         offsetX;             //!< X-offset of the the image from the left
   float         offsetY;             //!< Y-offset of the image from the top
Index: trunk/src/lib/gui/gtk_gui/gui_exec.cc
===================================================================
--- trunk/src/lib/gui/gtk_gui/gui_exec.cc	(revision 7201)
+++ trunk/src/lib/gui/gtk_gui/gui_exec.cc	(revision 7221)
@@ -47,6 +47,6 @@
   Frame* execFrame;            //!< The Frame that holds the ExecutionOptions.
 
-  this->confFile = NULL;
-  this->confDir = NULL;
+  this->confFile = "";
+  this->confDir = "";
 
   execFrame = new Frame("Execute-Tags:");
@@ -137,8 +137,4 @@
 GuiExec::~GuiExec()
 {
-  if(this->confFile)
-    delete []this->confFile;
-  if(this->confDir)
-    delete []this->confDir;
 }
 
@@ -156,7 +152,7 @@
   //! @todo F** Windows-support
 #ifndef __WIN32__
-  mkdir(this->confDir, 0755);
+  mkdir(this->confDir.c_str(), 0755);
 #else /* __WiN32__ */
-  mkdir(this->confDir);
+  mkdir(this->confDir.c_str());
 #endif /* __WIN32__ */
 }
@@ -170,8 +166,7 @@
 void GuiExec::setConfFile(const char* fileName)
 {
-  if (!this->confDir)
+  if (this->confDir.empty())
     this->setConfDir("~/");
-  this->confFile = new char[strlen(this->confDir)+strlen(fileName)+2];
-  sprintf(this->confFile, "%s/%s", this->confDir, fileName);
+  this->confFile = this->confDir + "/" + fileName;
   PRINTF(5)("ConfigurationFile is %s.\n", this->confFile);
 }
@@ -182,5 +177,5 @@
 const char* GuiExec::getConfigFile() const
 {
-  return this->confFile;
+  return this->confFile.c_str();
 }
 
@@ -204,7 +199,6 @@
   IniParser iniParser;
   this->writeFileText(widget, &iniParser, 0);
-  char* fileName = ResourceManager::homeDirCheck(confFile);
+  std::string fileName = ResourceManager::homeDirCheck(confFile);
   iniParser.writeFile(fileName);
-  delete[] fileName;
 }
 
@@ -259,7 +253,6 @@
 void GuiExec::readFromFile(Widget* widget)
 {
-  char* fileName = ResourceManager::homeDirCheck(confFile);
+  std::string fileName = ResourceManager::homeDirCheck(confFile);
   IniParser iniParser(fileName);
-  delete[] fileName;
   if (!iniParser.isOpen())
     return;
@@ -267,13 +260,13 @@
   iniParser.firstSection();
   Widget* groupWidget = widget;
-  const char* groupName;
-  const char* widgetName;
+  std::string groupName;
+  std::string widgetName;
   VarInfo varInfo;
-  while (groupName = iniParser.getCurrentSection())
+  while ((groupName = iniParser.getCurrentSection()) != "")
   {
-    printf("GROUP:::%s\n", groupName);
-    if((groupWidget = locateGroup(widget, groupName, 1))==NULL)
+    PRINTF(4)("GROUP:::%s\n", groupName.c_str());
+    if((groupWidget = locateGroup(widget, groupName.c_str(), 1))==NULL)
       {
-	PRINTF(2)("!!There is no group called %s in this GUI.\n First best Widget will get the Infos assigned.\n Config-File will be updated in next Save\n", groupName);
+        PRINTF(2)("!!There is no group called %s in this GUI.\n First best Widget will get the Infos assigned.\n Config-File will be updated in next Save\n", groupName.c_str());
 	groupWidget = widget;
 	continue;
@@ -282,11 +275,11 @@
       PRINT(4)("Group %s located.\n", static_cast<Packer*>(groupWidget)->groupName);
 
-    const char* entryName;
+    std::string entryName;
     iniParser.firstVar();
-    while(entryName = iniParser.getCurrentName())
-    {
-      PRINTF(4)("ENTRY:::%s = %s\n", entryName, iniParser.getCurrentValue());
-      varInfo.variableName = entryName;
-      varInfo.variableValue = iniParser.getCurrentValue();
+    while((entryName = iniParser.getCurrentName()) != "")
+    {
+      PRINTF(4)("ENTRY:::%s = %s\n", entryName.c_str(), iniParser.getCurrentValue().c_str());
+      varInfo.variableName = entryName.c_str();
+      varInfo.variableValue = iniParser.getCurrentValue().c_str();
       groupWidget->walkThrough(this->readFileText, &varInfo, 0);
       iniParser.nextVar();
Index: trunk/src/lib/gui/gtk_gui/gui_exec.h
===================================================================
--- trunk/src/lib/gui/gtk_gui/gui_exec.h	(revision 7201)
+++ trunk/src/lib/gui/gtk_gui/gui_exec.h	(revision 7221)
@@ -11,4 +11,6 @@
 #include "gui_gtk.h"
 
+#include <string>
+
 class Widget;
 class CheckButton;
@@ -22,6 +24,6 @@
   CheckButton* saveSettings;   //!< A CheckBox for if the Options should be saved.
 
-  char* confDir;               //!< The directory of the orxonox-configuration-files.
-  char* confFile;              //!< The name of the .orxonox.conf(ig)-file.
+  std::string confDir;         //!< The directory of the orxonox-configuration-files.
+  std::string confFile;        //!< The name of the .orxonox.conf(ig)-file.
 
   //! A struct that holds informations about variables.
@@ -58,6 +60,6 @@
 struct HashTable
 {
-  char* name;           //!< name of the entry
-  char* value;          //!< value of the entry
+  std::string name;           //!< name of the entry
+  std::string value;          //!< value of the entry
   HashTable* next;      //!< pointer to the next entry
 };
Index: trunk/src/lib/lang/base_object.cc
===================================================================
--- trunk/src/lib/lang/base_object.cc	(revision 7201)
+++ trunk/src/lib/lang/base_object.cc	(revision 7221)
@@ -34,8 +34,8 @@
 BaseObject::BaseObject()
 {
+  this->classID = CL_BASE_OBJECT;
   this->className = "BaseObject";
-  this->classID = CL_BASE_OBJECT;
-
-  this->objectName = NULL;
+
+  this->objectName = "";
   this->classList = NULL;
   this->xmlElem = NULL;
@@ -52,6 +52,4 @@
 
   //  delete []this->className;
-  if (this->objectName)
-    delete[] this->objectName;
   if (this->xmlElem != NULL)
     delete this->xmlElem;
@@ -80,5 +78,5 @@
  * @param className the class name
 */
-void BaseObject::setClassID(ClassID classID, const char* className)
+void BaseObject::setClassID(ClassID classID, const std::string& className)
 {
   //printf("%s(0x%.8X)->%s(0x%.8X)\n", this->className, this->classID, className, classID);
@@ -95,15 +93,7 @@
  * @brief set the name of the Object
  */
-void BaseObject::setName (const char* objectName)
-{
-  if (this->objectName)
-    delete[] this->objectName;
-  if (objectName != NULL)
-  {
-    this->objectName = new char[strlen(objectName)+1];
-    strcpy(this->objectName, objectName);
-  }
-  else
-    this->objectName = NULL;
+void BaseObject::setName (const std::string& objectName)
+{
+  this->objectName = objectName;
 }
 
@@ -160,5 +150,5 @@
  * @returns true if it is, false otherwise
  */
-bool BaseObject::isA (const char* className) const
+bool BaseObject::isA (const std::string& className) const
 {
   ClassID classID = ClassList::StringToID(className);
@@ -173,8 +163,7 @@
  * @returns true on match, false otherwise.
  */
-bool BaseObject::operator==(const char* objectName)
-{
-  if (likely(this->objectName != NULL && objectName != NULL))
-    return (strcmp(this->objectName, objectName)) ? false : true;
+bool BaseObject::operator==(const std::string& objectName)
+{
+  return (this->objectName == objectName);
 }
 
@@ -197,7 +186,9 @@
 int BaseObject::writeState( const byte * data, int length, int sender )
 {
-  SYNCHELP_READ_BEGIN();
-
-  if ( objectName )
+  /// FIXME STD
+
+  /*  SYNCHELP_READ_BEGIN();
+
+  if ( !objectName.empty() )
   {
     delete[] objectName;
@@ -211,5 +202,5 @@
   }
 
-  return SYNCHELP_READ_N;
+  return SYNCHELP_READ_N;*/
 }
 
@@ -222,9 +213,10 @@
 int BaseObject::readState( byte * data, int maxLength )
 {
-  SYNCHELP_WRITE_BEGIN();
+///FIXME STD
+  /*  SYNCHELP_WRITE_BEGIN();
 
   //PRINTF(0)("objectname = %s\n", this->objectName);
   SYNCHELP_WRITE_STRING( this->objectName, NWT_BO_NAME );
 
-  return SYNCHELP_WRITE_N;
-}
+  return SYNCHELP_WRITE_N;*/
+}
Index: trunk/src/lib/lang/base_object.h
===================================================================
--- trunk/src/lib/lang/base_object.h	(revision 7201)
+++ trunk/src/lib/lang/base_object.h	(revision 7221)
@@ -16,4 +16,5 @@
 #endif
 
+#include <string>
 #include "stdincl.h"
 
@@ -30,12 +31,12 @@
 
   virtual void loadParams(const TiXmlElement* root);
-  void setName (const char* newName);
+  void setName (const std::string& newName);
   /** returns the Name of this Object */
-  inline const char* getName ()const { return this->objectName; };
+  inline const char* getName ()const { return this->objectName.c_str(); };
   /** @returns the XML-Element with whicht this Object was loaded */
   inline TiXmlNode* getXmlElem() const { return this->xmlElem; };
 
   /** @returns the className of the corresponding Object */
-  inline const char* getClassName() const { return this->className; };
+  inline const char* getClassName() const { return this->className.c_str(); };
   /** @returns the classID of the corresponding Object */
   inline int getClassID() const { return this->classID; };
@@ -43,8 +44,8 @@
 
   bool isA (ClassID classID) const;
-  bool isA (const char* className) const;
+  bool isA (const std::string& className) const;
   void whatIs() const;
 
-  bool operator==(const char* objectName);
+  bool operator==(const std::string& objectName);
   /** @param classID comparer for a ClassID @returns true on match, false otherwise */
   bool operator==(ClassID classID) { return this->isA(classID); };
@@ -54,10 +55,10 @@
 
  protected:
-  void setClassID(ClassID classID, const char* className);
+   void setClassID(ClassID classID, const std::string& className);
 
  private:
-    const char*        className;        //!< the name of the class
+    std::string        className;        //!< the name of the class
     long               classID;          //!< this is the id from the class_id.h enumeration
-    char*              objectName;       //!< The name of this object
+    std::string        objectName;       //!< The name of this object
 
     ClassList*         classList;        //!< Pointer to the ClassList this Object is inside of
Index: trunk/src/lib/lang/class_list.cc
===================================================================
--- trunk/src/lib/lang/class_list.cc	(revision 7201)
+++ trunk/src/lib/lang/class_list.cc	(revision 7221)
@@ -37,7 +37,7 @@
  *  Creates a new ClassList
 */
-ClassList::ClassList(ClassID classID, unsigned long classIDFull, const char* className)
-{
-  this->className = className;
+ClassList::ClassList(ClassID classID, unsigned long classIDFull, const std::string& className)
+  : className(className)
+{
   this->classID = classID;
   this->classIDFull = classIDFull;
@@ -56,5 +56,5 @@
 
 //! a List of all strings of all classes, that have registered so far.
-std::list<const char*> ClassList::classNames;
+std::list<std::string> ClassList::classNames;
 
 /**
@@ -67,10 +67,10 @@
  * !! Before unsing the ClassList, as it creates the ClassLits
  */
-ClassList* ClassList::addToClassList(BaseObject* objectPointer, ClassID classID, unsigned long classIDFull, const char* className)
+ClassList* ClassList::addToClassList(BaseObject* objectPointer, ClassID classID, unsigned long classIDFull, const std::string& className)
 {
   if (unlikely(classList == NULL))
     ClassList::classList = new list<ClassList>();
 
-  PRINTF(5)("subscribe a '%s'\n", className );
+  PRINTF(5)("subscribe a '%s'\n", className.c_str() );
 
   ClassList* regClass = ClassList::getClassList(classID);
@@ -113,5 +113,5 @@
  * befor it changes anything.
  */
-const std::list<const char*>* ClassList::getClassNames()
+const std::list<std::string>* ClassList::getClassNames()
 {
   if (ClassList::classNames.size() != ClassList::classList->size())
@@ -155,5 +155,5 @@
  * @return the List accessed by classID, or NULL if not found
  */
-const std::list<BaseObject*>* ClassList::getList(const char* className)
+const std::list<BaseObject*>* ClassList::getList(const std::string& className)
 {
   ClassList* fl;
@@ -191,7 +191,7 @@
  * @returns the ClassList with className as specifyer, or NULL if not
  */
-ClassList* ClassList::getClassList(const char* className)
-{
-  if (className == NULL)
+ClassList* ClassList::getClassList(const std::string& className)
+{
+  if (className.empty())
     return NULL;
   std::list<ClassList>::iterator classIT = find (classList->begin(), classList->end(), className);
@@ -207,5 +207,5 @@
  * @todo: speed this up!!
  */
-BaseObject* ClassList::getObject(const char* objectName, ClassID classID)
+BaseObject* ClassList::getObject(const std::string& objectName, ClassID classID)
 {
   if (classID != CL_NULL)
@@ -216,5 +216,5 @@
       std::list<BaseObject*>::iterator bo;
       for (bo = cl->objectList.begin(); bo != cl->objectList.end(); bo++)
-        if ((*bo)->getName() != NULL && !strcmp((*bo)->getName(), objectName))
+        if ((*bo)->getName() != NULL && objectName == (*bo)->getName())
           return (*bo);
     }
@@ -227,5 +227,5 @@
       std::list<BaseObject*>::iterator bo;
       for (bo = (*cl).objectList.begin(); bo != (*cl).objectList.end(); bo++)
-        if ((*bo)->getName() != NULL && !strcmp((*bo)->getName(), objectName))
+        if ((*bo)->getName() != NULL && objectName == (*bo)->getName())
           return (*bo);
     }
@@ -276,5 +276,5 @@
     if (object->isA((*cl).classID))
   {
-    PRINT(0)("=%s::0x%.8X=-", (*cl).className, (*cl).classID);
+    PRINT(0)("=%s::0x%.8X=-", (*cl).className.c_str(), (*cl).classID);
   }
 }
@@ -285,8 +285,10 @@
  * @return a String containing the name of the Class, NULL if the Class was not found
  */
-const char* ClassList::IDToString(ClassID classID)
-{
+const std::string& ClassList::IDToString(ClassID classID)
+{
+  static const std::string empty("");
+
   ClassList* cl = ClassList::getClassList(classID);
-  return (cl != NULL) ? cl->className : NULL;
+  return (cl != NULL) ? cl->className : empty;
 }
 
@@ -296,5 +298,5 @@
  * @return the ClassID. CL_NULL, if the class was not found.
  */
-ClassID ClassList::StringToID(const char* className)
+ClassID ClassList::StringToID(const std::string& className)
 {
   ClassList* cl = ClassList::getClassList(className);
@@ -307,10 +309,7 @@
  * @returns true on match, false otherwise
  */
-bool ClassList::operator==(const char* className)
-{
-  if (likely( className != NULL && this->className != NULL))
-    return (!strcmp(this->className, className));
-  else
-    return false;
+bool ClassList::operator==(const std::string& className)
+{
+  return (this->className == className);
 }
 
@@ -342,9 +341,9 @@
       while (pow(10, lenCount) <= (*cl).objectList.size())
         ++lenCount;
-      for (int i=0; i < 30-strlen((*cl).className) - lenCount; i++)
+      for (int i=0; i < 30-(*cl).className.size() - lenCount; i++)
         (niceString[i]) = ' ';
-      niceString[30-strlen((*cl).className) - lenCount] = '\0';
-
-      PRINT(0)("| CLASS %s::%s %d\n", (*cl).className, niceString, (*cl).objectList.size());
+      niceString[30-(*cl).className.size() - lenCount] = '\0';
+
+      PRINT(0)("| CLASS %s::%s %d\n", (*cl).className.c_str(), niceString, (*cl).objectList.size());
 
       if (debugLevel >=2 && (*cl).objectList.size() > 0)
@@ -371,5 +370,5 @@
  * @see ClassList::debug
  */
-void ClassList::debugS(const char* className, unsigned int debugLevel)
+void ClassList::debugS(const std::string& className, unsigned int debugLevel)
 {
   ClassList::debug(debugLevel, ClassList::StringToID(className));
Index: trunk/src/lib/lang/class_list.h
===================================================================
--- trunk/src/lib/lang/class_list.h	(revision 7201)
+++ trunk/src/lib/lang/class_list.h	(revision 7221)
@@ -10,4 +10,5 @@
 #include "class_id.h"
 #include <list>
+#include <string>
 #ifndef NULL
 #define NULL     0    //!< NULL
@@ -32,9 +33,9 @@
 class ClassList {
   public:
-    ClassList(ClassID classID, unsigned long classIDFull, const char* className);
+    ClassList(ClassID classID, unsigned long classIDFull, const std::string& className);
     virtual ~ClassList();
 
     /* MAINTENANCE FUNCTIONS THESE ARE !!ONLY FOR BASEOBJECT !! */
-    static ClassList*                     addToClassList(BaseObject* objectPointer, ClassID classID, unsigned long classIDFull, const char* className);
+    static ClassList*                     addToClassList(BaseObject* objectPointer, ClassID classID, unsigned long classIDFull, const std::string& className);
     static void                           removeFromClassList(BaseObject* objectPointer);
 
@@ -42,7 +43,7 @@
 
     static const std::list<BaseObject*>*  getList(ClassID classID = CL_NULL);// { return (ClassList* fl = ClassList::getClassList(classID) != NULL)? &(fl->objectList) : NULL; };
-    static const std::list<BaseObject*>*  getList(const char* className); // { return (ClassList* fl = ClassList::getClassList(className) != NULL)? &(fl->objectList) : NULL;  };
-    static const std::list<const char*>*  getClassNames();
-    static BaseObject*                    getObject(const char* name, ClassID classID = CL_NULL);
+    static const std::list<BaseObject*>*  getList(const std::string& className); // { return (ClassList* fl = ClassList::getClassList(className) != NULL)? &(fl->objectList) : NULL;  };
+    static const std::list<std::string>*  getClassNames();
+    static BaseObject*                    getObject(const std::string& name, ClassID classID = CL_NULL);
     static bool                           exists(const BaseObject* object, ClassID classID = CL_NULL);
 
@@ -51,28 +52,28 @@
     static void                           whatIs(const BaseObject* object);
 
-    static const char*                    IDToString(ClassID classID = CL_NULL);
-    static ClassID                        StringToID(const char* className);
+    static const std::string&             IDToString(ClassID classID = CL_NULL);
+    static ClassID                        StringToID(const std::string& className);
     static void                           debug(unsigned int debugLevel = 0, ClassID classID = CL_NULL);
-    static void                           debugS(const char* className = NULL, unsigned int debugLevel = 0);
+    static void                           debugS(const std::string& className = "", unsigned int debugLevel = 0);
 
     inline bool                           operator==(ClassID classID) { return (this->classID == classID); };
-    bool                                  operator==(const char* className);
+    bool                                  operator==(const std::string& className);
     inline ClassID                        getLeafClassID() const { return this->classID; };
 
   private:
     static ClassList*                     getClassList(ClassID classID);
-    static ClassList*                     getClassList(const char* className);
+    static ClassList*                     getClassList(const std::string& className);
 
   private:
-    ClassID                         classID;                //!< ClassID stored in this ClassList
-    unsigned long                   classIDFull;            //!< The Full ClassID of this Class.
+    ClassID                               classID;                //!< ClassID stored in this ClassList
+    unsigned long                         classIDFull;            //!< The Full ClassID of this Class.
 
-    const char*                     className;              //!< Name of the Class Stored here
+    const std::string                     className;              //!< Name of the Class Stored here
 
-    std::list<BaseObject*>          objectList;             //!< A list of Objects belonging to this Class
+    std::list<BaseObject*>                objectList;             //!< A list of Objects belonging to this Class
 
     // STATIC MEMBERS
-    static std::list<ClassList>*    classList;              //!< The first Class in the List
-    static std::list<const char*>   classNames;             //!< a List of all Names of all classes, that have registered so far.
+    static std::list<ClassList>*          classList;              //!< The first Class in the List
+    static std::list<std::string>         classNames;             //!< a List of all Names of all classes, that have registered so far.
 };
 
Index: trunk/src/lib/parser/ini_parser/ini_parser.cc
===================================================================
--- trunk/src/lib/parser/ini_parser/ini_parser.cc	(revision 7201)
+++ trunk/src/lib/parser/ini_parser/ini_parser.cc	(revision 7221)
@@ -40,10 +40,10 @@
  * @param fileName: the path and name of the file to parse
  */
-IniParser::IniParser (const char* fileName)
-{
-  this->fileName = NULL;
-  this->comment = NULL;
-
-  if (fileName != NULL)
+IniParser::IniParser (const std::string& fileName)
+{
+  this->fileName = "";
+  this->comment = "";
+
+  if (!fileName.empty())
     this->readFile(fileName);
 }
@@ -56,6 +56,8 @@
 {
   this->deleteSections();
-  this->setFileName(NULL);
-}
+  this->setFileName("");
+}
+
+const std::string IniParser::emptyString = "";
 
 
@@ -66,25 +68,8 @@
 {
   // in all sections
-  while(!this->sections.empty())
-  {
-     IniSection section = this->sections.front();
-
-    // in all entries of the sections
-    while(!section.entries.empty())
-    {
-      // delete all strings of entries.
-      IniEntry entry = section.entries.front();
-      delete[] entry.name;
-      delete[] entry.value;
-      delete[] entry.comment;
-      section.entries.pop_front();
-    }
-    // delete all Sections
-    delete[] section.name;
-    delete[] section.comment;
-    this->sections.pop_front();
-  }
+  this->sections.clear();
+
   this->currentSection = this->sections.end();
-  this->setFileName(NULL);
+  this->setFileName("");
 }
 
@@ -95,19 +80,8 @@
  * If fileName is NULL the new Name will be set to NULL too.
  */
-void IniParser::setFileName(const char* fileName)
-{
-  if (this->fileName != NULL)
-    delete[] this->fileName;
-  if  (this->comment != NULL)
-    delete[] this->comment;
-  this->comment = NULL;
-
-  if (fileName != NULL)
-  {
-    this->fileName = new char[strlen(fileName)+1];
-    strcpy(this->fileName, fileName);
-  }
-  else
-    this->fileName = NULL;
+void IniParser::setFileName(const std::string& fileName)
+{
+  this->comment = "";
+  this->fileName = fileName;
 }
 
@@ -121,17 +95,18 @@
  * and the new one will be opened.
  */
-bool IniParser::readFile(const char* fileName)
+bool IniParser::readFile(const std::string& fileName)
 {
   FILE*    stream;           //< The stream we use to read the file.
   int      lineCount = 0;    //< The Count of lines.
 
-  if (this->fileName != NULL)
+  if (!this->fileName.empty())
     this->deleteSections();
-  if( fileName == NULL)
-    return false;
-
-  if( (stream = fopen (fileName, "r")) == NULL)
-  {
-    PRINTF(1)("IniParser could not open %s\n", fileName);
+
+  if( fileName.empty())
+    return false;
+
+  if( (stream = fopen (fileName.c_str(), "r")) == NULL)
+  {
+    PRINTF(1)("IniParser could not open %s\n", fileName.c_str());
     return false;
   }
@@ -143,6 +118,6 @@
     // READING IN THE INI-FILE //
     /////////////////////////////
-    char lineBuffer[PARSELINELENGHT];
-    char buffer[PARSELINELENGHT];
+    char lineBuffer[PARSELINELENGHT+1];
+    char buffer[PARSELINELENGHT+1];
     const char* lineBegin;
     char* ptr;
@@ -154,13 +129,17 @@
       if( (ptr = strchr( lineBuffer, '\n')) != NULL)
         *ptr = 0;
+      else
+        lineBuffer[PARSELINELENGHT] = 0;
       // cut up to the beginning of the line.
       while((*lineBegin == ' ' || *lineBegin == '\t') && lineBegin < lineBuffer + strlen(lineBuffer))
         ++lineBegin;
 
+      if ( !strcmp( lineBegin, "" ) )
+        continue;
+
       // check if we have a FileComment
       if ( (*lineBegin == '#' || *lineBegin == ';'))
       {
-        char* newCommenLine = new char[strlen(lineBegin)+1];
-        strcpy(newCommenLine, lineBegin);
+        string newCommenLine = lineBegin;
         this->commentList.push_back(newCommenLine);
         continue;
@@ -191,5 +170,6 @@
           continue;
         }
-        if( ptr == lineBegin) {
+        if( ptr == lineBegin)
+        {
           lineCount++;
           continue;
@@ -228,53 +208,43 @@
  * @return true on success false otherwise
  */
-bool IniParser::writeFile(const char* fileName) const
+bool IniParser::writeFile(const std::string& fileName) const
 {
   FILE*    stream;           //!< The stream we use to read the file.
-  if( fileName == NULL && (fileName = this->fileName) == NULL )
-    return false;
-
-  if( (stream = fopen (fileName, "w")) == NULL)
-  {
-    PRINTF(1)("IniParser could not open %s\n", fileName);
-    return false;
-  }
-  else
-  {
-    if (this->comment != NULL)
-      fprintf(stream, "%s\n\n", this->comment);
+  if( fileName.empty())
+    return false;
+
+  if( (stream = fopen (fileName.c_str(), "w")) == NULL)
+  {
+    PRINTF(1)("IniParser could not open %s\n", fileName.c_str());
+    return false;
+  }
+  else
+  {
+    if (!this->comment.empty())
+      fprintf(stream, "%s\n\n", this->comment.c_str());
 
     std::list<IniSection>::const_iterator section;
     for (section = this->sections.begin(); section != this->sections.end(); section++)
+    {
+      if (!(*section).comment.empty())
+        fprintf(stream, "%s", (*section).comment.c_str());
+      fprintf(stream, "\n [%s]\n", (*section).name.c_str());
+
+      std::list<IniEntry>::const_iterator entry;
+      for (entry = (*section).entries.begin(); entry != (*section).entries.end(); entry++)
       {
-        if ((*section).comment != NULL)
-          fprintf(stream, "%s", (*section).comment);
-        fprintf(stream, "\n [%s]\n", (*section).name);
-
-        std::list<IniEntry>::const_iterator entry;
-        for (entry = (*section).entries.begin(); entry != (*section).entries.end(); entry++)
-        {
-          if ((*entry).comment != NULL)
-            fprintf(stream, "%s", (*entry).comment);
-          fprintf(stream, "   %s = %s\n", (*entry).name, (*entry).value);
-         }
+        if (!(*entry).comment.empty())
+          fprintf(stream, "%s", (*entry).comment.c_str());
+        fprintf(stream, "   %s = %s\n", (*entry).name.c_str(), (*entry).value.c_str());
       }
+    }
   }
   fclose(stream);
 }
 
-void IniParser::setFileComment(const char* fileComment)
-{
-  if (this->comment != NULL)
-    delete this->comment;
-
-  if (fileComment != NULL)
-  {
-    this->comment = new char[strlen(fileComment)+1];
-    strcpy(this->comment, fileComment);
-  }
-  else
-    this->comment = NULL;
-}
-
+void IniParser::setFileComment(const std::string& fileComment)
+{
+  this->comment = fileComment;
+}
 
 /**
@@ -284,17 +254,18 @@
  * @return true on success... there is only success or segfault :)
  */
-bool IniParser::addSection(const char* sectionName)
-{
-  if (sectionName == NULL)
-    return false;
-  this->sections.push_back(IniSection());
-  this->sections.back().comment = NULL;
-  this->sections.back().name = new char[strlen(sectionName)+1];
-  strcpy(this->sections.back().name, sectionName);
+bool IniParser::addSection(const std::string& sectionName)
+{
+  if (sectionName.empty())
+    return false;
+  IniSection newSection;
+  newSection.name = sectionName;
+  newSection.comment = "";
+
+  this->sections.push_back(newSection);
 
   this->currentSection = --this->sections.end();
   if (!this->sections.empty())
-      this->currentEntry = (*this->currentSection).entries.begin();
-  PRINTF(5)("Added Section %s\n", sectionName);
+    this->currentEntry = (*this->currentSection).entries.begin();
+  PRINTF(5)("Added Section %s\n", sectionName.c_str());
   return true;
 }
@@ -306,5 +277,5 @@
  * @return true on success or false if the section could not be found
  */
-bool IniParser::getSection(const char* sectionName)
+bool IniParser::getSection(const std::string& sectionName)
 {
   this->currentSection = this->getSectionIT(sectionName);
@@ -321,5 +292,5 @@
  *
  */
-void IniParser::setSectionComment(const char* comment, const char* sectionName)
+void IniParser::setSectionComment(const std::string& comment, const std::string& sectionName)
 {
   std::list<IniSection>::iterator section = this->getSectionIT(sectionName);
@@ -327,13 +298,5 @@
     return;
 
-  if ((*section).comment != NULL)
-    delete[] (*section).comment;
-  if (comment != NULL)
-  {
-    (*section).comment = new char[strlen (comment)+1];
-    strcpy((*section).comment, comment);
-  }
-  else
-    (*section).comment = NULL;
+  (*section).comment = comment;
 }
 
@@ -342,5 +305,5 @@
  * @returns the Comment, or NULL on error.
  */
-const char* IniParser::getSectionComment(const char* sectionName) const
+const std::string& IniParser::getSectionComment(const std::string& sectionName) const
 {
   std::list<IniSection>::const_iterator section = this->getSectionIT(sectionName);
@@ -348,5 +311,5 @@
     return (*section).comment;
   else
-    return NULL;
+    return IniParser::emptyString;
 }
 
@@ -367,18 +330,18 @@
  * @returns the name of the section if found, NULL otherwise
  */
-const char* IniParser::nextSection()
+const std::string& IniParser::nextSection()
 {
   if (this->currentSection == this->sections.end())
-    return NULL;
+    return IniParser::emptyString;
 
   this->currentSection++;
 
   if (this->currentSection != this->sections.end())
-    {
-      this->currentEntry = (*this->currentSection).entries.begin();
-      return this->currentSection->name;
-    }
-  else
-    return NULL;
+  {
+    this->currentEntry = (*this->currentSection).entries.begin();
+    return this->currentSection->name;
+  }
+  else
+    return IniParser::emptyString;
 }
 
@@ -393,12 +356,12 @@
  * @return true if everything is ok false on error
  */
-bool IniParser::addVar(const char* entryName, const char* value, const char* sectionName)
+bool IniParser::addVar(const std::string& entryName, const std::string& value, const std::string& sectionName)
 {
   std::list<IniSection>::iterator section;
 
-  if (sectionName != NULL)
+  if (!sectionName.empty())
   {
     for (section = this->sections.begin(); section != this->sections.end(); section++)
-      if (!strcmp((*section).name, sectionName))
+      if ((*section).name == sectionName)
         break;
   }
@@ -411,5 +374,5 @@
   if (section == this->sections.end())
   {
-    PRINTF(2)("section '%s' not found for value '%s'\n", sectionName, entryName);
+    PRINTF(2)("section '%s' not found for value '%s'\n", sectionName.c_str(), entryName.c_str());
     return false;
   }
@@ -417,13 +380,11 @@
   {
     (*section).entries.push_back(IniEntry());
-    (*section).entries.back().comment = NULL;
-    (*section).entries.back().name = new char[strlen(entryName)+1];
-    strcpy((*section).entries.back().name, entryName);
-    (*section).entries.back().value = new char[strlen(value)+1];
-    strcpy((*section).entries.back().value, value);
+    (*section).entries.back().comment = "";
+    (*section).entries.back().name = entryName;
+    (*section).entries.back().value = value;
     PRINTF(5)("Added Entry %s with Value '%s' to Section %s\n",
-              (*section).entries.back().name,
-              (*section).entries.back().value,
-              (*section).name);
+              (*section).entries.back().name.c_str(),
+              (*section).entries.back().value.c_str(),
+              (*section).name.c_str());
     this->currentEntry = --(*section).entries.end();
     return true;
@@ -442,13 +403,12 @@
  * lead to unwanted behaviour.
 */
-const char* IniParser::getVar(const char* entryName, const char* sectionName, const char* defaultValue) const
-{
-  if (this->fileName != NULL)
+const std::string& IniParser::getVar(const std::string& entryName, const std::string& sectionName, const std::string& defaultValue) const
+{
+  if (!this->fileName.empty())
   {
     std::list<IniEntry>::const_iterator entry = this->getEntryIT(entryName, sectionName);
-    if (entry != NULL &&  !strcmp((*entry).name, entryName))
+    if (entry != NULL &&  (*entry).name == entryName)
       return (*entry).value;
-    PRINTF(2)("Entry '%s' in section '%s' not found.\n", entryName, sectionName);
-
+    PRINTF(2)("Entry '%s' in section '%s' not found.\n", entryName.c_str(), sectionName.c_str());
   }
   else
@@ -456,5 +416,4 @@
 
   return defaultValue;
-
 }
 
@@ -465,19 +424,8 @@
  * @param sectionName the Name of the Section
  */
-void IniParser::setEntryComment(const char* comment, const char* entryName, const char* sectionName)
+void IniParser::setEntryComment(const std::string& comment, const std::string& entryName, const std::string& sectionName)
 {
   std::list<IniEntry>::iterator entry = this->getEntryIT(entryName, sectionName);
-
-  if ((*entry).comment != NULL)
-    delete[] (*entry).comment;
-  if (comment != NULL)
-  {
-    (*entry).comment = new char[strlen (comment)+1];
-    strcpy((*entry).comment, comment);
-  }
-  else
-    (*entry).comment = NULL;
-
-
+  (*entry).comment = comment;
 }
 
@@ -487,5 +435,5 @@
  * @returns the queried Comment.
  */
-const char* IniParser::getEntryComment(const char* entryName, const char* sectionName) const
+const std::string& IniParser::getEntryComment(const std::string& entryName, const std::string& sectionName) const
 {
   std::list<IniEntry>::const_iterator entry = this->getEntryIT(entryName, sectionName);
@@ -501,5 +449,5 @@
 {
   if (!this->sections.empty() &&
-       this->currentSection != this->sections.end())
+      this->currentSection != this->sections.end())
     this->currentEntry = (*this->currentSection).entries.begin();
 }
@@ -530,5 +478,5 @@
  * @returns the name of the Current selected Section
  */
-const char* IniParser::getCurrentSection() const
+const std::string& IniParser::getCurrentSection() const
 {
   if (!this->sections.empty() &&
@@ -536,6 +484,6 @@
     return this->currentSection->name;
   else
-    return NULL;
- }
+    return IniParser::emptyString ;
+}
 
 
@@ -543,12 +491,12 @@
  * @returns the current entries Name, or NULL if we havn't selected a Entry
  */
-const char* IniParser::getCurrentName() const
-{
- if (!this->sections.empty() &&
-     this->currentSection != this->sections.end() &&
-     this->currentEntry != (*this->currentSection).entries.end())
-   return (*this->currentEntry).name;
- else
-   return NULL;
+const std::string& IniParser::getCurrentName() const
+{
+  if (!this->sections.empty() &&
+      this->currentSection != this->sections.end() &&
+      this->currentEntry != (*this->currentSection).entries.end())
+    return (*this->currentEntry).name;
+  else
+    return emptyString;
 }
 
@@ -556,5 +504,5 @@
  * @returns the current entries Value, or NULL if we havn't selected a Entry
  */
-const char* IniParser::getCurrentValue() const
+const std::string& IniParser::getCurrentValue() const
 {
   if (!this->sections.empty() &&
@@ -563,5 +511,5 @@
     return (*this->currentEntry).value;
   else
-    return NULL;
+    return IniParser::emptyString;
 }
 
@@ -571,12 +519,12 @@
  * @param sectionName the Name of the Section to get the Iterator from
  */
-std::list<IniParser::IniSection>::const_iterator IniParser::getSectionIT(const char* sectionName) const
+std::list<IniParser::IniSection>::const_iterator IniParser::getSectionIT(const std::string& sectionName) const
 {
   std::list<IniSection>::const_iterator section = this->currentSection;
-  if (sectionName == NULL)
+  if (sectionName.empty())
     return this->currentSection;
   else
     for (section = this->sections.begin(); section != this->sections.end(); section++)
-      if (!strcmp((*section).name, sectionName))
+      if ((*section).name == sectionName)
         break;
   return section;
@@ -588,12 +536,12 @@
  * @param sectionName the Name of the Section to get the Iterator from
  */
-std::list<IniParser::IniSection>::iterator IniParser::getSectionIT(const char* sectionName)
+std::list<IniParser::IniSection>::iterator IniParser::getSectionIT(const std::string& sectionName)
 {
   std::list<IniSection>::iterator section = this->currentSection;
-  if (sectionName == NULL)
+  if (sectionName.empty())
     return this->currentSection;
   else
     for (section = this->sections.begin(); section != this->sections.end(); section++)
-      if (!strcmp((*section).name, sectionName))
+      if ((*section).name == sectionName)
         break;
   return section;
@@ -606,7 +554,7 @@
  * @param sectionName the Name of the Section to get the Iterator from
  */
-std::list<IniParser::IniEntry>::const_iterator IniParser::getEntryIT(const char* entryName, const char* sectionName) const
-{
-  if (entryName == NULL)
+std::list<IniParser::IniEntry>::const_iterator IniParser::getEntryIT(const std::string& entryName, const std::string& sectionName) const
+{
+  if (entryName.empty())
     return this->currentEntry;
   std::list<IniSection>::const_iterator section = this->getSectionIT(sectionName);
@@ -615,5 +563,5 @@
   if (section != this->sections.end())
     for (entry = (*section).entries.begin(); entry != (*section).entries.end(); entry++)
-      if (!strcmp((*entry).name, entryName))
+      if ((*entry).name == entryName)
         break;
   if (entry == (*section).entries.end())
@@ -629,7 +577,7 @@
  * @param sectionName the Name of the Section to get the Iterator from
  */
-std::list<IniParser::IniEntry>::iterator IniParser::getEntryIT(const char* entryName, const char* sectionName)
-{
-  if (entryName == NULL)
+std::list<IniParser::IniEntry>::iterator IniParser::getEntryIT(const std::string& entryName, const std::string& sectionName)
+{
+  if (entryName.empty())
     return this->currentEntry;
   std::list<IniSection>::iterator section = this->getSectionIT(sectionName);
@@ -638,5 +586,5 @@
   if (section != this->sections.end())
     for (entry = (*section).entries.begin(); entry != (*section).entries.end(); entry++)
-      if (!strcmp((*entry).name, entryName))
+      if ((*entry).name == entryName)
         break;
   if (entry == (*section).entries.end())
@@ -652,25 +600,17 @@
 void IniParser::setFileComment()
 {
-  if (this->comment != NULL)
-    delete[] this->comment;
-
-  if (this->commentList.empty()) {
-    this->comment = NULL;
+  if (this->commentList.empty())
+  {
+    this->comment = "";
     return;
   }
 
-  unsigned int stringLength = 1;
   std::list<char*>::iterator comment;
-  for (comment = this->commentList.begin(); comment != this->commentList.end(); comment++)
-    stringLength += strlen((*comment)) +1;
-
-  this->comment = new char[stringLength];
-  this->comment[0] = '\0';
+
   while (!this->commentList.empty())
   {
-    if (*this->comment != '\0')
-      strcat(this->comment, "\n");
-    strcat(this->comment, this->commentList.front());
-    delete[] this->commentList.front();
+    if (this->comment[0] != '\0')
+      this->comment += "\n";
+    this->comment += this->commentList.front();
     this->commentList.pop_front();
   }
@@ -682,25 +622,14 @@
 void IniParser::setSectionComment()
 {
-  if ((*this->currentSection).comment != NULL)
-    delete[] (*this->currentSection).comment;
-
-  if (this->commentList.empty()) {
-    (*this->currentSection).comment = NULL;
+  (*this->currentSection).comment = "";
+
+  if (this->commentList.empty())
     return;
-  }
-
-  unsigned int stringLength = 1;
-  std::list<char*>::iterator comment;
-  for (comment = this->commentList.begin(); comment != this->commentList.end(); comment++)
-    stringLength += strlen((*comment)) +1;
-
-  (*this->currentSection).comment = new char[stringLength];
-  (*this->currentSection).comment[0] = '\0';
+
   while (!this->commentList.empty())
   {
-    if (*(*this->currentSection).comment != '\0')
-      strcat((*this->currentSection).comment, "\n");
-    strcat((*this->currentSection).comment, this->commentList.front());
-    delete[] this->commentList.front();
+    if ((*this->currentSection).comment[0] != '\0')
+      (*this->currentSection).comment += "\n";
+    (*this->currentSection).comment += this->commentList.front();
     this->commentList.pop_front();
   }
@@ -712,28 +641,15 @@
 void IniParser::setEntryComment()
 {
-  if ((*this->currentEntry).comment != NULL)
-    delete[] (*this->currentEntry).comment;
-
-  if (this->commentList.empty()) {
-    (*this->currentEntry).comment = NULL;
+  (*this->currentEntry).comment = "";
+  if (this->commentList.empty())
     return;
-  }
-
-  unsigned int stringLength = 1;
-  std::list<char*>::iterator comment;
-  for (comment = this->commentList.begin(); comment != this->commentList.end(); comment++)
-    stringLength += strlen((*comment)) +1;
-
-  (*this->currentEntry).comment = new char[stringLength];
-  (*this->currentEntry).comment[0] = '\0';
+
   while (!this->commentList.empty())
   {
-    if (*(*this->currentEntry).comment != '\0')
-      strcat((*this->currentEntry).comment, "\n");
-    strcat((*this->currentEntry).comment, this->commentList.front());
-    delete[] this->commentList.front();
+    if ((*this->currentEntry).comment[0] != '\0')
+      (*this->currentEntry).comment += "\n";
+    (*this->currentEntry).comment += this->commentList.front();
     this->commentList.pop_front();
   }
-
 }
 
@@ -744,23 +660,23 @@
 void IniParser::debug() const
 {
-  PRINTF(0)("Iniparser %s - debug\n", this->fileName);
-  if (this->comment != NULL)
-    PRINTF(0)("FileComment:\n %s\n\n", this->comment);
-
-  if (this->fileName != NULL)
+  PRINTF(0)("Iniparser %s - debug\n", this->fileName.c_str());
+  if (!this->comment.empty())
+    PRINTF(0)("FileComment:\n %s\n\n", this->comment.c_str());
+
+  if (!this->fileName.empty())
   {
     std::list<IniSection>::const_iterator section;
     for (section = this->sections.begin(); section != this->sections.end(); section++)
     {
-      if ((*section).comment != NULL)
-        PRINTF(0)(" %s\n", (*section).comment);
-      PRINTF(0)(" [%s]\n", (*section).name);
+      if (!(*section).comment.empty())
+        PRINTF(0)(" %s\n", (*section).comment.c_str());
+      PRINTF(0)(" [%s]\n", (*section).name.c_str());
 
       std::list<IniEntry>::const_iterator entry;
       for (entry = (*section).entries.begin(); entry != (*section).entries.end(); entry++)
       {
-        if ((*entry).comment != NULL)
-          PRINTF(0)(" %s\n", (*entry).comment);
-        PRINTF(0)("   '%s' -> '%s'\n", (*entry).name, (*entry).value);
+        if (!(*entry).comment.empty())
+          PRINTF(0)(" %s\n", (*entry).comment.c_str());
+        PRINTF(0)("   '%s' -> '%s'\n", (*entry).name.c_str(), (*entry).value.c_str());
       }
     }
Index: trunk/src/lib/parser/ini_parser/ini_parser.h
===================================================================
--- trunk/src/lib/parser/ini_parser/ini_parser.h	(revision 7201)
+++ trunk/src/lib/parser/ini_parser/ini_parser.h	(revision 7221)
@@ -15,4 +15,5 @@
 
 #include <list>
+#include <string>
 
 //! ini-file parser
@@ -27,7 +28,7 @@
     struct IniEntry
     {
-      char*               comment;  //!< A Comment that is appendet to the Top of this Entry.
-      char*               name;     //!< name of a given Entry
-      char*               value;    //!< value of a given Entry
+      std::string         comment;  //!< A Comment that is appendet to the Top of this Entry.
+      std::string         name;     //!< name of a given Entry
+      std::string         value;    //!< value of a given Entry
     };
 
@@ -35,6 +36,6 @@
     struct IniSection
     {
-      char*               comment;  //!< A Comment that is appendet to the Top of this Section.
-      char*               name;     //!< name of a given section
+      std::string         comment;  //!< A Comment that is appendet to the Top of this Section.
+      std::string         name;     //!< name of a given section
       std::list<IniEntry> entries;  //!< a list of entries for this section
     };
@@ -42,32 +43,32 @@
 
   public:
-    IniParser (const char* filename = NULL);
+    IniParser (const std::string& filename = "");
     virtual ~IniParser ();
 
     /** @returns true if the file is opened, false otherwise*/
-    bool isOpen() const { return (this->fileName != NULL)? true : false; };
+    bool isOpen() const { return (!this->fileName.empty())? true : false; };
     /** @returns the fileName we have opened. */
-    const char* getFileName() const { return this->fileName; };
+    const std::string& getFileName() const { return this->fileName; };
 
-    bool readFile(const char* fileName);
-    bool writeFile(const char* fileName) const;
+    bool readFile(const std::string& fileName);
+    bool writeFile(const std::string& fileName) const;
 
-    void setFileComment(const char* fileComment);
-    const char* getFileComment() const { return this->comment; };
+    void setFileComment(const std::string& fileComment);
+    const std::string& getFileComment() const { return this->comment; };
 
-    bool addSection(const char* sectionName);
-    bool getSection(const char* sectionName);
-    void setSectionComment(const char* comment, const char* sectionName);
-    const char* getSectionComment(const char* sectionNane) const;
+    bool addSection(const std::string& sectionName);
+    bool getSection(const std::string& sectionName);
+    void setSectionComment(const std::string& comment, const std::string& sectionName);
+    const std::string& getSectionComment(const std::string& sectionNane) const;
 
     // iterate through sections with these Functions
     void firstSection();
-    const char* nextSection();
+    const std::string& nextSection();
 
 
-    bool addVar(const char* entryName, const char* value, const char* sectionName = NULL);
-    const char* getVar(const char* entryName, const char* sectionName, const char* defaultValue = "") const;
-    void setEntryComment(const char* comment, const char* entryName, const char* sectionName);
-    const char* getEntryComment(const char* entryName, const char* sectionName) const;
+    bool addVar(const std::string& entryName, const std::string& value, const std::string& sectionName = "" );
+    const std::string& getVar(const std::string& entryName, const std::string& sectionName, const std::string& defaultValue = "") const;
+    void setEntryComment(const std::string& comment, const std::string& entryName, const std::string& sectionName);
+    const std::string& getEntryComment(const std::string& entryName, const std::string& sectionName) const;
 
     // iterate Through Variables with these Functions.
@@ -77,7 +78,7 @@
 
     // retrieving functions when iterating.
-    const char* getCurrentSection() const;
-    const char* getCurrentName() const;
-    const char* getCurrentValue() const;
+    const std::string& getCurrentSection() const;
+    const std::string& getCurrentName() const;
+    const std::string& getCurrentValue() const;
 
 
@@ -88,5 +89,5 @@
   private:
     void deleteSections();
-    void setFileName(const char* fileName);
+    void setFileName(const std::string& fileName);
 
     void setFileComment();
@@ -94,18 +95,21 @@
     void setEntryComment();
 
-    std::list<IniSection>::const_iterator getSectionIT(const char* sectionName) const;
-    std::list<IniSection>::iterator getSectionIT(const char* sectionName);
+    std::list<IniSection>::const_iterator getSectionIT(const std::string& sectionName) const;
+    std::list<IniSection>::iterator getSectionIT(const std::string& sectionName);
 
-    std::list<IniEntry>::const_iterator getEntryIT(const char* entryName, const char* sectionName = NULL) const;
-    std::list<IniEntry>::iterator getEntryIT(const char* entryName, const char* sectionName = NULL);
+    std::list<IniEntry>::const_iterator getEntryIT(const std::string& entryName, const std::string& sectionName = "") const;
+    std::list<IniEntry>::iterator getEntryIT(const std::string& entryName, const std::string& sectionName = "");
 
   private:
-    char*                            fileName;        //!< The name of the File that was parsed.
-    char*                            comment;         //!< A Comment for the header of this File.
+    std::string                      fileName;        //!< The name of the File that was parsed.
+    std::string                      comment;         //!< A Comment for the header of this File.
     std::list<IniSection>            sections;        //!< a list of all stored Sections of the Parser
     std::list<IniSection>::iterator  currentSection;  //!< the current selected Section
     std::list<IniEntry>::iterator    currentEntry;    //!< the current selected entry (in currentSection)
 
-    std::list<char*>                 commentList;     //!< A list of Comments. (this is for temporary saving of Comments, that are inserted in front of Sections/Entries.)
+    std::list<std::string>           commentList;     //!< A list of Comments. (this is for temporary saving of Comments, that are inserted in front of Sections/Entries.)
+
+
+    static const std::string         emptyString;
 };
 
Index: trunk/src/lib/parser/tinyxml/tinyxml.h
===================================================================
--- trunk/src/lib/parser/tinyxml/tinyxml.h	(revision 7201)
+++ trunk/src/lib/parser/tinyxml/tinyxml.h	(revision 7221)
@@ -26,4 +26,6 @@
 #ifndef TINYXML_INCLUDED
 #define TINYXML_INCLUDED
+
+#define TIXML_USE_STL
 
 #ifdef _MSC_VER
@@ -81,5 +83,5 @@
 		#define TIXML_SNSCANF  snscanf
 	#endif
-#endif	
+#endif
 
 class TiXmlDocument;
@@ -96,5 +98,5 @@
 const int TIXML_PATCH_VERSION = 2;
 
-/*	Internal structure for tracking location of items 
+/*	Internal structure for tracking location of items
 	in the XML file.
 */
@@ -110,6 +112,6 @@
 
 // Only used by Attribute::Query functions
-enum 
-{ 
+enum
+{
 	TIXML_SUCCESS,
 	TIXML_NO_ATTRIBUTE,
@@ -162,5 +164,5 @@
 	/**	All TinyXml classes can print themselves to a filestream.
 		This is a formatted print, and will insert tabs and newlines.
-		
+
 		(For an unformatted stream, use the << operator.)
 	*/
@@ -206,6 +208,6 @@
 	static const int utf8ByteTable[256];
 
-	virtual const char* Parse(	const char* p, 
-								TiXmlParsingData* data, 
+	virtual const char* Parse(	const char* p,
+								TiXmlParsingData* data,
 								TiXmlEncoding encoding /*= TIXML_ENCODING_UNKNOWN */ ) = 0;
 
@@ -245,7 +247,7 @@
 
 	static const char*	SkipWhiteSpace( const char*, TiXmlEncoding encoding );
-	inline static bool	IsWhiteSpace( char c )		
-	{ 
-		return ( isspace( (unsigned char) c ) || c == '\n' || c == '\r' ); 
+	inline static bool	IsWhiteSpace( char c )
+	{
+		return ( isspace( (unsigned char) c ) || c == '\n' || c == '\r' );
 	}
 
@@ -334,5 +336,5 @@
     /// Field containing a generic user pointer
 	void*			userData;
-	
+
 	// None of these methods are reliable for any language except English.
 	// Good for approximation, not great for accuracy.
@@ -386,5 +388,5 @@
 
 public:
-	#ifdef TIXML_USE_STL	
+	#ifdef TIXML_USE_STL
 
 	    /** An input stream operator, for every class. Tolerant of newlines and
@@ -400,5 +402,5 @@
 		    a node to a stream is very well defined. You'll get a nice stream
 		    of output, without any extra whitespace or newlines.
-		    
+
 		    But reading is not as well defined. (As it always is.) If you create
 		    a TiXmlElement (for example) and read that from an input stream,
@@ -408,5 +410,5 @@
 		    A TiXmlDocument will read nodes until it reads a root element, and
 			all the children of that root element.
-	    */	
+	    */
 	    friend std::ostream& operator<< (std::ostream& out, const TiXmlNode& base);
 
@@ -470,9 +472,9 @@
     #ifdef TIXML_USE_STL
 	/// STL std::string form.
-	void SetValue( const std::string& _value )    
-	{	  
+	void SetValue( const std::string& _value )
+	{
 		StringToBuffer buf( _value );
-		SetValue( buf.buffer ? buf.buffer : "" );    	
-	}	
+		SetValue( buf.buffer ? buf.buffer : "" );
+	}
 	#endif
 
@@ -492,5 +494,5 @@
 	TiXmlNode* LastChild()	{ return lastChild; }
 	const TiXmlNode* LastChild( const char * value ) const;			/// The last child of this node matching 'value'. Will be null if there are no children.
-	TiXmlNode* LastChild( const char * value );	
+	TiXmlNode* LastChild( const char * value );
 
     #ifdef TIXML_USE_STL
@@ -649,5 +651,5 @@
 
 	/** Create an exact duplicate of this node and return it. The memory must be deleted
-		by the caller. 
+		by the caller.
 	*/
 	virtual TiXmlNode* Clone() const = 0;
@@ -731,5 +733,5 @@
 	/** QueryIntValue examines the value string. It is an alternative to the
 		IntValue() method with richer error checking.
-		If the value is an integer, it is stored in 'value' and 
+		If the value is an integer, it is stored in 'value' and
 		the call returns TIXML_SUCCESS. If it is not
 		an integer, it returns TIXML_WRONG_TYPE.
@@ -750,14 +752,14 @@
     #ifdef TIXML_USE_STL
 	/// STL std::string form.
-	void SetName( const std::string& _name )	
-	{	
+	void SetName( const std::string& _name )
+	{
 		StringToBuffer buf( _name );
-		SetName ( buf.buffer ? buf.buffer : "error" );	
-	}
-	/// STL std::string form.	
-	void SetValue( const std::string& _value )	
-	{	
+		SetName ( buf.buffer ? buf.buffer : "error" );
+	}
+	/// STL std::string form.
+	void SetValue( const std::string& _value )
+	{
 		StringToBuffer buf( _value );
-		SetValue( buf.buffer ? buf.buffer : "error" );	
+		SetValue( buf.buffer ? buf.buffer : "error" );
 	}
 	#endif
@@ -801,5 +803,5 @@
 /*	A class used to manage a group of attributes.
 	It is only used internally, both by the ELEMENT and the DECLARATION.
-	
+
 	The set can be changed transparent to the Element and Declaration
 	classes that use it, but NOT transparent to the Attribute
@@ -882,9 +884,9 @@
 	/** QueryIntAttribute examines the attribute - it is an alternative to the
 		Attribute() method with richer error checking.
-		If the attribute is an integer, it is stored in 'value' and 
+		If the attribute is an integer, it is stored in 'value' and
 		the call returns TIXML_SUCCESS. If it is not
 		an integer, it returns TIXML_WRONG_TYPE. If the attribute
 		does not exist, then TIXML_NO_ATTRIBUTE is returned.
-	*/	
+	*/
 	int QueryIntAttribute( const char* name, int* _value ) const;
 	/// QueryDoubleAttribute examines the attribute - see QueryIntAttribute().
@@ -913,18 +915,18 @@
 
 	/// STL std::string form.
-	void SetAttribute( const std::string& name, const std::string& _value )	
-	{	
+	void SetAttribute( const std::string& name, const std::string& _value )
+	{
 		StringToBuffer n( name );
 		StringToBuffer v( _value );
 		if ( n.buffer && v.buffer )
-			SetAttribute (n.buffer, v.buffer );	
-	}	
+			SetAttribute (n.buffer, v.buffer );
+	}
 	///< STL std::string form.
-	void SetAttribute( const std::string& name, int _value )	
-	{	
+	void SetAttribute( const std::string& name, int _value )
+	{
 		StringToBuffer n( name );
 		if ( n.buffer )
-			SetAttribute (n.buffer, _value);	
-	}	
+			SetAttribute (n.buffer, _value);
+	}
 	#endif
 
@@ -954,5 +956,5 @@
 		and concise, GetText() is limited compared to getting the TiXmlText child
 		and accessing it directly.
-	
+
 		If the first child of 'this' is a TiXmlText, the GetText()
 		returns the character string of the Text node, else null is returned.
@@ -964,10 +966,10 @@
 		@endverbatim
 
-		'str' will be a pointer to "This is text". 
-		
+		'str' will be a pointer to "This is text".
+
 		Note that this function can be misleading. If the element foo was created from
 		this XML:
 		@verbatim
-		<foo><b>This is text</b></foo> 
+		<foo><b>This is text</b></foo>
 		@endverbatim
 
@@ -975,10 +977,10 @@
 		another element. From this XML:
 		@verbatim
-		<foo>This is <b>text</b></foo> 
+		<foo>This is <b>text</b></foo>
 		@endverbatim
 		GetText() will return "This is ".
 
-		WARNING: GetText() accesses a child node - don't become confused with the 
-				 similarly named TiXmlHandle::Text() and TiXmlNode::ToText() which are 
+		WARNING: GetText() accesses a child node - don't become confused with the
+				 similarly named TiXmlHandle::Text() and TiXmlNode::ToText() which are
 				 safe type casts on the referenced node.
 	*/
@@ -1054,7 +1056,7 @@
 
 
-/** XML text. A text node can have 2 ways to output the next. "normal" output 
+/** XML text. A text node can have 2 ways to output the next. "normal" output
 	and CDATA. It will default to the mode it was parsed from the XML file and
-	you generally want to leave it alone, but you can change the output mode with 
+	you generally want to leave it alone, but you can change the output mode with
 	SetCDATA() and query it with CDATA().
 */
@@ -1063,5 +1065,5 @@
 	friend class TiXmlElement;
 public:
-	/** Constructor for text element. By default, it is treated as 
+	/** Constructor for text element. By default, it is treated as
 		normal, encoded text. If you want it be output as a CDATA text
 		element, set the parameter _cdata to 'true'
@@ -1279,5 +1281,5 @@
 		- The ErrorDesc() method will return the name of the error. (very useful)
 		- The ErrorRow() and ErrorCol() will return the location of the error (if known)
-	*/	
+	*/
 	bool Error() const						{ return error; }
 
@@ -1290,5 +1292,5 @@
 	int ErrorId()	const				{ return errorId; }
 
-	/** Returns the location (if known) of the error. The first column is column 1, 
+	/** Returns the location (if known) of the error. The first column is column 1,
 		and the first row is row 1. A value of 0 means the row and column wasn't applicable
 		(memory errors, for example, have no row/column) or the parser lost the error. (An
@@ -1303,5 +1305,5 @@
 		to report the correct values for row and column. It does not change the output
 		or input in any way.
-		
+
 		By calling this method, with a tab size
 		greater than 0, the row and column of each node and attribute is stored
@@ -1331,9 +1333,9 @@
 		state is automatically cleared if you Parse a new XML block.
 	*/
-	void ClearError()						{	error = false; 
-												errorId = 0; 
-												errorDesc = ""; 
-												errorLocation.row = errorLocation.col = 0; 
-												//errorLocation.last = 0; 
+	void ClearError()						{	error = false;
+												errorId = 0;
+												errorDesc = "";
+												errorLocation.row = errorLocation.col = 0;
+												//errorLocation.last = 0;
 											}
 
@@ -1381,5 +1383,5 @@
 	@endverbatim
 
-	Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very 
+	Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very
 	easy to write a *lot* of code that looks like:
 
@@ -1401,5 +1403,5 @@
 
 	And that doesn't even cover "else" cases. TiXmlHandle addresses the verbosity
-	of such code. A TiXmlHandle checks for null	pointers so it is perfectly safe 
+	of such code. A TiXmlHandle checks for null	pointers so it is perfectly safe
 	and correct to use:
 
@@ -1422,5 +1424,5 @@
 
 	@verbatim
-	int i=0; 
+	int i=0;
 	while ( true )
 	{
@@ -1433,6 +1435,6 @@
 	@endverbatim
 
-	It seems reasonable, but it is in fact two embedded while loops. The Child method is 
-	a linear walk to find the element, so this code would iterate much more than it needs 
+	It seems reasonable, but it is in fact two embedded while loops. The Child method is
+	a linear walk to find the element, so this code would iterate much more than it needs
 	to. Instead, prefer:
 
@@ -1464,18 +1466,18 @@
 	TiXmlHandle FirstChildElement( const char * value ) const;
 
-	/** Return a handle to the "index" child with the given name. 
+	/** Return a handle to the "index" child with the given name.
 		The first child is 0, the second 1, etc.
 	*/
 	TiXmlHandle Child( const char* value, int index ) const;
-	/** Return a handle to the "index" child. 
+	/** Return a handle to the "index" child.
 		The first child is 0, the second 1, etc.
 	*/
 	TiXmlHandle Child( int index ) const;
-	/** Return a handle to the "index" child element with the given name. 
+	/** Return a handle to the "index" child element with the given name.
 		The first child element is 0, the second 1, etc. Note that only TiXmlElements
 		are indexed: other types are not counted.
 	*/
 	TiXmlHandle ChildElement( const char* value, int index ) const;
-	/** Return a handle to the "index" child element. 
+	/** Return a handle to the "index" child element.
 		The first child element is 0, the second 1, etc. Note that only TiXmlElements
 		are indexed: other types are not counted.
@@ -1492,5 +1494,5 @@
 
 	/// Return the handle as a TiXmlNode. This may return null.
-	TiXmlNode* Node() const			{ return node; } 
+	TiXmlNode* Node() const			{ return node; }
 	/// Return the handle as a TiXmlElement. This may return null.
 	TiXmlElement* Element() const	{ return ( ( node && node->ToElement() ) ? node->ToElement() : 0 ); }
Index: trunk/src/lib/particles/dot_particles.h
===================================================================
--- trunk/src/lib/particles/dot_particles.h	(revision 7201)
+++ trunk/src/lib/particles/dot_particles.h	(revision 7221)
@@ -21,5 +21,5 @@
   virtual void loadParams(const TiXmlElement* root);
 
-  void setMaterialTexture(const char* textureFile);
+  void setMaterialTexture(const std::string& textureFile);
 
   /** @returns the Material that lies on this particles */
Index: trunk/src/lib/particles/model_particles.cc
===================================================================
--- trunk/src/lib/particles/model_particles.cc	(revision 7201)
+++ trunk/src/lib/particles/model_particles.cc	(revision 7221)
@@ -89,5 +89,5 @@
  * @param textureFile the Texture to load onto these ModelParticles
  */
-void ModelParticles::setMaterialTexture(const char* textureFile)
+void ModelParticles::setMaterialTexture(const std::string& textureFile)
 {
   this->material.setDiffuseMap(textureFile);
Index: trunk/src/lib/particles/model_particles.h
===================================================================
--- trunk/src/lib/particles/model_particles.h	(revision 7201)
+++ trunk/src/lib/particles/model_particles.h	(revision 7221)
@@ -20,5 +20,5 @@
   virtual void loadParams(const TiXmlElement* root);
 
-  void setMaterialTexture(const char* textureFile);
+  void setMaterialTexture(const std::string& textureFile);
 
   /** @returns the Material that lies on this particles */
Index: trunk/src/lib/particles/particle_system.cc
===================================================================
--- trunk/src/lib/particles/particle_system.cc	(revision 7201)
+++ trunk/src/lib/particles/particle_system.cc	(revision 7221)
@@ -485,5 +485,5 @@
 void ParticleSystem::debug() const
 {
-  PRINT(0)("  ParticleCount: %d emitters: %d, maximumCount: %d :: filled %d%%\n", this->count, this->emitters.size(), this->maxCount, 100*this->count/this->maxCount);
+  PRINT(0)("  ParticleCount: %d emitters: %d, maximumCount: %d :: filled %d%%\n", this->count, this->emitters.size(), this->maxCount, ((this->maxCount!=0)?100*this->count/this->maxCount:0));
   if (deadList)
   {
Index: trunk/src/lib/particles/spark_particles.cc
===================================================================
--- trunk/src/lib/particles/spark_particles.cc	(revision 7201)
+++ trunk/src/lib/particles/spark_particles.cc	(revision 7221)
@@ -68,6 +68,4 @@
 {
   this->setClassID(CL_SPARK_PARTICLES, "SparkParticles");
-
-  this->material = NULL;
 }
 
Index: trunk/src/lib/particles/sprite_particles.cc
===================================================================
--- trunk/src/lib/particles/sprite_particles.cc	(revision 7201)
+++ trunk/src/lib/particles/sprite_particles.cc	(revision 7221)
@@ -89,5 +89,5 @@
  * @param textureFile the Texture to load onto these SpriteParticles
  */
-void SpriteParticles::setMaterialTexture(const char* textureFile)
+void SpriteParticles::setMaterialTexture(const std::string& textureFile)
 {
   this->material.setDiffuseMap(textureFile);
Index: trunk/src/lib/particles/sprite_particles.h
===================================================================
--- trunk/src/lib/particles/sprite_particles.h	(revision 7201)
+++ trunk/src/lib/particles/sprite_particles.h	(revision 7221)
@@ -21,5 +21,5 @@
   virtual void loadParams(const TiXmlElement* root);
 
-  void setMaterialTexture(const char* textureFile);
+  void setMaterialTexture(const std::string& textureFile);
 
   /** @returns the Material that lies on this particles */
Index: trunk/src/lib/physics/physics_connection.cc
===================================================================
--- trunk/src/lib/physics/physics_connection.cc	(revision 7201)
+++ trunk/src/lib/physics/physics_connection.cc	(revision 7221)
@@ -73,10 +73,10 @@
  * @param subjectName the name of the Subject for this PhysicsConnection
 */
-void PhysicsConnection::setSubject(const char* subjectName)
+void PhysicsConnection::setSubject(const std::string& subjectName)
 {
   this->subject = PhysicsEngine::getInstance()->getPhysicsInterfaceByName(subjectName);
   if (this->subject == NULL)
   {
-    PRINTF(2)("subject: (%s) not found for PhysicsConnection\n", subjectName);
+    PRINTF(2)("subject: (%s) not found for PhysicsConnection\n", subjectName.c_str());
   }
   else
@@ -87,10 +87,10 @@
 * @param fieldName the Name of the Field for this connection
 */
-void PhysicsConnection::setField(const char* fieldName)
+void PhysicsConnection::setField(const std::string& fieldName)
 {
   this->field = PhysicsEngine::getInstance()->getFieldByName(fieldName);
   if (this->field == NULL)
   {
-        PRINTF(2)("field: (%s) not found for PhysicsConnection\n", fieldName);
+    PRINTF(2)("field: (%s) not found for PhysicsConnection\n", fieldName.c_str());
   }
   else
Index: trunk/src/lib/physics/physics_connection.h
===================================================================
--- trunk/src/lib/physics/physics_connection.h	(revision 7201)
+++ trunk/src/lib/physics/physics_connection.h	(revision 7221)
@@ -35,6 +35,6 @@
   virtual ~PhysicsConnection();
 
-  void setSubject(const char* subjectName);
-  void setField(const char* fieldName);
+  void setSubject(const std::string& subjectName);
+  void setField(const std::string& fieldName);
 
   void apply() const;
Index: trunk/src/lib/physics/physics_engine.cc
===================================================================
--- trunk/src/lib/physics/physics_engine.cc	(revision 7201)
+++ trunk/src/lib/physics/physics_engine.cc	(revision 7221)
@@ -128,5 +128,5 @@
   @returns the PhysicsInterface if found, or NULL if not
  */
-PhysicsInterface* PhysicsEngine::getPhysicsInterfaceByName(const char* physicsInterfaceName) const
+PhysicsInterface* PhysicsEngine::getPhysicsInterfaceByName(const std::string& physicsInterfaceName) const
 {
   BaseObject* interface = ClassList::getObject(physicsInterfaceName, CL_PHYSICS_INTERFACE);
@@ -157,12 +157,12 @@
 
 /**
-* @param FieldName the Name of the PhysicsInterface to search for
+* @param fieldName the Name of the PhysicsInterface to search for
   @returns the Field if found, or NULL if not
  */
-Field* PhysicsEngine::getFieldByName(const char* FieldName) const
+Field* PhysicsEngine::getFieldByName(const std::string& fieldName) const
 {
   list<Field*>::const_iterator field;
   for (field = this->fields.begin(); field != this->fields.end(); field++)
-    if (!strcmp(FieldName, (*field)->getName()))
+    if (fieldName == (*field)->getName())
       return (*field);
   return NULL;
@@ -197,9 +197,9 @@
   @returns the PhysicsConnection if found, or NULL if not
  */
-PhysicsConnection* PhysicsEngine::getPhysicsConnectionByName(const char* physicsConnectionName) const
+PhysicsConnection* PhysicsEngine::getPhysicsConnectionByName(const std::string& physicsConnectionName) const
 {
   list<PhysicsConnection*>::const_iterator pc;
   for (pc = this->connections.begin(); pc != this->connections.end(); pc++)
-    if (!strcmp(physicsConnectionName, (*pc)->getName()))
+    if (physicsConnectionName == (*pc)->getName())
       delete (*pc);
   return NULL;
Index: trunk/src/lib/physics/physics_engine.h
===================================================================
--- trunk/src/lib/physics/physics_engine.h	(revision 7201)
+++ trunk/src/lib/physics/physics_engine.h	(revision 7221)
@@ -31,13 +31,13 @@
   void loadConnections(const TiXmlElement* root);
 
-  PhysicsInterface*      getPhysicsInterfaceByName(const char* physicsInterfaceName) const;
+  PhysicsInterface*      getPhysicsInterfaceByName(const std::string& physicsInterfaceName) const;
 
   void                   addField(Field* field);
   void                   removeField(Field* field);
-  Field*                 getFieldByName(const char* FieldName) const;
+  Field*                 getFieldByName(const std::string& fieldName) const;
 
   void                   addConnection(PhysicsConnection* connection);
   void                   removeConnection(PhysicsConnection* connection);
-  PhysicsConnection*     getPhysicsConnectionByName(const char* physicsConnectionName) const;
+  PhysicsConnection*     getPhysicsConnectionByName(const std::string& physicsConnectionName) const;
 
 
Index: trunk/src/lib/shell/shell.cc
===================================================================
--- trunk/src/lib/shell/shell.cc	(revision 7201)
+++ trunk/src/lib/shell/shell.cc	(revision 7221)
@@ -85,6 +85,5 @@
   this->lineSpacing = 0;
   this->bActive = true;
-  this->fontFile = new char[strlen(SHELL_DEFAULT_FONT)+1];
-  strcpy(this->fontFile, SHELL_DEFAULT_FONT);
+  this->fontFile = SHELL_DEFAULT_FONT;
 
 
@@ -110,5 +109,4 @@
     delete this->bufferText[i];
   delete[] this->bufferText;
-  delete[] this->fontFile;
   // delete the inputLine
   delete this->shellInput;
@@ -139,5 +137,5 @@
     if (!top)
     {
-      this->bufferText[i]->setText((*textLine), true);
+      this->bufferText[i]->setText((*textLine));
     if (textLine != ShellBuffer::getInstance()->getBuffer()->begin())
       top = true;
@@ -167,5 +165,5 @@
     if (textLine != ShellBuffer::getInstance()->getBuffer()->begin())
     {
-      this->bufferText[i]->setText((*textLine), false);
+      this->bufferText[i]->setText((*textLine));
       textLine--;
     }
@@ -181,14 +179,10 @@
  * (be aware that within orxonox fontFile is relative to the Data-Dir)
  */
-void Shell::setFont(const char* fontFile)
+void Shell::setFont(const std::string& fontFile)
 {
 //   if (!ResourceManager::isInDataDir(fontFile))
 //     return false;
 
-  if (this->fontFile != NULL)
-    delete[] this->fontFile;
-
-  this->fontFile = new char[strlen(fontFile)+1];
-  strcpy(this->fontFile, fontFile);
+  this->fontFile = fontFile;
 
   this->rebuildText();
@@ -245,5 +239,5 @@
  * @param fileName the filename of the Image to load
  */
-void Shell::setBackgroundImage(const char* fileName)
+void Shell::setBackgroundImage(const std::string& fileName)
 {
   this->backgroundMaterial->setDiffuseMap(fileName);
@@ -340,5 +334,5 @@
     for (int i = 0; i < this->bufferDisplaySize; i++)
     {
-      this->bufferText[i]->setText(NULL, true);
+      this->bufferText[i]->setText("");
     }
 
@@ -351,5 +345,5 @@
  * @param text the text to output.
  */
-void Shell::printToDisplayBuffer(const char* text)
+void Shell::printToDisplayBuffer(const std::string& text)
 {
   if(likely(bufferText != NULL))
@@ -382,5 +376,5 @@
     this->bufferText[0] = lastText;
 
-    this->bufferText[0]->setText(text, true);
+    this->bufferText[0]->setText(text);
   }
 }
@@ -427,5 +421,5 @@
   for (unsigned int i = 0; i < this->bufferDisplaySize; i++)
   {
-    this->bufferText[i]->setText((*it), false);
+    this->bufferText[i]->setText((*it));
     it--;
   }
Index: trunk/src/lib/shell/shell.h
===================================================================
--- trunk/src/lib/shell/shell.h	(revision 7201)
+++ trunk/src/lib/shell/shell.h	(revision 7221)
@@ -53,9 +53,9 @@
     inline bool isActive() const { return this->bActive; };
 
-    void setFont(const char* fontFile);
+    void setFont(const std::string& fontFile);
     void setTextSize(unsigned int textSize, unsigned int lineSpacing = 1);
     void setTextColor(float r, float g, float b, float a);
     void setBackgroundColor(float r, float g, float b, float a);
-    void setBackgroundImage(const char* fileName);
+    void setBackgroundImage(const std::string& fileName);
 
     void resetValues();
@@ -64,5 +64,5 @@
     // BUFFERS
     void setBufferDisplaySize(unsigned int bufferDisplaySize);
-    void printToDisplayBuffer(const char* text);
+    void printToDisplayBuffer(const std::string& text);
     void moveDisplayBuffer(int lineCount);
 
@@ -83,8 +83,8 @@
 
     //     void testI (int i);
-    //     void testS (const char* s);
+    //     void testS (const std::string& s);
     //     void testB (bool b);
     //     void testF (float f);
-    //     void testSF (const char* s, float f);
+    //     void testSF (const std::string& s, float f);
 
   private:
@@ -95,5 +95,5 @@
     unsigned int                textSize;               //!< The size of the text.
     float                       textColor[4];           //!< The text's color [r,g,b,a].
-    char*                       fontFile;               //!< The file containing the font.
+    std::string                 fontFile;               //!< The file containing the font.
     Material*                   backgroundMaterial;     //!< A material for the background.
 
Index: trunk/src/lib/shell/shell_command.cc
===================================================================
--- trunk/src/lib/shell/shell_command.cc	(revision 7201)
+++ trunk/src/lib/shell/shell_command.cc	(revision 7221)
@@ -41,6 +41,4 @@
   PRINTF(5)("create shellcommand %s %s\n", commandName, className);
   this->setName(commandName);
-  this->description = NULL;
-  this->alias = NULL;
   this->executor = executor.clone();
   this->executor->setName(commandName);
@@ -153,5 +151,5 @@
  * @return true on success, false otherwise.
  */
-bool ShellCommand::execute(const char* executionString)
+bool ShellCommand::execute(const std::string& executionString)
 {
   if (ShellCommandClass::commandClassList == NULL)
@@ -177,5 +175,5 @@
       for (alias = ShellCommandClass::aliasList->begin(); alias != ShellCommandClass::aliasList->end(); alias++ )
       {
-        if ((*alias)->getName() != NULL && !strcmp((*alias)->getName(), inputSplits.getString(0)) && (*alias)->getCommand() != NULL &&
+        if (inputSplits.getString(0) == (*alias)->getName() && (*alias)->getCommand() != NULL &&
             (*alias)->getCommand()->shellClass != NULL )
         {
@@ -184,5 +182,8 @@
           {
             if (inputSplits.getCount() > 1)
-              (*alias)->getCommand()->executor->execute(objectList->front(), executionString+inputSplits.getOffset(1));
+            {
+
+              (*alias)->getCommand()->executor->execute(objectList->front(), executionString.substr(inputSplits.getOffset(1))); /// TODO CHECK IF OK
+            }
             else
               (*alias)->getCommand()->executor->execute(objectList->front(), "");
@@ -198,5 +199,5 @@
       for (commandClassIT = ShellCommandClass::commandClassList->begin(); commandClassIT != ShellCommandClass::commandClassList->end(); commandClassIT++)
       {
-        if ((*commandClassIT)->getName() && !strcasecmp(inputSplits.getString(0), (*commandClassIT)->getName()))
+        if ((*commandClassIT)->getName() && inputSplits.getString(0) == (*commandClassIT)->getName())
         {
           //elemCL->getName();
@@ -217,5 +218,5 @@
         for (object = objectList->begin(); object != objectList->end(); object++)
         {
-          if ((*object)->getName() != NULL && !strcasecmp((*object)->getName(), inputSplits.getString(1)))
+          if ((*object)->getName() != NULL && inputSplits.getString(1) == (*object)->getName() )
           {
             objectPointer = (*object);
@@ -235,10 +236,10 @@
         for (cmdIT = commandClass->commandList.begin(); cmdIT != commandClass->commandList.end(); cmdIT++)
         {
-          if (!strcmp((*cmdIT)->getName(), inputSplits.getString(fktPos)))
+          if (inputSplits.getString(fktPos) == (*cmdIT)->getName())
           {
             if (objectPointer == NULL && (*cmdIT)->executor->getType() & Executor_Objective)
               return false;
             if (inputSplits.getCount() > fktPos+1)
-              (*cmdIT)->executor->execute(objectPointer, executionString+inputSplits.getOffset(fktPos +1));
+              (*cmdIT)->executor->execute(objectPointer, executionString.substr(inputSplits.getOffset(fktPos +1))); /// TODO CHECK IF OK
             else
               (*cmdIT)->executor->execute(objectPointer, "");
@@ -255,5 +256,5 @@
  * @param description the description of the Given command
  */
-ShellCommand* ShellCommand::describe(const char* description)
+ShellCommand* ShellCommand::describe(const std::string& description)
 {
   if (this == NULL)
@@ -326,5 +327,5 @@
   for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
   {
-    PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className, (*classIT)->commandList.size());
+    PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className.c_str(), (*classIT)->commandList.size());
 
     list<ShellCommand*>::iterator cmdIT;
@@ -335,6 +336,6 @@
       /*      for (unsigned int i = 0; i< elem->paramCount; i++)
        printf("%s ", ShellCommand::paramToString(elem->parameters[i]));*/
-      if ((*cmdIT)->description != NULL)
-       printf("- %s", (*cmdIT)->description);
+      if (!(*cmdIT)->description.empty())
+        printf("- %s", (*cmdIT)->description.c_str());
       printf("\n");
 
Index: trunk/src/lib/shell/shell_command.h
===================================================================
--- trunk/src/lib/shell/shell_command.h	(revision 7201)
+++ trunk/src/lib/shell/shell_command.h	(revision 7221)
@@ -61,7 +61,7 @@
   friend class ShellCommandClass;
   public:
-    static bool execute (const char* executionString);
+    static bool execute (const std::string& executionString);
 
-    ShellCommand* describe(const char* description);
+    ShellCommand* describe(const std::string& description);
     ShellCommand* setAlias(const char* alias);
     ShellCommand* defaultValues(const MultiType& value0 = MT_NULL, const MultiType& value1 = MT_NULL,
@@ -89,5 +89,5 @@
     ShellCommandAlias*               alias;                                //!< An Alias for the Class.
 
-    const char*                      description;                          //!< A description for this commnand. (initially NULL). Assigned with (create)->describe("blablabla");
+    std::string                      description;                          //!< A description for this commnand. (initially NULL). Assigned with (create)->describe("blablabla");
     Executor*                        executor;                             //!< The Executor, that really executes the Function.
 
@@ -100,5 +100,5 @@
   public:
     /** @returns the Name of the Alias. */
-    const char* getName() const { return this->aliasName; };
+    const std::string& getName() const { return this->aliasName; };
     /** @returns the Command, this Alias is asociated with */
     ShellCommand* getCommand() const { return this->command; };
@@ -106,8 +106,8 @@
   private:
     /** @param aliasName the name of the Alias @param command the Command, to associate this alias with */
-    ShellCommandAlias(const char* aliasName, ShellCommand* command) { this->aliasName = aliasName; this->command = command; };
+    ShellCommandAlias(const std::string& aliasName, ShellCommand* command) { this->aliasName = aliasName; this->command = command; };
 
   private:
-    const char*     aliasName;       //!< the name of the Alias
+    std::string     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 7201)
+++ trunk/src/lib/shell/shell_command_class.cc	(revision 7221)
@@ -36,10 +36,10 @@
  * @param className the Name of the command-class to create
  */
-ShellCommandClass::ShellCommandClass(const char* className)
+ShellCommandClass::ShellCommandClass(const std::string& className)
+  : className(className)
 {
   this->setClassID(CL_SHELL_COMMAND_CLASS, "ShellCommandClass");
   this->setName(className);
 
-  this->className = className;
   this->classID = CL_NULL;
 
@@ -65,7 +65,7 @@
  * @returns true on success, false otherwise
  */
-bool ShellCommandClass::getCommandListOfClass(const char* className, std::list<const char*>* stringList)
-{
-  if (stringList == NULL || className == NULL)
+bool ShellCommandClass::getCommandListOfClass(const std::string& className, std::list<std::string>* stringList)
+{
+  if (stringList == NULL)
     return false;
 
@@ -73,5 +73,5 @@
   for(elem = ShellCommandClass::commandClassList->begin(); elem != ShellCommandClass::commandClassList->end(); elem++)
   {
-    if (!strcmp ((*elem)->getName(), className))
+    if (className == (*elem)->getName())
     {
       list<ShellCommand*>::iterator command;
@@ -88,5 +88,5 @@
  * @returns true on success, false otherwise
  */
-bool ShellCommandClass::getCommandListOfAlias(std::list<const char*>* stringList)
+bool ShellCommandClass::getCommandListOfAlias(std::list<std::string>* stringList)
 {
   if (stringList == NULL || ShellCommandClass::aliasList == NULL)
@@ -130,5 +130,5 @@
  * @returns the CommandClass if found, NULL otherwise
  */
-const ShellCommandClass* ShellCommandClass::isRegistered(const char* className)
+const ShellCommandClass* ShellCommandClass::isRegistered(const std::string& className)
 {
   if (ShellCommandClass::commandClassList == NULL)
@@ -138,5 +138,5 @@
   for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
   {
-    if (!strcmp(className, (*classIT)->className))
+    if (className == (*classIT)->className)
     {
       if ((*classIT)->classID == CL_NULL)
@@ -154,5 +154,5 @@
  * @returns the CommandClass if found, or a new CommandClass if not
  */
-ShellCommandClass* ShellCommandClass::getCommandClass(const char* className)
+ShellCommandClass* ShellCommandClass::getCommandClass(const std::string& className)
 {
   if (ShellCommandClass::commandClassList == NULL)
@@ -162,5 +162,5 @@
   for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
   {
-    if (!strcmp(className, (*classIT)->className))
+    if (className == (*classIT)->className)
     {
       return (*classIT);
@@ -186,8 +186,6 @@
  * @param className: the Class of Commands to show help about
  */
-void ShellCommandClass::help(const char* className)
-{
-  if (className == NULL)
-    return;
+void ShellCommandClass::help(const std::string& className)
+{
   if (likely(ShellCommandClass::commandClassList != NULL))
   {
@@ -195,7 +193,7 @@
     for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
     {
-      if ((*classIT)->className && !strcasecmp(className, (*classIT)->className))
+      if (className == (*classIT)->className)
       {
-        PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className, (*classIT)->commandList.size());
+        PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className.c_str(), (*classIT)->commandList.size());
         list<ShellCommand*>::const_iterator cmdIT;
         for (cmdIT = (*classIT)->commandList.begin(); cmdIT != (*classIT)->commandList.end(); cmdIT++)
@@ -205,6 +203,6 @@
           /*          for (unsigned int i = 0; i< elem->paramCount; i++)
             PRINT(0)("%s ", ShellCommand::paramToString(elem->parameters[i]));*/
-          if ((*cmdIT)->description != NULL)
-            PRINT(0)("- %s", (*cmdIT)->description);
+          if (!(*cmdIT)->description.empty())
+            PRINT(0)("- %s", (*cmdIT)->description.c_str());
           PRINT(0)("\n");
         }
@@ -212,5 +210,5 @@
       }
     }
-    PRINTF(3)("Class %s not found in Command's classes\n", className);
+    PRINTF(3)("Class %s not found in Command's classes\n", className.c_str());
   }
   else
Index: trunk/src/lib/shell/shell_command_class.h
===================================================================
--- trunk/src/lib/shell/shell_command_class.h	(revision 7201)
+++ trunk/src/lib/shell/shell_command_class.h	(revision 7221)
@@ -27,21 +27,21 @@
     /** @returns the CommandClassList */
     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 bool getCommandListOfClass(const std::string& className, std::list<std::string>* stringList);
+    static bool getCommandListOfAlias(std::list<std::string>* aliasList);
 
-    static ShellCommandClass* getCommandClass(const char* className);
+    static ShellCommandClass* getCommandClass(const std::string& className);
     static void unregisterAllCommands();
 
-    static void help (const char* className);
+    static void help (const std::string& className);
 
   private:
-    ShellCommandClass(const char* className);
+    ShellCommandClass(const std::string& className);
     virtual ~ShellCommandClass();
 
-    static const ShellCommandClass* isRegistered(const char* className);
+    static const ShellCommandClass* isRegistered(const std::string& className);
     static void initCommandClassList();
 
   private:
-    const char*                            className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
+    const std::string                      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
Index: trunk/src/lib/shell/shell_completion.cc
===================================================================
--- trunk/src/lib/shell/shell_completion.cc	(revision 7201)
+++ trunk/src/lib/shell/shell_completion.cc	(revision 7221)
@@ -76,6 +76,5 @@
 
   // Check if we are in a input. eg. the supplied string "class " and now we complete either function or object
-  if (this->input->getInput() != NULL &&
-      strrchr(this->input->getInput(), ' ') >= this->input->getInput() + strlen(this->input->getInput())-1)
+  if (this->input->getInput()[this->input->getInput().size()-1] == ' ')
   {
     emptyComplete = true;
@@ -83,9 +82,5 @@
 
   // CREATE INPUTS
-  if (this->input->getInput() == NULL)
-    completionLine = "";
-  else
-    completionLine = this->input->getInput() + strspn(this->input->getInput(), " \t\n");
-  SubString inputSplits(completionLine, " \t\n,");
+  SubString inputSplits(this->input->getInput(), " \t\n,");
 
   // What String will be completed
@@ -93,5 +88,5 @@
     completeString = "";
   else
-    completeString = inputSplits.getString(inputSplits.getCount()-1);
+    completeString = inputSplits.getString(inputSplits.getCount()-1).c_str();
 
   // CLASS COMPLETION
@@ -111,5 +106,5 @@
             (inputSplits.getCount() == 2 && emptyComplete == false))
   {
-    classID = ClassList::StringToID(inputSplits.getString(0));
+    classID = ClassList::StringToID(inputSplits.getString(0).c_str()); //FIXME
     objectList = ClassList::getList((ClassID)classID);
     if (classID != CL_NULL)
@@ -121,5 +116,5 @@
             (inputSplits.getCount() == 3 && emptyComplete == false))
   {
-    classID = ClassList::StringToID(inputSplits.getString(0));
+    classID = ClassList::StringToID(inputSplits.getString(0) .c_str()); // FIXME
     if (classID == CL_NULL)
       return false;
@@ -133,5 +128,5 @@
     this->objectComplete(completeString, classID);
   if (completeType & SHELLC_FUNCTION)
-    this->functionComplete(completeString, inputSplits.getString(0));
+    this->functionComplete(completeString, inputSplits.getString(0).c_str()); // FIXME
   if (completeType & SHELLC_ALIAS)
     this->aliasComplete(completeString);
@@ -151,5 +146,5 @@
   if (unlikely(classBegin == NULL))
     return false;
-  const std::list<const char*>* clList = ClassList::getClassNames();
+  const std::list<std::string>* clList = ClassList::getClassNames();
   if (clList != NULL)
   {
@@ -195,5 +190,5 @@
   if (unlikely(functionBegin == NULL))
     return false;
-  std::list<const char*> fktList;
+  std::list<std::string> fktList;
   ShellCommandClass::getCommandListOfClass(className, &fktList);
   //printf("%s\n", boList->firstElement()->getName());
@@ -212,5 +207,5 @@
   if (unlikely(aliasBegin == NULL))
     return false;
-  std::list<const char*> aliasList;
+  std::list<std::string> aliasList;
   ShellCommandClass::getCommandListOfAlias(&aliasList);
   //printf("%s\n", boList->firstElement()->getName());
@@ -295,5 +290,5 @@
  * !! The strings MUST NOT be deleted !!
  */
-bool ShellCompletion::addToCompleteList(const std::list<const char*>* inputList, const char* completionBegin, SHELLC_TYPE type)
+bool ShellCompletion::addToCompleteList(const std::list<std::string>* inputList, const char* completionBegin, SHELLC_TYPE type)
 {
   if (inputList == NULL || completionBegin == NULL)
@@ -301,12 +296,12 @@
   unsigned int searchLength = strlen(completionBegin);
 
-  list<const char*>::const_iterator string;
+  list<std::string>::const_iterator string;
   for (string = inputList->begin(); string != inputList->end(); string++)
   {
-    if (strlen(*string) >= searchLength &&
-        !strncasecmp(*string, completionBegin, searchLength))
+    if ((*string).size() >= searchLength &&
+          !strncasecmp((*string).c_str(), completionBegin, searchLength))
     {
       ShellC_Element newElem;
-      newElem.name = *string;
+      newElem.name = (*string).c_str();
       newElem.type = type;
       this->completionList.push_back(newElem);
Index: trunk/src/lib/shell/shell_completion.h
===================================================================
--- trunk/src/lib/shell/shell_completion.h	(revision 7201)
+++ trunk/src/lib/shell/shell_completion.h	(revision 7221)
@@ -52,5 +52,5 @@
   bool generalComplete(const char* begin, const char* displayAs = "%s", const char* addBack = NULL, const char* addFront = NULL);
 
-  bool addToCompleteList(const std::list<const char*>* inputList, const char* completionBegin, SHELLC_TYPE type);
+  bool addToCompleteList(const std::list<std::string>* inputList, const char* completionBegin, SHELLC_TYPE type);
   bool addToCompleteList(const std::list<BaseObject*>* inputList, const char* completionBegin, SHELLC_TYPE type);
   void emptyCompletionList();
Index: trunk/src/lib/shell/shell_input.cc
===================================================================
--- trunk/src/lib/shell/shell_input.cc	(revision 7201)
+++ trunk/src/lib/shell/shell_input.cc	(revision 7221)
@@ -41,11 +41,10 @@
  * this also generates a ShellCompletion automatically.
 */
-ShellInput::ShellInput () : Text ((const char*)NULL)
+ShellInput::ShellInput () : Text ("")
 {
   this->pressedKey = SDLK_FIRST;
   this->setClassID(CL_SHELL_INPUT, "ShellInput");
 
-  this->inputLine = new char[1];
-  this->inputLine[0] = '\0';
+  this->inputLine = "";
   this->historyIT = this->history.begin();
   this->setHistoryLength(50);
@@ -70,10 +69,8 @@
 {
   // delete what has to be deleted here
-  delete[] this->inputLine;
   delete this->completion;
 
   while (!this->history.empty())
   {
-    delete[] this->history.front();
     this->history.pop_front();
   }
@@ -96,11 +93,6 @@
 void ShellInput::flush()
 {
-  if (likely(this->inputLine != NULL))
-  {
-    delete[] this->inputLine;
-  }
-  this->inputLine = new char[1];
-  *this->inputLine = '\0';
-  this->setText(this->inputLine, true);
+  this->inputLine.clear();
+  this->setText(this->inputLine);
 }
 
@@ -109,18 +101,8 @@
  * @param text the new Text to set as InputLine
  */
-void ShellInput::setInputText(const char* text)
-{
-  delete[] this->inputLine;
-  if (text == NULL)
-  {
-    this->inputLine = new char[1];
-    this->inputLine[0] = '\0';
-  }
-  else
-  {
-    this->inputLine = new char[strlen(text)+1];
-    strcpy(this->inputLine, text);
-  }
-  this->setText(this->inputLine, true);
+void ShellInput::setInputText(const std::string& text)
+{
+  this->inputLine = text;
+  this->setText(this->inputLine);
 }
 
@@ -134,15 +116,10 @@
   if (this->historyScrolling)
   {
-    delete[] this->history.back();
     this->history.pop_back();
     this->historyScrolling = false;
   }
 
-  char* addCharLine = new char[strlen(this->inputLine)+2];
-
-  sprintf(addCharLine, "%s%c", this->inputLine, character);
-  delete[] this->inputLine;
-  this->inputLine = addCharLine;
-  this->setText(this->inputLine, true);
+  this->inputLine += character;
+  this->setText(this->inputLine);
 }
 
@@ -151,19 +128,14 @@
  * @param characters a \\0 terminated char-array to add to the InputLine
  */
-void ShellInput::addCharacters(const char* characters)
+void ShellInput::addCharacters(const std::string& characters)
 {
   if (this->historyScrolling)
   {
-    delete[] this->history.back();
     this->history.pop_back();
     this->historyScrolling = false;
   }
 
-  char* addCharLine = new char[strlen(this->inputLine)+strlen(characters)+1];
-
-  sprintf(addCharLine, "%s%s", this->inputLine, characters);
-  delete[] this->inputLine;
-  this->inputLine = addCharLine;
-  this->setText(this->inputLine, true);
+  this->inputLine += characters;
+  this->setText(this->inputLine);
 }
 
@@ -176,22 +148,12 @@
   if (this->historyScrolling)
   {
-    delete[] this->history.back();
     this->history.pop_back();
     this->historyScrolling = false;
   }
-
-  if (strlen(this->inputLine) == 0)
-    return;
-
-  if (characterCount > strlen(this->inputLine))
-    characterCount = strlen(this->inputLine);
-
-  char* removeCharLine = new char[strlen(this->inputLine)-characterCount+1];
-
-  strncpy(removeCharLine, this->inputLine, strlen(this->inputLine)-characterCount);
-  removeCharLine[strlen(this->inputLine)-characterCount] = '\0';
-  delete[] this->inputLine;
-  this->inputLine = removeCharLine;
-  this->setText(this->inputLine, true);
+  if (this->inputLine.size() < characterCount)
+    characterCount = this->inputLine.size();
+
+  this->inputLine.erase(this->inputLine.size() - characterCount, this->inputLine.size());
+  this->setText(this->inputLine);
 }
 
@@ -202,18 +164,14 @@
 bool ShellInput::executeCommand()
 {
-  ShellBuffer::addBufferLineStatic("Execute Command: %s\n", this->inputLine);
-
-  if (strlen(this->inputLine) == 0)
+  ShellBuffer::addBufferLineStatic("Execute Command: %s\n", this->inputLine.c_str());
+
+  if (this->inputLine.empty())
     return false;
 
-  char* newCommand = new char[strlen(this->inputLine)+1];
-  strcpy(newCommand, this->inputLine);
-
-  ShellCommand::execute(newCommand);
+  ShellCommand::execute(this->inputLine);
 
   // removing the eventually added Entry (from scrolling) to the List
   if (this->historyScrolling)
   {
-    delete[] this->history.back();
     this->history.pop_back();
     this->historyScrolling = false;
@@ -221,8 +179,7 @@
 
   // adding the new Command to the History
-  this->history.push_back(newCommand);
+  this->history.push_back(this->inputLine);
   if (this->history.size() > this->historyLength)
   {
-    delete[] this->history.front();
     this->history.pop_front();
   }
@@ -241,7 +198,5 @@
   if (!this->historyScrolling)
   {
-    char* currentText = new char[strlen(this->inputLine)+1];
-    strcpy(currentText, this->inputLine);
-    this->history.push_back(currentText);
+    this->history.push_back(this->inputLine);
     this->historyScrolling = true;
     this->historyIT = --this->history.end();
@@ -250,8 +205,8 @@
   if(this->historyIT != this->history.begin())
   {
-    char* prevElem = *(--this->historyIT);
-    if (prevElem == NULL)
+    std::string prevElem = *(--this->historyIT);
+    /*if (prevElem == NULL) /// TODO STD
       return;
-    else
+    else */
     {
       this->flush();
@@ -270,8 +225,8 @@
   if (this->historyIT != this->history.end())
   {
-    char* nextElem = *(++this->historyIT);
-    if (nextElem == NULL)
+    std::string nextElem = *(++this->historyIT);
+    /*    if (nextElem == NULL) /// TODO FIX STD
       return;
-    else
+    else */
     {
       this->flush();
@@ -285,9 +240,9 @@
  * prints out some nice help about the Shell
  */
-void ShellInput::help(const char* className, const char* functionName)
-{
-  printf("%s::%s\n", className, functionName);
-
-  if (strlen(className) == 0)
+void ShellInput::help(const std::string& className, const std::string& functionName)
+{
+  printf("%s::%s\n", className.c_str(), functionName.c_str());
+
+  if (className.empty())
   {
     PRINT(0)("Help for the most important Shell-commands\n");
@@ -298,5 +253,5 @@
     PRINT(0)("- Also try 'help className'");
   }
-  else if (strlen (className) > 0 && strlen (functionName) == 0)
+  else if (!className.empty() && functionName.empty())
   {
     ShellCommandClass::help(className);
Index: trunk/src/lib/shell/shell_input.h
===================================================================
--- trunk/src/lib/shell/shell_input.h	(revision 7201)
+++ trunk/src/lib/shell/shell_input.h	(revision 7221)
@@ -31,11 +31,11 @@
 
   /** @returns the inputLine */
-  const char* getInput() const { return this->inputLine; };
+  const std::string& getInput() const { return this->inputLine; };
 
   // InputLine
   void flush();
-  void setInputText(const char* text);
+  void setInputText(const std::string& text);
   void addCharacter(char character);
-  void addCharacters(const char* characters);
+  void addCharacters(const std::string& characters);
   void removeCharacters(unsigned int characterCount = 1);
   void setRepeatDelay(float repeatDelay, float repeatRate);
@@ -47,5 +47,5 @@
   void historyMoveDown();
 
-  void help(const char* className = "", const char* function = "");
+  void help(const std::string& className = "", const std::string& function = "");
 
   virtual void tick(float dt);
@@ -54,16 +54,16 @@
  private:
     // HANDLING TEXT INPUT
-   ShellCompletion*            completion;             //!< The Completion Interface.
+   ShellCompletion*                  completion;       //!< The Completion Interface.
 
-   char*                       inputLine;              //!< the Char-Array of the Buffer
-   float                       repeatRate;             //!< The Repeat-Delay.
-   float                       repeatDelay;            //!< The delay of the first Character of a given Character.
-   float                       delayed;                //!< how much of the delay is remaining.
-   Uint16                      pressedKey;             //!< the pressed key that will be repeated.
+   std::string                       inputLine;        //!< the Char-Array of the Buffer
+   float                             repeatRate;       //!< The Repeat-Delay.
+   float                             repeatDelay;      //!< The delay of the first Character of a given Character.
+   float                             delayed;          //!< how much of the delay is remaining.
+   Uint16                            pressedKey;       //!< the pressed key that will be repeated.
 
-   std::list<char*>            history;                //!< The history of given commands.
-   std::list<char*>::iterator  historyIT;
-   unsigned int                historyLength;          //!< The maximum length of the InputHistory.
-   bool                        historyScrolling;       //!< true if we are scrolling through the history.
+   std::list<std::string>            history;          //!< The history of given commands.
+   std::list<std::string>::iterator  historyIT;        //!< The locator that tells us, where we are in the history.
+   unsigned int                      historyLength;    //!< The maximum length of the InputHistory.
+   bool                              historyScrolling; //!< true if we are scrolling through the history.
 };
 
Index: trunk/src/lib/sound/ogg_player.cc
===================================================================
--- trunk/src/lib/sound/ogg_player.cc	(revision 7201)
+++ trunk/src/lib/sound/ogg_player.cc	(revision 7221)
@@ -31,5 +31,5 @@
  * @param fileName the file to load
  */
-OggPlayer::OggPlayer(const char* fileName)
+OggPlayer::OggPlayer(const std::string& fileName)
 {
   this->setClassID(CL_SOUND_OGG_PLAYER, "OggPlayer");
@@ -40,5 +40,5 @@
   this->buffers[1] = 0;
 
-  if (fileName != NULL)
+  if (!fileName.empty())
   {
     if (this->open(fileName))
@@ -56,5 +56,5 @@
  * @param fileName the file to open
  */
-bool OggPlayer::open(const char* fileName)
+bool OggPlayer::open(const std::string& fileName)
 {
   if (this->buffers[0] == 0)
@@ -72,5 +72,5 @@
   int result;
 
-  if(!(oggFile = fopen(fileName, "rb")))
+  if(!(oggFile = fopen(fileName.c_str(), "rb")))
   {
     PRINTF(2)("Could not open Ogg file.");
Index: trunk/src/lib/sound/ogg_player.h
===================================================================
--- trunk/src/lib/sound/ogg_player.h	(revision 7201)
+++ trunk/src/lib/sound/ogg_player.h	(revision 7221)
@@ -27,8 +27,8 @@
 {
 public:
-  OggPlayer(const char* fileName = NULL);
+  OggPlayer(const std::string& fileName = "");
   virtual ~OggPlayer();
 
-  bool open(const char* fileName);
+  bool open(const std::string& fileName);
   void release();
   void debug();
Index: trunk/src/lib/sound/sound_buffer.cc
===================================================================
--- trunk/src/lib/sound/sound_buffer.cc	(revision 7201)
+++ trunk/src/lib/sound/sound_buffer.cc	(revision 7221)
@@ -32,5 +32,5 @@
  * @param fileName The name of the File
  */
-SoundBuffer::SoundBuffer(const char* fileName)
+SoundBuffer::SoundBuffer(const std::string& fileName)
 {
   this->setClassID(CL_SOUND_BUFFER, "SoundBuffer");
@@ -54,5 +54,5 @@
  * @returns true on success.
  */
-bool SoundBuffer::loadWAV(const char* fileName)
+bool SoundBuffer::loadWAV(const std::string& fileName)
 {
   SDL_AudioSpec wavSpec;
@@ -61,7 +61,7 @@
 
   /* Load the WAV */
-  if( SDL_LoadWAV(fileName, &wavSpec, &wavBuffer, &wavLength) == NULL)
+  if( SDL_LoadWAV(fileName.c_str(), &wavSpec, &wavBuffer, &wavLength) == NULL)
   {
-    PRINTF(2)("Could not open %s: %s\n", fileName, SDL_GetError());
+    PRINTF(2)("Could not open %s: %s\n", fileName.c_str(), SDL_GetError());
     return false;
   }
Index: trunk/src/lib/sound/sound_buffer.h
===================================================================
--- trunk/src/lib/sound/sound_buffer.h	(revision 7201)
+++ trunk/src/lib/sound/sound_buffer.h	(revision 7221)
@@ -17,8 +17,8 @@
 {
   public:
-    SoundBuffer(const char* fileName);
+    SoundBuffer(const std::string& fileName);
     virtual ~SoundBuffer();
 
-    bool loadWAV(const char* fileName);
+    bool loadWAV(const std::string& fileName);
 
     /** @returns the ID of the buffer used in this SoundBuffer */
Index: trunk/src/lib/sound/sound_engine.cc
===================================================================
--- trunk/src/lib/sound/sound_engine.cc	(revision 7201)
+++ trunk/src/lib/sound/sound_engine.cc	(revision 7221)
@@ -99,12 +99,12 @@
 void SoundEngine::loadSettings(IniParser* iniParser)
 {
-  const char* channels = iniParser->getVar(CONFIG_NAME_AUDIO_CHANNELS, CONFIG_SECTION_AUDIO, "32");
-  this->maxSourceCount = atoi(channels);
-
-  const char* effectsVolume = iniParser->getVar(CONFIG_NAME_EFFECTS_VOLUME, CONFIG_SECTION_AUDIO, "80");
-  this->effectsVolume = atof(effectsVolume)/100.0;
-
-  const char* musicVolume = iniParser->getVar(CONFIG_NAME_MUSIC_VOLUME, CONFIG_SECTION_AUDIO, "75");
-  this->musicVolume = atof(musicVolume)/100.0;
+  MultiType channels = iniParser->getVar(CONFIG_NAME_AUDIO_CHANNELS, CONFIG_SECTION_AUDIO, "32");
+  this->maxSourceCount = channels.getInt();
+
+  MultiType effectsVolume = iniParser->getVar(CONFIG_NAME_EFFECTS_VOLUME, CONFIG_SECTION_AUDIO, "80");
+  this->effectsVolume = effectsVolume.getFloat()/100.0;
+
+  MultiType musicVolume = iniParser->getVar(CONFIG_NAME_MUSIC_VOLUME, CONFIG_SECTION_AUDIO, "75");
+  this->musicVolume = musicVolume.getFloat()/100.0;
 }
 
@@ -117,5 +117,5 @@
    acctualy this is nothing more than a wrapper around the ResourceManager.
 */
-SoundSource* SoundEngine::createSource(const char* fileName, PNode* sourceNode)
+SoundSource* SoundEngine::createSource(const std::string& fileName, PNode* sourceNode)
 {
   return new SoundSource(sourceNode, (SoundBuffer*)ResourceManager::getInstance()->load(fileName, WAV, RP_LEVEL));
Index: trunk/src/lib/sound/sound_engine.h
===================================================================
--- trunk/src/lib/sound/sound_engine.h	(revision 7201)
+++ trunk/src/lib/sound/sound_engine.h	(revision 7221)
@@ -33,5 +33,5 @@
     void loadSettings(IniParser* iniParser);
 
-    SoundSource* createSource(const char* fileName, PNode* sourceNode = NULL);
+    SoundSource* createSource(const std::string& fileName, PNode* sourceNode = NULL);
 
     /** @param listener the listener in the scene */
Index: trunk/src/lib/util/executor/executor.cc
===================================================================
--- trunk/src/lib/util/executor/executor.cc	(revision 7201)
+++ trunk/src/lib/util/executor/executor.cc	(revision 7221)
@@ -105,16 +105,9 @@
   value[4] = &value4;
 
-  printf("%s ::: paramCount: %d\n", this->getName(), this->paramCount);
   for (unsigned int i = 0; i < this->paramCount; i++)
   {
     if (*value[i] != MT_NULL)
     {
-      printf("1:::: %d : %s \n",i, MultiType::MultiTypeToString(this->defaultValue[i].getType()));
-
-      this->defaultValue[i].debug();
-      //this->defaultValue[i].setValueOf(*value[i]);
-      //printf("2::::%s\n", MultiType::MultiTypeToString(this->defaultValue[i].getType()));
-      //this->defaultValue[i].debug();
-    //this->defaultValue[i].setValueOf(*value[i]);
+      this->defaultValue[i].setValueOf(*value[i]);
     }
   }
Index: trunk/src/lib/util/executor/executor.h
===================================================================
--- trunk/src/lib/util/executor/executor.h	(revision 7201)
+++ trunk/src/lib/util/executor/executor.h	(revision 7221)
@@ -16,8 +16,8 @@
 //! an enumerator for the definition of the Type.
 typedef enum {
-  Executor_Objective         = 0x00000001,
-  Executor_Static            = 0x00000002,
-
-  Executor_NoLoadString      = 0x00000010,
+  Executor_Objective         = 1,
+  Executor_Static            = 2,
+
+  Executor_NoLoadString      = 8,
 } Executor_Type;
 
@@ -48,5 +48,5 @@
 
     /** executes a Command @param object the object to apply this to @param parameters the parameters the command takes */
-    virtual void execute (BaseObject* object, const void* parameters = NULL) = 0;
+    virtual void execute (BaseObject* object, const std::string& parameters = "") = 0;
 
     /** @returns the Type of this Function (either static or objective) */
@@ -87,4 +87,6 @@
 #define   l_FLOAT_DEFGRAB(i)        this->defaultValue[i].getFloat()
 //! where to chek for default STRING values
+#define   l_STRING_DEFGRAB(i)       this->defaultValue[i].getString()
+//! where to chek for default CSTRING values
 #define   l_CSTRING_DEFGRAB(i)      this->defaultValue[i].getCString()
 
@@ -190,20 +192,20 @@
 #define ExecutorExecute1(t1) \
    else if (this->paramCount == 1 && this->defaultValue[0] == t1##_PARAM) \
-    EXECUTOREXECUTER(_1_##t1)(t1##_FUNC((const char*)parameters, t1##_DEFGRAB(0)))
+    EXECUTOREXECUTER(_1_##t1)(t1##_FUNC(sub[0], t1##_DEFGRAB(0)))
 
 //! execute-macro for functions with two parameters
 #define ExecutorExecute2(t1,t2) \
    else if (this->paramCount == 2 && this->defaultValue[0] == t1##_PARAM && this->defaultValue[1] == t2##_PARAM) \
-    EXECUTOREXECUTER(_2_##t1##_##t2)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)))
+    EXECUTOREXECUTER(_2_##t1##_##t2)(t1##_FUNC(sub[0], t1##_DEFGRAB(0)), t2##_FUNC(sub[1], t2##_DEFGRAB(1)))
 
 //! execute-macro for functions with three parameters
 #define ExecutorExecute3(t1,t2,t3) \
    else if (this->paramCount == 3 && this->defaultValue[0] == t1##_PARAM && this->defaultValue[1] == t2##_PARAM && this->defaultValue[2] == t3##_PARAM) \
-    EXECUTOREXECUTER(_3_##t1##_##t2##_##t3)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)), t3##_FUNC(sub.getString(2), t3##_DEFGRAB(2)))
+    EXECUTOREXECUTER(_3_##t1##_##t2##_##t3)(t1##_FUNC(sub[0], t1##_DEFGRAB(0)), t2##_FUNC(sub[1], t2##_DEFGRAB(1)), t3##_FUNC(sub[2], t3##_DEFGRAB(2)))
 
 //! execute-macro for functions with four parameters
 #define ExecutorExecute4(t1,t2,t3,t4) \
    else if (this->paramCount == 4 && this->defaultValue[0] == t1##_PARAM && this->defaultValue[1] == t2##_PARAM && this->defaultValue[2] == t3##_PARAM && this->defaultValue[3] == t4##_PARAM) \
-    EXECUTOREXECUTER(_4_##t1##_##t2##_##t3##_##t4)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)), t3##_FUNC(sub.getString(2), t3##_DEFGRAB(2)), t4##_FUNC(sub.getString(3), t4##_DEFGRAB(3))) \
+    EXECUTOREXECUTER(_4_##t1##_##t2##_##t3##_##t4)(t1##_FUNC(sub[0], t1##_DEFGRAB(0)), t2##_FUNC(sub[1], t2##_DEFGRAB(1)), t3##_FUNC(sub[2], t3##_DEFGRAB(2)), t4##_FUNC(sub[3], t4##_DEFGRAB(3))) \
 
 
@@ -211,5 +213,5 @@
 #define ExecutorExecute5(t1,t2,t3,t4,t5) \
    else if (this->paramCount == 5 && this->defaultValue[0] == t1##_PARAM && this->defaultValue[1] == t2##_PARAM && this->defaultValue[2] == t3##_PARAM && this->defaultValue[3] == t4##_PARAM && this->defaultValue[4] == t5##_PARAM) \
-    EXECUTOREXECUTER(_5_##t1##_##t2##_##t3##_##t4##_##t5)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)), t3##_FUNC(sub.getString(2), t3##_DEFGRAB(2)), t4##_FUNC(sub.getString(3), t4##_DEFGRAB(3)), t5##_FUNC(sub.getString(4), t5##_DEFGRAB(4)))
+    EXECUTOREXECUTER(_5_##t1##_##t2##_##t3##_##t4##_##t5)(t1##_FUNC(sub[0], t1##_DEFGRAB(0)), t2##_FUNC(sub[1], t2##_DEFGRAB(1)), t3##_FUNC(sub[2], t3##_DEFGRAB(2)), t4##_FUNC(sub[3], t4##_DEFGRAB(3)), t5##_FUNC(sub[4], t5##_DEFGRAB(4)))
 
 
@@ -240,12 +242,12 @@
 #define EXECUTORTYPE                   Executor_Objective
 //! keeps information about a Executor
-template<class T> class ExecutorObjective : public Executor
+template<class T> class EXECUTOR : public Executor
 {
   public:
-    ExecutorObjective() : Executor() { };
+    EXECUTOR() : Executor() { };
     // COPY constuctor (virtual version)
     virtual Executor* clone () const
     {
-      ExecutorObjective<T>* executor = new ExecutorObjective<T>();
+      EXECUTOR<T>* executor = new EXECUTOR<T>();
       this->cloning(executor);
       executor->fp = this->fp;
@@ -266,8 +268,8 @@
     } fp;
 
-    virtual void execute (BaseObject* object, const void* parameters = NULL)
+    virtual void execute (BaseObject* object, const std::string& parameters = "")
     {
-      SubString sub((const char*) parameters, " \n\t,", '\\');
-      printf("%s :: %s\n", this->getName(), (const char*) parameters);
+      SubString sub;
+      sub.split(parameters, " \n\t,", '\\');
 //! FUNCTOR_LIST is the List of Executive Functions
 #define FUNCTOR_LIST(x) ExecutorExecute ## x
@@ -305,9 +307,9 @@
 {
   public:
-    ExecutorStatic() : Executor() { };
+    EXECUTOR() : Executor() { };
     // COPY constuctor
     virtual Executor* clone () const
     {
-      ExecutorStatic<T>* executor = new ExecutorStatic<T>();
+      EXECUTOR<T>* executor = new EXECUTOR<T>();
       this->cloning(executor);
       executor->fp = this->fp;
@@ -329,7 +331,8 @@
 
 
-    virtual void execute (BaseObject* object, const void* parameters = NULL)
+    virtual void execute (BaseObject* object, const std::string& parameters = "")
     {
-  SubString sub((const char*)parameters, " \n\t,");
+      SubString sub;
+      sub.split(parameters, " \n\t,", '\\');
 //! FUNCTOR_LIST is the List of Executive Functions
 #define FUNCTOR_LIST(x) ExecutorExecute ## x
Index: trunk/src/lib/util/executor/executor_specials.h
===================================================================
--- trunk/src/lib/util/executor/executor_specials.h	(revision 7201)
+++ trunk/src/lib/util/executor/executor_specials.h	(revision 7221)
@@ -60,5 +60,5 @@
      * @param loadString ignored in this case
      */
-    virtual void execute(BaseObject* object, const void* parameters = NULL)
+    virtual void execute(BaseObject* object, const std::string& = "")
     {
       if (object != NULL && this->element != NULL)
Index: trunk/src/lib/util/executor/functor_list.h
===================================================================
--- trunk/src/lib/util/executor/functor_list.h	(revision 7201)
+++ trunk/src/lib/util/executor/functor_list.h	(revision 7221)
@@ -21,5 +21,5 @@
    l_SHORT:     short
    l_FLOAT:     float
-   l_CSTRING:    const char*
+   l_STRING:    const std::string&
    l_XML_ELEM:  TiXmlElement*
  */
@@ -74,14 +74,8 @@
 //#define l_VECTOR_DEFAULT   Vector(0,0,0)        //!< Default value for a VECTOR
 
-#define l_CSTRING_TYPE     const char*          //!< The type of a STRING
-#define l_CSTRING_FUNC     isString             //!< The function to parse a STRING
-#define l_CSTRING_NAME     "string"             //!< The name of a STRING
-#define l_CSTRING_PARAM    MT_STRING            //!< the type of the parameter STRING
-#define l_CSTRING_DEFAULT  ""                   //!< a default Value for an STRING
-
 #define l_STRING_TYPE      const std::string&   //!< The type of a STRING
 #define l_STRING_FUNC      isString             //!< The function to parse a STRING
 #define l_STRING_NAME      "string"             //!< The name of a STRING
-#define l_STRING_PARAM     MT_STRING            //!< the type of the parameter STRING
+#define l_STRING_PARAM     MT_STRING           //!< the type of the parameter STRING
 #define l_STRING_DEFAULT   ""                   //!< a default Value for an STRING
 
@@ -99,11 +93,12 @@
   FUNCTOR_LIST(0)();
   //! makes functions with one string
-  FUNCTOR_LIST(1)(l_CSTRING);
+  FUNCTOR_LIST(1)(l_STRING);
   //! makes functions with two strings
-  FUNCTOR_LIST(2)(l_CSTRING, l_CSTRING);
+  FUNCTOR_LIST(2)(l_STRING, l_STRING);
   //! makes functions with three strings
-  FUNCTOR_LIST(3)(l_CSTRING, l_CSTRING, l_CSTRING);
+  FUNCTOR_LIST(3)(l_STRING, l_STRING, l_STRING);
   //! makes functions with four strings
-  FUNCTOR_LIST(4)(l_CSTRING, l_CSTRING, l_CSTRING, l_CSTRING);
+  FUNCTOR_LIST(4)(l_STRING, l_STRING, l_STRING, l_STRING);
+
 
   //! makes functions with one bool
@@ -141,9 +136,9 @@
 
   //! mixed values:
-  FUNCTOR_LIST(2)(l_CSTRING, l_FLOAT);
+  FUNCTOR_LIST(2)(l_STRING, l_FLOAT);
   FUNCTOR_LIST(2)(l_UINT, l_LONG);
-  FUNCTOR_LIST(2)(l_CSTRING, l_UINT);
+  FUNCTOR_LIST(2)(l_STRING, l_UINT);
 
-  FUNCTOR_LIST(3)(l_CSTRING, l_FLOAT, l_UINT);
+  FUNCTOR_LIST(3)(l_STRING, l_FLOAT, l_UINT);
 
 
Index: trunk/src/lib/util/helper_functions.cc
===================================================================
--- trunk/src/lib/util/helper_functions.cc	(revision 7201)
+++ trunk/src/lib/util/helper_functions.cc	(revision 7221)
@@ -22,38 +22,37 @@
 
 /**
- * checks if the input was a bool
+ * @brief checks if the input was a bool
  * @param BOOL a String that holds a bool: must be one of those: 1,0,true,false(case-insensitive)
  * @param defaultValue a default value that is set, if BOOL is corrupt
  * @return returns the bool, if BOOL was correct otherwise defaultValue
  */
-bool isBool(const char* BOOL, bool defaultValue)
+bool isBool(const std::string& BOOL, bool defaultValue)
 {
-  if (BOOL == NULL)
+  if (BOOL.empty())
     return defaultValue;
-  if(!strcmp(BOOL, "1") || !strcasecmp( BOOL, "true") )
+  if(BOOL[0] == '1' || BOOL == "true" )
     return true;
-  else if (!strcmp(BOOL, "0") || !strcasecmp( BOOL, "false"))
+  else if (BOOL[0] == '0' || BOOL == "false")
     return false;
   else
     return defaultValue;
-
 }
 
 
 /**
- * checks if the input was a int
+ * @brief checks if the input was a int
  * @param INT a String that holds an int.
  * @param defaultValue a default value that is set, if INT is corrupt
  * @return returns the contained int, if INT was correct otherwise defaultValue
  */
-int isInt(const char* INT, int defaultValue)
+int isInt(const std::string& INT, int defaultValue)
 {
-  if (INT == NULL)
+  if (INT.empty())
     return defaultValue;
   char* endPtr = NULL;
 
-  int result = strtol(INT, &endPtr, 10);
+  int result = strtol(INT.c_str(), &endPtr, 10);
 
-  if ( endPtr >= INT && endPtr < INT + strlen(INT))
+  if ( endPtr >= INT.c_str() && endPtr < INT.c_str()+ INT.size())
     return defaultValue;
   else
@@ -63,17 +62,17 @@
 
 /**
- * checks if the input was a float
+ * @brief checks if the input was a float
  * @param FLOAT a String that holds an float.
  * @param defaultValue a default value that is set, if FLOAT is corrupt
  * @return returns the contained float, if FLOAT was correct otherwise defaultValue
  */
-float isFloat(const char* FLOAT, float defaultValue)
+float isFloat(const std::string& FLOAT, float defaultValue)
 {
-  if (FLOAT == NULL)
+  if (FLOAT.empty())
     return defaultValue;
   char* endPtr = NULL;
-  double result = strtod(FLOAT, &endPtr);
+  double result = strtod(FLOAT.c_str(), &endPtr);
 
-  if ( endPtr >= FLOAT && endPtr < FLOAT + strlen(FLOAT))
+  if ( endPtr >= FLOAT.c_str() && endPtr < FLOAT.c_str() + FLOAT.size())
     return defaultValue;
   else
@@ -83,14 +82,57 @@
 
 /**
- * checks if the input was a string
+ * @brief checks if the input was a string
  * @param STING a String(char-array) that holds an string.
  * @param defaultValue a default value that is set, if STRING is corrupt
  * @return returns the contained string (char-array), if STRING was correct otherwise defaultValue
  */
-const char* isString(const char* STRING, const char* defaultValue)
+const char* isCString(const std::string& STRING, const char* defaultValue)
 {
-  if (STRING != NULL && strlen(STRING) > 0)
+  if (STRING.size() > 0)
+    return STRING.c_str();
+  else
+    return defaultValue;
+}
+
+/**
+ * @brief checks if the input was a string
+ * @param STING a String(char-array) that holds an string.
+ * @param defaultValue a default value that is set, if STRING is corrupt
+ * @return returns the contained string (char-array), if STRING was correct otherwise defaultValue
+ */
+std::string isString(const std::string& STRING, const std::string& defaultValue)
+{
+  if (STRING.size() > 0)
     return STRING;
   else
     return defaultValue;
 }
+
+
+/**
+ * @brief compares two strings without ignoring the case
+ * @param s1 first string
+ * @param s2 second string
+ */
+int nocase_cmp(const std::string& s1, const std::string& s2)
+{
+  std::string::const_iterator it1=s1.begin();
+  std::string::const_iterator it2=s2.begin();
+
+  //stop when either string's end has been reached
+  while ( (it1!=s1.end()) && (it2!=s2.end()) )
+  {
+    if(::toupper(*it1) != ::toupper(*it2)) //letters differ?
+     // return -1 to indicate smaller than, 1 otherwise
+      return (::toupper(*it1)  < ::toupper(*it2)) ? -1 : 1;
+    //proceed to the next character in each string
+    ++it1;
+    ++it2;
+  }
+  size_t size1=s1.size(), size2=s2.size();// cache lengths
+   //return -1,0 or 1 according to strings' lengths
+  if (size1==size2)
+    return 0;
+  return (size1<size2) ? -1 : 1;
+}
+
Index: trunk/src/lib/util/helper_functions.h
===================================================================
--- trunk/src/lib/util/helper_functions.h	(revision 7201)
+++ trunk/src/lib/util/helper_functions.h	(revision 7221)
@@ -7,4 +7,6 @@
 #define _HELPER_FUNCTIONS_H
 
+#include <string>
+
 // FORWARD DECLARATION
 
@@ -12,8 +14,13 @@
 *** HELPER FUNCTIONS ***
 ***********************/
-bool          isBool(const char* BOOL, bool defaultValue);
-int           isInt(const char* INT, int defaultValue);
-float         isFloat(const char* FLOAT, float defaultValue);
-const char*   isString(const char* STRING, const char* defaultValue);
+bool          isBool(const std::string& BOOL, bool defaultValue);
+int           isInt(const std::string& INT, int defaultValue);
+float         isFloat(const std::string& FLOAT, float defaultValue);
+const char*   isCString(const std::string& STRING, const char* defaultValue);
+std::string   isString(const std::string& STRING, const std::string& defaultValue);
+
+
+int           nocase_cmp(const std::string& s1, const std::string& s2);
+
 
 #endif /* _HELPER_FUNCTIONS_H */
Index: trunk/src/lib/util/loading/factory.cc
===================================================================
--- trunk/src/lib/util/loading/factory.cc	(revision 7201)
+++ trunk/src/lib/util/loading/factory.cc	(revision 7221)
@@ -23,22 +23,14 @@
 //SHELL_COMMAND(create, Factory, fabricate);
 
-
-/*  --------------------------------------------------
- *               Factory
- *   --------------------------------------------------
+/**
+ * @brief constructor
+ *
+ * set everything to zero and define factoryName
  */
-
-/**
- *  constructor
-
-   set everything to zero and define factoryName
-*/
-Factory::Factory (const char* factoryName, ClassID classID)
+Factory::Factory (const std::string& factoryName, ClassID classID)
+  : className(factoryName), classID(classID)
 {
   this->setClassID(CL_FACTORY, "Factory");
   this->setName(factoryName);
-
-  this->classID = classID;
-  this->className = factoryName;
 
   if( Factory::factoryList == NULL)
@@ -48,11 +40,9 @@
 }
 
-/** a reference to the First Factory */
+/** @brief a reference to the First Factory */
 std::list<Factory*>* Factory::factoryList = NULL;
 
 /**
- *  destructor
- *
- * clear the Q
+ * @brief destructor
  */
 Factory::~Factory ()
@@ -64,5 +54,5 @@
 
 /**
- * deletes all the Factories. (cleanup)
+ * @brief deletes all the Factories. (cleanup)
  */
 void Factory::deleteFactories()
@@ -90,5 +80,5 @@
 
 /**
- * Compares the Factories Name against a given ClassName
+ * @brief Compares the Factories Name against a given ClassName
  * @param className the Name of the Class to Query
  * @returns true on match, false otherwise.
@@ -96,10 +86,20 @@
 bool Factory::operator==(const char* className) const
 {
-  return(className != NULL && !strcmp(className, this->className));
+  return(className != NULL && this->className == className);
+}
+
+/**
+ * @brief Compares the Factories Name against a given ClassName
+ * @param className the Name of the Class to Query
+ * @returns true on match, false otherwise.
+ */
+bool Factory::operator==(const std::string& className) const
+{
+  return(this->className == className);
 }
 
 
 /**
- * Creates a new Object of type root->Value() (name)
+ * @brief Creates a new Object of type root->Value() (name)
  * @param root the XML-Root to match for the newly created Object
  * @returns a new Object of Type root->Value() on match, NULL otherwise
@@ -133,7 +133,7 @@
  * @returns a new Object of Type className on match, NULL otherwise
  */
- BaseObject* Factory::fabricate(const char* className)
+ BaseObject* Factory::fabricate(const std::string& className)
 {
-  if (className == NULL || Factory::factoryList == NULL)
+  if (Factory::factoryList == NULL)
     return NULL;
 
@@ -178,5 +178,5 @@
   else
   {
-    PRINTF(2)("Could not Fabricate an Object of ClassID '%h'\n", classID);
+    PRINTF(2)("Could not Fabricate an Object of ClassID '0x%h'\n", classID);
     return NULL;
   }
Index: trunk/src/lib/util/loading/factory.h
===================================================================
--- trunk/src/lib/util/loading/factory.h	(revision 7201)
+++ trunk/src/lib/util/loading/factory.h	(revision 7221)
@@ -27,5 +27,4 @@
 #include "parser/tinyxml/tinyxml.h"
 #include "base_object.h"
-#include "debug.h"
 #include <vector>
 #include <list>
@@ -34,5 +33,5 @@
  * Creates a factory to a Loadable Class.
  * this should be used at the beginning of all the Classes that should be loadable (in the cc-file)
-*/
+ */
 #define CREATE_FACTORY(CLASS_NAME, CLASS_ID) \
     tFactory<CLASS_NAME>* global_##CLASS_NAME##_Factory = new tFactory<CLASS_NAME>(#CLASS_NAME, CLASS_ID)
@@ -49,5 +48,5 @@
   static void deleteFactories();
 
-  static  BaseObject* fabricate(const char* className);
+  static  BaseObject* fabricate(const std::string& className);
   static  BaseObject* fabricate(ClassID classID);
   static  BaseObject* fabricate(const TiXmlElement* root = NULL);
@@ -56,17 +55,18 @@
   bool operator==(ClassID classID) const;
   bool operator==(const char* className) const;
+  bool operator==(const std::string& className) const;
 
   protected:
-    Factory (const char* factoryName, ClassID classID);
+    Factory (const std::string& factoryName, ClassID classID);
     virtual BaseObject* fabricateObject(const TiXmlElement* root = NULL) const = 0;
 
   protected:
-    ClassID                       classID;              //!< The Class-Identifyer of the Factory.
-    const char*                   className;            //!< The name of the Class.
+    const ClassID                 classID;              //!< The Class-Identifyer of the Factory.
+    const std::string             className;            //!< The name of the Class.
     static std::list<Factory*>*   factoryList;          //!< List of Registered Factories
 };
 
 /**
- *  a factory that is able to load any kind of Object
+ *  @brief a factory that is able to load any kind of Object
  * (this is a Functor)
  */
@@ -75,5 +75,5 @@
  public:
  /**
-  * creates a new type Factory to enable the loading of T
+  * @brief creates a new type Factory to enable the loading of T
   * @param factoryName the Name of the Factory to load.
   * @param classID the ID of the Class to be created.
@@ -85,5 +85,5 @@
   private:
    /**
-    * fabricates an Object of type T, with the constructor T::T(const TiXmlElemnt*)
+    * @brief fabricates an Object of type T, with the constructor T::T(const TiXmlElemnt*)
     * @param root the TiXmlElement T should load parameters from.
     * @return the newly fabricated T.
Index: trunk/src/lib/util/loading/game_loader.cc
===================================================================
--- trunk/src/lib/util/loading/game_loader.cc	(revision 7201)
+++ trunk/src/lib/util/loading/game_loader.cc	(revision 7221)
@@ -86,12 +86,11 @@
  * this will interprete the map/campaign files and recursivly load a tree of worlds/campaigns
  */
-ErrorMessage GameLoader::loadCampaign(const char* fileName)
+ErrorMessage GameLoader::loadCampaign(const std::string& fileName)
 {
   ErrorMessage errorCode;
-  char* campaignName = ResourceManager::getFullName(fileName);
-  if (campaignName)
+  std::string campaignName = ResourceManager::getFullName(fileName);
+  if (!campaignName.empty())
     {
       this->currentCampaign = this->fileToCampaign(campaignName);
-      delete[] campaignName;
     }
 }
@@ -105,12 +104,11 @@
  * this will interprete the map/campaign files and recursivly load a tree of worlds/campaigns
  */
-ErrorMessage GameLoader::loadNetworkCampaign(const char* fileName)
+ErrorMessage GameLoader::loadNetworkCampaign(const std::string& fileName)
 {
   ErrorMessage errorCode;
-  char* campaignName = ResourceManager::getFullName(fileName);
-  if (campaignName)
+  std::string campaignName = ResourceManager::getFullName(fileName);
+  if (!campaignName.empty())
   {
     this->currentCampaign = this->fileToCampaign(campaignName);
-    delete[] campaignName;
   }
 }
@@ -220,5 +218,5 @@
  * this will interprete the map/campaign files and recursivly load a tree of worlds/campaigns
  */
-Campaign* GameLoader::fileToCampaign(const char* fileName)
+Campaign* GameLoader::fileToCampaign(const std::string& fileName)
 {
   /* do not entirely load the campaign. just the current world
@@ -227,5 +225,5 @@
   */
 
-  if( fileName == NULL)
+  if( fileName.empty())
     {
       PRINTF(2)("No filename specified for loading");
@@ -233,16 +231,15 @@
     }
 
-  TiXmlDocument* XMLDoc = new TiXmlDocument( fileName);
+  TiXmlDocument XMLDoc(fileName);
   // load the campaign document
-  if( !XMLDoc->LoadFile())
+  if( !XMLDoc.LoadFile(fileName))
     {
       // report an error
-      PRINTF(1)("Could not load XML File %s: %s @ %d:%d\n", fileName, XMLDoc->ErrorDesc(), XMLDoc->ErrorRow(), XMLDoc->ErrorCol());
-      delete XMLDoc;
+      PRINTF(1)("Could not load XML File %s: %s @ %d:%d\n", fileName.c_str(), XMLDoc.ErrorDesc(), XMLDoc.ErrorRow(), XMLDoc.ErrorCol());
       return NULL;
     }
 
   // check basic validity
-  TiXmlElement* root = XMLDoc->RootElement();
+  TiXmlElement* root = XMLDoc.RootElement();
   assert( root != NULL);
 
@@ -251,15 +248,9 @@
       // report an error
       PRINTF(2)("Specified XML File is not an orxonox campaign file (Campaign element missing)\n");
-      delete XMLDoc;
       return NULL;
     }
 
   // construct campaign
-  Campaign* c = new Campaign( root);
-
-  // free the XML data
-  delete XMLDoc;
-
-  return c;
+  return new Campaign( root);
 }
 
Index: trunk/src/lib/util/loading/game_loader.h
===================================================================
--- trunk/src/lib/util/loading/game_loader.h	(revision 7201)
+++ trunk/src/lib/util/loading/game_loader.h	(revision 7221)
@@ -44,7 +44,7 @@
   static GameLoader* getInstance() { if(singletonRef == NULL) singletonRef = new GameLoader(); return singletonRef; }
 
-  ErrorMessage loadCampaign(const char* name);
+  ErrorMessage loadCampaign(const std::string& name);
   ErrorMessage loadDebugCampaign(Uint32 campaignID);
-  ErrorMessage loadNetworkCampaign(const char* fileName);
+  ErrorMessage loadNetworkCampaign(const std::string& fileName);
 
   ErrorMessage init();
@@ -62,5 +62,5 @@
   GameLoader ();
 
-  Campaign* fileToCampaign(const char* name);
+  Campaign* fileToCampaign(const std::string& name);
 
 
Index: trunk/src/lib/util/loading/load_param.cc
===================================================================
--- trunk/src/lib/util/loading/load_param.cc	(revision 7201)
+++ trunk/src/lib/util/loading/load_param.cc	(revision 7221)
@@ -28,7 +28,7 @@
  * @param executor the Executor, that executes the loading procedure.
  */
-CLoadParam::CLoadParam(const TiXmlElement* root, const char* paramName, BaseObject* object, const Executor& executor, bool inLoadCycle)
-{
-  this->paramName = paramName;
+CLoadParam::CLoadParam(const TiXmlElement* root, const std::string& paramName, BaseObject* object, const Executor& executor, bool inLoadCycle)
+  :  paramName(paramName), object(object)
+{
   this->object = object;
   this->inLoadCycle = inLoadCycle;
@@ -37,6 +37,5 @@
   if (likely(!inLoadCycle))
     this->loadElem = grabParameterElement(root, paramName);
-  //this->loadString = grabParameter(root, paramName);
-  else if (!strcmp(root->Value(), paramName))
+  else if (paramName == root->Value())
     this->loadElem = (TiXmlElement*)root->FirstChild();
   else
@@ -46,6 +45,6 @@
   this->executor = executor.clone();
 
-  if (this->executor)
-    this->executor->setName(paramName);
+  //if (this->executor)
+  //  this->executor->setName(paramName);
 }
 
@@ -60,14 +59,13 @@
   if (likely(this->executor != NULL))
   {
+    std::string loadString = "";
     if (this->loadElem != NULL &&  this->loadElem->ToText())
-      this->loadString = this->loadElem->Value();
-    else
-      this->loadString = NULL;
+      loadString = this->loadElem->Value();
     if (likely(this->object != NULL) &&
-        ( this->loadString != NULL ||
+        ( !loadString.empty() ||
           ((this->executor->getType() & Executor_NoLoadString) == Executor_NoLoadString)))
     {
-      PRINTF(4)("Loading '%s' with Parameters '%s' onto: '%s'(%s)\n", this->paramName, this->loadString, this->object->getName(), this->object->getClassName());
-      this->executor->execute(this->object, this->loadString);
+      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());
+      this->executor->execute(this->object, loadString);
     }
     delete this->executor;
@@ -99,7 +97,7 @@
  * @returns a pointer to itself.
 */
-CLoadParam& CLoadParam::describe(const char* descriptionText)
-{
-  if (LoadClassDescription::parametersDescription && this->paramDesc && !this->paramDesc->getDescription())
+CLoadParam& CLoadParam::describe(const std::string& descriptionText)
+{
+  if (LoadClassDescription::parametersDescription && this->paramDesc && this->paramDesc->getDescription().empty())
   {
     this->paramDesc->setDescription(descriptionText);
@@ -230,15 +228,14 @@
  * @returns the Value of the parameter if found, NULL otherwise
 */
-const char* grabParameter(const TiXmlElement* root, const char* parameterName)
+std::string grabParameter(const TiXmlElement* root, const std::string& parameterName)
 {
   const TiXmlElement* element;
   const TiXmlNode* node;
 
-  if (root == NULL || parameterName == NULL)
-    return NULL;
-  assert( parameterName != NULL);
+  if (root == NULL)
+    return "";
 
   element = root->FirstChildElement( parameterName);
-  if( element == NULL) return NULL;
+  if( element == NULL) return "";
 
   node = element->FirstChild();
@@ -248,5 +245,5 @@
     node = node->NextSibling();
   }
-  return NULL;
+  return "";
 }
 
@@ -256,12 +253,11 @@
  * @returns the Element of the parameter if found, NULL otherwise
  */
-const TiXmlElement* grabParameterElement(const TiXmlElement* root, const char* parameterName)
+const TiXmlElement* grabParameterElement(const TiXmlElement* root, const std::string& parameterName)
 {
   const TiXmlElement* element;
   const TiXmlNode* node;
 
-  if (root == NULL || parameterName == NULL)
+  if (root == NULL)
     return NULL;
-  assert( parameterName != NULL);
 
   element = root->FirstChildElement( parameterName);
Index: trunk/src/lib/util/loading/load_param.h
===================================================================
--- trunk/src/lib/util/loading/load_param.h	(revision 7201)
+++ trunk/src/lib/util/loading/load_param.h	(revision 7221)
@@ -87,12 +87,12 @@
 {
   public:
-    CLoadParam(const TiXmlElement* root, const char* paramName, BaseObject* object, const Executor& executor, bool inLoadCycle = false);
+    CLoadParam(const TiXmlElement* root, const std::string& paramName, BaseObject* object, const Executor& executor, bool inLoadCycle = false);
     virtual ~CLoadParam();
 
-    CLoadParam& describe(const char* descriptionText);
+    CLoadParam& describe(const std::string& descriptionText);
     CLoadParam& defaultValues(const MultiType& value0 = MT_NULL, const MultiType& value1 = MT_NULL,
                               const MultiType& value2 = MT_NULL, const MultiType& value3 = MT_NULL,
                               const MultiType& value4 = MT_NULL);
-    CLoadParam& attribute(const char* attributeName, const Executor& executor);
+    CLoadParam& attribute(const std::string& attributeName, const Executor& executor);
 
 
@@ -101,10 +101,9 @@
     Executor*                executor;
     BaseObject*              object;
-    const char*              paramName;
+    const std::string        paramName;
 
     LoadClassDescription*    classDesc;            //!< The LoadClassDescription of this CLoadParameter
     LoadParamDescription*    paramDesc;            //!< The LoadParameterDescription of this LoadParameter
     const TiXmlElement*      loadElem;             //!< The Element to load.
-    const char*              loadString;           //!< The string loaded by this LoadParam
     const void*              pointerToParam;       //!< A Pointer to a Parameter.
 
@@ -114,6 +113,6 @@
 // helper function
 
-const char* grabParameter(const TiXmlElement* root, const char* parameterName);
-const TiXmlElement* grabParameterElement(const TiXmlElement* root, const char* parameterName);
+std::string grabParameter(const TiXmlElement* root, const std::string& parameterName);
+const TiXmlElement* grabParameterElement(const TiXmlElement* root, const std::string& parameterName);
 
 #endif /* _LOAD_PARAM_H */
Index: trunk/src/lib/util/loading/load_param_description.cc
===================================================================
--- trunk/src/lib/util/loading/load_param_description.cc	(revision 7201)
+++ trunk/src/lib/util/loading/load_param_description.cc	(revision 7221)
@@ -22,11 +22,9 @@
  * @param paramName the name of the parameter to load
  */
-LoadParamDescription::LoadParamDescription(const char* paramName)
+LoadParamDescription::LoadParamDescription(const std::string& paramName)
 {
   this->types = NULL;
-  this->description = NULL;
   this->defaultValues = NULL;
-  this->paramName = new char[strlen(paramName)+1];
-  strcpy(this->paramName, paramName);
+  this->paramName = paramName;
 }
 
@@ -46,6 +44,4 @@
   delete[] this->types;
   delete[] this->defaultValues;
-  delete[] this->paramName;
-  delete[] this->description;
 }
 
@@ -53,8 +49,7 @@
  * @param descriptionText The text to set as a description for this Parameter
  */
-void LoadParamDescription::setDescription(const char* descriptionText)
-{
-  this->description = new char[strlen(descriptionText)+1];
-  strcpy(this->description, descriptionText);
+void LoadParamDescription::setDescription(const std::string& descriptionText)
+{
+  this->description = descriptionText;
 }
 
@@ -64,5 +59,5 @@
 void LoadParamDescription::print() const
 {
-  PRINT(3)(" <%s>", this->paramName);
+  PRINT(3)(" <%s>", this->paramName.c_str());
   for (int i = 0; i < this->paramCount; i++)
   {
@@ -101,7 +96,7 @@
 //     }
   }
-  PRINT(3)("</%s>", this->paramName);
-  if (this->description)
-    PRINT(3)(" -- %s", this->description);
+  PRINT(3)("</%s>", this->paramName.c_str());
+  if (!this->description.empty())
+    PRINT(3)(" -- %s", this->description.c_str());
   // default values
   if (this->paramCount > 0)
@@ -139,8 +134,7 @@
  * @param className the name of the class to be loadable
  */
-LoadClassDescription::LoadClassDescription(const char* className)
-{
-  this->className = new char[strlen(className)+1];
-  strcpy(this->className, className);
+LoadClassDescription::LoadClassDescription(const std::string& className)
+{
+  this->className = className;
 
   if (LoadClassDescription::classList == NULL)
@@ -161,6 +155,4 @@
     this->paramList.pop_front();
   }
-
-  delete[] this->className;
 }
 
@@ -187,5 +179,5 @@
    Otherwise it returns a new classDescription
  */
-LoadClassDescription* LoadClassDescription::addClass(const char* className)
+LoadClassDescription* LoadClassDescription::addClass(const std::string& className)
 {
   if (LoadClassDescription::classList != NULL)
@@ -194,5 +186,5 @@
     while (it != LoadClassDescription::classList->end())
     {
-      if (!strcmp((*it)->className, className))
+      if ((*it)->className == className)
       {
         return (*it);
@@ -205,13 +197,13 @@
 
 /**
- *  does the same as addClass(const char* className), but with params
+ *  does the same as addClass(const std::string& className), but with params
  * @param paramName the name of the parameter to add.
  */
-LoadParamDescription* LoadClassDescription::addParam(const char* paramName)
+LoadParamDescription* LoadClassDescription::addParam(const std::string& paramName)
 {
   std::list<LoadParamDescription*>::iterator it = this->paramList.begin();
   while (it != this->paramList.end())
   {
-    if (!strcmp((*it)->paramName, paramName))
+    if ((*it)->paramName == paramName)
     {
       return NULL;
@@ -231,5 +223,5 @@
  * @todo implement it
  */
-void LoadClassDescription::printAll(const char* fileName)
+void LoadClassDescription::printAll(const std::string& fileName)
 {
   PRINT(3)("===============================================================\n");
@@ -240,5 +232,5 @@
     while (classDesc != LoadClassDescription::classList->end())
     {
-      PRINT(3)("<%s>\n", (*classDesc)->className);
+      PRINT(3)("<%s>\n", (*classDesc)->className.c_str());
       std::list<LoadParamDescription*>::iterator param = (*classDesc)->paramList.begin();
       while (param != (*classDesc)->paramList.end())
@@ -247,5 +239,5 @@
         param++;
       }
-      PRINT(3)("</%s>\n\n", (*classDesc)->className);
+      PRINT(3)("</%s>\n\n", (*classDesc)->className.c_str());
       classDesc++;
     }
@@ -262,10 +254,10 @@
  * !! The strings MUST NOT be deleted !!
  */
-std::list<const char*> LoadClassDescription::searchClassWithShort(const char* classNameBegin)
+std::list<std::string> LoadClassDescription::searchClassWithShort(const std::string& classNameBegin)
 {
   /// FIXME
   // NOT USED
 /*  unsigned int searchLength = strlen(classNameBegin);
-  std::list<const char*> retVal;
+  std::list<const std::string&> retVal;
 
   tIterator<LoadClassDescription>* iterator = LoadClassDescription::classList->getIterator();
Index: trunk/src/lib/util/loading/load_param_description.h
===================================================================
--- trunk/src/lib/util/loading/load_param_description.h	(revision 7201)
+++ trunk/src/lib/util/loading/load_param_description.h	(revision 7221)
@@ -36,19 +36,19 @@
   friend class LoadParam;
   friend class LoadClassDescription;
- public:
-  LoadParamDescription(const char* paramName);
+public:
+  LoadParamDescription(const std::string& paramName);
   ~LoadParamDescription();
 
-  void setDescription(const char* descriptionText);
+  void setDescription(const std::string& descriptionText);
   /** @returns the descriptionString */
-  const char* getDescription() { return this->description; };
+  const std::string& getDescription() { return this->description; };
 
   void print() const;
 
- private:
-  char*         paramName;             //!< The name of the parameter.
+private:
+  std::string   paramName;             //!< The name of the parameter.
   int           paramCount;            //!< The count of parameters.
   int*          types;                 //!< What kind of parameters does this function take ??
-  char*         description;           //!< A longer description about this function.
+  std::string   description;           //!< A longer description about this function.
   char**        defaultValues;         //!< The 'Default Values'. @TODO MAKE THIS A MULTITYPE
 };
@@ -58,21 +58,21 @@
 {
   friend class CLoadParam;
- public:
-  LoadClassDescription(const char* className);
+public:
+  LoadClassDescription(const std::string& className);
   ~LoadClassDescription();
 
-  static LoadClassDescription* addClass(const char* className);
-  LoadParamDescription* addParam(const char* paramName);
+  static LoadClassDescription* addClass(const std::string& className);
+  LoadParamDescription* addParam(const std::string& paramName);
 
   static void deleteAllDescriptions();
 
-  static void printAll(const char* fileName = NULL);
-  static std::list<const char*> searchClassWithShort(const char* classNameBegin);
-//  static const LoadParamDescription* getClass(const char* className);
+  static void printAll(const std::string& fileName = "");
+  static std::list<std::string> searchClassWithShort(const std::string& classNameBegin);
+  //  static const LoadParamDescription* getClass(const std::string& className);
 
- private:
+private:
   static bool                              parametersDescription;  //!< if parameter-description should be enabled.
   static std::list<LoadClassDescription*>* classList;              //!< a list, that stores all the loadable classes. (after one instance has been loaded)
-  char*                                    className;              //!< name of the class
+  std::string                              className;              //!< name of the class
 
   std::list<LoadParamDescription*>         paramList;              //!< List of parameters this class knows.
Index: trunk/src/lib/util/loading/resource_manager.cc
===================================================================
--- trunk/src/lib/util/loading/resource_manager.cc	(revision 7201)
+++ trunk/src/lib/util/loading/resource_manager.cc	(revision 7221)
@@ -59,9 +59,7 @@
   this->setName("ResourceManager");
 
-  this->dataDir = new char[3];
-  strcpy(this->dataDir, "./");
+  this->dataDir = "./";
+  this->_cwd = "";
   this->tryDataDir("./data");
-
-  this->_cwd = NULL;
 }
 
@@ -80,14 +78,4 @@
     PRINTF(1)("Not removed all Resources, since there are still %d resources registered\n", this->resourceList.size());
 
-  // deleting the Directorie Lists
-  while (!this->imageDirs.empty())
-  {
-    delete[] this->imageDirs.back();
-    this->imageDirs.pop_back();
-  }
-
-  delete[] this->dataDir;
-  if (this->_cwd)
-    delete[] this->_cwd;
   ResourceManager::singletonRef = NULL;
 }
@@ -97,29 +85,23 @@
  * @param dataDir the DataDirectory.
  */
-bool ResourceManager::setDataDir(const char* dataDir)
-{
-  char* realDir = ResourceManager::homeDirCheck(dataDir);
+bool ResourceManager::setDataDir(const std::string& dataDir)
+{
+  std::string realDir = ResourceManager::homeDirCheck(dataDir);
   if (isDir(realDir))
   {
-    delete[] this->dataDir;
-    if (dataDir[strlen(dataDir)-1] == '/' || dataDir[strlen(dataDir)-1] == '\\')
+    if (dataDir[dataDir.size()-1] == '/' || dataDir[dataDir.size()-1] == '\\')
     {
-      this->dataDir = new char[strlen(realDir)+1];
-      strcpy(this->dataDir, realDir);
+      this->dataDir = realDir;
     }
     else
     {
-      this->dataDir = new char[strlen(realDir)+2];
-      strcpy(this->dataDir, realDir);
-      this->dataDir[strlen(realDir)] = '/';
-      this->dataDir[strlen(realDir)+1] = '\0';
+      this->dataDir = realDir;
+      this->dataDir += '/';
     }
-    delete[] realDir;
     return true;
   }
   else
   {
-    PRINTF(1)("%s is not a Directory, and can not be the Data Directory, leaving as %s \n", realDir, this->dataDir);
-    delete[] realDir;
+    PRINTF(1)("%s is not a Directory, and can not be the Data Directory, leaving as %s \n", realDir.c_str(), this->dataDir.c_str());
     return false;
   }
@@ -132,26 +114,20 @@
  * this is essentially the same as setDataDir, but it ommits the error-message
  */
-bool ResourceManager::tryDataDir(const char* dataDir)
-{
-  char* realDir = ResourceManager::homeDirCheck(dataDir);
+bool ResourceManager::tryDataDir(const std::string& dataDir)
+{
+  std::string realDir = ResourceManager::homeDirCheck(dataDir);
   if (isDir(realDir))
   {
-    delete[] this->dataDir;
-    if (dataDir[strlen(dataDir)-1] == '/' || dataDir[strlen(dataDir)-1] == '\\')
+    if (dataDir[dataDir.size()-1] == '/' || dataDir[dataDir.size()-1] == '\\')
     {
-      this->dataDir = new char[strlen(realDir)+1];
-      strcpy(this->dataDir, realDir);
+      this->dataDir = realDir;
     }
     else
     {
-      this->dataDir = new char[strlen(realDir)+2];
-      strcpy(this->dataDir, realDir);
-      this->dataDir[strlen(realDir)] = '/';
-      this->dataDir[strlen(realDir)+1] = '\0';
+      this->dataDir = realDir;
+      this->dataDir += '/';
     }
-    delete[] realDir;
     return true;
   }
-  delete[] realDir;
   return false;
 }
@@ -162,17 +138,15 @@
  * @param fileInside is iniside of the given directory.
 */
-bool ResourceManager::verifyDataDir(const char* fileInside)
+bool ResourceManager::verifyDataDir(const std::string& fileInside)
 {
   bool retVal;
   if (!isDir(this->dataDir))
   {
-    PRINTF(1)("%s is not a directory\n", this->dataDir);
-    return false;
-  }
-
-  char* testFile = new char[strlen(this->dataDir)+strlen(fileInside)+1];
-  sprintf(testFile, "%s%s", this->dataDir, fileInside);
+    PRINTF(1)("%s is not a directory\n", this->dataDir.c_str());
+    return false;
+  }
+
+  std::string testFile = this->dataDir + fileInside;
   retVal = isFile(testFile);
-  delete[] testFile;
   return retVal;
 }
@@ -185,21 +159,15 @@
    false otherwise
 */
-bool ResourceManager::addImageDir(const char* imageDir)
-{
-  if (imageDir == NULL)
-    return false;
-
-  char* newDir;
-  if (imageDir[strlen(imageDir)-1] == '/' || imageDir[strlen(imageDir)-1] == '\\')
-  {
-    newDir = new char[strlen(imageDir)+1];
-    strcpy(newDir, imageDir);
-  }
-  else
-  {
-    newDir = new char[strlen(imageDir)+2];
-    strcpy(newDir, imageDir);
-    newDir[strlen(imageDir)] = '/';
-    newDir[strlen(imageDir)+1] = '\0';
+bool ResourceManager::addImageDir(const std::string& imageDir)
+{
+  std::string newDir;
+  if (imageDir[imageDir.size()-1] == '/' || imageDir[imageDir.size()-1] == '\\')
+  {
+    newDir = imageDir;
+  }
+  else
+  {
+    newDir = imageDir;
+    newDir += '/';
   }
   // check if the param is a Directory
@@ -207,11 +175,10 @@
   {
     // check if the Directory has been added before
-    std::vector<char*>::const_iterator imageDir;
+    std::vector<std::string>::const_iterator imageDir;
     for (imageDir = this->imageDirs.begin(); imageDir != this->imageDirs.end(); imageDir++)
     {
-      if (!strcmp(*imageDir, newDir))
+      if (*imageDir == newDir)
       {
-        PRINTF(3)("Path %s already loaded\n", newDir);
-        delete[] newDir;
+        PRINTF(3)("Path %s already loaded\n", newDir.c_str());
         return true;
       }
@@ -223,6 +190,5 @@
   else
   {
-    PRINTF(1)("%s is not a Directory, and can not be added to the Paths of Images\n", newDir);
-    delete[] newDir;
+    PRINTF(1)("%s is not a Directory, and can not be added to the Paths of Images\n", newDir.c_str());
     return false;
   }
@@ -239,21 +205,19 @@
  * @returns a pointer to a desired Resource.
 */
-BaseObject* ResourceManager::load(const char* fileName, ResourcePriority prio,
+BaseObject* ResourceManager::load(const std::string& fileName, ResourcePriority prio,
                                   const MultiType& param0, const MultiType& param1, const MultiType& param2)
 {
-  if (fileName == NULL)
-    return NULL;
   ResourceType tmpType;
 #ifndef NO_MODEL
 #define __IF_OK
-  if (!strncasecmp(fileName+(strlen(fileName)-4), ".obj", 4))
+  if (!strncasecmp(fileName.c_str()+(fileName.size()-4), ".obj", 4))
     tmpType = OBJ;
-  else if (!strncmp(fileName+(strlen(fileName)-4), ".md2", 4))
+  else if (!strncmp(fileName.c_str()+(fileName.size()-4), ".md2", 4))
     tmpType = MD2;
-  else if (!strcasecmp(fileName, "cube") ||
-           !strcasecmp(fileName, "sphere") ||
-           !strcasecmp(fileName, "plane") ||
-           !strcasecmp(fileName, "cylinder") ||
-           !strcasecmp(fileName, "cone"))
+  else if (!strcasecmp(fileName.c_str(), "cube") ||
+            !strcasecmp(fileName.c_str(), "sphere") ||
+            !strcasecmp(fileName.c_str(), "plane") ||
+            !strcasecmp(fileName.c_str(), "cylinder") ||
+            !strcasecmp(fileName.c_str(), "cone"))
     tmpType = PRIM;
 #endif /* NO_MODEL */
@@ -263,9 +227,9 @@
 #endif
 #define __IF_OK
-    if (!strncasecmp(fileName+(strlen(fileName)-4), ".wav", 4))
+    if (!strncasecmp(fileName.c_str()+(fileName.size()-4), ".wav", 4))
       tmpType = WAV;
-    else if (!strncasecmp(fileName+(strlen(fileName)-4), ".mp3", 4))
+    else if (!strncasecmp(fileName.c_str()+(fileName.size()-4), ".mp3", 4))
       tmpType = MP3;
-    else if (!strncasecmp(fileName+(strlen(fileName)-4), ".ogg", 4))
+    else if (!strncasecmp(fileName.c_str()+(fileName.size()-4), ".ogg", 4))
       tmpType = OGG;
 #endif /* NO_AUDIO */
@@ -275,5 +239,5 @@
 #endif
 #define __IF_OK
-      if (!strncasecmp(fileName+(strlen(fileName)-4), ".ttf", 4))
+      if (!strncasecmp(fileName.c_str()+(fileName.size()-4), ".ttf", 4))
         tmpType = TTF;
 #endif /* NO_TEXT */
@@ -283,5 +247,5 @@
 #endif
 #define __IF_OK
-        if (!strncasecmp(fileName+(strlen(fileName)-5), ".vert", 5))
+        if (!strncasecmp(fileName.c_str()+(fileName.size()-5), ".vert", 5))
           tmpType = SHADER;
 #endif /* NO_SHADERS */
@@ -308,9 +272,7 @@
  * during the initialisation instead of at Runtime.
  */
-bool ResourceManager::cache(const char* fileName, ResourceType type, ResourcePriority prio,
+bool ResourceManager::cache(const std::string& fileName, ResourceType type, ResourcePriority prio,
                             const MultiType& param0, const MultiType& param1, const MultiType& param2)
 {
-  assert(fileName != NULL);
-
   // searching if the resource was loaded before.
   Resource* tmpResource;
@@ -359,8 +321,7 @@
  * @returns a pointer to a desired Resource.
 */
-BaseObject* ResourceManager::load(const char* fileName, ResourceType type, ResourcePriority prio,
+BaseObject* ResourceManager::load(const std::string& fileName, ResourceType type, ResourcePriority prio,
                                   const MultiType& param0, const MultiType& param1, const MultiType& param2)
 {
-  assert(fileName != NULL);
 
   // searching if the resource was loaded before.
@@ -397,5 +358,5 @@
  * @returns a pointer to a desired Resource.
  */
-Resource* ResourceManager::loadResource(const char* fileName, ResourceType type, ResourcePriority prio,
+Resource* ResourceManager::loadResource(const std::string& fileName, ResourceType type, ResourcePriority prio,
                                         const MultiType& param0, const MultiType& param1, const MultiType& param2)
 {
@@ -406,9 +367,8 @@
   tmpResource->prio = prio;
   tmpResource->pointer = NULL;
-  tmpResource->name = new char[strlen(fileName)+1];
-  strcpy(tmpResource->name, fileName);
+  tmpResource->name = fileName;
 
   // creating the full name. (directoryName + FileName)
-  char* fullName = ResourceManager::getFullName(fileName);
+  std::string fullName = ResourceManager::getFullName(fileName);
   // Checking for the type of resource \see ResourceType
   switch(type)
@@ -425,5 +385,5 @@
       else
       {
-        PRINTF(2)("File %s in %s does not exist. Loading a cube-Model instead\n", fileName, dataDir);
+        PRINTF(2)("File %s in %s does not exist. Loading a cube-Model instead\n", fileName.c_str(), dataDir.c_str());
         tmpResource->pointer = ResourceManager::load("cube", PRIM, prio, tmpResource->param[0].getFloat());
       }
@@ -435,13 +395,13 @@
         tmpResource->param[0] = 1.0f;
 
-      if (!strcmp(tmpResource->name, "cube"))
+      if (tmpResource->name == "cube")
         tmpResource->pointer = new PrimitiveModel(PRIM_CUBE, tmpResource->param[0].getFloat());
-      else if (!strcmp(tmpResource->name, "sphere"))
+      else if (tmpResource->name == "sphere")
         tmpResource->pointer = new PrimitiveModel(PRIM_SPHERE, tmpResource->param[0].getFloat());
-      else if (!strcmp(tmpResource->name, "plane"))
+      else if (tmpResource->name == "plane")
         tmpResource->pointer = new PrimitiveModel(PRIM_PLANE, tmpResource->param[0].getFloat());
-      else if (!strcmp(tmpResource->name, "cylinder"))
+      else if (tmpResource->name == "cylinder")
         tmpResource->pointer = new PrimitiveModel(PRIM_CYLINDER, tmpResource->param[0].getFloat());
-      else if (!strcmp(tmpResource->name, "cone"))
+      else if (tmpResource->name == "cone")
         tmpResource->pointer = new PrimitiveModel(PRIM_CONE, tmpResource->param[0].getFloat());
       break;
@@ -468,5 +428,5 @@
         tmpResource->pointer = new Font(fullName, (unsigned int) tmpResource->param[0].getInt());
       else
-        PRINTF(2)("%s does not exist in %s. Not loading Font\n", fileName, this->dataDir);
+        PRINTF(2)("%s does not exist in %s. Not loading Font\n", fileName.c_str(), this->dataDir.c_str());
       break;
 #endif /* NO_TEXT */
@@ -494,21 +454,18 @@
       else
       {
-        std::vector<char*>::iterator imageDir;
+        std::vector<std::string>::iterator imageDir;
         for (imageDir = this->imageDirs.begin(); imageDir != this->imageDirs.end(); imageDir++)
         {
-          char* imgName = new char[strlen(*imageDir)+strlen(fileName)+1];
-          sprintf(imgName, "%s%s", *imageDir, fileName);
+          std::string imgName = *imageDir + fileName;
           if(isFile(imgName))
           {
             PRINTF(4)("Image %s resides to %s\n", fileName, imgName);
             tmpResource->pointer = new Texture(imgName, tmpResource->param[0].getInt());
-            delete[] imgName;
             break;
           }
-          delete[] imgName;
         }
       }
       if(!tmpResource)
-        PRINTF(2)("!!Image %s not Found!!\n", fileName);
+        PRINTF(2)("!!Image %s not Found!!\n", fileName.c_str());
       break;
 #endif /* NO_TEXTURES */
@@ -520,5 +477,5 @@
         {
           MultiType param = param0; /// HACK
-          char* secFullName = ResourceManager::getFullName(param.getCString());
+          std::string secFullName = ResourceManager::getFullName(param.getCString());
           if (ResourceManager::isFile(secFullName))
           {
@@ -526,10 +483,9 @@
             tmpResource->pointer = new Shader(fullName, secFullName);
           }
-          delete[] secFullName;
         }
         else
         {
           tmpResource->param[0] = param0;
-          tmpResource->pointer = new Shader(fullName, NULL);
+          tmpResource->pointer = new Shader(fullName, "");
         }
       }
@@ -538,11 +494,9 @@
     default:
       tmpResource->pointer = NULL;
-      PRINTF(1)("No type found for %s.\n   !!This should not happen unless the Type is not supported yet. JUST DO IT!!\n", tmpResource->name);
+      PRINTF(1)("No type found for %s.\n   !!This should not happen unless the Type is not supported yet. JUST DO IT!!\n", tmpResource->name.c_str());
       break;
   }
   if (tmpResource->pointer != NULL)
     this->resourceList.push_back(tmpResource);
-  delete[] fullName;
-
 
   if (tmpResource->pointer != NULL)
@@ -550,6 +504,5 @@
   else
   {
-    PRINTF(2)("Resource %s could not be loaded\n", fileName);
-    delete[] tmpResource->name;
+    PRINTF(2)("Resource %s could not be loaded\n", fileName.c_str());
     delete tmpResource;
     return NULL;
@@ -597,6 +550,5 @@
       delete resource->pointer;
       // deleting the List Entry:
-      PRINTF(4)("Resource %s safely removed.\n", resource->name);
-      delete[] resource->name;
+      PRINTF(4)("Resource %s safely removed.\n", resource->name.c_str());
       std::vector<Resource*>::iterator resourceIT = std::find(this->resourceList.begin(), this->resourceList.end(), resource);
       this->resourceList.erase(resourceIT);
@@ -604,8 +556,8 @@
     }
     else
-      PRINTF(4)("Resource %s not removed, because there are still %d References to it.\n", resource->name, resource->count);
-  }
-  else
-    PRINTF(4)("not deleting resource %s because DeleteLevel to high\n", resource->name);
+      PRINTF(4)("Resource %s not removed, because there are still %d References to it.\n", resource->name.c_str(), resource->count);
+  }
+  else
+    PRINTF(4)("not deleting resource %s because DeleteLevel to high\n", resource->name.c_str());
   return true;
 }
@@ -633,5 +585,5 @@
           if (round == 3)
             PRINTF(2)("unable to unload %s because there are still %d references to it\n",
-                      this->resourceList[index]->name, this->resourceList[index]->count);
+                      this->resourceList[index]->name.c_str(), this->resourceList[index]->count);
           removeCount++;
         }
@@ -653,5 +605,5 @@
  * @returns a Pointer to the Resource if found, NULL otherwise.
 */
-Resource* ResourceManager::locateResourceByInfo(const char* fileName, ResourceType type,
+Resource* ResourceManager::locateResourceByInfo(const std::string& fileName, ResourceType type,
     const MultiType& param0, const MultiType& param1, const MultiType& param2) const
 {
@@ -659,5 +611,5 @@
   for (resource = this->resourceList.begin(); resource != this->resourceList.end(); resource++)
   {
-    if ((*resource)->type == type && !strcmp(fileName, (*resource)->name))
+    if ((*resource)->type == type && fileName == (*resource)->name)
     {
       bool match = false;
@@ -743,15 +695,15 @@
 }
 
-char* ResourceManager::toResourcableString(unsigned int i)
-{
-  int len = strlen(ResourceManager::ResourceTypeToChar(this->resourceList[i]->type));
-  len += strlen(this->resourceList[i]->name);
+std::string ResourceManager::toResourcableString(unsigned int i)
+{
+/*  int len = strlen(ResourceManager::ResourceTypeToChar(this->resourceList[i]->type));
+  len += this->resourceList[i]->name.size();
   if (this->resourceList[i]->param[0].getCString()) len += strlen(this->resourceList[i]->param[0].getCString()) +1;
   if (this->resourceList[i]->param[1].getCString()) len += strlen(this->resourceList[i]->param[1].getCString()) +1;
   if (this->resourceList[i]->param[2].getCString()) len += strlen(this->resourceList[i]->param[2].getCString()) +1;
   len += 10;
-  char* tmp = new char[len];
+  std::string tmp = new char[len];
   tmp[0] = '\0';
-  strcat( tmp, ResourceManager::ResourceTypeToChar(this->resourceList[i]->type));
+  strcat(tmp, ResourceManager::ResourceTypeToChar(this->resourceList[i]->type));
   strcat(tmp,",");
   strcat (tmp, this->resourceList[i]->name);
@@ -771,5 +723,5 @@
     strcat( tmp, this->resourceList[i]->param[2].getCString());
   }
-  return tmp;
+  return tmp;*/
 }
 
@@ -778,7 +730,7 @@
  * @param resourceableString the String to cache the resource from.
  */
-bool ResourceManager::fromResourceableString(const char* resourceableString)
-{
-  SubString splits(resourceableString, ',');
+bool ResourceManager::fromResourceableString(const std::string& resourceableString)
+{
+/*  SubString splits(resourceableString, ',');
   splits.debug();
   if (splits.getCount() == 2)
@@ -793,5 +745,5 @@
   else if (splits.getCount() == 5)
     return this->cache(splits[1], ResourceManager::stringToResourceType(splits[0]),
-                RP_LEVEL, splits[2], splits[3], splits[4]);
+                RP_LEVEL, splits[2], splits[3], splits[4]);*/
 }
 
@@ -802,27 +754,17 @@
  * @returns true if it is a directory/symlink false otherwise
 */
-bool ResourceManager::isDir(const char* directoryName)
-{
-  if (directoryName == NULL)
-    return false;
-
-  char* tmpDirName = NULL;
+bool ResourceManager::isDir(const std::string& directoryName)
+{
+  std::string tmpDirName = directoryName;
   struct stat status;
 
   // checking for the termination of the string given. If there is a "/" at the end cut it away
-  if (directoryName[strlen(directoryName)-1] == '/' ||
-      directoryName[strlen(directoryName)-1] == '\\')
-  {
-    tmpDirName = new char[strlen(directoryName)];
-    strncpy(tmpDirName, directoryName, strlen(directoryName)-1);
-    tmpDirName[strlen(directoryName)-1] = '\0';
-  }
-  else
-  {
-    tmpDirName = new char[strlen(directoryName)+1];
-    strcpy(tmpDirName, directoryName);
-  }
-
-  if(!stat(tmpDirName, &status))
+  if (directoryName[directoryName.size()-1] == '/' ||
+      directoryName[directoryName.size()-1] == '\\')
+  {
+    tmpDirName.erase(tmpDirName.size()-1);
+  }
+
+  if(!stat(tmpDirName.c_str(), &status))
   {
     if (status.st_mode & (S_IFDIR
@@ -832,18 +774,11 @@
                          ))
     {
-      delete[] tmpDirName;
       return true;
     }
     else
-    {
-      delete[] tmpDirName;
       return false;
-    }
-  }
-  else
-  {
-    delete[] tmpDirName;
-    return false;
-  }
+  }
+  else
+    return false;
 }
 
@@ -853,12 +788,12 @@
  * @returns true if it is a regular file/symlink, false otherwise
 */
-bool ResourceManager::isFile(const char* fileName)
-{
-  if (fileName == NULL)
-    return false;
-  char* tmpFileName = ResourceManager::homeDirCheck(fileName);
+bool ResourceManager::isFile(const std::string& fileName)
+{
+  if (fileName.empty())
+    return false;
+  std::string tmpFileName = ResourceManager::homeDirCheck(fileName);
   // actually checks the File
   struct stat status;
-  if (!stat(tmpFileName, &status))
+  if (!stat(tmpFileName.c_str(), &status))
   {
     if (status.st_mode & (S_IFREG
@@ -868,18 +803,11 @@
                          ))
     {
-      delete[] tmpFileName;
       return true;
     }
     else
-    {
-      delete[] tmpFileName;
       return false;
-    }
-  }
-  else
-  {
-    delete[] tmpFileName;
-    return false;
-  }
+  }
+  else
+    return false;
 }
 
@@ -888,19 +816,16 @@
  * @param fileName The file to touch
 */
-bool ResourceManager::touchFile(const char* fileName)
-{
-  char* tmpName = ResourceManager::homeDirCheck(fileName);
-  if (tmpName == NULL)
+bool ResourceManager::touchFile(const std::string& fileName)
+{
+  std::string tmpName = ResourceManager::homeDirCheck(fileName);
+  if (tmpName.empty())
     return false;
   FILE* stream;
-  if( (stream = fopen (tmpName, "w")) == NULL)
-  {
-    PRINTF(1)("could not open %s fro writing\n", fileName);
-    delete[] tmpName;
+  if( (stream = fopen (tmpName.c_str(), "w")) == NULL)
+  {
+    PRINTF(1)("could not open %s fro writing\n", fileName.c_str());
     return false;
   }
   fclose(stream);
-
-  delete[] tmpName;
 }
 
@@ -909,11 +834,8 @@
  * @param fileName the File to delete
 */
-bool ResourceManager::deleteFile(const char* fileName)
-{
-  if (fileName == NULL)
-    return false;
-  char* tmpName = ResourceManager::homeDirCheck(fileName);
-  unlink(tmpName);
-  delete[] tmpName;
+bool ResourceManager::deleteFile(const std::string& fileName)
+{
+  std::string tmpName = ResourceManager::homeDirCheck(fileName);
+  unlink(tmpName.c_str());
 }
 
@@ -921,51 +843,37 @@
  * @param name the Name of the file to check
  * @returns The name of the file, including the HomeDir
- * IMPORTANT: this has to be deleted from the outside
- */
-char* ResourceManager::homeDirCheck(const char* name)
-{
-  if (name == NULL)
-    return NULL;
-  char* retName;
-  if (!strncmp(name, "~/", 2))
-  {
-    char tmpFileName[500];
+ */
+std::string ResourceManager::homeDirCheck(const std::string& name)
+{
+  if (name.size() >= 2 && name[0] == '~' && name[1] == '/')
+  {
+    std::string homeDir;
+    std::string newName = name.substr(1);
 #ifdef __WIN32__
-    strcpy(tmpFileName, getenv("USERPROFILE"));
+    homeDir = getenv("USERPROFILE");
 #else
-    strcpy(tmpFileName, getenv("HOME"));
-#endif
-    retName = new char[strlen(tmpFileName)+strlen(name)];
-    sprintf(retName, "%s%s", tmpFileName, name+1);
-  }
-  else
-  {
-    retName = new char[strlen(name)+1];
-    strcpy(retName, name);
-  }
-  return retName;
+    homeDir = getenv("HOME");
+#endif
+    return homeDir + newName;
+  }
+  else
+    return name;
 }
 
 /**
  * @param name the relative name of the File/Directory.
- * @returns a new char* with the name in abs-dir-format
- */
-char* ResourceManager::getAbsDir(const char* name)
-{
-  if (name == NULL)
-    return NULL;
-  char* retName;
-  if (strncmp(name, "/", 1))
-  {
-    if (*name == '.' && *(name+1) != '.')
-      name++;
-    const char* absDir = ResourceManager::cwd();
-    retName = new char[strlen(absDir)+strlen(name)+1];
-    sprintf(retName, "%s%s", absDir, name);
-  }
-  else
-  {
-    retName = new char[strlen(name)+1];
-    strcpy(retName, name);
+ * @returns a new std::string with the name in abs-dir-format
+ */
+std::string ResourceManager::getAbsDir(const std::string& name)
+{
+  if (name.empty())
+    return "";
+  std::string retName = name;
+  if (strncmp(name.c_str(), "/", 1))
+  {
+    if (name[0] == '.' && name[1] != '.')
+      retName.erase(0);
+    const std::string& absDir = ResourceManager::cwd();
+    retName = absDir + retName;
   }
   return retName;
@@ -978,19 +886,14 @@
  * !!IMPORTANT: this has to be deleted from the outside!!
 */
-char* ResourceManager::getFullName(const char* fileName)
-{
-  if (fileName == NULL || ResourceManager::getInstance()->getDataDir() == NULL)
-    return NULL;
-
-  char* retName = new char[strlen(ResourceManager::getInstance()->getDataDir())
-                           + strlen(fileName) + 1];
-  sprintf(retName, "%s%s", ResourceManager::getInstance()->getDataDir(), fileName);
+std::string ResourceManager::getFullName(const std::string& fileName)
+{
+  if (fileName.empty() || ResourceManager::getInstance()->getDataDir().empty())
+    return "";
+
+  std::string retName = ResourceManager::getInstance()->getDataDir() +fileName;
   if (ResourceManager::isFile(retName) || ResourceManager::isDir(retName))
     return retName;
   else
-  {
-    delete[] retName;
-    return NULL;
-  }
+    return "";
 }
 
@@ -1005,15 +908,14 @@
  * @returns the Current Woring Directory
  */
-const char* ResourceManager::cwd()
-{
-  if (ResourceManager::getInstance()->_cwd == NULL)
+const std::string& ResourceManager::cwd()
+{
+  if (ResourceManager::getInstance()->_cwd.empty())
   {
     char cwd[1024];
     char* errorCode = getcwd(cwd, 1024);
     if (errorCode == 0)
-      return NULL;
-
-    ResourceManager::getInstance()->_cwd = new char[strlen(cwd)+1];
-    strcpy(ResourceManager::getInstance()->_cwd, cwd);
+      return ResourceManager::getInstance()->_cwd;
+
+    ResourceManager::getInstance()->_cwd = cwd;
   }
   return ResourceManager::getInstance()->_cwd;
@@ -1026,13 +928,11 @@
  * @returns true if the file exists, false otherwise
  */
-bool ResourceManager::isInDataDir(const char* fileName)
-{
-  if (fileName == NULL || ResourceManager::getInstance()->getDataDir() == NULL)
+bool ResourceManager::isInDataDir(const std::string& fileName)
+{
+  if (fileName.empty() || ResourceManager::getInstance()->getDataDir().empty())
     return false;
 
   bool retVal = false;
-  char* checkFile = new char[strlen(ResourceManager::getInstance()->getDataDir())
-                             + strlen(fileName) + 1];
-  sprintf(checkFile, "%s%s", ResourceManager::getInstance()->getDataDir(), fileName);
+  std::string checkFile = ResourceManager::getInstance()->getDataDir() + fileName;
 
   if (ResourceManager::isFile(checkFile) || ResourceManager::isDir(checkFile))
@@ -1040,5 +940,4 @@
   else
     retVal = false;
-  delete[] checkFile;
   return retVal;
 }
@@ -1055,9 +954,9 @@
   // if it is not initialized
   PRINT(0)(" Reference is: %p\n", ResourceManager::singletonRef);
-  PRINT(0)(" Data-Directory is: %s\n", this->dataDir);
+  PRINT(0)(" Data-Directory is: %s\n", this->dataDir.c_str());
   PRINT(0)(" List of Image-Directories: ");
-  std::vector<char*>::const_iterator imageDir;
+  std::vector<std::string>::const_iterator imageDir;
   for (imageDir = this->imageDirs.begin(); imageDir != this->imageDirs.end(); imageDir++)
-    PRINT(0)("%s ", (*imageDir));
+    PRINT(0)("%s ", (*imageDir).c_str());
   PRINT(0)("\n");
 
@@ -1068,5 +967,5 @@
   {
     PRINT(0)("-----------------------------------------\n");
-    PRINT(0)("Name: %s; References: %d; Type: %s ", (*resource)->name, (*resource)->count, ResourceManager::ResourceTypeToChar((*resource)->type));
+    PRINT(0)("Name: %s; References: %d; Type: %s ", (*resource)->name.c_str(), (*resource)->count, ResourceManager::ResourceTypeToChar((*resource)->type));
 
     PRINT(0)("gets deleted at ");
Index: trunk/src/lib/util/loading/resource_manager.h
===================================================================
--- trunk/src/lib/util/loading/resource_manager.h	(revision 7201)
+++ trunk/src/lib/util/loading/resource_manager.h	(revision 7221)
@@ -71,5 +71,5 @@
   unsigned int      count;             //!< How many times this Resource has been loaded.
 
-  char*             name;              //!< Name of the Resource.
+  std::string       name;              //!< Name of the Resource.
   ResourceType      type;              //!< ResourceType of this Resource.
   ResourcePriority  prio;              //!< The Priority of this resource. (This will only be increased)
@@ -96,20 +96,20 @@
   inline static ResourceManager* getInstance() { if (!singletonRef) singletonRef = new ResourceManager();  return singletonRef; };
 
-  bool setDataDir(const char* dataDir);
+  bool setDataDir(const std::string& dataDir);
   /** @returns the Name of the data directory */
-  inline const char* getDataDir() const { return this->dataDir; };
+  inline const std::string& getDataDir() const { return this->dataDir; };
 
 
-  bool tryDataDir(const char* dataDir);
-  bool verifyDataDir(const char* fileInside);
-  bool addImageDir(const char* imageDir);
+  bool tryDataDir(const std::string& dataDir);
+  bool verifyDataDir(const std::string& fileInside);
+  bool addImageDir(const std::string& imageDir);
 
-  bool cache(const char* fileName, ResourceType type, ResourcePriority prio = RP_NO,
+  bool cache(const std::string& fileName, ResourceType type, ResourcePriority prio = RP_NO,
              const MultiType& param0 = MultiType(), const MultiType& param1 = MultiType(), const MultiType& param2 = MultiType());
   BaseObject* copy(BaseObject* resourcePointer);
 
-  BaseObject* load(const char* fileName, ResourcePriority prio = RP_NO,
+  BaseObject* load(const std::string& fileName, ResourcePriority prio = RP_NO,
                    const MultiType& param0 = MultiType(), const MultiType& param1 = MultiType(), const MultiType& param2 = MultiType());
-  BaseObject* load(const char* fileName, ResourceType type, ResourcePriority prio = RP_NO,
+  BaseObject* load(const std::string& fileName, ResourceType type, ResourcePriority prio = RP_NO,
                    const MultiType& param0 = MultiType(), const MultiType& param1 = MultiType(), const MultiType& param2 = MultiType());
   bool unload(BaseObject* pointer, ResourcePriority prio = RP_NO);
@@ -117,10 +117,10 @@
   bool unloadAllByPriority(ResourcePriority prio);
 
-  Resource* locateResourceByInfo(const char* fileName, ResourceType type,
+  Resource* locateResourceByInfo(const std::string& fileName, ResourceType type,
                                  const MultiType& param0 = MultiType(), const MultiType& param1 = MultiType(), const MultiType& param2 = MultiType()) const;
   Resource* locateResourceByPointer(const void* pointer) const;
 
-  char* toResourcableString(unsigned int i);
-  bool fromResourceableString(const char* resourceableString);
+  std::string toResourcableString(unsigned int i);
+  bool fromResourceableString(const std::string& resourceableString);
   /** @returns the Count of Resources the ResourceManager handles */
   unsigned int resourceCount() const { return this->resourceList.size(); }
@@ -130,13 +130,13 @@
 
   // utility functions for handling files in and around the data-directory
-  static bool isDir(const char* directory);
-  static bool isFile(const char* fileName);
-  static bool touchFile(const char* fileName);
-  static bool deleteFile(const char* fileName);
-  static char* homeDirCheck(const char* fileName);
-  static char* getFullName(const char* fileName);
-  static bool isInDataDir(const char* fileName);
-  static char* getAbsDir(const char* fileName);
-  static const char* cwd();
+  static bool isDir(const std::string& directory);
+  static bool isFile(const std::string& fileName);
+  static bool touchFile(const std::string& fileName);
+  static bool deleteFile(const std::string& fileName);
+  static std::string homeDirCheck(const std::string& fileName);
+  static std::string getFullName(const std::string& fileName);
+  static bool isInDataDir(const std::string& fileName);
+  static std::string getAbsDir(const std::string& fileName);
+  static const std::string& cwd();
 
   static const char* ResourceTypeToChar(ResourceType type);
@@ -145,17 +145,17 @@
  private:
   ResourceManager();
-  Resource* loadResource(const char* fileName, ResourceType type, ResourcePriority prio,
+  Resource* loadResource(const std::string& fileName, ResourceType type, ResourcePriority prio,
                          const MultiType& param0, const MultiType& param1, const MultiType& param2);
 
  private:
-  static ResourceManager*  singletonRef;       //!< singleton Reference
+  static ResourceManager*    singletonRef;       //!< singleton Reference
 
-  char*                    _cwd;               //!< The currend Working directory.
-  char*                    dataDir;            //!< The Data Directory, where all relevant Data is stored.
-  std::vector<char*>       imageDirs;          //!< A list of directories in which images are stored.
+  std::string                _cwd;               //!< The currend Working directory.
+  std::string                dataDir;            //!< The Data Directory, where all relevant Data is stored.
+  std::vector<std::string>   imageDirs;          //!< A list of directories in which images are stored.
 
-  std::vector<Resource*>   resourceList;       //!< The List of Resources, that has already been loaded.
+  std::vector<Resource*>     resourceList;       //!< The List of Resources, that has already been loaded.
 
-  static const char*       resourceNames[RESOURCE_TYPE_SIZE];
+  static const char*         resourceNames[RESOURCE_TYPE_SIZE];
 };
 
Index: trunk/src/lib/util/multi_type.cc
===================================================================
--- trunk/src/lib/util/multi_type.cc	(revision 7201)
+++ trunk/src/lib/util/multi_type.cc	(revision 7221)
@@ -39,4 +39,7 @@
   switch (this->type)
   {
+    default:
+      this->value.Float = 0.0f;
+      break;
     case MT_BOOL:
       this->value.Bool = false;
@@ -90,13 +93,4 @@
 {
   this->setChar(value);
-}
-
-/**
- * @brief creates a multiType out of a C-String
- * @param value the Value of this MulitType
- */
-MultiType::MultiType(const char* value)
-{
-  this->setString(value);
 }
 
@@ -482,15 +476,15 @@
  * @returns: the Type as MT_Type
  */
-MT_Type MultiType::StringToMultiType(const char* type)
-{
-  if (!strncmp(type, "bool", 4))
+MT_Type MultiType::StringToMultiType(const std::string& type)
+{
+  if (type == "bool")
     return MT_BOOL;
-  if (!strncmp(type, "int", 3))
+  if (type == "int")
     return MT_INT;
-  if (!strncmp(type, "float", 5))
+  if (type, "float")
     return MT_FLOAT;
-  if (!strncmp(type, "char", 4))
+  if (type == "char")
     return MT_CHAR;
-  if (!strncmp(type, "string", 6))
+  if (type == "string")
     return MT_STRING;
 
Index: trunk/src/lib/util/multi_type.h
===================================================================
--- trunk/src/lib/util/multi_type.h	(revision 7201)
+++ trunk/src/lib/util/multi_type.h	(revision 7221)
@@ -39,5 +39,4 @@
     MultiType(double value);
     MultiType(char value);
-    MultiType(const char* value);
     MultiType(const std::string& value);
     MultiType(const MultiType& multiType);
@@ -95,5 +94,5 @@
 
     static const char* MultiTypeToString(MT_Type type);
-    static MT_Type StringToMultiType(const char* type);
+    static MT_Type StringToMultiType(const std::string& type);
 
   private:
@@ -106,8 +105,6 @@
 //      std::string*      String;
     }                   value;
-
+    std::string         storedString;
     MT_Type             type;
-
-    std::string         storedString;
 };
 
Index: trunk/src/lib/util/substring.cc
===================================================================
--- trunk/src/lib/util/substring.cc	(revision 7201)
+++ trunk/src/lib/util/substring.cc	(revision 7221)
@@ -14,4 +14,14 @@
 
    2005-06-10: some naming conventions
+
+//
+//  splitLine
+//  STL string tokenizer
+//
+//  Created by Clemens Wacha.
+//  Version 1.0
+//  Copyright (c) 2005 Clemens Wacha. All rights reserved.
+//
+
 */
 
@@ -24,64 +34,15 @@
 #include "substring.h"
 
-#include "debug.h"
 #include <string.h>
-#include <assert.h>
-
-SubString::SubString( const char* string, char splitter)
-{
-  this->splittersCount = 0;
-  if (string == NULL)
-  {
-    this->strings = NULL;
-    this->offsets = NULL;
-    return;
-  }
-
-  for( int i = 0; i < strlen(string); i++)
-    if( string[i] == splitter)
-      this->splittersCount++;
-
-  this->splittersCount += 1;
-
-  this->strings = new char*[this->splittersCount];
-  this->offsets = new unsigned int[this->splittersCount];
-  assert (this->strings != NULL && this->offsets != NULL);
-
-  int i = 0;
-  int l = 0;
-
-  if( this->splittersCount > 1)
-  {
-    const char* offset = string;
-    const char* end = strchr( string, splitter);
-    while( end != NULL)
-    {
-      assert( i < this->splittersCount);
-      l = end - offset;
-      this->strings[i] = new char[l + 1];
-      assert( strings[i] != NULL);
-      strncpy( strings[i], offset, l);
-      strings[i][l] = '\0';
-      this->offsets[i] = offset - string;
-      i++;
-      end++;
-      offset = end;
-      end = strchr( offset, splitter);
-    }
-
-    l = strlen( offset);
-    strings[i] = new char[l + 1];
-    strncpy( strings[i], offset, l);
-    strings[i][l] = '\0';
-    this->offsets[i] = offset - string;
-  }
-  else
-  {
-    this->strings[0] = new char[strlen(string)+1];
-    strcpy(this->strings[0], string);
-    this->offsets[0] = 0;
-  }
-}
-
+#include <cassert>
+
+SubString::SubString(const std::string& string, char splitter)
+{
+  char split[2];
+  split[0] = splitter;
+  split[1] = '\0';
+  SubString::splitLine(this->strings, this->offsets,
+                       string, split);
+}
 
 /**
@@ -91,137 +52,202 @@
  *
  */
-SubString::SubString(const char* string, bool whiteSpaces)
-{
-  this->splittersCount = 0;
-  if (string == NULL || whiteSpaces == false)
+SubString::SubString(const std::string& string, bool whiteSpaces)
+{
+  SubString::splitLine(this->strings, this->offsets,
+                      string);
+}
+SubString::SubString(const std::string& string, const std::string& splitters, char escapeChar,char safemode_char, char comment_char)
+{
+  SubString::splitLine(this->strings, this->offsets,
+                       string, splitters, escapeChar, safemode_char);
+}
+
+/**
+ * An empty String
+ */
+const std::string SubString::emptyString = "";
+
+
+
+unsigned int SubString::split(const std::string& string, char splitter)
+{
+  this->offsets.clear();
+  this->strings.clear();
+  char split[2];
+  split[0] = splitter;
+  split[1] = '\0';
+  SubString::splitLine(this->strings, this->offsets, string, split);
+  return strings.size();
+}
+
+
+/**
+ * Splits a String into a Substring removing all whiteSpaces
+ * @param string the String to Split
+ * @param whiteSpaces MUST BE __TRUE__
+ *
+ */
+unsigned int SubString::split(const std::string& string, bool whiteSpaces)
+{
+  this->offsets.clear();
+  this->strings.clear();
+  SubString::splitLine(this->strings, this->offsets, string);
+  return strings.size();
+}
+
+unsigned int SubString::split(const std::string& string, const std::string& splitters, char escapeChar,char safemode_char, char comment_char)
+{
+  this->offsets.clear();
+  this->strings.clear();
+  SubString::splitLine(this->strings, this->offsets,
+                       string, splitters, escapeChar, safemode_char);
+  return strings.size();
+}
+
+
+/**
+ * @brief splits line into tokens and stores them in ret.
+ * @param ret the Array, where the Splitted strings will be stored in
+ * @param offsets an Array of Offsets, here the distance from the inputstring
+ * to the beginning of the current token is stored
+ * @param line the inputLine to split
+ * @param delimiters a String of Delimiters (here the input will be splitted)
+ * @param escape_char: Escape carater (escapes splitters)
+ * @param safemode_char: the beginning of the safemode is marked with this
+ * @param comment_char: the beginning of a comment is marked with this: (until the end of a Line)
+ * @param start_state: the Initial state on how to parse the String.
+ * @returns SPLIT_LINE_STATE the parser was in when returning
+ *
+ * Supports delimiters, escape characters,
+ * ignores special  characters between safemode_char and between comment_char and linend '\n'.
+ *
+ */
+SPLIT_LINE_STATE SubString::splitLine(std::vector<std::string>& ret, std::vector<unsigned int>& offsets,
+                                      const std::string& line, const std::string& delimiters,
+                                      char escape_char, char safemode_char, char comment_char,
+                                      SPLIT_LINE_STATE start_state)
+{
+  SPLIT_LINE_STATE state = start_state;
+  unsigned int i = 0;
+  std::string token;
+
+  if(start_state != SL_NORMAL && ret.size() > 0)
   {
-    this->strings = NULL;
-    this->offsets = NULL;
-    return;
+    token = ret[ret.size()-1];
+    ret.pop_back();
   }
 
-  // chop the input to the beginning of something usefull
-  if (strlen(string) > 0)
-    string = string + strspn(string, " \t\n");
-
-  // count the Splitters
-  bool lastWasWhiteSpace = false;
-  for(unsigned int i = 0; i < strlen(string); i++)
-    if( string[i] == ' ' || string[i] == '\t' || string[i] == '\n' )
-      lastWasWhiteSpace = true;
-    else
+  while(i < line.size())
+  {
+    switch(state)
     {
-      if (lastWasWhiteSpace)
-        this->splittersCount ++;
-      lastWasWhiteSpace = false;
+    case SL_NORMAL:
+      if(line[i] == escape_char)
+      {
+        state = SL_ESCAPE;
+      }
+      else if(line[i] == safemode_char)
+      {
+        state = SL_SAFEMODE;
+      }
+      else if(line[i] == comment_char)
+      {
+        /// FINISH
+        if(token.size() > 0)
+        {
+          ret.push_back(token);
+          offsets.push_back(i);
+          token.clear();
+        }
+        token += line[i];       // EAT
+        state = SL_COMMENT;
+      }
+      else if(delimiters.find(line[i]) != std::string::npos)
+      {
+        // line[i] is a delimiter
+        /// FINISH
+        if(token.size() > 0)
+        {
+          ret.push_back(token);
+          offsets.push_back(i);
+          token.clear();
+        }
+      }
+      else
+      {
+        token += line[i];       // EAT
+      }
+      break;
+    case SL_ESCAPE:
+      if(line[i] == 'n') token += '\n';
+      else if(line[i] == 't') token += '\t';
+      else if(line[i] == 'v') token += '\v';
+      else if(line[i] == 'b') token += '\b';
+      else if(line[i] == 'r') token += '\r';
+      else if(line[i] == 'f') token += '\f';
+      else if(line[i] == 'a') token += '\a';
+      else if(line[i] == '?') token += '\?';
+      else token += line[i];  // EAT
+      state = SL_NORMAL;
+      break;
+    case SL_SAFEMODE:
+      if(line[i] == safemode_char)
+      {
+        state = SL_NORMAL;
+      }
+      else if(line[i] == escape_char)
+      {
+        state = SL_SAFEESCAPE;
+      }
+      else
+      {
+        token += line[i];       // EAT
+      }
+      break;
+    case SL_SAFEESCAPE:
+      if(line[i] == 'n') token += '\n';
+      else if(line[i] == 't') token += '\t';
+      else if(line[i] == 'v') token += '\v';
+      else if(line[i] == 'b') token += '\b';
+      else if(line[i] == 'r') token += '\r';
+      else if(line[i] == 'f') token += '\f';
+      else if(line[i] == 'a') token += '\a';
+      else if(line[i] == '?') token += '\?';
+      else token += line[i];  // EAT
+      state = SL_SAFEMODE;
+      break;
+    case SL_COMMENT:
+      if(line[i] == '\n')
+      {
+        /// FINISH
+        if(token.size() > 0)
+        {
+          ret.push_back(token);
+          offsets.push_back(i);
+          token.clear();
+        }
+        state = SL_NORMAL;
+      }
+      else
+      {
+        token += line[i];       // EAT
+      }
+      break;
+    default:
+      // nothing
+      break;
     }
-  this->splittersCount += 1;
-
-  // allocate memory
-  this->strings = new char*[this->splittersCount];
-  this->offsets = new unsigned int[this->splittersCount];
-  assert (this->strings != NULL && this->offsets != NULL);
-
-
-  // split the String into substrings
-  int l = 0;
-  unsigned int i = 0;
-  if( this->splittersCount > 1)
+    i++;
+  }
+
+  /// FINISH
+  if(token.size() > 0)
   {
-    const char* offset = string;
-    const char* end = offset + strcspn(offset, " \t\n");
-    for (i = 0; i < this->splittersCount; i++)
-    {
-      assert( i < this->splittersCount);
-      l = end - offset;
-      this->strings[i] = new char[l + 1];
-      assert( strings[i] != NULL);
-      strncpy( strings[i], offset, l);
-      strings[i][l] = '\0';
-      this->offsets[i] = offset - string;
-      end += strspn(end, " \t\n");
-      offset = end;
-      end = offset + strcspn(offset, " \t\n");
-    }
+    ret.push_back(token);
+    offsets.push_back(i);
+    token.clear();
   }
-  else
-  {
-    unsigned int length = strcspn(string, " \t\n");
-    this->strings[0] = new char[length+1];
-    strncpy(this->strings[0], string, length);
-    this->strings[0][length] = '\0';
-    offsets[0] = 0;
-  }
-}
-
-SubString::SubString(const char* string, const char* splitters, char escapeChar)
-{
-  this->splittersCount = 0;
-  if (string == NULL || splitters == NULL)
-  {
-    this->strings = NULL;
-    this->offsets = NULL;
-    return;
-  }
-
-  // chop the input to the beginning of something usefull
-  if (strlen(string) > 0)
-    string = string + strspn(string, splitters);
-
-  // count the Splitters
-  bool lastWasSplitter = false;
-  for(unsigned int i = 0; i < strlen(string); i++)
-  {
-
-    if( strchr(splitters, string[i] ))
-      lastWasSplitter = true;
-    else
-    {
-      if (lastWasSplitter)
-      {
-        this->splittersCount ++;
-        lastWasSplitter = false;
-      }
-    }
-  }
-  this->splittersCount += 1;
-
-  // allocate memory
-  this->strings = new char*[this->splittersCount];
-  this->offsets = new unsigned int[this->splittersCount];
-  assert (this->strings != NULL && this->offsets != NULL);
-
-
-  // split the String into substrings
-  int l = 0;
-  unsigned int i = 0;
-  if( this->splittersCount > 1)
-  {
-    const char* offset = string;
-    const char* end = offset + strcspn(offset, splitters);
-    for (i = 0; i < this->splittersCount; i++)
-    {
-      assert( i < this->splittersCount);
-      l = end - offset;
-      this->strings[i] = new char[l + 1];
-      assert( strings[i] != NULL);
-      strncpy( strings[i], offset, l);
-      strings[i][l] = '\0';
-      this->offsets[i] = offset - string;
-      end += strspn(end, splitters);
-      offset = end;
-      end = offset + strcspn(offset, splitters);
-    }
-  }
-  else
-  {
-    unsigned int length = strcspn(string, splitters);
-    this->strings[0] = new char[length+1];
-    strncpy(this->strings[0], string, length);
-    this->strings[0][length] = '\0';
-    offsets[0] = 0;
-  }
-}
-
+  return(state);
+}
 
 /**
@@ -229,26 +255,5 @@
 */
 SubString::~SubString()
-{
-  if (this->strings)
-  {
-    for(unsigned int i = 0; i < this->splittersCount; i++)
-      delete[] this->strings[i];
-    delete[] this->strings;
-  }
-  delete[] this->offsets;
-}
-
-/**
- *  get a particular substring
- * @param i the ID of the substring to return
- * @returns the designated substring or NULL if an invalid ID was given
-*/
-const char* SubString::getString(unsigned int i)
-{
-  if( i < this->splittersCount && i >= 0)
-    return this->strings[i];
-  else
-    return NULL;
-}
+{ }
 
 /**
@@ -259,5 +264,5 @@
 unsigned int SubString::getOffset(unsigned int i)
 {
-  if( i < this->splittersCount && i >= 0)
+  if( i < this->offsets.size() && i >= 0)
     return this->offsets[i];
   else
@@ -270,8 +275,7 @@
 void SubString::debug() const
 {
-  PRINT(0)("Substring-information::count=%d ::", this->splittersCount);
-  if (this->strings != NULL)
-    for (unsigned int i = 0; i < this->splittersCount; i++)
-     PRINT(0)("s%d='%s'::", i, this->strings[i]);
-  PRINT(0)("\n");
-}
+  printf("Substring-information::count=%d ::", this->strings.size());
+  for (unsigned int i = 0; i < this->strings.size(); i++)
+    printf("s%d='%s'::", i, this->strings[i].c_str());
+  printf("\n");
+}
Index: trunk/src/lib/util/substring.h
===================================================================
--- trunk/src/lib/util/substring.h	(revision 7201)
+++ trunk/src/lib/util/substring.h	(revision 7221)
@@ -7,25 +7,47 @@
 #define _SUBSTRING_H
 
+#include <vector>
+#include <string>
+
+  typedef enum {
+    SL_NORMAL,
+    SL_ESCAPE,
+    SL_SAFEMODE,
+    SL_SAFEESCAPE,
+    SL_COMMENT,
+  } SPLIT_LINE_STATE;
+
 //! A class that can load one string and split it in multipe ones
 class SubString
 {
  public:
-  SubString(const char* string, char splitter = ',');
-  SubString(const char* string, bool whiteSpaces);
-  SubString(const char* string, const char* splitters, char escapeChar ='\\');
+  SubString(const std::string& string = "", char splitter = ',');
+  SubString(const std::string& string, bool whiteSpaces);
+  SubString(const std::string& string, const std::string& splitters, char escapeChar ='\\', char safemode_char = '"', char comment_char = '\0');
   ~SubString();
 
-  const char* operator[](unsigned int i) { return this->getString(i); };
+  unsigned int split(const std::string& string = "", char splitter = ',');
+  unsigned int split(const std::string& string, bool whiteSpaces);
+  unsigned int split(const std::string& string, const std::string& splitters, char escapeChar ='\\', char safemode_char = '"', char comment_char = '\0');
 
-  inline unsigned int getCount() { return this->splittersCount; };
-  const char* getString(unsigned int i);
+
+  const std::string& operator[](unsigned int i) { return this->getString(i); };
+
+  inline unsigned int getCount() { return this->strings.size(); };
+  const std::string& getString(unsigned int i) { return (i < this->strings.size()) ? this->strings[i] : emptyString; };
   unsigned int getOffset(unsigned int i);
+
+  static SPLIT_LINE_STATE splitLine(std::vector<std::string>& ret,std::vector<unsigned int>& offsets,
+                                    const std::string& line, const std::string& delimiters = " \t\r\n",
+                                    char escape_char = '\\', char safemode_char = '"', char comment_char = '\0',
+                                    SPLIT_LINE_STATE start_state = SL_NORMAL);
 
   void debug() const;
 
  private:
-  char**          strings;                      //!< strings produced from a single string splitted in multiple strings
-  unsigned int*   offsets;                      //!< offsets of the beginning of the input-string to the beginning of each substring.
-  unsigned int    splittersCount;               //!< how many splitted parts
+   std::vector<std::string>  strings;                      //!< strings produced from a single string splitted in multiple strings
+   std::vector<unsigned int> offsets;                      //!< offsets of the beginning of the input-string to the beginning of each substring.
+
+   static const std::string emptyString;
 };
 
