Changeset 10509 for code/branches/core7/src/libraries

Timestamp:

May 30, 2015, 12:22:27 PM (9 years ago)

Author:

landauf

Message:

moved static application paths (root, executable, modules) into new class named ApplicationPaths
moved configurable data paths (data, log, config) into new class named ConfigurablePaths
removed PathConfig

Location:

code/branches/core7/src/libraries

Files:

• core/ApplicationPaths.cc (copied) (copied from code/branches/core7/src/libraries/core/PathConfig.cc) (7 diffs)
• core/ApplicationPaths.h (copied) (copied from code/branches/core7/src/libraries/core/PathConfig.h) (8 diffs)
• core/CMakeLists.txt (modified) (3 diffs)
• core/ConfigurablePaths.cc (moved) (moved from code/branches/core7/src/libraries/core/PathConfig.cc) (6 diffs)
• core/ConfigurablePaths.h (moved) (moved from code/branches/core7/src/libraries/core/PathConfig.h) (6 diffs)
• core/Core.cc (modified) (8 diffs)
• core/Core.h (modified) (1 diff)
• core/CoreConfig.cc (modified) (2 diffs)
• core/CorePrereqs.h (modified) (3 diffs)
• core/GUIManager.cc (modified) (2 diffs)
• core/GraphicsManager.cc (modified) (6 diffs)
• core/Language.cc (modified) (4 diffs)
• core/command/Shell.cc (modified) (3 diffs)
• core/command/TclBind.cc (modified) (2 diffs)
• core/commandline/CommandLineParser.cc (modified) (1 diff)
• core/config/ConfigFile.cc (modified) (4 diffs)
• core/input/KeyBinder.cc (modified) (3 diffs)
• tools/ResourceLocation.cc (modified) (2 diffs)

code/branches/core7/src/libraries/core/ApplicationPaths.cc

@@ -27 +27 @@
  */
 
-#include "PathConfig.h"
+#include "ApplicationPaths.h"
 
 #include <cassert>
@@ -53 +53 @@
 #include "util/Output.h"
 #include "util/Exception.h"
-#include "commandline/CommandLineIncludes.h"
 
 // Differentiate Boost Filesystem v2 and v3
@@ -59 +58 @@
 #  define BF_LEAF leaf
 #  define BF_GENERIC_STRING string
-#  define BF_NATIVE_STRING file_string
 #else
 #  define BF_LEAF path().filename().string
 #  define BF_GENERIC_STRING generic_string
-#  define BF_NATIVE_STRING string
 #endif
 
@@ -71 +68 @@
 
     //! Static pointer to the singleton
-    PathConfig* PathConfig::singletonPtr_s  = 0;
-
-    SetCommandLineArgument(externalDataPath, "").information("Path to the external data files");
-    SetCommandLineArgument(writingPathSuffix, "").information("Additional subfolder for config and log files");
-
-    PathConfig::PathConfig()
+    ApplicationPaths* ApplicationPaths::singletonPtr_s  = 0;
+
+    ApplicationPaths::ApplicationPaths()
         : rootPath_(*(new bf::path()))
         , executablePath_(*(new bf::path()))
         , modulePath_(*(new bf::path()))
-        , dataPath_(*(new bf::path()))
-        , externalDataPath_(*(new bf::path()))
-        , configPath_(*(new bf::path()))
-        , logPath_(*(new bf::path()))
         , bBuildDirectoryRun_(false)
     {
@@ -138 +128 @@
         {
             orxout(internal_info) << "Running from the build tree." << endl;
-            PathConfig::bBuildDirectoryRun_ = true;
+            ApplicationPaths::bBuildDirectoryRun_ = true;
             modulePath_ = specialConfig::moduleDevDirectory;
         }
@@ -167 +157 @@
     }
 
-    PathConfig::~PathConfig()
+    ApplicationPaths::~ApplicationPaths()
     {
         delete &rootPath_;
         delete &executablePath_;
         delete &modulePath_;
-        delete &dataPath_;
-        delete &externalDataPath_;
-        delete &configPath_;
-        delete &logPath_;
-    }
-
-    void PathConfig::setConfigurablePaths()
-    {
-        if (bBuildDirectoryRun_)
-        {
-            dataPath_         = specialConfig::dataDevDirectory;
-            configPath_       = specialConfig::configDevDirectory;
-            logPath_          = specialConfig::logDevDirectory;
-
-            // Check for data path override by the command line
-            if (!CommandLineParser::getArgument("externalDataPath")->hasDefaultValue())
-                externalDataPath_ = CommandLineParser::getValue("externalDataPath").get<std::string>();
-            else
-                externalDataPath_ = specialConfig::externalDataDevDirectory;
-        }
-        else
-        {
-
-#ifdef INSTALL_COPYABLE // --> relative paths
-
-            // Using paths relative to the install prefix, complete them
-            dataPath_   = rootPath_ / specialConfig::defaultDataPath;
-            configPath_ = rootPath_ / specialConfig::defaultConfigPath;
-            logPath_    = rootPath_ / specialConfig::defaultLogPath;
-
-#else
-
-            dataPath_  = specialConfig::dataInstallDirectory;
-
-            // Get user directory
-#ifdef ORXONOX_PLATFORM_UNIX
-            char* userDataPathPtr(getenv("HOME"));
-#else
-            char* userDataPathPtr(getenv("APPDATA"));
-#endif
-            if (userDataPathPtr == NULL)
-                ThrowException(General, "Could not retrieve user data path.");
-            bf::path userDataPath(userDataPathPtr);
-            userDataPath /= ".orxonox";
-
-            configPath_ = userDataPath / specialConfig::defaultConfigPath;
-            logPath_    = userDataPath / specialConfig::defaultLogPath;
-
-#endif
-
-        }
-
-        // Option to put all the config and log files in a separate folder
-        if (!CommandLineParser::getArgument("writingPathSuffix")->hasDefaultValue())
-        {
-            const std::string& directory(CommandLineParser::getValue("writingPathSuffix").get<std::string>());
-            configPath_ = configPath_ / directory;
-            logPath_    = logPath_    / directory;
-        }
-
-        // Create directories to avoid problems when opening files in non existent folders.
-        std::vector<std::pair<bf::path, std::string> > directories;
-        directories.push_back(std::make_pair(bf::path(configPath_), std::string("config")));
-        directories.push_back(std::make_pair(bf::path(logPath_), std::string("log")));
-
-        for (std::vector<std::pair<bf::path, std::string> >::iterator it = directories.begin();
-            it != directories.end(); ++it)
-        {
-            if (bf::exists(it->first) && !bf::is_directory(it->first))
-            {
-                ThrowException(General, std::string("The ") + it->second + " directory has been preoccupied by a file! \
-                                         Please remove " + it->first.BF_GENERIC_STRING());
-            }
-            if (bf::create_directories(it->first)) // function may not return true at all (bug?)
-            {
-                orxout(internal_info) << "Created " << it->second << " directory" << endl;
-            }
-        }
-    }
-
-    std::vector<std::string> PathConfig::getModulePaths()
+    }
+
+    std::vector<std::string> ApplicationPaths::getModulePaths()
     {
         std::vector<std::string> modulePaths;
@@ -288 +200 @@
     }
 
