Changeset 7236 for code/branches/consolecommands3/src/libraries/core

Timestamp:

Aug 28, 2010, 1:51:04 AM (14 years ago)

Author:

landauf

Message:

replaced the temporary names of all ConsoleCommand related classes and functions by their real names

Location:

code/branches/consolecommands3/src/libraries/core

Files:

• ConfigFileManager.cc (modified) (2 diffs)
• Core.cc (modified) (1 diff)
• CorePrereqs.h (modified) (1 diff)
• GUIManager.cc (modified) (2 diffs)
• Game.cc (modified) (1 diff)
• GraphicsManager.cc (modified) (3 diffs)
• command/ArgumentCompletionFunctions.cc (modified) (6 diffs)
• command/CommandEvaluation.cc (modified) (2 diffs)
• command/CommandEvaluation.h (modified) (2 diffs)
• command/CommandExecutor.cc (modified) (2 diffs)
• command/ConsoleCommand.cc (modified) (34 diffs)
• command/ConsoleCommand.h (modified) (9 diffs)
• command/ConsoleCommandCompilation.cc (modified) (1 diff)
• command/IRC.cc (modified) (1 diff)
• command/Shell.cc (modified) (1 diff)
• command/TclBind.cc (modified) (1 diff)
• command/TclThreadManager.cc (modified) (1 diff)
• input/InputManager.cc (modified) (3 diffs)
• input/KeyBinderManager.cc (modified) (3 diffs)
• input/KeyDetector.cc (modified) (3 diffs)
• input/Mouse.cc (modified) (3 diffs)

code/branches/consolecommands3/src/libraries/core/ConfigFileManager.cc

@@ -431 +431 @@
     static const std::string __CC_getConfig_name = "getConfig";
 
-    _SetConsoleCommand(__CC_load_name,            &ConfigFile::load);
-    _SetConsoleCommand(__CC_setFilename_name,     &SettingsConfigFile::setFilename);
-    _SetConsoleCommand(__CC_config_name,          &SettingsConfigFile::config).argumentCompleter(0, autocompletion::settingssections()).argumentCompleter(1, autocompletion::settingsentries()).argumentCompleter(2, autocompletion::settingsvalue());
-    _SetConsoleCommand(__CC_tconfig_name,         &SettingsConfigFile::tconfig).argumentCompleter(0, autocompletion::settingssections()).argumentCompleter(1, autocompletion::settingsentries()).argumentCompleter(2, autocompletion::settingsvalue());
-    _SetConsoleCommand(__CC_getConfig_name,       &SettingsConfigFile::getConfig).argumentCompleter(0, autocompletion::settingssections()).argumentCompleter(1, autocompletion::settingsentries());
+    SetConsoleCommand(__CC_load_name,            &ConfigFile::load);
+    SetConsoleCommand(__CC_setFilename_name,     &SettingsConfigFile::setFilename);
+    SetConsoleCommand(__CC_config_name,          &SettingsConfigFile::config).argumentCompleter(0, autocompletion::settingssections()).argumentCompleter(1, autocompletion::settingsentries()).argumentCompleter(2, autocompletion::settingsvalue());
+    SetConsoleCommand(__CC_tconfig_name,         &SettingsConfigFile::tconfig).argumentCompleter(0, autocompletion::settingssections()).argumentCompleter(1, autocompletion::settingsentries()).argumentCompleter(2, autocompletion::settingsvalue());
+    SetConsoleCommand(__CC_getConfig_name,       &SettingsConfigFile::getConfig).argumentCompleter(0, autocompletion::settingssections()).argumentCompleter(1, autocompletion::settingsentries());
 
     SettingsConfigFile* SettingsConfigFile::singletonPtr_s = 0;
@@ -442 +442 @@
         : ConfigFile(filename)
     {
-        _ModifyConsoleCommand(__CC_load_name).setObject(this);
-        _ModifyConsoleCommand(__CC_setFilename_name).setObject(this);
-        _ModifyConsoleCommand(__CC_config_name).setObject(this);
-        _ModifyConsoleCommand(__CC_tconfig_name).setObject(this);
-        _ModifyConsoleCommand(__CC_getConfig_name).setObject(this);
+        ModifyConsoleCommand(__CC_load_name).setObject(this);
+        ModifyConsoleCommand(__CC_setFilename_name).setObject(this);
+        ModifyConsoleCommand(__CC_config_name).setObject(this);
+        ModifyConsoleCommand(__CC_tconfig_name).setObject(this);
+        ModifyConsoleCommand(__CC_getConfig_name).setObject(this);
     }
 
     SettingsConfigFile::~SettingsConfigFile()
     {
-        _ModifyConsoleCommand(__CC_load_name).setObject(0);
-        _ModifyConsoleCommand(__CC_setFilename_name).setObject(0);
-        _ModifyConsoleCommand(__CC_config_name).setObject(0);
-        _ModifyConsoleCommand(__CC_tconfig_name).setObject(0);
-        _ModifyConsoleCommand(__CC_getConfig_name).setObject(0);
+        ModifyConsoleCommand(__CC_load_name).setObject(0);
+        ModifyConsoleCommand(__CC_setFilename_name).setObject(0);
+        ModifyConsoleCommand(__CC_config_name).setObject(0);
+        ModifyConsoleCommand(__CC_tconfig_name).setObject(0);
+        ModifyConsoleCommand(__CC_getConfig_name).setObject(0);
     }
 

code/branches/consolecommands3/src/libraries/core/Core.cc

@@ -88 +88 @@
         : identifierDestroyer_(Identifier::destroyAllIdentifiers)
         // Cleanup guard for external console commands that don't belong to an Identifier
-        , consoleCommandDestroyer_(_ConsoleCommand::destroyAll)
+        , consoleCommandDestroyer_(ConsoleCommand::destroyAll)
         , bGraphicsLoaded_(false)
         , bStartIOConsole_(true)

code/branches/consolecommands3/src/libraries/core/CorePrereqs.h

@@ -194 +194 @@
     class ArgumentCompletionListElement;
     class CommandEvaluation;
-    class _ConsoleCommand;
+    class ConsoleCommand;
     class Executor;
     template <class T>

code/branches/consolecommands3/src/libraries/core/GUIManager.cc

@@ -71 +71 @@
     static void key_esc()
         { GUIManager::getInstance().keyESC(); }
-    _SetConsoleCommand("keyESC", &key_esc);
+    SetConsoleCommand("keyESC", &key_esc);
 
     class CEGUILogger : public CEGUI::DefaultLogger
@@ -99 +99 @@
     GUIManager* GUIManager::singletonPtr_s = 0;
 
