Changeset 7221 for trunk/src – Orxonox

trunk/src/lib/Makefile.am

-                      r7193
+                      r7221
 SUBDIRS = \
+        . \
         math \
         graphics \
 …
         parser \
         shell \
+        gui \
+        .
+        gui

trunk/src/lib/coord/p_node.cc

-                      r7193
+                      r7221
  * @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));
 …
  * @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));
 …
   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());
+}
 …
  * @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));
 …
  * @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));
+}
 …
            this->getAbsDirV().y,
            this->getAbsDirV().z,
            this->parentingModeToChar(parentMode),
+           this->parentingModeToString(parentMode),
            childNodeCount);
   if (depth >= 2 || depth == 0)
 …
  * @return the converted string
  */
 const char* PNode::parentingModeToChar(int parentingMode)
+const char* PNode::parentingModeToString(int parentingMode)
+{
   if (parentingMode == PNODE_LOCAL_ROTATE)
 …
  * @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);
+}

trunk/src/lib/coord/p_node.h

-                      r7076
+                      r7221
   // PARENTING //
   void addChild (PNode* child);
   void addChild (const char* childName);
+  void addChild (const std::string& childName);
   void removeChild (PNode* child);
   void removeNode();
 …
   /** @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; };
 …
   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; };
 …
   // 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(); };

trunk/src/lib/event/key_mapper.cc

-                      r6998
+                      r7221
  * @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);
 …
   iniParser->firstVar();
   while(iniParser->getCurrentName())
+  while(iniParser->getCurrentName() != "")
+  {
     PRINTF(3)("Keys: Parsing %s, %s now.\n", iniParser->getCurrentName(), iniParser->getCurrentValue());
 …
   iniParser->firstVar();
   while(iniParser->getCurrentName())
+  while(iniParser->getCurrentName() != "")
+  {
     PRINTF(3)("MISC: Parsing %s, %s now.\n", iniParser->getCurrentName(), iniParser->getCurrentValue());
 …
  * @param the name of the button
 */
 int* KeyMapper::nameToIndex (const char* name)
+int* KeyMapper::nameToIndex (const std::string& name)
+{
   coord[0] = -1;
 …
  * @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)

trunk/src/lib/event/key_mapper.h

-                      r6998
+                      r7221
   virtual ~KeyMapper();
   void loadKeyBindings(const char* fileName = NULL);
+  void loadKeyBindings(const std::string& fileName = "" );
   void loadKeyBindings(IniParser* iniParser);
 …
  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:

trunk/src/lib/event/key_names.cc

-                      r5476
+                      r7221
 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;
+}
 …
+}
 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";

trunk/src/lib/event/key_names.h

-                      r5474
+                      r7221
 /*!
  * @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);

trunk/src/lib/graphics/effects/fog_effect.cc

-                      r7193
+                      r7221
  * @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

trunk/src/lib/graphics/effects/fog_effect.h

-                      r7107
+                      r7221
     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; }
 …
   private:
     GLint charToFogMode(const char* mode);
+    GLint stringToFogMode(const std::string& mode);

trunk/src/lib/graphics/effects/lense_flare.cc

-                      r7193
+                      r7221
  * @param mode the mode character
  */
 GLint LenseFlare::charToFogMode(const char* mode)
+GLint LenseFlare::stringToFogMode(const std::string& mode)
 {}
 …
  *  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)
 …
   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
 …
     bb->setVisibility(true);
+  }
   PRINTF(0)("Finished adding\n", textureName);
+  PRINTF(4)("Finished adding\n");
+}

trunk/src/lib/graphics/effects/lense_flare.h

-                      r7015
+                      r7221
     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) ;

trunk/src/lib/graphics/graphics_engine.cc

-                      r7193
+                      r7221
   this->screen = NULL;
-  // Hardware
-  this->hwRenderer = NULL;
-  this->hwVendor = NULL;
-  this->hwVersion = NULL;
-  this->hwExtensions = NULL;
   // initialize the Modules
   TextEngine::getInstance();
 …
   // delete what has to be deleted here
   this->displayFPS( false );
-  delete[] this->hwRenderer;
-  delete[] this->hwVendor;
-  delete[] this->hwVersion;
-  delete this->hwExtensions;
   //TextEngine
 …
+{
   // 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);
 …
  * @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());
+}
 …
   //  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());
 …
  * @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;
+}
 …
 void GraphicsEngine::draw() const
+{
 //  LightManager::getInstance()->draw();
+  //  LightManager::getInstance()->draw();
   GraphicsEngine::storeMatrices();
 …
   switch (event.type)
+  {
       case EV_VIDEO_RESIZE:
       this->resolutionChanged(event.resize);
       break;
+  }
+}
+  case EV_VIDEO_RESIZE:
+    this->resolutionChanged(event.resize);
+    break;
+  }
+}

trunk/src/lib/graphics/graphics_engine.h

-                      r6990
+                      r7221
 #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;
 …
     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);
 …
     void listModes();
     bool hwSupportsEXT(const char* extension);
+    bool hwSupportsEXT(const std::string& extension);
     /** @brief swaps the GL_BUFFERS */
 …
     // 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

trunk/src/lib/graphics/importer/height_map.cc

-                      r7193
+                      r7221
+}
+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);
 …
+                }
      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());
 …
+}
+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);
 …
+                }
      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());
 …
   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);

trunk/src/lib/graphics/importer/height_map.h

-                      r6981
+                      r7221
 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);
 …
 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();

trunk/src/lib/graphics/importer/material.cc

-                      r7193
+                      r7221
  * @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");
 …
  * @param pathName The Path to add.
 */
 void Material::addTexturePath(const char* pathName)
+void Material::addTexturePath(const std::string& pathName)
+{
   ResourceManager::getInstance()->addImageDir(pathName);
 …
  * @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);
 …
   //! @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
 …
    @todo implement this
 */
 void Material::setAmbientMap(const char* aMap, GLenum target)
+void Material::setAmbientMap(const std::string& aMap, GLenum target)
+{
   SDL_Surface* ambientMap;
 …
    @todo implement this
 */
 void Material::setSpecularMap(const char* sMap, GLenum target)
+void Material::setSpecularMap(const std::string& sMap, GLenum target)
+{
   SDL_Surface* specularMap;
 …
    @todo implemet this
 */
 void Material::setBump(const char* bump)
+{
+}
+void Material::setBump(const std::string& bump)
+{
+}

trunk/src/lib/graphics/importer/material.h

-                      r7057
+                      r7221
+{
  public:
   Material (const char* mtlName = NULL);
+  Material (const std::string& mtlName = "");
   virtual ~Material ();
 …
  // 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:

trunk/src/lib/graphics/importer/md2Model.cc

-                      r7193
+                      r7221
   \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");
 …
+{
   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);
 …
   \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;
 …
   this->scaleFactor = scale;
   this->fileName = NULL;
   this->skinFileName = NULL;
+  this->fileName = "";
+  this->skinFileName = "";
   this->loadModel(modelFileName);
   this->loadSkin(skinFileName);
 …
 MD2Data::~MD2Data()
+{
-  delete [] this->fileName;
-  delete [] this->skinFileName;
   delete this->header;
 …
   \return true if success
 */
 bool MD2Data::loadModel(const char* fileName)
+bool MD2Data::loadModel(const std::string& fileName)
+{
   FILE *pFile;                            //file stream
 …
   //! @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))
+    {
 …
   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;
 …
   \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");

trunk/src/lib/graphics/importer/md2Model.h

-                      r7123
+                      r7221
+{
  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:
 …
   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
 …
 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();

trunk/src/lib/graphics/importer/media_container.cc

-                      r7193
+                      r7221
  * Default constructor
  */
 MediaContainer::MediaContainer(const char* filename)
+MediaContainer::MediaContainer(const std::string& filename)
+{
   // set the class id for the base object
 …
   fps = 0;
   mediaLoaded = false;
   this->loadMedia(filename);
+  if (!filename.empty())
+    this->loadMedia(filename);
+}
 …
+}
 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;
+  }
 …
   // 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;
+  }
 …
   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;
+  }
 …
   // 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;
+  }
 …
       // Free the packet that was allocated by av_read_frame
       av_free_packet(&packet);
       // Did we get a video frame?
       if(frame_finished)
 …
           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);
 …
+  }
   else
     return NULL;
+}
+    return 0;
+}

trunk/src/lib/graphics/importer/media_container.h

-                      r6981
+                      r7221
 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();

trunk/src/lib/graphics/importer/movie_player.cc

-                      r7193
+                      r7221
 MoviePlayer::MoviePlayer(const char* filename)
+MoviePlayer::MoviePlayer(const std::string& filename)
+{
   // set the class id for the base object
 …
   mediaLoaded = false;
   this->loadMovie(filename);
+  if (!filename.empty())
+    this->loadMovie(filename);
+}
 …
 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;
+  }
 …
   // 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;
+  }
 …
   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;
+  }
 …
   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;
+  }

trunk/src/lib/graphics/importer/movie_player.h

-                      r6981
+                      r7221
 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);

trunk/src/lib/graphics/importer/objModel.cc

-                      r6162
+                      r7221
  * @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");
 …
 */
 OBJModel::~OBJModel()
+{
+  PRINTF(4)("Deleting the obj-names\n");
+  if (this->objPath)
+    delete []this->objPath;
+}
+{ }
 /**
 …
    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
 …
+    {
       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);
 …
    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;
+    }
 …
  * 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;
+    }
 …
+    }
   fclose(stream);
-  delete []fileName;
   return true;
+}

trunk/src/lib/graphics/importer/objModel.h

-                      r6022
+                      r7221
+{
  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.
 };

trunk/src/lib/graphics/importer/static_model.cc

-                      r6423
+                      r7221
 #include <stdarg.h>
-#include "vector.h"
 using namespace std;
 …
+{
   PRINTF(4)("Adding new Group\n");
   this->name = NULL;
+  this->name = "";
   this->faceMode = -1;
   this->faceCount = 0;
 …
   if (this->listNumber != 0)
     glDeleteLists(this->listNumber, 1);
-  if (this->name != NULL)
-    delete[] this->name;
   if (this->next !=NULL)
 …
  * assigns it a Name and a Type
  */
 StaticModel::StaticModel(const char* modelName)
+StaticModel::StaticModel(const std::string& modelName)
+{
   this->setClassID(CL_STATIC_MODEL, "StaticModel");
 …
   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;
+  }
+}
 …
+{
   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;
 …
  * 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;
+}
 …
  * @returns the added material
  */
 Material* StaticModel::addMaterial(const char* materialName)
+Material* StaticModel::addMaterial(const std::string& materialName)
+{
   ModelMaterial* modMat = new ModelMaterial;
 …
  * @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;
 …
  * 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;
+}
 …
  *  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);
 …
  * 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);
 …
  * !! 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);
 …
  * 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;
 …
   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;
 …
   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);
 …
  * @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)
 …
   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;
+}
 …
   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;
+  }
+}
 …
   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 */
 …
       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;
 …
   while( this->currentGroup != NULL)
+  {
       // Putting Faces to GL
+    // Putting Faces to GL
     tmpFace = this->currentGroup->firstFace;
     while( tmpFace != NULL)
 …
   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);
+  }
+}

trunk/src/lib/graphics/importer/static_model.h

-                      r6423
+                      r7221
 #include <vector>
 #include <list>
-// FORWARD DECLARATION //
-template<class T> class tArray;
 // definition of different modes for setting up Faces
 …
   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.
 …
+{
  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);
 …
   void cubeModel();
   Material* findMaterialByName(const char* materialName);
+  Material* findMaterialByName(const std::string& materialName);
  protected:

trunk/src/lib/graphics/importer/texture.cc

-                      r6871
+                      r7221
  *  Constructor for a Texture
 */
 Texture::Texture(const char* imageName, GLenum target)
+Texture::Texture(const std::string& imageName, GLenum target)
+{
   this->setClassID(CL_TEXTURE, "Texture");
 …
   this->priority = 0.5;
   if (imageName != NULL)
+  if (!imageName.empty())
+  {
     this->setName(imageName);
 …
  * @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)
 …
       this->texture = 0;
+    }
     if (imageName != NULL)
+    if (!imageName.empty())
+    {
       SDL_Surface* tmpSurf;
 …
         glDeleteTextures(1, &this->texture);
       // load the new Image to memory
       tmpSurf = IMG_Load(imageName);
+      tmpSurf = IMG_Load(imageName.c_str());
       if(tmpSurf != NULL)
+      {

trunk/src/lib/graphics/importer/texture.h

-                      r6981
+                      r7221
+  {
     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();

trunk/src/lib/graphics/importer/texture_sequence.cc

-                      r6624
+                      r7221
  * @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;

trunk/src/lib/graphics/importer/texture_sequence.h

r7195	r7221
23	23	bool loadImageSeries(unsigned int count, ...);
24	24	bool loadImageSeries(unsigned int count, va_list textureNames);
25		bool addFrame(const char* image);
	25	bool addFrame(const std::string& image);
26	26	bool addFrame(SDL_Surface* surface);
27	27	bool addFrame(GLuint texture);

trunk/src/lib/graphics/render2D/billboard.cc

-                      r7193
+                      r7221
 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");
 …
  * @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);

trunk/src/lib/graphics/render2D/billboard.h

r6815	r7221
30	30
31	31	void setSize(float sizeX, float sizeY);
32		void setTexture(const char* textureFile);
	32	void setTexture(const std::string& textureFile);
33	33	void attachTo(PNode* pnode);
34	34

trunk/src/lib/graphics/render2D/element_2d.cc

-                      r7199
+                      r7221
  * @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);
+}
 …
 /**
  * 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));
 …
  * @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));
 …
  * @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));
 …
  * @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));
 …
   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());
+}
 …
  * @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));
 …
  * @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));
+}
 …
             this->relCoordinate.y,
             this->getAbsDir2D(),
             Element2D::parentingModeToChar2D(parentMode),
+            Element2D::parentingModeToString2D(parentMode),
             Element2D::layer2DToChar(this->layer));
 …
  * @return the converted string
  */
 const char* Element2D::parentingModeToChar2D(int parentingMode)
+const char* Element2D::parentingModeToString2D(int parentingMode)
+{
   if (parentingMode == E2D_PARENT_LOCAL_ROTATE)
 …
  * @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);
+}
 …
  * @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

trunk/src/lib/graphics/render2D/element_2d.h

-                      r7052
+                      r7221
     /** @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; };
 …
     /** @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; };
 …
     void addChild2D (Element2D* child);
     void addChild2D (const char* childName);
+    void addChild2D (const std::string& childName);
     void removeChild2D (Element2D* child);
     void remove2D();
 …
     /** @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; };
 …
     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; };
 …
     // 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:

trunk/src/lib/graphics/shader.cc

-                      r7193
+                      r7221
  * 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;
 …
        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);
 …
+}
 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);
 …
 bool Shader::loadShaderProgramm(SHADER_TYPE type, const char* fileName)
+bool Shader::loadShaderProgramm(SHADER_TYPE type, const std::string& fileName)
+{
   GLhandleARB shader = 0;
 …
   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);
 …
   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);
 …
+  {
     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.
 …
+}
 char* Shader::fileRead(const char* fileName)
+char* Shader::fileRead(const std::string& fileName)
+{
   FILE* fileHandle;
 …
   int count = 0;
   if (fileName == NULL)
+  if (fileName.empty())
     return NULL;
   fileHandle = fopen(fileName, "rt");
+  fileHandle = fopen(fileName.c_str(), "rt");
   if (fileHandle == NULL)
 …
 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;
+  }
 …
   if (type == SHADER_VERTEX && this->vertexShader != 0)
+  {
+    delete[] this->vertexShaderFile;
+    this->vertexShaderFile = NULL;
+    this->vertexShaderFile = "";
     glDetachObjectARB(this->shaderProgram, this->vertexShader);
     glDeleteObjectARB(this->vertexShader);
 …
   else if (type == SHADER_FRAGMENT && this->fragmentShader != 0)
+  {
+    delete[] this->fragmentShaderFile;
+    this->fragmentShaderFile = NULL;
+    this->fragmentShaderFile = "";
     glDetachObjectARB(this->shaderProgram, this->fragmentShader);
     glDeleteObjectARB(this->fragmentShader);

trunk/src/lib/graphics/shader.h

-                      r7195
+                      r7221
   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();
 …
  private:
    char*                  fragmentShaderFile;
    char*                  vertexShaderFile;
+   std::string            fragmentShaderFile;
+   std::string            vertexShaderFile;
    GLhandleARB            shaderProgram;
    GLhandleARB            vertexShader;

trunk/src/lib/graphics/text_engine/font.cc

-                      r6609
+                      r7221
  * @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();
 …
   this->setStyle("c");
   if (fontFile != NULL)
+  if (!fontFile.empty())
     this->loadFontFromTTF(fontFile);
+}
 …
  * @param imageFile the ImageFile to load the Font From.
  */
 Font::Font(const char* imageFile)
+Font::Font(const std::string& imageFile)
+{
   this->init();
 …
   //  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;
 …
+  }
   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());
+}
 …
   //! @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.
 …
  * @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.
 …
  *   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");
+}
 …
  * @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)
 …
   SDL_Rect tmpRect; // this represents a Rectangle for blitting.
   SDL_Surface* tmpSurf =  SDL_CreateRGBSurface(SDL_SWSURFACE,
                                                height*size, height*size,
 ,
+                          height*size, height*size,
+,
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN /* OpenGL RGBA masks */
 x000000FF,
 x0000FF00,
 x00FF0000,
 xFF000000
+x000000FF,
+x0000FF00,
+x00FF0000,
+xFF000000
 #else
 xFF000000,
 x00FF0000,
 x0000FF00,
 x000000FF
+xFF000000,
+x00FF0000,
+x0000FF00,
+x000000FF
 #endif
                                               );
 …
+    }
+  }
   SDL_SaveBMP(tmpSurf, fileName);
+  SDL_SaveBMP(tmpSurf, fileName.c_str());
   SDL_FreeSurface(tmpSurf);
+}
 …
   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();
 …
   SDL_Rect tmpRect; // this represents a Rectangle for blitting.
   SDL_Surface* tmpSurf =  SDL_CreateRGBSurface(SDL_SWSURFACE,
                                                rectSize, rectSize,
 ,
+                          rectSize, rectSize,
+,
 #if SDL_BYTEORDER == SDL_LIL_ENDIAN /* OpenGL RGBA masks */
 x000000FF,
 x0000FF00,
 x00FF0000,
 xFF000000
+x000000FF,
+x0000FF00,
+x00FF0000,
+xFF000000
 #else
 xFF000000,
 x00FF0000,
 x0000FF00,
 x000000FF
+xFF000000,
+x00FF0000,
+x0000FF00,
+x000000FF
 #endif
                                               );
 …
         break;
+      }
           // reading in the new Glyph
+      // reading in the new Glyph
       if (likely(this->fontTTF != NULL))
+      {
 …
   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);
+  }
 …
       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);
 …
           x = 0;
           y = y + maxLineHeight;
                   //maxLineHeight = 0;
+          //maxLineHeight = 0;
+        }
         if (y + maxLineHeight + 1 > size)
 …
   if(style==TTF_STYLE_NORMAL)
     PRINTF(0)(" normal");
+  else {
+  else
+  {
     if(style&TTF_STYLE_BOLD)
       PRINTF(0)(" bold");

trunk/src/lib/graphics/text_engine/font.h

-                      r6609
+                      r7221
+{
   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();
 …
   //  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 */
 …
     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();

trunk/src/lib/graphics/text_engine/text.cc

-                      r7193
+                      r7221
  * @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);
 …
   if (this->font != NULL && this->font != Font::getDefaultFont())
     ResourceManager::getInstance()->unload(this->font);
-  if (this->text)
-    delete[] this->text;
+}
 …
   // 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("");
+}
 …
  * @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;
 …
   // load a new Font
   if (fontFile != NULL)
+  if (!fontFile.empty())
+  {
     tmpFont = (Font*)ResourceManager::getInstance()->load(fontFile, TTF, RP_GAME, (int)fontSize);
 …
       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());
+  }
+}
 …
  * @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
 …
     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());
 …
     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);
 …
     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]);
 …
         posX += tmpGlyph->advance * this->getSizeY2D();
+      }
-      ++tmpText;
+    }
     glEnd();
 …
 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())

trunk/src/lib/graphics/text_engine/text.h

-                      r6981
+                      r7221
+{
   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; };
 …
     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.

trunk/src/lib/gui/gl_gui/glgui_button.cc

r6287	r7221
54	54	}
55	55
56		void GLGuiButton::setLabel(const char* label)
	56	void GLGuiButton::setLabel(const std::string& label)
57	57	{
58	58	this->label->setText(label);

trunk/src/lib/gui/gl_gui/glgui_button.h

r5427	r7221
35	35
36	36	void init();
37		void setLabel(const char* label);
	37	void setLabel(const std::string& label);
38	38
39	39	virtual void draw() const;

trunk/src/lib/gui/gl_gui/glgui_menu.h

-                      r5391
+                      r7221
   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);

trunk/src/lib/gui/gl_gui/glgui_widget.h

r7062	r7221
47	47	virtual char* save() {};
48	48	/** loads options of the Widget. @param loadString a string containing the Options */
49		virtual void load(const char* loadString) {};
	49	virtual void load(const std::string& loadString) {};
50	50
51	51	void show();

trunk/src/lib/gui/gl_gui/glmenu/glmenu_imagescreen.cc

-                      r7193
+                      r7221
    ### File Specific:
    main-programmer: Patrick Boenzli
    co-programmer:
+   co-programmer: Benjamin GRauer
 */
 …
 /**
   *  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);
 …
 /**
  *  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
 …
 /**
   \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))
 …
 /**
   \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)
 …
  * @param barImage An image for the Bar
 */
 void GLMenuImageScreen::setBarImage(const char* barImage)
+void GLMenuImageScreen::setBarImage(const std::string& barImage)
+{
   this->barMat->setDiffuseMap(barImage);
 …
 /**
  *  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)
 …
 /**
  *  set the maximum of countable steps
+ * @brief set the maximum of countable steps
  * @param maxValue of steps
 */
 …
 /**
  *  set current value
+ * @brief set current value
  * @param currentValue value to set
 */
 …
 /**
  *  get the current value
+ * @brief get the current value
  */
 int GLMenuImageScreen::getValue()
 …
 /**
   *  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 ()
 …
 /**
  *  draws the ImageScreen to the screenbuffer
+ * @brief draws the ImageScreen to the screenbuffer
 */
 void GLMenuImageScreen::draw ()

trunk/src/lib/gui/gl_gui/glmenu/glmenu_imagescreen.h

-                      r6512
+                      r7221
 //! 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);
 …
   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);
 …
  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

trunk/src/lib/gui/gtk_gui/gui_exec.cc

-                      r7193
+                      r7221
   Frame* execFrame;            //!< The Frame that holds the ExecutionOptions.
   this->confFile = NULL;
   this->confDir = NULL;
+  this->confFile = "";
+  this->confDir = "";
   execFrame = new Frame("Execute-Tags:");
 …
 GuiExec::~GuiExec()
+{
-  if(this->confFile)
-    delete []this->confFile;
-  if(this->confDir)
-    delete []this->confDir;
+}
 …
   //! @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__ */
+}
 …
 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);
+}
 …
 const char* GuiExec::getConfigFile() const
+{
   return this->confFile;
+  return this->confFile.c_str();
+}
 …
   IniParser iniParser;
   this->writeFileText(widget, &iniParser, 0);
   char* fileName = ResourceManager::homeDirCheck(confFile);
+  std::string fileName = ResourceManager::homeDirCheck(confFile);
   iniParser.writeFile(fileName);
-  delete[] fileName;
+}
 …
 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;
 …
   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;
 …
       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();

trunk/src/lib/gui/gtk_gui/gui_exec.h

-                      r6981
+                      r7221
 #include "gui_gtk.h"
+#include <string>
 class Widget;
 class CheckButton;
 …
   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.
 …
 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
 };

trunk/src/lib/lang/base_object.cc

-                      r7193
+                      r7221
 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;
 …
   //  delete []this->className;
-  if (this->objectName)
-    delete[] this->objectName;
   if (this->xmlElem != NULL)
     delete this->xmlElem;
 …
  * @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);
 …
  * @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;
+}
 …
  * @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);
 …
  * @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);
+}
 …
 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;
 …
+  }
   return SYNCHELP_READ_N;
+  return SYNCHELP_READ_N;*/
+}
 …
 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;*/
+}

trunk/src/lib/lang/base_object.h

-                      r6587
+                      r7221
 #endif
+#include <string>
 #include "stdincl.h"
 …
   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; };
 …
   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); };
 …
  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

trunk/src/lib/lang/class_list.cc

-                      r7199
+                      r7221
  *  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;
 …
 //! 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;
 /**
 …
  * !! 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);
 …
  * 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())
 …
  * @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;
 …
  * @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);
 …
  * @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)
 …
       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);
+    }
 …
       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);
+    }
 …
     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);
+  }
+}
 …
  * @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;
+}
 …
  * @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);
 …
  * @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);
+}
 …
       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)
 …
  * @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));

trunk/src/lib/lang/class_list.h

-                      r7165
+                      r7221
 #include "class_id.h"
 #include <list>
+#include <string>
 #ifndef NULL
 #define NULL     0    //!< NULL
 …
 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);
 …
     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);
 …
     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.
 };

trunk/src/lib/parser/ini_parser/ini_parser.cc

-                      r5953
+                      r7221
  * @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);
+}
 …
+{
   this->deleteSections();
+  this->setFileName(NULL);
+}
+  this->setFileName("");
+}
+const std::string IniParser::emptyString = "";
 …
+{
   // 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("");
+}
 …
  * 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;
+}
 …
  * 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;
+  }
 …
     // READING IN THE INI-FILE //
     /////////////////////////////
     char lineBuffer[PARSELINELENGHT];
     char buffer[PARSELINELENGHT];
+    char lineBuffer[PARSELINELENGHT+1];
+    char buffer[PARSELINELENGHT+1];
     const char* lineBegin;
     char* ptr;
 …
       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;
 …
           continue;
+        }
+        if( ptr == lineBegin) {
+        if( ptr == lineBegin)
+        {
           lineCount++;
           continue;
 …
  * @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;
+}
 /**
 …
  * @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;
+}
 …
  * @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);
 …
+ *
  */
 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);
 …
     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;
+}
 …
  * @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);
 …
     return (*section).comment;
   else
     return NULL;
+    return IniParser::emptyString;
+}
 …
  * @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;
+}
 …
  * @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;
+  }
 …
   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;
+  }
 …
+  {
     (*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;
 …
  * 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
 …
   return defaultValue;
+}
 …
  * @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;
+}
 …
  * @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);
 …
+{
   if (!this->sections.empty() &&
        this->currentSection != this->sections.end())
+      this->currentSection != this->sections.end())
     this->currentEntry = (*this->currentSection).entries.begin();
+}
 …
  * @returns the name of the Current selected Section
  */
 const char* IniParser::getCurrentSection() const
+const std::string& IniParser::getCurrentSection() const
+{
   if (!this->sections.empty() &&
 …
     return this->currentSection->name;
   else
     return NULL;
+ }
+    return IniParser::emptyString ;
+}
 …
  * @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;
+}
 …
  * @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() &&
 …
     return (*this->currentEntry).value;
   else
     return NULL;
+    return IniParser::emptyString;
+}
 …
  * @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;
 …
  * @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;
 …
  * @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);
 …
   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())
 …
  * @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);
 …
   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())
 …
 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();
+  }
 …
 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();
+  }
 …
 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();
+  }
+}
 …
 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());
+      }
+    }

trunk/src/lib/parser/ini_parser/ini_parser.h

-                      r6981
+                      r7221
 #include <list>
+#include <string>
 //! ini-file parser
 …
     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
     };
 …
     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
     };
 …
   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.
 …
     // 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;
 …
   private:
     void deleteSections();
     void setFileName(const char* fileName);
+    void setFileName(const std::string& fileName);
     void setFileComment();
 …
     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;
 };

trunk/src/lib/parser/tinyxml/tinyxml.h

-                      r5819
+                      r7221
 #ifndef TINYXML_INCLUDED
 #define TINYXML_INCLUDED
+#define TIXML_USE_STL
 #ifdef _MSC_VER
 …
                 #define TIXML_SNSCANF  snscanf
         #endif
 #endif
+#endif
 class TiXmlDocument;
 …
 const int TIXML_PATCH_VERSION = 2;
 /*      Internal structure for tracking location of items
+/*      Internal structure for tracking location of items
         in the XML file.
 */
 …
 // Only used by Attribute::Query functions
 enum
+{
+enum
+{
         TIXML_SUCCESS,
         TIXML_NO_ATTRIBUTE,
 …
         /**     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.)
         */
 …
         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;
 …
         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' );
+        }
 …
     /// 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.
 …
 public:
         #ifdef TIXML_USE_STL
+        #ifdef TIXML_USE_STL
             /** An input stream operator, for every class. Tolerant of newlines and
 …
                     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,
 …
                     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);
 …
     #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
 …
         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
 …
         /** 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;
 …
         /** 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.
 …
     #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
 …
 /*      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
 …
         /** 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().
 …
         /// 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
 …
                 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.
 …
                 @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
 …
                 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.
         */
 …
 /** 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().
 */
 …
         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'
 …
                 - 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; }
 …
         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
 …
                 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
 …
                 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;
+                                                                                        }
 …
         @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:
 …
         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:
 …
         @verbatim
         int i=0;
+        int i=0;
         while ( true )
