Index: /trunk/src/lib/shell/shell.cc
===================================================================
--- /trunk/src/lib/shell/shell.cc	(revision 5165)
+++ /trunk/src/lib/shell/shell.cc	(revision 5166)
@@ -78,36 +78,4 @@
 }
 
-
-void Shell::testI (int i)
-{
-  PRINTF(3)("This is the Test for one Int '%d'\n", i);
-}
-
-void Shell::testS (const char* s)
-{
-  PRINTF(3)("This is the Test for one String '%s'\n", s);
-}
-
-void Shell::testB (bool b)
-{
-  PRINTF(3)("This is the Test for one Bool: ");
-  if (b)
-    PRINTF(3)("true\n");
-  else
-    PRINTF(3)("false\n");
-}
-
-void Shell::testF (float f)
-{
-  PRINTF(3)("This is the Test for one Float '%f'\n", f);
-}
-
-void Shell::testSF (const char* s, float f)
-{
-  PRINTF(3)("This is the Test for one String '%s' and one Float '%f'\n",s , f);
-}
-
-
-
 Shell* Shell::singletonRef = NULL;
 
@@ -270,5 +238,4 @@
  * adds a new Line to the List of Buffers
  * @param line the Line as in the first argument in printf
- * @param args the arguments as a va_list
  */
 bool Shell::addBufferLineStatic(const char* line, ...)
@@ -445,5 +412,5 @@
 /**
  * adds multiple Characters to thr inputLine
- * @param characters a '\0' terminated char-array to add to the InputLine
+ * @param characters a \\0 terminated char-array to add to the InputLine
  */
 void Shell::addCharacters(const char* characters)
@@ -497,4 +464,7 @@
 }
 
+/**
+ * clears the Shell (empties all buffers)
+ */
 void Shell::clear()
 {
@@ -729,4 +699,8 @@
 }
 
+/**
+ * completes a Function
+ * @param functionBegin the beginning of the function String
+ */
 bool Shell::functionComplete(const char* functionBegin)
 {
@@ -849,4 +823,7 @@
 }
 
+/**
+ * prints out some nice help about the Shell
+ */
 void Shell::help() const
 {
@@ -862,4 +839,10 @@
 // HELPER FUNCTIONS  //
 ///////////////////////
+
+/**
+ * calculates the position of a Buffer-Display Line
+ * @param lineNumber the lineNumber from the bottom to calculate the position from
+ * @returns the Position of the Line.
+ */
 Vector Shell::calculateLinePosition(unsigned int lineNumber)
 {
@@ -887,2 +870,33 @@
   }
 }
+
+
+
+// void Shell::testI (int i)
+// {
+//   PRINTF(3)("This is the Test for one Int '%d'\n", i);
+// }
+//
+// void Shell::testS (const char* s)
+// {
+//   PRINTF(3)("This is the Test for one String '%s'\n", s);
+// }
+//
+// void Shell::testB (bool b)
+// {
+//   PRINTF(3)("This is the Test for one Bool: ");
+//   if (b)
+//     PRINTF(3)("true\n");
+//   else
+//     PRINTF(3)("false\n");
+// }
+//
+// void Shell::testF (float f)
+// {
+//   PRINTF(3)("This is the Test for one Float '%f'\n", f);
+// }
+//
+// void Shell::testSF (const char* s, float f)
+// {
+//   PRINTF(3)("This is the Test for one String '%s' and one Float '%f'\n",s , f);
+// }
Index: /trunk/src/lib/shell/shell.h
===================================================================
--- /trunk/src/lib/shell/shell.h	(revision 5165)
+++ /trunk/src/lib/shell/shell.h	(revision 5166)
@@ -39,10 +39,4 @@
     inline static Shell* getInstance() { if (!Shell::singletonRef) Shell::singletonRef = new Shell();  return Shell::singletonRef; };
 
