Changeset 2101 for code/branches/objecthierarchy/src/core

Timestamp:

Nov 2, 2008, 12:09:55 AM (16 years ago)

Author:

rgrieder

Message:

Finally managed to have a master InputState which enables:

• Console always opens
• Debug overlay toggles visibility in gui mode too

Had to change several other code:

• ConfigFileManager uses special class instead of enum for ConfigFileType
• You can add an arbitrary config file and get the ConfigFileType
• ConfigFileManager is an Ogre singleton too. Created in Main.cc
• CommandLineArgument "optionsFile" specifies another file for command line arguments
• CommandLineArgument "settingsFile" declares the file used for settings (orxonox.ini)
• changed all fileNames to filenames
• "Loaded config file blah" now uses COUT(3) instead of COUT(0)
• fixed a bug in ConfigFileManager::load() that cause orxonox.ini to double its size after every call

Location:

code/branches/objecthierarchy/src/core

Files:

• CommandLine.cc (modified) (2 diffs)
• CommandLine.h (modified) (3 diffs)
• ConfigFileManager.cc (modified) (15 diffs)
• ConfigFileManager.h (modified) (7 diffs)
• ConfigValueIncludes.h (modified) (2 diffs)
• CoreIncludes.h (modified) (1 diff)
• Identifier.h (modified) (1 diff)
• Language.cc (modified) (7 diffs)
• Language.h (modified) (1 diff)
• RootGameState.cc (modified) (5 diffs)
• RootGameState.h (modified) (1 diff)
• input/Button.cc (modified) (1 diff)
• input/Button.h (modified) (2 diffs)
• input/InputManager.cc (modified) (3 diffs)
• input/KeyBinder.cc (modified) (4 diffs)
• input/KeyBinder.h (modified) (3 diffs)

code/branches/objecthierarchy/src/core/CommandLine.cc

@@ -30 +30 @@
 
 #include "util/String.h"
+#include "util/SubString.h"
 
 namespace orxonox
 {
+    SetCommandLineArgument(optionsFile, "start.ini").shortcut("o");
+
     /**
     @brief
@@ -274 +277 @@
         }
     }
+
+    /**
+    @brief
+        Parses both command line and start.ini for CommandLineArguments.
+    */
+    void CommandLine::_parseAll(int argc, char** argv)
+    {
+        // parse command line first
+        std::vector<std::string> args;
+        for (int i = 1; i < argc; ++i)
+            args.push_back(argv[i]);
+        this->_parse(args);
+
+        // look for additional arguments in given file or start.ini as default
+        // They will not overwrite the arguments given directly
+        std::ifstream file;
+        std::string filename = CommandLine::getValue("optionsFile").getString();
+        file.open(filename.c_str());
+        args.clear();
+        if (file)
+        {
+            while (!file.eof())
+            {
+                std::string line;
+                std::getline(file, line);
+                line = removeTrailingWhitespaces(line);
+                //if (!(line[0] == '#' || line[0] == '%'))
+                //{
+                SubString tokens(line, " ", " ", false, 92, false, 34, false, 40, 41, false, '#');
+                for (unsigned i = 0; i < tokens.size(); ++i)
+                    if (tokens[i][0] != '#')
+                        args.push_back(tokens[i]);
+                //args.insert(args.end(), tokens.getAllStrings().begin(), tokens.getAllStrings().end());
+                //}
+            }
+            file.close();
+        }
+        else
+        {
+            COUT(2) << "Warning: Could not find " << filename
+                    << " to get additional command line arguments." << std::endl;
+        }
+
+        try
+        {
+            _parse(args);
+        }
+        catch (orxonox::ArgumentException& ex)
+        {
+            COUT(1) << "An Exception occured while parsing " << filename << std::endl;
+            throw(ex);
+        }
+    }
 }

code/branches/objecthierarchy/src/core/CommandLine.h

@@ -38 +38 @@
 
 #define SetCommandLineArgument(name, defaultValue) \
-    CommandLineArgument& CmdArgumentDummyBoolVar##name \
+    orxonox::CommandLineArgument& CmdArgumentDummyBoolVar##name \
     = orxonox::CommandLine::addArgument(#name, defaultValue)
 #define SetCommandLineSwitch(name) \
-    CommandLineArgument& CmdArgumentDummyBoolVar##name \
+    orxonox::CommandLineArgument& CmdArgumentDummyBoolVar##name \
     = orxonox::CommandLine::addArgument(#name, false)
 
@@ -135 +135 @@
 
         //! Parse redirection to internal member method.
-        static void parse(const std::vector<std::string>& arguments) { _getInstance()._parse(arguments); }
+        static void parseAll(int argc, char** argv) { _getInstance()._parseAll(argc, argv); }
 
         static std::string getUsageInformation();
@@ -165 +165 @@
         static CommandLine& _getInstance();
 
+        void _parseAll(int argc, char** argv);
         void _parse(const std::vector<std::string>& arguments);
         void checkFullArgument(const std::string& name, const std::string& value);

code/branches/objecthierarchy/src/core/ConfigFileManager.cc

@@ -28 +28 @@
 
 #include "ConfigFileManager.h"
-#include "ConfigValueContainer.h"
-#include "ConsoleCommand.h"
-#include "Identifier.h"
+
+#include <cassert>
 #include "util/Convert.h"
 #include "util/String.h"
-
+#include "ConsoleCommand.h"
+#include "ConfigValueContainer.h"
 
 namespace orxonox
@@ -39 +39 @@
     const int CONFIG_FILE_MAX_LINELENGHT  = 1024;
     const char* const DEFAULT_CONFIG_FILE = "default.ini";
+
+    ConfigFileManager* ConfigFileManager::singletonRef_s = 0;
 
     SetConsoleCommandShortcutExtern(config).argumentCompleter(0, autocompletion::configvalueclasses()).argumentCompleter(1, autocompletion::configvalues()).argumentCompleter(2, autocompletion::configvalue());
@@ -45 +47 @@
     SetConsoleCommandShortcutExtern(cleanConfig);
     SetConsoleCommandShortcutExtern(loadSettings).argumentCompleter(0, autocompletion::files());
-    SetConsoleCommandShortcutExtern(loadKeybindings).argumentCompleter(0, autocompletion::files());
 
     bool config(const std::string& classname, const std::string& varname, const std::string& value)
@@ -83 +84 @@
     void loadSettings(const std::string& filename)
     {
-        ConfigFileManager::getInstance().setFile(CFT_Settings, filename, false);
-    }
-
-    void loadKeybindings(const std::string& filename)
-    {
-        ConfigFileManager::getInstance().setFile(CFT_Keybindings, filename);
-    }
-
+        ConfigFileManager::getInstance().setFilename(ConfigFileType::Settings, filename);
+    }
 
     //////////////////////////
@@ -121 +116 @@
 
 
-    ///////////////////////////////
+    ////////////////////////////////
     // ConfigFileEntryVectorValue //
-    ///////////////////////////////
+    ////////////////////////////////
     std::string ConfigFileEntryVectorValue::getFileEntry() const
     {
@@ -217 +212 @@
     ConfigFile::~ConfigFile()
     {
-        for (std::list<ConfigFileSection*>::iterator it = this->sections_.begin(); it != this->sections_.end(); )
-            delete (*(it++));
+        this->clear();
     }
 
     void ConfigFile::load(bool bCreateIfNotExisting)
     {
-        if (bCreateIfNotExisting)
-        {
-            // This creates the default config file if it's not existing
-            std::ofstream createFile;
-            createFile.open(this->filename_.c_str(), std::fstream::app);
-            createFile.close();
-        }
+        // Be sure we start from new
+        this->clear();
+
+        // This creates the config file if it's not existing
+        std::ofstream createFile;
+        createFile.open(this->filename_.c_str(), std::fstream::app);
+        createFile.close();
 
         // Open the file
@@ -329 +323 @@
         file.close();
 
-        COUT(0) << "Loaded config file \"" << this->filename_ << "\"." << std::endl;
+        COUT(3) << "Loaded config file \"" << this->filename_ << "\"." << std::endl;
 
         // Save the file in case something changed (like stripped whitespaces)
         this->save();
+
+        // Update all ConfigValueContainers
+        this->updateConfigValues();
     }
 
@@ -366 +363 @@
     }
 
-    void ConfigFile::save(const std::string& filename)
+    void ConfigFile::saveAs(const std::string& filename)
     {
         std::string temp = this->filename_;
@@ -415 +412 @@
     }
 
+    void ConfigFile::clear()
+    {
+        for (std::list<ConfigFileSection*>::iterator it = this->sections_.begin(); it != this->sections_.end(); )
+            delete (*(it++));
+        this->sections_.clear();
+    }
+
     ConfigFileSection* ConfigFile::getSection(const std::string& section)
     {
@@ -446 +450 @@
     }
 
+    void ConfigFile::updateConfigValues()
+    {
+        if (this->type_ == ConfigFileType::Settings)
+        {
+            for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getIdentifierMapBegin(); it != Identifier::getIdentifierMapEnd(); ++it)
+            {
+                if (it->second->hasConfigValues())
+                {
+                    for (std::map<std::string, ConfigValueContainer*>::const_iterator it2 = (*it).second->getConfigValueMapBegin(); it2 != (*it).second->getConfigValueMapEnd(); ++it2)
+                        it2->second->update();
+
+                    it->second->updateConfigValues();
+                }
+            }
+        }
+    }
+
 
     ///////////////////////
     // ConfigFileManager //
     ///////////////////////
+
     ConfigFileManager::ConfigFileManager()
-    {
-        this->setFile(CFT_Settings, DEFAULT_CONFIG_FILE);
+         : mininmalFreeType_(ConfigFileType::numberOfReservedTypes)
+    {
+        assert(singletonRef_s == 0);
+        singletonRef_s = this;
     }
 
@@ -458 +482 @@
     {
         for(std::map<ConfigFileType, ConfigFile*>::const_iterator it = this->configFiles_.begin(); it != this->configFiles_.end(); )
-            delete (*(it++)).second;
-    }
-
-    ConfigFileManager& ConfigFileManager::getInstance()
-    {
-        static ConfigFileManager instance;
-        return instance;
-    }
-
-    void ConfigFileManager::setFile(ConfigFileType type, const std::string& filename, bool bCreateIfNotExisting)
+            delete (it++)->second;
+
+        assert(singletonRef_s != 0);
+        singletonRef_s = 0;
+    }
+
+    void ConfigFileManager::setFilename(ConfigFileType type, const std::string& filename)
     {
         std::map<ConfigFileType, ConfigFile*>::const_iterator it = this->configFiles_.find(type);
         if (it != this->configFiles_.end())
-            if ((*it).second != 0)
-                delete (*it).second;
-
-        this->configFiles_[type] = new ConfigFile(this->getFilePath(filename));
-        this->load(type, bCreateIfNotExisting);
-    }
-
-    void ConfigFileManager::load(bool bCreateIfNotExisting)
+        {
+            assert(it->second);
+            delete it->second;
+        }
+        this->configFiles_[type] = new ConfigFile(filename, type);
+        this->load(type);
+    }
+
+    void ConfigFileManager::load()
     {
         for(std::map<ConfigFileType, ConfigFile*>::const_iterator it = this->configFiles_.begin(); it != this->configFiles_.end(); ++it)
-            (*it).second->load(bCreateIfNotExisting);
-
-        this->updateConfigValues();
+            it->second->load();
     }
 
@@ -489 +509 @@
     {
         for(std::map<ConfigFileType, ConfigFile*>::const_iterator it = this->configFiles_.begin(); it != this->configFiles_.end(); ++it)
-            (*it).second->save();
+            it->second->save();
     }
 
@@ -495 +515 @@
     {
         for(std::map<ConfigFileType, ConfigFile*>::const_iterator it = this->configFiles_.begin(); it != this->configFiles_.end(); ++it)
-            this->clean((*it).first, bCleanComments);
-    }
-
-    void ConfigFileManager::load(ConfigFileType type, bool bCreateIfNotExisting)
-    {
-        this->getFile(type)->load(bCreateIfNotExisting);
-        this->updateConfigValues(type);
+            this->clean(it->first, bCleanComments);
+    }
+
+    void ConfigFileManager::load(ConfigFileType type)
+    {
+        this->getFile(type)->load();
     }
 
@@ -509 +528 @@
     }
 
-    void ConfigFileManager::save(ConfigFileType type, const std::string& filename)
-    {
-        this->getFile(type)->save(filename);
+    void ConfigFileManager::saveAs(ConfigFileType type, const std::string& saveFilename)
+    {
+        this->getFile(type)->saveAs(saveFilename);
     }
 
@@ -519 +538 @@
     }
 
-    void ConfigFileManager::updateConfigValues() const
+    void ConfigFileManager::updateConfigValues()
     {
         for(std::map<ConfigFileType, ConfigFile*>::const_iterator it = this->configFiles_.begin(); it != this->configFiles_.end(); ++it)
-            this->updateConfigValues((*it).first);
-    }
-
-    void ConfigFileManager::updateConfigValues(ConfigFileType type) const
-    {
-        if (type == CFT_Settings)
-        {
-            for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getIdentifierMapBegin(); it != Identifier::getIdentifierMapEnd(); ++it)
-            {
-                if ((*it).second->hasConfigValues() /* && (*it).second != ClassIdentifier<KeyBinder>::getIdentifier()*/)
-                {
-                    for (std::map<std::string, ConfigValueContainer*>::const_iterator it2 = (*it).second->getConfigValueMapBegin(); it2 != (*it).second->getConfigValueMapEnd(); ++it2)
-                        (*it2).second->update();
-
-                    (*it).second->updateConfigValues();
-                }
-            }
-        }
-        else if (type == CFT_Keybindings)
-        {
-            // todo
-        }
+            it->second->updateConfigValues();
+    }
+
+    void ConfigFileManager::updateConfigValues(ConfigFileType type)
+    {
+        this->getFile(type)->updateConfigValues();
+    }
+
+    const std::string& ConfigFileManager::getFilename(ConfigFileType type)
+    {
+        std::map<ConfigFileType, ConfigFile*>::const_iterator it = this->configFiles_.find(type);
+        if (it != this->configFiles_.end())
+            return it->second->getFilename();
+        else
+            return BLANKSTRING;
     }
 
     ConfigFile* ConfigFileManager::getFile(ConfigFileType type)
     {
-        std::map<ConfigFileType, ConfigFile*>::iterator it = this->configFiles_.find(type);
+        std::map<ConfigFileType, ConfigFile*>::const_iterator it = this->configFiles_.find(type);
         if (it != this->configFiles_.end())
-            return (*it).second;
-
-        if (type == CFT_Settings)
-            return this->configFiles_[type] = new ConfigFile(DEFAULT_CONFIG_FILE);
-        else
-            return this->configFiles_[type] = new ConfigFile("");
-    }
-
-    std::string ConfigFileManager::getFilePath(const std::string& name) const
-    {
-        return name;
+            return it->second;
+        else
+        {
+            COUT(1) << "ConfigFileManager: Can't find a config file for type with ID " << (int)type << std::endl;
+            COUT(1) << "Using " << DEFAULT_CONFIG_FILE << " file." << std::endl;
+            this->setFilename(type, DEFAULT_CONFIG_FILE);
+            return getFile(type);
+        }
     }
 }

code/branches/objecthierarchy/src/core/ConfigFileManager.h