+        {
 …
         @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:
 …
         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.
 …
         /// 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 ); }

trunk/src/lib/particles/dot_particles.h

r6652	r7221
21	21	virtual void loadParams(const TiXmlElement* root);
22	22
23		void setMaterialTexture(const char* textureFile);
	23	void setMaterialTexture(const std::string& textureFile);
24	24
25	25	/** @returns the Material that lies on this particles */

trunk/src/lib/particles/model_particles.cc

r7198	r7221
89	89	* @param textureFile the Texture to load onto these ModelParticles
90	90	*/
91		void ModelParticles::setMaterialTexture(const char* textureFile)
	91	void ModelParticles::setMaterialTexture(const std::string& textureFile)
92	92	{
93	93	this->material.setDiffuseMap(textureFile);

trunk/src/lib/particles/model_particles.h

r6629	r7221
20	20	virtual void loadParams(const TiXmlElement* root);
21	21
22		void setMaterialTexture(const char* textureFile);
	22	void setMaterialTexture(const std::string& textureFile);
23	23
24	24	/** @returns the Material that lies on this particles */

trunk/src/lib/particles/particle_system.cc

r7199	r7221
485	485	void ParticleSystem::debug() const
486	486	{
487		PRINT(0)(" ParticleCount: %d emitters: %d, maximumCount: %d :: filled %d%%\n", this->count, this->emitters.size(), this->maxCount, ~~100*this->count/this->maxCount~~);
	487	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));
488	488	if (deadList)
489	489	{

trunk/src/lib/particles/spark_particles.cc

r7193	r7221
68	68	{
69	69	this->setClassID(CL_SPARK_PARTICLES, "SparkParticles");
70
71		~~this->material = NULL;~~
72	70	}
73	71

trunk/src/lib/particles/sprite_particles.cc

r7198	r7221
89	89	* @param textureFile the Texture to load onto these SpriteParticles
90	90	*/
91		void SpriteParticles::setMaterialTexture(const char* textureFile)
	91	void SpriteParticles::setMaterialTexture(const std::string& textureFile)
92	92	{
93	93	this->material.setDiffuseMap(textureFile);

trunk/src/lib/particles/sprite_particles.h

r6626	r7221
21	21	virtual void loadParams(const TiXmlElement* root);
22	22
23		void setMaterialTexture(const char* textureFile);
	23	void setMaterialTexture(const std::string& textureFile);
24	24
25	25	/** @returns the Material that lies on this particles */

trunk/src/lib/physics/physics_connection.cc

r7193	r7221
73	73	* @param subjectName the name of the Subject for this PhysicsConnection
74	74	*/
75		void PhysicsConnection::setSubject(const char* subjectName)
	75	void PhysicsConnection::setSubject(const std::string& subjectName)
76	76	{
77	77	this->subject = PhysicsEngine::getInstance()->getPhysicsInterfaceByName(subjectName);
78	78	if (this->subject == NULL)
79	79	{
80		PRINTF(2)("subject: (%s) not found for PhysicsConnection\n", subjectName);
	80	PRINTF(2)("subject: (%s) not found for PhysicsConnection\n", subjectName.c_str());
81	81	}
82	82	else
…	…
87	87	* @param fieldName the Name of the Field for this connection
88	88	*/
89		void PhysicsConnection::setField(const char* fieldName)
	89	void PhysicsConnection::setField(const std::string& fieldName)
90	90	{
91	91	this->field = PhysicsEngine::getInstance()->getFieldByName(fieldName);
92	92	if (this->field == NULL)
93	93	{
94		~~PRINTF(2)("field: (%s) not found for PhysicsConnection\n", fieldName~~);
	94	PRINTF(2)("field: (%s) not found for PhysicsConnection\n", fieldName.c_str());
95	95	}
96	96	else

trunk/src/lib/physics/physics_connection.h

-                      r5257
+                      r7221
   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;

trunk/src/lib/physics/physics_engine.cc

-                      r7193
+                      r7221
   @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);
 …
 /**
 * @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;
 …
   @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;

trunk/src/lib/physics/physics_engine.h

-                      r6512
+                      r7221
   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;

trunk/src/lib/shell/shell.cc

-                      r7198
+                      r7221
   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;
 …
     delete this->bufferText[i];
   delete[] this->bufferText;
-  delete[] this->fontFile;
   // delete the inputLine
   delete this->shellInput;
 …
     if (!top)
+    {
       this->bufferText[i]->setText((*textLine), true);
+      this->bufferText[i]->setText((*textLine));
     if (textLine != ShellBuffer::getInstance()->getBuffer()->begin())
       top = true;
 …
     if (textLine != ShellBuffer::getInstance()->getBuffer()->begin())
+    {
       this->bufferText[i]->setText((*textLine), false);
+      this->bufferText[i]->setText((*textLine));
       textLine--;
+    }
 …
  * (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();
 …
  * @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);
 …
     for (int i = 0; i < this->bufferDisplaySize; i++)
+    {
       this->bufferText[i]->setText(NULL, true);
+      this->bufferText[i]->setText("");
+    }
 …
  * @param text the text to output.
  */
 void Shell::printToDisplayBuffer(const char* text)
+void Shell::printToDisplayBuffer(const std::string& text)
+{
   if(likely(bufferText != NULL))
 …
     this->bufferText[0] = lastText;
     this->bufferText[0]->setText(text, true);
+    this->bufferText[0]->setText(text);
+  }
+}
 …
   for (unsigned int i = 0; i < this->bufferDisplaySize; i++)
+  {
     this->bufferText[i]->setText((*it), false);
+    this->bufferText[i]->setText((*it));
     it--;
+  }

trunk/src/lib/shell/shell.h

-                      r5784
+                      r7221
     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();
 …
     // BUFFERS
     void setBufferDisplaySize(unsigned int bufferDisplaySize);
     void printToDisplayBuffer(const char* text);
+    void printToDisplayBuffer(const std::string& text);
     void moveDisplayBuffer(int lineCount);
 …
     //     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:
 …
     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.

trunk/src/lib/shell/shell_command.cc

-                      r7201
+                      r7221
   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);
 …
  * @return true on success, false otherwise.
  */
 bool ShellCommand::execute(const char* executionString)
+bool ShellCommand::execute(const std::string& executionString)
+{
   if (ShellCommandClass::commandClassList == NULL)
 …
       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 )
+        {
 …
+          {
             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(), "");
 …
       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();
 …
         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);
 …
         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, "");
 …
  * @param description the description of the Given command
  */
 ShellCommand* ShellCommand::describe(const char* description)
+ShellCommand* ShellCommand::describe(const std::string& description)
+{
   if (this == NULL)
 …
   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;
 …
       /*      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");

trunk/src/lib/shell/shell_command.h

-                      r7201
+                      r7221
   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,
 …
     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.
 …
   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; };
 …
   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.
 };

trunk/src/lib/shell/shell_command_class.cc

-                      r5780
+                      r7221
  * @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;
 …
  * @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;
 …
   for(elem = ShellCommandClass::commandClassList->begin(); elem != ShellCommandClass::commandClassList->end(); elem++)
+  {
     if (!strcmp ((*elem)->getName(), className))
+    if (className == (*elem)->getName())
+    {
       list<ShellCommand*>::iterator command;
 …
  * @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)
 …
  * @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)
 …
   for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
+  {
     if (!strcmp(className, (*classIT)->className))
+    if (className == (*classIT)->className)
+    {
       if ((*classIT)->classID == CL_NULL)
 …
  * @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)
 …
   for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
+  {
     if (!strcmp(className, (*classIT)->className))
+    if (className == (*classIT)->className)
+    {
       return (*classIT);
 …
  * @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))
+  {
 …
     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++)
 …
           /*          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");
+        }
 …
+      }
+    }
     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

trunk/src/lib/shell/shell_command_class.h

-                      r6981
+                      r7221
     /** @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

trunk/src/lib/shell/shell_completion.cc

-                      r5885
+                      r7221
   // 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;
 …
   // 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
 …
     completeString = "";
   else
     completeString = inputSplits.getString(inputSplits.getCount()-1);
+    completeString = inputSplits.getString(inputSplits.getCount()-1).c_str();
   // CLASS COMPLETION
 …
             (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)
 …
             (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;
 …
     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);
 …
   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)
+  {
 …
   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());
 …
   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());
 …
  * !! 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)
 …
   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);

trunk/src/lib/shell/shell_completion.h

r5784	r7221
52	52	bool generalComplete(const char* begin, const char* displayAs = "%s", const char* addBack = NULL, const char* addFront = NULL);
53	53
54		bool addToCompleteList(const std::list<const char> inputList, const char* completionBegin, SHELLC_TYPE type);
	54	bool addToCompleteList(const std::list<std::string>* inputList, const char* completionBegin, SHELLC_TYPE type);
55	55	bool addToCompleteList(const std::list<BaseObject> inputList, const char* completionBegin, SHELLC_TYPE type);
56	56	void emptyCompletionList();

trunk/src/lib/shell/shell_input.cc

-                      r6222
+                      r7221
  * 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);
 …
+{
   // 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();
+  }
 …
 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);
+}
 …
  * @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);
+}
 …
   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);
+}
 …
  * @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);
+}
 …
   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);
+}
 …
 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;
 …
   // 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();
+  }
 …
   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();
 …
   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();
 …
   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();
 …
  * 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");
 …
     PRINT(0)("- Also try 'help className'");
+  }
   else if (strlen (className) > 0 && strlen (functionName) == 0)
+  else if (!className.empty() && functionName.empty())
+  {
     ShellCommandClass::help(className);

trunk/src/lib/shell/shell_input.h

-                      r5786
+                      r7221
   /** @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);
 …
   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);
 …
  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.
 };

trunk/src/lib/sound/ogg_player.cc

-                      r6987
+                      r7221
  * @param fileName the file to load
  */
 OggPlayer::OggPlayer(const char* fileName)
+OggPlayer::OggPlayer(const std::string& fileName)
+{
   this->setClassID(CL_SOUND_OGG_PLAYER, "OggPlayer");
 …
   this->buffers[1] = 0;
   if (fileName != NULL)
+  if (!fileName.empty())
+  {
     if (this->open(fileName))
 …
  * @param fileName the file to open
  */
 bool OggPlayer::open(const char* fileName)
+bool OggPlayer::open(const std::string& fileName)
+{
   if (this->buffers[0] == 0)
 …
   int result;
   if(!(oggFile = fopen(fileName, "rb")))
+  if(!(oggFile = fopen(fileName.c_str(), "rb")))
+  {
     PRINTF(2)("Could not open Ogg file.");

trunk/src/lib/sound/ogg_player.h

-                      r7054
+                      r7221
+{
 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();

trunk/src/lib/sound/sound_buffer.cc

-                      r6836
+                      r7221
  * @param fileName The name of the File
  */
 SoundBuffer::SoundBuffer(const char* fileName)
+SoundBuffer::SoundBuffer(const std::string& fileName)
+{
   this->setClassID(CL_SOUND_BUFFER, "SoundBuffer");
 …
  * @returns true on success.
  */
 bool SoundBuffer::loadWAV(const char* fileName)
+bool SoundBuffer::loadWAV(const std::string& fileName)
+{
   SDL_AudioSpec wavSpec;
 …
   /* 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;
+  }

trunk/src/lib/sound/sound_buffer.h

-                      r6981
+                      r7221
+{
   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 */

trunk/src/lib/sound/sound_engine.cc

-                      r7193
+                      r7221
 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;
+}
 …
    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));

trunk/src/lib/sound/sound_engine.h

r6849	r7221
33	33	void loadSettings(IniParser* iniParser);
34	34
35		SoundSource* createSource(const char* fileName, PNode* sourceNode = NULL);
	35	SoundSource* createSource(const std::string& fileName, PNode* sourceNode = NULL);
36	36
37	37	/** @param listener the listener in the scene */

trunk/src/lib/util/executor/executor.cc

r7201	r7221
105	105	value[4] = &value4;
106	106
107		~~printf("%s ::: paramCount: %d\n", this->getName(), this->paramCount);~~
108	107	for (unsigned int i = 0; i < this->paramCount; i++)
109	108	{
110	109	if (*value[i] != MT_NULL)
111	110	{
112		printf("1:::: %d : %s \n",i, MultiType::MultiTypeToString(this->defaultValue[i].getType()));
113
114		this->defaultValue[i].debug();
115		//this->defaultValue[i].setValueOf(*value[i]);
116		//printf("2::::%s\n", MultiType::MultiTypeToString(this->defaultValue[i].getType()));
117		//this->defaultValue[i].debug();
118		//this->defaultValue[i].setValueOf(*value[i]);
	111	this->defaultValue[i].setValueOf(*value[i]);
119	112	}
120	113	}

trunk/src/lib/util/executor/executor.h

-                      r7200
+                      r7221
 //! 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;
 …
     /** 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) */
 …
 #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()
 …
 #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))) \
 …
 #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)))
 …
 #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;
 …
     } 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
 …
+{
   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;
 …
     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

trunk/src/lib/util/executor/executor_specials.h

r7197	r7221
60	60	* @param loadString ignored in this case
61	61	*/
62		virtual void execute(BaseObject* object, const ~~void* parameters = NULL~~)
	62	virtual void execute(BaseObject* object, const std::string& = "")
63	63	{
64	64	if (object != NULL && this->element != NULL)

trunk/src/lib/util/executor/functor_list.h

-                      r7199
+                      r7221
    l_SHORT:     short
    l_FLOAT:     float
    l_CSTRING:    const char*
+   l_STRING:    const std::string&
    l_XML_ELEM:  TiXmlElement*
  */
 …
 //#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
 …
   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
 …
   //! 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);

trunk/src/lib/util/helper_functions.cc

-                      r5331
+                      r7221
 /**
  * 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
 …
 /**
  * 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
 …
 /**
  * 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;
+}

trunk/src/lib/util/helper_functions.h

-                      r5141
+                      r7221
 #define _HELPER_FUNCTIONS_H
+#include <string>
 // FORWARD DECLARATION
 …
 *** 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 */

trunk/src/lib/util/loading/factory.cc

-                      r7193
+                      r7221
 //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)
 …
+}
 /** 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 ()
 …
 /**
  * deletes all the Factories. (cleanup)
+ * @brief deletes all the Factories. (cleanup)
  */
 void Factory::deleteFactories()
 …
 /**
  * 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.
 …
 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
 …
  * @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;
 …
   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;
+  }

trunk/src/lib/util/loading/factory.h

-                      r7167
+                      r7221
 #include "parser/tinyxml/tinyxml.h"
 #include "base_object.h"
-#include "debug.h"
 #include <vector>
 #include <list>
 …
  * 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)
 …
   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);
 …
   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)
  */
 …
  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.
 …
   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.

trunk/src/lib/util/loading/game_loader.cc

-                      r7193
+                      r7221
  * 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;
+    }
+}
 …
  * 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;
+  }
+}
 …
  * 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
 …
   */
   if( fileName == NULL)
+  if( fileName.empty())
+    {
       PRINTF(2)("No filename specified for loading");
 …
+    }
   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);
 …
       // 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);
+}

trunk/src/lib/util/loading/game_loader.h

-                      r6981
+                      r7221
   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();
 …
   GameLoader ();
   Campaign* fileToCampaign(const char* name);
+  Campaign* fileToCampaign(const std::string& name);

trunk/src/lib/util/loading/load_param.cc

-                      r7201
+                      r7221
  * @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;
 …
   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
 …
   this->executor = executor.clone();
   if (this->executor)
     this->executor->setName(paramName);
+  //if (this->executor)
+  //  this->executor->setName(paramName);
+}
 …
   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;
 …
  * @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);
 …
  * @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();
 …
     node = node->NextSibling();
+  }
   return NULL;
+  return "";
+}
 …
  * @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);

trunk/src/lib/util/loading/load_param.h

-                      r7198
+                      r7221
+{
   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);
 …
     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.
 …
 // 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 */

trunk/src/lib/util/loading/load_param_description.cc

-                      r7130
+                      r7221
  * @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;
+}
 …
   delete[] this->types;
   delete[] this->defaultValues;
-  delete[] this->paramName;
-  delete[] this->description;
+}
 …
  * @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;
+}
 …
 void LoadParamDescription::print() const
+{
   PRINT(3)(" <%s>", this->paramName);
+  PRINT(3)(" <%s>", this->paramName.c_str());
   for (int i = 0; i < this->paramCount; i++)
+  {
 …
 //     }
+  }
   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)
 …
  * @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)
 …
     this->paramList.pop_front();
+  }
-  delete[] this->className;
+}
 …
    Otherwise it returns a new classDescription
  */
 LoadClassDescription* LoadClassDescription::addClass(const char* className)
+LoadClassDescription* LoadClassDescription::addClass(const std::string& className)
+{
   if (LoadClassDescription::classList != NULL)
 …
     while (it != LoadClassDescription::classList->end())
+    {
       if (!strcmp((*it)->className, className))
+      if ((*it)->className == className)
+      {
         return (*it);
 …
 /**
  *  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;
 …
  * @todo implement it
  */
 void LoadClassDescription::printAll(const char* fileName)
+void LoadClassDescription::printAll(const std::string& fileName)
+{
   PRINT(3)("===============================================================\n");
 …
     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())
 …
         param++;
+      }
       PRINT(3)("</%s>\n\n", (*classDesc)->className);
+      PRINT(3)("</%s>\n\n", (*classDesc)->className.c_str());
       classDesc++;
+    }
 …
  * !! 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();

trunk/src/lib/util/loading/load_param_description.h

-                      r7130
+                      r7221
   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
 };
 …
+{
   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.

trunk/src/lib/util/loading/resource_manager.cc

-                      r7199
+                      r7221
   this->setName("ResourceManager");
   this->dataDir = new char[3];
   strcpy(this->dataDir, "./");
+  this->dataDir = "./";
+  this->_cwd = "";
   this->tryDataDir("./data");
-  this->_cwd = NULL;
+}
 …
     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;
+}
 …
  * @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;
+  }
 …
  * 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;
+}
 …
  * @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;
+}
 …
    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
 …
+  {
     // 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;
+      }
 …
   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;
+  }
 …
  * @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 */
 …
 #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 */
 …
 #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 */
 …
 #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 */
 …
  * 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;
 …
  * @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.
 …
  * @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)
+{
 …
   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)
 …
       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());
+      }
 …
         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;
 …
         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 */
 …
       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 */
 …
+        {
           MultiType param = param0; /// HACK
           char* secFullName = ResourceManager::getFullName(param.getCString());
+          std::string secFullName = ResourceManager::getFullName(param.getCString());
           if (ResourceManager::isFile(secFullName))
+          {
 …
             tmpResource->pointer = new Shader(fullName, secFullName);
+          }
-          delete[] secFullName;
+        }
         else
+        {
           tmpResource->param[0] = param0;
           tmpResource->pointer = new Shader(fullName, NULL);
+          tmpResource->pointer = new Shader(fullName, "");
+        }
+      }
 …
     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)
 …
   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;
 …
       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);
 …
+    }
     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;
+}
 …
           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++;
+        }
 …
  * @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
+{
 …
   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;
 …
+}
 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);
 …
     strcat( tmp, this->resourceList[i]->param[2].getCString());
+  }
   return tmp;
+  return tmp;*/
+}
 …
  * @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)
 …
   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]);*/
+}
 …
  * @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
 …
                          ))
+    {
-      delete[] tmpDirName;
       return true;
+    }
     else
+    {
-      delete[] tmpDirName;
       return false;
+    }
+  }
+  else
+  {
+    delete[] tmpDirName;
+    return false;
+  }
+  }
+  else
+    return false;
+}
 …
  * @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
 …
                          ))
+    {
-      delete[] tmpFileName;
       return true;
+    }
     else
+    {
-      delete[] tmpFileName;
       return false;
+    }
+  }
+  else
+  {
+    delete[] tmpFileName;
+    return false;
+  }
+  }
+  else
+    return false;
+}
 …
  * @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;
+}
 …
  * @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());
+}
 …
  * @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;
 …
  * !!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 "";
+}
 …
  * @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;
 …
  * @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))
 …
   else
     retVal = false;
-  delete[] checkFile;
   return retVal;
+}
 …
   // 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");
 …
+  {
     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 ");

trunk/src/lib/util/loading/resource_manager.h

-                      r7196
+                      r7221
   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)
 …
   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);
 …
   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(); }
 …
   // 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);
 …
  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];
 };

trunk/src/lib/util/multi_type.cc

-                      r7201
+                      r7221
   switch (this->type)
+  {
+    default:
+      this->value.Float = 0.0f;
+      break;
     case MT_BOOL:
       this->value.Bool = false;
 …
+{
   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);
+}
 …
  * @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;

trunk/src/lib/util/multi_type.h

-                      r7200
+                      r7221
     MultiType(double value);
     MultiType(char value);
-    MultiType(const char* value);
     MultiType(const std::string& value);
     MultiType(const MultiType& multiType);
 …
     static const char* MultiTypeToString(MT_Type type);
     static MT_Type StringToMultiType(const char* type);
+    static MT_Type StringToMultiType(const std::string& type);
   private:
 …
 //      std::string*      String;
     }                   value;
+    std::string         storedString;
     MT_Type             type;
-    std::string         storedString;
 };

trunk/src/lib/util/substring.cc

-                      r5656
+                      r7221
 -06-10: some naming conventions
+//
+//  splitLine
+//  STL string tokenizer
+//
+//  Created by Clemens Wacha.
+//  Version 1.0
+//  Copyright (c) 2005 Clemens Wacha. All rights reserved.
+//
 */
 …
 #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);
+}
 /**
 …
+ *
  */
+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);
+}
 /**
 …
 */
 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;
+}
+{ }
 /**
 …
 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
 …
 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");
+}

trunk/src/lib/util/substring.h

-                      r6648
+                      r7221
 #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;
 };

trunk/src/orxonox.cc

-                      r7193
+                      r7221
   this->port = -1;
   this->configFileName = NULL;
+  this->configFileName = "";
+}
 …
   // orxonox class-stuff
   delete this->iniParser;
-  delete[] this->configFileName;
   SDL_QuitSubSystem(SDL_INIT_TIMER);
 …
 /**
  *  this finds the config file
+ * @brief this finds the config file
  * @returns the new config-fileName
  * Since the config file varies from user to user and since one may want to specify different config files
 …
  * it's path and name into configfilename
 */
 const char* Orxonox::getConfigFile ()
+const std::string& Orxonox::getConfigFile ()
+{
   if (ResourceManager::isFile("orxonox.conf"))
+  {
+    this->configFileName = new char[strlen("orxonox.conf")+1];
+    strcpy(this->configFileName, "orxonox.conf");
+    this->configFileName =  "orxonox.conf";
+  }
   else
 …
   GraphicsEngine::getInstance()->initFromIniFile(this->iniParser);
   char* iconName = ResourceManager::getFullName("pictures/fighter-top-32x32.bmp");
   if (iconName != NULL)
+  std::string iconName = ResourceManager::getFullName("pictures/fighter-top-32x32.bmp");
+  if (!iconName.empty())
+  {
     GraphicsEngine::getInstance()->setWindowName(PACKAGE_NAME " " PACKAGE_VERSION, iconName);
-    delete[] iconName;
+  }
   return 0;
 …
   // init the resource manager
   const char* dataPath;
   if ((dataPath = this->iniParser->getVar(CONFIG_NAME_DATADIR, CONFIG_SECTION_DATA))!= NULL)
+  std::string dataPath;
+  if ((dataPath = this->iniParser->getVar(CONFIG_NAME_DATADIR, CONFIG_SECTION_DATA))!= "")
+  {
     if (!ResourceManager::getInstance()->setDataDir(dataPath) &&
         !ResourceManager::getInstance()->verifyDataDir(DEFAULT_DATA_DIR_CHECKFILE))
+    {
       PRINTF(1)("Data Could not be located in %s\n", dataPath);
+      PRINTF(1)("Data Could not be located in %s\n", dataPath.c_str());
+    }
+  }
 …
     PRINTF(1)("The DataDirectory %s could not be verified\n\nh" \
               "!!!  Please Change in File %s Section %s Entry %s to a suitable value !!!\n",
               ResourceManager::getInstance()->getDataDir(),
               this->configFileName,
+    ResourceManager::getInstance()->getDataDir().c_str(),
+    this->configFileName.c_str(),
               CONFIG_SECTION_DATA,
               CONFIG_NAME_DATADIR );
 …
+  }
   //! @todo this is a hack and should be loadable
   char* imageDir = ResourceManager::getInstance()->getFullName("maps");