-    /*static*/ std::string PathConfig::getRootPathString()
+    /*static*/ std::string ApplicationPaths::getRootPathString()
     {
         return getInstance().rootPath_.BF_GENERIC_STRING() + '/';
     }
 
-    /*static*/ std::string PathConfig::getExecutablePathString()
+    /*static*/ std::string ApplicationPaths::getExecutablePathString()
     {
         return getInstance().executablePath_.BF_GENERIC_STRING() + '/';
     }
 
-    /*static*/ std::string PathConfig::getDataPathString()
-    {
-        return getInstance().dataPath_.BF_GENERIC_STRING() + '/';
-    }
-
-    /*static*/ std::string PathConfig::getExternalDataPathString()
-    {
-        return getInstance().externalDataPath_.BF_GENERIC_STRING() + '/';
-    }
-
-    /*static*/ std::string PathConfig::getConfigPathString()
-    {
-        return getInstance().configPath_.BF_GENERIC_STRING() + '/';
-    }
-
-    /*static*/ std::string PathConfig::getLogPathString()
-    {
-        return getInstance().logPath_.BF_GENERIC_STRING() + '/';
-    }
-
-    /*static*/ std::string PathConfig::getModulePathString()
+    /*static*/ std::string ApplicationPaths::getModulePathString()
     {
         return getInstance().modulePath_.BF_GENERIC_STRING() + '/';

code/branches/core7/src/libraries/core/ApplicationPaths.h

@@ -32 +32 @@
 */
 
-#ifndef _PathConfig_H__
-#define _PathConfig_H__
+#ifndef _ApplicationPaths_H__
+#define _ApplicationPaths_H__
 
 #include "CorePrereqs.h"
@@ -47 +47 @@
     /**
     @brief
-        The PathConfig class is a singleton used to configure different paths.
+        The ApplicationPaths class is a singleton which provides static paths of the application.
     @details
-        The class provides information about the data, config, log, executable,
-        root and module path.
+        The class provides information about the executable, root and module path.
         It determines those by the use of platform specific functions.
     @remarks
         Not all paths are always available:
         - root only when installed copyable
-        - externalData only for development builds in the build tree
     */
-    class _CoreExport PathConfig //tolua_export
-        : public Singleton<PathConfig>
+    class _CoreExport ApplicationPaths //tolua_export
+        : public Singleton<ApplicationPaths>
     { //tolua_export
-        friend class Singleton<PathConfig>;
-        friend class Core;
+        friend class Singleton<ApplicationPaths>;
 
         public:
@@ -67 +64 @@
             @brief
                 Retrieves the executable path and sets all hard coded fixed paths (currently only the module path)
-                Also checks for "orxonox_dev_build.keep_me" in the executable diretory.
+                Also checks for "orxonox_dev_build.keep_me" in the executable directory.
                 If found it means that this is not an installed run, hence we
                 don't write the logs and config files to ~/.orxonox
@@ -73 +70 @@
                 GeneralException
             */
-            PathConfig();
-            ~PathConfig();
+            ApplicationPaths();
+            ~ApplicationPaths();
 
             //! Returns the path to the root folder as boost::filesystem::path
@@ -82 +79 @@
             static const boost::filesystem::path& getExecutablePath()
                 { return getInstance().executablePath_; }
-            //! Returns the path to the data files as boost::filesystem::path
-            static const boost::filesystem::path& getDataPath()
-                { return getInstance().dataPath_; }
-            //! Returns the path to the external data files as boost::filesystem::path
-            static const boost::filesystem::path& getExternalDataPath()
-                { return getInstance().externalDataPath_; }
-            //! Returns the path to the config files as boost::filesystem::path
-            static const boost::filesystem::path& getConfigPath()
-                { return getInstance().configPath_; }
-            //! Returns the path to the log files as boost::filesystem::path
-            static const boost::filesystem::path& getLogPath()
-                { return getInstance().logPath_; }
             //! Returns the path to the modules as boost::filesystem::path
             static const boost::filesystem::path& getModulePath()
@@ -102 +87 @@
             //! Returns the path to the executable folder as std::string
             static std::string getExecutablePathString();
-            //! Returns the path to the data files as std::string
-            static std::string getDataPathString();
-            //! Returns the path to the external data files as std::string
-            static std::string getExternalDataPathString();
-            //! Returns the path to the config files as std::string
-            static std::string getConfigPathString(); //tolua_export
-            //! Returns the path to the log files as std::string
-            static std::string getLogPathString();
             //! Returns the path to the modules as std::string
             static std::string getModulePathString();
@@ -116 +93 @@
             static bool buildDirectoryRun() { return getInstance().bBuildDirectoryRun_; }
 
-        private:
-            PathConfig(const PathConfig&); //!< Don't use (undefined symbol)
-
-            /**
-            @brief
-                Sets config, log and media path and creates the folders if necessary.
-            @throws
-                GeneralException
-            */
-            void setConfigurablePaths();
             //! Returns a list with all modules declared by a *.module file in the module folder.
             std::vector<std::string> getModulePaths();
+
+        private:
+            ApplicationPaths(const ApplicationPaths&); //!< Don't use (undefined symbol)
 
             //! Path to the parent directory of the ones above if program was installed with relative paths
@@ -133 +103 @@
             boost::filesystem::path& executablePath_;        //!< Path to the executable
             boost::filesystem::path& modulePath_;            //!< Path to the modules
-            boost::filesystem::path& dataPath_;              //!< Path to the data files folder
-            boost::filesystem::path& externalDataPath_;      //!< Path to the external data files folder
-            boost::filesystem::path& configPath_;            //!< Path to the config files folder
-            boost::filesystem::path& logPath_;               //!< Path to the log files folder
 
             bool                     bBuildDirectoryRun_;    //!< True for runs in the build directory (not installed)
-            static PathConfig* singletonPtr_s;
+            static ApplicationPaths* singletonPtr_s;
     }; //tolua_export
 } //tolua_export
 
-#endif /* _PathConfig_H__ */
+#endif /* _ApplicationPaths_H__ */

code/branches/core7/src/libraries/core/CMakeLists.txt

@@ -55 +55 @@
   command/ArgumentCompletionFunctions.cc
   config/ConfigFile.cc
-  PathConfig.cc
+  ApplicationPaths.cc
+  Configurablepaths.cc
 END_BUILD_UNIT
 
@@ -84 +85 @@
     command/CommandExecutor.h
     config/SettingsConfigFile.h
+    ApplicationPaths.h
+    ConfigurablePaths.h
     Game.h
     GameMode.h
@@ -90 +93 @@
     Loader.h
     LuaState.h
-    PathConfig.h
     input/InputManager.h
     input/KeyBinder.h

code/branches/core7/src/libraries/core/ConfigurablePaths.cc

@@ -27 +27 @@
  */
 
-#include "PathConfig.h"
+#include "ConfigurablePaths.h"
 
 #include <cassert>
@@ -57 +57 @@
 // Differentiate Boost Filesystem v2 and v3
 #if (BOOST_FILESYSTEM_VERSION < 3)
-#  define BF_LEAF leaf
 #  define BF_GENERIC_STRING string
-#  define BF_NATIVE_STRING file_string
 #else
-#  define BF_LEAF path().filename().string
 #  define BF_GENERIC_STRING generic_string
-#  define BF_NATIVE_STRING string
 #endif
 
@@ -71 +67 @@
 
     //! Static pointer to the singleton
-    PathConfig* PathConfig::singletonPtr_s  = 0;
+    ConfigurablePaths* ConfigurablePaths::singletonPtr_s  = 0;
 
     SetCommandLineArgument(externalDataPath, "").information("Path to the external data files");
     SetCommandLineArgument(writingPathSuffix, "").information("Additional subfolder for config and log files");
 
-    PathConfig::PathConfig()
-        : rootPath_(*(new bf::path()))
-        , executablePath_(*(new bf::path()))
-        , modulePath_(*(new bf::path()))
-        , dataPath_(*(new bf::path()))
+    ConfigurablePaths::ConfigurablePaths()
+        : dataPath_(*(new bf::path()))
         , externalDataPath_(*(new bf::path()))
         , configPath_(*(new bf::path()))
         , logPath_(*(new bf::path()))
-        , bBuildDirectoryRun_(false)
     {
-        //////////////////////////
-        // FIND EXECUTABLE PATH //
-        //////////////////////////
-
-#ifdef ORXONOX_PLATFORM_WINDOWS
-        // get executable module
-        TCHAR buffer[1024];
-        if (GetModuleFileName(NULL, buffer, 1024) == 0)
-            ThrowException(General, "Could not retrieve executable path.");
-
-#elif defined(ORXONOX_PLATFORM_APPLE)
-        char buffer[1024];
-        uint32_t path_len = 1023;
-        if (_NSGetExecutablePath(buffer, &path_len))
-            ThrowException(General, "Could not retrieve executable path.");
-
-#else /* Linux */
-        /* written by Nicolai Haehnle <prefect_@gmx.net> */
-
-        /* Get our PID and build the name of the link in /proc */
-        char linkname[64]; /* /proc/<pid>/exe */
-        if (snprintf(linkname, sizeof(linkname), "/proc/%i/exe", getpid()) < 0)
-        {
-            /* This should only happen on large word systems. I'm not sure
-               what the proper response is here.
-               Since it really is an assert-like condition, aborting the
-               program seems to be in order. */
-            assert(false);
-        }
-
-        /* Now read the symbolic link */
-        char buffer[1024];
-        int ret;
-        ret = readlink(linkname, buffer, 1024);
-        /* In case of an error, leave the handling up to the caller */
-        if (ret == -1)
-            ThrowException(General, "Could not retrieve executable path.");
-
-        /* Ensure proper NUL termination */
-        buffer[ret] = 0;
-#endif
-
-        // Remove executable filename
-        executablePath_ = bf::path(buffer).branch_path();
-
-        /////////////////////
-        // SET MODULE PATH //
-        /////////////////////
-
-        if (bf::exists(executablePath_ / "orxonox_dev_build.keep_me"))
-        {
-            orxout(internal_info) << "Running from the build tree." << endl;
-            PathConfig::bBuildDirectoryRun_ = true;
-            modulePath_ = specialConfig::moduleDevDirectory;
-        }
-        else
-        {
-
-#ifdef INSTALL_COPYABLE // --> relative paths
-
-            // Also set the root path
-            bf::path relativeExecutablePath(specialConfig::defaultRuntimePath);
-            rootPath_ = executablePath_;
-            while (!bf::equivalent(rootPath_ / relativeExecutablePath, executablePath_) && !rootPath_.empty())
-                rootPath_ = rootPath_.branch_path();
-            if (rootPath_.empty())
-                ThrowException(General, "Could not derive a root directory. Might the binary installation directory contain '..' when taken relative to the installation prefix path?");
-
-            // Module path is fixed as well
-            modulePath_ = rootPath_ / specialConfig::defaultModulePath;
-
-#else
-
-            // There is no root path, so don't set it at all
-            // Module path is fixed as well
-            modulePath_ = specialConfig::moduleInstallDirectory;
-
-#endif
-        }
     }
 
-    PathConfig::~PathConfig()
+    ConfigurablePaths::~ConfigurablePaths()
     {
-        delete &rootPath_;
-        delete &executablePath_;
-        delete &modulePath_;
         delete &dataPath_;
         delete &externalDataPath_;
@@ -178 +88 @@
     }
 
-    void PathConfig::setConfigurablePaths()
+    void ConfigurablePaths::setConfigurablePaths(const ApplicationPaths& applicationPaths)
     {
-        if (bBuildDirectoryRun_)
+        if (applicationPaths.buildDirectoryRun())
         {
             dataPath_         = specialConfig::dataDevDirectory;
@@ -198 +108 @@
 
             // Using paths relative to the install prefix, complete them
-            dataPath_   = rootPath_ / specialConfig::defaultDataPath;
-            configPath_ = rootPath_ / specialConfig::defaultConfigPath;
-            logPath_    = rootPath_ / specialConfig::defaultLogPath;
+            dataPath_   = applicationPaths.getRootPath() / specialConfig::defaultDataPath;
+            configPath_ = applicationPaths.getRootPath() / specialConfig::defaultConfigPath;
+            logPath_    = applicationPaths.getRootPath() / specialConfig::defaultLogPath;
 
 #else
@@ -252 +162 @@
     }
 
-    std::vector<std::string> PathConfig::getModulePaths()
-    {
-        std::vector<std::string> modulePaths;
-
-        // We search for helper files with the following extension
-        const std::string& moduleextension = specialConfig::moduleExtension;
-        size_t moduleextensionlength = moduleextension.size();
-
-        // Make sure the path exists, otherwise don't load modules
-        if (!boost::filesystem::exists(modulePath_))
-            return modulePaths;
-
-        boost::filesystem::directory_iterator file(modulePath_);
-        boost::filesystem::directory_iterator end;
-
-        // Iterate through all files
-        while (file != end)
-        {
-            std::string filename = file->BF_LEAF();
-
-            // Check if the file ends with the extension in question
-            if (filename.size() > moduleextensionlength)
-            {
-                if (filename.substr(filename.size() - moduleextensionlength) == moduleextension)
-                {
-                    // We've found a helper file
-                    const std::string& library = filename.substr(0, filename.size() - moduleextensionlength);
-                    modulePaths.push_back(getModulePathString() + library);
-                }
-            }
-            ++file;
-        }
-
-        return modulePaths;
-    }
-
-    /*static*/ std::string PathConfig::getRootPathString()
-    {
-        return getInstance().rootPath_.BF_GENERIC_STRING() + '/';
-    }
-
-    /*static*/ std::string PathConfig::getExecutablePathString()
-    {
-        return getInstance().executablePath_.BF_GENERIC_STRING() + '/';
-    }
-
-    /*static*/ std::string PathConfig::getDataPathString()
+    /*static*/ std::string ConfigurablePaths::getDataPathString()
     {
         return getInstance().dataPath_.BF_GENERIC_STRING() + '/';
     }
 
-    /*static*/ std::string PathConfig::getExternalDataPathString()
+    /*static*/ std::string ConfigurablePaths::getExternalDataPathString()
     {
         return getInstance().externalDataPath_.BF_GENERIC_STRING() + '/';
     }
 
-    /*static*/ std::string PathConfig::getConfigPathString()
+    /*static*/ std::string ConfigurablePaths::getConfigPathString()
     {
         return getInstance().configPath_.BF_GENERIC_STRING() + '/';
     }
 
-    /*static*/ std::string PathConfig::getLogPathString()
+    /*static*/ std::string ConfigurablePaths::getLogPathString()
     {
         return getInstance().logPath_.BF_GENERIC_STRING() + '/';
     }
-
-    /*static*/ std::string PathConfig::getModulePathString()
-    {
-        return getInstance().modulePath_.BF_GENERIC_STRING() + '/';
-    }
 }

code/branches/core7/src/libraries/core/ConfigurablePaths.h

@@ -32 +32 @@
 */
 
-#ifndef _PathConfig_H__
-#define _PathConfig_H__
+#ifndef _ConfigurablePaths_H__
+#define _ConfigurablePaths_H__
 
 #include "CorePrereqs.h"
 
 #include <string>
-#include <vector>
 #include "util/Singleton.h"
 
@@ -47 +46 @@
     /**
     @brief
-        The PathConfig class is a singleton used to configure different paths.
+        The ConfigurablePaths class is a singleton used to configure different paths.
     @details
-        The class provides information about the data, config, log, executable,
-        root and module path.
-        It determines those by the use of platform specific functions.
+        The class provides information about the data, config, and log path.
     @remarks
         Not all paths are always available:
-        - root only when installed copyable
         - externalData only for development builds in the build tree
     */
-    class _CoreExport PathConfig //tolua_export
-        : public Singleton<PathConfig>
+    class _CoreExport ConfigurablePaths //tolua_export
+        : public Singleton<ConfigurablePaths>
     { //tolua_export
-        friend class Singleton<PathConfig>;
-        friend class Core;
+        friend class Singleton<ConfigurablePaths>;
 
         public:
-            /**
-            @brief
-                Retrieves the executable path and sets all hard coded fixed paths (currently only the module path)
-                Also checks for "orxonox_dev_build.keep_me" in the executable diretory.
-                If found it means that this is not an installed run, hence we
-                don't write the logs and config files to ~/.orxonox
-            @throw
-                GeneralException
-            */
-            PathConfig();
-            ~PathConfig();
+            ConfigurablePaths();
+            ~ConfigurablePaths();
 
-            //! Returns the path to the root folder as boost::filesystem::path
-            static const boost::filesystem::path& getRootPath()
-                { return getInstance().rootPath_; }
-            //! Returns the path to the executable folder as boost::filesystem::path
-            static const boost::filesystem::path& getExecutablePath()
-                { return getInstance().executablePath_; }
             //! Returns the path to the data files as boost::filesystem::path
             static const boost::filesystem::path& getDataPath()
@@ -94 +74 @@
             static const boost::filesystem::path& getLogPath()
                 { return getInstance().logPath_; }
-            //! Returns the path to the modules as boost::filesystem::path
-            static const boost::filesystem::path& getModulePath()
-                { return getInstance().modulePath_; }
 
-            //! Returns the path to the root folder as std::string
-            static std::string getRootPathString();
-            //! Returns the path to the executable folder as std::string
-            static std::string getExecutablePathString();
             //! Returns the path to the data files as std::string
             static std::string getDataPathString();
@@ -110 +83 @@
             //! Returns the path to the log files as std::string
             static std::string getLogPathString();
-            //! Returns the path to the modules as std::string
-            static std::string getModulePathString();
-
-            //! Return true for runs in the build directory (not installed)
-            static bool buildDirectoryRun() { return getInstance().bBuildDirectoryRun_; }
-
-        private:
-            PathConfig(const PathConfig&); //!< Don't use (undefined symbol)
 
             /**
@@ -125 +90 @@
                 GeneralException
             */
-            void setConfigurablePaths();
-            //! Returns a list with all modules declared by a *.module file in the module folder.
-            std::vector<std::string> getModulePaths();
+            void setConfigurablePaths(const ApplicationPaths& applicationPaths);
 
-            //! Path to the parent directory of the ones above if program was installed with relative paths
-            boost::filesystem::path& rootPath_;
-            boost::filesystem::path& executablePath_;        //!< Path to the executable
-            boost::filesystem::path& modulePath_;            //!< Path to the modules
+        private:
+            ConfigurablePaths(const ConfigurablePaths&); //!< Don't use (undefined symbol)
+
             boost::filesystem::path& dataPath_;              //!< Path to the data files folder
             boost::filesystem::path& externalDataPath_;      //!< Path to the external data files folder
@@ -138 +100 @@
             boost::filesystem::path& logPath_;               //!< Path to the log files folder
 
-            bool                     bBuildDirectoryRun_;    //!< True for runs in the build directory (not installed)
-            static PathConfig* singletonPtr_s;
+            static ConfigurablePaths* singletonPtr_s;
     }; //tolua_export
 } //tolua_export
 
-#endif /* _PathConfig_H__ */
+#endif /* _ConfigurablePaths_H__ */

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

@@ -59 +59 @@
 #include "core/singleton/ScopedSingletonIncludes.h"
 #include "util/SignalHandler.h"
-#include "PathConfig.h"
+#include "ApplicationPaths.h"
+#include "ConfigurablePaths.h"
 #include "commandline/CommandLineIncludes.h"
 #include "config/ConfigFileManager.h"
@@ -94 +95 @@
 
     Core::Core(const std::string& cmdLine)
-        : pathConfig_(NULL)
+        : applicationPaths_(NULL)
+        , configurablePaths_(NULL)
         , dynLibManager_(NULL)
         , signalHandler_(NULL)
@@ -115 +117 @@
 
         // Set the hard coded fixed paths
-        this->pathConfig_ = new PathConfig();
+        this->applicationPaths_ = new ApplicationPaths();
 
         // Create a new dynamic library manager
@@ -122 +124 @@
         // Load modules
         orxout(internal_info) << "Loading modules:" << endl;
-        const std::vector<std::string>& modulePaths = this->pathConfig_->getModulePaths();
+        const std::vector<std::string>& modulePaths = ApplicationPaths::getInstance().getModulePaths();
         for (std::vector<std::string>::const_iterator it = modulePaths.begin(); it != modulePaths.end(); ++it)
         {
@@ -146 +148 @@
 
         // Set configurable paths like log, config and media
-        this->pathConfig_->setConfigurablePaths();
-
-        orxout(internal_info) << "Root path:       " << PathConfig::getRootPathString() << endl;
-        orxout(internal_info) << "Executable path: " << PathConfig::getExecutablePathString() << endl;
-        orxout(internal_info) << "Data path:       " << PathConfig::getDataPathString() << endl;
-        orxout(internal_info) << "Ext. data path:  " << PathConfig::getExternalDataPathString() << endl;
-        orxout(internal_info) << "Config path:     " << PathConfig::getConfigPathString() << endl;
-        orxout(internal_info) << "Log path:        " << PathConfig::getLogPathString() << endl;
-        orxout(internal_info) << "Modules path:    " << PathConfig::getModulePathString() << endl;
-
-        // create a signal handler (only active for Linux)
+        this->configurablePaths_ = new ConfigurablePaths();
+        this->configurablePaths_->setConfigurablePaths(ApplicationPaths::getInstance());
+
+        orxout(internal_info) << "Root path:       " << ApplicationPaths::getRootPathString() << endl;
+        orxout(internal_info) << "Executable path: " << ApplicationPaths::getExecutablePathString() << endl;
+        orxout(internal_info) << "Modules path:    " << ApplicationPaths::getModulePathString() << endl;
+
+        orxout(internal_info) << "Data path:       " << ConfigurablePaths::getDataPathString() << endl;
+        orxout(internal_info) << "Ext. data path:  " << ConfigurablePaths::getExternalDataPathString() << endl;
+        orxout(internal_info) << "Config path:     " << ConfigurablePaths::getConfigPathString() << endl;
+        orxout(internal_info) << "Log path:        " << ConfigurablePaths::getLogPathString() << endl;
+
+        // create a signal handler
         // This call is placed as soon as possible, but after the directories are set
         this->signalHandler_ = new SignalHandler();
-        this->signalHandler_->doCatch(PathConfig::getExecutablePathString(), PathConfig::getLogPathString() + "orxonox_crash.log");
+        this->signalHandler_->doCatch(ApplicationPaths::getExecutablePathString(), ConfigurablePaths::getLogPathString() + "orxonox_crash.log");
 
 #ifdef ORXONOX_PLATFORM_WINDOWS
@@ -186 +190 @@
 
         // Set the correct log path and rewrite the log file with the correct log levels
-        OutputManager::getInstance().getLogWriter()->setLogDirectory(PathConfig::getLogPathString());
+        OutputManager::getInstance().getLogWriter()->setLogDirectory(ConfigurablePaths::getLogPathString());
 
 #if !defined(ORXONOX_PLATFORM_APPLE) && !defined(ORXONOX_USE_WINMAIN)
@@ -209 +213 @@
 
         // initialise Tcl
-        this->tclBind_ = new TclBind(PathConfig::getDataPathString());
+        this->tclBind_ = new TclBind(ConfigurablePaths::getDataPathString());
         this->tclThreadManager_ = new TclThreadManager(tclBind_->getTclInterpreter());
 
@@ -255 +259 @@
         safeObjectDelete(&signalHandler_);
         safeObjectDelete(&dynLibManager_);
-        safeObjectDelete(&pathConfig_);
+        safeObjectDelete(&configurablePaths_);
+        safeObjectDelete(&applicationPaths_);
 
         orxout(internal_status) << "finished destroying Core object" << endl;

code/branches/core7/src/libraries/core/Core.h

@@ -91 +91 @@
             void setThreadAffinity(int limitToCPU);
 
-            PathConfig*               pathConfig_;
+            ApplicationPaths*         applicationPaths_;
+            ConfigurablePaths*        configurablePaths_;
             DynLibManager*            dynLibManager_;
             SignalHandler*            signalHandler_;

code/branches/core7/src/libraries/core/CoreConfig.cc

@@ -34 +34 @@
 #include "core/config/ConfigValueIncludes.h"
 #include "core/Language.h"
-#include "core/PathConfig.h"
+#include "core/ApplicationPaths.h"
 
 namespace orxonox
@@ -72 +72 @@
             .callback(static_cast<BaseWriter*>(OutputManager::getInstance().getLogWriter()), &BaseWriter::changedConfigurableAdditionalContexts);
 
-        SetConfigValue(bDevMode_, PathConfig::buildDirectoryRun())
+        SetConfigValue(bDevMode_, ApplicationPaths::buildDirectoryRun())
             .description("Developer mode. If not set, hides some things from the user to not confuse him.")
             .callback(this, &CoreConfig::devModeChanged);

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

@@ -132 +132 @@
     T orxonox_cast(U*);
 
+    class ApplicationPaths;
     class BaseObject;
     template <class T>
@@ -152 +153 @@
     class ConfigFileSection;
     class Configurable;
+    class ConfigurablePaths;
     class ConfigValueContainer;
     class Context;
@@ -196 +198 @@
     class OrxonoxClass;
     class OrxonoxInterface;
-    class PathConfig;
     struct ResourceInfo;
     template <ScopeID::Value>

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

@@ -106 +106 @@
 #include "GraphicsManager.h"
 #include "LuaState.h"
-#include "PathConfig.h"
+#include "ConfigurablePaths.h"
 #include "Resource.h"
 #include "command/ConsoleCommandIncludes.h"
@@ -331 +331 @@
         // Create our own logger to specify the filepath
         std::auto_ptr<CEGUILogger> ceguiLogger(new CEGUILogger());
-        ceguiLogger->setLogFilename(PathConfig::getLogPathString() + "cegui.log");
+        ceguiLogger->setLogFilename(ConfigurablePaths::getLogPathString() + "cegui.log");
         ceguiLogger->setLoggingLevel(static_cast<CEGUI::LoggingLevel>(this->outputLevelCeguiLog_));
         this->ceguiLogger_ = ceguiLogger.release();

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

@@ -59 +59 @@
 #include "GUIManager.h"
 #include "Loader.h"
-#include "PathConfig.h"
+#include "ApplicationPaths.h"
+#include "ConfigurablePaths.h"
 #include "ViewportEventListener.h"
 #include "WindowEventListener.h"
@@ -113 +114 @@
 
         // At first, add the root paths of the data directories as resource locations
-        Ogre::ResourceGroupManager::getSingleton().addResourceLocation(PathConfig::getDataPathString(), "FileSystem");
+        Ogre::ResourceGroupManager::getSingleton().addResourceLocation(ConfigurablePaths::getDataPathString(), "FileSystem");
         // Load resources
         resources_.reset(new XMLFile("DefaultResources.oxr"));
@@ -120 +121 @@
 
         // Only for runs in the build directory (not installed)
-        if (PathConfig::buildDirectoryRun())
-            Ogre::ResourceGroupManager::getSingleton().addResourceLocation(PathConfig::getExternalDataPathString(), "FileSystem");
+        if (ApplicationPaths::buildDirectoryRun())
+            Ogre::ResourceGroupManager::getSingleton().addResourceLocation(ConfigurablePaths::getExternalDataPathString(), "FileSystem");
 
         extResources_.reset(new XMLFile("resources.oxr"));
@@ -220 +221 @@
         }
 
-        boost::filesystem::path ogreConfigFilepath(PathConfig::getConfigPath() / this->ogreConfigFile_);
-        boost::filesystem::path ogreLogFilepath(PathConfig::getLogPath() / this->ogreLogFile_);
+        boost::filesystem::path ogreConfigFilepath(ConfigurablePaths::getConfigPath() / this->ogreConfigFile_);
+        boost::filesystem::path ogreLogFilepath(ConfigurablePaths::getLogPath() / this->ogreLogFile_);
 
         // create a new logManager
@@ -260 +261 @@
         std::string pluginPath = specialConfig::ogrePluginsDirectory;
 #ifdef DEPENDENCY_PACKAGE_ENABLE
-        if (!PathConfig::buildDirectoryRun())
+        if (!ApplicationPaths::buildDirectoryRun())
         {
 #  if defined(ORXONOX_PLATFORM_WINDOWS)
-            pluginPath = PathConfig::getExecutablePathString();
+            pluginPath = ApplicationPaths::getExecutablePathString();
 #  elif defined(ORXONOX_PLATFORM_APPLE)
             // TODO: Where are the plugins being installed to?
-            pluginPath = PathConfig::getExecutablePathString();
+            pluginPath = ApplicationPaths::getExecutablePathString();
 #  endif
         }
@@ -559 +560 @@
     {
         assert(this->renderWindow_);
-        this->renderWindow_->writeContentsToTimestampedFile(PathConfig::getLogPathString() + "screenShot_", ".png");
+        this->renderWindow_->writeContentsToTimestampedFile(ConfigurablePaths::getLogPathString() + "screenShot_", ".png");
     }
 }

code/branches/core7/src/libraries/core/Language.cc

@@ -37 +37 @@
 #include "util/Output.h"
 #include "util/StringUtils.h"
-#include "PathConfig.h"
+#include "ConfigurablePaths.h"
 
 namespace orxonox
@@ -202 +202 @@
         orxout(internal_info, context::language) << "Read default language file." << endl;
 
-        const std::string& filepath = PathConfig::getConfigPathString() + getFilename(this->defaultLanguage_);
+        const std::string& filepath = ConfigurablePaths::getConfigPathString() + getFilename(this->defaultLanguage_);
 
         // This creates the file if it's not existing
@@ -252 +252 @@
         orxout(internal_info, context::language) << "Read translated language file (" << language << ")." << endl;
 
-        const std::string& filepath = PathConfig::getConfigPathString() + getFilename(language);
+        const std::string& filepath = ConfigurablePaths::getConfigPathString() + getFilename(language);
 
         // Open the file
@@ -305 +305 @@
         orxout(verbose, context::language) << "Write default language file." << endl;
 
-        const std::string& filepath = PathConfig::getConfigPathString() + getFilename(this->defaultLanguage_);
+        const std::string& filepath = ConfigurablePaths::getConfigPathString() + getFilename(this->defaultLanguage_);
 
         // Open the file

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

@@ -42 +42 @@
 #include "core/config/ConfigFileManager.h"
 #include "core/config/ConfigValueIncludes.h"
-#include "core/PathConfig.h"
+#include "core/ApplicationPaths.h"
 #include "core/input/InputBuffer.h"
 #include "CommandExecutor.h"
@@ -84 +84 @@
 
         // Choose the default level according to the path Orxonox was started (build directory or not)
-        OutputLevel defaultDebugLevel = (PathConfig::buildDirectoryRun() ? DefaultLogLevel::Dev : DefaultLogLevel::User);
+        OutputLevel defaultDebugLevel = (ApplicationPaths::buildDirectoryRun() ? DefaultLogLevel::Dev : DefaultLogLevel::User);
         this->setLevelMax(defaultDebugLevel);
 
@@ -164 +164 @@
     void Shell::devModeChanged(bool value)
     {
-        bool isNormal = (value == PathConfig::buildDirectoryRun());
+        bool isNormal = (value == ApplicationPaths::buildDirectoryRun());
         if (isNormal)
         {

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

@@ -37 +37 @@
 #include "util/Exception.h"
 #include "util/StringUtils.h"
-#include "core/PathConfig.h"
+#include "core/ApplicationPaths.h"
 #include "CommandExecutor.h"
 #include "ConsoleCommandIncludes.h"
@@ -143 +143 @@
     {
 #ifdef DEPENDENCY_PACKAGE_ENABLE
-        if (PathConfig::buildDirectoryRun())
+        if (ApplicationPaths::buildDirectoryRun())
             return (std::string(specialConfig::dependencyLibraryDirectory) + "/tcl");
         else
-            return (PathConfig::getRootPathString() + specialConfig::defaultLibraryPath + "/tcl");
+            return (ApplicationPaths::getRootPathString() + specialConfig::defaultLibraryPath + "/tcl");
 #else
         return "";

code/branches/core7/src/libraries/core/commandline/CommandLineParser.cc

@@ -37 +37 @@
 #include "util/StringUtils.h"
 #include "util/SubString.h"
-#include "core/PathConfig.h"
 
 namespace orxonox

code/branches/core7/src/libraries/core/config/ConfigFile.cc

@@ -38 +38 @@
 #include "util/Convert.h"
 #include "util/StringUtils.h"
-#include "core/PathConfig.h"
+#include "core/ConfigurablePaths.h"
 #include "ConfigFileEntryComment.h"
 #include "ConfigFileEntryValue.h"
@@ -81 +81 @@
         if (!filepath.is_complete())
         {
-            filepath = PathConfig::getConfigPath() / filepath;
+            filepath = ConfigurablePaths::getConfigPath() / filepath;
             if (this->bCopyFallbackFile_)
             {
@@ -87 +87 @@
                 if (!boost::filesystem::exists(filepath))
                 {
-                    boost::filesystem::path defaultFilepath(PathConfig::getDataPath() / DEFAULT_CONFIG_FOLDER / this->filename_);
+                    boost::filesystem::path defaultFilepath(ConfigurablePaths::getDataPath() / DEFAULT_CONFIG_FOLDER / this->filename_);
                     if (boost::filesystem::exists(defaultFilepath))
                     {
@@ -216 +216 @@
         boost::filesystem::path filepath(filename);
         if (!filepath.is_complete())
-            filepath = PathConfig::getConfigPath() / filename;
+            filepath = ConfigurablePaths::getConfigPath() / filename;
         std::ofstream file;
         file.open(filepath.string().c_str(), std::fstream::out);

code/branches/core7/src/libraries/core/input/KeyBinder.cc

@@ -37 +37 @@
 #include "core/config/ConfigValueIncludes.h"
 #include "core/config/ConfigFile.h"
-#include "core/PathConfig.h"
+#include "core/ApplicationPaths.h"
+#include "core/ConfigurablePaths.h"
 #include "InputCommands.h"
 #include "JoyStick.h"
@@ -255 +256 @@
         orxout(internal_info, context::input) << "KeyBinder: Loading key bindings..." << endl;
 
-        this->configFile_ = new ConfigFile(this->filename_, !PathConfig::buildDirectoryRun());
+        this->configFile_ = new ConfigFile(this->filename_, !ApplicationPaths::buildDirectoryRun());
         this->configFile_->load();
 
-        if (PathConfig::buildDirectoryRun())
+        if (ApplicationPaths::buildDirectoryRun())
         {
             // Dev users should have combined key bindings files
-            std::string defaultFilepath(PathConfig::getDataPathString() + ConfigFile::DEFAULT_CONFIG_FOLDER + '/' + this->filename_);
+            std::string defaultFilepath(ConfigurablePaths::getDataPathString() + ConfigFile::DEFAULT_CONFIG_FOLDER + '/' + this->filename_);
             std::ifstream file(defaultFilepath.c_str());
             if (file.is_open())
@@ -289 +290 @@
             addButtonToCommand(binding, it->second);
             std::string str = binding;
-            if (PathConfig::buildDirectoryRun() && binding.empty())
+            if (ApplicationPaths::buildDirectoryRun() && binding.empty())
                 str = "NoBinding";
             it->second->setBinding(this->configFile_, this->fallbackConfigFile_, binding, bTemporary);

code/branches/core7/src/libraries/tools/ResourceLocation.cc

@@ -35 +35 @@
 #include "util/Exception.h"
 #include "core/CoreIncludes.h"
-#include "core/PathConfig.h"
+#include "core/ApplicationPaths.h"
+#include "core/ConfigurablePaths.h"
 #include "core/XMLFile.h"
 #include "core/XMLPort.h"
@@ -74 +75 @@
         namespace bf = boost::filesystem;
         bf::path path;
-        if (bf::exists(PathConfig::getDataPath() / this->getPath()))
-            path = PathConfig::getDataPath() / this->getPath();
-        else if (PathConfig::buildDirectoryRun() && bf::exists(PathConfig::getExternalDataPath() / this->getPath()))
-            path = PathConfig::getExternalDataPath() / this->getPath();
+        if (bf::exists(ConfigurablePaths::getDataPath() / this->getPath()))
+            path = ConfigurablePaths::getDataPath() / this->getPath();
+        else if (ApplicationPaths::buildDirectoryRun() && bf::exists(ConfigurablePaths::getExternalDataPath() / this->getPath()))
+            path = ConfigurablePaths::getExternalDataPath() / this->getPath();
         else
         {