-    void testI (int i);
-    void testS (const char* s);
-    void testB (bool b);
-    void testF (float f);
-    void testSF (const char* s, float f);
-
     void activate();
     void deactivate();
@@ -52,4 +46,5 @@
 
     // BUFFER //
+    /** @param bufferSize the new Buffer-Size */
     void setBufferSize(unsigned int bufferSize) { this->bufferSize = bufferSize; };
     void setBufferDisplaySize(unsigned int bufferDisplaySize);
@@ -59,5 +54,5 @@
     void printToDisplayBuffer(const char* text);
     void moveBuffer(unsigned int lineCount);
-    void moveBufferTo(unsigned int lineNumber);
+//    void moveBufferTo(unsigned int lineNumber);
     const char* getBufferLine(unsigned int lineNumber);
 
@@ -93,9 +88,13 @@
     const tList<const char>* createCompleteList(const tList<const char>* inputList, const char* classNameBegin);
     const tList<const char>* createCompleteList(const tList<BaseObject>* inputList, const char* classNameBegin);
-    const tList<const char>* createCompleteList(const tList<ShellCommandBase>* inputList, const char* classNameBegin);
+//    const tList<const char>* createCompleteList(const tList<ShellCommandBase>* inputList, const char* classNameBegin);
 
     // helpers //
     Vector calculateLinePosition(unsigned int lineNumber);
-
+//     void testI (int i);
+//     void testS (const char* s);
+//     void testB (bool b);
+//     void testF (float f);
+//     void testSF (const char* s, float f);
 
   private:
@@ -126,5 +125,5 @@
     char                     bufferArray[SHELL_BUFFER_SIZE];     //!< a BUFFER for fast writing
     char                     keepBufferArray[SHELL_BUFFER_SIZE]; //!< a BUFFER to have multi-non-newLine commands be copied into the shell.
-    bool                     keepBuffer;
+    bool                     keepBuffer;             //!< if the keepbuffer contains unfinished lines.
 
     // completion
Index: /trunk/src/lib/shell/shell_command.cc
===================================================================
--- /trunk/src/lib/shell/shell_command.cc	(revision 5165)
+++ /trunk/src/lib/shell/shell_command.cc	(revision 5166)
@@ -28,4 +28,11 @@
 using namespace std;
 
+/**
+ * constructs and registers a new Command
+ * @param commandName the name of the Command
+ * @param className the name of the class to apply this command to
+ * @param paramCount the count of parameters this command takes
+ * @return self
+ */
 ShellCommandBase::ShellCommandBase(const char* commandName, const char* className, unsigned int paramCount, ...)
 {
@@ -83,4 +90,8 @@
 }
 
+/**
+ * deconstructs a ShellCommand
+ * @return
+ */
 ShellCommandBase::~ShellCommandBase()
 {
@@ -88,4 +99,7 @@
 }
 
+/**
+ * unregisters all Commands that exist
+ */
 void ShellCommandBase::unregisterAllCommands()
 {
@@ -104,6 +118,12 @@
 }
 
-
-void unregisterCommand(const char* commandName, const char* className)
+/**
+ * unregister an existing commandName
+ * @param className the name of the Class the command belongs to.
+ * @param commandName the name of the command itself
+ *
+ * @todo implement
+ */
+void ShellCommandBase::unregisterCommand(const char* commandName, const char* className)
 {
   PRINTF(1)("IMPLEMENT THIS\n");
@@ -113,5 +133,14 @@
 
 
-
+/**
+ * checks if a command has already been registered.
+ * @param commandName the name of the Command
+ * @param className the name of the Class the command should apply to.
+ * @param paramCount how many arguments the Command takes
+ * @returns true, if the command is registered/false otherwise
+ *
+ * This is used internally, to see, if we have multiple command subscriptions.
+ * This is checked in the registerCommand-function.
+ */
 bool ShellCommandBase::isRegistered(const char* commandName, const char* className, unsigned int paramCount, ...)
 {
@@ -240,5 +269,8 @@
 }
 
-
+/**
+ * lets a command be described
+ * @param description the description of the Given command
+ */
 ShellCommandBase* ShellCommandBase::describe(const char* description)
 {
@@ -252,4 +284,7 @@
 }
 
+/**
+ * see ShellCommandBase::debug()
+ */
 void ShellCommandBase::debugDyn()
 {
@@ -257,4 +292,7 @@
 }
 
+/**
+ * prints out nice information about the Shells Commands
+ */
 void ShellCommandBase::debug()
 {
@@ -269,5 +307,5 @@
   while(elem != NULL)
   {
-    PRINT(0)("Class %s registered command %s with %d parameters: ", elem->className, elem->getName(), elem->paramCount);
+    PRINT(0)("Class:'%s':command:'%s':params:%d: ", elem->className, elem->getName(), elem->paramCount);
     for (unsigned int i = 0; i< elem->paramCount; i++)
       printf("%s ", ShellCommandBase::paramToString(elem->parameters[i]));
@@ -281,6 +319,9 @@
 }
 
-
-
+/**
+ * converts a Parameter to a String
+ * @param parameter the Parameter we have.
+ * @returns the Name of the Parameter at Hand
+ */
 const char* ShellCommandBase::paramToString(long parameter)
 {
Index: /trunk/src/lib/shell/shell_command.h
===================================================================
--- /trunk/src/lib/shell/shell_command.h	(revision 5165)
+++ /trunk/src/lib/shell/shell_command.h	(revision 5166)
@@ -15,5 +15,5 @@
 #include <stdarg.h>
 
-#define SHELL_COMMAND_MAX_SIZE
+#define     SHELL_COMMAND_MAX_SIZE      //!< The maximum size of a Shell Command
 
 
@@ -22,4 +22,10 @@
 template<class T> class tList;
 
+/**
+ * an easy to use Macro to create a Command
+ * @param command the name of the command (without "" around the string)
+ * @param class the name of the class to apply this command to (without the "" around the string)
+ * @param function the function to call
+ */
 #define SHELL_COMMAND(command, class, function) \
         ShellCommandBase* shell_command_##class##_##command = ShellCommand<class>::registerCommand(#command, #class, &class::function)
@@ -37,8 +43,9 @@
     ShellCommandBase* describe(const char* description);
 
+    /** @returns the CommandList of the Shell */
     static const tList<ShellCommandBase>* getCommandList() { return ShellCommandBase::commandList; };
 
     static void unregisterAllCommands();
-    static void unregisterCommand(const char* commandNaame, const char* className);
+    static void unregisterCommand(const char* commandName, const char* className);
 
     static void debug();
@@ -54,14 +61,15 @@
 
   private:
+    /** executes a Command @param object the object to apply this to @param parameters the parameters the command takes */
     virtual void executeCommand (BaseObject* object, const char* parameters) = NULL;
 
   protected:
     void*                            functionPointer;                      //!< The pointeer to the function of the Class (or static pointer if ClassID == CL_NULL )
-    unsigned int                     paramCount;                           //!< the count of parameters
-    unsigned int*                    parameters;                           //!< Parameters
-    char*                            defaultStrings[FUNCTOR_MAX_ARGUMENTS];
-    int                              defaultInts[FUNCTOR_MAX_ARGUMENTS];
-    float                            defaultFloats[FUNCTOR_MAX_ARGUMENTS];
-    bool                             defaultBools[FUNCTOR_MAX_ARGUMENTS];
+    unsigned int                     paramCount;                           //!< the count of parameters.
+    unsigned int*                    parameters;                           //!< Parameters the function of this Command takes.
+    char*                            defaultStrings[FUNCTOR_MAX_ARGUMENTS];//!< A list of default Strings stored.
+    int                              defaultInts[FUNCTOR_MAX_ARGUMENTS];   //!< A list of default Ints stored.
+    float                            defaultFloats[FUNCTOR_MAX_ARGUMENTS]; //!< A list of default Floats stored.
+    bool                             defaultBools[FUNCTOR_MAX_ARGUMENTS];  //!< A list of default Bools stored.
 
   private:
@@ -69,5 +77,5 @@
     const char*                      className;                            //!< The Name of the Class associated to this Command
 
-    const char*                      description;
+    const char*                      description;                          //!< A description for this commnand. (initially NULL). Assigned with (create)->describe("blablabla");
 
     // STATIC MEMBERS
@@ -81,9 +89,15 @@
 // MACRO DEFINITIONS //
 ///////////////////////
+//! where to chek for default BOOL values
 #define   l_BOOL_DEFGRAB(i)         this->defaultBools[i]
+//! where to chek for default INT values
 #define   l_INT_DEFGRAB(i)          this->defaultInts[i]
+//! where to chek for default UINT values
 #define   l_UINT_DEFGRAB(i)         (unsigned int)this->defaultInts[i]
+//! where to chek for default LONG values
 #define   l_LONG_DEFGRAB(i)         (long)this->defaultInts[i]
+//! where to chek for default FLOAT values
 #define   l_FLOAT_DEFGRAB(i)        this->defaultFloats[i]
+//! where to chek for default STRING values
 #define   l_STRING_DEFGRAB(i)       this->defaultStrings[i]
 
@@ -91,5 +105,5 @@
 // COMMAND REGISTRATION //
 //////////////////////////
-// NO ARGUMENTS
+//! registers a command without any parameters
 #define ShellCommandRegister0() \
   static ShellCommand<T>* registerCommand(const char* commandName, const char* className, void (T::*function)()) \
@@ -100,4 +114,5 @@
   }
 
+//! registers a command with 1 parameter
 #define ShellCommandRegister1(t1) \
   static ShellCommand<T>* registerCommand(const char* commandName, const char* className, void (T::*function)(t1##_TYPE), t1##_TYPE d1 = t1##_DEFAULT) \
@@ -108,4 +123,5 @@
   }
 
+//! registers a command with 2 parameters
 #define ShellCommandRegister2(t1,t2) \
   static ShellCommand<T>* registerCommand(const char* commandName, const char* className, void (T::*function)(t1##_TYPE, t2##_TYPE), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT) \
@@ -116,4 +132,5 @@
   }
 
+//! registers a command with 3 parameters
 #define ShellCommandRegister3(t1,t2,t3) \
   static ShellCommand<T>* registerCommand(const char* commandName, const char* className, void (T::*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT, t3##_TYPE d3 = t3##_DEFAULT) \
@@ -124,4 +141,5 @@
   }
 
+//! registers a command with 4 parameters
 #define ShellCommandRegister4(t1,t2,t3,t4) \
   static ShellCommand<T>* registerCommand(const char* commandName, const char* className, void (T::*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT, t3##_TYPE d3 = t3##_DEFAULT, t4##_TYPE d4 = t4##_DEFAULT) \
@@ -132,4 +150,5 @@
   }
 
+//! registers a command with 5 parameters
 #define ShellCommandRegister5(t1,t2,t3,t4,t5) \
   static ShellCommand<T>* registerCommand(const char* commandName, const char* className, void (T::*function)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE), t1##_TYPE d1 = t1##_DEFAULT, t2##_TYPE d2 = t2##_DEFAULT, t3##_TYPE d3 = t3##_DEFAULT, t4##_TYPE d4 = t4##_DEFAULT, t5##_TYPE d5 = t5##_DEFAULT) \
@@ -143,4 +162,5 @@
 // CONSTRUCTORS //
 /////////////////
+//! creates a command that takes no parameters
 #define ShellCommandConstructor0() \
   void (T::*functionPointer_0)(); \
@@ -151,4 +171,5 @@
   }
 
+//! creates a command that takes one parameter
 #define ShellCommandConstructor1(t1) \
   void (T::*functionPointer_1_##t1)(t1##_TYPE); \
@@ -159,4 +180,5 @@
   }
 
+//! creates a command that takes two parameters
 #define ShellCommandConstructor2(t1,t2) \
   void (T::*functionPointer_2_##t1##_##t2)(t1##_TYPE, t2##_TYPE); \
@@ -167,4 +189,5 @@
   }
 
+//! creates a command that takes three parameter
 #define ShellCommandConstructor3(t1,t2,t3) \
   void (T::*functionPointer_3_##t1##_##t2##_##t3)(t1##_TYPE, t2##_TYPE, t3##_TYPE); \
@@ -175,4 +198,5 @@
   }
 
+//! creates a command that takes four parameter
 #define ShellCommandConstructor4(t1,t2,t3,t4) \
   void (T::*functionPointer_4_##t1##_##t2##_##t3##_##t4)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE); \
@@ -183,4 +207,5 @@
   }
 
+//! creates a command that takes five parameter
 #define ShellCommandConstructor5(t1,t2,t3,t4,t5) \
   void (T::*functionPointer_5_##t1##_##t2##_##t3##_##t4##_##t5)(t1##_TYPE, t2##_TYPE, t3##_TYPE, t4##_TYPE, t5##_TYPE); \
@@ -194,24 +219,30 @@
 // EXECUTION //
 ///////////////
+//! execute-macro for functions with no parameters
 #define ShellCommandExecute0() \
   if (this->paramCount == 0) \
     (dynamic_cast<T*>(object)->*functionPointer_0)()
 
+//! execute-macro for functions with one parameter
 #define ShellCommandExecute1(t1) \
    else if (this->paramCount == 1 && this->parameters[0] == t1##_PARAM) \
     (dynamic_cast<T*>(object)->*functionPointer_1_##t1)(t1##_FUNC(parameters, t1##_DEFGRAB(0)))
 
+//! execute-macro for functions with two parameters
 #define ShellCommandExecute2(t1,t2) \
    else if (this->paramCount == 2 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM) \
     (dynamic_cast<T*>(object)->*functionPointer_2_##t1##_##t2)(t1##_FUNC(sub.getString(0), t1##_DEFGRAB(0)), t2##_FUNC(sub.getString(1), t2##_DEFGRAB(1)))
 
+//! execute-macro for functions with three parameters
 #define ShellCommandExecute3(t1,t2,t3) \
    else if (this->paramCount == 3 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM && this->parameters[2] == t3##_PARAM) \
     (dynamic_cast<T*>(object)->*functionPointer_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)))
 
+//! execute-macro for functions with four parameters
 #define ShellCommandExecute4(t1,t2,t3,t4) \
    else if (this->paramCount == 4 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM && this->parameters[2] == t3##_PARAM && this->parameters[3] == t4##_PARAM) \
     (dynamic_cast<T*>(object)->*functionPointer_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)))
 
+//! execute-macro for functions with five parameters
 #define ShellCommandExecute5(t1,t2,t3,t4,t5) \
    else if (this->paramCount == 5 && this->parameters[0] == t1##_PARAM && this->parameters[1] == t2##_PARAM && this->parameters[2] == t3##_PARAM && this->parameters[3] == t4##_PARAM && this->parameters[4] == t5##_PARAM) \
@@ -228,4 +259,5 @@
 #endif
 
+//! FUNCTOR_LIST is the List of command-registerers
 #define FUNCTOR_LIST(x) ShellCommandRegister ## x
 #include "functor_list.h"
@@ -234,4 +266,5 @@
 
   private:
+//! FUNCTOR_LIST is the List of CommandConstructors
 #define FUNCTOR_LIST(x) ShellCommandConstructor ## x
 #include "functor_list.h"
@@ -242,4 +275,5 @@
 //      if (parameters != NULL)
       SubString sub(parameters);
+//! FUNCTOR_LIST is the List of Executive Functions
 #define FUNCTOR_LIST(x) ShellCommandExecute ## x
 #include "functor_list.h"