+  std::string imageDir = ResourceManager::getInstance()->getFullName("maps");
   ResourceManager::getInstance()->addImageDir(imageDir);
-  delete[] imageDir;
   imageDir = ResourceManager::getInstance()->getFullName("pictures");
   ResourceManager::getInstance()->addImageDir(imageDir);
-  delete[] imageDir;
   DynamicLoader::loadDyLib("libtest.so");

trunk/src/orxonox.h

-                      r5996
+                      r7221
   Orxonox ();
   void parseIniFile(const char* fileName);
+  void parseIniFile(const std::string& fileName);
   int initResources ();
 …
   int initMisc ();
   const char* getConfigFile ();
+  const std::string& getConfigFile ();
  private:
 …
   IniParser*        iniParser;               //!< Reference to the ini-parser used in orxonox
   char*             configFileName;          //!< Filename of the configuration-file.
+  std::string       configFileName;          //!< Filename of the configuration-file.
   GameLoader*       gameLoader;              //!< The gameLoader

trunk/src/story_entities/game_world.cc

-                      r7193
+                      r7221
   GameLoader* loader = GameLoader::getInstance();
   if( getLoadFile() == NULL)
+  if( getLoadFile().empty())
+  {
     PRINTF(1)("GameWorld has no path specified for loading\n");
 …
   if( !XMLDoc->LoadFile())
+  {
     PRINTF(1)("loading XML File: %s @ %s:l%d:c%d\n", XMLDoc->ErrorDesc(), this->getLoadFile(), XMLDoc->ErrorRow(), XMLDoc->ErrorCol());
+    PRINTF(1)("loading XML File: %s @ %s:l%d:c%d\n", XMLDoc->ErrorDesc(), this->getLoadFile().c_str(), XMLDoc->ErrorRow(), XMLDoc->ErrorCol());
     delete XMLDoc;
     return (ErrorMessage){213,"XML File parsing error","GameWorld::load()"};

trunk/src/story_entities/game_world_data.cc

-                      r7193
+                      r7221
   // load the parameters
   // name
   const char* string = grabParameter( root, "name");
   if( string == NULL)
+  std::string string = grabParameter( root, "name");
+  if( string.empty() )
+  {
     PRINTF(2)("GameWorld is missing a proper 'name'\n");
 …
+  }
   else
     this->setName(string);
+    this->setName(string.c_str());
   this->loadGUI(root);
 …
   if (this->music != NULL)
     this->setSoundTrack(NULL);
+    this->setSoundTrack("");
   this->music = NULL;
   /* stop the sound eninge */
 …
 void GameWorldData::setSoundTrack(const char* name)
+void GameWorldData::setSoundTrack(const std::string& name)
+{
   if (this->music != NULL)
 …
   this->music = NULL;
   if (name != NULL)
+  {
     PRINTF(3)("Setting Sound Track to %s\n", name);
     char* oggFile = ResourceManager::getFullName(name); /// FIXME
+  if (!name.empty())
+  {
+    PRINTF(3)("Setting Sound Track to %s\n", name.c_str());
+    std::string oggFile = ResourceManager::getFullName(name);
     this->music = new OggPlayer(oggFile);
-    delete[] oggFile;
     //(OggPlayer*)ResourceManager::getInstance()->load(name, OGG, RP_LEVEL);

trunk/src/story_entities/game_world_data.h

r7020	r7221
42	42
43	43	/* interface functions */
44		void setSoundTrack(const char* name);
	44	void setSoundTrack(const std::string& name);
45	45	void loadGameRule(const TiXmlElement* root);
46	46

trunk/src/story_entities/movie_loader.cc

-                      r7193
+                      r7221
+}
 MovieLoader::~MovieLoader()
+MovieLoader::~MovieLoader()
+{
   delete this->movie_player;
 …
+}
 void MovieLoader::loadMovie(const char* filename)
+void MovieLoader::loadMovie(const std::string& filename)
+{
   movie_player->loadMovie(filename);
 …
   this->movie_player->start(0);
   this->isRunning = true;
   this->run();
 …
   // calculate time difference in milliseconds (Uint32)
   this->dt = currentFrame - this->lastFrame;
+  this->dt = currentFrame - this->lastFrame;
   // calculate time difference in seconds (float)
   this->dts = (float)this->dt / 1000.0f;

trunk/src/story_entities/movie_loader.h

r7022	r7221
43	43
44	44	private:
45		void loadMovie(const char* filename);
	45	void loadMovie(const std::string& filename);
46	46	void setFPS(float fps);
47	47	void tick();

trunk/src/story_entities/simple_game_menu.cc

-                      r7193
+                      r7221
   this->menuSelectedIndex = 0;
+  this->loadParams(root);
+  if (root != NULL)
+    this->loadParams(root);
   State::setMenuID(this->getNextStoryID());
 …
 /**
  *  remove the SimpleGameMenu from memory
+ *  @brief remove the SimpleGameMenu from memory
+ *
  *  delete everything explicitly, that isn't contained in the parenting tree!
 …
 /**
  * loads the parameters of a SimpleGameMenu from an XML-element
+ * @brief loads the parameters of a SimpleGameMenu from an XML-element
  * @param root the XML-element to load from
  */
 …
 /**
  * this is executed just before load
+ * @brief this is executed just before load
+ *
  * since the load function sometimes needs data, that has been initialized
 …
 /**
  * load the data
+ * @brief load the data
  */
 ErrorMessage SimpleGameMenu::loadData()
 …
 /**
  * start the menu
+ * @brief start the menu
  */
 bool SimpleGameMenu::start()

trunk/src/story_entities/story_entity.cc

-                      r7193
+                      r7221
   this->isRunning = false;
   this->loadFile = NULL;
+  this->loadFile = "";
   this->storyID = -1;
   this->description = NULL;
   this->menuItemImage = NULL;
   this->menuScreenshoot = NULL;
+  this->description = "";
+  this->menuItemImage = "";
+  this->menuScreenshoot = "";
   this->nextStoryID = WORLD_ID_GAMEEND;
   this->bMenuEntry = false;
 …
  * @param name the name of the path
  */
 void StoryEntity::setLoadFile(const char* fileName)
+void StoryEntity::setLoadFile(const std::string& fileName)
+{
-  if (this->loadFile)
-    delete this->loadFile;
   if (ResourceManager::isFile(fileName))
+  {
+    this->loadFile = new char[strlen(fileName)+1];
+    strcpy(this->loadFile, fileName);
+    this->loadFile =  fileName;
+  }
   else
 …
  * @param name name
  */
 void StoryEntity::setDescription(const char* description)
+void StoryEntity::setDescription(const std::string& description)
+{
+  if (this->description)
+    delete[] this->description;
+  if (description!= NULL)
+  {
+    this->description= new char[strlen(description)+1];
+    strcpy(this->description, description);
+  }
+  else this->description= NULL;
+  this->description = description;
+}
 …
+{
   PRINTF(3)("Grabbing the Worlds Settings\n", this->getLoadFile());
   if( getLoadFile() == NULL)
     return;
+  if( getLoadFile().empty())
+        return;
   TiXmlDocument XMLDoc(this->getLoadFile());
   // load the xml world file for further loading
   if( !XMLDoc.LoadFile())
+  {
     PRINTF(1)("loading XML File: %s @ %s:l%d:c%d\n", XMLDoc.ErrorDesc(), this->getLoadFile(), XMLDoc.ErrorRow(), XMLDoc.ErrorCol());
+    PRINTF(1)("loading XML File: %s @ %s:l%d:c%d\n", XMLDoc.ErrorDesc(), this->getLoadFile().c_str(), XMLDoc.ErrorRow(), XMLDoc.ErrorCol());
     return;
+  }
 …
  * @param name name
  */
 void StoryEntity::setMenuItemImage(const char* image)
+void StoryEntity::setMenuItemImage(const std::string& image)
+{
+  if (this->menuItemImage)
+    delete[] this->menuItemImage;
+  if (image != NULL)
+  {
+    this->menuItemImage = new char[strlen(image)+1];
+    strcpy(this->menuItemImage, image);
+  }
+  else this->menuItemImage = NULL;
+  this->menuItemImage = image;
+}
+/** sets the menu screenshoot of this StoryEntity @param name name */
+void StoryEntity::setMenuScreenshoot(const char* image)
+/** sets the menu screenshoot of this StoryEntity
+ * @param name name
+ */
+void StoryEntity::setMenuScreenshoot(const std::string& image)
+{
+  if (this->menuScreenshoot)
+    delete[] this->menuScreenshoot;
+  if (image != NULL)
+  {
+    this->menuScreenshoot = new char[strlen(image)+1];
+    strcpy(this->menuScreenshoot, image);
+  }
+  else this->menuScreenshoot = NULL;
+  this->menuScreenshoot = image;
+}

trunk/src/story_entities/story_entity.h

-                      r6993
+                      r7221
   inline int getStoryID() { return this->storyID; }
   void setLoadFile( const char* fileName);
+  void setLoadFile(const std::string& fileName);
   /** @returns the Filename this StoryEntity was loaded with */
   const char* getLoadFile() const { return this->loadFile; }
+  const std::string& getLoadFile() const { return this->loadFile; }
   void setNextStoryID(int nextStoryID);
   /**  gets the story id of the current entity @returns story id */
   inline int getNextStoryID() const { return this->nextStoryID; }
   inline void setDescription(const char* description);
+  inline void setDescription(const std::string& description);
   /** @returns the description of this StoryEntity */
   inline const char* getDescription() { return this->description; }
+  inline const std::string& getDescription() { return this->description; }
   void grabWorldInfo();
 …
   inline bool isContainedInMenu() { return this->bMenuEntry; }
   /** sets the menu item image of this StoryEntity @param name name */
   inline void setMenuItemImage(const char* image);
+  inline void setMenuItemImage(const std::string& image);
   /** @returns the menu item image of this StoryEntity */
   inline const char* getMenuItemImage() { return this->menuItemImage; }
   inline void setMenuScreenshoot(const char* image);
+  inline const std::string& getMenuItemImage() { return this->menuItemImage; }
+  inline void setMenuScreenshoot(const std::string& image);
   /** @returns the menu screenshoot of this StoryEntity */
   inline const char* getMenuScreenshoot() { return this->menuScreenshoot; }
+  inline const std::string& getMenuScreenshoot() { return this->menuScreenshoot; }
   protected:
     bool isInit;            //!< if the entity is initialized, this has to be true.
     bool isRunning;         //!< is true if the entity is running
     bool isPaused;          //!< is true if the entity is paused
+    bool          isInit;            //!< if the entity is initialized, this has to be true.
+    bool          isRunning;         //!< is true if the entity is running
+    bool          isPaused;          //!< is true if the entity is paused
  private:
     int     storyID;          //!< this is the number of this entity, identifying it in a list/tree...
     int     nextStoryID;      //!< if this entity has finished, this entity shall be called
     char*   loadFile;         //!< The file from which this world is loaded
+    int           storyID;          //!< this is the number of this entity, identifying it in a list/tree...
+    int           nextStoryID;      //!< if this entity has finished, this entity shall be called
+    std::string   loadFile;         //!< The file from which this world is loaded
     char*   description;      //!< the description of the StoryEntity
     char*   menuItemImage;    //!< the item image of the StoryEntity
     char*   menuScreenshoot;  //!< the screenshoot of the StoryEntity
     bool    bMenuEntry;       //!< If true, this GameWorld apears in the SimpleMenu: SimpleMenu specific
+    std::string   description;      //!< the description of the StoryEntity
+    std::string   menuItemImage;    //!< the item image of the StoryEntity
+    std::string   menuScreenshoot;  //!< the screenshoot of the StoryEntity
+    bool          bMenuEntry;       //!< If true, this GameWorld apears in the SimpleMenu: SimpleMenu specific
 };

trunk/src/subprojects/others/TTFtoIMG.cc

-                      r6348
+                      r7221
 #include <SDL/SDL.h>
 #include <SDL/SDL_ttf.h>
+#include <string>
 …
 void createAsciiImage(const char* fileName, unsigned int size)
+void createAsciiImage(const std::string& fileName, unsigned int size)
+{
   if (fontTTF == NULL)
 …
+    }
+  }
   SDL_SaveBMP(tmpSurf, fileName);
+  SDL_SaveBMP(tmpSurf, fileName.c_str());
   SDL_FreeSurface(tmpSurf);
+}
 …
   fontTTF = TTF_OpenFont(argv[1], renderSize);
   createAsciiImage(argv[2], renderSize);
   //  delete fontTTF;
   TTF_Quit();

trunk/src/util/Makefile.am

-                      r7193
+                      r7221
                         animation/animation_player.cc \
+                        \
+                        track/pilot_node.cc \
+                        track/track_manager.cc \
+                        track/pilot_node.cc
+#                       track/track_manager.cc \
                         track/track_node.cc
 …
                         animation/t_animation.h \
+                        \
+                        track/pilot_node.h \
+                        track/track_manager.h \
+                        track/pilot_node.h
+#                       track/track_manager.h \
                         track/track_node.h

trunk/src/util/fast_factory.cc

-                      r5750
+                      r7221
  * @return a new FastFactory
  */
 FastFactory::FastFactory (ClassID classID, const char* fastFactoryName)
+FastFactory::FastFactory (ClassID classID, const std::string& fastFactoryName)
+{
   this->setClassID(CL_FAST_FACTORY, "FastFactory");
 …
  * @returns true if found, false otherwise.
  */
 FastFactory* FastFactory::searchFastFactory(const char* fastFactoryName)
+FastFactory* FastFactory::searchFastFactory(const std::string& fastFactoryName)
+{
   if (FastFactory::first == NULL)
 …
     while (tmpFac != NULL)
+    {
       if (strcmp(tmpFac->getName(), fastFactoryName))
+      if (fastFactoryName == tmpFac->getName())
         return tmpFac;
       tmpFac = tmpFac->next;

trunk/src/util/fast_factory.h

-                      r5447
+                      r7221
     static FastFactory* searchFastFactory(ClassID classID);
     static FastFactory* searchFastFactory(const char* fastFactoryName);
+    static FastFactory* searchFastFactory(const std::string& fastFactoryName);
     ClassID getStoredID() const { return this->storedClassID; };
   protected:
     FastFactory (ClassID classID, const char* fastFactoryName = NULL);
+    FastFactory (ClassID classID, const std::string& fastFactoryName = "");
     /** sets the Next factory in the list @param nextFactory the next factory */
 …
+  {
   public:
     static tFastFactory<T>* getFastFactory(ClassID classID, const char* fastFactoryName = NULL);
+    static tFastFactory<T>* getFastFactory(ClassID classID, const std::string& fastFactoryName = NULL);
   private:
     tFastFactory(ClassID classID, const char* fastFactoryName);
+    tFastFactory(ClassID classID, const std::string& fastFactoryName);
     virtual void fabricate();
 …
  */
 template<class T>
 tFastFactory<T>::tFastFactory(ClassID classID, const char* fastFactoryName)
+tFastFactory<T>::tFastFactory(ClassID classID, const std::string& fastFactoryName)
     : FastFactory(classID, fastFactoryName)
 {}
 …
  */
 template<class T>
 tFastFactory<T>* tFastFactory<T>::getFastFactory(ClassID classID, const char* fastFactoryName)
+    tFastFactory<T>* tFastFactory<T>::getFastFactory(ClassID classID, const std::string& fastFactoryName)
+{
   tFastFactory<T>* tmpFac = NULL;

trunk/src/util/multiplayer_team_deathmatch.cc

r7193	r7221
92	92
93	93
94		void MultiplayerTeamDeathmatch::setDeathScreen(const char* imageName)
	94	void MultiplayerTeamDeathmatch::setDeathScreen(const std::string& imageName)
95	95	{
96	96	if( this->deathScreen)

trunk/src/util/multiplayer_team_deathmatch.h

r7044	r7221
38	38	inline void setDeathPenaltyTimeout(float time) { this->deathTimeout = time; }
39	39	inline void setMaxKills(int kills) { this->maxKills = kills; }
40		void setDeathScreen(const char* imageName);
	40	void setDeathScreen(const std::string& imageName);
41	41
42	42	protected:

trunk/src/util/object_manager.cc

-                      r7198
+                      r7221
  * this function also does a transformation from omList as char* to OM_LIST.
  */
 void ObjectManager::toList (WorldEntity* entity, const char* omList)
+void ObjectManager::toList (WorldEntity* entity, const std::string& omList)
+{
   this->toList(entity, ObjectManager::StringToOMList(omList));
 …
  * @param level: level 0: only show list info; level 1: also show entities and their names.
  */
 void ObjectManager::debug(const char* listName, unsigned int level)
+void ObjectManager::debug(const std::string& listName, unsigned int level)
+{
   PRINT(0)("=================================\n");
   PRINT(0)("=ObjectManager-DEBUG=============\n");
   PRINT(0)("=================================\n");
   if (listName == NULL || listName[0] == '\0')
+  if (listName.empty())
     for (unsigned int i = 0; i < OM_SIZE; ++i)
       debug((OM_LIST) i, level);
 …
  * @returns the OM_LIST transformed from listName. or the default, if not found or NULL.
  */
 OM_LIST ObjectManager::StringToOMList(const char* listName)
+{
   if (unlikely(listName == NULL)) return OM_DEFAULT_LIST;
+OM_LIST ObjectManager::StringToOMList(const std::string& listName)
+{
+  if (unlikely(listName.empty())) return OM_DEFAULT_LIST;
   for(unsigned int i = 0; i < OM_SIZE; ++i) {
     if(!strcmp(listName, ObjectManager::objectManagerListNames[i])) {
+    if(listName == ObjectManager::objectManagerListNames[i]) {
       return (OM_LIST)i;
+    }

trunk/src/util/object_manager.h

-                      r6142
+                      r7221
   void toList (WorldEntity* entity, OM_LIST omList = OM_DEFAULT_LIST);
   void toList (WorldEntity* entity, const char* omList);
+  void toList (WorldEntity* entity, const std::string& omList);
 …
   void debug(OM_LIST omList, unsigned int level = 0) const;
   void debug(const char* listName = NULL, unsigned int level = 0);
+  void debug(const std::string& listName = "", unsigned int level = 0);
   static OM_LIST StringToOMList(const char* listName);
+  static OM_LIST StringToOMList(const std::string& listName);
   static const char* OMListToString(OM_LIST omList);

trunk/src/util/track/track_manager.cc

-                      r7193
+                      r7221
  * @returns The TrackElement if Found, NULL otherwise.
 */
 TrackElement* TrackElement::findByName(const char* trackName)
+TrackElement* TrackElement::findByName(const std::string& trackName)
+{
   // return if Found.
 …
  * @param trackName the Name of the Track to work on
 */
 void TrackManager::workOnS(const char* trackName)
+void TrackManager::workOnS(const std::string& trackName)
+{
   TrackElement* tmpElem = this->firstTrackElem->findByName(trackName);
 …
    @todo this must be better
 */
 void TrackManager::setSavePointS(const char* nextElementName)
+void TrackManager::setSavePointS(const std::string& nextElementName)
+{
   this->setSavePoint(NULL);
 …
   for(int i = 0; i < count; i++)
+    {
       this->firstTrackElem->findByID(trackIDs[i])->setName(va_arg(name, const char*));
+      this->firstTrackElem->findByID(trackIDs[i])->setName(va_arg(name, const std::string&));
+    }
   va_end(name);
 …
    \see TrackManager::fork(unsigned int count, ...)
 */
 void TrackManager::forkS(const char* forkString)
+void TrackManager::forkS(const std::string& forkString)
+{
   SubString strings(forkString, ',');
 …
   for(int i = 0; i < count; i++)
+    {
       const char* name = va_arg (NAME, char*);
+      const std::string& name = va_arg (NAME, char*);
       TrackElement* tmpElem = this->firstTrackElem->findByName(name);
       if (tmpElem)
 …
    \see void TrackManager::join(unsigned int count, ...)
 */
 void TrackManager::joinS(const char* joinString)
+void TrackManager::joinS(const std::string& joinString)
+{
   SubString strings(joinString, ',');
 …
   for(unsigned int i = 0; i < strings.getCount(); i++)
+    {
       TrackElement* tmpElem = this->firstTrackElem->findByName(strings.getString(i));
+      TrackElement* tmpElem = this->firstTrackElem->findByName(strings.getString(i).c_str());
       if (tmpElem != NULL)
         trackIDs[i] = tmpElem->ID;
       else
+      {
         PRINTF(1)("Trying to join a Track, of which the name does not exist: %s\n", strings.getString(i));
+        PRINTF(1)("Trying to join a Track, of which the name does not exist: %s\n", strings.getString(i).c_str());
         trackIDs[i] = -1;
+      }

trunk/src/util/track/track_manager.h

-                      r7130
+                      r7221
   TrackElement* findByID(unsigned int trackID);
   TrackElement* findByName(const char* trackName);
+  TrackElement* findByName(const std::string& trackName);
   bool backLoopCheck() const;
 …
   // Methods to change the Path (initialisation)
   void workOn(unsigned int trackID);
   void workOnS(const char* trackName);
+  void workOnS(const std::string& trackName);
   /** \see setCurveType(CurveType curveType, TrackElement* trackElem); @param curveType the type of the Curve */
 …
   void addHotPoint(float x, float y, float z);
   int addHotPointV(Vector newPoint, TrackElement* trackElem = NULL);
   void setSavePointS(const char* nextElementName);
+  void setSavePointS(const std::string& nextElementName);
   void setSavePoint(TrackElement* trackElem = NULL);
   void fork(unsigned int count, ...);
   void forkS(unsigned int count, ...);
   void forkS(const char* forkString);
+  void forkS(const std::string& forkString);
   void forkV(unsigned int count, int* trackIDs, char** trackNames, TrackElement* trackElem = NULL);
   void condition(unsigned int trackID, CONDITION cond, void* subject);
   void condition(CONDITION cond, void* subject, TrackElement* trackElem = NULL);
   void join(unsigned int count, ...);
   void joinS(const char* joinString);
+  void joinS(const std::string& joinString);
   void joinS(unsigned int cound, ...);
   void joinV(unsigned int count, int* trackIDs);

trunk/src/world_entities/creatures/md2_creature.cc

r7193	r7221
52	52	* @param fileName the name of the File to load the MD2Creature from (absolute path)
53	53	*/
54		MD2Creature::MD2Creature(const char* fileName)
	54	MD2Creature::MD2Creature(const std::string& fileName)
55	55	{
56	56	this->init();
…	…
59	59	if(!doc.LoadFile())
60	60	{
61		PRINTF(2)("Loading file %s failed for md2 creature.\n", fileName);
	61	PRINTF(2)("Loading file %s failed for md2 creature.\n", fileName.c_str());
62	62	return;
63	63	}
…	…
255	255	this->shiftCoor (move);
256	256
257		if( this->bJump)
	257	if( this->bJump && likely(this->getModel(0) != NULL))
258	258	{
259	259	((MD2Model*)this->getModel(0))->setAnim(JUMP);
260	260	}
261		else if( this->bFire)
	261	else if( this->bFire && likely(this->getModel(0) != NULL))
262	262	{
263	263	if( ((MD2Model)this->getModel(0))->getAnim() != ATTACK) ((MD2Model)this->getModel(0))->setAnim(ATTACK);
264	264	}
265		else if( fabs(move.len()) > 0.0f)
	265	else if( fabs(move.len()) > 0.0f && likely(this->getModel(0) != NULL))
266	266	{
267	267	if( ((MD2Model)this->getModel(0))->getAnim() != RUN) ((MD2Model)this->getModel(0))->setAnim(RUN);
268	268	}
269		else
	269	else if (likely(this->getModel(0) != NULL))
270	270	{
271	271	if( ((MD2Model)this->getModel(0))->getAnim() != STAND) ((MD2Model)this->getModel(0))->setAnim(STAND);

trunk/src/world_entities/creatures/md2_creature.h

r7092	r7221
19	19	public:
20	20
21		MD2Creature(const char* fileName);
	21	MD2Creature(const std::string& fileName);
22	22	MD2Creature(const TiXmlElement* root = NULL);
23	23	virtual ~MD2Creature();

trunk/src/world_entities/elements/image_entity.cc

r7193	r7221
106	106	* @param textureFile The texture-file to load onto the crosshair
107	107	*/
108		void ImageEntity::setTexture(const char* textureFile)
	108	void ImageEntity::setTexture(const std::string& textureFile)
109	109	{
110	110	this->material->setDiffuseMap(textureFile);

trunk/src/world_entities/elements/image_entity.h

r7016	r7221
30	30
31	31	void setSize(float sizeX, float sizeY);
32		void setTexture(const char* textureFile);
	32	void setTexture(const std::string& textureFile);
33	33	/** @param rotationSpeed the speed at what the crosshair should rotate */
34	34	void setRotationSpeed(float rotationSpeed) { this->rotationSpeed = rotationSpeed; };

trunk/src/world_entities/elements/text_element.cc

r7193	r7221
70	70	}
71	71
72		void TextElement::setText(const char* text)
	72	void TextElement::setText(const std::string& text)
73	73	{
74	74	Text::setText(text);
75	75	}
76	76
77		void TextElement::setFont(const char* font)
	77	void TextElement::setFont(const std::string& font)
78	78	{
79	79	Text::setFont(font, (unsigned int)this->getSizeY2D());

trunk/src/world_entities/elements/text_element.h

-                      r7019
+                      r7221
   virtual void loadParams(const TiXmlElement* root);
   void setText(const char* text);
   void setFont(const char* font);
+  void setText(const std::string& text);
+  void setFont(const std::string& font);
  private:

trunk/src/world_entities/movie_entity.cc

r7193	r7221
74	74	}
75	75
76		void MovieEntity::loadMovie(const char* filename)
	76	void MovieEntity::loadMovie(const std::string& filename)
77	77	{
78	78	if(media_container->loadMedia(filename))

trunk/src/world_entities/movie_entity.h

r7010	r7221
37	37	virtual void loadParams(const TiXmlElement* root);
38	38
39		void loadMovie(const char* filename);
	39	void loadMovie(const std::string& filename);
40	40	void setAxis(float axis);
41	41	void setRotation(float rotation);

trunk/src/world_entities/planet.cc

-                      r7193
+                      r7221
   this->toList(OM_GROUP_01);
-  this->material = new Material();
   //this->material->setIllum(20);
   //this->material->setAmbient(0.1, 0.1, 0.1);
 …
+{
   PRINTF(5)("Deleting Planet\n");
-  if( this->material)
-    delete this->material;
+}
 …
  * @param textureName the top texture.
 */
 void Planet::setTexture(const char* textureName)
+void Planet::setTexture(const std::string& textureName)
+{
   this->material->setDiffuseMap(textureName);
+  this->material.setDiffuseMap(textureName);
+}
 …
   glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
   this->material->select();
+  this->material.select();
 //   /WorldEntity::draw();

trunk/src/world_entities/planet.h

-                      r6959
+                      r7221
 /* INCLUDES */
 #include "world_entity.h"
+#include "material.h"
 /* FORWARD DECLARATION */
-class Material;
 class Texture;
 …
   void setSize(float size);
   /** assumes jpg as input-format */
   void setTexture(const char* textureName);
+  void setTexture(const std::string& textureName);
 …
  private:
   Material*       material;        //!< Materials for the Planet. sorted by number (0-5) top, bottom, left, right, front, back
+  Material        material;        //!< Materials for the Planet. sorted by number (0-5) top, bottom, left, right, front, back
   Texture*        texture;         //!< Textures for the CubeMap.

trunk/src/world_entities/power_ups/param_power_up.cc

-                      r7193
+                      r7221
+}
 void ParamPowerUp::setType(const char* type)
+void ParamPowerUp::setType(const std::string& type)
+{
   for(int i = 0; i < POWERUP_PARAM_size; ++i) {
     if(strcmp(type, paramTypes[i]) == 0) {
+    if(type == paramTypes[i]) {
       this->type = (EnumParamPowerUpType)i;
       break;

trunk/src/world_entities/power_ups/param_power_up.h

-                      r7065
+                      r7221
   void setMaxValue(float value);
   void setMinValue(float value);
   void setType(const char* type);
+  void setType(const std::string& type);
   EnumParamPowerUpType getType();
   float getValue();
 …
 private:
+  static const char* paramTypes[];
+  EnumParamPowerUpType type;
+  float value;
+  float max_value;
+  float min_value;
+  EnumParamPowerUpType    type;
+  float                   value;
+  float                   max_value;
+  float                   min_value;
+  static const char*      paramTypes[];
 };

trunk/src/world_entities/power_ups/power_up.cc

-                      r7193
+                      r7221
   this->respawnStart = 10;
   this->model = NULL;
 /*  if(!PowerUp::sphereModel) {*/
+  /*  if(!PowerUp::sphereModel) {*/
   Model* sphereModel = new PrimitiveModel(PRIM_SPHERE, 7, 5);
 …
 void PowerUp::loadPickupSound(const char* pickupSound)
+void PowerUp::loadPickupSound(const std::string& pickupSound)
+{
   if (this->pickupBuffer != NULL)
     ResourceManager::getInstance()->unload(this->pickupBuffer);
   else if (pickupSound != NULL)
+{
   this->pickupBuffer = (SoundBuffer*)ResourceManager::getInstance()->load(pickupSound, WAV);
   if (this->pickupBuffer != NULL)
+  {
     PRINTF(4)("Loaded sound %s to Pickup: %s.\n", pickupSound, this->getName());
+  }
   else
+  {
     PRINTF(2)("Failed to load sound %s to pickup %s.\n.", pickupSound, this->getName());
+  }
+}
+  else if (!pickupSound.empty())
+  {
+    this->pickupBuffer = (SoundBuffer*)ResourceManager::getInstance()->load(pickupSound, WAV);
+    if (this->pickupBuffer != NULL)
+    {
+      PRINTF(4)("Loaded sound %s to Pickup: %s.\n", pickupSound.c_str(), this->getName());
+    }
+    else
+    {
+      PRINTF(2)("Failed to load sound %s to pickup %s.\n.", pickupSound.c_str(), this->getName());
+    }
+  }
   else
     this->pickupBuffer = NULL;
+}
 void PowerUp::loadRespawnSound(const char* respawnSound)
+void PowerUp::loadRespawnSound(const std::string& respawnSound)
+{
   if (this->respawnBuffer != NULL)
     ResourceManager::getInstance()->unload(this->respawnBuffer);
   else if (respawnSound != NULL)
+  else if (!respawnSound.empty())
+  {
     this->respawnBuffer = (SoundBuffer*)ResourceManager::getInstance()->load(respawnSound, WAV);
     if (this->respawnBuffer != NULL)
+    {
       PRINTF(4)("Loaded sound %s to Pickup: %s.\n", respawnSound, this->getName());
+      PRINTF(4)("Loaded sound %s to Pickup: %s.\n", respawnSound.c_str(), this->getName());
+    }
     else
+    {
       PRINTF(2)("Failed to load sound %s to respawn %s.\n.", respawnSound, this->getName());
+      PRINTF(2)("Failed to load sound %s to respawn %s.\n.", respawnSound.c_str(), this->getName());
+    }
+  }
 …
         this->soundSource.play(this->pickupBuffer);
+      switch(respawnType) {
+        case RESPAWN_NONE:
+          this->toList(OM_DEAD);
+          break;
+        case RESPAWN_TIME:
+          this->toList(OM_DEAD_TICK);
+          this->respawnTime = this->respawnStart;
+          break;
+      switch(respawnType)
+      {
+      case RESPAWN_NONE:
+        this->toList(OM_DEAD);
+        break;
+      case RESPAWN_TIME:
+        this->toList(OM_DEAD_TICK);
+        this->respawnTime = this->respawnStart;
+        break;
+      }
+    }
 …
+}
+void PowerUp::tick(float dt) {
+  if(this->getOMListNumber() != OM_COMMON) {
+void PowerUp::tick(float dt)
+{
+  if(this->getOMListNumber() != OM_COMMON)
+  {
     this->respawnTime -= dt;
     if(this->respawnTime <= 0)
 …
 void PowerUp::draw() const
+{
+  if(this->model != NULL) {
+  if(this->model != NULL)
+  {
     glMatrixMode(GL_MODELVIEW);
     glPushMatrix();
 …
+}
+const char* PowerUp::respawnTypes[] = {
+  "none",
+  "time"
+};
+void PowerUp::setRespawnType(const char* type)
+{
+  for(int i = 0; i < RESPAWN_size; ++i) {
+    if(!strcmp(type, respawnTypes[i])) {
+const char* PowerUp::respawnTypes[] =
+  {
+    "none",
+    "time"
+  };
+void PowerUp::setRespawnType(const std::string& type)
+{
+  for(int i = 0; i < RESPAWN_size; ++i)
+  {
+    if(type == respawnTypes[i])
+    {
       this->respawnType = (PowerUpRespawn)i;
       break;

trunk/src/world_entities/power_ups/power_up.h

-                      r7102
+                      r7221
   void collidesWith (WorldEntity* entity, const Vector& location);
   void loadPickupSound(const char* pickupSound);
   void loadRespawnSound(const char* pickupSound);
+  void loadPickupSound(const std::string& pickupSound);
+  void loadRespawnSound(const std::string& respawnSound);
   virtual void draw () const;
   virtual void tick(float dt);
   void setRespawnType(const char* type);
+  void setRespawnType(const std::string& type);
   void setRespawnTime(const float respawn);
 …
 private:
   SoundSource    soundSource;
   SoundBuffer*   pickupBuffer;
   SoundBuffer*   respawnBuffer;
   Material* sphereMaterial;
   PowerUpRespawn respawnType;
   float respawnTime;
   float respawnStart;
   static const char* respawnTypes[];
+  SoundSource         soundSource;
+  SoundBuffer*        pickupBuffer;
+  SoundBuffer*        respawnBuffer;
+  Material*           sphereMaterial;
+  PowerUpRespawn      respawnType;
+  float               respawnTime;
+  float               respawnStart;
+  static const char*  respawnTypes[];
   WorldEntity* collider;
+  WorldEntity*        collider;
 };

trunk/src/world_entities/power_ups/weapon_power_up.cc

r7193	r7221
92	92	}
93	93
94		void WeaponPowerUp::setWeaponClass(const char* name)
	94	void WeaponPowerUp::setWeaponClass(const std::string& name)
95	95	{
96	96	this->weapon = dynamic_cast<Weapon*>(Factory::fabricate(name));
97	97	if (this->weapon == NULL)
98	98	{
99		PRINTF(1)("Unable to load Weapon. %s\n", name);
	99	PRINTF(1)("Unable to load Weapon. %s\n", name.c_str());
100	100	this->weapon = dynamic_cast<Weapon*>(Factory::fabricate("Turret"));
101	101	}

trunk/src/world_entities/power_ups/weapon_power_up.h

r7065	r7221
22	22
23	23	Weapon* getWeapon();
24		void setWeaponClass(const char* name);
	24	void setWeaponClass(const std::string& name);
25	25
26	26	virtual int writeBytes(const byte* data, int length, int sender);

trunk/src/world_entities/projectiles/projectile.cc

r7193	r7221
61	61
62	62
63		void Projectile::loadExplosionSound(const char* explosionSound)
	63	void Projectile::loadExplosionSound(const std::string& explosionSound)
64	64	{
65	65	if (this->explosionBuffer != NULL)
66	66	ResourceManager::getInstance()->unload(this->explosionBuffer);
67	67
68		else if (~~explosionSound != NULL~~)
	68	else if (!explosionSound.empty())
69	69	{
70	70	this->explosionBuffer = (SoundBuffer*)ResourceManager::getInstance()->load(explosionSound, WAV);
71	71	if (this->explosionBuffer != NULL)
72	72	{
73		PRINTF(4)("Loaded sound %s to Pickup: %s.\n", explosionSound, this->getName());
	73	PRINTF(4)("Loaded sound %s to Pickup: %s.\n", explosionSound.c_str(), this->getName());
74	74	}
75	75	else
76	76	{
77		PRINTF(2)("Failed to load sound %s to explosion %s.\n.", explosionSound, this->getName());
	77	PRINTF(2)("Failed to load sound %s to explosion %s.\n.", explosionSound.c_str(), this->getName());
78	78	}
79	79	}
…	…
83	83
84	84
85		void Projectile::loadEngineSound(const char* engineSound)
	85	void Projectile::loadEngineSound(const std::string& engineSound)
86	86	{
87	87	if (this->engineBuffer != NULL)
88	88	ResourceManager::getInstance()->unload(this->engineBuffer);
89	89
90		else if (~~engineSound != NULL~~)
	90	else if (!engineSound.empty())
91	91	{
92	92	this->engineBuffer = (SoundBuffer*)ResourceManager::getInstance()->load(engineSound, WAV);
93	93	if (this->engineBuffer != NULL)
94	94	{
95		PRINTF(4)("Loaded sound %s to Pickup: %s.\n", engineSound, this->getName());
	95	PRINTF(4)("Loaded sound %s to Pickup: %s.\n", engineSound.c_str(), this->getName());
96	96	}
97	97	else
98	98	{
99		PRINTF(2)("Failed to load sound %s to engine %s.\n.", engineSound, this->getName());
	99	PRINTF(2)("Failed to load sound %s to engine %s.\n.", engineSound.c_str(), this->getName());
100	100	}
101	101	}

trunk/src/world_entities/projectiles/projectile.h

-                      r7193
+                      r7221
     void setLifeSpan(float lifeSpan);
     void loadExplosionSound(const char* explosionSound);
     void loadEngineSound(const char* engineSound);
+    void loadExplosionSound(const std::string& explosionSound);
+    void loadEngineSound(const std::string& engineSound);
     void setMinEnergy(float energyMin);
     /** @returns the minimal charched energy */

trunk/src/world_entities/recorder.cc

-                      r7193
+                      r7221
   LoadParam(root, "duration", this, Recorder, setStreamDuration);
   LoadParam(root, "fps", this, Recorder, setFPS);
   LoadParam(root, "name", this, Recorder, initVideo);
+}
 …
 void Recorder::initVideo(const char* filename)
+void Recorder::initVideo(const std::string& filename)
+{
   frame_count = 0;
 …
   // auto detect the output format from the name, default is mpeg
   output_format = guess_format(NULL, filename, NULL);
+  output_format = guess_format(NULL, filename.c_str(), NULL);
   if (!output_format)
+  {
 …
   format_context->oformat = output_format;
   snprintf(format_context->filename, sizeof(format_context->filename), "%s", filename);
+  snprintf(format_context->filename, sizeof(format_context->filename), "%s", filename.c_str());
   // add video stream using the default format codec and initialize the codec
 …
   // print some information
   dump_format(format_context, 0, filename, 1);
+  dump_format(format_context, 0, filename.c_str(), 1);
   // now that all the parameters are set, we can open the
 …
   if(video_stream)
     this->openVideo();
   // open the output file, if needed
   if(!(output_format->flags & AVFMT_NOFILE))
+  {
     if(url_fopen(&format_context->pb, filename, URL_WRONLY) < 0)
       PRINTF(1)("Could not open %s\n", filename);
+    if(url_fopen(&format_context->pb, filename.c_str(), URL_WRONLY) < 0)
+      PRINTF(1)("Could not open %s\n", filename.c_str());
+  }
   // write the stream header, if any
   av_write_header(format_context);
+  av_write_header(format_context);
+}
 …
   av_free(buffer);
   // write the trailer, if any
+  // write the trailer, if any
   av_write_trailer(format_context);
   // free the streams
   for(int i = 0; i < format_context->nb_streams; i++)
 …
 void Recorder::allocPicture()
+{
+{
   picture = avcodec_alloc_frame();
   if(!picture)
 …
       return;
+  }
   avpicture_fill((AVPicture *)picture, picture_buf,
+  avpicture_fill((AVPicture *)picture, picture_buf,
                   codec_context->pix_fmt, width, height);
 …
   if (!video_stream)
     PRINTF(1)("Could not alloc stream\n");
   codec_context = video_stream->codec;
   codec_context->codec_id = output_format->video_codec;
 …
   codec_context->bit_rate = 400000;
   // resolution must be a multiple of two
   codec_context->width = State::getResX();
+  codec_context->width = State::getResX();
   codec_context->height = State::getResY();
 …
   // timebase should be 1/framerate and timestamp increments should be
   // identically 1
   codec_context->time_base.den = (int)stream_frame_rate;
+  codec_context->time_base.den = (int)stream_frame_rate;
   codec_context->time_base.num = 1;
   codec_context->gop_size = 12;  // emit one intra frame every twelve frames at most
 …
   if (codec_context->codec_id == CODEC_ID_MPEG1VIDEO)
       // needed to avoid using macroblocks in which some coeffs overflow
       // this doesnt happen with normal video, it just happens here as the
+      // needed to avoid using macroblocks in which some coeffs overflow
+      // this doesnt happen with normal video, it just happens here as the
       // motion of the chroma plane doesnt match the luma plane
       codec_context->mb_decision=2;
 …
+{
   int out_size, err;
   codec_context = video_stream->codec;
   if(frame_count >= stream_nb_frames)
+  {
 …
     this->fillYuvImage();
   if(format_context->oformat->flags & AVFMT_RAWPICTURE)
+  {
 …
     // futur for that
     av_init_packet(&packet);
     packet.flags |= PKT_FLAG_KEY;
     packet.stream_index= video_stream->index;
     packet.data= (uint8_t *)picture;
     packet.size= sizeof(AVPicture);
     err = av_write_frame(format_context, &packet);
+  }
 …
+    {
       av_init_packet(&packet);
       packet.pts= av_rescale_q(codec_context->coded_frame->pts, codec_context->time_base, video_stream->time_base);
       if(codec_context->coded_frame->key_frame)
 …
       packet.data= buffer;
       packet.size= out_size;
       // write the compressed frame in the media file
       err = av_write_frame(format_context, &packet);

trunk/src/world_entities/recorder.h

-                      r6981
+                      r7221
 class Recorder : public WorldEntity
+{
-  private:
-    AVFrame* picture;
-    uint8_t* buffer;
-    int frame_count;
-    int buffer_size;
-    AVOutputFormat* output_format;
-    AVFormatContext* format_context;
-    AVCodecContext* codec_context;
-    AVCodec *codec;
-    AVStream* video_stream;
-    AVPacket packet;
-    double video_pts;
-    uint8_t *picture_buf;
-    int size;
-    int height;
-    int width;
-    float time;
-    float stream_duration;
-    float stream_frame_rate;
-    int stream_nb_frames;
-AVFrame* RGB_frame;
   public:
     Recorder (const TiXmlElement* root = NULL);
 …
   private:
     void initVideo(const char* filename);
+    void initVideo(const std::string& filename);
     void addVideoStream();
     void openVideo();
 …
     void setStreamDuration(float duration);
     void setFPS(float fps);
+  private:
+    AVFrame*            picture;
+    uint8_t*            buffer;
+    int                 frame_count;
+    int                 buffer_size;
+    AVOutputFormat*     output_format;
+    AVFormatContext*    format_context;
+    AVCodecContext*     codec_context;
+    AVCodec*            codec;
+    AVStream*           video_stream;
+    AVPacket            packet;
+    double              video_pts;
+    uint8_t*            picture_buf;
+    int                 size;
+    int                 height;
+    int                 width;
+    float               time;
+    float               stream_duration;
+    float               stream_frame_rate;
+    int                 stream_nb_frames;
+    AVFrame*            RGB_frame;
 };

trunk/src/world_entities/skybox.cc

-                      r7193
+                      r7221
  * @param fileName the file to take as input for the SkyBox
 */
 SkyBox::SkyBox(const char* fileName)
+SkyBox::SkyBox(const std::string& fileName)
+{
   this->preInit();
   if (fileName)
+  if (!fileName.empty())
     this->setTextureAndType(fileName, ".jpg");
   this->postInit();
 …
   this->setParentMode(PNODE_MOVEMENT);
   this->textureName = NULL;
+  this->textureName = "";
+}
 …
   for (int i = 0; i < 6; i++)
+  {
     if( this->material[i])
+    if (this->material[i])
       delete this->material[i];
     if( this->cubeTexture[i])
+    if (this->cubeTexture[i])
       ResourceManager::getInstance()->unload(this->cubeTexture[i]);
+  }
+}
+void SkyBox::setTexture(const std::string& name)
+{
+  this->textureName = name;
+  this->setTextureAndType (name, "jpg");
+};
 /**
 …
                "skybox_right.jpg", "skybox_front.jpg", "skybox_back.jpg");
 */
+void SkyBox::setTextureAndType(const char* name, const char* extension)
+{
+  char* top    = new char[strlen(name)+strlen(extension)+ 10];
+  char* bottom = new char[strlen(name)+strlen(extension)+ 10];
+  char* left   = new char[strlen(name)+strlen(extension)+ 10];
+  char* right  = new char[strlen(name)+strlen(extension)+ 10];
+  char* front  = new char[strlen(name)+strlen(extension)+ 10];
+  char* back   = new char[strlen(name)+strlen(extension)+ 10];
+  sprintf(top, "%s_top.%s", name, extension);
+  sprintf(bottom, "%s_bottom.%s", name, extension);
+  sprintf(left, "%s_left.%s", name, extension);
+  sprintf(right, "%s_right.%s", name, extension);
+  sprintf(front, "%s_front.%s", name, extension);
+  sprintf(back, "%s_back.%s", name, extension);
+void SkyBox::setTextureAndType(const std::string& name, const std::string& extension)
+{
+  std::string top = name + "_top." + extension;
+  std::string bottom = name + "_bottom." + extension;
+  std::string left = name + "_left." + extension;
+  std::string right = name + "_right." + extension;
+  std::string front = name + "_front." + extension;
+  std::string back = name + "_back." + extension;
   this->setTextures(top, bottom, left, right, front, back);
-  // deleted alocated memory of this function
-  delete []top;
-  delete []bottom;
-  delete []left;
-  delete []right;
-  delete []front;
-  delete []back;
+}
 …
  * @param back the back texture.
 */
 void SkyBox::setTextures(const char* top, const char* bottom, const char* left,
                           const char* right, const char* front, const char* back)
+void SkyBox::setTextures(const std::string& top, const std::string& bottom, const std::string& left,
+                          const std::string& right, const std::string& front, const std::string& back)
+{
   this->material[0]->setDiffuseMap(top);
 …
+}
 void SkyBox::loadCubeMapTextures(const char* top, const char* bottom, const char* left,
                                   const char* right, const char* front, const char* back)
+void SkyBox::loadCubeMapTextures(const std::string& top, const std::string& bottom, const std::string& left,
+                                  const std::string& right, const std::string& front, const std::string& back)
+{
   this->cubeTexture[0] = (Texture*)ResourceManager::getInstance()->load(top, RP_LEVEL, IMAGE, GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT);
 …
   SYNCHELP_READ_FLOAT( size, NWT_SB_SIZE );
   if ( textureName )
+  if ( !this->textureName.empty() )
+  {
+    delete[] textureName;
+    textureName = NULL;
+    textureName = "";
+  }
+  SYNCHELP_READ_STRINGM( textureName, NWT_SB_TEXTURENAME );
+  char* texName;
+  SYNCHELP_READ_STRINGM( texName, NWT_SB_TEXTURENAME );
   this->setSize( size );
   this->setTextureAndType( textureName, "jpg" );
+  this->setTextureAndType( texName, "jpg" );
   this->rebuild();
 …
     SYNCHELP_WRITE_FLOAT(this->size, NWT_SB_SIZE);
     SYNCHELP_WRITE_STRING(this->textureName, NWT_SB_TEXTURENAME);
+    SYNCHELP_WRITE_STRING(this->textureName.c_str(), NWT_SB_TEXTURENAME);
     return SYNCHELP_WRITE_N;

trunk/src/world_entities/skybox.h

-                      r6771
+                      r7221
+{
  public:
   SkyBox(const char* fileName = NULL);
+  SkyBox(const std::string& fileName = "");
   SkyBox(const TiXmlElement* root);
 …
   void setSize(float size);
   /** assumes jpg as input-format */
   void setTexture(const char* name) { if (textureName) delete[] textureName; textureName = new char[strlen(name)+1]; strcpy(textureName, name); this->setTextureAndType (name, "jpg"); };
+  void setTexture(const std::string& name);
   void setTextureAndType(const char* name, const char* extension);
   void setTextures(const char* top, const char* bottom, const char* left,
                    const char* right, const char* front, const char* back);
+  void setTextureAndType(const std::string& name, const std::string& extension);
+  void setTextures(const std::string& top, const std::string& bottom, const std::string& left,
+                   const std::string& right, const std::string& front, const std::string& back);
   void loadCubeMapTextures(const char* top, const char* bottom, const char* left,
                            const char* right, const char* front, const char* back);
+  void loadCubeMapTextures(const std::string& top, const std::string& bottom, const std::string& left,
+                           const std::string& right, const std::string& front, const std::string& back);
   GLuint getTexture(SKY_SIDE side) const { return (this->material[side]) ? this->material[side]->getDiffuseTexture(): 0; };
 …
   float           size;            //!< Size of the SkyBox. This should match the frustum maximum range.
   float           textureSize;     //!< this is the length of a texture (assumes a square texture)
   char*           textureName;     //!< Name of the Texture
+  std::string     textureName;     //!< Name of the Texture
 };

trunk/src/world_entities/space_ships/helicopter.cc

-                      r7193
+                      r7221
  * @param fileName the name of the File to load the helicopter from (absolute path)
  */
 Helicopter::Helicopter(const char* fileName)
+Helicopter::Helicopter(const std::string& fileName)
+{
   this->init();
 …
   if(!doc.LoadFile())
+  {
     PRINTF(2)("Loading file %s failed for Helicopter.\n", fileName);
+    PRINTF(2)("Loading file %s failed for Helicopter.\n", fileName.c_str());
     return;
+  }
 …
   this->loadModel("models/ships/helicopter_#.obj", 1.0);
   EventHandler::getInstance()->grabEvents(true);
+  //EventHandler::getInstance()->grabEvents(true);
   bUp = bDown = bLeft = bRight = bAscend = bDescend = bRollL = bRollR = false;

trunk/src/world_entities/space_ships/helicopter.h

r7092	r7221
17	17
18	18	Helicopter();
19		Helicopter(const char* fileName);
	19	Helicopter(const std::string& fileName);
20	20	Helicopter(const TiXmlElement* root);
21	21	virtual ~Helicopter();

trunk/src/world_entities/space_ships/hover.cc

r7193	r7221
47	47	* @param fileName the name of the File to load the hover from (absolute path)
48	48	*/
49		Hover::Hover(const char* fileName)
	49	Hover::Hover(const std::string& fileName)
50	50	{
51	51	this->init();
…	…
54	54	if(!doc.LoadFile())
55	55	{
56		PRINTF(2)("Loading file %s failed for Hover.\n", fileName);
	56	PRINTF(2)("Loading file %s failed for Hover.\n", fileName.c_str());
57	57	return;
58	58	}

trunk/src/world_entities/space_ships/hover.h

r7092	r7221
14	14	public:
15	15
16		Hover(const char* fileName);
	16	Hover(const std::string& fileName);
17	17	Hover(const TiXmlElement* root = NULL);
18	18	virtual ~Hover();

trunk/src/world_entities/space_ships/space_ship.cc

r7193	r7221
69	69	* @param fileName the name of the File to load the spaceship from (absolute path)
70	70	*/
71		SpaceShip::SpaceShip(const char* fileName)
	71	SpaceShip::SpaceShip(const std::string& fileName)
72	72	{
73	73	this->init();
…	…
76	76	if(!doc.LoadFile())
77	77	{
78		PRINTF(2)("Loading file %s failed for spaceship.\n", fileName);
	78	PRINTF(2)("Loading file %s failed for spaceship.\n", fileName.c_str());
79	79	return;
80	80	}

trunk/src/world_entities/space_ships/space_ship.h

r7116	r7221
21	21
22	22	public:
23		SpaceShip(const char* fileName);
	23	SpaceShip(const std::string& fileName);
24	24	SpaceShip(const TiXmlElement* root = NULL);
25	25	virtual ~SpaceShip();

trunk/src/world_entities/space_ships/turbine_hover.cc

r7193	r7221
49	49	* @param fileName the name of the File to load the turbine_hover from (absolute path)
50	50	*/
51		TurbineHover::TurbineHover(const char* fileName)
	51	TurbineHover::TurbineHover(const std::string& fileName)
52	52	{
53	53	this->init();
…	…
56	56	if(!doc.LoadFile())
57	57	{
58		PRINTF(2)("Loading file %s failed for TurbineHover.\n", fileName);
	58	PRINTF(2)("Loading file %s failed for TurbineHover.\n", fileName.c_str());
59	59	return;
60	60	}

trunk/src/world_entities/space_ships/turbine_hover.h

r7092	r7221
18	18	public:
19	19
20		TurbineHover(const char* fileName);
	20	TurbineHover(const std::string& fileName);
21	21	TurbineHover(const TiXmlElement* root = NULL);
22	22	virtual ~TurbineHover();

trunk/src/world_entities/terrain.cc

-                      r7193
+                      r7221
     this->loadParams(root);
 //  if (this->model != NULL)
     //this->ssp = new SpatialSeparation((Model*)this->model, 10.0f);
+  //  if (this->model != NULL)
+  //this->ssp = new SpatialSeparation((Model*)this->model, 10.0f);
+}
 …
    this either loads out of an OBJ-file, or loads a heightmap if no .obj-extension is found.
 */
 Terrain::Terrain(const char* fileName)
+Terrain::Terrain(const std::string& fileName)
+{
   this->init();
   if (!strstr(fileName, ".obj") || !strstr(fileName, ".OBJ") )
+    {
       this->loadModel(fileName);
+    }
+  if (fileName.rfind(".obj" ) != -1 || fileName.rfind(".OBJ") != -1 )
+  {
+    this->loadModel(fileName);
+  }
   else
+    {
       // load the hightMap here.
+    }
+  {
+    // load the hightMap here.
+  }
+}
 …
   if(this->heightMap)
         delete heightMap;
+    delete heightMap;
+}
 …
   LoadParam(root, "scale", this, Terrain, setScale)
       .describe("The scale in x,y,z direction");
+  .describe("The scale in x,y,z direction");
   LoadParam(root, "texture", this, Terrain, loadTexture)
       .describe("The name of the Texture for this heightMap");
+  .describe("The name of the Texture for this heightMap");
   LoadParam(root, "vegetation", this, Terrain, loadVegetation)
       .describe("the fileName of the vegetation, that should be loaded onto this terrain. (must be relative to the data-dir)") ;
+  .describe("the fileName of the vegetation, that should be loaded onto this terrain. (must be relative to the data-dir)") ;
   LoadParam(root, "height-map", this, Terrain, loadHeightMap)
       .describe("The HeightMap, splitted into two strings seperated by ','. 1: HeighMap, 2: ColorMap");
+  .describe("The HeightMap, splitted into two strings seperated by ','. 1: HeighMap, 2: ColorMap");
+}
 …
+}
 void Terrain::loadHeightMap(const char* heightMapFile, const char* colorMap)
+void Terrain::loadHeightMap(const std::string& heightMapFile, const std::string& colorMap)
+{
   if (this->heightMap != NULL)
 …
   this->heightMap = NULL;
   char* hmName = ResourceManager::getFullName(heightMapFile);
   char* hmColorName = ResourceManager::getFullName(colorMap);
+  std::string hmName = ResourceManager::getFullName(heightMapFile);
+  std::string hmColorName = ResourceManager::getFullName(colorMap);
   this->heightMap = new HeightMap(hmName, hmColorName);
 //   heightMap->scale(Vector(43.0f,4.7f,43.0f));
+  //   heightMap->scale(Vector(43.0f,4.7f,43.0f));
   heightMap->scale(this->terrainScale);
   heightMap->setAbsCoor(this->getAbsCoor());
   heightMap->load();
+  delete[] hmName;
+  delete[] hmColorName;
+}
+void Terrain::loadTexture(const char* textureName)
+{
+   PRINTF(0)("Load texture: %s\n", textureName);
+   heightMapMaterial->setDiffuse(1.0,1.0,1.0);
+   heightMapMaterial->setAmbient(1.0,1.0,1.0 );
+   heightMapMaterial->setSpecular(1.0,1.0,1.0);
+   heightMapMaterial->setShininess(.5);
+   heightMapMaterial->setTransparency(1.0);
+   heightMapMaterial->setDiffuseMap(textureName);
+   heightMapMaterial->setAmbientMap(textureName);
+   heightMapMaterial->setSpecularMap(textureName);
+}
+void Terrain::loadVegetation(const char* vegetationFile)
+{
+  PRINTF(0)("loadVegetation: %s\n", vegetationFile);
+}
+void Terrain::loadTexture(const std::string& textureName)
+{
+  PRINTF(4)("Load texture: %s\n", textureName.c_str());
+  heightMapMaterial->setDiffuse(1.0,1.0,1.0);
+  heightMapMaterial->setAmbient(1.0,1.0,1.0 );
+  heightMapMaterial->setSpecular(1.0,1.0,1.0);
+  heightMapMaterial->setShininess(.5);
+  heightMapMaterial->setTransparency(1.0);
+  heightMapMaterial->setDiffuseMap(textureName);
+  //   heightMapMaterial->setAmbientMap(textureName);
+  //   heightMapMaterial->setSpecularMap(textureName);
+}
+void Terrain::loadVegetation(const std::string& vegetationFile)
+{
+  PRINTF(4)("loadVegetation: %s\n", vegetationFile.c_str());
   if (this->vegetation)
     ResourceManager::getInstance()->unload(this->vegetation, RP_LEVEL);
   if (vegetationFile != NULL)
+  {
     PRINTF(4)("fetching %s\n", vegetationFile);
+  if (!vegetationFile.empty())
+  {
+    PRINTF(4)("fetching %s\n", vegetationFile.c_str());
     this->vegetation = dynamic_cast<Model*>(ResourceManager::getInstance()->load(vegetationFile, OBJ, RP_CAMPAIGN));
+  }
 …
                 this->getAbsCoor ().z);
   /* rotate */
  // Vector tmpRot = this->getAbsDir().getSpacialAxis();
+  // Vector tmpRot = this->getAbsDir().getSpacialAxis();
   //glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
 …
 /*
   glMatrixMode(GL_MODELVIEW);
   glPushMatrix();
   glLoadIdentity();
   Vector camera =   State::getCameraNode()->getAbsCoor(); // Go on here ..........!!!
   float height =    heightMap->getHeight(camera.x, camera.z);
   glEnable (GL_COLOR_MATERIAL) ;
   glBegin(GL_QUADS);            // Draw The Cube Using quads
   glColor3f(0.0f,1.0f,0.0f);  // Color Blue
   glVertex3f(camera.x + 63.0f,Terrain->getHeight(camera.x+63.0f, camera.z-10.0f)+13.0f,camera.z-10.0f);      // Top Right Of The Quad (Top)
   glVertex3f(camera.x-63.0f, getHeight(camera.x+63.0f, camera.z-10.0f)+13.0f,camera.z-10.0f);      // Top Left Of The Quad (Top)
   glVertex3f(camera.x-63.0f, getHeight(camera.x+63.0f, camera.z+10.0f)+13.0f, camera.z+10.0f);      // Bottom Left Of The Quad (Top)
   glVertex3f(camera.x+ 63.0f, getHeight(camera.x+63.0f, camera.z+10.0f)+13.0f, camera.z+10.0f);      // Bottom Right Of The Quad (Top)
   glEnd();                      // End Drawing The Plan
   glPopMatrix();*/
 /* THIS IS ONLY FOR DEBUGGING INFORMATION */
+  /*
+    glMatrixMode(GL_MODELVIEW);
+    glPushMatrix();
+    glLoadIdentity();
+    Vector camera =   State::getCameraNode()->getAbsCoor(); // Go on here ..........!!!
+    float height =    heightMap->getHeight(camera.x, camera.z);
+    glEnable (GL_COLOR_MATERIAL) ;
+    glBegin(GL_QUADS);            // Draw The Cube Using quads
+    glColor3f(0.0f,1.0f,0.0f);  // Color Blue
+    glVertex3f(camera.x + 63.0f,Terrain->getHeight(camera.x+63.0f, camera.z-10.0f)+13.0f,camera.z-10.0f);      // Top Right Of The Quad (Top)
+    glVertex3f(camera.x-63.0f, getHeight(camera.x+63.0f, camera.z-10.0f)+13.0f,camera.z-10.0f);      // Top Left Of The Quad (Top)
+    glVertex3f(camera.x-63.0f, getHeight(camera.x+63.0f, camera.z+10.0f)+13.0f, camera.z+10.0f);      // Bottom Left Of The Quad (Top)
+    glVertex3f(camera.x+ 63.0f, getHeight(camera.x+63.0f, camera.z+10.0f)+13.0f, camera.z+10.0f);      // Bottom Right Of The Quad (Top)
+    glEnd();                      // End Drawing The Plan
+    glPopMatrix();*/
+  /* THIS IS ONLY FOR DEBUGGING INFORMATION */
   if (this->ssp != NULL)
     this->ssp->drawQuadtree();
 …
   // if the terrain is the Terrain of Dave
   if (debugTerrain == TERRAIN_DAVE)
+    {
       objectList = glGenLists(1);
       glNewList (objectList, GL_COMPILE);
       glColor3f(1.0,0,0);
       int sizeX = 100;
       int sizeZ = 80;
       float length = 1000;
       float width = 200;
       float widthX = float (length /sizeX);
       float widthZ = float (width /sizeZ);
       float height [sizeX][sizeZ];
       Vector normal_vectors[sizeX][sizeZ];
       for ( int i = 0; i<sizeX-1; i+=1)
         for (int j = 0; j<sizeZ-1;j+=1)
           //height[i][j] = rand()/20046 + (j-25)*(j-25)/30;
+  {
+    objectList = glGenLists(1);
+    glNewList (objectList, GL_COMPILE);
+    glColor3f(1.0,0,0);
+    int sizeX = 100;
+    int sizeZ = 80;
+    float length = 1000;
+    float width = 200;
+    float widthX = float (length /sizeX);
+    float widthZ = float (width /sizeZ);
+    float height [sizeX][sizeZ];
+    Vector normal_vectors[sizeX][sizeZ];
+    for ( int i = 0; i<sizeX-1; i+=1)
+      for (int j = 0; j<sizeZ-1;j+=1)
+        //height[i][j] = rand()/20046 + (j-25)*(j-25)/30;
 #ifdef __WIN32__
           height[i][j]=(sin((float)j/3)*rand()*i/182400)*.5;
+        height[i][j]=(sin((float)j/3)*rand()*i/182400)*.5;
 #else
       height[i][j]=(sin((float)j/3)*rand()*(long)i/6282450500.0)*.5;
+        height[i][j]=(sin((float)j/3)*rand()*(long)i/6282450500.0)*.5;
 #endif
+      //Die Huegel ein wenig glaetten
+      for (int h=1; h<2;h++)
+        for (int i=1;i<sizeX-2 ;i+=1 )
+          for(int j=1;j<sizeZ-2;j+=1)
+            height[i][j]=(height[i+1][j]+height[i][j+1]+height[i-1][j]+height[i][j-1])/4;
+      //Berechnung von normalen Vektoren
+      for(int i=1;i<sizeX-2;i+=1)
+        for(int j=1;j<sizeZ-2 ;j+=1)
+          {
+            Vector v1 = Vector (widthX*(1),      height[i][j],      widthZ*(j) );
+            Vector v2 = Vector (widthX*(i-1),    height[i-1][j],    widthZ*(j));
+            Vector v3 = Vector (widthX*(i),      height[i][j+1],    widthZ*(j+1));
+            Vector v4 = Vector (widthX*(i+1),    height[i+1][j],    widthZ*(j));
+            Vector v5 = Vector (widthX*(i),      height[i][j-1],    widthZ*(j-1));
+            Vector c1 = v2 - v1;
+            Vector c2 = v3 - v1;
+            Vector c3=  v4 - v1;
+            Vector c4 = v5 - v1;
+            Vector zero = Vector (0,0,0);
+            normal_vectors[i][j]=c1.cross(v3-v5)+c2.cross(v4-v2)+c3.cross(v5-v3)+c4.cross(v2-v4);
+            normal_vectors[i][j].normalize();
+          }
+      glBegin(GL_QUADS);
+      int snowheight=3;
+      for ( int i = 0; i<sizeX; i+=1)
+        for (int j = 0; j<sizeZ;j+=1)
+          {
+            Vector v1 = Vector (widthX*(i),      height[i][j]-20,       widthZ*(j)  -width/2);
+            Vector v2 = Vector (widthX*(i+1),    height[i+1][j]-20,     widthZ*(j)  -width/2);
+            Vector v3 = Vector (widthX*(i+1),    height[i+1][j+1]-20,   widthZ*(j+1)-width/2);
+            Vector v4 = Vector (widthX*(i),      height[i][j+1]-20,     widthZ*(j+1)-width/2);
+            float a[3];
+            if(height[i][j]<snowheight){
+              a[0]=0;
+              a[1]=1.0-height[i][j]/10-.3;
+              a[2]=0;
+              glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+            }
+            else{
+              a[0]=1.0;
+              a[1]=1.0;
+              a[2]=1.0;
+              glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+            }
+            glNormal3f(normal_vectors[i][j].x, normal_vectors[i][j].y, normal_vectors[i][j].z);
+            glVertex3f(v1.x, v1.y, v1.z);
+            if(height[i+1][j]<snowheight){
+              a[0]=0;
+              a[1] =1.0-height[i+1][j]/10-.3;
+              a[2]=0;
+              glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+            }
+            else{
+              a[0]=1.0;
+              a[1]=1.0;
+              a[2]=1.0;
+              glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+            }
+            glNormal3f(normal_vectors[i+1][j].x, normal_vectors[i+1][j].y, normal_vectors[i+1][j].z);
+            glVertex3f(v2.x, v2.y, v2.z);
+            if(height[i+1][j+1]<snowheight){
+              a[0]=0;
+              a[1] =1.0-height[i+1][j+1]/10-.3;
+              a[2]=0;
+              glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+            }
+            else{
+              a[0]=1.0;
+              a[1]=1.0;
+              a[2]=1.0;
+              glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+            }
+            glNormal3f(normal_vectors[i+1][j+1].x, normal_vectors[i+1][j+1].y, normal_vectors[i+1][j+1].z);
+            glVertex3f(v3.x, v3.y, v3.z);
+            if(height[i][j+1]<snowheight){
+              a[0]=0;
+              a[1] =1.0-height[i+1][j+1]/10-.3;
+              a[2]=0;
+              glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+            }
+            else{
+              a[0]=1.0;
+              a[1]=1.0;
+              a[2]=1.0;
+              glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+            }
+            glNormal3f(normal_vectors[i][j+1].x, normal_vectors[i][j+1].y, normal_vectors[i][j+1].z);
+            glVertex3f(v4.x, v4.y, v4.z);
+          }
+      glEnd();
+      glEndList();
+    }
+    //Die Huegel ein wenig glaetten
+    for (int h=1; h<2;h++)
+      for (int i=1;i<sizeX-2 ;i+=1 )
+        for(int j=1;j<sizeZ-2;j+=1)
+          height[i][j]=(height[i+1][j]+height[i][j+1]+height[i-1][j]+height[i][j-1])/4;
+    //Berechnung von normalen Vektoren
+    for(int i=1;i<sizeX-2;i+=1)
+      for(int j=1;j<sizeZ-2 ;j+=1)
+      {
+        Vector v1 = Vector (widthX*(1),      height[i][j],      widthZ*(j) );
+        Vector v2 = Vector (widthX*(i-1),    height[i-1][j],    widthZ*(j));
+        Vector v3 = Vector (widthX*(i),      height[i][j+1],    widthZ*(j+1));
+        Vector v4 = Vector (widthX*(i+1),    height[i+1][j],    widthZ*(j));
+        Vector v5 = Vector (widthX*(i),      height[i][j-1],    widthZ*(j-1));
+        Vector c1 = v2 - v1;
+        Vector c2 = v3 - v1;
+        Vector c3=  v4 - v1;
+        Vector c4 = v5 - v1;
+        Vector zero = Vector (0,0,0);
+        normal_vectors[i][j]=c1.cross(v3-v5)+c2.cross(v4-v2)+c3.cross(v5-v3)+c4.cross(v2-v4);
+        normal_vectors[i][j].normalize();
+      }
+    glBegin(GL_QUADS);
+    int snowheight=3;
+    for ( int i = 0; i<sizeX; i+=1)
+      for (int j = 0; j<sizeZ;j+=1)
+      {
+        Vector v1 = Vector (widthX*(i),      height[i][j]-20,       widthZ*(j)  -width/2);
+        Vector v2 = Vector (widthX*(i+1),    height[i+1][j]-20,     widthZ*(j)  -width/2);
+        Vector v3 = Vector (widthX*(i+1),    height[i+1][j+1]-20,   widthZ*(j+1)-width/2);
+        Vector v4 = Vector (widthX*(i),      height[i][j+1]-20,     widthZ*(j+1)-width/2);
+        float a[3];
+        if(height[i][j]<snowheight)
+        {
+          a[0]=0;
+          a[1]=1.0-height[i][j]/10-.3;
+          a[2]=0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+        }
+        else
+        {
+          a[0]=1.0;
+          a[1]=1.0;
+          a[2]=1.0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+        }
+        glNormal3f(normal_vectors[i][j].x, normal_vectors[i][j].y, normal_vectors[i][j].z);
+        glVertex3f(v1.x, v1.y, v1.z);
+        if(height[i+1][j]<snowheight)
+        {
+          a[0]=0;
+          a[1] =1.0-height[i+1][j]/10-.3;
+          a[2]=0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+        }
+        else
+        {
+          a[0]=1.0;
+          a[1]=1.0;
+          a[2]=1.0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+        }
+        glNormal3f(normal_vectors[i+1][j].x, normal_vectors[i+1][j].y, normal_vectors[i+1][j].z);
+        glVertex3f(v2.x, v2.y, v2.z);
+        if(height[i+1][j+1]<snowheight)
+        {
+          a[0]=0;
+          a[1] =1.0-height[i+1][j+1]/10-.3;
+          a[2]=0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+        }
+        else
+        {
+          a[0]=1.0;
+          a[1]=1.0;
+          a[2]=1.0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+        }
+        glNormal3f(normal_vectors[i+1][j+1].x, normal_vectors[i+1][j+1].y, normal_vectors[i+1][j+1].z);
+        glVertex3f(v3.x, v3.y, v3.z);
+        if(height[i][j+1]<snowheight)
+        {
+          a[0]=0;
+          a[1] =1.0-height[i+1][j+1]/10-.3;
+          a[2]=0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+        }
+        else
+        {
+          a[0]=1.0;
+          a[1]=1.0;
+          a[2]=1.0;
+          glMaterialfv(GL_FRONT,GL_DIFFUSE,a);
+        }
+        glNormal3f(normal_vectors[i][j+1].x, normal_vectors[i][j+1].y, normal_vectors[i][j+1].z);
+        glVertex3f(v4.x, v4.y, v4.z);
+      }
+    glEnd();
+    glEndList();
+  }
   if (debugTerrain == TERRAIN_BENSCH)
+    {
       /*
         this->model = (OBJModel*) new Model();
       this->model->setName("CUBE");
       this->model->addVertex (-0.5, -0.5, 0.5);
       this->model->addVertex (0.5, -0.5, 0.5);
       this->model->addVertex (-0.5, 0.5, 0.5);
       this->model->addVertex (0.5, 0.5, 0.5);
       this->model->addVertex (-0.5, 0.5, -0.5);
       this->model->addVertex (0.5, 0.5, -0.5);
       this->model->addVertex (-0.5, -0.5, -0.5);
       this->model->addVertex (0.5, -0.5, -0.5);
       this->model->addVertexTexture (0.0, 0.0);
       this->model->addVertexTexture (1.0, 0.0);
       this->model->addVertexTexture (0.0, 1.0);
       this->model->addVertexTexture (1.0, 1.0);
       this->model->addVertexTexture (0.0, 2.0);
       this->model->addVertexTexture (1.0, 2.0);
       this->model->addVertexTexture (0.0, 3.0);
       this->model->addVertexTexture (1.0, 3.0);
       this->model->addVertexTexture (0.0, 4.0);
       this->model->addVertexTexture (1.0, 4.0);
       this->model->addVertexTexture (2.0, 0.0);
       this->model->addVertexTexture (2.0, 1.0);
       this->model->addVertexTexture (-1.0, 0.0);
       this->model->addVertexTexture (-1.0, 1.0);
       this->model->finalize();
       */
+    }
+  {
+    /*
+      this->model = (OBJModel*) new Model();
+    this->model->setName("CUBE");
+    this->model->addVertex (-0.5, -0.5, 0.5);
+    this->model->addVertex (0.5, -0.5, 0.5);
+    this->model->addVertex (-0.5, 0.5, 0.5);
+    this->model->addVertex (0.5, 0.5, 0.5);
+    this->model->addVertex (-0.5, 0.5, -0.5);
+    this->model->addVertex (0.5, 0.5, -0.5);
+    this->model->addVertex (-0.5, -0.5, -0.5);
+    this->model->addVertex (0.5, -0.5, -0.5);
+    this->model->addVertexTexture (0.0, 0.0);
+    this->model->addVertexTexture (1.0, 0.0);
+    this->model->addVertexTexture (0.0, 1.0);
+    this->model->addVertexTexture (1.0, 1.0);
+    this->model->addVertexTexture (0.0, 2.0);
+    this->model->addVertexTexture (1.0, 2.0);
+    this->model->addVertexTexture (0.0, 3.0);
+    this->model->addVertexTexture (1.0, 3.0);
+    this->model->addVertexTexture (0.0, 4.0);
+    this->model->addVertexTexture (1.0, 4.0);
+    this->model->addVertexTexture (2.0, 0.0);
+    this->model->addVertexTexture (2.0, 1.0);
+    this->model->addVertexTexture (-1.0, 0.0);
+    this->model->addVertexTexture (-1.0, 1.0);
+    this->model->finalize();
+    */
+  }
+}
 …
 void Terrain::writeDebug( ) const
+{
+}
+  {}
 void Terrain::readDebug( ) const
+{
+}
+  {}
 float Terrain::getHeight(float x, float y)
+{
         if(this->heightMap != NULL)
                 return (this->heightMap->getHeight(x, y));
         return 0;
+}
+  if(this->heightMap != NULL)
+    return (this->heightMap->getHeight(x, y));
+  return 0;
+}

trunk/src/world_entities/terrain.h

-                      r7046
+                      r7221
  public:
   Terrain(const TiXmlElement* root = NULL);
   Terrain(const char* fileName);
+  Terrain(const std::string& fileName);
   Terrain(DebugTerrain debugTerrain);
   virtual ~Terrain();
 …
   virtual void loadParams(const TiXmlElement* root);
   void loadVegetation(const char* vegetationFile);
+  void loadVegetation(const std::string& vegetationFile);
   void loadHeightMap(const char* heightMapFile, const char* colorMap = NULL);
   void loadTexture(const char* textureName);
+  void loadHeightMap(const std::string& heightMapFile, const std::string& colorMap);
+  void loadTexture(const std::string& textureName);
   void setScale(float x, float y, float z);

trunk/src/world_entities/weapons/aim.cc

r7193	r7221
147	147	* @param textureFile The texture-file to load onto the crosshair
148	148	*/
149		void Aim::setTexture(const char* textureFile)
	149	void Aim::setTexture(const std::string& textureFile)
150	150	{
151	151	this->material->setDiffuseMap(textureFile);

trunk/src/world_entities/weapons/aim.h

r6724	r7221
46	46
47	47	void setSize(float size);
48		void setTexture(const char* textureFile);
	48	void setTexture(const std::string& textureFile);
49	49	/** @param rotationSpeed the speed at what the crosshair should rotate */
50	50	inline void setRotationSpeed(float rotationSpeed) { this->rotationSpeed = rotationSpeed; };

trunk/src/world_entities/weapons/aiming_turret.cc

-                      r7193
+                      r7221
   glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
+  this->getModel()->draw();
+  if (this->getModel())
+    this->getModel()->draw();
   glPopMatrix();
+}

trunk/src/world_entities/weapons/crosshair.cc

-                      r7193
+                      r7221
   EventListener::loadParams(root);
   LoadParam(root, "texture", this, Crosshair, setTexture)
+  LoadParam(root, "texture", this->material, Material, setDiffuseMap)
       .describe("the texture-file to load onto the Crosshair");
 …
  * @param textureFile The texture-file to load onto the crosshair
  */
 void Crosshair::setTexture(const char* textureFile)
+void Crosshair::setTexture(const std::string& textureFile)
+{
   this->material->setDiffuseMap(textureFile);

trunk/src/world_entities/weapons/crosshair.h

r6512	r7221
31	31
32	32	void setSize(float size);
33		void setTexture(const char* textureFile);
	33	void setTexture(const std::string& textureFile);
34	34	/** @param rotationSpeed the speed at what the crosshair should rotate */
35	35	void setRotationSpeed(float rotationSpeed) { this->rotationSpeed = rotationSpeed; };

trunk/src/world_entities/weapons/weapon.cc

-                      r7193
+                      r7221
  * @param projectile the Name of the Projectile.
  */
+void Weapon::setProjectileTypeC(const char* projectile)
+{
+  if (projectile == NULL)
+    return;
+void Weapon::setProjectileTypeC(const std::string& projectile)
+{
   FastFactory* tmpFac = FastFactory::searchFastFactory(projectile);
   if (tmpFac != NULL)
 …
   else
+  {
     PRINTF(1)("Projectile %s does not exist for weapon %s\n", projectile, this->getName());
+    PRINTF(1)("Projectile %s does not exist for weapon %s\n", projectile.c_str(), this->getName());
+  }
+}
 …
  * @param soundFile the soundFile's relative position to the data-directory (will be looked for by the ResourceManager)
  */
 void Weapon::setActionSound(WeaponAction action, const char* soundFile)
+void Weapon::setActionSound(WeaponAction action, const std::string& soundFile)
+{
   if (action >= WA_ACTION_COUNT)
 …
     ResourceManager::getInstance()->unload(this->soundBuffers[action]);
   else if (soundFile != NULL)
+  else if (!soundFile.empty())
+  {
     this->soundBuffers[action] = (SoundBuffer*)ResourceManager::getInstance()->load(soundFile, WAV);
     if (this->soundBuffers[action] != NULL)
+    {
       PRINTF(4)("Loaded sound %s to action %s.\n", soundFile, actionToChar(action));
+      PRINTF(4)("Loaded sound %s to action %s.\n", soundFile.c_str(), actionToChar(action));
+    }
     else
+    {
       PRINTF(2)("Failed to load sound %s to %s.\n.", soundFile, actionToChar(action));
+      PRINTF(2)("Failed to load sound %s to %s.\n.", soundFile.c_str(), actionToChar(action));
+    }
+  }
 …
  * @return The Action if known, WA_NONE otherwise.
  */
 WeaponAction Weapon::charToAction(const char* action)
+{
   if (!strcmp(action, "none"))
+WeaponAction Weapon::charToAction(const std::string& action)
+{
+  if (action == "none")
     return WA_NONE;
   else if (!strcmp(action, "shoot"))
+  else if (action == "shoot")
     return WA_SHOOT;
   else if (!strcmp(action, "charge"))
+  else if (action == "charge")
     return WA_CHARGE;
   else if (!strcmp(action, "reload"))
+  else if (action == "reload")
     return WA_RELOAD;
   else if (!strcmp(action, "acitvate"))
+  else if (action == "acitvate")
     return WA_ACTIVATE;
   else if (!strcmp(action, "deactivate"))
+  else if (action == "deactivate")
     return WA_DEACTIVATE;
   else if (!strcmp(action, "special1"))
+  else if (action == "special1")
     return WA_SPECIAL1;
   else
+  {
     PRINTF(2)("action %s could not be identified.\n", action);
+    PRINTF(2)("action %s could not be identified.\n", action.c_str());
     return WA_NONE;
+  }
 …
  * @return The State if known, WS_NONE otherwise.
  */
 WeaponState Weapon::charToState(const char* state)
+{
   if (!strcmp(state, "none"))
+WeaponState Weapon::charToState(const std::string& state)
+{
+  if (state == "none")
     return WS_NONE;
   else if (!strcmp(state, "shooting"))
+  else if (state == "shooting")
     return WS_SHOOTING;
   else if (!strcmp(state, "charging"))
+  else if (state == "charging")
     return WS_CHARGING;
   else if (!strcmp(state, "reloading"))
+  else if (state == "reloading")
     return WS_RELOADING;
   else if (!strcmp(state, "activating"))
+  else if (state == "activating")
     return WS_ACTIVATING;
   else if (!strcmp(state, "deactivating"))
+  else if (state == "deactivating")
     return WS_DEACTIVATING;
   else if (!strcmp(state, "inactive"))
+  else if (state == "inactive")
     return WS_INACTIVE;
   else if (!strcmp(state, "idle"))
+  else if (state == "idle")
     return WS_IDLE;
   else
+  {
     PRINTF(2)("state %s could not be identified.\n", state);
+    PRINTF(2)("state %s could not be identified.\n", state.c_str());
     return WS_NONE;
+  }

trunk/src/world_entities/weapons/weapon.h

-                      r7102
+                      r7221
     inline long getCapability() const { return this->capability; };
     void setProjectileType(ClassID projectile);
     void setProjectileTypeC(const char* projectile);
+    void setProjectileTypeC(const std::string& projectile);
     /** @returns The projectile's classID */
     inline ClassID getProjectileType() { return this->projectile; };
 …
     // STATE CHANGES //
     /** @param state the State to time @param duration the duration of the State */
     inline void setStateDuration(const char* state, float duration) { setStateDuration(charToState(state), duration); };
+    inline void setStateDuration(const std::string& state, float duration) { setStateDuration(charToState(state), duration); };
     /** @param state the State to time @param duration the duration of the State */
     inline void setStateDuration(WeaponState state, float duration) { /*(state < WS_STATE_COUNT)?*/this->times[state] = duration; };
 …
     inline void setAmmoContainer(const CountPointer<AmmoContainer>& ammoContainer) { this->ammoContainer = ammoContainer;}
     void setActionSound(WeaponAction action, const char* soundFile);
     /** @see void setActionSound(WeaponAction action, const char* soundFile); */
     void setActionSound(const char* action, const char* soundFile) { this->setActionSound(charToAction(action), soundFile); };
+    void setActionSound(WeaponAction action, const std::string& soundFile);
+    /** @see void setActionSound(WeaponAction action, const std::string& soundFile); */
+    void setActionSound(const std::string& action, const std::string& soundFile) { this->setActionSound(charToAction(action), soundFile); };
     Animation3D* getAnimation(WeaponState state, PNode* node = NULL);
 …
     // utility:
     static WeaponAction  charToAction(const char* action);
+    static WeaponAction  charToAction(const std::string& action);
     static const char*   actionToChar(WeaponAction action);
     static WeaponState   charToState(const char* state);
+    static WeaponState   charToState(const std::string& state);
     static const char*   stateToChar(WeaponState state);

trunk/src/world_entities/world_entity.cc

-                      r7198
+                      r7221
   this->bCollide = true;
-  this->md2TextureFileName = NULL;
   this->objectListNumber = OM_INIT;
   this->objectListIterator = NULL;
 …
  * @param fileName the name of the model to load
  * @param scaling the Scaling of the model
+ *
+ * @todo fix this, so it only has one loadModel-Function.
+*/
+void WorldEntity::loadModel(const char* fileName, float scaling, unsigned int modelNumber)
+ */
+void WorldEntity::loadModel(const std::string& fileName, float scaling, unsigned int modelNumber)
+{
   this->modelLODName = fileName;
   this->scaling = scaling;
   if ( fileName != NULL && strcmp(fileName, "") )
+  if (!fileName.empty())
+  {
     // search for the special character # in the LoadParam
+    if (strchr(fileName, '#') != NULL)
+    {
+      PRINTF(4)("Found # in %s... searching for LOD's\n", fileName);
+      char* lodFile = new char[strlen(fileName)+1];
+      strcpy(lodFile, fileName);
+      char* depth = strchr(lodFile, '#');
+    if (fileName.find('#') != std::string::npos)
+    {
+      PRINTF(4)("Found # in %s... searching for LOD's\n", fileName.c_str());
+      std::string lodFile = fileName;
+      unsigned int offset = lodFile.find('#');
       for (unsigned int i = 0; i < 3; i++)
+      {
         *depth = 48+(int)i;
+        lodFile[offset] = 48+(int)i;
         if (ResourceManager::isInDataDir(lodFile))
           this->loadModel(lodFile, scaling, i);
 …
       this->scaling = 1.0;
+    }
     if(strstr(fileName, ".obj"))
+    {
       PRINTF(4)("fetching OBJ file: %s\n", fileName);
+    if(fileName.find(".obj") != std::string::npos)
+    {
+      PRINTF(4)("fetching OBJ file: %s\n", fileName.c_str());
       BaseObject* loadedModel = ResourceManager::getInstance()->load(fileName, OBJ, RP_CAMPAIGN, this->scaling);
       if (loadedModel != NULL)
         this->setModel(dynamic_cast<Model*>(loadedModel), modelNumber);
+      else
+        PRINTF(1)("OBJ-File %s not found.\n", fileName.c_str());
       if( modelNumber == 0)
         this->buildObbTree(4);
+    }
     else if(strstr(fileName, ".md2"))
+    {
       PRINTF(4)("fetching MD2 file: %s\n", fileName);
+    else if(fileName.find(".md2") != std::string::npos)
+    {
+      PRINTF(4)("fetching MD2 file: %s\n", fileName.c_str());
       Model* m = new MD2Model(fileName, this->md2TextureFileName, this->scaling);
       //this->setModel((Model*)ResourceManager::getInstance()->load(fileName, MD2, RP_CAMPAIGN), 0);
 …
     char* name = (char*)(getModel( 0 )->getName());
     if ( strstr(name, ResourceManager::getInstance()->getDataDir()) )
+    {
       name += strlen(ResourceManager::getInstance()->getDataDir());
+    if (  ResourceManager::getInstance()->getDataDir() == name ) /// FIXME (do not know what to do here.)
+    {
+      name += ResourceManager::getInstance()->getDataDir().size();
+    }

trunk/src/world_entities/world_entity.h

-                      r7095
+                      r7221
   virtual void loadParams(const TiXmlElement* root);
   void loadModel(const char* fileName, float scaling = 1.0f, unsigned int modelNumber = 0);
+  void loadModel(const std::string& fileName, float scaling = 1.0f, unsigned int modelNumber = 0);
   void setModel(Model* model, unsigned int modelNumber = 0);
   Model* getModel(unsigned int modelNumber = 0) const { return (this->models.size() > modelNumber)? this->models[modelNumber] : NULL; };
   inline void loadMD2Texture(const char* fileName) { this->md2TextureFileName = fileName; }
+  inline void loadMD2Texture(const std::string& fileName) { this->md2TextureFileName = fileName; }
   bool buildObbTree(unsigned int depth);
 …
   std::vector<Model*>     models;             //!< The model that should be loaded for this entity.
   const char*             md2TextureFileName; //!< the file name of the md2 model texture, only if this
   const char*             modelLODName;       //!< the name of the model lod file
+  std::string             md2TextureFileName; //!< the file name of the md2 model texture, only if this
+  std::string             modelLODName;       //!< the name of the model lod file
   BVTree*                 obbTree;            //!< this is the obb tree reference needed for collision detection

Context Navigation

Changeset 7221 in orxonox.OLD for trunk/src

Legend: