Changeset 6417 for code/trunk/src/libraries/core

code/trunk

Property svn:mergeinfo changed

/code/branches/ingamemenu (added)	merged: 6003,6018-6020,6022-6023
/code/branches/menu (added)	merged: 5941,5944,5952,6024,6032,6036,6047-6049,6051,6145-6146,6148
/code/branches/particles2 (added)	merged: 6050,6059,6065-6068,6076,6078-6082,6086-6087,6098-6099,6101,6109
/code/branches/presentation2 (added)	merged: 6106-6108,6110-6124,6127-6141,6143-6144,6147,6149-6162,6164-6197,6199,6201-6210,6212-6219,6222-6224,6226-6228,6230-6239,6241,6243-6245,6247-6248,6250-6252,6254-6262,6265-6266,6268-6273,6276-6287,6289-6293,6295,6298-6303,6305-6307,6310-6316,6318-6329,6332,6334-6336,6338-6389,6391-6404,6406-6411,6413,6415-6416
/code/branches/sound3 (added)	merged: 5941,5943,5946,5954,5956-5957,5962,5982,6031,6046,6069-6072,6074,6088,6093,6097,6100,6102
/code/branches/steering (added)	merged: 5979,5981,5984,5993,6001,6033,6045,6052,6055,6058,6091

code/trunk/src/libraries/core/ArgumentCompletionFunctions.cc

-                      r5929
+                      r6417
                 else
+                {
                     std::string dir = startdirectory.string();
+                    const std::string& dir = startdirectory.string();
                     if (dir.size() > 0 && dir[dir.size() - 1] == ':')
                         startdirectory = dir + '/';
 …
+                {
                     if (boost::filesystem::is_directory(*file))
                         dirlist.push_back(ArgumentCompletionListElement((*file).string() + '/', getLowercase((*file).string()) + '/', (*file).BOOST_LEAF_FUNCTION() + '/'));
+                        dirlist.push_back(ArgumentCompletionListElement(file->string() + '/', getLowercase(file->string()) + '/', file->BOOST_LEAF_FUNCTION() + '/'));
                     else
                         filelist.push_back(ArgumentCompletionListElement((*file).string(), getLowercase((*file).string()), (*file).BOOST_LEAF_FUNCTION()));
+                        filelist.push_back(ArgumentCompletionListElement(file->string(), getLowercase(file->string()), file->BOOST_LEAF_FUNCTION()));
                     ++file;
+                }
 …
             for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getStringIdentifierMapBegin(); it != Identifier::getStringIdentifierMapEnd(); ++it)
                 if ((*it).second->hasConfigValues())
                     classlist.push_back(ArgumentCompletionListElement((*it).second->getName(), getLowercase((*it).first)));
+                if (it->second->hasConfigValues())
+                    classlist.push_back(ArgumentCompletionListElement(it->first, getLowercase(it->first)));
             return classlist;
 …
+        {
             ArgumentCompletionList configvalues;
             std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getStringIdentifierMap().find(classname);
+            std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getLowercaseStringIdentifierMap().find(getLowercase(classname));
             if (identifier != Identifier::getStringIdentifierMapEnd() && (*identifier).second->hasConfigValues())
+            if (identifier != Identifier::getLowercaseStringIdentifierMapEnd() && identifier->second->hasConfigValues())
+            {
                 for (std::map<std::string, ConfigValueContainer*>::const_iterator it = (*identifier).second->getConfigValueMapBegin(); it != (*identifier).second->getConfigValueMapEnd(); ++it)
                     configvalues.push_back(ArgumentCompletionListElement((*it).second->getName(), getLowercase((*it).first)));
+                for (std::map<std::string, ConfigValueContainer*>::const_iterator it = identifier->second->getConfigValueMapBegin(); it != identifier->second->getConfigValueMapEnd(); ++it)
+                    configvalues.push_back(ArgumentCompletionListElement(it->first, getLowercase(it->first)));
+            }
 …
             if (identifier != Identifier::getLowercaseStringIdentifierMapEnd())
+            {
                 std::map<std::string, ConfigValueContainer*>::const_iterator variable = (*identifier).second->getLowercaseConfigValueMap().find(getLowercase(varname));
                 if (variable != (*identifier).second->getLowercaseConfigValueMapEnd())
+                std::map<std::string, ConfigValueContainer*>::const_iterator variable = identifier->second->getLowercaseConfigValueMap().find(getLowercase(varname));
+                if (variable != identifier->second->getLowercaseConfigValueMapEnd())
+                {
                     std::string valuestring = (*variable).second->toString();
+                    const std::string& valuestring = variable->second->toString();
                     oldvalue.push_back(ArgumentCompletionListElement(valuestring, getLowercase(valuestring), "Old value: " + valuestring));
+                }

code/trunk/src/libraries/core/BaseObject.cc

-                      r5929
+                      r6417
 #include <tinyxml/tinyxml.h>
-#include "util/StringUtils.h"
 #include "CoreIncludes.h"
 #include "Event.h"
 …
         XMLPortObjectTemplate(BaseObject, Template, "templates", addTemplate, getTemplate, xmlelement, mode, Template*);
         XMLPortObject(BaseObject, BaseObject, "eventlisteners", addEventListener, getEventListener, xmlelement, mode);
         Element* events = 0;
         if (mode == XMLPort::LoadObject || mode == XMLPort::ExpandObject)
 …
         XMLPortEventState(BaseObject, BaseObject, "visibility", setVisible, xmlelement, mode);
         XMLPortEventState(BaseObject, BaseObject, "mainstate", setMainState, xmlelement, mode);
         this->bRegisteredEventStates_ = true;
+    }
 …
             if (it->second != state)
                 continue;
             if (i == index)
                 return it->first;
 …
         listener->addEventSource(this, "mainstate");
+    }
     /**
         @brief Returns an event listener with a given index.
 …
         if (it != this->eventStates_.end())
+        {
             COUT(2) << "Warning: Overwriting EventState in class " << this->getIdentifier()->getName() << "." << std::endl;
+            COUT(2) << "Warning: Overwriting EventState in class " << this->getIdentifier()->getName() << '.' << std::endl;
             delete (it->second);
+        }
 …
         std::map<std::string, EventState*>::const_iterator it = this->eventStates_.find(name);
         if (it != this->eventStates_.end())
             return ((*it).second);
+            return (it->second);
         else
             return 0;
 …
+    {
         this->registerEventStates();
         std::map<std::string, EventState*>::const_iterator it = this->eventStates_.find(event.statename_);
         if (it != this->eventStates_.end())
             it->second->process(event, this);
         else if (event.statename_ != "")
+        else if (!event.statename_.empty())
             COUT(2) << "Warning: \"" << event.statename_ << "\" is not a valid state in object \"" << this->getName() << "\" of class " << this->getIdentifier()->getName() << "." << std::endl;
         else
 …
     /**
         @brief Sets the main state of the object to a given boolean value.
         Note: The main state of an object can be set with the @ref setMainStateName function.
         It's part of the eventsystem and used for event forwarding (when the target object can't specify a specific state,
 …
         this->mainStateFunctor_ = 0;
         if (this->mainStateName_ != "")
+        if (!this->mainStateName_.empty())
+        {
             this->registerEventStates();
             std::map<std::string, EventState*>::const_iterator it = this->eventStates_.find(this->mainStateName_);
             if (it != this->eventStates_.end() && it->second->getFunctor())
 …
+        }
+    }
     /**
         @brief Calls XMLEventPort with an empty XML-element to register the event states if necessary.
 …
+        }
+    }
     /**
         @brief Manually loads all event states, even if the class doesn't officially support them. This is needed by some classes like @ref EventDispatcher or @ref EventTarget.
 …
             for (std::list<std::string>::iterator it = eventnames.begin(); it != eventnames.end(); ++it)
+            {
                 std::string statename = (*it);
+                const std::string& statename = (*it);
                 // if the event state is already known, continue with the next state
 …
                 if (!container)
+                {
                     ExecutorMember<BaseObject>* setfunctor = createExecutor(createFunctor(&BaseObject::addEventSource), std::string( "BaseObject" ) + "::" + "addEventSource" + "(" + statename + ")");
                     ExecutorMember<BaseObject>* getfunctor = createExecutor(createFunctor(&BaseObject::getEventSource), std::string( "BaseObject" ) + "::" + "getEventSource" + "(" + statename + ")");
+                    ExecutorMember<BaseObject>* setfunctor = createExecutor(createFunctor(&BaseObject::addEventSource), std::string( "BaseObject" ) + "::" + "addEventSource" + '(' + statename + ')');
+                    ExecutorMember<BaseObject>* getfunctor = createExecutor(createFunctor(&BaseObject::getEventSource), std::string( "BaseObject" ) + "::" + "getEventSource" + '(' + statename + ')');
                     setfunctor->setDefaultValue(1, statename);
                     getfunctor->setDefaultValue(1, statename);

code/trunk/src/libraries/core/BaseObject.h

-                      r5929
+                      r6417
             void removeEventSource(BaseObject* source);
             BaseObject* getEventSource(unsigned int index, const std::string& state) const;
             void addEventListener(BaseObject* listener);
             BaseObject* getEventListener(unsigned int index) const;
 …
             /** @brief Returns the indentation of the debug output in the Loader. @return The indentation */
             inline const std::string& getLoaderIndentation() const { return this->loaderIndentation_; }
             static void loadAllEventStates(Element& xmlelement, XMLPort::Mode mode, BaseObject* object, Identifier* identifier);
 …
             Gametype*              oldGametype_;
             std::set<Template*>    templates_;
             std::map<BaseObject*, std::string>  eventSources_;           //!< List of objects which send events to this object, mapped to the state which they affect
             std::set<BaseObject*>               eventListeners_;         //!< List of objects which listen to the events of this object

code/trunk/src/libraries/core/CMakeLists.txt

-                      r6105
+                      r6417
   TOLUA_FILES
     CommandExecutor.h
+    ConfigFileManager.h
+    Game.h
+    GameMode.h
+    GUIManager.h
     Loader.h
     LuaState.h
+    PathConfig.h
+    input/InputManager.h
+    input/KeyBinder.h
+    input/KeyBinderManager.h
   DEFINE_SYMBOL
     "CORE_SHARED_BUILD"

code/trunk/src/libraries/core/ClassTreeMask.cc

-                      r5929
+                      r6417
     void ClassTreeMask::add(const Identifier* subclass, bool bInclude, bool overwrite, bool clean)
+    {
+        if (!subclass)
+            return;
         // Check if the given subclass is a child of our root-class
         if (subclass->isA(this->root_->getClass()))
 …
     void ClassTreeMask::add(ClassTreeMaskNode* node, const Identifier* subclass, bool bInclude, bool overwrite)
+    {
+        if (!subclass)
+            return;
         // Check if the current node contains exactly the subclass we want to add
         if (subclass == node->getClass())
 …
     void ClassTreeMask::addSingle(const Identifier* subclass, bool bInclude, bool clean)
+    {
+        if (!subclass)
+            return;
         for (std::set<const Identifier*>::const_iterator it = subclass->getDirectChildrenBegin(); it != subclass->getDirectChildrenEnd(); ++it)
             this->add(*it, this->isIncluded(*it), false, false);
 …
     bool ClassTreeMask::isIncluded(ClassTreeMaskNode* node, const Identifier* subclass) const
+    {
+        if (!subclass)
+            return false;
         // Check if the searched subclass is of the same type as the class in the current node or a derivative
         if (subclass->isA(node->getClass()))
 …
             // Calculate the prefix: + means included, - means excluded
             if (it->isIncluded())
                 out << "+";
+                out << '+';
             else
                 out << "-";
+                out << '-';
             // Put the name of the corresponding class on the stream
             out << it->getClass()->getName() << " ";
+            out << it->getClass()->getName() << ' ';
+        }
 …
         // If there is a first subclass, move the object-iterator to the first object of this class. Else go to the end
         if (this->subclassIterator_ != this->subclasses_.end())
             this->objectIterator_ = (*this->subclassIterator_).first->getObjects()->begin();
+            this->objectIterator_ = this->subclassIterator_->first->getObjects()->begin();
         else
             this->objectIterator_ = ObjectList<BaseObject>::end();
         // Check if the iterator points on a valid object. If not, go to the next object by calling ++
         if (!this->objectIterator_ || ((*this->subclassIterator_).second && !this->objectIterator_->isExactlyA((*this->subclassIterator_).first)))
+        if (!this->objectIterator_ || (this->subclassIterator_->second && !this->objectIterator_->isExactlyA(this->subclassIterator_->first)))
             this->operator++();
 …
                     // Check if there really is a next class. If yes, move the object-iterator to the first object
                     if (this->subclassIterator_ != this->subclasses_.end())
                         this->objectIterator_ = (*this->subclassIterator_).first->getObjects()->begin();
+                        this->objectIterator_ = this->subclassIterator_->first->getObjects()->begin();
                     else
                         return (*this);
 …
             // Repeat this until we reach a valid object or the end
             } while ((*this->subclassIterator_).second && !this->objectIterator_->isExactlyA((*this->subclassIterator_).first));
+            } while (this->subclassIterator_->second && !this->objectIterator_->isExactlyA(this->subclassIterator_->first));
+        }
         return (*this);

code/trunk/src/libraries/core/CommandEvaluation.cc

-                      r5781
+                      r6417
         this->commandTokens_.split(command, " ", SubString::WhiteSpaces, false, '\\', false, '"', false, '(', ')', false, '\0');
         this->additionalParameter_ = "";
+        this->additionalParameter_.clear();
         this->bEvaluatedParams_ = false;
 …
         this->functionclass_ = 0;
         this->function_ = 0;
         this->possibleArgument_ = "";
         this->argument_ = "";
         this->errorMessage_ = "";
+        this->possibleArgument_.clear();
+        this->argument_.clear();
+        this->errorMessage_.clear();
         this->state_ = CommandState::Empty;
+    }
 …
         if (this->bEvaluatedParams_ && this->function_)
+        {
             COUT(6) << "CE_execute (evaluation): " << this->function_->getName() << " " << this->param_[0] << " " << this->param_[1] << " " << this->param_[2] << " " << this->param_[3] << " " << this->param_[4] << std::endl;
+            COUT(6) << "CE_execute (evaluation): " << this->function_->getName() << ' ' << this->param_[0] << ' ' << this->param_[1] << ' ' << this->param_[2] << ' ' << this->param_[3] << ' ' << this->param_[4] << std::endl;
             (*this->function_)(this->param_[0], this->param_[1], this->param_[2], this->param_[3], this->param_[4]);
             return true;
 …
+    }
     std::string CommandEvaluation::complete()
+    const std::string& CommandEvaluation::complete()
+    {
         if (!this->bNewCommand_)
 …
                             return (this->command_ = this->function_->getName());
                         else
                             return (this->command_ = this->function_->getName() + " ");
+                            return (this->command_ = this->function_->getName() + ' ');
+                    }
                     else if (this->functionclass_)
                         return (this->command_ = this->functionclass_->getName() + " ");
+                        return (this->command_ = this->functionclass_->getName() + ' ');
                     break;
                 case CommandState::Function:
 …
+                    {
                         if (this->function_->getParamCount() == 0)
                             return (this->command_ = this->functionclass_->getName() + " " + this->function_->getName());
+                            return (this->command_ = this->functionclass_->getName() + ' ' + this->function_->getName());
                         else
                             return (this->command_ = this->functionclass_->getName() + " " + this->function_->getName() + " ");
+                            return (this->command_ = this->functionclass_->getName() + ' ' + this->function_->getName() + ' ');
+                    }
                     break;
 …
                 case CommandState::Params:
+                {
                     if (this->argument_ == "" && this->possibleArgument_ == "")
+                    if (this->argument_.empty() && this->possibleArgument_.empty())
                         break;
 …
                     if (this->command_[this->command_.size() - 1] != ' ')
                         maxIndex -= 1;
                     std::string whitespace = "";
                     if (this->possibleArgument_ != "")
+                    std::string whitespace;
+                    if (!this->possibleArgument_.empty())
+                    {
                         this->argument_ = this->possibleArgument_;
 …
+                    }
                     return (this->command_ = this->commandTokens_.subSet(0, maxIndex).join() + " " + this->argument_ + whitespace);
+                    return (this->command_ = this->commandTokens_.subSet(0, maxIndex).join() + ' ' + this->argument_ + whitespace);
                     break;
+                }
 …
     std::string CommandEvaluation::dump(const std::list<std::pair<const std::string*, const std::string*> >& list)
+    {
         std::string output = "";
+        std::string output;
         for (std::list<std::pair<const std::string*, const std::string*> >::const_iterator it = list.begin(); it != list.end(); ++it)
+        {
             if (it != list.begin())
                 output += " ";
             output += *(*it).second;
+                output += ' ';
+            output += *(it->second);
+        }
         return output;
 …
     std::string CommandEvaluation::dump(const ArgumentCompletionList& list)
+    {
         std::string output = "";
+        std::string output;
         for (ArgumentCompletionList::const_iterator it = list.begin(); it != list.end(); ++it)
+        {
             if (it != list.begin())
                 output += " ";
             output += (*it).getDisplay();
+                output += ' ';
+            output += it->getDisplay();
+        }
         return output;
 …
+        {
             if (i != 0)
                 output += " ";
+                output += ' ';
             if (command->defaultValueSet(i))
                 output += "[";
+                output += '[';
             else
                 output += "{";
+                output += '{';
             output += command->getTypenameParam(i);
             if (command->defaultValueSet(i))
                 output += "=" + command->getDefaultValue(i).getString() + "]";
+                output += '=' + command->getDefaultValue(i).getString() + ']';
             else
                 output += "}";
+                output += '}';
+        }
         return output;

code/trunk/src/libraries/core/CommandEvaluation.h

-                      r5781
+                      r6417
             bool execute() const;
             std::string complete();
+            const std::string& complete();
             std::string hint() const;
             void evaluateParams();
 …
                 { this->additionalParameter_ = param; this->bEvaluatedParams_ = false; }
             inline std::string getAdditionalParameter() const
                 { return (this->additionalParameter_ != "") ? (" " + this->additionalParameter_) : ""; }
+                { return (!this->additionalParameter_.empty()) ? (' ' + this->additionalParameter_) : ""; }
             void setEvaluatedParameter(unsigned int index, MultiType param);

code/trunk/src/libraries/core/CommandExecutor.cc

-                      r5929
+                      r6417
         if (it != CommandExecutor::getInstance().consoleCommandShortcuts_.end())
+        {
             COUT(2) << "Warning: Overwriting console-command shortcut with name " << command->getName() << "." << std::endl;
+            COUT(2) << "Warning: Overwriting console-command shortcut with name " << command->getName() << '.' << std::endl;
+        }
 …
         std::map<std::string, ConsoleCommand*>::const_iterator it = CommandExecutor::getInstance().consoleCommandShortcuts_.find(name);
         if (it != CommandExecutor::getInstance().consoleCommandShortcuts_.end())
             return (*it).second;
+            return it->second;
         else
             return 0;
 …
         std::map<std::string, ConsoleCommand*>::const_iterator it = CommandExecutor::getInstance().consoleCommandShortcuts_LC_.find(name);
         if (it != CommandExecutor::getInstance().consoleCommandShortcuts_LC_.end())
             return (*it).second;
+            return it->second;
         else
             return 0;
 …
                         CommandExecutor::getEvaluation().state_ = CommandState::Error;
                         AddLanguageEntry("commandexecutorunknownfirstargument", "is not a shortcut nor a classname");
                         CommandExecutor::getEvaluation().errorMessage_ = "Error: " + CommandExecutor::getArgument(0) + " " + GetLocalisation("commandexecutorunknownfirstargument") + ".";
+                        CommandExecutor::getEvaluation().errorMessage_ = "Error: " + CommandExecutor::getArgument(0) + ' ' + GetLocalisation("commandexecutorunknownfirstargument") + '.';
                         return;
+                    }
 …
+                    {
                         // It's a shortcut
                         std::string functionname = *(*CommandExecutor::getEvaluation().listOfPossibleFunctions_.begin()).first;
+                        const std::string& functionname = *CommandExecutor::getEvaluation().listOfPossibleFunctions_.begin()->first;
                         CommandExecutor::getEvaluation().function_ = CommandExecutor::getPossibleCommand(functionname);
                         if (getLowercase(functionname) != getLowercase(CommandExecutor::getArgument(0)))
 …
                         if (CommandExecutor::getEvaluation().function_->getParamCount() > 0)
+                        {
                             CommandExecutor::getEvaluation().command_ += " ";
+                            CommandExecutor::getEvaluation().command_ += ' ';
                             CommandExecutor::getEvaluation().bCommandChanged_ = true;
+                        }
 …
+                    {
                         // It's a classname
                         std::string classname = *(*CommandExecutor::getEvaluation().listOfPossibleIdentifiers_.begin()).first;
+                        const std::string& classname = *CommandExecutor::getEvaluation().listOfPossibleIdentifiers_.begin()->first;
                         CommandExecutor::getEvaluation().functionclass_ = CommandExecutor::getPossibleIdentifier(classname);
                         if (getLowercase(classname) != getLowercase(CommandExecutor::getArgument(0)))
 …
                         CommandExecutor::getEvaluation().state_ = CommandState::Function;
                         CommandExecutor::getEvaluation().function_ = 0;
                         CommandExecutor::getEvaluation().command_ = CommandExecutor::getEvaluation().functionclass_->getName() + " ";
+                        CommandExecutor::getEvaluation().command_ = CommandExecutor::getEvaluation().functionclass_->getName() + ' ';
                         // Move on to next case
+                    }
 …
                         CommandExecutor::getEvaluation().state_ = CommandState::Error;
                         AddLanguageEntry("commandexecutorunknownfirstargumentstart", "There is no command or classname starting with");
                         CommandExecutor::getEvaluation().errorMessage_ = "Error: " + GetLocalisation("commandexecutorunknownfirstargumentstart") + " " + CommandExecutor::getArgument(0) + ".";
+                        CommandExecutor::getEvaluation().errorMessage_ = "Error: " + GetLocalisation("commandexecutorunknownfirstargumentstart") + ' ' + CommandExecutor::getArgument(0) + '.';
                         return;
+                    }
 …
+                        {
                             // It's a function
                             std::string functionname = *(*CommandExecutor::getEvaluation().listOfPossibleFunctions_.begin()).first;
+                            const std::string& functionname = *CommandExecutor::getEvaluation().listOfPossibleFunctions_.begin()->first;
                             CommandExecutor::getEvaluation().function_ = CommandExecutor::getPossibleCommand(functionname, CommandExecutor::getEvaluation().functionclass_);
                             if (getLowercase(functionname) != getLowercase(CommandExecutor::getArgument(1)))
 …
+                            }
                             CommandExecutor::getEvaluation().state_ = CommandState::ParamPreparation;
                             CommandExecutor::getEvaluation().command_ = CommandExecutor::getEvaluation().functionclass_->getName() + " " + CommandExecutor::getEvaluation().function_->getName();
+                            CommandExecutor::getEvaluation().command_ = CommandExecutor::getEvaluation().functionclass_->getName() + ' ' + CommandExecutor::getEvaluation().function_->getName();
                             if (CommandExecutor::getEvaluation().function_->getParamCount() > 0)
+                            {
                                 CommandExecutor::getEvaluation().command_ += " ";
+                                CommandExecutor::getEvaluation().command_ += ' ';
                                 CommandExecutor::getEvaluation().bCommandChanged_ = true;
+                            }
 …
                             CommandExecutor::getEvaluation().state_ = CommandState::Error;
                             AddLanguageEntry("commandexecutorunknownsecondargumentstart", "has no function starting with");
                             CommandExecutor::getEvaluation().errorMessage_ = "Error: " + CommandExecutor::getEvaluation().functionclass_->getName() + " " + GetLocalisation("commandexecutorunknownsecondargumentstart") + " " + CommandExecutor::getArgument(1) + ".";
+                            CommandExecutor::getEvaluation().errorMessage_ = "Error: " + CommandExecutor::getEvaluation().functionclass_->getName() + ' ' + GetLocalisation("commandexecutorunknownsecondargumentstart") + ' ' + CommandExecutor::getArgument(1) + '.';
                             return;
+                        }
 …
+                        {
                             // There are several possibilities
                             CommandExecutor::getEvaluation().command_ = CommandExecutor::getEvaluation().functionclass_->getName() + " " + CommandExecutor::getCommonBegin(CommandExecutor::getEvaluation().listOfPossibleFunctions_);
+                            CommandExecutor::getEvaluation().command_ = CommandExecutor::getEvaluation().functionclass_->getName() + ' ' + CommandExecutor::getCommonBegin(CommandExecutor::getEvaluation().listOfPossibleFunctions_);
                             CommandExecutor::getEvaluation().function_ = CommandExecutor::getPossibleCommand(CommandExecutor::getArgument(1), CommandExecutor::getEvaluation().functionclass_);
                             CommandExecutor::getEvaluation().bCommandChanged_ = true;
 …
+                {
                     // There is exactly one possible argument
                     CommandExecutor::getEvaluation().argument_ = (*CommandExecutor::getEvaluation().listOfPossibleArguments_.begin()).getString();
                     CommandExecutor::getEvaluation().possibleArgument_ = (*CommandExecutor::getEvaluation().listOfPossibleArguments_.begin()).getString();
+                    CommandExecutor::getEvaluation().argument_ = CommandExecutor::getEvaluation().listOfPossibleArguments_.begin()->getString();
+                    CommandExecutor::getEvaluation().possibleArgument_ = CommandExecutor::getEvaluation().listOfPossibleArguments_.begin()->getString();
                     CommandExecutor::getEvaluation().state_ = CommandState::ParamPreparation;
                     return;
 …
+    }
     std::string CommandExecutor::getArgument(unsigned int index)
+    const std::string& CommandExecutor::getArgument(unsigned int index)
+    {
         if (index < (CommandExecutor::getEvaluation().commandTokens_.size()))
             return CommandExecutor::getEvaluation().commandTokens_[index];
         else
             return "";
+    }
     std::string CommandExecutor::getLastArgument()
+            return BLANKSTRING;
+    }
+    const std::string& CommandExecutor::getLastArgument()
+    {
         return CommandExecutor::getArgument(CommandExecutor::argumentsGiven() - 1);
 …
+    {
         CommandExecutor::getEvaluation().listOfPossibleIdentifiers_.clear();
         std::string lowercase = getLowercase(fragment);
+        const std::string& lowercase = getLowercase(fragment);
         for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getLowercaseStringIdentifierMapBegin(); it != Identifier::getLowercaseStringIdentifierMapEnd(); ++it)
             if ((*it).second->hasConsoleCommands())
                 if ((*it).first.find(lowercase) == 0 || fragment == "")
                     CommandExecutor::getEvaluation().listOfPossibleIdentifiers_.push_back(std::pair<const std::string*, const std::string*>(&(*it).first, &(*it).second->getName()));
+            if (it->second->hasConsoleCommands())
+                if (it->first.find(lowercase) == 0 || fragment.empty())
+                    CommandExecutor::getEvaluation().listOfPossibleIdentifiers_.push_back(std::pair<const std::string*, const std::string*>(&it->first, &it->second->getName()));
+    }
 …
+    {
         CommandExecutor::getEvaluation().listOfPossibleFunctions_.clear();
         std::string lowercase = getLowercase(fragment);
+        const std::string& lowercase = getLowercase(fragment);
         if (!identifier)
+        {
             for (std::map<std::string, ConsoleCommand*>::const_iterator it = CommandExecutor::getLowercaseConsoleCommandShortcutMapBegin(); it != CommandExecutor::getLowercaseConsoleCommandShortcutMapEnd(); ++it)
                 if ((*it).first.find(lowercase) == 0 || fragment == "")
                     CommandExecutor::getEvaluation().listOfPossibleFunctions_.push_back(std::pair<const std::string*, const std::string*>(&(*it).first, &(*it).second->getName()));
+                if (it->first.find(lowercase) == 0 || fragment.empty())
+                    CommandExecutor::getEvaluation().listOfPossibleFunctions_.push_back(std::pair<const std::string*, const std::string*>(&it->first, &it->second->getName()));
+        }
         else
+        {
             for (std::map<std::string, ConsoleCommand*>::const_iterator it = identifier->getLowercaseConsoleCommandMapBegin(); it != identifier->getLowercaseConsoleCommandMapEnd(); ++it)
                 if ((*it).first.find(lowercase) == 0 || fragment == "")
                     CommandExecutor::getEvaluation().listOfPossibleFunctions_.push_back(std::pair<const std::string*, const std::string*>(&(*it).first, &(*it).second->getName()));
+                if (it->first.find(lowercase) == 0 || fragment.empty())
+                    CommandExecutor::getEvaluation().listOfPossibleFunctions_.push_back(std::pair<const std::string*, const std::string*>(&it->first, &it->second->getName()));
+        }
+    }
 …
         CommandExecutor::getEvaluation().listOfPossibleArguments_.clear();
         std::string lowercase = getLowercase(fragment);
+        const std::string& lowercase = getLowercase(fragment);
         for (ArgumentCompletionList::const_iterator it = command->getArgumentCompletionListBegin(); it != command->getArgumentCompletionListEnd(); ++it)
+        {
             if ((*it).lowercaseComparison())
+            {
                 if ((*it).getComparable().find(lowercase) == 0 || fragment == "")
+            if (it->lowercaseComparison())
+            {
+                if (it->getComparable().find(lowercase) == 0 || fragment.empty())
                     CommandExecutor::getEvaluation().listOfPossibleArguments_.push_back(*it);
+            }
             else
+            {
                 if ((*it).getComparable().find(fragment) == 0 || fragment == "")
+                if (it->getComparable().find(fragment) == 0 || fragment.empty())
                     CommandExecutor::getEvaluation().listOfPossibleArguments_.push_back(*it);
+            }
 …
     Identifier* CommandExecutor::getPossibleIdentifier(const std::string& name)
+    {
         std::string lowercase = getLowercase(name);
+        const std::string& lowercase = getLowercase(name);
         std::map<std::string, Identifier*>::const_iterator it = Identifier::getLowercaseStringIdentifierMap().find(lowercase);
         if ((it != Identifier::getLowercaseStringIdentifierMapEnd()) && (*it).second->hasConsoleCommands())
             return (*it).second;
+        if ((it != Identifier::getLowercaseStringIdentifierMapEnd()) && it->second->hasConsoleCommands())
+            return it->second;
         return 0;
 …
     ConsoleCommand* CommandExecutor::getPossibleCommand(const std::string& name, Identifier* identifier)
+    {
         std::string lowercase = getLowercase(name);
+        const std::string& lowercase = getLowercase(name);
         if (!identifier)
+        {
             std::map<std::string, ConsoleCommand*>::const_iterator it = CommandExecutor::getLowercaseConsoleCommandShortcutMap().find(lowercase);
             if (it != CommandExecutor::getLowercaseConsoleCommandShortcutMapEnd())
                 return (*it).second;
+                return it->second;
+        }
         else
 …
             std::map<std::string, ConsoleCommand*>::const_iterator it = identifier->getLowercaseConsoleCommandMap().find(lowercase);
             if (it != identifier->getLowercaseConsoleCommandMapEnd())
                 return (*it).second;
+                return it->second;
+        }
         return 0;
+    }
     std::string CommandExecutor::getPossibleArgument(const std::string& name, ConsoleCommand* command, unsigned int param)
+    const std::string& CommandExecutor::getPossibleArgument(const std::string& name, ConsoleCommand* command, unsigned int param)
+    {
         CommandExecutor::createArgumentCompletionList(command, param);
         std::string lowercase = getLowercase(name);
+        const std::string& lowercase = getLowercase(name);
         for (ArgumentCompletionList::const_iterator it = command->getArgumentCompletionListBegin(); it != command->getArgumentCompletionListEnd(); ++it)
+        {
             if ((*it).lowercaseComparison())
+            {
                 if ((*it).getComparable() == lowercase)
                     return (*it).getString();
+            if (it->lowercaseComparison())
+            {
+                if (it->getComparable() == lowercase)
+                    return it->getString();
+            }
             else
+            {
                 if ((*it).getComparable() == name)
                     return (*it).getString();
+            }
+        }
         return "";
+                if (it->getComparable() == name)
+                    return it->getString();
+            }
+        }
+        return BLANKSTRING;
+    }
 …
         else if (list.size() == 1)
+        {
             return ((*(*list.begin()).first) + " ");
+        }
         else
+        {
             std::string output = "";
+            return ((*list.begin()->first) + ' ');
+        }
+        else
+        {
+            std::string output;
             for (unsigned int i = 0; true; i++)
+            {
 …
                 for (std::list<std::pair<const std::string*, const std::string*> >::const_iterator it = list.begin(); it != list.end(); ++it)
+                {
                     if ((*(*it).first).size() > i)
+                    if (it->first->size() > i)
+                    {
                         if (it == list.begin())
+                        {
                             temp = (*(*it).first)[i];
+                            temp = (*it->first)[i];
+                        }
                         else
+                        {
                             if (temp != (*(*it).first)[i])
+                            if (temp != (*it->first)[i])
                                 return output;
+                        }
 …
         else if (list.size() == 1)
+        {
             return ((*list.begin()).getComparable() + " ");
+        }
         else
+        {
             std::string output = "";
+            return (list.begin()->getComparable() + ' ');
+        }
+        else
+        {
+            std::string output;
             for (unsigned int i = 0; true; i++)
+            {
+                char tempComparable = 0;
                 char temp = 0;
                 for (ArgumentCompletionList::const_iterator it = list.begin(); it != list.end(); ++it)
+                {
+                    std::string argument = (*it).getComparable();
+                    const std::string& argumentComparable = it->getComparable();
+                    const std::string& argument = it->getString();
                     if (argument.size() > i)
+                    {
                         if (it == list.begin())
+                        {
+                            tempComparable = argumentComparable[i];
                             temp = argument[i];
+                        }
                         else
+                        {
                             if (temp != argument[i])
+                            if (tempComparable != argumentComparable[i])
                                 return output;
+                            else if (temp != argument[i])
+                                temp = tempComparable;
+                        }
+                    }

code/trunk/src/libraries/core/CommandExecutor.h

-                      r5781
+                      r6417
             static unsigned int argumentsGiven();
             static bool enoughArgumentsGiven(ConsoleCommand* command);
             static std::string getArgument(unsigned int index);
             static std::string getLastArgument();
+            static const std::string& getArgument(unsigned int index);
+            static const std::string& getLastArgument();
             static void createListOfPossibleIdentifiers(const std::string& fragment);
 …
             static Identifier* getPossibleIdentifier(const std::string& name);
             static ConsoleCommand* getPossibleCommand(const std::string& name, Identifier* identifier = 0);
             static std::string getPossibleArgument(const std::string& name, ConsoleCommand* command, unsigned int param);
+            static const std::string& getPossibleArgument(const std::string& name, ConsoleCommand* command, unsigned int param);
             static void createArgumentCompletionList(ConsoleCommand* command, unsigned int param);

code/trunk/src/libraries/core/CommandLineParser.cc

-                      r6021
+                      r6417
                 this->value_ = temp;
+            }
             else if (value == "")
+            else if (value.empty())
+            {
                 this->bHasDefaultValue_ = false;
 …
                     OrxAssert(cmdLineArgsShortcut_.find(it->second->getShortcut()) == cmdLineArgsShortcut_.end(),
                         "Cannot have two command line shortcut with the same name.");
                     if (it->second->getShortcut() != "")
+                    if (!it->second->getShortcut().empty())
                         cmdLineArgsShortcut_[it->second->getShortcut()] = it->second;
+                }
 …
+                        {
                             // negative number as a value
                             value += arguments[i] + " ";
+                            value += arguments[i] + ' ';
+                        }
                         else
 …
                             // save old data first
                             value = removeTrailingWhitespaces(value);
                             if (name != "")
+                            if (!name.empty())
+                            {
                                 checkFullArgument(name, value, bParsingFile);
                                 name = "";
                                 assert(shortcut == "");
+                                name.clear();
+                                assert(shortcut.empty());
+                            }
                             else if (shortcut != "")
+                            else if (!shortcut.empty())
+                            {
                                 checkShortcut(shortcut, value, bParsingFile);
                                 shortcut = "";
                                 assert(name == "");
+                                shortcut.clear();
+                                assert(name.empty());
+                            }
 …
                             // reset value string
                             value = "";
+                            value.clear();
+                        }
+                    }
 …
                         // value string
                         if (name == "" && shortcut == "")
+                        if (name.empty() && shortcut.empty())
+                        {
                             ThrowException(Argument, "Expected \"-\" or \"-\" in command line arguments.\n");
 …
             // parse last argument
             value = removeTrailingWhitespaces(value);
             if (name != "")
+            if (!name.empty())
+            {
                 checkFullArgument(name, value, bParsingFile);
                 assert(shortcut == "");
+            }
             else if (shortcut != "")
+                assert(shortcut.empty());
+            }
+            else if (!shortcut.empty())
+            {
                 checkShortcut(shortcut, value, bParsingFile);
                 assert(name == "");
+                assert(name.empty());
+            }
+        }
 …
             it != inst.cmdLineArgs_.end(); ++it)
+        {
             if (it->second->getShortcut() != "")
+            if (!it->second->getShortcut().empty())
                 infoStr << " [-" << it->second->getShortcut() << "] ";
             else
                 infoStr << "      ";
             infoStr << "--" << it->second->getName() << " ";
+            infoStr << "--" << it->second->getName() << ' ';
             if (it->second->getValue().getType() != MT_Type::Bool)
                 infoStr << "ARG ";
 …
     void CommandLineParser::_parseFile()
+    {
         std::string filename = CommandLineParser::getValue("optionsFile").getString();
+        const std::string& filename = CommandLineParser::getValue("optionsFile").getString();
         // look for additional arguments in given file or start.ini as default

code/trunk/src/libraries/core/ConfigFileManager.cc

-                      r5929
+                      r6417
         if (identifier != Identifier::getLowercaseStringIdentifierMapEnd())
+        {
             std::map<std::string, ConfigValueContainer*>::const_iterator variable = (*identifier).second->getLowercaseConfigValueMap().find(getLowercase(varname));
             if (variable != (*identifier).second->getLowercaseConfigValueMapEnd())
                 return (*variable).second->set(value);
+            std::map<std::string, ConfigValueContainer*>::const_iterator variable = identifier->second->getLowercaseConfigValueMap().find(getLowercase(varname));
+            if (variable != identifier->second->getLowercaseConfigValueMapEnd())
+                return variable->second->set(value);
+        }
         return false;
+    }
+    std::string getConfig(const std::string& classname, const std::string& varname)
+    {
+        return ConfigFileManager::getInstance().getValue(ConfigFileType::Settings, classname, varname, "", true);
+    }
 …
         if (identifier != Identifier::getLowercaseStringIdentifierMapEnd())
+        {
             std::map<std::string, ConfigValueContainer*>::const_iterator variable = (*identifier).second->getLowercaseConfigValueMap().find(getLowercase(varname));
             if (variable != (*identifier).second->getLowercaseConfigValueMapEnd())
                 return (*variable).second->tset(value);
+            std::map<std::string, ConfigValueContainer*>::const_iterator variable = identifier->second->getLowercaseConfigValueMap().find(getLowercase(varname));
+            if (variable != identifier->second->getLowercaseConfigValueMapEnd())
+                return variable->second->tset(value);
+        }
         return false;
 …
             this->value_ = value;
         else
             this->value_ = "\"" + addSlashes(stripEnclosingQuotes(value)) + "\"";
+            this->value_ = '"' + addSlashes(stripEnclosingQuotes(value)) + '"';
+    }
 …
     std::string ConfigFileEntryValue::getFileEntry() const
+    {
         if (this->additionalComment_ == "" || this->additionalComment_.size() == 0)
             return (this->name_ + "=" + this->value_);
         else
             return (this->name_ + "=" + this->value_ + " " + this->additionalComment_);
+        if (this->additionalComment_.empty())
+            return (this->name_ + '=' + this->value_);
+        else
+            return (this->name_ + '=' + this->value_ + " " + this->additionalComment_);
+    }
 …
     std::string ConfigFileEntryVectorValue::getFileEntry() const
+    {
         if (this->additionalComment_ == "" || this->additionalComment_.size() == 0)
             return (this->name_ + "[" + multi_cast<std::string>(this->index_) + "]" + "=" + this->value_);
         else
             return (this->name_ + "[" + multi_cast<std::string>(this->index_) + "]=" + this->value_ + " " + this->additionalComment_);
+        if (this->additionalComment_.empty())
+            return (this->name_ + '[' + multi_cast<std::string>(this->index_) + ']' + '=' + this->value_);
+        else
+            return (this->name_ + '[' + multi_cast<std::string>(this->index_) + "]=" + this->value_ + ' ' + this->additionalComment_);
+    }
 …
     std::string ConfigFileSection::getFileEntry() const
+    {
         if (this->additionalComment_ == "" || this->additionalComment_.size() == 0)
             return ("[" + this->name_ + "]");
         else
             return ("[" + this->name_ + "] " + this->additionalComment_);
+        if (this->additionalComment_.empty())
+            return ('[' + this->name_ + ']');
+        else
+            return ('[' + this->name_ + "] " + this->additionalComment_);
+    }
 …
                 std::getline(file, line);
                 std::string temp = getStripped(line);
+                const std::string& temp = getStripped(line);
                 if (!isEmpty(temp) && !isComment(temp))
+                {
 …
+                    {
                         // New section
                         std::string comment = line.substr(pos2 + 1);
+                        const std::string& comment = line.substr(pos2 + 1);
                         if (isComment(comment))
                             newsection = new ConfigFileSection(line.substr(pos1 + 1, pos2 - pos1 - 1), comment);
 …
                                 commentposition = getNextCommentPosition(line, commentposition + 1);
+                            }
                             std::string value = "", comment = "";
+                            std::string value, comment;
                             if (commentposition == std::string::npos)
+                            {
 …
+        {
             std::map<std::string, Identifier*>::const_iterator it2 = Identifier::getStringIdentifierMap().find((*it1)->getName());
             if (it2 != Identifier::getStringIdentifierMapEnd() && (*it2).second->hasConfigValues())
+            if (it2 != Identifier::getStringIdentifierMapEnd() && it2->second->hasConfigValues())
+            {
                 // The section exists, delete comment
 …
                 for (std::list<ConfigFileEntry*>::iterator it3 = (*it1)->entries_.begin(); it3 != (*it1)->entries_.end(); )
+                {
                     std::map<std::string, ConfigValueContainer*>::const_iterator it4 = (*it2).second->getConfigValueMap().find((*it3)->getName());
                     if (it4 != (*it2).second->getConfigValueMapEnd())
+                    std::map<std::string, ConfigValueContainer*>::const_iterator it4 = it2->second->getConfigValueMap().find((*it3)->getName());
+                    if (it4 != it2->second->getConfigValueMapEnd())
+                    {
                         // The config-value exists, delete comment
 …
                 if (it->second->hasConfigValues())
+                {
                     for (std::map<std::string, ConfigValueContainer*>::const_iterator it2 = (*it).second->getConfigValueMapBegin(); it2 != (*it).second->getConfigValueMapEnd(); ++it2)
+                    for (std::map<std::string, ConfigValueContainer*>::const_iterator it2 = it->second->getConfigValueMapBegin(); it2 != it->second->getConfigValueMapEnd(); ++it2)
                         it2->second->update();

code/trunk/src/libraries/core/ConfigFileManager.h

-                      r6105
+                      r6417
 #include "util/Singleton.h"
+// tolua_begin
 namespace orxonox
+{
+    // tolua_end
     // Use int as config file type to have an arbitrary number of files
     struct ConfigFileType : OrxEnum<ConfigFileType>
 …
         static const int Settings            = 1;
         static const int JoyStickCalibration = 2;
+        static const int CommandHistory      = 3;
         static const int numberOfReservedTypes = 1024;
     };
+    _CoreExport bool config(const std::string& classname, const std::string& varname, const std::string& value);
+    _CoreExport bool config(const std::string& classname, const std::string& varname, const std::string& value); // tolua_export
+    _CoreExport std::string getConfig(const std::string& classname, const std::string& varname); // tolua_export
     _CoreExport bool tconfig(const std::string& classname, const std::string& varname, const std::string& value);
     _CoreExport void reloadConfig();
 …
+    {
         public:
+            inline ConfigFileEntryValue(const std::string& name, const std::string& value = "", bool bString = false, const std::string& additionalComment = "") : name_(name), value_(value), bString_(bString), additionalComment_(additionalComment) {}
+            inline ConfigFileEntryValue(const std::string& name, const std::string& value = "", bool bString = false, const std::string& additionalComment = "")
+                : name_(name)
+                , value_(value)
+                , bString_(bString)
+                , additionalComment_(additionalComment)
+                {}
             inline virtual ~ConfigFileEntryValue() {}
 …
         public:
+            inline ConfigFileSection(const std::string& name, const std::string& additionalComment = "") : name_(name), additionalComment_(additionalComment), bUpdated_(false) {}
+            inline ConfigFileSection(const std::string& name, const std::string& additionalComment = "")
+                : name_(name)
+                , additionalComment_(additionalComment)
+                , bUpdated_(false)
+                {}
             ~ConfigFileSection();
 …
                 { this->getSection(section)->setValue(name, value, bString); this->save(); }
             inline std::string getValue(const std::string& section, const std::string& name, const std::string& fallback, bool bString)
                 { std::string output = this->getSection(section)->getValue(name, fallback, bString); this->saveIfUpdated(); return output; }
+                { const std::string& output = this->getSection(section)->getValue(name, fallback, bString); this->saveIfUpdated(); return output; }
             inline void setValue(const std::string& section, const std::string& name, unsigned int index, const std::string& value, bool bString)
                 { this->getSection(section)->setValue(name, index, value, bString); this->save(); }
             inline std::string getValue(const std::string& section, const std::string& name, unsigned int index, const std::string& fallback, bool bString)
                 { std::string output = this->getSection(section)->getValue(name, index, fallback, bString); this->saveIfUpdated(); return output; }
+                { const std::string& output = this->getSection(section)->getValue(name, index, fallback, bString); this->saveIfUpdated(); return output; }
             inline void deleteVectorEntries(const std::string& section, const std::string& name, unsigned int startindex = 0)
 …
             static ConfigFileManager* singletonPtr_s;
     };
+}
+} // tolua_export
 #endif /* _ConfigFileManager_H__ */

code/trunk/src/libraries/core/ConfigValueContainer.h

-                      r5738
+                      r6417
                 @param defvalue The default-value
             */
             template <class V>
             ConfigValueContainer(ConfigFileType type, Identifier* identifier, const std::string& sectionname, const std::string& varname, const std::vector<V>& defvalue)
+            template <class D, class V>
+            ConfigValueContainer(ConfigFileType type, Identifier* identifier, const std::string& sectionname, const std::string& varname, const std::vector<D>& defvalue, const std::vector<V>& value)
+            {
                 this->init(type, identifier, sectionname, varname);
 …
                 if ((this->callback_ && object) || this->bContainerIsNew_)
+                {
-                    if (this->bContainerIsNew_)
-                        this->bContainerIsNew_ = false;
                     T temp = *value;
                     this->value_.getValue(value);
+                    if ((*value) != temp)
+                    {
+                    if (this->bContainerIsNew_ || (*value) != temp)
+                    {
+                        this->bContainerIsNew_ = false;
                         if (this->callback_ && object)
                             this->callback_->call(object);

code/trunk/src/libraries/core/ConfigValueIncludes.h

-                      r6105
+                      r6417
  *      Fabian 'x3n' Landau
  *   Co-authors:
  *      ...
+ *      Reto Grieder (functions)
+ *
  */
 /**
+    @file
+    @brief Definition of macros for config-values.
+@file
+@brief
+    Definition of macros and functions for config-values.
 */
 …
 #include "ConfigFileManager.h"
+namespace orxonox
+{
+    /** Sets a runtime configurable value.
+        If the container for the value doesn't yet exist, a new one is created.
+        Also, the @a variable argument will be modified and set to the new value (default or from ini file).
+    @param object
+        Class instance that the config value should belong to (usually just 'this')
+    @param variable
+        Pointer to the variable where the value should be written to
+    @param type
+        Type of the config file, usually ConfigFileType::Settings
+    @param sectionName
+        Name of the section in the ini file (e.g. [MySection])
+    @param entryName
+        Name of the entry in the ini file (e.g. [MySection] myValue)
+    @param defaultValue
+        Value to be used if it cannot be read from the ini file
+    */
+    template <class T, class D, class V>
+    inline ConfigValueContainer& setConfigValueGeneric(T* object, V* variable, ConfigFileType type, const std::string& sectionName, const std::string& entryName, const D& defaultValue)
+    {
+        ConfigValueContainer* container = object->getIdentifier()->getConfigValueContainer(entryName);
+        if (!container)
+        {
+            container = new ConfigValueContainer(type, object->getIdentifier(), sectionName, entryName, defaultValue, *variable);
+            object->getIdentifier()->addConfigValueContainer(entryName, container);
+        }
+        return container->getValue(variable, object);
+    }
+}
+/**
+    @brief Assigns the value, defined in the config-file, to the variable (or the default-value, if there is no entry in the file).
+    @param varname The name of the variable
+    @param defvalue The default-value of the variable
+/** Sets a runtime configurable value (simplified macro version of setConfigValueGeneric)
+    If the container for the value doesn't yet exist, a new one is created.
+    Also, the @a varname argument will be modified and set to the new value (default or from ini file).
+@param varname
+    Variable name as C++ identifier. It will be used as entry name and as variable pointer
+@param defaultValue
+    Value to be used if it cannot be read from the ini file
 */
+#define SetConfigValueGeneric(type, varname, entryname, sectionname, defvalue) \
+    static orxonox::Identifier* identifier##varname = this->getIdentifier(); \
+    orxonox::ConfigValueContainer* container##varname = identifier##varname->getConfigValueContainer(entryname); \
+    if (!container##varname) \
+    { \
+        container##varname = new orxonox::ConfigValueContainer(type, identifier##varname, sectionname, entryname, defvalue, varname); \
+        identifier##varname->addConfigValueContainer(entryname, container##varname); \
+    } \
+    container##varname->getValue(&varname, this)
+#define SetConfigValue(varname, defaultValue) \
+    orxonox::setConfigValueGeneric(this, &varname, ConfigFileType::Settings, this->getIdentifier()->getName(), #varname, defaultValue)
+#define SetConfigValue(varname, defvalue) SetConfigValueGeneric(ConfigFileType::Settings, varname, #varname, identifier##varname->getName(), defvalue)
+/** Sets a runtime configurable value (simplified macro version of setConfigValueGeneric)
+    If the container for the value doesn't yet exist, a new one is created.
+    Also, the @a varname argument will be modified and set to the new value (default or from ini file).
+@param variable
+    Variable name as C++ identifier.
+@param entryName
+    Name of the entry in the ini file (e.g. [MySection] myValue)
+@param defaultValue
+    Value to be used if it cannot be read from the ini file
+*/
+#define SetConfigValueAlias(variable, entryName, defaultValue) \
+    orxonox::setConfigValueGeneric(this, &variable, ConfigFileType::Settings, this->getIdentifier()->getName(), entryName, defaultValue)
+/**
+    @brief Assigns the vector-values, defined in the config-file, to the vector (or the default-value, if there are no entries in the file).
+    @param varname The name of the std::vector
+    @param defvalue The default-value
+namespace orxonox
+{
+    /** Resets a runtime configurable value to its default.
+        If the container for the value doesn't yet exist, a warning is displayed.
+        Also, the @a variable argument will be modified and set to the default value.
+    @param object
+        Class instance that the config value should belong to (usually just 'this')
+    @param variable
+        Pointer to the variable where the value should be written to
+    @param entryName
+        Name of the entry in the ini file (e.g. [MySection] myValue)
+    */
+    template <class T, class V>
+    inline void resetConfigValueGeneric(T* object, V* variable, const std::string& entryName)
+    {
+        ConfigValueContainer* container = object->getIdentifier()->getConfigValueContainer(entryName);
+        if (container)
+        {
+            container->reset();
+            container->getValue(variable, object);
+        }
+        else
+        {
+            COUT(2) << "Warning: Couldn't reset config-value '" << entryName << "' in class '"
+                    << object->getIdentifier()->getName() << "', corresponding container doesn't exist." << std::endl;
+        }
+    }
+}
+/** Resets a runtime configurable value to its default (simplified macro version of modifyConfigValueGeneric)
+    If the container for the value doesn't yet exist, a warning is displayed.
+    Also, the @a varname argument will be modified and set to the default value.
+@param varname
+    Variable name as C++ identifier. It will be used as entry name and as variable pointer
 */
+#define SetConfigValueVectorGeneric(type, varname, defvalue) \
+    static orxonox::Identifier* identifier##varname = this->getIdentifier(); \
+    orxonox::ConfigValueContainer* container##varname = identifier##varname->getConfigValueContainer(#varname); \
+    if (!container##varname) \
+    { \
+        container##varname = new orxonox::ConfigValueContainer(type, identifier##varname, identifier##varname->getName(), #varname, defvalue); \
+        identifier##varname->addConfigValueContainer(#varname, container##varname); \
+    } \
+    container##varname->getValue(&varname, this)
+#define SetConfigValueVector(varname, defvalue) SetConfigValueVectorGeneric(ConfigFileType::Settings, varname, defvalue)
+#define ResetConfigValue(varname) \
+    orxonox::resetConfigValueGeneric(this, &varname, #varname)
+/**
+    @brief Sets the variable and the config-file entry back to the previously defined default-value.
+    @param varname The name of the variable
+/** Modifies a runtime configurable value by using a modifier and some arguments.
+    If the container for the value doesn't yet exist, a warning is displayed.
+    Also, the @a variable argument will be modified and set to the current value.
+@param object
+    Class instance that the config value should belong to (usually just 'this')
+@param variable
+    Pointer to the variable where the value should be written to
+@param entryName
+    Name of the entry in the ini file (e.g. [MySection] myValue)
+@param modifier
+    On of these functions: set, tset, add, remove, reset, update
+@param ...
+    Arguments for the modifier function
 */
+#define ResetConfigValue(varname) \
+    orxonox::ConfigValueContainer* container##varname##reset = this->getIdentifier()->getConfigValueContainer(#varname); \
+    if (container##varname##reset) \
+#define ModifyConfigValueGeneric(object, variable, entryName, modifier, ...) \
+    if (orxonox::ConfigValueContainer* container = object->getIdentifier()->getConfigValueContainer(entryName)) \
     { \
         container##varname##reset->reset(); \
         container##varname##reset->getValue(&varname, this); \
+        container->modifier(__VA_ARGS__); \
+        container->getValue(variable, object); \
     } \
     else \
     { \
+        COUT(2) << "Warning: Couldn't reset config-value '" << #varname << "', corresponding container doesn't exist." << std::endl; \
+        COUT(2) << "Warning: Couln't modify config-value '" << entryName << "' in class '" \
+                << object->getIdentifier()->getName() << "', corresponding container doesn't exist." << std::endl; \
+    }
+/**
+    @brief Modifies a config-value by using a modifier and some arguments.
+    @param varname The name of the config-value
+    @param modifier The name of the modifier: set, tset, add, remove, reset, update
+/** Modifies a runtime configurable value by using a modifier and some arguments.
+    If the container for the value doesn't yet exist, a warning is displayed.
+    Also, the @a varname argument will be modified and set to the current value.
+@param varname
+    Variable name as C++ identifier. It will be used as entry name and as variable pointer
+@param modifier
+    On of these functions: set, tset, add, remove, reset, update
+@param ...
+    Arguments for the modifier function
 */
 #define ModifyConfigValue(varname, modifier, ...) \
+    orxonox::ConfigValueContainer* container##varname##modify##modifier = this->getIdentifier()->getConfigValueContainer(#varname); \
+    if (container##varname##modify##modifier) \
+    { \
+        container##varname##modify##modifier->modifier(__VA_ARGS__); \
+        container##varname##modify##modifier->getValue(&varname, this); \
+    } \
+    else \
+    { \
+        COUT(2) << "Warning: Couln't modify config-value '" << #varname << "', corresponding container doesn't exist." << std::endl; \
+    }
+    ModifyConfigValueGeneric(this, &varname, #varname, modifier, __VA_ARGS__)
 #endif /* _ConfigValueIncludes_H__ */

code/trunk/src/libraries/core/ConsoleCommandCompilation.cc

r6105	r6417
35	35	#include "util/Debug.h"
36	36	#include "util/ExprParser.h"
	37	#include "util/StringUtils.h"
37	38	#include "ConsoleCommand.h"
38	39
…	…
142	143	}
143	144
144		std::string output ~~= ""~~;
	145	std::string output;
145	146	while (file.good() && !file.eof())
146	147	{
…	…
158	159	float calculate(const std::string& calculation)
159	160	{
160		ExprParser expr(calculation);
	161	ExprParser expr;
	162	expr.parse(calculation);
161	163	if (expr.getSuccess())
162	164	{
…	…
165	167	COUT(3) << "Greetings from the restaurant at the end of the universe." << std::endl;
166	168	}
167		if (~~expr.getRemains() != ""~~)
	169	if (!expr.getRemains().empty())
168	170	{
169		COUT(2) << "Warning: Expression could not be parsed to the end! Remains: '" << expr.getRemains() << ~~"'"~~ << std::endl;
	171	COUT(2) << "Warning: Expression could not be parsed to the end! Remains: '" << expr.getRemains() << '\'' << std::endl;
170	172	}
171	173	return static_cast<float>(expr.getResult());

code/trunk/src/libraries/core/Core.cc

-                      r6105
+                      r6417
 #include "util/Debug.h"
 #include "util/Exception.h"
+#include "util/Scope.h"
 #include "util/SignalHandler.h"
 #include "PathConfig.h"
 …
     SetCommandLineArgument(settingsFile, "orxonox.ini").information("THE configuration file");
 #ifdef ORXONOX_PLATFORM_WINDOWS
+    SetCommandLineArgument(limitToCPU, 0).information("Limits the program to one cpu/core (1, 2, 3, etc.). 0 turns it off (default)");
+#endif
+    /**
+    @brief
+        Helper class for the Core singleton: we cannot derive
+        Core from OrxonoxClass because we need to handle the Identifier
+        destruction in the Core destructor.
+    */
+    class CoreConfiguration : public OrxonoxClass
+    {
+    public:
+        CoreConfiguration()
+        {
+        }
+        void initialise()
+        {
+            RegisterRootObject(CoreConfiguration);
+            this->setConfigValues();
+        }
+        /**
+            @brief Function to collect the SetConfigValue-macro calls.
+        */
+        void setConfigValues()
+        {
+#ifdef ORXONOX_RELEASE
+            const unsigned int defaultLevelLogFile = 3;
+#else
+            const unsigned int defaultLevelLogFile = 4;
+#endif
+            SetConfigValueGeneric(ConfigFileType::Settings, softDebugLevelLogFile_, "softDebugLevelLogFile", "OutputHandler", defaultLevelLogFile)
+                .description("The maximum level of debug output shown in the log file");
+            OutputHandler::getInstance().setSoftDebugLevel(OutputHandler::logFileOutputListenerName_s, this->softDebugLevelLogFile_);
+            SetConfigValue(language_, Language::getInstance().defaultLanguage_)
+                .description("The language of the in game text")
+                .callback(this, &CoreConfiguration::languageChanged);
+            SetConfigValue(bInitializeRandomNumberGenerator_, true)
+                .description("If true, all random actions are different each time you start the game")
+                .callback(this, &CoreConfiguration::initializeRandomNumberGenerator);
+        }
+        /**
+            @brief Callback function if the language has changed.
+        */
+        void languageChanged()
+        {
+            // Read the translation file after the language was configured
+            Language::getInstance().readTranslatedLanguageFile();
+        }
+        /**
+            @brief Sets the language in the config-file back to the default.
+        */
+        void resetLanguage()
+        {
+            ResetConfigValue(language_);
+        }
+        void initializeRandomNumberGenerator()
+        {
+            static bool bInitialized = false;
+            if (!bInitialized && this->bInitializeRandomNumberGenerator_)
+            {
+                srand(static_cast<unsigned int>(time(0)));
+                rand();
+                bInitialized = true;
+            }
+        }
+        int softDebugLevelLogFile_;                     //!< The debug level for the log file (belongs to OutputHandler)
+        std::string language_;                          //!< The language
+        bool bInitializeRandomNumberGenerator_;         //!< If true, srand(time(0)) is called
+    };
+    SetCommandLineArgument(limitToCPU, 1).information("Limits the program to one CPU/core (1, 2, 3, etc.). Default is the first core (faster than off)");
+#endif
     Core::Core(const std::string& cmdLine)
 …
         // Cleanup guard for external console commands that don't belong to an Identifier
         , consoleCommandDestroyer_(CommandExecutor::destroyExternalCommands)
-        , configuration_(new CoreConfiguration()) // Don't yet create config values!
         , bGraphicsLoaded_(false)
+    {
 …
         this->languageInstance_.reset(new Language());
+        // Do this soon after the ConfigFileManager has been created to open up the
+        // possibility to configure everything below here
+        ClassIdentifier<Core>::getIdentifier("Core")->initialiseObject(this, "Core", true);
+        this->setConfigValues();
         // create persistent io console
         this->ioConsole_.reset(new IOConsole());
 …
         // creates the class hierarchy for all classes with factories
         Identifier::createClassHierarchy();
-        // Do this soon after the ConfigFileManager has been created to open up the
-        // possibility to configure everything below here
-        this->configuration_->initialise();
         // Load OGRE excluding the renderer and the render window
 …
     Core::~Core()
+    {
+        // Remove us from the object lists again to avoid problems when destroying them
+        this->unregisterObject();
+    }
+    //! Function to collect the SetConfigValue-macro calls.
+    void Core::setConfigValues()
+    {
+#ifdef ORXONOX_RELEASE
+        const unsigned int defaultLevelLogFile = 3;
+#else
+        const unsigned int defaultLevelLogFile = 4;
+#endif
+        setConfigValueGeneric(this, &this->softDebugLevelLogFile_, ConfigFileType::Settings, "OutputHandler", "softDebugLevelLogFile", defaultLevelLogFile)
+            .description("The maximum level of debug output shown in the log file");
+        OutputHandler::getInstance().setSoftDebugLevel(OutputHandler::logFileOutputListenerName_s, this->softDebugLevelLogFile_);
+        SetConfigValue(language_, Language::getInstance().defaultLanguage_)
+            .description("The language of the in game text")
+            .callback(this, &Core::languageChanged);
+        SetConfigValue(bInitRandomNumberGenerator_, true)
+            .description("If true, all random actions are different each time you start the game")
+            .callback(this, &Core::initRandomNumberGenerator);
+    }
+    //! Callback function if the language has changed.
+    void Core::languageChanged()
+    {
+        // Read the translation file after the language was configured
+        Language::getInstance().readTranslatedLanguageFile();
+    }
+    void Core::initRandomNumberGenerator()
+    {
+        static bool bInitialized = false;
+        if (!bInitialized && this->bInitRandomNumberGenerator_)
+        {
+            srand(static_cast<unsigned int>(time(0)));
+            rand();
+            bInitialized = true;
+        }
+    }
 …
+    }
+    /**
+        @brief Returns the configured language.
+    */
+    /*static*/ const std::string& Core::getLanguage()
+    {
+        return Core::getInstance().configuration_->language_;
+    }
+    /**
+        @brief Sets the language in the config-file back to the default.
+    */
+    /*static*/ void Core::resetLanguage()
+    {
+        Core::getInstance().configuration_->resetLanguage();
+    //! Sets the language in the config-file back to the default.
+    void Core::resetLanguage()
+    {
+        ResetConfigValue(language_);
+    }
 …
     void Core::preUpdate(const Clock& time)
+    {
         // singletons from other libraries
         ScopedSingletonManager::update<ScopeID::Root>(time);
+        // Update singletons before general ticking
+        ScopedSingletonManager::preUpdate<ScopeID::Root>(time);
         if (this->bGraphicsLoaded_)
+        {
             // process input events
             this->inputManager_->update(time);
             // process gui events
             this->guiManager_->update(time);
             // graphics singletons from other libraries
             ScopedSingletonManager::update<ScopeID::Graphics>(time);
+        }
         // process console text
         this->ioConsole_->update(time);
         // process thread commands
         this->tclThreadManager_->update(time);
+            // Process input events
+            this->inputManager_->preUpdate(time);
+            // Update GUI
+            this->guiManager_->preUpdate(time);
+            // Update singletons before general ticking
+            ScopedSingletonManager::preUpdate<ScopeID::Graphics>(time);
+        }
+        // Process console events and status line
+        this->ioConsole_->preUpdate(time);
+        // Process thread commands
+        this->tclThreadManager_->preUpdate(time);
+    }
     void Core::postUpdate(const Clock& time)
+    {
+        // Update singletons just before rendering
+        ScopedSingletonManager::postUpdate<ScopeID::Root>(time);
         if (this->bGraphicsLoaded_)
+        {
+            // Update singletons just before rendering
+            ScopedSingletonManager::postUpdate<ScopeID::Graphics>(time);
             // Render (doesn't throw)
             this->graphicsManager_->update(time);
+            this->graphicsManager_->postUpdate(time);
+        }
+    }

code/trunk/src/libraries/core/Core.h

-                      r6105
+                      r6417
 #include <cassert>
+#include <string>
 #include <boost/scoped_ptr.hpp>
-#include "util/OutputHandler.h"
-#include "util/Scope.h"
 #include "util/ScopeGuard.h"
 #include "util/Singleton.h"
+#include "core/OrxonoxClass.h"
 namespace orxonox
+{
-    class CoreConfiguration;
     /**
     @brief
 …
         You should only create this singleton once because it destroys the identifiers!
     */
     class _CoreExport Core : public Singleton<Core>
+    class _CoreExport Core : public Singleton<Core>, public OrxonoxClass
+    {
         typedef Loki::ScopeGuardImpl0<void (*)()> SimpleScopeGuard;
 …
             void setConfigValues();
+            static const std::string& getLanguage();
+            static void  resetLanguage();
+            //! Returns the configured language.
+            const std::string& getLanguage()
+                { return this->language_; }
+            void resetLanguage();
         private:
             Core(const Core&); //!< Don't use (undefined symbol)
+            void languageChanged();
+            void initRandomNumberGenerator();
             void preUpdate(const Clock& time);
 …
             void setThreadAffinity(int limitToCPU);
+            // MANAGED SINGLETONS/OBJECTS
             // Mind the order for the destruction!
             scoped_ptr<PathConfig>        pathConfig_;
 …
             scoped_ptr<Language>          languageInstance_;
             scoped_ptr<IOConsole>         ioConsole_;
-            scoped_ptr<CoreConfiguration> configuration_;
             scoped_ptr<TclBind>           tclBind_;
             scoped_ptr<TclThreadManager>  tclThreadManager_;
+            scoped_ptr<Scope<ScopeID::Root> >     rootScope_;
             // graphical
             scoped_ptr<GraphicsManager>   graphicsManager_;     //!< Interface to OGRE
             scoped_ptr<InputManager>      inputManager_;        //!< Interface to OIS
             scoped_ptr<GUIManager>        guiManager_;          //!< Interface to GUI
-            scoped_ptr<Scope<ScopeID::Root> >     rootScope_;
             scoped_ptr<Scope<ScopeID::Graphics> > graphicsScope_;
             bool                          bGraphicsLoaded_;
+            static Core* singletonPtr_s;
+            int                           softDebugLevelLogFile_;      //!< The debug level for the log file (belongs to OutputHandler)
+            std::string                   language_;                   //!< The language
+            bool                          bInitRandomNumberGenerator_; //!< If true, srand(time(0)) is called
+            static Core*                  singletonPtr_s;
     };
+}

code/trunk/src/libraries/core/DynLib.cc

-                      r6073
+                      r6417
         m_hInst = (DYNLIB_HANDLE)DYNLIB_LOAD( name.c_str() );
         if( !m_hInst )
+        if (!m_hInst)
             ThrowException(
                 General,
 …
         COUT(4) << "Unloading module " << mName << std::endl;
         if( DYNLIB_UNLOAD( m_hInst ) )
+        if (DYNLIB_UNLOAD( m_hInst ))
+        {
             ThrowException(
 …
         return std::string(mac_errorBundle());
 #else
         return std::string("");
+        return "";
 #endif
+    }

code/trunk/src/libraries/core/Event.cc

-                      r5929
+                      r6417
     /**
         @brief Processes an event (calls the set-function if the necessary conditions are met).
         @param event     The fired event
         @param object    The object whose state is affected by the event (only needed for debug output)
 …
         if (this->bProcessingEvent_)
+        {
             COUT(2) << "Warning: Detected Event loop in section \"" << event.statename_ << "\" of object \"" << object->getName() << "\" and fired by \"" << event.originator_->getName() << "\"" << std::endl;
+            COUT(2) << "Warning: Detected Event loop in section \"" << event.statename_ << "\" of object \"" << object->getName() << "\" and fired by \"" << event.originator_->getName() << '"' << std::endl;
             return;
+        }

code/trunk/src/libraries/core/Event.h

-                      r5929
+                      r6417
     /**
         @brief The EventState contains information about an event state.
         An event state is a state of an object, which can be changed by events.
         Event states are changed through functions. Possible functions headers for set event states are:
 …
          - boolean state:    function(bool state)
          - individual state: function(bool state, SomeClass originator)
         Note that SomeClass may be any class deriving from BaseObject. You will not receive events from originators of other classes.
         The actual class for SomeClass must be specified as the second argument of the XMLPortEventState macro.
         The this pointer of the affected object is hidden in the functors, because the events are processed in the BaseObject, but some
         statefunctions may be from child-classes.
 …
             void process(const Event& event, BaseObject* object);
             Functor* getFunctor() const
                 { return this->statefunction_; }

code/trunk/src/libraries/core/EventIncludes.h

-                      r5929
+                      r6417
 /**
     @brief Defines a new event state (a state of the object which can be changed by events).
     @param classname    The name of this class
     @param subclassname Usually BaseObject - if different, only instances of this class can send events to this object
 …
 #define XMLPortEventStateIntern(name, classname, statename, xmlelement, mode) \
     static orxonox::ExecutorMember<classname>* xmlsetfunctor##name = (orxonox::ExecutorMember<classname>*)&orxonox::createExecutor(orxonox::createFunctor(&classname::addEventSource), std::string( #classname ) + "::" + "addEventSource" + "(" + statename + ")")->setDefaultValue(1, statename); \
     static orxonox::ExecutorMember<classname>* xmlgetfunctor##name = (orxonox::ExecutorMember<classname>*)&orxonox::createExecutor(orxonox::createFunctor(&classname::getEventSource), std::string( #classname ) + "::" + "getEventSource" + "(" + statename + ")")->setDefaultValue(1, statename); \
+    static orxonox::ExecutorMember<classname>* xmlsetfunctor##name = (orxonox::ExecutorMember<classname>*)&orxonox::createExecutor(orxonox::createFunctor(&classname::addEventSource), std::string( #classname ) + "::" + "addEventSource" + '(' + statename + ')')->setDefaultValue(1, statename); \
+    static orxonox::ExecutorMember<classname>* xmlgetfunctor##name = (orxonox::ExecutorMember<classname>*)&orxonox::createExecutor(orxonox::createFunctor(&classname::getEventSource), std::string( #classname ) + "::" + "getEventSource" + '(' + statename + ')')->setDefaultValue(1, statename); \
     XMLPortObjectGeneric(xmlport##name, classname, orxonox::BaseObject, statename, xmlsetfunctor##name, xmlgetfunctor##name, xmlelement, mode, false, true)
 /**
     @brief Defines a new event name for a class. Named events can only have names which were defined with this macro.
     @param classname The name of the class
     @param name      The name of the event
 …
 /**
     @brief This macro is needed to fire an event with this name. The event name must previously be declared with @ref CreateEventName.
 */
+*/
 #define FireEventName(classname, name) \
     eventname##classname##name
 #endif /* _EventIncludes_H__ */

code/trunk/src/libraries/core/Executor.cc

r5738	r6417
73	73	{
74	74	// only one param: check if there are params given, otherwise try to use default values
75		std::string temp = getStripped(params);
76		if ((temp != "") && (temp.size() != 0))
	75	if (!getStripped(params).empty())
77	76	{
78	77	param[0] = params;

code/trunk/src/libraries/core/Executor.h

-                      r5738
+                      r6417
     else if (paramCount == 1) \
     { \
         std::string temp = getStripped(params); \
         if ((temp != "") && (temp.size() != 0)) \
+        const std::string& temp = getStripped(params); \
+        if (!temp.empty()) \
         { \
             COUT(5) << "Calling Executor " << this->name_ << " through parser with one parameter, using whole string: " << params << std::endl; \
 …
                 { return this->functor_->getTypenameReturnvalue(); }
             inline void setName(const std::string name)
+            inline void setName(const std::string& name)
                 { this->name_ = name; }
             inline const std::string& getName() const

code/trunk/src/libraries/core/Functor.h

r5929	r6417
35	35	#include "util/Debug.h"
36	36	#include "util/MultiType.h"
37		~~#include "util/StringUtils.h"~~
38	37
39	38	namespace orxonox

code/trunk/src/libraries/core/GUIManager.cc

-                      r6105
+                      r6417
 #include <CEGUIResourceProvider.h>
 #include <CEGUISystem.h>
+#include <CEGUIWindow.h>
 #include <ogreceguirenderer/OgreCEGUIRenderer.h>
 …
 #include "util/Clock.h"
+#include "util/Convert.h"
 #include "util/Debug.h"
 #include "util/Exception.h"
 #include "util/OrxAssert.h"
+#include "ConsoleCommand.h"
+#include "Core.h"
 #include "LuaState.h"
 #include "PathConfig.h"
 …
 namespace orxonox
+{
+    static void key_esc()
+        { GUIManager::getInstance().keyESC(); }
+    SetConsoleCommandShortcutExternAlias(key_esc, "keyESC");
     class CEGUILogger : public CEGUI::DefaultLogger
+    {
 …
     GUIManager* GUIManager::singletonPtr_s = 0;
+    SetConsoleCommandShortcut(GUIManager, showGUI).accessLevel(AccessLevel::User).defaultValue(1, false).defaultValue(2, true);
+    SetConsoleCommandShortcut(GUIManager, hideGUI).accessLevel(AccessLevel::User);
     /**
     @brief
 …
         , resourceProvider_(0)
         , camera_(NULL)
+        , bShowIngameGUI_(false)
+    {
         using namespace CEGUI;
 …
         // setup scripting
         luaState_.reset(new LuaState());
+        rootFileInfo_ = Resource::getInfo("InitialiseGUI.lua");
+        // This is necessary to ensure that input events also use the right resource info when triggering lua functions
+        luaState_->setDefaultResourceInfo(this->rootFileInfo_);
         scriptModule_.reset(new LuaScriptModule(luaState_->getInternalLuaState()));
 …
         // Initialise the basic Lua code
+        rootFileInfo_ = Resource::getInfo("InitialiseGUI.lua", "GUI");
+        this->luaState_->doFile("InitialiseGUI.lua", "GUI", false);
+        this->luaState_->doFile("InitialiseGUI.lua");
         // Align CEGUI mouse with OIS mouse
 …
         This time value is then used to provide a fluent animation of the GUI.
     */
     void GUIManager::update(const Clock& time)
+    void GUIManager::preUpdate(const Clock& time)
+    {
         assert(guiSystem_);
 …
         For more details check out loadGUI_2.lua where the function presides.
     */
+    void GUIManager::showGUI(const std::string& name)
+    {
+        this->luaState_->doString("showGUI(\"" + name + "\")", rootFileInfo_);
+    /*static*/ void GUIManager::showGUI(const std::string& name, bool hidePrevious, bool showCursor)
+    {
+        GUIManager::getInstance().executeCode("showGUI(\"" + name + "\", " + multi_cast<std::string>(hidePrevious) + ", " + multi_cast<std::string>(showCursor) + ")");
+    }
+    /**
+    @brief
+        Hack-ish. Needed for GUIOverlay.
+    */
+    void GUIManager::showGUIExtra(const std::string& name, const std::string& ptr, bool hidePrevious, bool showCursor)
+    {
+        this->executeCode("showGUI(\"" + name + "\", " + multi_cast<std::string>(hidePrevious) + ", " + multi_cast<std::string>(showCursor) + ", " + ptr + ")");
+    }
+    /**
+    @brief
+        Hides specified GUI.
+    @param name
+        The name of the GUI.
+    */
+    /*static*/ void GUIManager::hideGUI(const std::string& name)
+    {
+        GUIManager::getInstance().executeCode("hideGUI(\"" + name + "\")");
+    }
+    void GUIManager::keyESC()
+    {
+        this->executeCode("keyESC()");
+    }
+    void GUIManager::setBackground(const std::string& name)
+    {
+        this->executeCode("setBackground(\"" + name + "\")");
+    }
 …
+        }
+    }
+    void GUIManager::subscribeEventHelper(CEGUI::Window* window, const std::string& event, const std::string& function)
+    {
+        window->subscribeScriptedEvent(event, function);
+    }
+}

code/trunk/src/libraries/core/GUIManager.h

-                      r5929
+                      r6417
 #include <map>
+#include <set>
 #include <string>
 #include <CEGUIForwardRefs.h>
 …
 #include "input/InputHandler.h"
 namespace orxonox
+{
+namespace orxonox // tolua_export
+{ // tolua_export
     class PlayerInfo; // Forward declaration
 …
         Those input events are then injected into CEGUI in Lua.
     */
+    class _CoreExport GUIManager : public Singleton<GUIManager>, public InputHandler
+    {
+    class _CoreExport GUIManager // tolua_export
+        : public Singleton<GUIManager>, public InputHandler
+    { // tolua_export
         friend class Singleton<GUIManager>;
     public:
 …
         ~GUIManager();
         void update(const Clock& time);
+        void preUpdate(const Clock& time);
+        void showGUI(const std::string& name);
+        void executeCode(const std::string& str);
+        static void showGUI(const std::string& name, bool hidePrevious=false, bool showCursor=true);
+        void showGUIExtra(const std::string& name, const std::string& ptr, bool hidePrevious=false, bool showCursor=true);
+        static void hideGUI(const std::string& name);
+        void keyESC();
+        void setBackground(const std::string& name);
         void setCamera(Ogre::Camera* camera);
 …
             { std::map<std::string, PlayerInfo*>::const_iterator it = this->players_.find(guiname); return (it != this->players_.end()) ? it->second : 0; }
+        // TODO: Temporary hack because the tolua exported CEGUI method does not seem to work
+        static void subscribeEventHelper(CEGUI::Window* window, const std::string& event, const std::string& function); //tolua_export
     private:
         GUIManager(const GUIManager& instance); //!< private and undefined copy c'tor (this is a singleton class)
+        void executeCode(const std::string& str);
         // keyHandler functions
 …
         static GUIManager*                   singletonPtr_s;    //!< Singleton reference to GUIManager
+        bool                                 bShowIngameGUI_;
     };
+}
+    }; // tolua_export
+} // tolua_export
 #endif /* _GUIManager_H__ */

code/trunk/src/libraries/core/Game.cc

-                      r6021
+                      r6417
 #include "GameMode.h"
 #include "GameState.h"
+#include "GUIManager.h"
 namespace orxonox
 …
     Game* Game::singletonPtr_s = 0;
+    /**
+    @brief
+        Represents one node of the game state tree.
+    */
+    //! Represents one node of the game state tree.
     struct GameStateTreeNode
+    {
 …
     };
-    /**
-    @brief
-        Another helper class for the Game singleton: we cannot derive
-        Game from OrxonoxClass because we need to handle the Identifier
-        destruction in the Core destructor.
-    */
-    class GameConfiguration : public OrxonoxClass
+    {
-    public:
-        GameConfiguration()
+        {
-            RegisterRootObject(GameConfiguration);
-            this->setConfigValues();
+        }
-        void setConfigValues()
+        {
-            SetConfigValue(statisticsRefreshCycle_, 250000)
-                .description("Sets the time in microseconds interval at which average fps, etc. get updated.");
-            SetConfigValue(statisticsAvgLength_, 1000000)
-                .description("Sets the time in microseconds interval at which average fps, etc. gets calculated.");
-            SetConfigValue(fpsLimit_, 50)
-                .description("Sets the desired framerate (0 for no limit).");
+        }
-        unsigned int statisticsRefreshCycle_;
-        unsigned int statisticsAvgLength_;
-        unsigned int fpsLimit_;
-    };
-    /**
-    @brief
-        Non-initialising constructor.
-    */
     Game::Game(const std::string& cmdLine)
         // Destroy factories before the Core!
 …
 #endif
+        // reset statistics
+        this->statisticsStartTime_ = 0;
+        this->statisticsTickTimes_.clear();
+        this->periodTickTime_ = 0;
+        this->periodTime_ = 0;
+        this->avgFPS_ = 0.0f;
+        this->avgTickTime_ = 0.0f;
+        this->excessSleepTime_ = 0;
         // Create an empty root state
         this->declareGameState<GameState>("GameState", "emptyRootGameState", true, false);
 …
         // Create the Core
         this->core_.reset(new Core(cmdLine));
+        // Do this after the Core creation!
+        ClassIdentifier<Game>::getIdentifier("Game")->initialiseObject(this, "Game", true);
+        this->setConfigValues();
         // After the core has been created, we can safely instantiate the GameStates that don't require graphics
 …
         this->loadedTopStateNode_ = this->rootStateNode_;
         this->loadedStates_.push_back(this->getState(rootStateNode_->name_));
-        // Do this after the Core creation!
-        this->configuration_.reset(new GameConfiguration());
+    }
 …
     Game::~Game()
+    {
+        // Remove us from the object lists again to avoid problems when destroying them
+        this->unregisterObject();
+    }
+    void Game::setConfigValues()
+    {
+        SetConfigValue(statisticsRefreshCycle_, 250000)
+            .description("Sets the time in microseconds interval at which average fps, etc. get updated.");
+        SetConfigValue(statisticsAvgLength_, 1000000)
+            .description("Sets the time in microseconds interval at which average fps, etc. gets calculated.");
+        SetConfigValue(fpsLimit_, 50)
+            .description("Sets the desired frame rate (0 for no limit).");
+    }
 …
             COUT(0) << "Warning: Starting game without requesting GameState. This automatically terminates the program." << std::endl;
-        // reset statistics
-        this->statisticsStartTime_ = 0;
-        this->statisticsTickTimes_.clear();
-        this->periodTickTime_ = 0;
-        this->periodTime_ = 0;
-        this->avgFPS_ = 0.0f;
-        this->avgTickTime_ = 0.0f;
-        this->excessSleepTime_ = 0;
         // START GAME
         // first delta time should be about 0 seconds
 …
             this->updateGameStateStack();
             // Core preUpdate (doesn't throw)
+            // Core preUpdate
             try
                 { this->core_->preUpdate(*this->gameClock_); }
 …
             this->updateGameStates();
             // Core postUpdate (doesn't throw)
+            // Core postUpdate
             try
                 { this->core_->postUpdate(*this->gameClock_); }
 …
             this->updateStatistics();
             // Limit framerate
+            // Limit frame rate
             this->updateFPSLimiter();
+        }
 …
         this->statisticsTickTimes_.back().tickLength += currentRealTime - currentTime;
         this->periodTickTime_ += currentRealTime - currentTime;
         if (this->periodTime_ > this->configuration_->statisticsRefreshCycle_)
+        if (this->periodTime_ > this->statisticsRefreshCycle_)
+        {
             std::list<StatisticsTickInfo>::iterator it = this->statisticsTickTimes_.begin();
             assert(it != this->statisticsTickTimes_.end());
             int64_t lastTime = currentTime - this->configuration_->statisticsAvgLength_;
+            int64_t lastTime = currentTime - this->statisticsAvgLength_;
             if (static_cast<int64_t>(it->tickTime) < lastTime)
+            {
 …
             uint32_t framesPerPeriod = this->statisticsTickTimes_.size();
+            this->avgFPS_ = static_cast<float>(framesPerPeriod) / (currentTime - this->statisticsTickTimes_.front().tickTime) * 1000000.0f;
+            // Why minus 1? No idea, but otherwise the fps rate is always (from 10 to 200!) one frame too low
+            this->avgFPS_ = -1 + static_cast<float>(framesPerPeriod) / (currentTime - this->statisticsTickTimes_.front().tickTime) * 1000000.0f;
             this->avgTickTime_ = static_cast<float>(this->periodTickTime_) / framesPerPeriod / 1000.0f;
             this->periodTime_ -= this->configuration_->statisticsRefreshCycle_;
+            this->periodTime_ -= this->statisticsRefreshCycle_;
+        }
+    }
 …
     void Game::updateFPSLimiter()
+    {
+        // Why configuration_->fpsLimit_ - 1? No idea, but otherwise the fps rate is always (from 10 to 200!) one frame too high
+        uint32_t nextTime = gameClock_->getMicroseconds() - excessSleepTime_ + static_cast<uint32_t>(1000000.0f / (configuration_->fpsLimit_ - 1));
+        uint64_t nextTime = gameClock_->getMicroseconds() - excessSleepTime_ + static_cast<uint32_t>(1000000.0f / fpsLimit_);
         uint64_t currentRealTime = gameClock_->getRealMicroseconds();
         while (currentRealTime < nextTime - minimumSleepTime_)
 …
         shared_ptr<GameState> state = this->getState(name);
         state->activate();
+        state->activateInternal();
         if (!this->loadedStates_.empty())
             this->loadedStates_.back()->activity_.topState = false;
 …
             if (!this->loadedStates_.empty())
                 this->loadedStates_.back()->activity_.topState = true;
             state->deactivate();
+            state->deactivateInternal();
+        }
         catch (...)

code/trunk/src/libraries/core/Game.h

-                      r5929
+                      r6417
 #include "util/ScopeGuard.h"
 #include "util/Singleton.h"
+#include "core/OrxonoxClass.h"
 /**
 …
 #define DeclareGameState(className, stateName, bIgnoreTickTime, bGraphicsMode) \
     static bool BOOST_PP_CAT(bGameStateDummy_##className, __LINE__) = orxonox::Game::declareGameState<className>(#className, stateName, bIgnoreTickTime, bGraphicsMode)
+// tolua_begin
 namespace orxonox
+{
+    class GameConfiguration;
+// tolua_end
     //! Helper object required before GameStates are being constructed
 …
         You should only create this singleton once because it owns the Core class! (see remark there)
     */
+    class _CoreExport Game : public Singleton<Game>
+    {
+// tolua_begin
+    class _CoreExport Game
+// tolua_end
+        : public Singleton<Game>, public OrxonoxClass
+    { // tolua_export
         friend class Singleton<Game>;
         typedef std::vector<shared_ptr<GameState> > GameStateVector;
 …
         ~Game();
+        void setConfigValues();
         void setStateHierarchy(const std::string& str);
         shared_ptr<GameState> getState(const std::string& name);
 …
         void stop();
+        void requestState(const std::string& name);
+        void requestStates(const std::string& names);
+        void popState();
+        static Game& getInstance(){ return Singleton<Game>::getInstance(); } // tolua_export
+        void requestState(const std::string& name); //tolua_export
+        void requestStates(const std::string& names); //tolua_export
+        void popState(); //tolua_export
         const Clock& getGameClock() { return *this->gameClock_; }
 …
         scoped_ptr<Core>                   core_;
         ObjScopeGuard                      gsFactoryDestroyer_;
-        scoped_ptr<GameConfiguration>      configuration_;
         GameStateMap                       constructedStates_;
 …
         unsigned int                       minimumSleepTime_;
+        // config values
+        unsigned int                       statisticsRefreshCycle_;
+        unsigned int                       statisticsAvgLength_;
+        unsigned int                       fpsLimit_;
         static std::map<std::string, GameStateInfo> gameStateDeclarations_s;
         static Game* singletonPtr_s;        //!< Pointer to the Singleton
     };
+    }; //tolua_export
     template <class T>
 …
         return true;
+    }
+}
+} //tolua_export
 #endif /* _Game_H__ */

code/trunk/src/libraries/core/GameMode.h

-                      r5929
+                      r6417
 #include "CorePrereqs.h"
+// tolua_begin
 namespace orxonox
+{
     class _CoreExport GameMode
+    {
+// tolua_end
         friend class Core;
         public:
+// tolua_begin
             static bool showsGraphics() { return bShowsGraphics_s; }
             static bool playsSound()    { return bPlaysSound_s; }
 …
             static bool isStandalone()  { return bIsStandalone_s; }
             static bool isMaster()      { return bIsMaster_s; }
+// tolua_end
             static void setPlaysSound   (bool val) { bPlaysSound_s    = val; }
 …
             static bool bIsStandalone_s;
             static bool bIsMaster_s;
     };
+}
+    }; // tolua_export
+} // tolua_export
 #endif /* _GameMode_H__ */

code/trunk/src/libraries/core/GameState.cc

r5738	r6417
83	83	this->activity_.active = false;
84	84	this->activity_.deactivating = true;
85		this->activate();
	85	this->deactivate();
86	86	this->activity_.deactivating = false;
87	87	this->activity_.suspended = false;

code/trunk/src/libraries/core/GraphicsManager.cc

-                      r6105
+                      r6417
         // At first, add the root paths of the data directories as resource locations
         Ogre::ResourceGroupManager::getSingleton().addResourceLocation(PathConfig::getDataPathString(), "FileSystem", "dataRoot", false);
+        Ogre::ResourceGroupManager::getSingleton().addResourceLocation(PathConfig::getDataPathString(), "FileSystem");
         // Load resources
         resources_.reset(new XMLFile("resources.oxr", "dataRoot"));
+        resources_.reset(new XMLFile("DefaultResources.oxr"));
         resources_->setLuaSupport(false);
         Loader::open(resources_.get());
 …
         if (PathConfig::isDevelopmentRun())
+        {
             Ogre::ResourceGroupManager::getSingleton().addResourceLocation(PathConfig::getExternalDataPathString(), "FileSystem", "externalDataRoot", false);
             extResources_.reset(new XMLFile("resources.oxr", "externalDataRoot"));
+            Ogre::ResourceGroupManager::getSingleton().addResourceLocation(PathConfig::getExternalDataPathString(), "FileSystem");
+            extResources_.reset(new XMLFile("resources.oxr"));
             extResources_->setLuaSupport(false);
             Loader::open(extResources_.get());
 …
                 shared_array<char> data(new char[output.str().size()]);
                 // Debug optimisations
                 const std::string outputStr = output.str();
+                const std::string& outputStr = output.str();
                 char* rawData = data.get();
                 for (unsigned i = 0; i < outputStr.size(); ++i)
 …
         COUT(3) << "Setting up Ogre..." << std::endl;
         if (ogreConfigFile_ == "")
+        if (ogreConfigFile_.empty())
+        {
             COUT(2) << "Warning: Ogre config file set to \"\". Defaulting to config.cfg" << std::endl;
             ModifyConfigValue(ogreConfigFile_, tset, "config.cfg");
+        }
         if (ogreLogFile_ == "")
+        if (ogreLogFile_.empty())
+        {
             COUT(2) << "Warning: Ogre log file set to \"\". Defaulting to ogre.log" << std::endl;
 …
+    {
         // just to make sure the next statement doesn't segfault
         if (ogrePluginsDirectory_ == "")
             ogrePluginsDirectory_ = ".";
+        if (ogrePluginsDirectory_.empty())
+            ogrePluginsDirectory_ = '.';
         boost::filesystem::path folder(ogrePluginsDirectory_);
 …
         need the time. So we shouldn't run into problems.
     */
     void GraphicsManager::update(const Clock& time)
+    void GraphicsManager::postUpdate(const Clock& time)
+    {
         Ogre::FrameEvent evt;
 …
+    {
         int orxonoxLevel;
+        switch (lml)
+        {
+        case Ogre::LML_TRIVIAL:
+            orxonoxLevel = this->ogreLogLevelTrivial_;
+            break;
+        case Ogre::LML_NORMAL:
+            orxonoxLevel = this->ogreLogLevelNormal_;
+            break;
+        case Ogre::LML_CRITICAL:
+            orxonoxLevel = this->ogreLogLevelCritical_;
+            break;
+        default:
+            orxonoxLevel = 0;
+        std::string introduction;
+        // Do not show caught OGRE exceptions in front
+        if (message.find("EXCEPTION") != std::string::npos)
+        {
+            orxonoxLevel = OutputLevel::Debug;
+            introduction = "Ogre, caught exception: ";
+        }
+        else
+        {
+            switch (lml)
+            {
+            case Ogre::LML_TRIVIAL:
+                orxonoxLevel = this->ogreLogLevelTrivial_;
+                break;
+            case Ogre::LML_NORMAL:
+                orxonoxLevel = this->ogreLogLevelNormal_;
+                break;
+            case Ogre::LML_CRITICAL:
+                orxonoxLevel = this->ogreLogLevelCritical_;
+                break;
+            default:
+                orxonoxLevel = 0;
+            }
+            introduction = "Ogre: ";
+        }
         OutputHandler::getOutStream(orxonoxLevel)
             << "Ogre: " << message << std::endl;
+            << introduction << message << std::endl;
+    }
 …
+    {
         assert(this->renderWindow_);
+        this->renderWindow_->writeContentsToTimestampedFile(PathConfig::getLogPathString() + "screenShot_", ".jpg");
+        this->renderWindow_->writeContentsToTimestampedFile(PathConfig::getLogPathString() + "screenShot_", ".png");
+    }
+}

code/trunk/src/libraries/core/GraphicsManager.h

r6105	r6417
63	63	void setConfigValues();
64	64
65		void update(const Clock& time);
	65	void postUpdate(const Clock& time);
66	66
67	67	Ogre::Viewport* getViewport() { return this->viewport_; }

code/trunk/src/libraries/core/IOConsole.cc

-                      r6105
+                      r6417
 #include <iomanip>
 #include <iostream>
+#include "util/Clock.h"
+#include "util/Math.h"
 #include "core/Game.h"
 #include "core/input/InputBuffer.h"
 …
     IOConsole* IOConsole::singletonPtr_s = NULL;
-    int IOConsole::extractLogLevel(std::string* text)
+    {
-        // Handle line colouring by inspecting the first letter
-        char level = 0;
-        if (!text->empty())
+        {
-            level = (*text)[0];
-            if (level == -1 || level >= 1 && level <= 6)
+            {
-                *text = text->substr(1);
-                if (level != -1)
-                    return level;
+            }
+        }
-        return 0;
+    }
-    inline bool IOConsole::willPrintStatusLines()
+    {
-        return !this->statusLineWidths_.empty()
-             && this->terminalWidth_  >= this->statusLineMaxWidth_
-             && this->terminalHeight_ >= (this->minOutputLines_ + this->statusLineWidths_.size());
+    }
     // ###############################
     // ###  ShellListener methods  ###
 …
+    }
-    //! Called if the text in the input-line has changed
-    void IOConsole::inputChanged()
+    {
-        this->printInputLine();
-        this->cout_.flush();
+    }
-    //! Called if the position of the cursor in the input-line has changed
-    void IOConsole::cursorChanged()
+    {
-        this->printInputLine();
-        this->cout_.flush();
+    }
     //! Called if a command is about to be executed
     void IOConsole::executed()
+    {
         this->shell_->addOutputLine(this->promptString_ + this->shell_->getInput());
+        this->shell_->addOutput(this->promptString_ + this->shell_->getInput() + '\n', Shell::Command);
+    }
 …
     IOConsole::IOConsole()
         : shell_(new Shell("IOConsole", false, true))
+        : shell_(new Shell("IOConsole", false))
         , buffer_(shell_->getInputBuffer())
         , cout_(std::cout.rdbuf())
+        , promptString_("orxonox # ")
         , bStatusPrinted_(false)
+        , promptString_("orxonox # ")
+        , originalTerminalSettings_(new termios())
+        , originalTerminalSettings_(0)
+    {
         this->setTerminalMode();
 …
         // Make sure we make way for the status lines
         this->update(Game::getInstance().getGameClock());
+        this->preUpdate(Game::getInstance().getGameClock());
+    }
     IOConsole::~IOConsole()
+    {
+        // Empty all buffers
+        this->update(Game::getInstance().getGameClock());
+        // Process output written to std::cout in the meantime
+        std::cout.flush();
+        if (!this->origCout_.str().empty())
+            this->shell_->addOutput(this->origCout_.str(), Shell::None);
         // Erase input and status lines
         this->cout_ << "\033[1G\033[J";
 …
         resetTerminalMode();
-        delete this->originalTerminalSettings_;
         this->shell_->destroy();
 …
+    }
     void IOConsole::update(const Clock& time)
+    void IOConsole::preUpdate(const Clock& time)
+    {
         unsigned char c;
 …
+        }
         // We always assume that the cursor is on the inputline.
+        // We always assume that the cursor is on the input line.
         // But we cannot always be sure about that, esp. if we scroll the console
         this->cout_ << "\033[" << this->statusLineWidths_.size() << 'B';
 …
         // Process output written to std::cout
+        std::cout.flush();
         if (!this->origCout_.str().empty())
+        {
             this->shell_->addOutputLine(this->origCout_.str());
+            this->shell_->addOutput(this->origCout_.str(), Shell::None);
             this->origCout_.str("");
+        }
+    }
+    void IOConsole::printLogText(const std::string& text)
+    {
+        std::string output = text;
+        /*int level =*/ this->extractLogLevel(&output);
+    void IOConsole::printOutputLine(const std::string& text, Shell::LineType type)
+    {
 /*
         // Colour line
         switch (level)
+        {
         case -1: this->cout_ << "\033[37m"; break;
         case  1: this->cout_ << "\033[91m"; break;
         case  2: this->cout_ << "\033[31m"; break;
         case  3: this->cout_ << "\033[34m"; break;
         case  4: this->cout_ << "\033[36m"; break;
         case  5: this->cout_ << "\033[35m"; break;
         case  6: this->cout_ << "\033[37m"; break;
+        switch (type)
+        {
+        case Shell::None:    this->cout_ << "\033[37m"; break;
+        case Shell::Error:   this->cout_ << "\033[91m"; break;
+        case Shell::Warning: this->cout_ << "\033[31m"; break;
+        case Shell::Info:    this->cout_ << "\033[34m"; break;
+        case Shell::Debug:   this->cout_ << "\033[36m"; break;
+        case Shell::Verbose: this->cout_ << "\033[35m"; break;
+        case Shell::Ultra:   this->cout_ << "\033[37m"; break;
         default: break;
+        }
 …
         // Print output line
         this->cout_ << output;
+        this->cout_ << text;
         // Reset colour to white
 …
         this->cout_ << "\033[u";
         if (this->buffer_->getCursorPosition() > 0)
             this->cout_ << "\033[" << this->buffer_->getCursorPosition() << "C";
+            this->cout_ << "\033[" << this->buffer_->getCursorPosition() << 'C';
+    }
 …
+    {
         termios new_settings;
+        this->originalTerminalSettings_ = new termios();
         tcgetattr(0, this->originalTerminalSettings_);
 …
         new_settings.c_cc[VMIN]  = 0;
         tcsetattr(0, TCSANOW, &new_settings);
+    }
+    void IOConsole::resetTerminalMode()
+    {
+        tcsetattr(0, TCSANOW, IOConsole::originalTerminalSettings_);
+        atexit(&IOConsole::resetTerminalMode);
+    }
+    /*static*/ void IOConsole::resetTerminalMode()
+    {
+        if(IOConsole::singletonPtr_s && IOConsole::singletonPtr_s->originalTerminalSettings_)
+        {
+            tcsetattr(0, TCSANOW, IOConsole::singletonPtr_s->originalTerminalSettings_);
+            delete IOConsole::singletonPtr_s->originalTerminalSettings_;
+            IOConsole::singletonPtr_s->originalTerminalSettings_ = 0;
+        }
+    }
 …
+    }
+    inline bool IOConsole::willPrintStatusLines()
+    {
+        return !this->statusLineWidths_.empty()
+             && this->terminalWidth_  >= this->statusLineMaxWidth_
+             && this->terminalHeight_ >= this->minOutputLines_ + (int)this->statusLineWidths_.size();
+    }
     // ###############################
     // ###  ShellListener methods  ###
 …
         this->cout_ << "\033[K";
         // Reprint the last output line
         this->printLogText(*(this->shell_->getNewestLineIterator()));
+        this->printOutputLine(this->shell_->getNewestLineIterator()->first, this->shell_->getNewestLineIterator()->second);
         // Restore cursor
         this->cout_ << "\033[u";
 …
     void IOConsole::lineAdded()
+    {
         int newLines = this->shell_->getNewestLineIterator()->size() / this->terminalWidth_ + 1;
+        int newLines = this->shell_->getNewestLineIterator()->first.size() / this->terminalWidth_ + 1;
         // Create new lines by scrolling the screen
         this->cout_ << "\033[" << newLines << 'S';
 …
         // Print the new output lines
         for (int i = 0; i < newLines; ++i)
+            this->printLogText(this->shell_->getNewestLineIterator()->substr(i*this->terminalWidth_, this->terminalWidth_));
+        {
+            Shell::LineList::const_iterator it = this->shell_->getNewestLineIterator();
+            this->printOutputLine(it->first.substr(i*this->terminalWidth_, this->terminalWidth_), it->second);
+        }
         // Move cursor down
         this->cout_ << "\033[1B\033[1G";
 …
         this->cout_.flush();
+    }
+    //! Called if the text in the input-line has changed
+    void IOConsole::inputChanged()
+    {
+        this->printInputLine();
+        this->cout_.flush();
+    }
+    //! Called if the position of the cursor in the input-line has changed
+    void IOConsole::cursorChanged()
+    {
+        this->printInputLine();
+        this->cout_.flush();
+    }
+}
 …
 // ##################################
+#include <windows.h>
 namespace orxonox
+{
+    //! Redirects std::cout, creates the corresponding Shell and changes the terminal mode
     IOConsole::IOConsole()
         : shell_(new Shell("IOConsole", false, true))
+        : shell_(new Shell("IOConsole", false))
         , buffer_(shell_->getInputBuffer())
         , cout_(std::cout.rdbuf())
-        , bStatusPrinted_(false)
         , promptString_("orxonox # ")
+    {
+        , inputLineHeight_(1)
+        , statusLines_(1)
+        , lastOutputLineHeight_(0)
+    {
+        // Disable standard this->cout_ logging
+        OutputHandler::getInstance().disableCout();
+        // Redirect std::cout to an ostringstream
+        // (Other part is in the initialiser list)
+        std::cout.rdbuf(this->origCout_.rdbuf());
+        this->setTerminalMode();
+        CONSOLE_SCREEN_BUFFER_INFO screenBufferInfo;
+        GetConsoleScreenBufferInfo(this->stdOutHandle_, &screenBufferInfo);
+        this->terminalWidth_  = screenBufferInfo.dwSize.X;
+        this->terminalHeight_ = screenBufferInfo.dwSize.Y;
+        // Determines where we are in respect to output already written with std::cout
+        this->inputLineRow_ = screenBufferInfo.dwCursorPosition.Y;
 /*
+        this->setTerminalMode();
+        this->lastTerminalWidth_  = this->terminalWidth_;
+        this->lastTerminalHeight_ = this->terminalHeight_;
+*/
+        // Cursor already at the end of the screen buffer?
+        // (assuming the current input line height is 1)
+        if (this->inputLineRow_ >= this->terminalHeight_ - this->statusLines_)
+            SetConsoleCursorPosition(this->stdOutHandle_, makeCOORD(0, this->terminalHeight_ - this->statusLines_));
+        // Prevent input line from overflowing
+        int maxInputLength = (this->terminalHeight_ - this->statusLines_) * this->terminalWidth_ - 1 - this->promptString_.size();
+        // Consider that the echo of a command might include the command plus some other characters (assumed max 80)
+        // Also put a minimum so the config file parser is not overwhelmed with the command history
+        this->buffer_->setMaxLength(std::min(8192, (maxInputLength - 80) / 2));
+        // Print input and status line and position cursor
+        this->inputChanged();
+        this->cursorChanged();
+        this->lastRefreshTime_ = Game::getInstance().getGameClock().getRealMicroseconds();
+        this->preUpdate(Game::getInstance().getGameClock());
         this->shell_->registerListener(this);
+        // Manually set the widths of the individual status lines
+        this->statusLineWidths_.push_back(29);
+        this->statusLineMaxWidth_ = 29;
+        this->getTerminalSize();
+    }
+    //! Resets std::cout redirection and restores the terminal mode
+    IOConsole::~IOConsole()
+    {
+        // Process output written to std::cout in the meantime
+        std::cout.flush();
+        if (!this->origCout_.str().empty())
+            this->shell_->addOutput(this->origCout_.str(), Shell::None);
+        this->shell_->unregisterListener(this);
+        // Erase input and status lines
+        COORD pos = {0, this->inputLineRow_};
+        this->writeText(std::string((this->inputLineHeight_ + this->statusLines_) * this->terminalWidth_, ' '), pos);
+        // Move cursor to the beginning of the line
+        SetConsoleCursorPosition(stdOutHandle_, pos);
+        // Restore this->cout_ redirection
+        std::cout.rdbuf(this->cout_.rdbuf());
+        // Enable standard this->cout_ logging again
+        OutputHandler::getInstance().enableCout();
+        resetTerminalMode();
+        this->shell_->destroy();
+    }
+    //! Processes the pending input key strokes, refreshes the status lines and handles std::cout (redirected)
+    void IOConsole::preUpdate(const Clock& time)
+    {
+        // Process input
+        while (true)
+        {
+            DWORD count;
+            INPUT_RECORD inrec;
+            PeekConsoleInput(this->stdInHandle_, &inrec, 1, &count);
+            if (count == 0)
+                break;
+            ReadConsoleInput(this->stdInHandle_, &inrec, 1, &count);
+            if (inrec.EventType == KEY_EVENT && inrec.Event.KeyEvent.bKeyDown)
+            {
+                // Process keyboard modifiers (Ctrl, Alt and Shift)
+                DWORD modifiersIn = inrec.Event.KeyEvent.dwControlKeyState;
+                int modifiersOut = 0;
+                if ((modifiersIn & (LEFT_ALT_PRESSED  | RIGHT_ALT_PRESSED))  != 0)
+                    modifiersOut |= KeyboardModifier::Alt;
+                if ((modifiersIn & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED)) != 0)
+                    modifiersOut |= KeyboardModifier::Ctrl;
+                if ((modifiersIn & SHIFT_PRESSED) != 0)
+                    modifiersOut |= KeyboardModifier::Shift;
+                // ASCII character (0 for special keys)
+                char asciiChar = inrec.Event.KeyEvent.uChar.AsciiChar;
+                // Process special keys and if not found, use Key::A as dummy (InputBuffer uses the ASCII text anyway)
+                switch (inrec.Event.KeyEvent.wVirtualKeyCode)
+                {
+                case VK_BACK:   this->buffer_->buttonPressed(KeyEvent(KeyCode::Back,     asciiChar, modifiersOut)); break;
+                case VK_TAB:    this->buffer_->buttonPressed(KeyEvent(KeyCode::Tab,      asciiChar, modifiersOut)); break;
+                case VK_RETURN: this->buffer_->buttonPressed(KeyEvent(KeyCode::Return,   asciiChar, modifiersOut)); break;
+                case VK_PAUSE:  this->buffer_->buttonPressed(KeyEvent(KeyCode::Pause,    asciiChar, modifiersOut)); break;
+                case VK_ESCAPE: this->buffer_->buttonPressed(KeyEvent(KeyCode::Escape,   asciiChar, modifiersOut)); break;
+                case VK_SPACE:  this->buffer_->buttonPressed(KeyEvent(KeyCode::Space,    asciiChar, modifiersOut)); break;
+                case VK_PRIOR:  this->buffer_->buttonPressed(KeyEvent(KeyCode::PageUp,   asciiChar, modifiersOut)); break;
+                case VK_NEXT:   this->buffer_->buttonPressed(KeyEvent(KeyCode::PageDown, asciiChar, modifiersOut)); break;
+                case VK_END:    this->buffer_->buttonPressed(KeyEvent(KeyCode::End,      asciiChar, modifiersOut)); break;
+                case VK_HOME:   this->buffer_->buttonPressed(KeyEvent(KeyCode::Home,     asciiChar, modifiersOut)); break;
+                case VK_LEFT:   this->buffer_->buttonPressed(KeyEvent(KeyCode::Left,     asciiChar, modifiersOut)); break;
+                case VK_UP:     this->buffer_->buttonPressed(KeyEvent(KeyCode::Up,       asciiChar, modifiersOut)); break;
+                case VK_RIGHT:  this->buffer_->buttonPressed(KeyEvent(KeyCode::Right,    asciiChar, modifiersOut)); break;
+                case VK_DOWN:   this->buffer_->buttonPressed(KeyEvent(KeyCode::Down,     asciiChar, modifiersOut)); break;
+                case VK_INSERT: this->buffer_->buttonPressed(KeyEvent(KeyCode::Insert,   asciiChar, modifiersOut)); break;
+                case VK_DELETE: this->buffer_->buttonPressed(KeyEvent(KeyCode::Delete,   asciiChar, modifiersOut)); break;
+                default:        this->buffer_->buttonPressed(KeyEvent(KeyCode::A,        asciiChar, modifiersOut));
+                }
+            }
+        }
+        // TODO: Respect screen buffer size changes
+/*
+        // The user can manually adjust the screen buffer size on Windows
+        // And we don't want to screw the console because of that
         this->lastTerminalWidth_ = this->terminalWidth_;
         this->lastTerminalHeight_ = this->terminalHeight_;
+        // Disable standard this->cout_ logging
+        OutputHandler::getInstance().disableCout();
+        this->getTerminalSize(); // Also sets this->inputLineRow_ according to the cursor position
+        // Is there still enough space below the cursor for the status line(s)?
+        if (this->inputLineRow_ >= this->terminalHeight_ - this->statusLines_)
+            this->moveCursor(0, -this->inputLineRow_ + this->terminalHeight_ - this->statusLines_ - 1);
 */
+    }
+    IOConsole::~IOConsole()
+    {
+/*
+        resetTerminalMode();
+        this->shell_->destroy();
+        // Enable standard this->cout_ logging again
+        OutputHandler::getInstance().enableCout();
+*/
+    }
+    void IOConsole::update(const Clock& time)
+    {
+/*
+        unsigned char c = 0;
+        while (std::cin.good())
+        {
+            c = std::cin.get();
+            if (std::cin.bad())
+                break;
+        }
+        // Reset error flags in std::cin
+        std::cin.clear();
+        // Determine terminal width and height
+        this->lastTerminalWidth_ = this->terminalWidth_;
+        this->lastTerminalHeight_ = this->terminalHeight_;
+        this->getTerminalSize();
+*/
+    }
+    void IOConsole::printLogText(const std::string& text)
+    {
+    }
+    void IOConsole::printInputLine()
+    {
+    }
+        // Refresh status line 5 times per second
+        if (time.getMicroseconds() > this->lastRefreshTime_ + 1000000)
+        {
+            this->printStatusLines();
+            this->lastRefreshTime_ = time.getMicroseconds();
+        }
+        // Process output written to std::cout
+        std::cout.flush();
+        if (!this->origCout_.str().empty())
+        {
+            this->shell_->addOutput(this->origCout_.str(), Shell::None);
+            this->origCout_.str("");
+        }
+    }
+    //! Prints output text. Similar to writeText, but sets the colour according to the output level
+    void IOConsole::printOutputLine(const std::string& text, Shell::LineType type, const COORD& pos)
+    {
+        // Colour line
+        WORD colour = 0;
+        switch (type)
+        {
+        case Shell::Error:   colour = FOREGROUND_INTENSITY                    | FOREGROUND_RED; break;
+        case Shell::Warning: colour = FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED; break;
+        case Shell::Info:
+        case Shell::Debug:
+        case Shell::Verbose:
+        case Shell::Ultra:   colour = FOREGROUND_INTENSITY                                     ; break;
+        case Shell::Command: colour =                        FOREGROUND_GREEN                  | FOREGROUND_BLUE; break;
+        case Shell::Hint:    colour =                        FOREGROUND_GREEN | FOREGROUND_RED                  ; break;
+        default:             colour =                        FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE; break;
+        }
+        // Print output line
+        this->writeText(text, pos, colour);
+    }
+    //! Prints all status lines with current content
     void IOConsole::printStatusLines()
+    {
+/*
         if (this->willPrintStatusLines())
+        {
             this->bStatusPrinted_ = true;
+        }
         else
             this->bStatusPrinted_ = false;
+*/
+    }
+        // Prepare text to be written
+        std::ostringstream oss;
+        oss << std::fixed << std::setprecision(2) << std::setw(5) << Game::getInstance().getAvgFPS() << " fps, ";
+        oss <<               std::setprecision(2) << std::setw(5) << Game::getInstance().getAvgTickTime() << " ms tick time";
+        // Clear rest of the line by inserting spaces
+        oss << std::string(this->terminalWidth_ - oss.str().size(), ' ');
+        this->writeText(oss.str(), makeCOORD(0, this->inputLineRow_ + this->inputLineHeight_), FOREGROUND_GREEN);
+    }
+    //! Changes the console parameters for unbuffered input
     void IOConsole::setTerminalMode()
+    {
+    }
+        // Set the console mode to no-echo, raw input, and no window or mouse events
+        this->stdOutHandle_ = GetStdHandle(STD_OUTPUT_HANDLE);
+        this->stdInHandle_  = GetStdHandle(STD_INPUT_HANDLE);
+        if (this->stdInHandle_ == INVALID_HANDLE_VALUE
+            || !GetConsoleMode(this->stdInHandle_, &this->originalTerminalSettings_)
+            || !SetConsoleMode(this->stdInHandle_, 0))
+        {
+            COUT(1) << "Error: Could not set Windows console settings" << std::endl;
+            return;
+        }
+        FlushConsoleInputBuffer(this->stdInHandle_);
+    }
+    //! Restores the console parameters
     void IOConsole::resetTerminalMode()
+    {
+    }
+        SetConsoleMode(this->stdInHandle_, this->originalTerminalSettings_);
+    }
+    //! Sets this->terminalWidth_ and this->terminalHeight_
     void IOConsole::getTerminalSize()
+    {
+        CONSOLE_SCREEN_BUFFER_INFO screenBufferInfo;
+        GetConsoleScreenBufferInfo(this->stdOutHandle_, &screenBufferInfo);
+        this->terminalWidth_  = screenBufferInfo.dwSize.X;
+        this->terminalHeight_ = screenBufferInfo.dwSize.Y;
+    }
+    //! Writes arbitrary text to the console with a certain colour and screen buffer position
+    void IOConsole::writeText(const std::string& text, const COORD& coord, WORD attributes)
+    {
+        DWORD count;
+        WriteConsoleOutputCharacter(stdOutHandle_, text.c_str(), text.size(), coord, &count);
+        FillConsoleOutputAttribute(stdOutHandle_, attributes, text.size(), coord, &count);
+    }
+    /** Scrolls the console screen buffer to create empty lines above the input line.
+    @details
+        If the input and status lines are already at the bottom of the screen buffer
+        the whole output gets scrolled up. In the other case the input and status
+        lines get scrolled down.
+        In any case the status and input lines get scrolled down as far as possible.
+    @param lines
+        Number of lines to be inserted. Behavior for negative values is undefined.
+    */
+    void IOConsole::createNewOutputLines(int lines)
+    {
+        CHAR_INFO fillChar = {{' '}, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED};
+        // Lines to scroll input/status down (if possible)
+        int linesDown = clamp(terminalHeight_ - inputLineRow_ - inputLineHeight_ - statusLines_, 0, lines);
+        if (linesDown > 0)
+        {
+            // Scroll input and status lines down
+            SMALL_RECT oldRect = {0, this->inputLineRow_,
+                this->terminalWidth_ - 1, this->inputLineRow_ + this->inputLineHeight_ + this->statusLines_ - 1};
+            this->inputLineRow_ += linesDown;
+            ScrollConsoleScreenBuffer(stdOutHandle_, &oldRect, NULL, makeCOORD(0, this->inputLineRow_), &fillChar);
+            // Move cursor down to the new bottom so the user can see the status lines
+            COORD pos = {0, this->inputLineRow_ + this->inputLineHeight_ - 1 + this->statusLines_};
+            SetConsoleCursorPosition(stdOutHandle_, pos);
+            // Get cursor back to the right position
+            this->cursorChanged();
+        }
+        // Check how many lines we still have to scroll up the output
+        if (lines - linesDown > 0)
+        {
+            // Scroll output up
+            SMALL_RECT oldRect = {0, lines - linesDown, this->terminalWidth_ - 1, this->inputLineRow_ - 1};
+            ScrollConsoleScreenBuffer(stdOutHandle_, &oldRect, NULL, makeCOORD(0, 0), &fillChar);
+        }
+    }
 …
     // ###############################
+    //! Called if the text in the input line has changed
+    void IOConsole::inputChanged()
+    {
+        int newInputLineLength = this->promptString_.size() + this->shell_->getInput().size();
+        int newInputLineHeight = 1 + newInputLineLength / this->terminalWidth_;
+        int newLines = newInputLineHeight - this->inputLineHeight_;
+        if (newLines > 0)
+        {
+            // Abuse this function to scroll the console
+            this->createNewOutputLines(newLines);
+            // Either Compensate for side effects (input/status lines scrolled down)
+            // or we have to do this anyway (output scrolled up)
+            this->inputLineRow_ -= newLines;
+        }
+        else if (newLines < 0)
+        {
+            // Scroll status lines up
+            int statusLineRow = this->inputLineRow_ + this->inputLineHeight_;
+            SMALL_RECT oldRect = {0, statusLineRow, this->terminalWidth_ - 1, statusLineRow + this->statusLines_};
+            CHAR_INFO fillChar = {{' '}, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED};
+            ScrollConsoleScreenBuffer(stdOutHandle_, &oldRect, NULL, makeCOORD(0, statusLineRow + newLines), &fillChar);
+            // Clear potential leftovers
+            if (-newLines - this->statusLines_ > 0)
+            {
+                COORD pos = {0, this->inputLineRow_ + newInputLineHeight + this->statusLines_};
+                this->writeText(std::string((-newLines - this->statusLines_) * this->terminalWidth_, ' '), pos);
+            }
+        }
+        this->inputLineHeight_ = newInputLineHeight;
+        // Print the whole line, including spaces that erase leftovers
+        std::string inputLine = this->promptString_ + this->shell_->getInput();
+        inputLine += std::string(this->terminalWidth_ - newInputLineLength % this->terminalWidth_, ' ');
+        this->writeText(inputLine, makeCOORD(0, this->inputLineRow_), FOREGROUND_GREEN | FOREGROUND_INTENSITY);
+        // If necessary, move cursor
+        if (newLines != 0)
+            this->cursorChanged();
+    }
+    //! Called if the position of the cursor in the input-line has changed
+    void IOConsole::cursorChanged()
+    {
+        int rawCursorPos = this->promptString_.size() + this->buffer_->getCursorPosition();
+        // Compensate for cursor further to the right than the terminal width
+        COORD pos;
+        pos.X = rawCursorPos % this->terminalWidth_;
+        pos.Y = this->inputLineRow_ + rawCursorPos / this->terminalWidth_;
+        SetConsoleCursorPosition(stdOutHandle_, pos);
+    }
     //! Called if only the last output-line has changed
     void IOConsole::onlyLastLineChanged()
+    {
+    }
+    //! Called if a new output-line was added
+        int newLineHeight = 1 + this->shell_->getNewestLineIterator()->first.size() / this->terminalWidth_;
+        // Compute the number of new lines needed
+        int newLines = newLineHeight - this->lastOutputLineHeight_;
+        this->lastOutputLineHeight_ = newLineHeight;
+        // Scroll console if necessary
+        if (newLines > 0) // newLines < 0 is assumed impossible
+            this->createNewOutputLines(newLines);
+        Shell::LineList::const_iterator it = this->shell_->getNewestLineIterator();
+        this->printOutputLine(it->first, it->second, makeCOORD(0, this->inputLineRow_ - newLineHeight));
+    }
+    //! Called if a new output line was added
     void IOConsole::lineAdded()
+    {
+        Shell::LineList::const_iterator it = this->shell_->getNewestLineIterator();
+        // Scroll console
+        this->lastOutputLineHeight_ = 1 + it->first.size() / this->terminalWidth_;
+        this->createNewOutputLines(this->lastOutputLineHeight_);
+        // Write the text
+        COORD pos = {0, this->inputLineRow_ - this->lastOutputLineHeight_};
+        this->printOutputLine(it->first, it->second, pos);
+    }
+}

code/trunk/src/libraries/core/IOConsole.h

-                      r6105
+                      r6417
 #ifdef ORXONOX_PLATFORM_UNIX
 struct termios;
+#elif defined(ORXONOX_PLATFORM_WINDOWS)
+#define WIN32_LEAN_AND_MEAN
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
 #endif
 …
         ~IOConsole();
         void update(const Clock& time);
+        void preUpdate(const Clock& time);
     private:
         void setTerminalMode();
-        void resetTerminalMode();
         void getTerminalSize();
-        bool willPrintStatusLines();
-        int extractLogLevel(std::string* text);
-        void printLogText(const std::string& line);
-        void printInputLine();
         void printStatusLines();
+        static int extractLogLevel(std::string* text);
         // Methods from ShellListener
 …
         void executed();
         void exit();
         Shell*                  shell_;
         InputBuffer*            buffer_;
         std::ostream            cout_;
         std::ostringstream      origCout_;
+        unsigned int            terminalWidth_;
+        unsigned int            terminalHeight_;
+        unsigned int            lastTerminalWidth_;
+        unsigned int            lastTerminalHeight_;
+        int                     terminalWidth_;
+        int                     terminalHeight_;
+        int                     lastTerminalWidth_;
+        int                     lastTerminalHeight_;
+        const std::string       promptString_;
+#ifdef ORXONOX_PLATFORM_UNIX
+        bool willPrintStatusLines();
+        void printInputLine();
+        void printOutputLine(const std::string& line, Shell::LineType type);
+        static void resetTerminalMode();
         bool                    bPrintStatusLine_;
         bool                    bStatusPrinted_;
         std::vector<unsigned>   statusLineWidths_;
         unsigned int            statusLineMaxWidth_;
         const std::string       promptString_;
         static const unsigned   minOutputLines_ = 3;
+        std::vector<int>        statusLineWidths_;
+        int                     statusLineMaxWidth_;
+        static const int        minOutputLines_ = 3;
+        termios*                originalTerminalSettings_;
+#ifdef ORXONOX_PLATFORM_UNIX
+        termios*                originalTerminalSettings_;
+#elif defined(ORXONOX_PLATFORM_WINDOWS)
+        void resetTerminalMode();
+        void moveCursor(int dx, int dy);
+        void writeText(const std::string& text, const COORD& pos, WORD attributes = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED);
+        void createNewOutputLines(int lines);
+        void printOutputLine(const std::string& line, Shell::LineType type, const COORD& pos);
+        static inline COORD makeCOORD(int x, int y)
+        {
+            COORD val = {x, y};
+            return val;
+        }
+        DWORD                   originalTerminalSettings_;
+        HANDLE                  stdInHandle_;
+        HANDLE                  stdOutHandle_;
+        int                     inputLineRow_;
+        int                     inputLineHeight_;
+        const int               statusLines_;
+        int                     lastOutputLineHeight_;
+        uint64_t                lastRefreshTime_;
 #endif

code/trunk/src/libraries/core/IRC.cc

r5781	r6417
33	33	#include "util/Convert.h"
34	34	#include "util/Exception.h"
	35	#include "util/StringUtils.h"
35	36	#include "ConsoleCommand.h"
36	37	#include "CoreIncludes.h"
…	…
103	104	void IRC::say(const std::string& message)
104	105	{
105		if (IRC::eval("irk::say $conn #orxonox {" + message + ~~"}"~~))
	106	if (IRC::eval("irk::say $conn #orxonox {" + message + '}'))
106	107	IRC::tcl_say(Tcl::object(), Tcl::object(IRC::getInstance().nickname_), Tcl::object(message));
107	108	}
…	…
109	110	void IRC::msg(const std::string& channel, const std::string& message)
110	111	{
111		if (IRC::eval("irk::say $conn " + channel + " {" + message + ~~"}"~~))
	112	if (IRC::eval("irk::say $conn " + channel + " {" + message + '}'))
112	113	IRC::tcl_privmsg(Tcl::object(channel), Tcl::object(IRC::getInstance().nickname_), Tcl::object(message));
113	114	}
…	…
131	132	void IRC::tcl_action(Tcl::object const &channel, Tcl::object const &nick, Tcl::object const &args)
132	133	{
133		COUT(0) << "IRC> * " << nick.get() << ~~" "~~ << stripEnclosingBraces(args.get()) << std::endl;
	134	COUT(0) << "IRC> * " << nick.get() << ' ' << stripEnclosingBraces(args.get()) << std::endl;
134	135	}
135	136

code/trunk/src/libraries/core/Identifier.cc

r5929	r6417
410	410	if (it != this->configValues_.end())
411	411	{
412		COUT(2) << "Warning: Overwriting config-value with name " << varname << " in class " << this->getName() << ~~"."~~ << std::endl;
	412	COUT(2) << "Warning: Overwriting config-value with name " << varname << " in class " << this->getName() << '.' << std::endl;
413	413	delete (it->second);
414	414	}
…	…
458	458	if (it != this->consoleCommands_.end())
459	459	{
460		COUT(2) << "Warning: Overwriting console-command with name " << command->getName() << " in class " << this->getName() << ~~"."~~ << std::endl;
	460	COUT(2) << "Warning: Overwriting console-command with name " << command->getName() << " in class " << this->getName() << '.' << std::endl;
461	461	delete (it->second);
462	462	}
…	…
524	524	if (it != this->xmlportParamContainers_.end())
525	525	{
526		COUT(2) << "Warning: Overwriting XMLPortParamContainer in class " << this->getName() << ~~"."~~ << std::endl;
	526	COUT(2) << "Warning: Overwriting XMLPortParamContainer in class " << this->getName() << '.' << std::endl;
527	527	delete (it->second);
528	528	}
…	…
555	555	if (it != this->xmlportObjectContainers_.end())
556	556	{
557		COUT(2) << "Warning: Overwriting XMLPortObjectContainer in class " << this->getName() << ~~"."~~ << std::endl;
	557	COUT(2) << "Warning: Overwriting XMLPortObjectContainer in class " << this->getName() << '.' << std::endl;
558	558	delete (it->second);
559	559	}
…	…
573	573	{
574	574	if (it != list.begin())
575		out << ~~" "~~;
	575	out << ' ';
576	576	out << (*it)->getName();
577	577	}

code/trunk/src/libraries/core/Identifier.h

r5929	r6417
411	411	{
412	412	// Get the name of the class
413		~~std::string~~ name = typeid(T).name();
	413	const std::string& name = typeid(T).name();
414	414
415	415	// create a new identifier anyway. Will be deleted in Identifier::getIdentifier if not used.

code/trunk/src/libraries/core/Language.cc

r5929	r6417
62	62	{
63	63	// Check if the translation is more than just an empty string
64		if (~~(localisation != "") && (localisation.size() > 0~~))
	64	if (!localisation.empty())
65	65	{
66	66	this->localisedEntry_ = localisation;
…	…
130	130	}
131	131
132		COUT(2) << "Warning: Language entry " << label << " is duplicate in " << getFilename(this->defaultLanguage_) << ~~"!"~~ << std::endl;
	132	COUT(2) << "Warning: Language entry " << label << " is duplicate in " << getFilename(this->defaultLanguage_) << '!' << std::endl;
133	133	return it->second;
134	134	}
…	…
199	199	COUT(4) << "Read default language file." << std::endl;
200	200
201		~~std::string~~ filepath = PathConfig::getConfigPathString() + getFilename(this->defaultLanguage_);
	201	const std::string& filepath = PathConfig::getConfigPathString() + getFilename(this->defaultLanguage_);
202	202
203	203	// This creates the file if it's not existing
…	…
224	224
225	225	// Check if the line is empty
226		if (~~(lineString != "") && (lineString.size() > 0~~))
	226	if (!lineString.empty())
227	227	{
228	228	size_t pos = lineString.find('=');
…	…
246	246	void Language::readTranslatedLanguageFile()
247	247	{
248		COUT(4) << "Read translated language file (" << Core::getLanguage() << ")." << std::endl;
249
250		~~std::string filepath = PathConfig::getConfigPathString() + getFilename(Core::~~getLanguage());
	248	COUT(4) << "Read translated language file (" << Core::getInstance().getLanguage() << ")." << std::endl;
	249
	250	const std::string& filepath = PathConfig::getConfigPathString() + getFilename(Core::getInstance().getLanguage());
251	251
252	252	// Open the file
…	…
257	257	{
258	258	COUT(1) << "An error occurred in Language.cc:" << std::endl;
259		COUT(1) << "Error: Couldn't open file " << getFilename(Core::getLanguage()) << " to read the translated language entries!" << std::endl;
260		Core::resetLanguage();
261		COUT(3) << "Info: Reset language to " << this->defaultLanguage_ << ~~"."~~ << std::endl;
	259	COUT(1) << "Error: Couldn't open file " << getFilename(Core::getInstance().getLanguage()) << " to read the translated language entries!" << std::endl;
	260	Core::getInstance().resetLanguage();
	261	COUT(3) << "Info: Reset language to " << this->defaultLanguage_ << '.' << std::endl;
262	262	return;
263	263	}
…	…
270	270
271	271	// Check if the line is empty
272		if (~~(lineString != "") && (lineString.size() > 0~~))
	272	if (!lineString.empty())
273	273	{
274	274	size_t pos = lineString.find('=');
…	…
287	287	else
288	288	{
289		COUT(2) << "Warning: Invalid language entry \"" << lineString << "\" in " << getFilename(Core::getLanguage()) << std::endl;
	289	COUT(2) << "Warning: Invalid language entry \"" << lineString << "\" in " << getFilename(Core::getInstance().getLanguage()) << std::endl;
290	290	}
291	291	}
…	…
302	302	COUT(4) << "Language: Write default language file." << std::endl;
303	303
304		~~std::string~~ filepath = PathConfig::getConfigPathString() + getFilename(this->defaultLanguage_);
	304	const std::string& filepath = PathConfig::getConfigPathString() + getFilename(this->defaultLanguage_);
305	305
306	306	// Open the file
…	…
318	318	for (std::map<std::string, LanguageEntry*>::const_iterator it = this->languageEntries_.begin(); it != this->languageEntries_.end(); ++it)
319	319	{
320		file << ~~(it).second->getLabel() << "=" << (it).~~second->getDefault() << std::endl;
	320	file << it->second->getLabel() << '=' << it->second->getDefault() << std::endl;
321	321	}
322	322

code/trunk/src/libraries/core/Language.h

r5738	r6417
116	116	{
117	117	friend class Singleton<Language>;
118		friend class Core~~Configuration~~;
	118	friend class Core;
119	119
120	120	public:

code/trunk/src/libraries/core/Loader.cc

r5929	r6417
80	80	for (std::vector<std::pair<const XMLFile*, ClassTreeMask> >::iterator it = Loader::files_s.begin(); it != Loader::files_s.end(); ++it)
81	81	{
82		if (~~(*it).~~first == file)
	82	if (it->first == file)
83	83	{
84	84	Loader::files_s.erase(it);
…	…
92	92	bool success = true;
93	93	for (std::vector<std::pair<const XMLFile*, ClassTreeMask> >::iterator it = Loader::files_s.begin(); it != Loader::files_s.end(); ++it)
94		if (!Loader::load(~~(it).first, (it).~~second * mask))
	94	if (!Loader::load(it->first, it->second * mask))
95	95	success = false;
96	96
…	…
128	128	scoped_ptr<LuaState> luaState(new LuaState());
129	129	luaState->setIncludeParser(&Loader::replaceLuaTags);
130		luaState->includeFile(file->getFilename()~~, file->getResourceGroup(), false~~);
	130	luaState->includeFile(file->getFilename());
131	131	xmlInput = luaState->getOutput().str();
132	132	}
133	133	else
134	134	{
135		shared_ptr<ResourceInfo> info = Resource::getInfo(file->getFilename()~~, file->getResourceGroup()~~);
	135	shared_ptr<ResourceInfo> info = Resource::getInfo(file->getFilename());
136	136	if (info == NULL)
137	137	{
…	…
139	139	return false;
140	140	}
141		xmlInput = Resource::open(file->getFilename()~~, file->getResourceGroup()~~)->getAsString();
	141	xmlInput = Resource::open(file->getFilename())->getAsString();
142	142	}
143	143
…	…
165	165	rootNamespace->XMLPort(rootElement, XMLPort::LoadObject);
166	166
167		COUT(0) << "Finished loading " << file->getFilename() << ~~"."~~ << std::endl;
	167	COUT(0) << "Finished loading " << file->getFilename() << '.' << std::endl;
168	168
169	169	COUT(4) << "Namespace-tree:" << std::endl << rootNamespace->toString(" ") << std::endl;
…	…
174	174	{
175	175	COUT(1) << std::endl;
176		COUT(1) << "An XML-error occurred in Loader.cc while loading " << file->getFilename() << ~~":"~~ << std::endl;
	176	COUT(1) << "An XML-error occurred in Loader.cc while loading " << file->getFilename() << ':' << std::endl;
177	177	COUT(1) << ex.what() << std::endl;
178	178	COUT(1) << "Loading aborted." << std::endl;
…	…
182	182	{
183	183	COUT(1) << std::endl;
184		COUT(1) << "A loading-error occurred in Loader.cc while loading " << file->getFilename() << ~~":"~~ << std::endl;
	184	COUT(1) << "A loading-error occurred in Loader.cc while loading " << file->getFilename() << ':' << std::endl;
185	185	COUT(1) << ex.what() << std::endl;
186	186	COUT(1) << "Loading aborted." << std::endl;
…	…
190	190	{
191	191	COUT(1) << std::endl;
192		COUT(1) << "An error occurred in Loader.cc while loading " << file->getFilename() << ~~":"~~ << std::endl;
	192	COUT(1) << "An error occurred in Loader.cc while loading " << file->getFilename() << ':' << std::endl;
193	193	COUT(1) << Exception::handleMessage() << std::endl;
194	194	COUT(1) << "Loading aborted." << std::endl;
…	…
218	218	std::string Loader::replaceLuaTags(const std::string& text)
219	219	{
220		// chreate map with all Lua tags
	220	// create map with all Lua tags
221	221	std::map<size_t, bool> luaTags;
222	222	{
…	…
291	291	{
292	292	if (it != luaTags.end())
293		end = (*(it++)).first;
	293	end = (it++)->first;
294	294	else
295	295	end = std::string::npos;
…	…
300	300	{
301	301	// count ['='[ and ]'='] and replace tags with print([[ and ]])
302		~~std::string~~ temp = text.substr(start, end - start);
	302	const std::string& temp = text.substr(start, end - start);
303	303	{
304	304	size_t pos = 0;
…	…
345	345	}
346	346	}
347		std::string equalSigns ~~= ""~~;
	347	std::string equalSigns;
348	348	for(unsigned int i = 0; i < equalSignCounter; i++)
349	349	{
350		equalSigns += ~~"="~~;
	350	equalSigns += '=';
351	351	}
352		output << "print([" + equalSigns + ~~"[" + temp + "]"~~ + equalSigns +"])";
	352	output << "print([" + equalSigns + '[' + temp + ']' + equalSigns +"])";
353	353	start = end + 5;
354	354	}

code/trunk/src/libraries/core/LuaState.cc

-                      r6105
+                      r6417
+    }
+    shared_ptr<ResourceInfo> LuaState::getFileInfo(const std::string& filename, const std::string& resourceGroup, bool bSearchOtherPaths)
+    {
+        shared_ptr<ResourceInfo> sourceInfo;
+        if (resourceGroup != "NoResourceGroupProvided")
+            sourceInfo = Resource::getInfo(filename, resourceGroup);
+        // Continue search if not explicitely forbidden
+        if (bSearchOtherPaths && sourceInfo == NULL)
+        {
+            // Call might be relative to the file currently being processed
+            sourceInfo = Resource::getInfo(sourceFileInfo_->path + filename, sourceFileInfo_->group);
+            if (sourceInfo == NULL)
+            {
+                // Maybe find something in the same group but in the root path
+                sourceInfo = Resource::getInfo(filename, sourceFileInfo_->group);
+            }
+        }
+    shared_ptr<ResourceInfo> LuaState::getFileInfo(const std::string& filename)
+    {
+        // Look in the current directory first
+        shared_ptr<ResourceInfo> sourceInfo = Resource::getInfo(sourceFileInfo_->path + filename);
+        // Continue search in root directories
+        if (sourceInfo == NULL && !sourceFileInfo_->path.empty())
+            sourceInfo = Resource::getInfo(filename);
         return sourceInfo;
+    }
     void LuaState::includeFile(const std::string& filename, const std::string& resourceGroup, bool bSearchOtherPaths)
+    {
         shared_ptr<ResourceInfo> sourceInfo = this->getFileInfo(filename, resourceGroup, bSearchOtherPaths);
+    void LuaState::includeFile(const std::string& filename)
+    {
+        shared_ptr<ResourceInfo> sourceInfo = this->getFileInfo(filename);
         if (sourceInfo != NULL)
+            this->includeString(Resource::open(sourceInfo->filename, sourceInfo->group)->getAsString(), sourceInfo);
+        else
+            COUT(2) << "LuaState: Cannot include file '" << filename << "' in resource group '"
+                    << (resourceGroup == "NoResourceGroupProvided" ? sourceFileInfo_->group : resourceGroup) << "': group not found." << std::endl;
+    }
+    void LuaState::includeString(const std::string& code, shared_ptr<ResourceInfo> sourceFileInfo)
+            this->includeString(Resource::open(sourceInfo)->getAsString(), sourceInfo);
+        else
+            COUT(2) << "LuaState: Cannot include file '" << filename << "'." << std::endl;
+    }
+    void LuaState::includeString(const std::string& code, const shared_ptr<ResourceInfo>& sourceFileInfo)
+    {
         // Parse string with provided include parser (otherwise don't preparse at all)
 …
+    }
     void LuaState::doFile(const std::string& filename, const std::string& resourceGroup, bool bSearchOtherPaths)
+    {
         shared_ptr<ResourceInfo> sourceInfo = this->getFileInfo(filename, resourceGroup, bSearchOtherPaths);
+    void LuaState::doFile(const std::string& filename)
+    {
+        shared_ptr<ResourceInfo> sourceInfo = this->getFileInfo(filename);
         if (sourceInfo != NULL)
+            this->doString(Resource::open(sourceInfo->filename, sourceInfo->group)->getAsString(), sourceInfo);
+        else
+            COUT(2) << "LuaState: Cannot do file '" << filename << "' in resource group '"
+                << (resourceGroup == "NoResourceGroupProvided" ? sourceFileInfo_->group : resourceGroup) << "': group not found." << std::endl;
+    }
+    void LuaState::doString(const std::string& code, shared_ptr<ResourceInfo> sourceFileInfo)
+    {
+        // Save the oold source file info
+            this->doString(Resource::open(sourceInfo)->getAsString(), sourceInfo);
+        else
+            COUT(2) << "LuaState: Cannot do file '" << filename << "'." << std::endl;
+    }
+    void LuaState::doString(const std::string& code, const shared_ptr<ResourceInfo>& sourceFileInfo)
+    {
+        // Save the old source file info
         shared_ptr<ResourceInfo> oldSourceFileInfo = sourceFileInfo_;
         // Only override if sourceFileInfo provides useful information
 …
             if (sourceFileInfo != NULL)
                 origin = " originating from " + sourceFileInfo_->filename;
             COUT(2) << "Error in Lua-script" << origin << ": " << lua_tostring(luaState_, -1) << std::endl;
+            COUT(1) << "Error in Lua-script" << origin << ": " << lua_tostring(luaState_, -1) << std::endl;
             // return value is nil
             lua_pushnil(luaState_);
 …
+    }
     bool LuaState::fileExists(const std::string& filename, const std::string& resourceGroup, bool bSearchOtherPaths)
+    {
         shared_ptr<ResourceInfo> info =  this->getFileInfo(filename, resourceGroup, bSearchOtherPaths);
+    bool LuaState::fileExists(const std::string& filename)
+    {
+        shared_ptr<ResourceInfo> info = this->getFileInfo(filename);
         if (info == NULL)
             return false;
 …
+        }
+    }
+    LuaFunctor::LuaFunctor(const std::string& code, LuaState* luaState)
+    {
+        this->code_ = code;
+        this->lua_ = luaState;
+    }
+    void LuaFunctor::operator()(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
+    {
+        lua_->doString(this->code_);
+    }
+}

code/trunk/src/libraries/core/LuaState.h

-                      r5781
+                      r6417
 #include "util/ScopeGuard.h"
+#include "core/Functor.h"
 #include "ToluaInterface.h"
+// tolua_begin
+namespace orxonox
+{
+namespace orxonox // tolua_export
+{ // tolua_export
+    class Functor; // tolua_export
+    //! Functor subclass that simply executes code with 0 arguments.
+    class _CoreExport LuaFunctor : public Functor
+    {
+        public:
+            LuaFunctor(const std::string& code, LuaState* luaState);
+            void operator()(const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null);
+            void evaluateParam(unsigned int index, MultiType& param) const {}
+        private:
+            std::string code_;
+            LuaState*   lua_;
+    };
     /**
     @brief
         Representation of an interface to lua
     */
+    class _CoreExport LuaState
+    {
+// tolua_end
+    class _CoreExport LuaState // tolua_export
+    { // tolua_export
     public:
         LuaState();
         ~LuaState();
         void doFile(const std::string& filename, const std::string& resourceGroup = "General", bool bSearchOtherPaths = true); // tolua_export
         void doString(const std::string& code, shared_ptr<ResourceInfo> sourceFileInfo = shared_ptr<ResourceInfo>());
+        void doFile(const std::string& filename); // tolua_export
+        void doString(const std::string& code, const shared_ptr<ResourceInfo>& sourceFileInfo = shared_ptr<ResourceInfo>());
         void includeFile(const std::string& filename, const std::string& resourceGroup = "General", bool bSearchOtherPaths = true); // tolua_export
         void includeString(const std::string& code, shared_ptr<ResourceInfo> sourceFileInfo = shared_ptr<ResourceInfo>());
+        void includeFile(const std::string& filename); // tolua_export
+        void includeString(const std::string& code, const shared_ptr<ResourceInfo>& sourceFileInfo = shared_ptr<ResourceInfo>());
         void luaPrint(const std::string& str); // tolua_export
         void luaLog(unsigned int level, const std::string& message); // tolua_export
         bool fileExists(const std::string& filename, const std::string& resourceGroup = "General", bool bSearchOtherPaths = true); // tolua_export
+        bool fileExists(const std::string& filename); // tolua_export
         const std::stringstream& getOutput() const { return output_; }
 …
         lua_State* getInternalLuaState() { return luaState_; }
+        void setDefaultResourceInfo(const shared_ptr<ResourceInfo>& sourceFileInfo) { this->sourceFileInfo_ = sourceFileInfo; }
+        const shared_ptr<ResourceInfo>& getDefaultResourceInfo() { return this->sourceFileInfo_; }
+        Functor* createLuaFunctor(const std::string& code) { return new LuaFunctor(code, this); } // tolua_export
         static bool addToluaInterface(int (*function)(lua_State*), const std::string& name);
         static bool removeToluaInterface(const std::string& name);
 …
     private:
         shared_ptr<ResourceInfo> getFileInfo(const std::string& filename, const std::string& resourceGroup, bool bSearchOtherPaths);
+        shared_ptr<ResourceInfo> getFileInfo(const std::string& filename);
 #if LUA_VERSION_NUM != 501

code/trunk/src/libraries/core/MemoryArchive.cc

r5940	r6417
64	64	}
65	65
66		void MemoryArchive::findFiles(const String& pattern, bool bRecursive,
	66	void MemoryArchive::findFiles(const String& pattern, bool bRecursive,
67	67	bool bDirs, StringVector* simpleList, FileInfoList* detailList)
68	68	{
…	…
118	118	}
119	119
120		FileInfoListPtr MemoryArchive::findFileInfo(const String& pattern,
	120	FileInfoListPtr MemoryArchive::findFileInfo(const String& pattern,
121	121	bool recursive, bool dirs)
122	122	{

code/trunk/src/libraries/core/MemoryArchive.h

r5781	r6417
79	79
80	80	private:
81		void findFiles(const Ogre::String& pattern, bool bRecursive,
	81	void findFiles(const Ogre::String& pattern, bool bRecursive,
82	82	bool bDirs, Ogre::StringVector* simpleList, Ogre::FileInfoList* detailList);
83	83

code/trunk/src/libraries/core/Namespace.cc

r5781	r6417
173	173	{
174	174	if (i > 0)
175		output += ~~"\n"~~;
	175	output += '\n';
176	176
177	177	output += (*it)->toString(indentation);

code/trunk/src/libraries/core/NamespaceNode.cc

r5781	r6417
43	43	{
44	44	for (std::map<std::string, NamespaceNode*>::iterator it = this->subnodes_.begin(); it != this->subnodes_.end(); )
45		delete (~~(*(it++)).second)~~;
	45	delete (it++)->second;
46	46	}
47	47
…	…
50	50	std::set<NamespaceNode*> nodes;
51	51
52		if (~~(name.size() == 0) \|\| (name == ""~~))
	52	if (name.empty())
53	53	{
54	54	nodes.insert(this);
…	…
89	89	it = this->subnodes_.insert(this->subnodes_.begin(), std::pair<std::string, NamespaceNode*>(firstPart, new NamespaceNode(firstPart, this)));
90	90
91		if (~~(*it).~~second->isHidden())
	91	if (it->second->isHidden())
92	92	{
93	93	COUT(2) << "Warning: Subnamespace '" << firstPart << "' in namespace '" << this->name_ << "' is hidden and can't be accessed." << std::endl;
…	…
96	96	else
97	97	{
98		nodes = ~~(*it).~~second->getNodeRelative(secondPart);
	98	nodes = it->second->getNodeRelative(secondPart);
99	99	}
100	100	}
…	…
105	105	for (std::map<std::string, NamespaceNode*>::iterator it = this->subnodes_.begin(); it != this->subnodes_.end(); ++it)
106	106	{
107		if (~~(it).first.find(firstPart) == ((it).~~first.size() - firstPart.size()))
	107	if (it->first.find(firstPart) == (it->first.size() - firstPart.size()))
108	108	{
109		std::set<NamespaceNode> temp2 = ~~(it).~~second->getNodeRelative(secondPart);
	109	std::set<NamespaceNode*> temp2 = it->second->getNodeRelative(secondPart);
110	110	nodes.insert(temp2.begin(), temp2.end());
111	111	bFoundMatchingNamespace = true;
…	…
133	133	{
134	134	for (std::map<std::string, NamespaceNode*>::const_iterator it = this->subnodes_.begin(); it != this->subnodes_.end(); ++it)
135		if (~~(*it).~~second->includes(ns))
	135	if (it->second->includes(ns))
136	136	return true;
137	137	}
…	…
154	154	output += ", ";
155	155
156		output += ~~(*it).~~second->toString();
	156	output += it->second->toString();
157	157	}
158	158
159		output += ~~")"~~;
	159	output += ')';
160	160	}
161	161
…	…
165	165	std::string NamespaceNode::toString(const std::string& indentation) const
166	166	{
167		std::string output = (indentation + this->name_ + ~~"\n"~~);
	167	std::string output = (indentation + this->name_ + '\n');
168	168
169	169	for (std::map<std::string, NamespaceNode*>::const_iterator it = this->subnodes_.begin(); it != this->subnodes_.end(); ++it)
170		output += ~~(*it).~~second->toString(indentation + " ");
	170	output += it->second->toString(indentation + " ");
171	171
172	172	return output;

code/trunk/src/libraries/core/OrxonoxClass.cc

-                      r6105
+                      r6417
         this->referenceCount_ = 0;
         this->requestedDestruction_ = false;
+        // Optimisation
+        this->objectPointers_.reserve(6);
+    }
 …
+    {
 //        if (!this->requestedDestruction_)
 //            COUT(2) << "Warning: Destroyed object without destroy() (" << this->getIdentifier()->getName() << ")" << std::endl;
+//            COUT(2) << "Warning: Destroyed object without destroy() (" << this->getIdentifier()->getName() << ')' << std::endl;
         assert(this->referenceCount_ <= 0);
         delete this->metaList_;
+        this->unregisterObject();
         // parents_ exists only if isCreatingHierarchy() of the associated Identifier returned true while creating the class
         if (this->parents_)
             delete this->parents_;
         // reset all weak pointers pointing to this object
         for (std::set<WeakPtr<OrxonoxClass>*>::iterator it = this->weakPointers_.begin(); it != this->weakPointers_.end(); )
 …
         this->requestedDestruction_ = true;
         if (this->referenceCount_ == 0)
+            delete this;
+        {
+            this->preDestroy();
+            if (this->referenceCount_ == 0)
+                delete this;
+        }
+    }
+    void OrxonoxClass::unregisterObject()
+    {
+        if (this->metaList_)
+            delete this->metaList_;
+        this->metaList_ = 0;
+    }

code/trunk/src/libraries/core/OrxonoxClass.h

-                      r6105
+                      r6417
             void destroy();
+            void unregisterObject();
             /** @brief Function to collect the SetConfigValue-macro calls. */
 …
             {   return const_cast<OrxonoxClass*>(this)->getDerivedPointer<T>(classID);   }
+        protected:
+            virtual void preDestroy() {}
         private:
             /** @brief Increments the reference counter (for smart pointers). */
 …
             /** @brief Decrements the reference counter (for smart pointers). */
             inline void decrementReferenceCount()
+                { --this->referenceCount_; if (this->referenceCount_ == 0 && this->requestedDestruction_) { delete this; } }
+            {
+                --this->referenceCount_;
+                if (this->referenceCount_ == 0 && this->requestedDestruction_)
+                    this->destroy();
+            }
             /** @brief Register a weak pointer which points to this object. */
             template <class T>

code/trunk/src/libraries/core/PathConfig.cc

-                      r6105
+                      r6417
         if (!CommandLineParser::getArgument("writingPathSuffix")->hasDefaultValue())
+        {
             std::string directory(CommandLineParser::getValue("writingPathSuffix").getString());
+            const std::string& directory(CommandLineParser::getValue("writingPathSuffix").getString());
             configPath_ = configPath_ / directory;
             logPath_    = logPath_    / directory;
 …
         // We search for helper files with the following extension
         std::string moduleextension = specialConfig::moduleExtension;
+        const std::string& moduleextension = specialConfig::moduleExtension;
         size_t moduleextensionlength = moduleextension.size();
         // Add that path to the PATH variable in case a module depends on another one
         std::string pathVariable = getenv("PATH");
         putenv(const_cast<char*>(("PATH=" + pathVariable + ";" + modulePath_.string()).c_str()));
+        std::string pathVariable(getenv("PATH"));
+        putenv(const_cast<char*>(("PATH=" + pathVariable + ';' + modulePath_.string()).c_str()));
         // Make sure the path exists, otherwise don't load modules
 …
         while (file != end)
+        {
             std::string filename = file->BOOST_LEAF_FUNCTION();
+            const std::string& filename = file->BOOST_LEAF_FUNCTION();
             // Check if the file ends with the exension in question
 …
+                {
                     // We've found a helper file
                     std::string library = filename.substr(0, filename.size() - moduleextensionlength);
+                    const std::string& library = filename.substr(0, filename.size() - moduleextensionlength);
                     modulePaths.push_back((modulePath_ / library).file_string());
+                }

code/trunk/src/libraries/core/PathConfig.h

-                      r5929
+                      r6417
 #include "util/Singleton.h"
+//tolua_begin
 namespace orxonox
+{
+//tolua_end
     /**
     @brief
 …
         - externalData only for development builds in the build tree
     */
+    class _CoreExport PathConfig : public Singleton<PathConfig>
+    {
+    class _CoreExport PathConfig //tolua_export
+        : public Singleton<PathConfig>
+    { //tolua_export
         friend class Singleton<PathConfig>;
         friend class Core;
 …
             static std::string getExternalDataPathString();
             //! Returns the path to the config files as std::string
             static std::string getConfigPathString();
+            static std::string getConfigPathString(); //tolua_export
             //! Returns the path to the log files as std::string
             static std::string getLogPathString();
 …
             bool                     bDevRun_;               //!< True for runs in the build directory (not installed)
             static PathConfig* singletonPtr_s;
     };
+}
+    }; //tolua_export
+} //tolua_export
 #endif /* _PathConfig_H__ */

code/trunk/src/libraries/core/Resource.cc

-                      r5781
+                      r6417
 #include "Resource.h"
+#include <OgreException.h>
 #include <OgreResourceGroupManager.h>
 …
     std::string Resource::DEFAULT_GROUP(Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
     DataStreamPtr Resource::open(const std::string& name, const std::string& group, bool bSearchGroupsIfNotFound)
+    DataStreamPtr Resource::open(const std::string& name)
+    {
+        return Ogre::ResourceGroupManager::getSingleton().openResource(name, group, bSearchGroupsIfNotFound);
+        return Ogre::ResourceGroupManager::getSingleton().openResource(name,
+            Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, true);
+    }
     DataStreamListPtr Resource::openMulti(const std::string& pattern, const std::string& group)
+    DataStreamListPtr Resource::openMulti(const std::string& pattern)
+    {
+        return Ogre::ResourceGroupManager::getSingleton().openResources(pattern, group);
+        DataStreamListPtr resources(new Ogre::DataStreamList());
+        const Ogre::StringVector& groups = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
+        for (Ogre::StringVector::const_iterator it = groups.begin(); it != groups.end(); ++it)
+        {
+            DataStreamListPtr temp = Ogre::ResourceGroupManager::getSingleton().openResources(pattern, *it);
+            resources->insert(resources->end(), temp->begin(), temp->end());
+        }
+        return resources;
+    }
     bool Resource::exists(const std::string& name, const std::string& group)
+    bool Resource::exists(const std::string& name)
+    {
+        return Ogre::ResourceGroupManager::getSingleton().resourceExists(group, name);
+        try
+        {
+            Ogre::ResourceGroupManager::getSingleton().findGroupContainingResource(name);
+            return true;
+        }
+        catch (const Ogre::Exception&)
+        {
+            return false;
+        }
+    }
     shared_ptr<ResourceInfo> Resource::getInfo(const std::string& name, const std::string& group)
+    shared_ptr<ResourceInfo> Resource::getInfo(const std::string& name)
+    {
+        std::string group;
+        try
+        {
+            group = Ogre::ResourceGroupManager::getSingleton().findGroupContainingResource(name);
+        }
+        catch (const Ogre::Exception&)
+        {
+            return shared_ptr<ResourceInfo>();
+        }
         Ogre::FileInfoListPtr infos = Ogre::ResourceGroupManager::getSingleton().findResourceFileInfo(group, name);
         for (std::vector<Ogre::FileInfo>::const_iterator it = infos->begin(); it != infos->end(); ++it)
 …
         return shared_ptr<ResourceInfo>();
+    }
+    StringVectorPtr Resource::findResourceNames(const std::string& pattern)
+    {
+        StringVectorPtr resourceNames(new Ogre::StringVector());
+        const Ogre::StringVector& groups = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
+        for (Ogre::StringVector::const_iterator it = groups.begin(); it != groups.end(); ++it)
+        {
+            StringVectorPtr temp = Ogre::ResourceGroupManager::getSingleton().findResourceNames(*it, pattern);
+            resourceNames->insert(resourceNames->end(), temp->begin(), temp->end());
+        }
+        return resourceNames;
+    }
+}

code/trunk/src/libraries/core/Resource.h

-                      r5929
+                      r6417
 #include <boost/shared_ptr.hpp>
 #include <OgreDataStream.h>
+#include <OgreStringVector.h>
 namespace orxonox
 …
     using Ogre::DataStreamList;
     using Ogre::DataStreamListPtr;
+    using Ogre::StringVector;
+    using Ogre::StringVectorPtr;
     //! Stores basic information about a Resource from Ogre
 …
     };
+    /**
+    @brief
+        Provides simple functions to easily access the Ogre::ResourceGroupManager
+    /** Provides simple functions to easily access the Ogre::ResourceGroupManager.
+        The wrapper functions also avoid having to deal with resource groups.
     */
     class _CoreExport Resource
 …
             Even if resource locations are added recursively, you
             must provide a fully qualified name to this method.
-        @param groupName
-            The name of the resource group; this determines which
-            locations are searched.
-        @param searchGroupsIfNotFound
-            If true, if the resource is not found in
-            the group specified, other groups will be searched.
         @return
             Shared pointer to data stream containing the data. Will be
             destroyed automatically when no longer referenced.
         */
+        static DataStreamPtr open(const std::string& name,
+            const std::string& group = Resource::DEFAULT_GROUP,
+            bool bSearchGroupsIfNotFound = false);
+        static DataStreamPtr open(const std::string& name);
+        //! Similar to open(string, string, bool), but with a fileInfo struct
+        static DataStreamPtr open(shared_ptr<ResourceInfo> fileInfo)
+        {
+            return open(fileInfo->filename);
+        }
         /**
         @brief
             Open all resources matching a given pattern (which can contain
             the character '*' as a wildcard), and return a collection of
+            the character '*' as a wildcard), and return a collection of
             DataStream objects on them.
         @param pattern
 …
             added recursively, subdirectories will be searched too so this
             does not need to be fully qualified.
-        @param groupName
-            The resource group; this determines which locations
-            are searched.
         @return
             Shared pointer to a data stream list , will be
             destroyed automatically when no longer referenced
         */
         static DataStreamListPtr openMulti(const std::string& pattern, const std::string& group = Resource::DEFAULT_GROUP);
+        static DataStreamListPtr openMulti(const std::string& pattern);
         /**
             Find out if the named file exists in a group.
+            Find out if the named file exists.
         @param filename
             Fully qualified name of the file to test for
-        @param group
-            The name of the resource group
         */
         static bool exists(const std::string& name, const std::string& group = Resource::DEFAULT_GROUP);
+        static bool exists(const std::string& name);
         /**
             Get struct with information about group, path and size.
+            Get struct with information about path and size.
         @param filename
             Fully qualified name of the file to test for
-        @param group
-            The name of the resource group
         */
+        static shared_ptr<ResourceInfo> getInfo(const std::string& name, const std::string& group = Resource::DEFAULT_GROUP);
+        static shared_ptr<ResourceInfo> getInfo(const std::string& name);
+        /**
+            Retrieves a list with all resources matching a certain pattern.
+        @param pattern
+            The pattern to look for. If resource locations have been
+            added recursively, subdirectories will be searched too so this
+            does not need to be fully qualified.
+        */
+        static StringVectorPtr findResourceNames(const std::string& pattern);
         //! Name of the default resource group (usually "General")

code/trunk/src/libraries/core/ScopedSingletonManager.h

-                      r6035
+                      r6417
 #define ManageScopedSingleton(className, scope, allowedToFail) \
+    className* className::singletonPtr_s = NULL; \
     static ClassScopedSingletonManager<className, scope, allowedToFail> className##ScopedSingletonManager(#className)
 …
             template<ScopeID::Value scope>
             static void update(const Clock& time)
+            static void preUpdate(const Clock& time)
+            {
                 assert(Scope<scope>::isActive());
                 for (ManagerMultiMap::iterator it = getManagersByScope().lower_bound(scope); it != getManagersByScope().upper_bound(scope); ++it)
                     it->second->update(time);
+                    it->second->preUpdate(time);
+            }
+            virtual void update(const Clock& time) = 0;
+            virtual void preUpdate(const Clock& time) = 0;
+            template<ScopeID::Value scope>
+            static void postUpdate(const Clock& time)
+            {
+                assert(Scope<scope>::isActive());
+                for (ManagerMultiMap::iterator it = getManagersByScope().lower_bound(scope); it != getManagersByScope().upper_bound(scope); ++it)
+                    it->second->postUpdate(time);
+            }
+            virtual void postUpdate(const Clock& time) = 0;
             static std::map<std::string, ScopedSingletonManager*>& getManagers();
 …
         //! Called every frame by the ScopedSingletonManager
+        void update(const Clock& time)
+        {
+            assert(Scope<scope>::isActive());
+            // assuming T inherits Singleton<T>
+            singletonPtr_->updateSingleton(time);
+        void preUpdate(const Clock& time)
+        {
+            assert(Scope<scope>::isActive());
+            // assuming T inherits Singleton<T>
+            singletonPtr_->preUpdateSingleton(time);
+        }
+        //! Called every frame by the ScopedSingletonManager
+        void postUpdate(const Clock& time)
+        {
+            assert(Scope<scope>::isActive());
+            // assuming T inherits Singleton<T>
+            singletonPtr_->postUpdateSingleton(time);
+        }
 …
             try
                 { singletonPtr_ = new T(); }
+            catch (const InitialisationAbortedException& ex)
+                { COUT(3) << ex.getDescription() << std::endl; }
             catch (...)
                 { COUT(1) << "Singleton creation failed: " << Exception::handleMessage() << std::endl; }
 …
         //! Called every frame by the ScopedSingletonManager
         void update(const Clock& time)
+        void preUpdate(const Clock& time)
+        {
             assert(Scope<scope>::isActive());
             // assuming T inherits Singleton<T>
             if (singletonPtr_ != NULL)
+                singletonPtr_->updateSingleton(time);
+                singletonPtr_->preUpdateSingleton(time);
+        }
+        //! Called every frame by the ScopedSingletonManager
+        void postUpdate(const Clock& time)
+        {
+            assert(Scope<scope>::isActive());
+            // assuming T inherits Singleton<T>
+            if (singletonPtr_ != NULL)
+                singletonPtr_->postUpdateSingleton(time);
+        }

code/trunk/src/libraries/core/Shell.cc

-                      r6105
+                      r6417
     SetConsoleCommandShortcut(OutputHandler, debug);
     Shell::Shell(const std::string& consoleName, bool bScrollable, bool bPrependOutputLevel)
+    Shell::Shell(const std::string& consoleName, bool bScrollable)
         : OutputListener(consoleName)
         , inputBuffer_(new InputBuffer())
         , consoleName_(consoleName)
-        , bPrependOutputLevel_(bPrependOutputLevel)
         , bScrollable_(bScrollable)
+    {
 …
         this->configureInputBuffer();
+        // Get a config file for the command history
+        this->commandHistoryConfigFileType_ = ConfigFileManager::getInstance().getNewConfigFileType();
+        ConfigFileManager::getInstance().setFilename(this->commandHistoryConfigFileType_, "commandHistory.ini");
+        // Use a stringstream object to buffer the output and get it line by line in update()
+        // Specify file for the command history
+        ConfigFileManager::getInstance().setFilename(ConfigFileType::CommandHistory, "commandHistory.ini");
+        // Use a stringstream object to buffer the output
         this->outputStream_ = &this->outputBuffer_;
 …
         SetConfigValue(historyOffset_, 0)
             .callback(this, &Shell::commandHistoryOffsetChanged);
         SetConfigValueVectorGeneric(commandHistoryConfigFileType_, commandHistory_, std::vector<std::string>());
+        setConfigValueGeneric(this, &commandHistory_, ConfigFileType::CommandHistory, "Shell", "commandHistory_", std::vector<std::string>());
 #ifdef ORXONOX_RELEASE
 …
         const unsigned int defaultLevel = 3;
 #endif
         SetConfigValueGeneric(ConfigFileType::Settings, softDebugLevel_, "softDebugLevel" + this->consoleName_, "OutputHandler", defaultLevel)
+        setConfigValueGeneric(this, &softDebugLevel_, ConfigFileType::Settings, "OutputHandler", "softDebugLevel" + this->consoleName_, defaultLevel)
             .description("The maximal level of debug output shown in the Shell");
         this->setSoftDebugLevel(this->softDebugLevel_);
 …
         for (unsigned int i = instance.historyOffset_; i < instance.commandHistory_.size(); ++i)
             instance.addOutputLine(instance.commandHistory_[i], -1);
+            instance.addOutput(instance.commandHistory_[i] + '\n', -1);
         for (unsigned int i =  0; i < instance.historyOffset_; ++i)
             instance.addOutputLine(instance.commandHistory_[i], -1);
+            instance.addOutput(instance.commandHistory_[i] + '\n', -1);
+    }
     */
 …
+    }
+    void Shell::addOutputLine(const std::string& line, int level)
+    {
+        // Make sure we really only have one line per line (no new lines!)
+        SubString lines(line, '\n');
+        for (unsigned i = 0; i < lines.size(); ++i)
+        {
+            if (level <= this->softDebugLevel_)
+                this->outputLines_.push_front(lines[i]);
+            this->updateListeners<&ShellListener::lineAdded>();
+        }
+    void Shell::addOutput(const std::string& text, LineType type)
+    {
+        this->outputBuffer_ << text;
+        this->outputChanged(type);
+    }
 …
+    }
     std::list<std::string>::const_iterator Shell::getNewestLineIterator() const
+    Shell::LineList::const_iterator Shell::getNewestLineIterator() const
+    {
         if (this->scrollPosition_)
 …
+    }
     std::list<std::string>::const_iterator Shell::getEndIterator() const
+    Shell::LineList::const_iterator Shell::getEndIterator() const
+    {
         return this->outputLines_.end();
 …
+    }
     std::string Shell::getFromHistory() const
+    const std::string& Shell::getFromHistory() const
+    {
         unsigned int index = mod(static_cast<int>(this->historyOffset_) - static_cast<int>(this->historyPosition_), this->maxHistoryLength_);
 …
             return this->commandHistory_[index];
         else
             return "";
+    }
     void Shell::outputChanged(int level)
+            return BLANKSTRING;
+    }
+    void Shell::outputChanged(int lineType)
+    {
         bool newline = false;
 …
             newline = (!eof && !fail);
             if (!newline && output == "")
+            if (!newline && output.empty())
                 break;
             if (this->bFinishedLastLine_)
+            {
+                if (this->bPrependOutputLevel_)
+                    output.insert(0, 1, static_cast<char>(level));
+                this->outputLines_.push_front(output);
+                this->outputLines_.push_front(std::make_pair(output, static_cast<LineType>(lineType)));
                 if (this->scrollPosition_)
 …
                 if (!this->scrollPosition_)
+                {
                     this->updateListeners<&ShellListener::lineAdded>();
+                }
+            }
             else
+            {
                 (*this->outputLines_.begin()) += output;
+                this->outputLines_.front().first += output;
                 this->bFinishedLastLine_ = newline;
                 this->updateListeners<&ShellListener::onlyLastLineChanged>();
+            }
+            this->bFinishedLastLine_ = newline;
         } while (newline);
 …
         if (!CommandExecutor::execute(this->inputBuffer_->get()))
+            this->addOutputLine("Error: Can't execute \"" + this->inputBuffer_->get() + "\".", 1);
+        {
+            this->outputBuffer_ << "Error: Can't execute \"" << this->inputBuffer_->get() << "\"." << std::endl;
+            this->outputChanged(Error);
+        }
         this->clearInput();
 …
+    {
         this->inputBuffer_->set(CommandExecutor::complete(this->inputBuffer_->get()));
+        this->addOutputLine(CommandExecutor::hint(this->inputBuffer_->get()), -1);
+        this->outputBuffer_ << CommandExecutor::hint(this->inputBuffer_->get()) << std::endl;
+        this->outputChanged(Hint);
         this->inputChanged();
 …
             return;
         unsigned int cursorPosition = this->getCursorPosition();
         std::string input_str(this->getInput().substr(0, cursorPosition)); // only search for the expression from the beginning of the inputline until the cursor position
+        const std::string& input_str(this->getInput().substr(0, cursorPosition)); // only search for the expression from the beginning of the inputline until the cursor position
         for (unsigned int newPos = this->historyPosition_ + 1; newPos <= this->historyOffset_; newPos++)
+        {
 …
             return;
         unsigned int cursorPosition = this->getCursorPosition();
         std::string input_str(this->getInput().substr(0, cursorPosition)); // only search for the expression from the beginning
+        const std::string& input_str(this->getInput().substr(0, cursorPosition)); // only search for the expression from the beginning
         for (unsigned int newPos = this->historyPosition_ - 1; newPos > 0; newPos--)
+        {

code/trunk/src/libraries/core/Shell.h

-                      r6105
+                      r6417
+    {
         public:
+            Shell(const std::string& consoleName, bool bScrollable, bool bPrependOutputLevel = false);
+            enum LineType
+            {
+                None    = OutputLevel::None,
+                Warning = OutputLevel::Warning,
+                Error   = OutputLevel::Error,
+                Info    = OutputLevel::Info,
+                Debug   = OutputLevel::Debug,
+                Verbose = OutputLevel::Verbose,
+                Ultra   = OutputLevel::Ultra,
+                Input,
+                Command,
+                Hint
+            };
+            Shell(const std::string& consoleName, bool bScrollable);
             ~Shell();
 …
                 { return this->inputBuffer_->getCursorPosition(); }
             inline std::string getInput() const
+            inline const std::string& getInput() const
                 { return this->inputBuffer_->get(); }
+            std::list<std::string>::const_iterator getNewestLineIterator() const;
+            std::list<std::string>::const_iterator getEndIterator() const;
+            typedef std::list<std::pair<std::string, LineType> > LineList;
+            LineList::const_iterator getNewestLineIterator() const;
+            LineList::const_iterator getEndIterator() const;
             void addOutputLine(const std::string& line, int level = 0);
+            void addOutput(const std::string& text, LineType type = None);
             void clearOutput();
 …
             void addToHistory(const std::string& command);
             std::string getFromHistory() const;
+            const std::string& getFromHistory() const;
             void clearInput();
             // OutputListener
 …
             std::stringstream         outputBuffer_;
             bool                      bFinishedLastLine_;
             std::list<std::string>    outputLines_;
             std::list<std::string>::const_iterator scrollIterator_;
+            LineList                  outputLines_;
+            LineList::const_iterator  scrollIterator_;
             unsigned int              scrollPosition_;
             unsigned int              historyPosition_;
-            ConfigFileType            commandHistoryConfigFileType_;
             std::string               promptPrefix_;
             const std::string         consoleName_;
-            const bool                bPrependOutputLevel_;
             const bool                bScrollable_;

code/trunk/src/libraries/core/SmartPtr.h

r5929	r6417
84	84	this->base_->decrementReferenceCount();
85	85	}
86
	86
87	87	inline const SmartPtr& operator=(int)
88	88	{

code/trunk/src/libraries/core/SubclassIdentifier.h

r5929	r6417
98	98	if (identifier)
99	99	{
100		COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << ~~"!"~~ << std::endl;
	100	COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << '!' << std::endl;
101	101	COUT(1) << "Error: SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << std::endl;
102	102	}
…	…
166	166	{
167	167	COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
168		COUT(1) << "Error: Class " << this->identifier_->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << ~~"!"~~ << std::endl;
	168	COUT(1) << "Error: Class " << this->identifier_->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << '!' << std::endl;
169	169	COUT(1) << "Error: Couldn't fabricate a new Object." << std::endl;
170	170	}

code/trunk/src/libraries/core/TclBind.cc

-                      r5929
+                      r6417
+    {
         Tcl::interpreter* interpreter = new Tcl::interpreter();
         std::string libpath = TclBind::getTclLibraryPath();
+        const std::string& libpath = TclBind::getTclLibraryPath();
         try
+        {
             if (libpath != "")
                 interpreter->eval("set tcl_library \"" + libpath + "\"");
+            if (!libpath.empty())
+                interpreter->eval("set tcl_library \"" + libpath + '"');
             Tcl_Init(interpreter->get());
 …
         COUT(4) << "Tcl_query: " << args.get() << std::endl;
         std::string command = stripEnclosingBraces(args.get());
+        const std::string& command = stripEnclosingBraces(args.get());
         if (!CommandExecutor::execute(command, false))
 …
+    {
         COUT(4) << "Tcl_execute: " << args.get() << std::endl;
         std::string command = stripEnclosingBraces(args.get());
+        const std::string& command = stripEnclosingBraces(args.get());
         if (!CommandExecutor::execute(command, false))
 …
             try
+            {
                 std::string output = TclBind::getInstance().interpreter_->eval("uplevel #0 " + tclcode);
                 if (output != "")
+                const std::string& output = TclBind::getInstance().interpreter_->eval("uplevel #0 " + tclcode);
+                if (!output.empty())
+                {
                     COUT(0) << "tcl> " << output << std::endl;
 …
+    }
     void TclBind::bgerror(std::string error)
+    void TclBind::bgerror(const std::string& error)
+    {
         COUT(1) << "Tcl background error: " << stripEnclosingBraces(error) << std::endl;

code/trunk/src/libraries/core/TclBind.h

r5781	r6417
46	46
47	47	static std::string tcl(const std::string& tclcode);
48		static void bgerror(~~std::string~~ error);
	48	static void bgerror(const std::string& error);
49	49
50	50	void setDataPath(const std::string& datapath);

code/trunk/src/libraries/core/TclThreadManager.cc

-                      r5929
+                      r6417
 #include "util/Convert.h"
 #include "util/Exception.h"
+#include "util/StringUtils.h"
 #include "CommandExecutor.h"
 #include "ConsoleCommand.h"
 …
         @brief The "main loop" of the TclThreadManager. Creates new threads if needed and handles queries and queued commands for the main interpreter.
     */
     void TclThreadManager::update(const Clock& time)
+    void TclThreadManager::preUpdate(const Clock& time)
+    {
         // Get the bundle of the main interpreter (0)
 …
     void TclThreadManager::initialize(TclInterpreterBundle* bundle)
+    {
         std::string id_string = getConvertedValue<unsigned int, std::string>(bundle->id_);
+        const std::string& id_string = getConvertedValue<unsigned int, std::string>(bundle->id_);
         // Initialize the new interpreter
 …
+            {
                 // This query would lead to a deadlock - return with an error
                 TclThreadManager::error("Error: Circular query (" + this->dumpList(source_bundle->queriers_.getList()) + " " + getConvertedValue<unsigned int, std::string>(source_bundle->id_) \
+                TclThreadManager::error("Error: Circular query (" + this->dumpList(source_bundle->queriers_.getList()) + ' ' + getConvertedValue<unsigned int, std::string>(source_bundle->id_) \
                             + " -> " + getConvertedValue<unsigned int, std::string>(target_bundle->id_) \
                             + "), couldn't query Tcl-interpreter with ID " + getConvertedValue<unsigned int, std::string>(target_bundle->id_) \
                             + " from other interpreter with ID " + getConvertedValue<unsigned int, std::string>(source_bundle->id_) + ".");
+                            + " from other interpreter with ID " + getConvertedValue<unsigned int, std::string>(source_bundle->id_) + '.');
+            }
             else
 …
     std::string TclThreadManager::dumpList(const std::list<unsigned int>& list)
+    {
         std::string output = "";
+        std::string output;
         for (std::list<unsigned int>::const_iterator it = list.begin(); it != list.end(); ++it)
+        {
             if (it != list.begin())
                 output += " ";
+                output += ' ';
             output += getConvertedValue<unsigned int, std::string>(*it);
 …
         @param command the Command to execute
     */
     void tclThread(TclInterpreterBundle* bundle, std::string command)
+    void tclThread(TclInterpreterBundle* bundle, const std::string& command)
+    {
         TclThreadManager::debug("TclThread_execute: " + command);
 …
         @param file The name of the file that should be executed by the non-interactive interpreter.
     */
     void sourceThread(std::string file)
+    void sourceThread(const std::string& file)
+    {
         TclThreadManager::debug("TclThread_source: " + file);
 …
         // Initialize the non-interactive interpreter (like in @ref TclBind::createTclInterpreter but exception safe)
         std::string libpath = TclBind::getTclLibraryPath();
         if (libpath != "")
             TclThreadManager::eval(bundle, "set tcl_library \"" + libpath + "\"", "source");
+        const std::string& libpath = TclBind::getTclLibraryPath();
+        if (!libpath.empty())
+            TclThreadManager::eval(bundle, "set tcl_library \"" + libpath + '"', "source");
         int cc = Tcl_Init(interp);
         TclThreadManager::eval(bundle, "source \"" + TclBind::getInstance().getTclDataPath() + "/init.tcl\"", "source");

code/trunk/src/libraries/core/TclThreadManager.h

-                      r5781
+                      r6417
         friend class Singleton<TclThreadManager>;
         friend class TclBind;
         friend _CoreExport void tclThread(TclInterpreterBundle* bundle, std::string command);
         friend _CoreExport void sourceThread(std::string file);
+        friend _CoreExport void tclThread(TclInterpreterBundle* bundle, const std::string& command);
+        friend _CoreExport void sourceThread(const std::string& file);
         friend _CoreExport int Tcl_OrxonoxAppInit(Tcl_Interp* interp);
 …
             static void debug(const std::string& error);
             void update(const Clock& time);
+            void preUpdate(const Clock& time);
             std::list<unsigned int> getThreadList() const;
 …
     };
     _CoreExport void tclThread(TclInterpreterBundle* bundle, std::string command);
     _CoreExport void sourceThread(std::string file);
+    _CoreExport void tclThread(TclInterpreterBundle* bundle, const std::string& command);
+    _CoreExport void sourceThread(const std::string& file);
     _CoreExport int Tcl_OrxonoxAppInit(Tcl_Interp* interp);
+}

code/trunk/src/libraries/core/Template.cc

r5781	r6417
79	79	SUPER(Template, changedName);
80	80
81		if (~~this->getName() != ""~~)
	81	if (!this->getName().empty())
82	82	{
83	83	std::map<std::string, Template*>::iterator it;

code/trunk/src/libraries/core/Template.h

r5781	r6417
48	48
49	49	inline void setLink(const std::string& link)
50		{ this->link_ = link; this->bIsLink_ = ~~(link != ""~~); }
	50	{ this->link_ = link; this->bIsLink_ = !link.empty(); }
51	51	inline const std::string& getLink() const
52	52	{ return this->link_; }

code/trunk/src/libraries/core/Thread.cc

r5738	r6417
41	41	{
42	42	boost::posix_time::millisec THREAD_WAIT_BEFORE_DETACH(1000);
43
44
	43
	44
45	45	Thread::Thread():
46	46	executor_(0),
…	…
53	53	this->workerThread_ = new boost::thread( boost::bind(&Thread::threadLoop, this) );
54	54	}
55
	55
56	56	Thread::~Thread()
57	57	{
…	…
66	66	delete this->isWorkingMutex_;
67	67	}
68
	68
69	69	bool Thread::isWorking()
70	70	{
…	…
74	74	return isWorking;
75	75	}
76
	76
77	77	bool Thread::evaluateExecutor( Executor* executor )
78	78	{
…	…
85	85	return true;
86	86	}
87
	87
88	88	void Thread::threadLoop()
89	89	{
…	…
114	114	}
115	115	}
116
	116
117	117	void Thread::waitUntilFinished()
118	118	{

code/trunk/src/libraries/core/Thread.h

r5738	r6417
50	50	private:
51	51	void threadLoop();
52
	52
53	53	Executor* executor_;
54	54	bool isWorking_;

code/trunk/src/libraries/core/ThreadPool.cc

r5738	r6417
37	37	{
38	38	}
39
	39
40	40	ThreadPool::~ThreadPool()
41	41	{
…	…
43	43	assert(a == 0);
44	44	}
45
	45
46	46	void ThreadPool::addThreads( unsigned int nr )
47	47	{
…	…
80	80	}
81	81	}
82
	82
83	83	bool ThreadPool::passFunction( Executor* executor, bool addThread )
84	84	{
…	…
103	103	return false;
104	104	}
105
	105
106	106	void ThreadPool::synchronise()
107	107	{

code/trunk/src/libraries/core/ThreadPool.h

-                      r5738
+                      r6417
         ThreadPool();
         virtual ~ThreadPool();
         void addThreads( unsigned int nr );
         unsigned int removeThreads( unsigned int nr );
         unsigned int setNrOfThreads( unsigned int nr );
         bool passFunction( Executor* executor, bool addThread=false );
         void synchronise();
     private:
         std::vector<Thread*> threadPool_;
     };
+}

code/trunk/src/libraries/core/WeakPtr.h

r5929	r6417
44	44	{
45	45	friend class OrxonoxClass;
46
	46
47	47	public:
48	48	inline WeakPtr() : pointer_(0), base_(0), callback_(0)
…	…
79	79	if (this->callback_)
80	80	delete this->callback_;
81
82		}
83
	81
	82	}
	83
84	84	inline const WeakPtr& operator=(int)
85	85	{
…	…
145	145	if (other.base_)
146	146	other.base_->unregisterWeakPtr(&other);
147
	147
148	148	{
149	149	T* temp = this->pointer_;
…	…
167	167	WeakPtr().swap(*this);
168	168	}
169
	169
170	170	inline void setCallback(Functor* callback)
171	171	{
172	172	this->callback_ = callback;
173	173	}
174
	174
175	175	inline Functor* getFunctor() const
176	176	{
…	…
186	186	(*this->callback_)();
187	187	}
188
	188
189	189	T* pointer_;
190	190	OrxonoxClass* base_;

code/trunk/src/libraries/core/XMLFile.h

-                      r5781
+                      r6417
+    {
         public:
             XMLFile(const std::string& filename, const std::string& resourceGroup = "General")
+            XMLFile(const std::string& filename)
                 : filename_(filename)
-                , group_(resourceGroup)
                 , bLuaSupport_(true)
             { }
             XMLFile(const ClassTreeMask& mask, const std::string& filename, const std::string& resourceGroup = "General")
+            XMLFile(const ClassTreeMask& mask, const std::string& filename)
                 : filename_(filename)
-                , group_(resourceGroup)
                 , mask_(mask)
                 , bLuaSupport_(true)
 …
             const std::string& getFilename() const { return this->filename_; }
-            const std::string& getResourceGroup() const { return this->group_; }
             const ClassTreeMask& getMask() const { return this->mask_; }
             bool getLuaSupport() const { return this->bLuaSupport_; }
 …
         private:
             std::string filename_;
-            std::string group_;
             ClassTreeMask mask_;
             bool bLuaSupport_; // Default is true

code/trunk/src/libraries/core/XMLPort.h

-                      r5929
+                      r6417
 #include "util/MultiType.h"
 #include "util/OrxAssert.h"
+#include "util/StringUtils.h"
 #include "Identifier.h"
 #include "Executor.h"
 …
         ClassIdentifier<classname>::getIdentifier()->addXMLPortParamContainer(paramname, containername); \
     } \
     containername->port(static_cast<BaseObject*>(this), object, xmlelement, mode)
+    containername->port(dynamic_cast<BaseObject*>(this), object, xmlelement, mode)
 // --------------------
 …
                 { return this->paramname_; }
             virtual XMLPortParamContainer& description(const std::string description) = 0;
+            virtual XMLPortParamContainer& description(const std::string& description) = 0;
             virtual const std::string& getDescription() = 0;
 …
         public:
             XMLPortClassParamContainer(const std::string paramname, Identifier* identifier, ExecutorMember<T>* loadexecutor, ExecutorMember<T>* saveexecutor)
+            XMLPortClassParamContainer(const std::string& paramname, Identifier* identifier, ExecutorMember<T>* loadexecutor, ExecutorMember<T>* saveexecutor)
+            {
                 this->paramname_ = paramname;
 …
+                        }
                         std::map<std::string, std::string>::const_iterator it = this->owner_->xmlAttributes_.find(getLowercase(this->paramname_));
                         std::string attributeValue("");
+                        std::string attributeValue;
                         if (it != this->owner_->xmlAttributes_.end())
                             attributeValue = it->second;
 …
+                    {
                         COUT(1) << std::endl;
                         COUT(1) << "An error occurred in XMLPort.h while loading attribute '" << this->paramname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << this->owner_->getName() << ") in " << this->owner_->getFilename() << ":" << std::endl;
+                        COUT(1) << "An error occurred in XMLPort.h while loading attribute '" << this->paramname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << this->owner_->getName() << ") in " << this->owner_->getFilename() << ':' << std::endl;
                         COUT(1) << ex.what() << std::endl;
+                    }
 …
+            }
             virtual XMLPortParamContainer& description(const std::string description)
+            virtual XMLPortParamContainer& description(const std::string& description)
                 { this->loadexecutor_->setDescription(description); return (*this); }
             virtual const std::string& getDescription()
 …
                 { return this->sectionname_; }
             virtual XMLPortObjectContainer& description(const std::string description) = 0;
+            virtual XMLPortObjectContainer& description(const std::string& description) = 0;
             virtual const std::string& getDescription() = 0;
 …
+    {
         public:
             XMLPortClassObjectContainer(const std::string sectionname, Identifier* identifier, ExecutorMember<T>* loadexecutor, ExecutorMember<T>* saveexecutor, bool bApplyLoaderMask, bool bLoadBefore)
+            XMLPortClassObjectContainer(const std::string& sectionname, Identifier* identifier, ExecutorMember<T>* loadexecutor, ExecutorMember<T>* saveexecutor, bool bApplyLoaderMask, bool bLoadBefore)
+            {
                 this->sectionname_ = sectionname;
 …
+                    {
                         Element* xmlsubelement;
                         if ((this->sectionname_ != "") && (this->sectionname_.size() > 0))
+                        if (!this->sectionname_.empty())
                             xmlsubelement = xmlelement.FirstChildElement(this->sectionname_, false);
                         else
 …
+                                                    {
                                                         newObject->XMLPort(*child, XMLPort::LoadObject);
                                                         COUT(4) << object->getLoaderIndentation() << "assigning " << child->Value() << " (objectname " << newObject->getName() << ") to " << this->identifier_->getName() << " (objectname " << static_cast<BaseObject*>(object)->getName() << ")" << std::endl;
+                                                        COUT(4) << object->getLoaderIndentation() << "assigning " << child->Value() << " (objectname " << newObject->getName() << ") to " << this->identifier_->getName() << " (objectname " << static_cast<BaseObject*>(object)->getName() << ')' << std::endl;
+                                                    }
                                                     else
+                                                    {
                                                         COUT(4) << object->getLoaderIndentation() << "assigning " << child->Value() << " (object not yet loaded) to " << this->identifier_->getName() << " (objectname " << static_cast<BaseObject*>(object)->getName() << ")" << std::endl;
+                                                        COUT(4) << object->getLoaderIndentation() << "assigning " << child->Value() << " (object not yet loaded) to " << this->identifier_->getName() << " (objectname " << static_cast<BaseObject*>(object)->getName() << ')' << std::endl;
+                                                    }
 …
                                 else
+                                {
                                     if (this->sectionname_ != "")
+                                    if (!this->sectionname_.empty())
+                                    {
                                         COUT(2) << object->getLoaderIndentation() << "Warning: '" << child->Value() << "' is not a valid classname." << std::endl;
 …
+                    {
                         COUT(1) << std::endl;
                         COUT(1) << "An error occurred in XMLPort.h while loading a '" << ClassIdentifier<O>::getIdentifier()->getName() << "' in '" << this->sectionname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << object->getName() << ") in " << object->getFilename() << ":" << std::endl;
+                        COUT(1) << "An error occurred in XMLPort.h while loading a '" << ClassIdentifier<O>::getIdentifier()->getName() << "' in '" << this->sectionname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << object->getName() << ") in " << object->getFilename() << ':' << std::endl;
                         COUT(1) << ex.what() << std::endl;
+                    }
 …
+            }
             virtual XMLPortObjectContainer& description(const std::string description)
+            virtual XMLPortObjectContainer& description(const std::string& description)
                 { this->loadexecutor_->setDescription(description); return (*this); }
             virtual const std::string& getDescription()

code/trunk/src/libraries/core/input/Button.cc

-                      r5929
+                      r6417
         for (unsigned int iCommand = 0; iCommand < commandStrings.size(); iCommand++)
+        {
             if (commandStrings[iCommand] != "")
+            if (!commandStrings[iCommand].empty())
+            {
                 SubString tokens(commandStrings[iCommand], " ", SubString::WhiteSpaces, false,
 …
                 KeybindMode::Value mode = KeybindMode::None;
                 float paramModifier = 1.0f;
                 std::string commandStr = "";
+                std::string commandStr;
                 for (unsigned int iToken = 0; iToken < tokens.size(); ++iToken)
+                {
                     std::string token = getLowercase(tokens[iToken]);
+                    const std::string& token = getLowercase(tokens[iToken]);
                     if (token == "onpress")
 …
                         // we interpret everything from here as a command string
                         while (iToken != tokens.size())
                             commandStr += tokens[iToken++] + " ";
+                    }
+                }
                 if (commandStr == "")
+                            commandStr += tokens[iToken++] + ' ';
+                    }
+                }
+                if (commandStr.empty())
+                {
                     parseError("No command string given.", false);
 …
+    }
     inline void Button::parseError(std::string message, bool serious)
+    inline void Button::parseError(const std::string& message, bool serious)
+    {
         if (serious)

code/trunk/src/libraries/core/input/Button.h

r5781	r6417
76	76
77	77	private:
78		void parseError(~~std::string~~ message, bool serious);
	78	void parseError(const std::string& message, bool serious);
79	79	};
80	80

code/trunk/src/libraries/core/input/InputBuffer.cc

-                      r6105
+                      r6417
         RegisterRootObject(InputBuffer);
-        this->buffer_ = "";
         this->cursor_ = 0;
+        this->maxLength_ = 1024;
         this->allowedChars_ = "abcdefghijklmnopqrstuvwxyz \
                                ABCDEFGHIJKLMNOPQRSTUVWXYZ \
 …
         RegisterRootObject(InputBuffer);
+        this->maxLength_ = 1024;
         this->allowedChars_ = allowedChars;
-        this->buffer_ = "";
         this->cursor_ = 0;
 …
+    }
+    void InputBuffer::setMaxLength(unsigned int length)
+    {
+        this->maxLength_ = length;
+        if (this->buffer_.size() > length)
+            this->buffer_.resize(length);
+    }
     void InputBuffer::set(const std::string& input, bool update)
+    {
 …
         if (this->charIsAllowed(input))
+        {
+            if (this->buffer_.size() >= this->maxLength_)
+                return;
             this->buffer_.insert(this->cursor_, 1, input);
             ++this->cursor_;
 …
     void InputBuffer::clear(bool update)
+    {
         this->buffer_ = "";
+        this->buffer_.clear();
         this->cursor_ = 0;
 …
     bool InputBuffer::charIsAllowed(const char& input)
+    {
         if (this->allowedChars_ == "")
+        if (this->allowedChars_.empty())
             return true;
         else

code/trunk/src/libraries/core/input/InputBuffer.h

-                      r6105
+                      r6417
             void setConfigValues();
+            unsigned int getMaxLength() const { return this->maxLength_; }
+            void setMaxLength(unsigned int length);
             template <class T>
 …
             std::list<BaseInputBufferListenerTuple*> listeners_;
             std::string allowedChars_;
+            unsigned int maxLength_;
             unsigned int cursor_;

code/trunk/src/libraries/core/input/InputCommands.h

r5781	r6417
71	71	@brief
72	72	Executes a simple command with no additional paramters.
73		@return
	73	@return
74	74	True if command execution was successful, false otherwise.
75	75	*/

code/trunk/src/libraries/core/input/InputDevice.h

r5929	r6417
203	203	{
204	204	// remove the button from the pressedButtons_ list
	205	bool found = false;
205	206	for (unsigned int iButton = 0; iButton < pressedButtons_.size(); iButton++)
206	207	{
…	…
208	209	{
209	210	pressedButtons_.erase(pressedButtons_.begin() + iButton);
	211	found = true;
210	212	break;
211	213	}
212	214	}
	215	if (!found)
	216	return; // We ignore release strokes when the press was not captured
213	217
214	218	// Call states

code/trunk/src/libraries/core/input/InputManager.cc

-                      r6105
+                      r6417
         // destroy all user InputStates
         while (statesByName_.size() > 0)
             this->destroyStateInternal((*statesByName_.rbegin()).second);
+            this->destroyStateInternal(statesByName_.rbegin()->second);
         if (!(internalState_ & Bad))
 …
             if (device == NULL)
                 continue;
             std::string className = device->getClassName();
+            const std::string& className = device->getClassName();
             try
+            {
 …
     // ############################################################
     void InputManager::update(const Clock& time)
+    void InputManager::preUpdate(const Clock& time)
+    {
         if (internalState_ & Bad)
 …
     @brief
         Updates the currently active states (according to activeStates_) for each device.
         Also, a list of all active states (no duplicates!) is compiled for the general update().
+        Also, a list of all active states (no duplicates!) is compiled for the general preUpdate().
     */
     void InputManager::updateActiveStates()
 …
         if (mouseStates.empty())
             requestedMode = MouseMode::Nonexclusive;
         else
+        else
             requestedMode = mouseStates.front()->getMouseMode();
         if (requestedMode != MouseMode::Dontcare && mouseMode_ != requestedMode)
 …
+    }
     //! Gets called by WindowEventListener upon focus change --> clear buffers
+    //! Gets called by WindowEventListener upon focus change --> clear buffers
     void InputManager::windowFocusChanged()
+    {
 …
     InputState* InputManager::createInputState(const std::string& name, bool bAlwaysGetsInput, bool bTransparent, InputStatePriority priority)
+    {
         if (name == "")
+        if (name.empty())
             return 0;
         if (statesByName_.find(name) == statesByName_.end())
 …
+                {
                     // not scheduled for destruction
                     // prevents a state being added multiple times
+                    // prevents a state from being added multiple times
                     stateEnterRequests_.insert(it->second);
                     return true;
+                }
+            }
+            else if (this->stateLeaveRequests_.find(it->second) != this->stateLeaveRequests_.end())
+            {
+                // State already scheduled for leaving --> cancel
+                this->stateLeaveRequests_.erase(this->stateLeaveRequests_.find(it->second));
+            }
+        }
         return false;
 …
                 return true;
+            }
+            else if (this->stateEnterRequests_.find(it->second) != this->stateEnterRequests_.end())
+            {
+                // State already scheduled for entering --> cancel
+                this->stateEnterRequests_.erase(this->stateEnterRequests_.find(it->second));
+            }
+        }
         return false;

code/trunk/src/libraries/core/input/InputManager.h

-                      r6084
+                      r6417
 #include "InputState.h"
+// tolua_begin
 namespace orxonox
+{
 …
           If the OIS::InputManager or the Keyboard fail, an exception is thrown.
     */
+    class _CoreExport InputManager : public Singleton<InputManager>, public WindowEventListener
+    {
+    class _CoreExport InputManager
+// tolua_end
+        : public Singleton<InputManager>, public WindowEventListener
+    { // tolua_export
         friend class Singleton<InputManager>;
     public:
 …
         @brief
             Loads the devices and initialises the KeyDetector and the Calibrator.
             If either the OIS input system and/or the keyboard could not be created,
             the constructor fails with an std::exception.
 …
             was submitted while updating, the request will be postponed until the next update call.
         */
         void update(const Clock& time);
+        void preUpdate(const Clock& time);
         //! Clears all input device buffers. This usually only includes the pressed button list.
         void clearBuffers();
 …
             Reloads all the input devices. Use this method to initialise new joy sticks.
         @note
             Only reloads immediately if the call stack doesn't include the update() method.
+            Only reloads immediately if the call stack doesn't include the preUpdate() method.
         */
         void reload();
 …
             False if name was not found, true otherwise.
         */
         bool enterState(const std::string& name);
+        bool enterState(const std::string& name); // tolua_export
         /**
         @brief
 …
             False if name was not found, true otherwise.
         */
         bool leaveState(const std::string& name);
+        bool leaveState(const std::string& name); // tolua_export
         /**
         @brief
 …
         @remarks
             - You can't remove the internal states "empty", "calibrator" and "detector".
             - The removal process is being postponed if InputManager::update() is currently running.
+            - The removal process is being postponed if InputManager::preUpdate() is currently running.
         */
         bool destroyState(const std::string& name);
 …
         std::pair<int, int> getMousePosition() const;
+        static InputManager& getInstance() { return Singleton<InputManager>::getInstance(); } // tolua_export
     private: // functions
         // don't mess with a Singleton
 …
         static InputManager*                singletonPtr_s;        //!< Pointer reference to the singleton
     };
+}
+    }; // tolua_export
+} // tolua_export
 #endif /* _InputManager_H__ */

code/trunk/src/libraries/core/input/InputPrereqs.h

r5781	r6417
202	202	MediaSelect = OIS::KC_MEDIASELECT // Media Select
203	203	};
204
	204
205	205	//! Key codes as strings
206	206	const char* const ByString[] =

code/trunk/src/libraries/core/input/InputState.cc

r5929	r6417
102	102	if (enterFunctor_)
103	103	(*enterFunctor_)();
104
	104
105	105	}
106	106

code/trunk/src/libraries/core/input/JoyStick.cc

-                      r5781
+                      r6417
 #include <boost/foreach.hpp>
+#include "util/StringUtils.h"
 #include "core/ConfigFileManager.h"
 #include "core/ConfigValueIncludes.h"
 …
             std::string name = oisDevice_->vendor();
             replaceCharacters(name, ' ', '_');
             deviceName_ = name + "_";
+        }
         deviceName_ += multi_cast<std::string>(oisDevice_->getNumberOfComponents(OIS::OIS_Button))  + "_";
         deviceName_ += multi_cast<std::string>(oisDevice_->getNumberOfComponents(OIS::OIS_Axis))    + "_";
         deviceName_ += multi_cast<std::string>(oisDevice_->getNumberOfComponents(OIS::OIS_Slider))  + "_";
+            deviceName_ = name + '_';
+        }
+        deviceName_ += multi_cast<std::string>(oisDevice_->getNumberOfComponents(OIS::OIS_Button))  + '_';
+        deviceName_ += multi_cast<std::string>(oisDevice_->getNumberOfComponents(OIS::OIS_Axis))    + '_';
+        deviceName_ += multi_cast<std::string>(oisDevice_->getNumberOfComponents(OIS::OIS_Slider))  + '_';
         deviceName_ += multi_cast<std::string>(oisDevice_->getNumberOfComponents(OIS::OIS_POV));
         //deviceName_ += multi_cast<std::string>(oisDevice_->getNumberOfComponents(OIS::OIS_Vector3));
 …
+            {
                 // Make the ID unique for this execution time.
                 deviceName_ += "_" + multi_cast<std::string>(this->getDeviceName());
+                deviceName_ += '_' + multi_cast<std::string>(this->getDeviceName());
                 break;
+            }

code/trunk/src/libraries/core/input/JoyStickQuantityListener.h

r5781	r6417
29	29	/**
30	30	@file
31		@brief
	31	@brief
32	32	*/
33	33

code/trunk/src/libraries/core/input/KeyBinder.cc

-                      r5929
+                      r6417
 #include "KeyBinder.h"
+#include <algorithm>
+#include <sstream>
 #include "util/Convert.h"
 #include "util/Debug.h"
 …
         mouseRelative_[0] = 0;
         mouseRelative_[1] = 0;
         mousePosition_[0] = 0;
         mousePosition_[1] = 0;
+        mousePosition_[0] = 0.0;
+        mousePosition_[1] = 0.0;
         RegisterRootObject(KeyBinder);
 …
         for (unsigned int i = 0; i < KeyCode::numberOfKeys; i++)
+        {
             std::string keyname = KeyCode::ByString[i];
+            const std::string& keyname = KeyCode::ByString[i];
             if (!keyname.empty())
                 keys_[i].name_ = std::string("Key") + keyname;
             else
                 keys_[i].name_ = "";
+                keys_[i].name_.clear();
             keys_[i].paramCommandBuffer_ = &paramCommandBuffer_;
             keys_[i].groupName_ = "Keys";
 …
         SetConfigValue(bFilterAnalogNoise_, false)
             .description("Specifies whether to filter small analog values like joy stick fluctuations.");
         SetConfigValue(mouseSensitivity_, 1.0f)
+        SetConfigValue(mouseSensitivity_, 3.0f)
             .description("Mouse sensitivity.");
+        this->totalMouseSensitivity_ = this->mouseSensitivity_ / this->mouseClippingSize_;
         SetConfigValue(bDeriveMouseInput_, false)
             .description("Whether or not to derive moues movement for the absolute value.");
 …
         this->joyStickButtons_.resize(joySticks_.size());
         // reinitialise all joy stick binings (doesn't overwrite the old ones)
+        // reinitialise all joy stick bindings (doesn't overwrite the old ones)
         for (unsigned int iDev = 0; iDev < joySticks_.size(); iDev++)
+        {
             std::string deviceName = joySticks_[iDev]->getDeviceName();
+            const std::string& deviceName = joySticks_[iDev]->getDeviceName();
             // joy stick buttons
             for (unsigned int i = 0; i < JoyStickButtonCode::numberOfButtons; i++)
 …
         for (unsigned int i = 0; i < KeyCode::numberOfKeys; i++)
             if (!keys_[i].name_.empty())
                 allButtons_[keys_[i].groupName_ + "." + keys_[i].name_] = keys_ + i;
+                allButtons_[keys_[i].groupName_ + '.' + keys_[i].name_] = keys_ + i;
         for (unsigned int i = 0; i < numberOfMouseButtons_; i++)
             allButtons_[mouseButtons_[i].groupName_ + "." + mouseButtons_[i].name_] = mouseButtons_ + i;
+            allButtons_[mouseButtons_[i].groupName_ + '.' + mouseButtons_[i].name_] = mouseButtons_ + i;
         for (unsigned int i = 0; i < MouseAxisCode::numberOfAxes * 2; i++)
+        {
             allButtons_[mouseAxes_[i].groupName_ + "." + mouseAxes_[i].name_] = mouseAxes_ + i;
+            allButtons_[mouseAxes_[i].groupName_ + '.' + mouseAxes_[i].name_] = mouseAxes_ + i;
             allHalfAxes_.push_back(mouseAxes_ + i);
+        }
 …
+        {
             for (unsigned int i = 0; i < JoyStickButtonCode::numberOfButtons; i++)
                 allButtons_[(*joyStickButtons_[iDev])[i].groupName_ + "." + (*joyStickButtons_[iDev])[i].name_] = &((*joyStickButtons_[iDev])[i]);
+                allButtons_[(*joyStickButtons_[iDev])[i].groupName_ + '.' + (*joyStickButtons_[iDev])[i].name_] = &((*joyStickButtons_[iDev])[i]);
             for (unsigned int i = 0; i < JoyStickAxisCode::numberOfAxes * 2; i++)
+            {
                 allButtons_[(*joyStickAxes_[iDev])[i].groupName_ + "." + (*joyStickAxes_[iDev])[i].name_] = &((*joyStickAxes_[iDev])[i]);
+                allButtons_[(*joyStickAxes_[iDev])[i].groupName_ + '.' + (*joyStickAxes_[iDev])[i].name_] = &((*joyStickAxes_[iDev])[i]);
                 allHalfAxes_.push_back(&((*joyStickAxes_[iDev])[i]));
+            }
 …
         // Parse bindings and create the ConfigValueContainers if necessary
         for (std::map<std::string, Button*>::const_iterator it = allButtons_.begin(); it != allButtons_.end(); ++it)
+        {
             it->second->readConfigValue(this->configFile_);
+            addButtonToCommand(it->second->bindingString_, it->second);
+        }
         COUT(3) << "KeyBinder: Loading key bindings done." << std::endl;
 …
         if (it != allButtons_.end())
+        {
+            addButtonToCommand(binding, it->second);
             if (bTemporary)
                 it->second->configContainer_->tset(binding);
 …
             return false;
+        }
+    }
+     void KeyBinder::addButtonToCommand(const std::string& command, Button* button)
+     {
+        std::ostringstream stream;
+        stream << button->groupName_  << '.' << button->name_;
+        std::vector<std::string>& oldKeynames = this->allCommands_[button->bindingString_];
+        std::vector<std::string>::iterator it = std::find(oldKeynames.begin(), oldKeynames.end(), stream.str());
+        if(it != oldKeynames.end())
+        {
+            oldKeynames.erase(it);
+        }
+        if (!command.empty())
+        {
+            std::vector<std::string>& keynames = this->allCommands_[command];
+            if( std::find(keynames.begin(), keynames.end(), stream.str()) == keynames.end())
+            {
+                this->allCommands_[command].push_back(stream.str());
+            }
+        }
+     }
+    /**
+    @brief
+        Return the first key name for a specific command
+    */
+    const std::string& KeyBinder::getBinding(const std::string& commandName)
+    {
+        if( this->allCommands_.find(commandName) != this->allCommands_.end())
+        {
+            std::vector<std::string>& keynames = this->allCommands_[commandName];
+            return keynames.front();
+        }
+        return BLANKSTRING;
+    }
+    /**
+    @brief
+        Return the key name for a specific command at a given index.
+    @param commandName
+        The command name the key name is returned for.
+    @param index
+        The index at which the key name is returned for.
+    */
+    const std::string& KeyBinder::getBinding(const std::string& commandName, unsigned int index)
+    {
+        if( this->allCommands_.find(commandName) != this->allCommands_.end())
+        {
+            std::vector<std::string>& keynames = this->allCommands_[commandName];
+            if(index < keynames.size())
+            {
+                return keynames[index];
+            }
+            return BLANKSTRING;
+        }
+        return BLANKSTRING;
+    }
+    /**
+    @brief
+        Get the number of different key bindings of a specific command.
+    @param commandName
+        The command.
+    */
+    unsigned int KeyBinder::getNumberOfBindings(const std::string& commandName)
+    {
+        if( this->allCommands_.find(commandName) != this->allCommands_.end())
+        {
+            std::vector<std::string>& keynames = this->allCommands_[commandName];
+            return keynames.size();
+        }
+        return 0;
+    }
 …
         // these are the actually useful axis bindings for analog input
+        if (!bFilterAnalogNoise_ || halfAxis.relVal_ > analogThreshold_ || halfAxis.absVal_ > analogThreshold_)
+        {
+            halfAxis.execute();
+        }
+        halfAxis.execute();
+    }
 …
                     mouseAxes_[2*i + 0].hasChanged_ = true;
                     mouseAxes_[2*i + 1].hasChanged_ = true;
                     mousePosition_[i] += rel[i];
+                    mousePosition_[i] += rel[i] * totalMouseSensitivity_;
                     // clip absolute position
                     if (mousePosition_[i] > mouseClippingSize_)
                         mousePosition_[i] =  mouseClippingSize_;
                     if (mousePosition_[i] < -mouseClippingSize_)
                         mousePosition_[i] = -mouseClippingSize_;
                     if (mousePosition_[i] < 0)
+                    if (mousePosition_[i] > 1.0)
+                        mousePosition_[i] =  1.0;
+                    if (mousePosition_[i] < -1.0)
+                        mousePosition_[i] = -1.0;
+                    if (mousePosition_[i] < 0.0)
+                    {
                         mouseAxes_[2*i + 0].absVal_ = -mouseSensitivity_ * mousePosition_[i] / mouseClippingSize_;
+                        mouseAxes_[2*i + 0].absVal_ = -mousePosition_[i];
                         mouseAxes_[2*i + 1].absVal_ = 0.0f;
+                    }
 …
+                    {
                         mouseAxes_[2*i + 0].absVal_ = 0.0f;
                         mouseAxes_[2*i + 1].absVal_ =  mouseSensitivity_ * mousePosition_[i] / mouseClippingSize_;
+                        mouseAxes_[2*i + 1].absVal_ =  mousePosition_[i];
+                    }
+                }
 …
+        {
             if (rel[i] < 0)
                 mouseAxes_[0 + 2*i].relVal_ = -mouseSensitivity_ * rel[i] / mouseClippingSize_;
+                mouseAxes_[0 + 2*i].relVal_ = -rel[i] * totalMouseSensitivity_;
             else
                 mouseAxes_[1 + 2*i].relVal_ =  mouseSensitivity_ * rel[i] / mouseClippingSize_;
+                mouseAxes_[1 + 2*i].relVal_ =  rel[i] * totalMouseSensitivity_;
+        }
+    }
 …
     void KeyBinder::axisMoved(unsigned int device, unsigned int axisID, float value)
+    {
+        // Filter analog noise
+        if (this->bFilterAnalogNoise_ && std::abs(value) < this->analogThreshold_)
+            value = 0.0;
         int i = axisID * 2;
         JoyStickAxisVector& axis = *joyStickAxes_[device];

code/trunk/src/libraries/core/input/KeyBinder.h

-                      r5929
+                      r6417
 #include <string>
 #include <vector>
+#include <map>
 #include <boost/shared_ptr.hpp>
 …
 #include "JoyStickQuantityListener.h"
+// tolua_begin
 namespace orxonox
+{
+    // tolua_end
     /**
     @brief
 …
         KeyBinders. If you need to load other bindings, just create a new one.
     */
+    class _CoreExport KeyBinder : public InputHandler, public JoyStickQuantityListener
+    {
+    class _CoreExport KeyBinder // tolua_export
+        : public InputHandler, public JoyStickQuantityListener
+    { // tolua_export
     public:
         KeyBinder (const std::string& filename);
 …
         void clearBindings();
         bool setBinding(const std::string& binding, const std::string& name, bool bTemporary = false);
+        const std::string& getBinding(const std::string& commandName); //tolua_export
+        const std::string& getBinding(const std::string& commandName, unsigned int index); //tolua_export
+        unsigned int getNumberOfBindings(const std::string& commandName); //tolua_export
         const std::string& getBindingsFilename()
             { return this->filename_; }
 …
         //! Pointer list with all half axes
         std::vector<HalfAxis*> allHalfAxes_;
+        //! Maps input commands to all Button names, including half axes
+        std::map< std::string, std::vector<std::string> > allCommands_;
         /**
 …
         std::vector<BufferedParamCommand*> paramCommandBuffer_;
         //! Keeps track of the absolute mouse value (incl. scroll wheel)
         int mousePosition_[2];
+        //! Keeps track of the absolute mouse value
+        float mousePosition_[2];
         //! Used to derive mouse input if requested
         int mouseRelative_[2];
 …
     private:
+        void addButtonToCommand(const std::string& command, Button* button);
         //##### ConfigValues #####
         //! Whether to filter small value analog input
 …
         //! mouse sensitivity if mouse input is derived
         float mouseSensitivityDerived_;
         //! Equals one step of the mousewheel
+        //! Equals one step of the mouse wheel
         int mouseWheelStepSize_;
+        //! Multiplication of mouse sensitivity and clipping size
+        float totalMouseSensitivity_;
         //##### Constant config variables #####
         // Use some value at about 1000. This can be configured with mouseSensitivity_ anyway.
         static const int mouseClippingSize_ = 1024;
     };
+    };// tolua_export
 …
             mouseAxes_[i].relVal_ = 0.0f;
+    }
+}
+}// tolua_export
 #endif /* _KeyBinder_H__ */

code/trunk/src/libraries/core/input/KeyBinderManager.cc

-                      r5929
+                      r6417
 namespace orxonox
+{
-    KeyBinderManager* KeyBinderManager::singletonPtr_s = 0;
     ManageScopedSingleton(KeyBinderManager, ScopeID::Graphics, false);
 …
         , bBinding_(false)
+    {
-        this->callbackFunction_ = createFunctor(&KeyBinderManager::callback, this);
         RegisterObject(KeyBinderManager);
         this->setConfigValues();
 …
             .defaultValues("");
         CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(createFunctor(&KeyBinderManager::tkeybind, this), "tkeybind"))
+            .defaultValues("");
+        CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(createFunctor(&KeyBinderManager::unbind, this), "unbind"))
+            .defaultValues("");
+        CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(createFunctor(&KeyBinderManager::tunbind, this), "tunbind"))
             .defaultValues("");
 …
         for (std::map<std::string, KeyBinder*>::const_iterator it = this->binders_.begin(); it != this->binders_.end(); ++it)
             delete it->second;
-        delete this->callbackFunction_;
+    }
 …
         else
             this->bDefaultFileLoaded_ = false;
+    }
+    inline void KeyBinderManager::unbind(const std::string& binding)
+    {
+        this->currentBinder_->setBinding("", binding, false);
+    }
+    inline void KeyBinderManager::tunbind(const std::string& binding)
+    {
+        this->currentBinder_->setBinding("", binding, true);
+    }
 …
+        {
             COUT(0) << "Press any button/key or move a mouse/joystick axis" << std::endl;
             KeyDetector::getInstance().setCallback(callbackFunction_);
+            KeyDetector::getInstance().setCallback(shared_ptr<Functor>(createFunctor(&KeyBinderManager::keybindKeyPressed, this)));
             InputManager::getInstance().enterState("detector");
             this->command_ = command;
 …
     // Gets called by the KeyDetector (registered with a Functor)
     void KeyBinderManager::callback(const std::string& keyName)
+    void KeyBinderManager::keybindKeyPressed(const std::string& keyName)
+    {
         if (this->bBinding_)
+        {
+            COUT(0) << "Binding string \"" << command_ << "\" on key '" << keyName << "'" << std::endl;
+            this->currentBinder_->setBinding(command_, keyName, bTemporary_);
+            if (keyName == "Keys.KeyEscape")
+            {
+                COUT(0) << "Keybinding aborted." << std::endl;
+            }
+            else
+            {
+                COUT(0) << "Binding string \"" << command_ << "\" on key '" << keyName << "'" << std::endl;
+                this->currentBinder_->setBinding(command_, keyName, bTemporary_);
+            }
             InputManager::getInstance().leaveState("detector");
+            // inform whatever was calling the command
+            if (this->callbackFunction_)
+                (*this->callbackFunction_)();
             this->bBinding_ = false;
+        }

code/trunk/src/libraries/core/input/KeyBinderManager.h

-                      r5929
+                      r6417
 #include <map>
 #include <string>
+#include <boost/shared_ptr.hpp>
 #include "util/Singleton.h"
 #include "core/OrxonoxClass.h"
 namespace orxonox
+{
+namespace orxonox //tolua_export
+{ //tolua_export
     /**
     @brief
 …
         maps to the currently active KeyBinder. You can set that with setCurrent().
         There is also a default one, retrieved with getDefault(). The idea is that
         mostly the default KeyBinder is active except for special situtations (mini-game for inst).
+        mostly the default KeyBinder is active except for special situations (mini-game for inst).
     @remarks
         You are not forced to use the KeyBinder imposed by getCurrent(). But be aware that "keybind"
         will not work as expected!
     */
+    class _CoreExport KeyBinderManager : public Singleton<KeyBinderManager>, public OrxonoxClass
+    {
+    class _CoreExport KeyBinderManager //tolua_export
+        : public Singleton<KeyBinderManager>, public OrxonoxClass
+    { //tolua_export
         friend class Singleton<KeyBinderManager>;
     public:
 …
         void setConfigValues();
+        static KeyBinderManager& getInstance() { return Singleton<KeyBinderManager>::getInstance(); } //tolua_export
         //! Returns the currently selected KeyBinder
+        KeyBinder*    getCurrent()
+            { return this->currentBinder_; }
+        KeyBinder* getCurrent() { return this->currentBinder_; } //tolua_export
         //! Like getCurrent(), but returns it as InputHandler* (so you don't have to include KeyBinder.h)
         InputHandler* getCurrentAsHandler();
 …
         //! Returns the default KeyBinder
         KeyBinder*    getDefault()
+        KeyBinder* getDefault()
             { return binders_[this->defaultFilename_]; }
         //! Returns the default KeyBinder as InputHandler* (so you don't have to include KeyBinder.h)
 …
         //! Returns a pointer to a KeyBinder (creates it if not yet loaded)
         KeyBinder*    get(const std::string& name);
+        KeyBinder* get(const std::string& name);
         //! Like get() but return value is of type InputHandler* (so you don't have to include KeyBinder.h)
         InputHandler* getAsHandler(const std::string& name);
         //! Loads a KeyBinder by creating it (no different from get() except for the return value)
         void load  (const std::string& filename);
+        void load(const std::string& filename);
         //! Destroys a KeyBinder completely (does nothing if not yet loaded)
         void unload(const std::string& filename);
         //! Bind 'command' to any key pressed after this call (use with care!)
+        inline void keybind(const std::string& command)
+            { this->keybindInternal(command, false); }
+        inline void keybind(const std::string& command) { this->keybindInternal(command, false); } //tolua_export
         //! Bind 'command' to any key pressed after this call (use with care!), but temporarily (no file save)
         inline void tkeybind(const std::string& command)
             { this->keybindInternal(command, true); }
+        void unbind(const std::string& binding); //tolua_export
+        void tunbind(const std::string& binding);
+        inline void registerKeybindCallback(Functor* function) { this->callbackFunction_.reset(function); } // tolua_export
     private:
         KeyBinderManager(const KeyBinderManager&);
         void keybindInternal(const std::string& command, bool bTemporary);
         void callback(const std::string& keyName);
+        void keybindKeyPressed(const std::string& keyName);
         void defaultFilenameChanged();
 …
         // keybind command related
         Functor* callbackFunction_;                  //! Function to be called when key was pressed after "keybind" command
+        shared_ptr<Functor> callbackFunction_;       //! Function to be called when key was pressed after "keybind" command
         bool bBinding_;                              //! Tells whether a key binding process is active
         bool bTemporary_;                            //! Stores tkeybind/keybind value
 …
         static KeyBinderManager* singletonPtr_s;
     };
+}
+    }; //tolua_export
+} //tolua_export
 #endif /* _KeyBinderManager_H__ */

code/trunk/src/libraries/core/input/KeyDetector.cc

r5929	r6417
39	39	{
40	40	std::string KeyDetector::callbackCommand_s = "KeyDetectorKeyPressed";
41		~~KeyDetector* KeyDetector::singletonPtr_s = 0;~~
42	41	ManageScopedSingleton(KeyDetector, ScopeID::Graphics, false);
43	42
…	…
68	67	for (std::map<std::string, Button*>::const_iterator it = allButtons_.begin(); it != allButtons_.end(); ++it)
69	68	{
70		it->second->bindingString_ = callbackCommand_s + ~~" "~~ + it->second->groupName_ + "." + it->second->name_;
	69	it->second->bindingString_ = callbackCommand_s + ' ' + it->second->groupName_ + "." + it->second->name_;
71	70	it->second->parse();
72	71	}

code/trunk/src/libraries/core/input/KeyDetector.h

-                      r5929
+                      r6417
 #include "InputPrereqs.h"
+#include <boost/shared_ptr.hpp>
 #include "util/Singleton.h"
 #include "KeyBinder.h"
 …
         ~KeyDetector();
         void setCallback(Functor* function) { this->callbackFunction_ = function; }
+        void setCallback(const shared_ptr<Functor>& function) { this->callbackFunction_ = function; }
     private:
 …
         void assignCommands();
         Functor* callbackFunction_;
+        shared_ptr<Functor> callbackFunction_;
         InputState* inputState_;
         static std::string callbackCommand_s;

code/trunk/src/libraries/core/input/Keyboard.cc

-                      r5781
+                      r6417
             modifiers_ |= KeyboardModifier::Shift; // shift key
+        // Do not distribute the alt+tab event (messes with the operating system)
+        if ((modifiers_ & KeyboardModifier::Alt) != 0 && arg.key == OIS::KC_TAB)
+            return true;
         KeyEvent evt(arg);
         super::buttonPressed(evt);

Context Navigation

Legend:

Download in other formats: