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"
