Index: trunk/src/lib/shell/shell.cc
===================================================================
--- trunk/src/lib/shell/shell.cc	(revision 7201)
+++ trunk/src/lib/shell/shell.cc	(revision 7221)
@@ -85,6 +85,5 @@
   this->lineSpacing = 0;
   this->bActive = true;
-  this->fontFile = new char[strlen(SHELL_DEFAULT_FONT)+1];
-  strcpy(this->fontFile, SHELL_DEFAULT_FONT);
+  this->fontFile = SHELL_DEFAULT_FONT;
 
 
@@ -110,5 +109,4 @@
     delete this->bufferText[i];
   delete[] this->bufferText;
-  delete[] this->fontFile;
   // delete the inputLine
   delete this->shellInput;
@@ -139,5 +137,5 @@
     if (!top)
     {
-      this->bufferText[i]->setText((*textLine), true);
+      this->bufferText[i]->setText((*textLine));
     if (textLine != ShellBuffer::getInstance()->getBuffer()->begin())
       top = true;
@@ -167,5 +165,5 @@
     if (textLine != ShellBuffer::getInstance()->getBuffer()->begin())
     {
-      this->bufferText[i]->setText((*textLine), false);
+      this->bufferText[i]->setText((*textLine));
       textLine--;
     }
@@ -181,14 +179,10 @@
  * (be aware that within orxonox fontFile is relative to the Data-Dir)
  */
-void Shell::setFont(const char* fontFile)
+void Shell::setFont(const std::string& fontFile)
 {
 //   if (!ResourceManager::isInDataDir(fontFile))
 //     return false;
 
-  if (this->fontFile != NULL)
-    delete[] this->fontFile;
-
-  this->fontFile = new char[strlen(fontFile)+1];
-  strcpy(this->fontFile, fontFile);
+  this->fontFile = fontFile;
 
   this->rebuildText();
@@ -245,5 +239,5 @@
  * @param fileName the filename of the Image to load
  */
-void Shell::setBackgroundImage(const char* fileName)
+void Shell::setBackgroundImage(const std::string& fileName)
 {
   this->backgroundMaterial->setDiffuseMap(fileName);
@@ -340,5 +334,5 @@
     for (int i = 0; i < this->bufferDisplaySize; i++)
     {
-      this->bufferText[i]->setText(NULL, true);
+      this->bufferText[i]->setText("");
     }
 
@@ -351,5 +345,5 @@
  * @param text the text to output.
  */
-void Shell::printToDisplayBuffer(const char* text)
+void Shell::printToDisplayBuffer(const std::string& text)
 {
   if(likely(bufferText != NULL))
@@ -382,5 +376,5 @@
     this->bufferText[0] = lastText;
 
-    this->bufferText[0]->setText(text, true);
+    this->bufferText[0]->setText(text);
   }
 }
@@ -427,5 +421,5 @@
   for (unsigned int i = 0; i < this->bufferDisplaySize; i++)
   {
-    this->bufferText[i]->setText((*it), false);
+    this->bufferText[i]->setText((*it));
     it--;
   }
Index: trunk/src/lib/shell/shell.h
===================================================================
--- trunk/src/lib/shell/shell.h	(revision 7201)
+++ trunk/src/lib/shell/shell.h	(revision 7221)
@@ -53,9 +53,9 @@
     inline bool isActive() const { return this->bActive; };
 
-    void setFont(const char* fontFile);
+    void setFont(const std::string& fontFile);
     void setTextSize(unsigned int textSize, unsigned int lineSpacing = 1);
     void setTextColor(float r, float g, float b, float a);
     void setBackgroundColor(float r, float g, float b, float a);
-    void setBackgroundImage(const char* fileName);
+    void setBackgroundImage(const std::string& fileName);
 
     void resetValues();
@@ -64,5 +64,5 @@
     // BUFFERS
     void setBufferDisplaySize(unsigned int bufferDisplaySize);
-    void printToDisplayBuffer(const char* text);
+    void printToDisplayBuffer(const std::string& text);
     void moveDisplayBuffer(int lineCount);
 
@@ -83,8 +83,8 @@
 
     //     void testI (int i);
-    //     void testS (const char* s);
+    //     void testS (const std::string& s);
     //     void testB (bool b);
     //     void testF (float f);
-    //     void testSF (const char* s, float f);
+    //     void testSF (const std::string& s, float f);
 
   private:
@@ -95,5 +95,5 @@
     unsigned int                textSize;               //!< The size of the text.
     float                       textColor[4];           //!< The text's color [r,g,b,a].
-    char*                       fontFile;               //!< The file containing the font.
+    std::string                 fontFile;               //!< The file containing the font.
     Material*                   backgroundMaterial;     //!< A material for the background.
 
Index: trunk/src/lib/shell/shell_command.cc
===================================================================
--- trunk/src/lib/shell/shell_command.cc	(revision 7201)
+++ trunk/src/lib/shell/shell_command.cc	(revision 7221)
@@ -41,6 +41,4 @@
   PRINTF(5)("create shellcommand %s %s\n", commandName, className);
   this->setName(commandName);
-  this->description = NULL;
-  this->alias = NULL;
   this->executor = executor.clone();
   this->executor->setName(commandName);
@@ -153,5 +151,5 @@
  * @return true on success, false otherwise.
  */
-bool ShellCommand::execute(const char* executionString)
+bool ShellCommand::execute(const std::string& executionString)
 {
   if (ShellCommandClass::commandClassList == NULL)
@@ -177,5 +175,5 @@
       for (alias = ShellCommandClass::aliasList->begin(); alias != ShellCommandClass::aliasList->end(); alias++ )
       {
-        if ((*alias)->getName() != NULL && !strcmp((*alias)->getName(), inputSplits.getString(0)) && (*alias)->getCommand() != NULL &&
+        if (inputSplits.getString(0) == (*alias)->getName() && (*alias)->getCommand() != NULL &&
             (*alias)->getCommand()->shellClass != NULL )
         {
@@ -184,5 +182,8 @@
           {
             if (inputSplits.getCount() > 1)
-              (*alias)->getCommand()->executor->execute(objectList->front(), executionString+inputSplits.getOffset(1));
+            {
+
+              (*alias)->getCommand()->executor->execute(objectList->front(), executionString.substr(inputSplits.getOffset(1))); /// TODO CHECK IF OK
+            }
             else
               (*alias)->getCommand()->executor->execute(objectList->front(), "");
@@ -198,5 +199,5 @@
       for (commandClassIT = ShellCommandClass::commandClassList->begin(); commandClassIT != ShellCommandClass::commandClassList->end(); commandClassIT++)
       {
-        if ((*commandClassIT)->getName() && !strcasecmp(inputSplits.getString(0), (*commandClassIT)->getName()))
+        if ((*commandClassIT)->getName() && inputSplits.getString(0) == (*commandClassIT)->getName())
         {
           //elemCL->getName();
@@ -217,5 +218,5 @@
         for (object = objectList->begin(); object != objectList->end(); object++)
         {
-          if ((*object)->getName() != NULL && !strcasecmp((*object)->getName(), inputSplits.getString(1)))
+          if ((*object)->getName() != NULL && inputSplits.getString(1) == (*object)->getName() )
           {
             objectPointer = (*object);
@@ -235,10 +236,10 @@
         for (cmdIT = commandClass->commandList.begin(); cmdIT != commandClass->commandList.end(); cmdIT++)
         {
-          if (!strcmp((*cmdIT)->getName(), inputSplits.getString(fktPos)))
+          if (inputSplits.getString(fktPos) == (*cmdIT)->getName())
           {
             if (objectPointer == NULL && (*cmdIT)->executor->getType() & Executor_Objective)
               return false;
             if (inputSplits.getCount() > fktPos+1)
-              (*cmdIT)->executor->execute(objectPointer, executionString+inputSplits.getOffset(fktPos +1));
+              (*cmdIT)->executor->execute(objectPointer, executionString.substr(inputSplits.getOffset(fktPos +1))); /// TODO CHECK IF OK
             else
               (*cmdIT)->executor->execute(objectPointer, "");
@@ -255,5 +256,5 @@
  * @param description the description of the Given command
  */
-ShellCommand* ShellCommand::describe(const char* description)
+ShellCommand* ShellCommand::describe(const std::string& description)
 {
   if (this == NULL)
@@ -326,5 +327,5 @@
   for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
   {
-    PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className, (*classIT)->commandList.size());
+    PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className.c_str(), (*classIT)->commandList.size());
 
     list<ShellCommand*>::iterator cmdIT;
@@ -335,6 +336,6 @@
       /*      for (unsigned int i = 0; i< elem->paramCount; i++)
        printf("%s ", ShellCommand::paramToString(elem->parameters[i]));*/
-      if ((*cmdIT)->description != NULL)
-       printf("- %s", (*cmdIT)->description);
+      if (!(*cmdIT)->description.empty())
+        printf("- %s", (*cmdIT)->description.c_str());
       printf("\n");
 
Index: trunk/src/lib/shell/shell_command.h
===================================================================
--- trunk/src/lib/shell/shell_command.h	(revision 7201)
+++ trunk/src/lib/shell/shell_command.h	(revision 7221)
@@ -61,7 +61,7 @@
   friend class ShellCommandClass;
   public:
-    static bool execute (const char* executionString);
+    static bool execute (const std::string& executionString);
 
-    ShellCommand* describe(const char* description);
+    ShellCommand* describe(const std::string& description);
     ShellCommand* setAlias(const char* alias);
     ShellCommand* defaultValues(const MultiType& value0 = MT_NULL, const MultiType& value1 = MT_NULL,
@@ -89,5 +89,5 @@
     ShellCommandAlias*               alias;                                //!< An Alias for the Class.
 
-    const char*                      description;                          //!< A description for this commnand. (initially NULL). Assigned with (create)->describe("blablabla");
+    std::string                      description;                          //!< A description for this commnand. (initially NULL). Assigned with (create)->describe("blablabla");
     Executor*                        executor;                             //!< The Executor, that really executes the Function.
 
@@ -100,5 +100,5 @@
   public:
     /** @returns the Name of the Alias. */
-    const char* getName() const { return this->aliasName; };
+    const std::string& getName() const { return this->aliasName; };
     /** @returns the Command, this Alias is asociated with */
     ShellCommand* getCommand() const { return this->command; };
@@ -106,8 +106,8 @@
   private:
     /** @param aliasName the name of the Alias @param command the Command, to associate this alias with */
-    ShellCommandAlias(const char* aliasName, ShellCommand* command) { this->aliasName = aliasName; this->command = command; };
+    ShellCommandAlias(const std::string& aliasName, ShellCommand* command) { this->aliasName = aliasName; this->command = command; };
 
   private:
-    const char*     aliasName;       //!< the name of the Alias
+    std::string     aliasName;       //!< the name of the Alias
     ShellCommand*   command;         //!< a pointer to the command, this alias executes.
 };
Index: trunk/src/lib/shell/shell_command_class.cc
===================================================================
--- trunk/src/lib/shell/shell_command_class.cc	(revision 7201)
+++ trunk/src/lib/shell/shell_command_class.cc	(revision 7221)
@@ -36,10 +36,10 @@
  * @param className the Name of the command-class to create
  */
-ShellCommandClass::ShellCommandClass(const char* className)
+ShellCommandClass::ShellCommandClass(const std::string& className)
+  : className(className)
 {
   this->setClassID(CL_SHELL_COMMAND_CLASS, "ShellCommandClass");
   this->setName(className);
 
-  this->className = className;
   this->classID = CL_NULL;
 
@@ -65,7 +65,7 @@
  * @returns true on success, false otherwise
  */
-bool ShellCommandClass::getCommandListOfClass(const char* className, std::list<const char*>* stringList)
-{
-  if (stringList == NULL || className == NULL)
+bool ShellCommandClass::getCommandListOfClass(const std::string& className, std::list<std::string>* stringList)
+{
+  if (stringList == NULL)
     return false;
 
@@ -73,5 +73,5 @@
   for(elem = ShellCommandClass::commandClassList->begin(); elem != ShellCommandClass::commandClassList->end(); elem++)
   {
-    if (!strcmp ((*elem)->getName(), className))
+    if (className == (*elem)->getName())
     {
       list<ShellCommand*>::iterator command;
@@ -88,5 +88,5 @@
  * @returns true on success, false otherwise
  */
-bool ShellCommandClass::getCommandListOfAlias(std::list<const char*>* stringList)
+bool ShellCommandClass::getCommandListOfAlias(std::list<std::string>* stringList)
 {
   if (stringList == NULL || ShellCommandClass::aliasList == NULL)
@@ -130,5 +130,5 @@
  * @returns the CommandClass if found, NULL otherwise
  */
-const ShellCommandClass* ShellCommandClass::isRegistered(const char* className)
+const ShellCommandClass* ShellCommandClass::isRegistered(const std::string& className)
 {
   if (ShellCommandClass::commandClassList == NULL)
@@ -138,5 +138,5 @@
   for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
   {
-    if (!strcmp(className, (*classIT)->className))
+    if (className == (*classIT)->className)
     {
       if ((*classIT)->classID == CL_NULL)
@@ -154,5 +154,5 @@
  * @returns the CommandClass if found, or a new CommandClass if not
  */
-ShellCommandClass* ShellCommandClass::getCommandClass(const char* className)
+ShellCommandClass* ShellCommandClass::getCommandClass(const std::string& className)
 {
   if (ShellCommandClass::commandClassList == NULL)
@@ -162,5 +162,5 @@
   for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
   {
-    if (!strcmp(className, (*classIT)->className))
+    if (className == (*classIT)->className)
     {
       return (*classIT);
@@ -186,8 +186,6 @@
  * @param className: the Class of Commands to show help about
  */
-void ShellCommandClass::help(const char* className)
-{
-  if (className == NULL)
-    return;
+void ShellCommandClass::help(const std::string& className)
+{
   if (likely(ShellCommandClass::commandClassList != NULL))
   {
@@ -195,7 +193,7 @@
     for (classIT = ShellCommandClass::commandClassList->begin(); classIT != ShellCommandClass::commandClassList->end(); classIT++)
     {
-      if ((*classIT)->className && !strcasecmp(className, (*classIT)->className))
+      if (className == (*classIT)->className)
       {
-        PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className, (*classIT)->commandList.size());
+        PRINT(0)("Class:'%s' registered %d commands: \n", (*classIT)->className.c_str(), (*classIT)->commandList.size());
         list<ShellCommand*>::const_iterator cmdIT;
         for (cmdIT = (*classIT)->commandList.begin(); cmdIT != (*classIT)->commandList.end(); cmdIT++)
@@ -205,6 +203,6 @@
           /*          for (unsigned int i = 0; i< elem->paramCount; i++)
             PRINT(0)("%s ", ShellCommand::paramToString(elem->parameters[i]));*/
-          if ((*cmdIT)->description != NULL)
-            PRINT(0)("- %s", (*cmdIT)->description);
+          if (!(*cmdIT)->description.empty())
+            PRINT(0)("- %s", (*cmdIT)->description.c_str());
           PRINT(0)("\n");
         }
@@ -212,5 +210,5 @@
       }
     }
-    PRINTF(3)("Class %s not found in Command's classes\n", className);
+    PRINTF(3)("Class %s not found in Command's classes\n", className.c_str());
   }
   else
Index: trunk/src/lib/shell/shell_command_class.h
===================================================================
--- trunk/src/lib/shell/shell_command_class.h	(revision 7201)
+++ trunk/src/lib/shell/shell_command_class.h	(revision 7221)
@@ -27,21 +27,21 @@
     /** @returns the CommandClassList */
     static const std::list<ShellCommandClass*>* getCommandClassList() { return ShellCommandClass::commandClassList; };
-    static bool getCommandListOfClass(const char* className, std::list<const char*>* stringList);
-    static bool getCommandListOfAlias(std::list<const char*>* aliasList);
+    static bool getCommandListOfClass(const std::string& className, std::list<std::string>* stringList);
+    static bool getCommandListOfAlias(std::list<std::string>* aliasList);
 
-    static ShellCommandClass* getCommandClass(const char* className);
+    static ShellCommandClass* getCommandClass(const std::string& className);
     static void unregisterAllCommands();
 
-    static void help (const char* className);
+    static void help (const std::string& className);
 
   private:
-    ShellCommandClass(const char* className);
+    ShellCommandClass(const std::string& className);
     virtual ~ShellCommandClass();
 
-    static const ShellCommandClass* isRegistered(const char* className);
+    static const ShellCommandClass* isRegistered(const std::string& className);
     static void initCommandClassList();
 
   private:
-    const char*                            className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
+    const std::string                      className;                 //!< The Name of the Class. This should match the ClassName of the Commands Class.
     long                                   classID;                   //!< The classID of this Class
     std::list<ShellCommand*>               commandList;               //!< A list of Commands from this Class
Index: trunk/src/lib/shell/shell_completion.cc
===================================================================
--- trunk/src/lib/shell/shell_completion.cc	(revision 7201)
+++ trunk/src/lib/shell/shell_completion.cc	(revision 7221)
@@ -76,6 +76,5 @@
 
   // Check if we are in a input. eg. the supplied string "class " and now we complete either function or object
-  if (this->input->getInput() != NULL &&
-      strrchr(this->input->getInput(), ' ') >= this->input->getInput() + strlen(this->input->getInput())-1)
+  if (this->input->getInput()[this->input->getInput().size()-1] == ' ')
   {
     emptyComplete = true;
@@ -83,9 +82,5 @@
 
   // CREATE INPUTS
-  if (this->input->getInput() == NULL)
-    completionLine = "";
-  else
-    completionLine = this->input->getInput() + strspn(this->input->getInput(), " \t\n");
-  SubString inputSplits(completionLine, " \t\n,");
+  SubString inputSplits(this->input->getInput(), " \t\n,");
 
   // What String will be completed
@@ -93,5 +88,5 @@
     completeString = "";
   else
-    completeString = inputSplits.getString(inputSplits.getCount()-1);
+    completeString = inputSplits.getString(inputSplits.getCount()-1).c_str();
 
   // CLASS COMPLETION
@@ -111,5 +106,5 @@
             (inputSplits.getCount() == 2 && emptyComplete == false))
   {
-    classID = ClassList::StringToID(inputSplits.getString(0));
+    classID = ClassList::StringToID(inputSplits.getString(0).c_str()); //FIXME
     objectList = ClassList::getList((ClassID)classID);
     if (classID != CL_NULL)
@@ -121,5 +116,5 @@
             (inputSplits.getCount() == 3 && emptyComplete == false))
   {
-    classID = ClassList::StringToID(inputSplits.getString(0));
+    classID = ClassList::StringToID(inputSplits.getString(0) .c_str()); // FIXME
     if (classID == CL_NULL)
       return false;
@@ -133,5 +128,5 @@
     this->objectComplete(completeString, classID);
   if (completeType & SHELLC_FUNCTION)
-    this->functionComplete(completeString, inputSplits.getString(0));
+    this->functionComplete(completeString, inputSplits.getString(0).c_str()); // FIXME
   if (completeType & SHELLC_ALIAS)
     this->aliasComplete(completeString);
@@ -151,5 +146,5 @@
   if (unlikely(classBegin == NULL))
     return false;
-  const std::list<const char*>* clList = ClassList::getClassNames();
+  const std::list<std::string>* clList = ClassList::getClassNames();
   if (clList != NULL)
   {
@@ -195,5 +190,5 @@
   if (unlikely(functionBegin == NULL))
     return false;
-  std::list<const char*> fktList;
+  std::list<std::string> fktList;
   ShellCommandClass::getCommandListOfClass(className, &fktList);
   //printf("%s\n", boList->firstElement()->getName());
@@ -212,5 +207,5 @@
   if (unlikely(aliasBegin == NULL))
     return false;
-  std::list<const char*> aliasList;
+  std::list<std::string> aliasList;
   ShellCommandClass::getCommandListOfAlias(&aliasList);
   //printf("%s\n", boList->firstElement()->getName());
@@ -295,5 +290,5 @@
  * !! The strings MUST NOT be deleted !!
  */
-bool ShellCompletion::addToCompleteList(const std::list<const char*>* inputList, const char* completionBegin, SHELLC_TYPE type)
+bool ShellCompletion::addToCompleteList(const std::list<std::string>* inputList, const char* completionBegin, SHELLC_TYPE type)
 {
   if (inputList == NULL || completionBegin == NULL)
@@ -301,12 +296,12 @@
   unsigned int searchLength = strlen(completionBegin);
 
-  list<const char*>::const_iterator string;
+  list<std::string>::const_iterator string;
   for (string = inputList->begin(); string != inputList->end(); string++)
   {
-    if (strlen(*string) >= searchLength &&
-        !strncasecmp(*string, completionBegin, searchLength))
+    if ((*string).size() >= searchLength &&
+          !strncasecmp((*string).c_str(), completionBegin, searchLength))
     {
       ShellC_Element newElem;
-      newElem.name = *string;
+      newElem.name = (*string).c_str();
       newElem.type = type;
       this->completionList.push_back(newElem);
Index: trunk/src/lib/shell/shell_completion.h
===================================================================
--- trunk/src/lib/shell/shell_completion.h	(revision 7201)
+++ trunk/src/lib/shell/shell_completion.h	(revision 7221)
@@ -52,5 +52,5 @@
   bool generalComplete(const char* begin, const char* displayAs = "%s", const char* addBack = NULL, const char* addFront = NULL);
 
-  bool addToCompleteList(const std::list<const char*>* inputList, const char* completionBegin, SHELLC_TYPE type);
+  bool addToCompleteList(const std::list<std::string>* inputList, const char* completionBegin, SHELLC_TYPE type);
   bool addToCompleteList(const std::list<BaseObject*>* inputList, const char* completionBegin, SHELLC_TYPE type);
   void emptyCompletionList();
Index: trunk/src/lib/shell/shell_input.cc
===================================================================
--- trunk/src/lib/shell/shell_input.cc	(revision 7201)
+++ trunk/src/lib/shell/shell_input.cc	(revision 7221)
@@ -41,11 +41,10 @@
  * this also generates a ShellCompletion automatically.
 */
-ShellInput::ShellInput () : Text ((const char*)NULL)
+ShellInput::ShellInput () : Text ("")
 {
   this->pressedKey = SDLK_FIRST;
   this->setClassID(CL_SHELL_INPUT, "ShellInput");
 
-  this->inputLine = new char[1];
-  this->inputLine[0] = '\0';
+  this->inputLine = "";
   this->historyIT = this->history.begin();
   this->setHistoryLength(50);
@@ -70,10 +69,8 @@
 {
   // delete what has to be deleted here
-  delete[] this->inputLine;
   delete this->completion;
 
   while (!this->history.empty())
   {
-    delete[] this->history.front();
     this->history.pop_front();
   }
@@ -96,11 +93,6 @@
 void ShellInput::flush()
 {
-  if (likely(this->inputLine != NULL))
-  {
-    delete[] this->inputLine;
-  }
-  this->inputLine = new char[1];
-  *this->inputLine = '\0';
-  this->setText(this->inputLine, true);
+  this->inputLine.clear();
+  this->setText(this->inputLine);
 }
 
@@ -109,18 +101,8 @@
  * @param text the new Text to set as InputLine
  */
-void ShellInput::setInputText(const char* text)
-{
-  delete[] this->inputLine;
-  if (text == NULL)
-  {
-    this->inputLine = new char[1];
-    this->inputLine[0] = '\0';
-  }
-  else
-  {
-    this->inputLine = new char[strlen(text)+1];
-    strcpy(this->inputLine, text);
-  }
-  this->setText(this->inputLine, true);
+void ShellInput::setInputText(const std::string& text)
+{
+  this->inputLine = text;
+  this->setText(this->inputLine);
 }
 
@@ -134,15 +116,10 @@
   if (this->historyScrolling)
   {
-    delete[] this->history.back();
     this->history.pop_back();
     this->historyScrolling = false;
   }
 
-  char* addCharLine = new char[strlen(this->inputLine)+2];
-
-  sprintf(addCharLine, "%s%c", this->inputLine, character);
-  delete[] this->inputLine;
-  this->inputLine = addCharLine;
-  this->setText(this->inputLine, true);
+  this->inputLine += character;
+  this->setText(this->inputLine);
 }
 
@@ -151,19 +128,14 @@
  * @param characters a \\0 terminated char-array to add to the InputLine
  */
-void ShellInput::addCharacters(const char* characters)
+void ShellInput::addCharacters(const std::string& characters)
 {
   if (this->historyScrolling)
   {
-    delete[] this->history.back();
     this->history.pop_back();
     this->historyScrolling = false;
   }
 
-  char* addCharLine = new char[strlen(this->inputLine)+strlen(characters)+1];
-
-  sprintf(addCharLine, "%s%s", this->inputLine, characters);
-  delete[] this->inputLine;
-  this->inputLine = addCharLine;
-  this->setText(this->inputLine, true);
+  this->inputLine += characters;
+  this->setText(this->inputLine);
 }
 
@@ -176,22 +148,12 @@
   if (this->historyScrolling)
   {
-    delete[] this->history.back();
     this->history.pop_back();
     this->historyScrolling = false;
   }
-
-  if (strlen(this->inputLine) == 0)
-    return;
-
-  if (characterCount > strlen(this->inputLine))
-    characterCount = strlen(this->inputLine);
-
-  char* removeCharLine = new char[strlen(this->inputLine)-characterCount+1];
-
-  strncpy(removeCharLine, this->inputLine, strlen(this->inputLine)-characterCount);
-  removeCharLine[strlen(this->inputLine)-characterCount] = '\0';
-  delete[] this->inputLine;
-  this->inputLine = removeCharLine;
-  this->setText(this->inputLine, true);
+  if (this->inputLine.size() < characterCount)
+    characterCount = this->inputLine.size();
+
+  this->inputLine.erase(this->inputLine.size() - characterCount, this->inputLine.size());
+  this->setText(this->inputLine);
 }
 
@@ -202,18 +164,14 @@
 bool ShellInput::executeCommand()
 {
-  ShellBuffer::addBufferLineStatic("Execute Command: %s\n", this->inputLine);
-
-  if (strlen(this->inputLine) == 0)
+  ShellBuffer::addBufferLineStatic("Execute Command: %s\n", this->inputLine.c_str());
+
+  if (this->inputLine.empty())
     return false;
 
-  char* newCommand = new char[strlen(this->inputLine)+1];
-  strcpy(newCommand, this->inputLine);
-
-  ShellCommand::execute(newCommand);
+  ShellCommand::execute(this->inputLine);
 
   // removing the eventually added Entry (from scrolling) to the List
   if (this->historyScrolling)
   {
-    delete[] this->history.back();
     this->history.pop_back();
     this->historyScrolling = false;
@@ -221,8 +179,7 @@
 
   // adding the new Command to the History
-  this->history.push_back(newCommand);
+  this->history.push_back(this->inputLine);
   if (this->history.size() > this->historyLength)
   {
-    delete[] this->history.front();
     this->history.pop_front();
   }
@@ -241,7 +198,5 @@
   if (!this->historyScrolling)
   {
-    char* currentText = new char[strlen(this->inputLine)+1];
-    strcpy(currentText, this->inputLine);
-    this->history.push_back(currentText);
+    this->history.push_back(this->inputLine);
     this->historyScrolling = true;
     this->historyIT = --this->history.end();
@@ -250,8 +205,8 @@
   if(this->historyIT != this->history.begin())
   {
-    char* prevElem = *(--this->historyIT);
-    if (prevElem == NULL)
+    std::string prevElem = *(--this->historyIT);
+    /*if (prevElem == NULL) /// TODO STD
       return;
-    else
+    else */
     {
       this->flush();
@@ -270,8 +225,8 @@
   if (this->historyIT != this->history.end())
   {
-    char* nextElem = *(++this->historyIT);
-    if (nextElem == NULL)
+    std::string nextElem = *(++this->historyIT);
+    /*    if (nextElem == NULL) /// TODO FIX STD
       return;
-    else
+    else */
     {
       this->flush();
@@ -285,9 +240,9 @@
  * prints out some nice help about the Shell
  */
-void ShellInput::help(const char* className, const char* functionName)
-{
-  printf("%s::%s\n", className, functionName);
-
-  if (strlen(className) == 0)
+void ShellInput::help(const std::string& className, const std::string& functionName)
+{
+  printf("%s::%s\n", className.c_str(), functionName.c_str());
+
+  if (className.empty())
   {
     PRINT(0)("Help for the most important Shell-commands\n");
@@ -298,5 +253,5 @@
     PRINT(0)("- Also try 'help className'");
   }
-  else if (strlen (className) > 0 && strlen (functionName) == 0)
+  else if (!className.empty() && functionName.empty())
   {
     ShellCommandClass::help(className);
Index: trunk/src/lib/shell/shell_input.h
===================================================================
--- trunk/src/lib/shell/shell_input.h	(revision 7201)
+++ trunk/src/lib/shell/shell_input.h	(revision 7221)
@@ -31,11 +31,11 @@
 
   /** @returns the inputLine */
-  const char* getInput() const { return this->inputLine; };
+  const std::string& getInput() const { return this->inputLine; };
 
   // InputLine
   void flush();
-  void setInputText(const char* text);
+  void setInputText(const std::string& text);
   void addCharacter(char character);
-  void addCharacters(const char* characters);
+  void addCharacters(const std::string& characters);
   void removeCharacters(unsigned int characterCount = 1);
   void setRepeatDelay(float repeatDelay, float repeatRate);
@@ -47,5 +47,5 @@
   void historyMoveDown();
 
-  void help(const char* className = "", const char* function = "");
+  void help(const std::string& className = "", const std::string& function = "");
 
   virtual void tick(float dt);
@@ -54,16 +54,16 @@
  private:
     // HANDLING TEXT INPUT
-   ShellCompletion*            completion;             //!< The Completion Interface.
+   ShellCompletion*                  completion;       //!< The Completion Interface.
 
-   char*                       inputLine;              //!< the Char-Array of the Buffer
-   float                       repeatRate;             //!< The Repeat-Delay.
-   float                       repeatDelay;            //!< The delay of the first Character of a given Character.
-   float                       delayed;                //!< how much of the delay is remaining.
-   Uint16                      pressedKey;             //!< the pressed key that will be repeated.
+   std::string                       inputLine;        //!< the Char-Array of the Buffer
+   float                             repeatRate;       //!< The Repeat-Delay.
+   float                             repeatDelay;      //!< The delay of the first Character of a given Character.
+   float                             delayed;          //!< how much of the delay is remaining.
+   Uint16                            pressedKey;       //!< the pressed key that will be repeated.
 
-   std::list<char*>            history;                //!< The history of given commands.
-   std::list<char*>::iterator  historyIT;
-   unsigned int                historyLength;          //!< The maximum length of the InputHistory.
-   bool                        historyScrolling;       //!< true if we are scrolling through the history.
+   std::list<std::string>            history;          //!< The history of given commands.
+   std::list<std::string>::iterator  historyIT;        //!< The locator that tells us, where we are in the history.
+   unsigned int                      historyLength;    //!< The maximum length of the InputHistory.
+   bool                              historyScrolling; //!< true if we are scrolling through the history.
 };
 