-    _SetConsoleCommand("showGUI", &GUIManager::showGUI).defaultValue(1, false).defaultValue(2, true);
-    _SetConsoleCommand("hideGUI", &GUIManager::hideGUI);
+    SetConsoleCommand("showGUI", &GUIManager::showGUI).defaultValue(1, false).defaultValue(2, true);
+    SetConsoleCommand("hideGUI", &GUIManager::hideGUI);
 
     /**

code/branches/consolecommands3/src/libraries/core/Game.cc

@@ -57 +57 @@
     static void stop_game()
         { Game::getInstance().stop(); }
-    _SetConsoleCommand("exit", &stop_game);
+    SetConsoleCommand("exit", &stop_game);
     static void printFPS()
         { COUT(0) << Game::getInstance().getAvgFPS() << std::endl; }
-    _SetConsoleCommand("printFPS", &printFPS);
+    SetConsoleCommand("printFPS", &printFPS);
     static void printTickTime()
         { COUT(0) << Game::getInstance().getAvgTickTime() << std::endl; }
-    _SetConsoleCommand("printTickTime", &printTickTime);
+    SetConsoleCommand("printTickTime", &printTickTime);
 
     std::map<std::string, GameStateInfo> Game::gameStateDeclarations_s;

code/branches/consolecommands3/src/libraries/core/GraphicsManager.cc

@@ -66 +66 @@
 {
     static const std::string __CC_printScreen_name = "printScreen";
-    _DeclareConsoleCommand(__CC_printScreen_name, &prototype::void__void);
+    DeclareConsoleCommand(__CC_printScreen_name, &prototype::void__void);
 
     class OgreWindowEventListener : public Ogre::WindowEventListener
@@ -134 +134 @@
 
         Ogre::WindowEventUtilities::removeWindowEventListener(renderWindow_, ogreWindowEventListener_.get());
-        _ModifyConsoleCommand(__CC_printScreen_name).resetFunction();
+        ModifyConsoleCommand(__CC_printScreen_name).resetFunction();
 
         // Undeclare the resources
@@ -324 +324 @@
 
         // add console commands
-        _ModifyConsoleCommand(__CC_printScreen_name).setFunction(&GraphicsManager::printScreen, this);
+        ModifyConsoleCommand(__CC_printScreen_name).setFunction(&GraphicsManager::printScreen, this);
     }
 

code/branches/consolecommands3/src/libraries/core/command/ArgumentCompletionFunctions.cc

@@ -60 +60 @@
         namespace detail
         {
-            bool groupIsVisible(const std::map<std::string, _ConsoleCommand*>& group, bool bOnlyShowHidden)
-            {
-                for (std::map<std::string, _ConsoleCommand*>::const_iterator it_command = group.begin(); it_command != group.end(); ++it_command)
+            bool groupIsVisible(const std::map<std::string, ConsoleCommand*>& group, bool bOnlyShowHidden)
+            {
+                for (std::map<std::string, ConsoleCommand*>::const_iterator it_command = group.begin(); it_command != group.end(); ++it_command)
                     if (it_command->second->isActive() && it_command->second->hasAccess() && (!it_command->second->isHidden())^bOnlyShowHidden)
                         return true;
@@ -74 +74 @@
                 std::string fragmentLC = getLowercase(fragment);
 
-                const std::map<std::string, std::map<std::string, _ConsoleCommand*> >& commands = _ConsoleCommand::getCommands();
-                for (std::map<std::string, std::map<std::string, _ConsoleCommand*> >::const_iterator it_group = commands.begin(); it_group != commands.end(); ++it_group)
+                const std::map<std::string, std::map<std::string, ConsoleCommand*> >& commands = ConsoleCommand::getCommands();
+                for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = commands.begin(); it_group != commands.end(); ++it_group)
                     if (groupIsVisible(it_group->second, bOnlyShowHidden) && it_group->first != "" && (fragmentLC == "" || getLowercase(it_group->first).find_first_of(fragmentLC) == 0))
                         groupList.push_back(ArgumentCompletionListElement(it_group->first, getLowercase(it_group->first)));
 
-                std::map<std::string, std::map<std::string, _ConsoleCommand*> >::const_iterator it_group = commands.find("");
+                std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = commands.find("");
                 if (it_group != commands.end())
                 {
@@ -85 +85 @@
                         groupList.push_back(ArgumentCompletionListElement("", "", "\n"));
 
-                    for (std::map<std::string, _ConsoleCommand*>::const_iterator it_command = it_group->second.begin(); it_command != it_group->second.end(); ++it_command)
+                    for (std::map<std::string, ConsoleCommand*>::const_iterator it_command = it_group->second.begin(); it_command != it_group->second.end(); ++it_command)
                         if (it_command->second->isActive() && it_command->second->hasAccess() && (!it_command->second->isHidden())^bOnlyShowHidden && (fragmentLC == "" || getLowercase(it_command->first).find_first_of(fragmentLC) == 0))
                             groupList.push_back(ArgumentCompletionListElement(it_command->first, getLowercase(it_command->first)));
@@ -102 +102 @@
                 std::string groupLC = getLowercase(group);
 
-                std::map<std::string, std::map<std::string, _ConsoleCommand*> >::const_iterator it_group = _ConsoleCommand::getCommands().begin();
-                for ( ; it_group != _ConsoleCommand::getCommands().end(); ++it_group)
+                std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommands().begin();
+                for ( ; it_group != ConsoleCommand::getCommands().end(); ++it_group)
                     if (getLowercase(it_group->first) == groupLC)
                         break;
 
-                if (it_group != _ConsoleCommand::getCommands().end())
-                {
-                    for (std::map<std::string, _ConsoleCommand*>::const_iterator it_command = it_group->second.begin(); it_command != it_group->second.end(); ++it_command)
+                if (it_group != ConsoleCommand::getCommands().end())
+                {
+                    for (std::map<std::string, ConsoleCommand*>::const_iterator it_command = it_group->second.begin(); it_command != it_group->second.end(); ++it_command)
                         if (it_command->second->isActive() && it_command->second->hasAccess() && (!it_command->second->isHidden())^bOnlyShowHidden)
                             commandList.push_back(ArgumentCompletionListElement(it_command->first, getLowercase(it_command->first)));
@@ -152 +152 @@
                 return detail::_groupsandcommands(fragment, true);
 
-            if (_ConsoleCommand::getCommandLC(getLowercase(tokens[0])))
+            if (ConsoleCommand::getCommandLC(getLowercase(tokens[0])))
                 return ARGUMENT_COMPLETION_FUNCTION_CALL(command)(fragment);
 
             if (tokens.size() == 1)
             {
-                std::map<std::string, std::map<std::string, _ConsoleCommand*> >::const_iterator it_group = _ConsoleCommand::getCommands().find(tokens[0]);
-                if (it_group != _ConsoleCommand::getCommands().end())
+                std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommands().find(tokens[0]);
+                if (it_group != ConsoleCommand::getCommands().end())
                     return detail::_subcommands(fragment, tokens[0], true);
                 else
@@ -164 +164 @@
             }
 
-            if (_ConsoleCommand::getCommandLC(getLowercase(tokens[0]), getLowercase(tokens[1])))
+            if (ConsoleCommand::getCommandLC(getLowercase(tokens[0]), getLowercase(tokens[1])))
                 return ARGUMENT_COMPLETION_FUNCTION_CALL(command)(fragment);
 

code/branches/consolecommands3/src/libraries/core/command/CommandEvaluation.cc

@@ -213 +213 @@
             {
                 std::string groupLC = getLowercase(this->getToken(0));
-                std::map<std::string, std::map<std::string, _ConsoleCommand*> >::const_iterator it_group = _ConsoleCommand::getCommands().begin();
-                for ( ; it_group != _ConsoleCommand::getCommands().end(); ++it_group)
+                std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommands().begin();
+                for ( ; it_group != ConsoleCommand::getCommands().end(); ++it_group)
                     if (getLowercase(it_group->first) == groupLC)
                         return std::string("Error: There is no command in group \"") + this->getToken(0) + "\" starting with \"" + this->getToken(1) + "\".";
@@ -380 +380 @@
     }
 
-    /* static */ std::string CommandEvaluation::dump(const _ConsoleCommand* command)
+    /* static */ std::string CommandEvaluation::dump(const ConsoleCommand* command)
     {
         std::string output = command->getName();

code/branches/consolecommands3/src/libraries/core/command/CommandEvaluation.h

@@ -59 +59 @@
                 { return (this->execCommand_ != 0); }
 
-            inline _ConsoleCommand* getConsoleCommand() const
+            inline ConsoleCommand* getConsoleCommand() const
                 { return this->execCommand_; }
 
@@ -84 +84 @@
 
             static std::string dump(const ArgumentCompletionList& list);
-            static std::string dump(const _ConsoleCommand* command);
+            static std::string dump(const ConsoleCommand* command);
 
             static std::string getCommonBegin(const ArgumentCompletionList& list);
 
-            _ConsoleCommand* execCommand_;
-            _ConsoleCommand* hintCommand_;
+            ConsoleCommand* execCommand_;
+            ConsoleCommand* hintCommand_;
             SubString tokens_;
             std::string string_;

code/branches/consolecommands3/src/libraries/core/command/CommandExecutor.cc

@@ -38 +38 @@
     static const std::string __CC_autocomplete_name = "autocomplete";
 
-    _SetConsoleCommand(__CC_CommandExecutor_name, __CC_autocomplete_name, &CommandExecutor::_autocomplete)
+    SetConsoleCommand(__CC_CommandExecutor_name, __CC_autocomplete_name, &CommandExecutor::_autocomplete)
         .hide()
         .argumentCompleter(0, autocompletion::groupsandcommands())
         .argumentCompleter(1, autocompletion::subcommands());
 
-    _SetConsoleCommand("unhide", &CommandExecutor::unhide)
+    SetConsoleCommand("unhide", &CommandExecutor::unhide)
         .argumentCompleter(0, autocompletion::hiddencommand());
 
@@ -87 +87 @@
         evaluation.initialize(command);
 
-        evaluation.hintCommand_ = _ConsoleCommand::getCommand(__CC_CommandExecutor_name, __CC_autocomplete_name);
+        evaluation.hintCommand_ = ConsoleCommand::getCommand(__CC_CommandExecutor_name, __CC_autocomplete_name);
 
         if (evaluation.getNumberOfArguments() >= 1)
         {
-            evaluation.execCommand_ = _ConsoleCommand::getCommandLC(evaluation.getToken(0));
+            evaluation.execCommand_ = ConsoleCommand::getCommandLC(evaluation.getToken(0));
             if (evaluation.execCommand_)
                 evaluation.execArgumentsOffset_ = 1;
             else if (evaluation.getNumberOfArguments() >= 2)
             {
-                evaluation.execCommand_ = _ConsoleCommand::getCommandLC(evaluation.getToken(0), evaluation.getToken(1));
+                evaluation.execCommand_ = ConsoleCommand::getCommandLC(evaluation.getToken(0), evaluation.getToken(1));
                 if (evaluation.execCommand_)
                     evaluation.execArgumentsOffset_ = 2;

code/branches/consolecommands3/src/libraries/core/command/ConsoleCommand.cc

@@ -36 +36 @@
 namespace orxonox
 {
-    _ConsoleCommand::_ConsoleCommand(const std::string& group, const std::string& name, const ExecutorPtr& executor, bool bInitialized)
+    ConsoleCommand::ConsoleCommand(const std::string& group, const std::string& name, const ExecutorPtr& executor, bool bInitialized)
     {
         this->bActive_ = true;
@@ -57 +57 @@
             this->executor_ = executor;
 
-        _ConsoleCommand::registerCommand(group, name, this);
-    }
-
-    _ConsoleCommand::~_ConsoleCommand()
-    {
-        _ConsoleCommand::unregisterCommand(this);
-    }
-
-    _ConsoleCommand& _ConsoleCommand::addShortcut()
-    {
-        _ConsoleCommand::registerCommand("", this->baseName_, this);
-        return *this;
-    }
-
-    _ConsoleCommand& _ConsoleCommand::addShortcut(const std::string&  name)
-    {
-        _ConsoleCommand::registerCommand("", name, this);
-        return *this;
-    }
-
-    _ConsoleCommand& _ConsoleCommand::addGroup(const std::string& group)
-    {
-        _ConsoleCommand::registerCommand(group, this->baseName_, this);
-        return *this;
-    }
-
-    _ConsoleCommand& _ConsoleCommand::addGroup(const std::string& group, const std::string&  name)
-    {
-        _ConsoleCommand::registerCommand(group, name, this);
-        return *this;
-    }
-
-    bool _ConsoleCommand::isActive() const
+        ConsoleCommand::registerCommand(group, name, this);
+    }
+
+    ConsoleCommand::~ConsoleCommand()
+    {
+        ConsoleCommand::unregisterCommand(this);
+    }
+
+    ConsoleCommand& ConsoleCommand::addShortcut()
+    {
+        ConsoleCommand::registerCommand("", this->baseName_, this);
+        return *this;
+    }
+
+    ConsoleCommand& ConsoleCommand::addShortcut(const std::string&  name)
+    {
+        ConsoleCommand::registerCommand("", name, this);
+        return *this;
+    }
+
+    ConsoleCommand& ConsoleCommand::addGroup(const std::string& group)
+    {
+        ConsoleCommand::registerCommand(group, this->baseName_, this);
+        return *this;
+    }
+
+    ConsoleCommand& ConsoleCommand::addGroup(const std::string& group, const std::string&  name)
+    {
+        ConsoleCommand::registerCommand(group, name, this);
+        return *this;
+    }
+
+    bool ConsoleCommand::isActive() const
     {
         return (this->bActive_ && this->executor_ && this->executor_->getFunctor() && (this->executor_->getFunctor()->getType() == Functor::Type::Static || this->executor_->getFunctor()->getRawObjectPointer()));
     }
 
-    bool _ConsoleCommand::hasAccess() const
+    bool ConsoleCommand::hasAccess() const
     {
         switch (this->accessLevel_)
@@ -110 +110 @@
     }
 
-    bool _ConsoleCommand::headersMatch(const FunctorPtr& functor)
+    bool ConsoleCommand::headersMatch(const FunctorPtr& functor)
     {
         unsigned int minparams = std::min(this->baseExecutor_->getParamCount(), functor->getParamCount());
@@ -130 +130 @@
     }
 
-    bool _ConsoleCommand::headersMatch(const ExecutorPtr& executor)
+    bool ConsoleCommand::headersMatch(const ExecutorPtr& executor)
     {
         unsigned int minparams = std::min(this->baseExecutor_->getParamCount(), executor->getParamCount());
@@ -148 +148 @@
     }
 
-    bool _ConsoleCommand::setFunction(const ExecutorPtr& executor, bool bForce)
+    bool ConsoleCommand::setFunction(const ExecutorPtr& executor, bool bForce)
     {
         if (!executor || !executor->getFunctor() || bForce || this->headersMatch(executor))
@@ -162 +162 @@
     }
 
-    bool _ConsoleCommand::setFunction(const FunctorPtr& functor, bool bForce)
+    bool ConsoleCommand::setFunction(const FunctorPtr& functor, bool bForce)
     {
         if (!functor || bForce || this->headersMatch(functor))
@@ -180 +180 @@
     }
 
-    void _ConsoleCommand::pushFunction(const ExecutorPtr& executor, bool bForce)
+    void ConsoleCommand::pushFunction(const ExecutorPtr& executor, bool bForce)
     {
         Command command;
@@ -191 +191 @@
     }
 
-    void _ConsoleCommand::pushFunction(const FunctorPtr& functor, bool bForce)
+    void ConsoleCommand::pushFunction(const FunctorPtr& functor, bool bForce)
     {
         Command command;
@@ -202 +202 @@
     }
 
-    void _ConsoleCommand::pushFunction()
+    void ConsoleCommand::pushFunction()
     {
         if (this->executor_)
@@ -210 +210 @@
     }
 
-    void _ConsoleCommand::popFunction()
+    void ConsoleCommand::popFunction()
     {
         Command command;
@@ -224 +224 @@
     }
 
-    void _ConsoleCommand::resetFunction()
+    void ConsoleCommand::resetFunction()
     {
         if (this->executor_)
@@ -230 +230 @@
     }
 
-    const ExecutorPtr& _ConsoleCommand::getExecutor() const
+    const ExecutorPtr& ConsoleCommand::getExecutor() const
     {
         return this->executor_;
     }
 
-    bool _ConsoleCommand::setObject(void* object)
+    bool ConsoleCommand::setObject(void* object)
     {
         if (this->executor_)
@@ -253 +253 @@
     }
 
-    void _ConsoleCommand::pushObject(void* object)
+    void ConsoleCommand::pushObject(void* object)
     {
         void* oldobject = this->getObject();
@@ -260 +260 @@
     }
 
-    void _ConsoleCommand::popObject()
+    void ConsoleCommand::popObject()
     {
         void* newobject = 0;
@@ -271 +271 @@
     }
 
-    void* _ConsoleCommand::getObject() const
+    void* ConsoleCommand::getObject() const
     {
         if (this->executor_ && this->executor_->getFunctor())
@@ -279 +279 @@
     }
 
-    _ConsoleCommand& _ConsoleCommand::defaultValues(const MultiType& param1)
+    ConsoleCommand& ConsoleCommand::defaultValues(const MultiType& param1)
     {
         if (this->executor_)
@@ -289 +289 @@
     }
 
-    _ConsoleCommand& _ConsoleCommand::defaultValues(const MultiType& param1, const MultiType& param2)
+    ConsoleCommand& ConsoleCommand::defaultValues(const MultiType& param1, const MultiType& param2)
     {
         if (this->executor_)
@@ -299 +299 @@
     }
 
-    _ConsoleCommand& _ConsoleCommand::defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3)
+    ConsoleCommand& ConsoleCommand::defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3)
     {
         if (this->executor_)
@@ -309 +309 @@
     }
 
-    _ConsoleCommand& _ConsoleCommand::defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4)
+    ConsoleCommand& ConsoleCommand::defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4)
     {
         if (this->executor_)
@@ -319 +319 @@
     }
 
-    _ConsoleCommand& _ConsoleCommand::defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
+    ConsoleCommand& ConsoleCommand::defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
     {
         if (this->executor_)
@@ -329 +329 @@
     }
 
-    _ConsoleCommand& _ConsoleCommand::defaultValue(unsigned int index, const MultiType& param)
+    ConsoleCommand& ConsoleCommand::defaultValue(unsigned int index, const MultiType& param)
     {
         if (this->executor_)
@@ -339 +339 @@
     }
 
-    _ConsoleCommand& _ConsoleCommand::argumentCompleter(unsigned int param, ArgumentCompleter* completer)
+    ConsoleCommand& ConsoleCommand::argumentCompleter(unsigned int param, ArgumentCompleter* completer)
     {
         if (param < 5)
@@ -349 +349 @@
     }
 
-    ArgumentCompleter* _ConsoleCommand::getArgumentCompleter(unsigned int param) const
+    ArgumentCompleter* ConsoleCommand::getArgumentCompleter(unsigned int param) const
     {
         if (param < 5)
@@ -357 +357 @@
     }
 
-    _ConsoleCommand& _ConsoleCommand::description(const std::string& description)
+    ConsoleCommand& ConsoleCommand::description(const std::string& description)
     {
         this->description_ = std::string("ConsoleCommandDescription::" + this->baseName_ + "::function");
@@ -364 +364 @@
     }
 
-    const std::string& _ConsoleCommand::getDescription() const
+    const std::string& ConsoleCommand::getDescription() const
     {
         return GetLocalisation_noerror(this->description_);
     }
 
-    _ConsoleCommand& _ConsoleCommand::descriptionParam(unsigned int param, const std::string& description)
+    ConsoleCommand& ConsoleCommand::descriptionParam(unsigned int param, const std::string& description)
     {
         if (param < MAX_FUNCTOR_ARGUMENTS)
@@ -379 +379 @@
     }
 
-    const std::string& _ConsoleCommand::getDescriptionParam(unsigned int param) const
+    const std::string& ConsoleCommand::getDescriptionParam(unsigned int param) const
     {
         if (param < MAX_FUNCTOR_ARGUMENTS)
@@ -387 +387 @@
     }
 
-    _ConsoleCommand& _ConsoleCommand::descriptionReturnvalue(const std::string& description)
+    ConsoleCommand& ConsoleCommand::descriptionReturnvalue(const std::string& description)
     {
         this->descriptionReturnvalue_ = std::string("ConsoleCommandDescription::" + this->baseName_ + "::returnvalue");
@@ -394 +394 @@
     }
 
-    const std::string& _ConsoleCommand::getDescriptionReturnvalue(int param) const
+    const std::string& ConsoleCommand::getDescriptionReturnvalue(int param) const
     {
         return GetLocalisation_noerror(this->descriptionReturnvalue_);
     }
 
-    /* static */ _ConsoleCommand* _ConsoleCommand::getCommand(const std::string& group, const std::string& name, bool bPrintError)
-    {
-        std::map<std::string, std::map<std::string, _ConsoleCommand*> >::const_iterator it_group = _ConsoleCommand::getCommandMap().find(group);
-        if (it_group != _ConsoleCommand::getCommandMap().end())
-        {
-            std::map<std::string, _ConsoleCommand*>::const_iterator it_name = it_group->second.find(name);
+    /* static */ ConsoleCommand* ConsoleCommand::getCommand(const std::string& group, const std::string& name, bool bPrintError)
+    {
+        std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommandMap().find(group);
+        if (it_group != ConsoleCommand::getCommandMap().end())
+        {
+            std::map<std::string, ConsoleCommand*>::const_iterator it_name = it_group->second.find(name);
             if (it_name != it_group->second.end())
             {
@@ -420 +420 @@
     }
 
-    /* static */ _ConsoleCommand* _ConsoleCommand::getCommandLC(const std::string& group, const std::string& name, bool bPrintError)
+    /* static */ ConsoleCommand* ConsoleCommand::getCommandLC(const std::string& group, const std::string& name, bool bPrintError)
     {
         std::string groupLC = getLowercase(group);
         std::string nameLC = getLowercase(name);
 
-        std::map<std::string, std::map<std::string, _ConsoleCommand*> >::const_iterator it_group = _ConsoleCommand::getCommandMapLC().find(groupLC);
-        if (it_group != _ConsoleCommand::getCommandMapLC().end())
-        {
-            std::map<std::string, _ConsoleCommand*>::const_iterator it_name = it_group->second.find(nameLC);
+        std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommandMapLC().find(groupLC);
+        if (it_group != ConsoleCommand::getCommandMapLC().end())
+        {
+            std::map<std::string, ConsoleCommand*>::const_iterator it_name = it_group->second.find(nameLC);
             if (it_name != it_group->second.end())
             {
@@ -444 +444 @@
     }
 
-    /* static */ std::map<std::string, std::map<std::string, _ConsoleCommand*> >& _ConsoleCommand::getCommandMap()
-    {
-        static std::map<std::string, std::map<std::string, _ConsoleCommand*> > commandMap;
+    /* static */ std::map<std::string, std::map<std::string, ConsoleCommand*> >& ConsoleCommand::getCommandMap()
+    {
+        static std::map<std::string, std::map<std::string, ConsoleCommand*> > commandMap;
         return commandMap;
     }
 
-    /* static */ std::map<std::string, std::map<std::string, _ConsoleCommand*> >& _ConsoleCommand::getCommandMapLC()
-    {
-        static std::map<std::string, std::map<std::string, _ConsoleCommand*> > commandMapLC;
+    /* static */ std::map<std::string, std::map<std::string, ConsoleCommand*> >& ConsoleCommand::getCommandMapLC()
+    {
+        static std::map<std::string, std::map<std::string, ConsoleCommand*> > commandMapLC;
         return commandMapLC;
     }
 
-    /* static */ void _ConsoleCommand::registerCommand(const std::string& group, const std::string& name, _ConsoleCommand* command)
+    /* static */ void ConsoleCommand::registerCommand(const std::string& group, const std::string& name, ConsoleCommand* command)
     {
         if (name == "")
             return;
 
-        if (_ConsoleCommand::getCommand(group, name) != 0)
+        if (ConsoleCommand::getCommand(group, name) != 0)
         {
             if (group == "")
@@ -470 +470 @@
         else
         {
-            _ConsoleCommand::getCommandMap()[group][name] = command;
-            _ConsoleCommand::getCommandMapLC()[getLowercase(group)][getLowercase(name)] = command;
-        }
-    }
-
-    /* static */ void _ConsoleCommand::unregisterCommand(_ConsoleCommand* command)
-    {
-        for (std::map<std::string, std::map<std::string, _ConsoleCommand*> >::iterator it_group = _ConsoleCommand::getCommandMap().begin(); it_group != _ConsoleCommand::getCommandMap().end(); )
-        {
-            for (std::map<std::string, _ConsoleCommand*>::iterator it_name = it_group->second.begin(); it_name != it_group->second.end(); )
+            ConsoleCommand::getCommandMap()[group][name] = command;
+            ConsoleCommand::getCommandMapLC()[getLowercase(group)][getLowercase(name)] = command;
+        }
+    }
+
+    /* static */ void ConsoleCommand::unregisterCommand(ConsoleCommand* command)
+    {
+        for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::iterator it_group = ConsoleCommand::getCommandMap().begin(); it_group != ConsoleCommand::getCommandMap().end(); )
+        {
+            for (std::map<std::string, ConsoleCommand*>::iterator it_name = it_group->second.begin(); it_name != it_group->second.end(); )
             {
                 if (it_name->second == command)
@@ -488 +488 @@
 
             if (it_group->second.empty())
-                _ConsoleCommand::getCommandMap().erase(it_group++);
+                ConsoleCommand::getCommandMap().erase(it_group++);
             else
                 ++it_group;
         }
 
-        for (std::map<std::string, std::map<std::string, _ConsoleCommand*> >::iterator it_group = _ConsoleCommand::getCommandMapLC().begin(); it_group != _ConsoleCommand::getCommandMapLC().end(); )
-        {
-            for (std::map<std::string, _ConsoleCommand*>::iterator it_name = it_group->second.begin(); it_name != it_group->second.end(); )
+        for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::iterator it_group = ConsoleCommand::getCommandMapLC().begin(); it_group != ConsoleCommand::getCommandMapLC().end(); )
+        {
+            for (std::map<std::string, ConsoleCommand*>::iterator it_name = it_group->second.begin(); it_name != it_group->second.end(); )
             {
                 if (it_name->second == command)
@@ -504 +504 @@
 
             if (it_group->second.empty())
-                _ConsoleCommand::getCommandMapLC().erase(it_group++);
+                ConsoleCommand::getCommandMapLC().erase(it_group++);
             else
                 ++it_group;
@@ -510 +510 @@
     }
 
-    /* static */ void _ConsoleCommand::destroyAll()
-    {
-        while (!_ConsoleCommand::getCommandMap().empty() && !_ConsoleCommand::getCommandMap().begin()->second.empty())
-            delete _ConsoleCommand::getCommandMap().begin()->second.begin()->second;
+    /* static */ void ConsoleCommand::destroyAll()
+    {
+        while (!ConsoleCommand::getCommandMap().empty() && !ConsoleCommand::getCommandMap().begin()->second.empty())
+            delete ConsoleCommand::getCommandMap().begin()->second.begin()->second;
     }
 }

code/branches/consolecommands3/src/libraries/core/command/ConsoleCommand.h

@@ -41 +41 @@
 
 
-#define _SetConsoleCommand(...) \
-    BOOST_PP_EXPAND(BOOST_PP_CAT(_SetConsoleCommand, ORXONOX_VA_NARGS(__VA_ARGS__))(__VA_ARGS__))
-#define _SetConsoleCommand2(name, functionpointer) \
-    _SetConsoleCommandGeneric("", name, orxonox::createFunctor(functionpointer))
-#define _SetConsoleCommand3(group, name, functionpointer) \
-    _SetConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer))
-#define _SetConsoleCommand4(group, name, functionpointer, object) \
-    _SetConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer, object))
-
-#define _SetConsoleCommandGeneric(group, name, functor) \
-    static orxonox::_ConsoleCommand& BOOST_PP_CAT(__consolecommand_, __LINE__) = (*orxonox::_createConsoleCommand(group, name, orxonox::createExecutor(functor)))
-
-
-#define _DeclareConsoleCommand(...) \
-    BOOST_PP_CAT(_DeclareConsoleCommand, ORXONOX_VA_NARGS(__VA_ARGS__))(__VA_ARGS__)
-#define _DeclareConsoleCommand2(name, functionpointer) \
-    _DeclareConsoleCommandGeneric("", name, orxonox::createFunctor(functionpointer))
-#define _DeclareConsoleCommand3(group, name, functionpointer) \
-    _DeclareConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer))
-#define _DeclareConsoleCommand4(group, name, functionpointer, object) \
-    _DeclareConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer, object))
-
-#define _DeclareConsoleCommandGeneric(group, name, functor) \
-    static orxonox::_ConsoleCommand& BOOST_PP_CAT(__consolecommand_, __LINE__) = (*orxonox::_createConsoleCommand(group, name, orxonox::createExecutor(functor), false))
+#define SetConsoleCommand(...) \
+    BOOST_PP_EXPAND(BOOST_PP_CAT(SetConsoleCommand, ORXONOX_VA_NARGS(__VA_ARGS__))(__VA_ARGS__))
+#define SetConsoleCommand2(name, functionpointer) \
+    SetConsoleCommandGeneric("", name, orxonox::createFunctor(functionpointer))
+#define SetConsoleCommand3(group, name, functionpointer) \
+    SetConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer))
+#define SetConsoleCommand4(group, name, functionpointer, object) \
+    SetConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer, object))
+
+#define SetConsoleCommandGeneric(group, name, functor) \
+    static orxonox::ConsoleCommand& BOOST_PP_CAT(__consolecommand_, __LINE__) = (*orxonox::createConsoleCommand(group, name, orxonox::createExecutor(functor)))
+
+
+#define DeclareConsoleCommand(...) \
+    BOOST_PP_CAT(DeclareConsoleCommand, ORXONOX_VA_NARGS(__VA_ARGS__))(__VA_ARGS__)
+#define DeclareConsoleCommand2(name, functionpointer) \
+    DeclareConsoleCommandGeneric("", name, orxonox::createFunctor(functionpointer))
+#define DeclareConsoleCommand3(group, name, functionpointer) \
+    DeclareConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer))
+#define DeclareConsoleCommand4(group, name, functionpointer, object) \
+    DeclareConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer, object))
+
+#define DeclareConsoleCommandGeneric(group, name, functor) \
+    static orxonox::ConsoleCommand& BOOST_PP_CAT(__consolecommand_, __LINE__) = (*orxonox::createConsoleCommand(group, name, orxonox::createExecutor(functor), false))
 
 
@@ -90 +90 @@
     }
 
-    class _CoreExport _ConsoleCommand
+    class _CoreExport ConsoleCommand
     {
-        friend struct _ConsoleCommandManipulator;
+        friend struct ConsoleCommandManipulator;
 
         struct Command
@@ -101 +101 @@
 
         public:
-            struct _ConsoleCommandManipulator
+            struct ConsoleCommandManipulator
             {
                 public:
-                    _ConsoleCommandManipulator(const _ConsoleCommand* command) : command_(const_cast<_ConsoleCommand*>(command)) {}
+                    ConsoleCommandManipulator(const ConsoleCommand* command) : command_(const_cast<ConsoleCommand*>(command)) {}
 
                     template <class F>
-                    inline _ConsoleCommandManipulator& setFunction(F function, bool bForce = false)
+                    inline ConsoleCommandManipulator& setFunction(F function, bool bForce = false)
                         {
                             if (this->command_)
@@ -122 +122 @@
                         }
                     template <class F, class O>
-                    inline _ConsoleCommandManipulator& setFunction(F function, O* object, bool bForce = false)
+                    inline ConsoleCommandManipulator& setFunction(F function, O* object, bool bForce = false)
                         {
                             if (this->command_)
@@ -137 +137 @@
                             return *this;
                         }
-                    inline _ConsoleCommandManipulator& setFunction(const FunctorPtr& functor, bool bForce = false)
+                    inline ConsoleCommandManipulator& setFunction(const FunctorPtr& functor, bool bForce = false)
                         { if (this->command_) { this->command_->setFunction(functor, bForce); } return *this; }
-                    inline _ConsoleCommandManipulator& setFunction(const ExecutorPtr& executor, bool bForce = false)
+                    inline ConsoleCommandManipulator& setFunction(const ExecutorPtr& executor, bool bForce = false)
                         { if (this->command_) { this->command_->setFunction(executor, bForce); } return *this; }
 
                     template <class F>
-                    inline _ConsoleCommandManipulator& pushFunction(F function, bool bForce = false)
+                    inline ConsoleCommandManipulator& pushFunction(F function, bool bForce = false)
                         { if (this->command_) { this->command_->pushFunction(createFunctor(function), bForce); } return *this; }
                     template <class F, class O>
-                    inline _ConsoleCommandManipulator& pushFunction(F function, O* object, bool bForce = false)
+                    inline ConsoleCommandManipulator& pushFunction(F function, O* object, bool bForce = false)
                         { if (this->command_) { this->command_->pushFunction(createFunctor(function, object), bForce); } return *this; }
-                    inline _ConsoleCommandManipulator& pushFunction(const FunctorPtr& functor, bool bForce = false)
+                    inline ConsoleCommandManipulator& pushFunction(const FunctorPtr& functor, bool bForce = false)
                         { if (this->command_) { this->command_->pushFunction(functor, bForce); } return *this; }
-                    inline _ConsoleCommandManipulator& pushFunction(const ExecutorPtr& executor, bool bForce = false)
+                    inline ConsoleCommandManipulator& pushFunction(const ExecutorPtr& executor, bool bForce = false)
                         { if (this->command_) { this->command_->pushFunction(executor, bForce); } return *this; }
 
-                    inline _ConsoleCommandManipulator& popFunction()
+                    inline ConsoleCommandManipulator& popFunction()
                         { if (this->command_) { this->command_->popFunction(); } return *this; }
 
-                    inline _ConsoleCommandManipulator& resetFunction()
+                    inline ConsoleCommandManipulator& resetFunction()
                         { if (this->command_) { this->command_->resetFunction(); } return *this; }
 
-                    inline _ConsoleCommandManipulator& setObject(void* object)
+                    inline ConsoleCommandManipulator& setObject(void* object)
                         { if (this->command_) { this->command_->setObject(object); } return *this; }
-                    inline _ConsoleCommandManipulator& pushObject(void* object)
+                    inline ConsoleCommandManipulator& pushObject(void* object)
                         { if (this->command_) { this->command_->pushObject(object); } return *this; }
-                    inline _ConsoleCommandManipulator& popObject()
+                    inline ConsoleCommandManipulator& popObject()
                         { if (this->command_) { this->command_->popObject(); } return *this; }
 
-                    inline _ConsoleCommandManipulator& setActive(bool bActive)
+                    inline ConsoleCommandManipulator& setActive(bool bActive)
                         { if (this->command_) { this->command_->setActive(bActive); } return *this; }
-                    inline _ConsoleCommandManipulator& activate()
+                    inline ConsoleCommandManipulator& activate()
                         { return this->setActive(true); }
-                    inline _ConsoleCommandManipulator& deactivate()
+                    inline ConsoleCommandManipulator& deactivate()
                         { return this->setActive(false); }
 
-                    inline _ConsoleCommandManipulator& setHidden(bool bHidden)
+                    inline ConsoleCommandManipulator& setHidden(bool bHidden)
                         { if (this->command_) { this->command_->setHidden(bHidden); } return *this; }
-                    inline _ConsoleCommandManipulator& hide()
+                    inline ConsoleCommandManipulator& hide()
                         { return this->setHidden(true); }
-                    inline _ConsoleCommandManipulator& show()
+                    inline ConsoleCommandManipulator& show()
                         { return this->setHidden(false); }
 
-                    inline _ConsoleCommandManipulator& defaultValues(const MultiType& param1)
+                    inline ConsoleCommandManipulator& defaultValues(const MultiType& param1)
                         { if (this->command_) { this->command_->defaultValues(param1); } return *this; }
-                    inline _ConsoleCommandManipulator& defaultValues(const MultiType& param1, const MultiType& param2)
+                    inline ConsoleCommandManipulator& defaultValues(const MultiType& param1, const MultiType& param2)
                         { if (this->command_) { this->command_->defaultValues(param1, param2); } return *this; }
-                    inline _ConsoleCommandManipulator& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3)
+                    inline ConsoleCommandManipulator& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3)
                         { if (this->command_) { this->command_->defaultValues(param1, param2, param3); } return *this; }
-                    inline _ConsoleCommandManipulator& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4)
+                    inline ConsoleCommandManipulator& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4)
                         { if (this->command_) { this->command_->defaultValues(param1, param2, param3, param4); } return *this; }
-                    inline _ConsoleCommandManipulator& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
+                    inline ConsoleCommandManipulator& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
                         { if (this->command_) { this->command_->defaultValues(param1, param2, param3, param4, param5); } return *this; }
-                    inline _ConsoleCommandManipulator& defaultValue(unsigned int index, const MultiType& param)
+                    inline ConsoleCommandManipulator& defaultValue(unsigned int index, const MultiType& param)
                         { if (this->command_) { this->command_->defaultValue(index, param); } return *this; }
 
-                    inline _ConsoleCommandManipulator& accessLevel(AccessLevel::Enum level)
+                    inline ConsoleCommandManipulator& accessLevel(AccessLevel::Enum level)
                         { if (this->command_) { this->command_->accessLevel(level); } return *this; }
 
-                    inline _ConsoleCommandManipulator& argumentCompleter(unsigned int param, ArgumentCompleter* completer)
+                    inline ConsoleCommandManipulator& argumentCompleter(unsigned int param, ArgumentCompleter* completer)
                         { if (this->command_) { this->command_->argumentCompleter(param, completer); } return *this; }
 
-                    inline _ConsoleCommandManipulator& setAsInputCommand()
+                    inline ConsoleCommandManipulator& setAsInputCommand()
                         { if (this->command_) { this->command_->setAsInputCommand(); } return *this; }
-                    inline _ConsoleCommandManipulator& keybindMode(KeybindMode::Value mode)
+                    inline ConsoleCommandManipulator& keybindMode(KeybindMode::Value mode)
                         { if (this->command_) { this->command_->keybindMode(mode); } return *this; }
-                    inline _ConsoleCommandManipulator& inputConfiguredParam(int index)
+                    inline ConsoleCommandManipulator& inputConfiguredParam(int index)
                         { if (this->command_) { this->command_->inputConfiguredParam(index); } return *this; }
 
                 private:
-                    _ConsoleCommand* command_;
+                    ConsoleCommand* command_;
             };
 
         public:
-            _ConsoleCommand(const std::string& group, const std::string& name, const ExecutorPtr& executor, bool bInitialized = true);
-            ~_ConsoleCommand();
-
-            _ConsoleCommand& addShortcut();
-            _ConsoleCommand& addShortcut(const std::string&  name);
-            _ConsoleCommand& addGroup(const std::string& group);
-            _ConsoleCommand& addGroup(const std::string& group, const std::string&  name);
+            ConsoleCommand(const std::string& group, const std::string& name, const ExecutorPtr& executor, bool bInitialized = true);
+            ~ConsoleCommand();
+
+            ConsoleCommand& addShortcut();
+            ConsoleCommand& addShortcut(const std::string&  name);
+            ConsoleCommand& addGroup(const std::string& group);
+            ConsoleCommand& addGroup(const std::string& group, const std::string&  name);
 
             inline const std::string& getName() const
@@ -226 +226 @@
                 { return this->baseExecutor_; }
 
-            inline _ConsoleCommand& setActive(bool bActive)
+            inline ConsoleCommand& setActive(bool bActive)
                 { this->bActive_ = bActive; return *this; }
-            inline _ConsoleCommand& activate()
+            inline ConsoleCommand& activate()
                 { return this->setActive(true); }
-            inline _ConsoleCommand& deactivate()
+            inline ConsoleCommand& deactivate()
                 { return this->setActive(false); }
 
-            inline _ConsoleCommand& setHidden(bool bHidden)
+            inline ConsoleCommand& setHidden(bool bHidden)
                 { this->bHidden_ = bHidden; return *this; }
-            inline _ConsoleCommand& hide()
+            inline ConsoleCommand& hide()
                 { return this->setHidden(true); }
-            inline _ConsoleCommand& show()
+            inline ConsoleCommand& show()
                 { return this->setHidden(false); }
 
@@ -245 +245 @@
                 { return this->bHidden_; }
 
-            _ConsoleCommand& description(const std::string& description);
+            ConsoleCommand& description(const std::string& description);
             const std::string& getDescription() const;
 
-            _ConsoleCommand& descriptionParam(unsigned int param, const std::string& description);
+            ConsoleCommand& descriptionParam(unsigned int param, const std::string& description);
             const std::string& getDescriptionParam(unsigned int param) const;
 
-            _ConsoleCommand& descriptionReturnvalue(const std::string& description);
+            ConsoleCommand& descriptionReturnvalue(const std::string& description);
             const std::string& getDescriptionReturnvalue(int param) const;
 
-            _ConsoleCommand& defaultValues(const MultiType& param1);
-            _ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2);
-            _ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3);
-            _ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4);
-            _ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5);
-            _ConsoleCommand& defaultValue(unsigned int index, const MultiType& param);
-
-            inline _ConsoleCommand& accessLevel(AccessLevel::Enum level)
+            ConsoleCommand& defaultValues(const MultiType& param1);
+            ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2);
+            ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3);
+            ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4);
+            ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5);
+            ConsoleCommand& defaultValue(unsigned int index, const MultiType& param);
+
+            inline ConsoleCommand& accessLevel(AccessLevel::Enum level)
                 { this->accessLevel_ = level; return *this; }
             inline AccessLevel::Enum getAccessLevel() const
                 { return this->accessLevel_; }
 
-            _ConsoleCommand& argumentCompleter(unsigned int param, ArgumentCompleter* completer);
+            ConsoleCommand& argumentCompleter(unsigned int param, ArgumentCompleter* completer);
             ArgumentCompleter* getArgumentCompleter(unsigned int param) const;
 
-            inline _ConsoleCommand& setAsInputCommand()
+            inline ConsoleCommand& setAsInputCommand()
             {
                 this->keybindMode(KeybindMode::OnHold);
@@ -277 +277 @@
             }
 
-            inline _ConsoleCommand& keybindMode(KeybindMode::Value mode)
+            inline ConsoleCommand& keybindMode(KeybindMode::Value mode)
                 { this->keybindMode_ = mode; return *this; }
             inline KeybindMode::Value getKeybindMode() const
                 { return this->keybindMode_; }
 
-            inline _ConsoleCommand& inputConfiguredParam(int index)
+            inline ConsoleCommand& inputConfiguredParam(int index)
                 { this->inputConfiguredParam_ = index; return *this; }
             inline int getInputConfiguredParam_() const
                 { return this->inputConfiguredParam_; }
 
-            inline _ConsoleCommandManipulator getManipulator() const
+            inline ConsoleCommandManipulator getManipulator() const
                 { return this; }
 
@@ -327 +327 @@
 
         public:
-            static inline const std::map<std::string, std::map<std::string, _ConsoleCommand*> >& getCommands()
-                { return _ConsoleCommand::getCommandMap(); }
-            static inline const std::map<std::string, std::map<std::string, _ConsoleCommand*> >& getCommandsLC()
-                { return _ConsoleCommand::getCommandMapLC(); }
-
-            static inline _ConsoleCommand* getCommand(const std::string& name, bool bPrintError = false)
-                { return _ConsoleCommand::getCommand("", name, bPrintError); }
-            static inline _ConsoleCommand* getCommandLC(const std::string& name, bool bPrintError = false)
-                { return _ConsoleCommand::getCommandLC("", name, bPrintError); }
-
-            static _ConsoleCommand* getCommand(const std::string& group, const std::string& name, bool bPrintError = false);
-            static _ConsoleCommand* getCommandLC(const std::string& group, const std::string& name, bool bPrintError = false);
+            static inline const std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommands()
+                { return ConsoleCommand::getCommandMap(); }
+            static inline const std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommandsLC()
+                { return ConsoleCommand::getCommandMapLC(); }
+
+            static inline ConsoleCommand* getCommand(const std::string& name, bool bPrintError = false)
+                { return ConsoleCommand::getCommand("", name, bPrintError); }
+            static inline ConsoleCommand* getCommandLC(const std::string& name, bool bPrintError = false)
+                { return ConsoleCommand::getCommandLC("", name, bPrintError); }
+
+            static ConsoleCommand* getCommand(const std::string& group, const std::string& name, bool bPrintError = false);
+            static ConsoleCommand* getCommandLC(const std::string& group, const std::string& name, bool bPrintError = false);
 
             static void destroyAll();
 
         private:
-            static std::map<std::string, std::map<std::string, _ConsoleCommand*> >& getCommandMap();
-            static std::map<std::string, std::map<std::string, _ConsoleCommand*> >& getCommandMapLC();
-
-            static void registerCommand(const std::string& group, const std::string& name, _ConsoleCommand* command);
-            static void unregisterCommand(_ConsoleCommand* command);
+            static std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommandMap();
+            static std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommandMapLC();
+
+            static void registerCommand(const std::string& group, const std::string& name, ConsoleCommand* command);
+            static void unregisterCommand(ConsoleCommand* command);
     };
 
-    inline _ConsoleCommand* _createConsoleCommand(const std::string& name, const ExecutorPtr& executor, bool bInitialized = true)
-        { return new _ConsoleCommand("", name, executor, bInitialized); }
-    inline _ConsoleCommand* _createConsoleCommand(const std::string& group, const std::string& name, const ExecutorPtr& executor, bool bInitialized = true)
-        { return new _ConsoleCommand(group, name, executor, bInitialized); }
-
-    inline _ConsoleCommand::_ConsoleCommandManipulator _ModifyConsoleCommand(const std::string& name)
-        { return _ConsoleCommand::getCommand(name, true); }
-    inline _ConsoleCommand::_ConsoleCommandManipulator _ModifyConsoleCommand(const std::string& group, const std::string& name)
-        { return _ConsoleCommand::getCommand(group, name, true); }
+    inline ConsoleCommand* createConsoleCommand(const std::string& name, const ExecutorPtr& executor, bool bInitialized = true)
+        { return new ConsoleCommand("", name, executor, bInitialized); }
+    inline ConsoleCommand* createConsoleCommand(const std::string& group, const std::string& name, const ExecutorPtr& executor, bool bInitialized = true)
+        { return new ConsoleCommand(group, name, executor, bInitialized); }
+
+    inline ConsoleCommand::ConsoleCommandManipulator ModifyConsoleCommand(const std::string& name)
+        { return ConsoleCommand::getCommand(name, true); }
+    inline ConsoleCommand::ConsoleCommandManipulator ModifyConsoleCommand(const std::string& group, const std::string& name)
+        { return ConsoleCommand::getCommand(group, name, true); }
 }
 

code/branches/consolecommands3/src/libraries/core/command/ConsoleCommandCompilation.cc

@@ -41 +41 @@
 namespace orxonox
 {
-    _SetConsoleCommand("source", source).argumentCompleter(0, autocompletion::files());
-    _SetConsoleCommand("echo", echo);
-    _SetConsoleCommand("puts", puts);
+    SetConsoleCommand("source", source).argumentCompleter(0, autocompletion::files());
+    SetConsoleCommand("echo", echo);
+    SetConsoleCommand("puts", puts);
 
-    _SetConsoleCommand("read", read).argumentCompleter(0, autocompletion::files());
-    _SetConsoleCommand("append", append).argumentCompleter(0, autocompletion::files());
-    _SetConsoleCommand("write", write).argumentCompleter(0, autocompletion::files());
+    SetConsoleCommand("read", read).argumentCompleter(0, autocompletion::files());
+    SetConsoleCommand("append", append).argumentCompleter(0, autocompletion::files());
+    SetConsoleCommand("write", write).argumentCompleter(0, autocompletion::files());
 
-    _SetConsoleCommand("calculate", calculate);
+    SetConsoleCommand("calculate", calculate);
 
     void source(const std::string& filename)

code/branches/consolecommands3/src/libraries/core/command/IRC.cc

@@ -42 +42 @@
     static const unsigned int IRC_TCL_THREADID  = 1421421421;
 
-    _SetConsoleCommand("IRC", "say",  &IRC::say);
-    _SetConsoleCommand("IRC", "msg",  &IRC::msg);
-    _SetConsoleCommand("IRC", "nick", &IRC::nick);
+    SetConsoleCommand("IRC", "say",  &IRC::say);
+    SetConsoleCommand("IRC", "msg",  &IRC::msg);
+    SetConsoleCommand("IRC", "nick", &IRC::nick);
 
     IRC::IRC()

code/branches/consolecommands3/src/libraries/core/command/Shell.cc

@@ -40 +40 @@
 namespace orxonox
 {
-    _SetConsoleCommand("log",     OutputHandler::log    );
-    _SetConsoleCommand("error",   OutputHandler::error  );
-    _SetConsoleCommand("warning", OutputHandler::warning);
-    _SetConsoleCommand("info",    OutputHandler::info   );
-    _SetConsoleCommand("debug",   OutputHandler::debug  );
+    SetConsoleCommand("log",     OutputHandler::log    );
+    SetConsoleCommand("error",   OutputHandler::error  );
+    SetConsoleCommand("warning", OutputHandler::warning);
+    SetConsoleCommand("info",    OutputHandler::info   );
+    SetConsoleCommand("debug",   OutputHandler::debug  );
 
     unsigned int Shell::cacheSize_s;

code/branches/consolecommands3/src/libraries/core/command/TclBind.cc

@@ -44 +44 @@
 namespace orxonox
 {
-    _SetConsoleCommand("tcl", &TclBind::tcl);
-    _SetConsoleCommand("bgerror", &TclBind::bgerror);
+    SetConsoleCommand("tcl", &TclBind::tcl);
+    SetConsoleCommand("bgerror", &TclBind::bgerror);
 
     TclBind* TclBind::singletonPtr_s = 0;

code/branches/consolecommands3/src/libraries/core/command/TclThreadManager.cc

@@ -50 +50 @@
     const float TCLTHREADMANAGER_MAX_CPU_USAGE = 0.50f;
 
-    _SetConsoleCommand("tclexecute", &TclThreadManager::execute).argumentCompleter(0, autocompletion::tclthreads());
-    _SetConsoleCommand("tclquery",   &TclThreadManager::query  ).argumentCompleter(0, autocompletion::tclthreads());
-    _SetConsoleCommand("TclThreadManager", "create",  &TclThreadManager::create);
-    _SetConsoleCommand("TclThreadManager", "destroy", &TclThreadManager::destroy).argumentCompleter(0, autocompletion::tclthreads());
-    _SetConsoleCommand("TclThreadManager", "execute", &TclThreadManager::execute).argumentCompleter(0, autocompletion::tclthreads());
-    _SetConsoleCommand("TclThreadManager", "query",   &TclThreadManager::query  ).argumentCompleter(0, autocompletion::tclthreads());
-    _SetConsoleCommand("TclThreadManager", "source",  &TclThreadManager::source ).argumentCompleter(0, autocompletion::tclthreads());
+    SetConsoleCommand("tclexecute", &TclThreadManager::execute).argumentCompleter(0, autocompletion::tclthreads());
+    SetConsoleCommand("tclquery",   &TclThreadManager::query  ).argumentCompleter(0, autocompletion::tclthreads());
+    SetConsoleCommand("TclThreadManager", "create",  &TclThreadManager::create);
+    SetConsoleCommand("TclThreadManager", "destroy", &TclThreadManager::destroy).argumentCompleter(0, autocompletion::tclthreads());
+    SetConsoleCommand("TclThreadManager", "execute", &TclThreadManager::execute).argumentCompleter(0, autocompletion::tclthreads());
+    SetConsoleCommand("TclThreadManager", "query",   &TclThreadManager::query  ).argumentCompleter(0, autocompletion::tclthreads());
+    SetConsoleCommand("TclThreadManager", "source",  &TclThreadManager::source ).argumentCompleter(0, autocompletion::tclthreads());
 
     /**

code/branches/consolecommands3/src/libraries/core/input/InputManager.cc

@@ -66 +66 @@
     static const std::string __CC_reload_name = "reload";
 
-    _SetConsoleCommand(__CC_InputManager_name, __CC_calibrate_name, &InputManager::calibrate).addShortcut();
-    _SetConsoleCommand(__CC_InputManager_name, __CC_reload_name,    &InputManager::reload   );
+    SetConsoleCommand(__CC_InputManager_name, __CC_calibrate_name, &InputManager::calibrate).addShortcut();
+    SetConsoleCommand(__CC_InputManager_name, __CC_reload_name,    &InputManager::reload   );
 
     // Abuse of this source file for the InputHandler
@@ -125 +125 @@
         this->updateActiveStates();
 
-        _ModifyConsoleCommand(__CC_InputManager_name, __CC_calibrate_name).setObject(this);
-        _ModifyConsoleCommand(__CC_InputManager_name, __CC_reload_name).setObject(this);
+        ModifyConsoleCommand(__CC_InputManager_name, __CC_calibrate_name).setObject(this);
+        ModifyConsoleCommand(__CC_InputManager_name, __CC_reload_name).setObject(this);
 
         CCOUT(4) << "Construction complete." << std::endl;
@@ -294 +294 @@
 
         // Reset console commands
-        _ModifyConsoleCommand(__CC_InputManager_name, __CC_calibrate_name).setObject(0);
-        _ModifyConsoleCommand(__CC_InputManager_name, __CC_reload_name).setObject(0);
+        ModifyConsoleCommand(__CC_InputManager_name, __CC_calibrate_name).setObject(0);
+        ModifyConsoleCommand(__CC_InputManager_name, __CC_reload_name).setObject(0);
 
         CCOUT(3) << "Destruction complete." << std::endl;

code/branches/consolecommands3/src/libraries/core/input/KeyBinderManager.cc

@@ -48 +48 @@
     static const std::string __CC_tunbind_name = "tunbind";
 
-    _SetConsoleCommand(__CC_keybind_name,  &KeyBinderManager::keybind).defaultValues("");
-    _SetConsoleCommand(__CC_tkeybind_name, &KeyBinderManager::tkeybind).defaultValues("");
-    _SetConsoleCommand(__CC_unbind_name,   &KeyBinderManager::unbind).defaultValues("");
-    _SetConsoleCommand(__CC_tunbind_name,  &KeyBinderManager::tunbind).defaultValues("");
+    SetConsoleCommand(__CC_keybind_name,  &KeyBinderManager::keybind).defaultValues("");
+    SetConsoleCommand(__CC_tkeybind_name, &KeyBinderManager::tkeybind).defaultValues("");
+    SetConsoleCommand(__CC_unbind_name,   &KeyBinderManager::unbind).defaultValues("");
+    SetConsoleCommand(__CC_tunbind_name,  &KeyBinderManager::tunbind).defaultValues("");
 
     KeyBinderManager::KeyBinderManager()
@@ -62 +62 @@
 
         // keybind console commands
-        _ModifyConsoleCommand(__CC_keybind_name ).setObject(this);
-        _ModifyConsoleCommand(__CC_tkeybind_name).setObject(this);
-        _ModifyConsoleCommand(__CC_unbind_name  ).setObject(this);
-        _ModifyConsoleCommand(__CC_tunbind_name ).setObject(this);
+        ModifyConsoleCommand(__CC_keybind_name ).setObject(this);
+        ModifyConsoleCommand(__CC_tkeybind_name).setObject(this);
+        ModifyConsoleCommand(__CC_unbind_name  ).setObject(this);
+        ModifyConsoleCommand(__CC_tunbind_name ).setObject(this);
 
         // Load default key binder
@@ -78 +78 @@
 
         // Reset console commands
-        _ModifyConsoleCommand(__CC_keybind_name ).setObject(0);
-        _ModifyConsoleCommand(__CC_tkeybind_name).setObject(0);
-        _ModifyConsoleCommand(__CC_unbind_name  ).setObject(0);
-        _ModifyConsoleCommand(__CC_tunbind_name ).setObject(0);
+        ModifyConsoleCommand(__CC_keybind_name ).setObject(0);
+        ModifyConsoleCommand(__CC_tkeybind_name).setObject(0);
+        ModifyConsoleCommand(__CC_unbind_name  ).setObject(0);
+        ModifyConsoleCommand(__CC_tunbind_name ).setObject(0);
     }
 

code/branches/consolecommands3/src/libraries/core/input/KeyDetector.cc

@@ -41 +41 @@
 
     static const std::string __CC_KeyDetector_callback_name = "KeyDetectorKeyPressed";
-    _DeclareConsoleCommand(__CC_KeyDetector_callback_name, &prototype::void__string);
+    DeclareConsoleCommand(__CC_KeyDetector_callback_name, &prototype::void__string);
 
     KeyDetector::KeyDetector()
@@ -48 +48 @@
         RegisterObject(KeyDetector);
 
-        _ModifyConsoleCommand(__CC_KeyDetector_callback_name).setFunction(&KeyDetector::callback, this);
+        ModifyConsoleCommand(__CC_KeyDetector_callback_name).setFunction(&KeyDetector::callback, this);
 
         this->assignCommands();
@@ -62 +62 @@
         inputState_->setHandler(NULL);
         InputManager::getInstance().destroyState("detector");
-        _ModifyConsoleCommand(__CC_KeyDetector_callback_name).resetFunction();
+        ModifyConsoleCommand(__CC_KeyDetector_callback_name).resetFunction();
     }
 

code/branches/consolecommands3/src/libraries/core/input/Mouse.cc

@@ -46 +46 @@
     static const std::string __CC_ungrab_name = "ungrab";
 
-    _SetConsoleCommand(__CC_Mouse_name, __CC_grab_name,   &Mouse::grab);
-    _SetConsoleCommand(__CC_Mouse_name, __CC_ungrab_name, &Mouse::ungrab);
+    SetConsoleCommand(__CC_Mouse_name, __CC_grab_name,   &Mouse::grab);
+    SetConsoleCommand(__CC_Mouse_name, __CC_ungrab_name, &Mouse::ungrab);
 #endif
 
@@ -57 +57 @@
 
 #ifdef ORXONOX_PLATFORM_LINUX
-        _ModifyConsoleCommand(__CC_Mouse_name, __CC_grab_name).setObject(this);
-        _ModifyConsoleCommand(__CC_Mouse_name, __CC_ungrab_name).setObject(this);
+        ModifyConsoleCommand(__CC_Mouse_name, __CC_grab_name).setObject(this);
+        ModifyConsoleCommand(__CC_Mouse_name, __CC_ungrab_name).setObject(this);
 #endif
     }
@@ -65 +65 @@
     {
 #ifdef ORXONOX_PLATFORM_LINUX
-        _ModifyConsoleCommand(__CC_Mouse_name, __CC_grab_name).setObject(0);
-        _ModifyConsoleCommand(__CC_Mouse_name, __CC_ungrab_name).setObject(0);
+        ModifyConsoleCommand(__CC_Mouse_name, __CC_grab_name).setObject(0);
+        ModifyConsoleCommand(__CC_Mouse_name, __CC_ungrab_name).setObject(0);
 #endif
     }