@@ -41 +41 @@
 namespace orxonox
 {
-    enum _CoreExport ConfigFileType
-    {
-        CFT_Settings,
-        CFT_Keybindings,
-        CFT_JoyStickCalibration
-    };
-
+    // Use unsigned int as config file type to have an arbitrary number of files
+    class ConfigFileType
+    {
+    public:
+        ConfigFileType() { }
+        ConfigFileType(unsigned int type)              { type_ = type; }
+        ConfigFileType(const ConfigFileType& instance) { type_ = instance.type_; }
+
+        operator unsigned int() { return type_; }
+        ConfigFileType& operator =(unsigned int type) { type_ = type; return *this; }
+        bool operator <(const ConfigFileType& right) const   { return (type_ < right.type_); }
+
+        /* *** Put the different config file types here *** */
+        static const unsigned int NoType              = 0;
+        static const unsigned int Settings            = 1;
+        static const unsigned int JoyStickCalibration = 2;
+
+        static const unsigned int numberOfReservedTypes = 1024;
+
+    private:
+        unsigned int type_;
+    };
 
     bool config(const std::string& classname, const std::string& varname, const std::string& value);
@@ -55 +70 @@
     void cleanConfig();
     void loadSettings(const std::string& filename);
-    void loadKeybindings(const std::string& filename);
 
 
@@ -218 +232 @@
     {
         public:
-            inline ConfigFile(const std::string& filename) : filename_(filename), bUpdated_(false) {}
+            inline ConfigFile(const std::string& filename, ConfigFileType type)
+                : filename_(filename)
+                , type_(type)
+                , bUpdated_(false)
+            { }
             ~ConfigFile();
 
             void load(bool bCreateIfNotExisting = true);
             void save() const;
-            void save(const std::string& filename);
+            void saveAs(const std::string& filename);
             void clean(bool bCleanComments = false);
+            void clear();
+
+            const std::string& getFilename() { return this->filename_; }
 
             inline void setValue(const std::string& section, const std::string& name, const std::string& value, bool bString)
@@ -241 +262 @@
                 { return this->getSection(section)->getVectorSize(name); }
 
+            void updateConfigValues();
+
         private:
             ConfigFileSection* getSection(const std::string& section);
@@ -246 +269 @@
 
             std::string filename_;
+            ConfigFileType type_;
             std::list<ConfigFileSection*> sections_;
             bool bUpdated_;
@@ -257 +281 @@
     {
         public:
-            static ConfigFileManager& getInstance();
-
-            void setFile(ConfigFileType type, const std::string& filename, bool bCreateIfNotExisting = true);
-
-            void load(bool bCreateIfNotExisting = true);
+            ConfigFileManager();
+            ~ConfigFileManager();
+
+            void load();
             void save();
             void clean(bool bCleanComments = false);
 
-            void load(ConfigFileType type, bool bCreateIfNotExisting = true);
+            void setFilename(ConfigFileType type, const std::string& filename);
+            const std::string& getFilename(ConfigFileType type);
+
+            ConfigFileType getNewConfigFileType() { return mininmalFreeType_++; }
+
+            void load(ConfigFileType type);
             void save(ConfigFileType type);
-            void save(ConfigFileType type, const std::string& filename);
+            void saveAs(ConfigFileType type, const std::string& saveFilename);
             void clean(ConfigFileType type, bool bCleanComments = false);
 
@@ -285 +313 @@
                 { return this->getFile(type)->getVectorSize(section, name); }
 
-            void updateConfigValues() const;
-            void updateConfigValues(ConfigFileType type) const;
-
-        private:
-            ConfigFileManager();
-            ConfigFileManager(const ConfigFileManager& other);
-            ~ConfigFileManager();
+            void updateConfigValues();
+            void updateConfigValues(ConfigFileType type);
+
+            static ConfigFileManager& getInstance() { assert(singletonRef_s); return *singletonRef_s; }
+
+        private:
+            ConfigFileManager(const ConfigFileManager&);
 
             ConfigFile* getFile(ConfigFileType type);
 
-            std::string getFilePath(const std::string& name) const;
-
             std::map<ConfigFileType, ConfigFile*> configFiles_;
+            unsigned int mininmalFreeType_;
+
+            static ConfigFileManager* singletonRef_s;
     };
 }

code/branches/objecthierarchy/src/core/ConfigValueIncludes.h

@@ -52 +52 @@
     if (!container##varname) \
     { \
-        container##varname = new orxonox::ConfigValueContainer(CFT_Settings, identifier##varname, identifier##varname->getName(), #varname, defvalue, varname); \
+        container##varname = new orxonox::ConfigValueContainer(ConfigFileType::Settings, identifier##varname, identifier##varname->getName(), #varname, defvalue, varname); \
         identifier##varname->addConfigValueContainer(#varname, container##varname); \
     } \
     container##varname->getValue(&varname, this)
 
-#define SetConfigValue(varname, defvalue) SetConfigValueGeneric(CFT_Settings, varname, defvalue)
-#define SetKeybindingValue(varname, defvalue) SetConfigValueGeneric(CFT_Keybindings, varname, defvalue)
+#define SetConfigValue(varname, defvalue) SetConfigValueGeneric(ConfigFileType::Settings, varname, defvalue)
 
 
@@ -71 +70 @@
     if (!container##varname) \
     { \
-        container##varname = new orxonox::ConfigValueContainer(CFT_Settings, identifier##varname, identifier##varname->getName(), #varname, defvalue); \
+        container##varname = new orxonox::ConfigValueContainer(ConfigFileType::Settings, identifier##varname, identifier##varname->getName(), #varname, defvalue); \
         identifier##varname->addConfigValueContainer(#varname, container##varname); \
     } \
     container##varname->getValue(&varname, this)
 
-#define SetConfigValueVector(varname, defvalue) SetConfigValueVectorGeneric(CFT_Settings, varname, defvalue)
-#define SetKeybindingValueVector(varname, defvalue) SetConfigValueVectorGeneric(CFT_Keybindings, varname, defvalue)
+#define SetConfigValueVector(varname, defvalue) SetConfigValueVectorGeneric(ConfigFileType::Settings, varname, defvalue)
 
 

code/branches/objecthierarchy/src/core/CoreIncludes.h

@@ -135 +135 @@
 #define RegisterConstructionCallback(ThisClassName, TargetClassName, FunctionName) \
     orxonox::ClassIdentifier<TargetClassName>::getIdentifier()->addConstructionCallback( \
-        createFunctor(&ThisClassName::FunctionName)->setObject(this))
+        orxonox::createFunctor(&ThisClassName::FunctionName)->setObject(this))
 
 #endif /* _CoreIncludes_H__ */

code/branches/objecthierarchy/src/core/Identifier.h

@@ -485 +485 @@
         You can only assign an Identifier that belongs to a class T (or derived) to a SubclassIdentifier<T>.
         If you assign something else, the program aborts.
-        Because we know the minimal type, a dynamic_cast is done, which makes it easier to create a new object.
+        Because we know the minimum type, a dynamic_cast is done, which makes it easier to create a new object.
     */
     template <class T>

code/branches/objecthierarchy/src/core/Language.cc

@@ -137 +137 @@
         }
 
-        COUT(2) << "Warning: Language entry " << label << " is duplicate in " << getFileName(this->defaultLanguage_) << "!" << std::endl;
+        COUT(2) << "Warning: Language entry " << label << " is duplicate in " << getFilename(this->defaultLanguage_) << "!" << std::endl;
         return it->second;
     }
@@ -194 +194 @@
         @return The filename
     */
-    const std::string Language::getFileName(const std::string& language)
+    const std::string Language::getFilename(const std::string& language)
     {
         return std::string("translation_" + language + ".lang");
@@ -208 +208 @@
         // This creates the file if it's not existing
         std::ofstream createFile;
-        createFile.open(getFileName(this->defaultLanguage_).c_str(), std::fstream::app);
+        createFile.open(getFilename(this->defaultLanguage_).c_str(), std::fstream::app);
         createFile.close();
 
         // Open the file
         std::ifstream file;
-        file.open(getFileName(this->defaultLanguage_).c_str(), std::fstream::in);
+        file.open(getFilename(this->defaultLanguage_).c_str(), std::fstream::in);
 
         if (!file.is_open())
         {
             COUT(1) << "An error occurred in Language.cc:" << std::endl;
-            COUT(1) << "Error: Couldn't open file " << getFileName(this->defaultLanguage_) << " to read the default language entries!" << std::endl;
+            COUT(1) << "Error: Couldn't open file " << getFilename(this->defaultLanguage_) << " to read the default language entries!" << std::endl;
             return;
         }
@@ -240 +240 @@
                 else
                 {
-                    COUT(2) << "Warning: Invalid language entry \"" << lineString << "\" in " << getFileName(this->defaultLanguage_) << std::endl;
+                    COUT(2) << "Warning: Invalid language entry \"" << lineString << "\" in " << getFilename(this->defaultLanguage_) << std::endl;
                 }
             }
@@ -257 +257 @@
         // Open the file
         std::ifstream file;
-        file.open(getFileName(Core::getLanguage()).c_str(), std::fstream::in);
+        file.open(getFilename(Core::getLanguage()).c_str(), std::fstream::in);
 
         if (!file.is_open())
         {
             COUT(1) << "An error occurred in Language.cc:" << std::endl;
-            COUT(1) << "Error: Couldn't open file " << getFileName(Core::getLanguage()) << " to read the translated language entries!" << std::endl;
+            COUT(1) << "Error: Couldn't open file " << getFilename(Core::getLanguage()) << " to read the translated language entries!" << std::endl;
             Core::resetLanguage();
             COUT(3) << "Info: Reset language to " << this->defaultLanguage_ << "." << std::endl;
@@ -294 +294 @@
                 else
                 {
-                    COUT(2) << "Warning: Invalid language entry \"" << lineString << "\" in " << getFileName(Core::getLanguage()) << std::endl;
+                    COUT(2) << "Warning: Invalid language entry \"" << lineString << "\" in " << getFilename(Core::getLanguage()) << std::endl;
                 }
             }
@@ -311 +311 @@
         // Open the file
         std::ofstream file;
-        file.open(getFileName(this->defaultLanguage_).c_str(), std::fstream::out);
+        file.open(getFilename(this->defaultLanguage_).c_str(), std::fstream::out);
 
         if (!file.is_open())
         {
             COUT(1) << "An error occurred in Language.cc:" << std::endl;
-            COUT(1) << "Error: Couldn't open file " << getFileName(this->defaultLanguage_) << " to write the default language entries!" << std::endl;
+            COUT(1) << "Error: Couldn't open file " << getFilename(this->defaultLanguage_) << " to write the default language entries!" << std::endl;
             return;
         }

code/branches/objecthierarchy/src/core/Language.h

@@ -128 +128 @@
             void readTranslatedLanguageFile();
             void writeDefaultLanguageFile() const;
-            static const std::string getFileName(const std::string& language);
+            static const std::string getFilename(const std::string& language);
             LanguageEntry* createEntry(const LanguageEntryLabel& label, const std::string& entry);
 

code/branches/objecthierarchy/src/core/RootGameState.cc

@@ -29 +29 @@
 #include "RootGameState.h"
 
-#include "util/String.h"
-#include "util/SubString.h"
 #include "util/Debug.h"
 #include "util/Exception.h"
@@ -130 +128 @@
         State to start with (usually main menu or specified by command line)
     */
-    void RootGameState::start(int argc, char** argv)
+    void RootGameState::start()
     {
 #ifdef NDEBUG
@@ -141 +139 @@
             // create the Core settings to configure the output level
             Core::getInstance();
-
-            parseArguments(argc, argv);
 
             this->activate();
@@ -168 +164 @@
             COUT(1) << ex.what() << std::endl;
             COUT(1) << "Program aborted." << std::endl;
-            abort();
         }
         // anything that doesn't inherit from std::exception
@@ -174 +169 @@
         {
             COUT(1) << "An unidentifiable exception has occured. Program aborted." << std::endl;
-            abort();
         }
 #endif
     }
-
-    /**
-    @brief
-        Parses both command line and start.ini for CommandLineArguments.
-    */
-    void RootGameState::parseArguments(int argc, char** argv)
-    {
-        // parse command line first
-        std::vector<std::string> args;
-        for (int i = 1; i < argc; ++i)
-            args.push_back(argv[i]);
-
-        try
-        {
-            orxonox::CommandLine::parse(args);
-        }
-        catch (orxonox::ArgumentException& ex)
-        {
-            COUT(1) << ex.what() << std::endl;
-            COUT(0) << "Usage:" << std::endl << "orxonox " << CommandLine::getUsageInformation() << std::endl;
-        }
-
-        // look for additional arguments in start.ini
-        std::ifstream file;
-        file.open("start.ini");
-        args.clear();
-        if (file)
-        {
-            while (!file.eof())
-            {
-                std::string line;
-                std::getline(file, line);
-                line = removeTrailingWhitespaces(line);
-                //if (!(line[0] == '#' || line[0] == '%'))
-                //{
-                SubString tokens(line, " ", " ", false, 92, false, 34, false, 40, 41, false, '#');
-                for (unsigned i = 0; i < tokens.size(); ++i)
-                    if (tokens[i][0] != '#')
-                        args.push_back(tokens[i]);
-                //args.insert(args.end(), tokens.getAllStrings().begin(), tokens.getAllStrings().end());
-                //}
-            }
-            file.close();
-        }
-
-        try
-        {
-            orxonox::CommandLine::parse(args);
-        }
-        catch (orxonox::ArgumentException& ex)
-        {
-            COUT(1) << "An Exception occured while parsing start.ini" << std::endl;
-            COUT(1) << ex.what() << std::endl;
-            COUT(0) << "Usage:" << std::endl << "orxonox " << CommandLine::getUsageInformation() << std::endl;
-        }
-    }
 }

code/branches/objecthierarchy/src/core/RootGameState.h

@@ -42 +42 @@
 
         void requestState(const std::string& name);
-        void start(int argc, char** argv);
+        void start();
 
     private:
         void makeTransition(GameStateBase* source, GameStateBase* destination);
         void gotoState(const std::string& name);
-
-        void parseArguments(int argc, char** argv);
 
         std::string           stateRequest_;

code/branches/objecthierarchy/src/core/input/Button.cc

@@ -82 +82 @@
     }
 
-    void Button::readConfigValue()
+    void Button::readConfigValue(ConfigFileType configFile)
     {
         // create/get ConfigValueContainer
         if (!configContainer_)
         {
-            configContainer_ = new ConfigValueContainer(CFT_Keybindings, 0, groupName_, name_, "", name_);
+            configContainer_ = new ConfigValueContainer(configFile, 0, groupName_, name_, "", name_);
             configContainer_->callback(this, &Button::parse);
         }

code/branches/objecthierarchy/src/core/input/Button.h

@@ -41 +41 @@
 #include <vector>
 #include "InputCommands.h"
+#include "core/ConfigFileManager.h"
 
 namespace orxonox
@@ -52 +53 @@
         virtual bool addParamCommand(ParamCommand* command) { return false; }
         void parse();
-        void readConfigValue();
+        void readConfigValue(ConfigFileType configFile);
         bool execute(KeybindMode::Enum mode, float abs = 1.0f, float rel = 1.0f);
 

code/branches/objecthierarchy/src/core/input/InputManager.cc

@@ -395 +395 @@
             if (!cont)
             {
-                cont = new ConfigValueContainer(CFT_Settings, getIdentifier(), getIdentifier()->getName(), "CoeffPos", coeffPos);
+                cont = new ConfigValueContainer(ConfigFileType::Settings, getIdentifier(), getIdentifier()->getName(), "CoeffPos", coeffPos);
                 getIdentifier()->addConfigValueContainer("CoeffPos", cont);
             }
@@ -403 +403 @@
             if (!cont)
             {
-                cont = new ConfigValueContainer(CFT_Settings, getIdentifier(), getIdentifier()->getName(), "CoeffNeg", coeffNeg);
+                cont = new ConfigValueContainer(ConfigFileType::Settings, getIdentifier(), getIdentifier()->getName(), "CoeffNeg", coeffNeg);
                 getIdentifier()->addConfigValueContainer("CoeffNeg", cont);
             }
@@ -411 +411 @@
             if (!cont)
             {
-                cont = new ConfigValueContainer(CFT_Settings, getIdentifier(), getIdentifier()->getName(), "Zero", zero);
+                cont = new ConfigValueContainer(ConfigFileType::Settings, getIdentifier(), getIdentifier()->getName(), "Zero", zero);
                 getIdentifier()->addConfigValueContainer("Zero", cont);
             }

code/branches/objecthierarchy/src/core/input/KeyBinder.cc

@@ -106 +106 @@
         }
 
+        // Get a new ConfigFileType from the ConfigFileManager
+        this->configFile_ = ConfigFileManager::getInstance().getNewConfigFileType();
+
         // initialise joy sticks separatly to allow for reloading
         numberOfJoySticks_ = InputManager::getInstance().numberOfJoySticks();
@@ -133 +136 @@
     void KeyBinder::setConfigValues()
     {
-        SetConfigValue(defaultKeybindings_, "def_keybindings.ini")
-            .description("Filename of default keybindings.");
         SetConfigValue(analogThreshold_, 0.05f)
             .description("Threshold for analog axes until which the state is 0.");
@@ -173 +174 @@
 
         // load the bindings if required
-        if (!configFile_.empty())
+        if (configFile_ != ConfigFileType::NoType)
         {
             for (unsigned int iDev = oldValue; iDev < numberOfJoySticks_; ++iDev)
             {
                 for (unsigned int i = 0; i < JoyStickButtonCode::numberOfButtons; ++i)
-                    joyStickButtons_[iDev][i].readConfigValue();
+                    joyStickButtons_[iDev][i].readConfigValue(this->configFile_);
                 for (unsigned int i = 0; i < JoyStickAxisCode::numberOfAxes * 2; ++i)
-                    joyStickAxes_[iDev][i].readConfigValue();
+                    joyStickAxes_[iDev][i].readConfigValue(this->configFile_);
             }
         }
@@ -250 +251 @@
         True if loading succeeded.
     */
-    void KeyBinder::loadBindings(const std::string& filename)
+    void KeyBinder::loadBindings(const std::string& filename, const std::string& defaultFilename)
     {
         COUT(3) << "KeyBinder: Loading key bindings..." << std::endl;
 
-        configFile_ = filename;
-        if (configFile_.empty())
+        if (filename.empty())
             return;
 
         // get bindings from default file if filename doesn't exist.
         std::ifstream infile;
-        infile.open(configFile_.c_str());
+        infile.open(filename.c_str());
         if (!infile)
         {
-            ConfigFileManager::getInstance().setFile(CFT_Keybindings, defaultKeybindings_);
-            ConfigFileManager::getInstance().save(CFT_Keybindings, configFile_);
+            ConfigFileManager::getInstance().setFilename(this->configFile_, defaultFilename);
+            ConfigFileManager::getInstance().saveAs(this->configFile_, filename);
         }
         else
             infile.close();
-        ConfigFileManager::getInstance().setFile(CFT_Keybindings, configFile_);
+        ConfigFileManager::getInstance().setFilename(this->configFile_, filename);
 
         // Parse bindings and create the ConfigValueContainers if necessary
         clearBindings();
         for (std::map<std::string, Button*>::const_iterator it = allButtons_.begin(); it != allButtons_.end(); ++it)
-            it->second->readConfigValue();
+            it->second->readConfigValue(this->configFile_);
 
         COUT(3) << "KeyBinder: Loading key bindings done." << std::endl;

code/branches/objecthierarchy/src/core/input/KeyBinder.h

@@ -44 +44 @@
 #include "InputCommands.h"
 #include "JoyStickDeviceNumberListener.h"
+#include "core/ConfigFileManager.h"
 
 namespace orxonox
@@ -59 +60 @@
         virtual ~KeyBinder();
 
-        void loadBindings(const std::string& filename);
+        void loadBindings(const std::string& filename, const std::string& defaultFilename);
         void clearBindings();
         bool setBinding(const std::string& binding, const std::string& name, bool bTemporary = false);
@@ -142 +143 @@
         float deriveTime_;
 
-        //! Config file used. "" in case of KeyDetector. Also indicates whether we've already loaded.
-        std::string configFile_;
+        //! Config file used. ConfigFileType::NoType in case of KeyDetector. Also indicates whether we've already loaded.
+        ConfigFileType configFile_;
 
     private:
         //##### ConfigValues #####
-        //! Filename of default keybindings.
-        std::string defaultKeybindings_;
         //! Whether to filter small value analog input
         bool bFilterAnalogNoise_;