The final traces of boost has been eliminated

CMakeLists.txt

@@ -49,11 +49,6 @@ endif()
 find_package(Freetype REQUIRED)
 find_package(FreeImage REQUIRED)
 find_package(SDL2 REQUIRED)
-if(MSVC)
-find_package(Boost REQUIRED COMPONENTS system date_time)
-else()
-find_package(Boost REQUIRED COMPONENTS system filesystem date_time)
-endif()
 find_package(CURL REQUIRED)
 find_package(VLC REQUIRED)
 find_package(libCEC)
@@ -113,7 +108,6 @@ set(COMMON_INCLUDE_DIRS
     ${FREETYPE_INCLUDE_DIRS}
     ${FreeImage_INCLUDE_DIRS}
     ${SDL2_INCLUDE_DIR}
-    ${Boost_INCLUDE_DIRS}
     ${CURL_INCLUDE_DIR}
     ${VLC_INCLUDE_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}/external
@@ -157,17 +151,11 @@ endif()
 #define libraries and directories
 if(DEFINED BCMHOST)
     link_directories(
-        ${Boost_LIBRARY_DIRS}
         "/opt/vc/lib"
     )
-else()
-    link_directories(
-        ${Boost_LIBRARY_DIRS}
-    )
 endif()
 
 set(COMMON_LIBRARIES
-    ${Boost_LIBRARIES}
     ${FREETYPE_LIBRARIES}
     ${FreeImage_LIBRARIES}
     ${SDL2_LIBRARY}

CREDITS.md

@@ -23,9 +23,6 @@ FreeType
 cURL
 	http://curl.haxx.se/
 
-Boost
-	http://www.boost.org/
-
 nanosvg
 	https://github.com/memononen/nanosvg
 

README.md

@@ -9,13 +9,12 @@ Building
 
 EmulationStation uses some C++11 code, which means you'll need to use at least g++-4.7 on Linux, or VS2010 on Windows, to compile.
 
-EmulationStation has a few dependencies. For building, you'll need CMake, SDL2, Boost (System, Filesystem, DateTime, Locale), FreeImage, FreeType, and cURL.  You also should probably install the `fonts-droid` package which contains fallback fonts for Chinese/Japanese/Korean characters, but ES will still work fine without it (this package is only used at run-time).
+EmulationStation has a few dependencies. For building, you'll need CMake, SDL2, FreeImage, FreeType, and cURL.  You also should probably install the `fonts-droid` package which contains fallback fonts for Chinese/Japanese/Korean characters, but ES will still work fine without it (this package is only used at run-time).
 
 **On Debian/Ubuntu:**
 All of this be easily installed with apt-get:
 ```bash
-sudo apt-get install libsdl2-dev libboost-system-dev libboost-filesystem-dev libboost-date-time-dev \
+sudo apt-get install libsdl2-dev libfreeimage-dev libfreetype6-dev libcurl4-openssl-dev \
-  libboost-locale-dev libfreeimage-dev libfreetype6-dev libcurl4-openssl-dev \
   libasound2-dev libgl1-mesa-dev build-essential cmake fonts-droid \
   libvlc-dev libvlccore-dev vlc-nox
 ```
@@ -47,8 +46,6 @@ Complete Raspberry Pi build instructions at [emulationstation.org](http://emulat
 
 **On Windows:**
 
-[Boost](http://www.boost.org/users/download/) (you'll need to compile yourself or get the pre-compiled binaries)
-
 [FreeImage](http://downloads.sourceforge.net/freeimage/FreeImage3154Win32.zip)
 
 [FreeType2](http://download.savannah.gnu.org/releases/freetype/freetype-2.4.9.tar.bz2) (you'll need to compile)

es-app/CMakeLists.txt

@@ -155,8 +155,8 @@ SET(CPACK_RESOURCE_FILE README "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
 SET(CPACK_DEBIAN_PACKAGE_MAINTAINER "Alec Lofquist <allofquist@yahoo.com>")
 SET(CPACK_DEBIAN_PACKAGE_SECTION "misc")
 SET(CPACK_DEBIAN_PACKAGE_PRIORITY "extra")
-SET(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6, libsdl2-2.0-0, libboost-system${Boost_MAJOR_VERSION}.${Boost_MINOR_VERSION}.${Boost_SUBMINOR_VERSION}, libboost-filesystem${Boost_MAJOR_VERSION}.${Boost_MINOR_VERSION}.${Boost_SUBMINOR_VERSION}, libfreeimage3, libfreetype6, libcurl3, libasound2")
+SET(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6, libsdl2-2.0-0, libfreeimage3, libfreetype6, libcurl3, libasound2")
-SET(CPACK_DEBIAN_PACKAGE_BUILDS_DEPENDS "debhelper (>= 8.0.0), cmake, g++ (>= 4.8), libsdl2-dev, libboost-system-dev, libboost-filesystem-dev, libboost-date-time-dev, libfreeimage-dev, libfreetype6-dev, libcurl4-openssl-dev, libasound2-dev, libgl1-mesa-dev")
+SET(CPACK_DEBIAN_PACKAGE_BUILDS_DEPENDS "debhelper (>= 8.0.0), cmake, g++ (>= 4.8), libsdl2-dev, libfreeimage-dev, libfreetype6-dev, libcurl4-openssl-dev, libasound2-dev, libgl1-mesa-dev")
 
 SET(CPACK_PACKAGE_VENDOR "emulationstation.org")
 SET(CPACK_PACKAGE_VERSION "2.0.0~rc1")

es-app/src/CollectionSystemManager.cpp

@@ -330,7 +330,7 @@ bool CollectionSystemManager::isThemeCustomCollectionCompatible(std::vector<std:
 	auto set = themeSets.find(Settings::getInstance()->getString("ThemeSet"));
 	if(set != themeSets.cend())
 	{
-		std::string defaultThemeFilePath = set->second.path.string() + "/theme.xml";
+		std::string defaultThemeFilePath = set->second.path + "/theme.xml";
 		if (Utils::FileSystem::exists(defaultThemeFilePath))
 		{
 			return true;
@@ -879,11 +879,11 @@ std::vector<std::string> CollectionSystemManager::getSystemsFromTheme()
 		Settings::getInstance()->setString("ThemeSet", set->first);
 	}
 
-	boost::filesystem::path themePath = set->second.path;
+	std::string themePath = set->second.path;
 
-	if (Utils::FileSystem::exists(themePath.generic_string()))
+	if (Utils::FileSystem::exists(themePath))
 	{
-		Utils::FileSystem::stringList dirContent = Utils::FileSystem::getDirContent(themePath.generic_string());
+		Utils::FileSystem::stringList dirContent = Utils::FileSystem::getDirContent(themePath);
 
 		for (Utils::FileSystem::stringList::const_iterator it = dirContent.cbegin(); it != dirContent.cend(); ++it)
 		{
@@ -891,9 +891,9 @@ std::vector<std::string> CollectionSystemManager::getSystemsFromTheme()
 			{
 				//... here you have a directory
 				std::string folder = *it;
-				folder = folder.substr(themePath.string().size()+1);
+				folder = folder.substr(themePath.size()+1);
 
-				if(Utils::FileSystem::exists(set->second.getThemePath(folder).generic_string()))
+				if(Utils::FileSystem::exists(set->second.getThemePath(folder)))
 				{
 					systems.push_back(folder);
 				}
@@ -940,18 +940,18 @@ std::vector<std::string> CollectionSystemManager::getUnusedSystemsFromTheme()
 std::vector<std::string> CollectionSystemManager::getCollectionsFromConfigFolder()
 {
 	std::vector<std::string> systems;
-	boost::filesystem::path configPath = getCollectionsFolder();
+	std::string configPath = getCollectionsFolder();
 
-	if (Utils::FileSystem::exists(configPath.generic_string()))
+	if (Utils::FileSystem::exists(configPath))
 	{
-		Utils::FileSystem::stringList dirContent = Utils::FileSystem::getDirContent(configPath.generic_string());
+		Utils::FileSystem::stringList dirContent = Utils::FileSystem::getDirContent(configPath);
 		for (Utils::FileSystem::stringList::const_iterator it = dirContent.cbegin(); it != dirContent.cend(); ++it)
 		{
 			if (Utils::FileSystem::isRegularFile(*it))
 			{
 				// it's a file
 				std::string file = *it;
-				std::string filename = file.substr(configPath.string().size());
+				std::string filename = file.substr(configPath.size());
 
 				// need to confirm filename matches config format
 				if (filename != "custom-.cfg" && Utils::String::startsWith(filename, "custom-") && Utils::String::endsWith(filename, ".cfg"))
@@ -1013,8 +1013,7 @@ bool CollectionSystemManager::includeFileInAutoCollections(FileData* file)
 
 std::string getCustomCollectionConfigPath(std::string collectionName)
 {
-	boost::filesystem::path path = getCollectionsFolder() + "custom-" + collectionName + ".cfg";
+	return getCollectionsFolder() + "custom-" + collectionName + ".cfg";;
-	return path.generic_string();
 }
 
 std::string getCollectionsFolder()

es-app/src/FileData.cpp

@@ -12,8 +12,9 @@
 #include "SystemData.h"
 #include "VolumeControl.h"
 #include "Window.h"
+#include <assert.h>
 
-FileData::FileData(FileType type, const boost::filesystem::path& path, SystemEnvironmentData* envData, SystemData* system)
+FileData::FileData(FileType type, const std::string& path, SystemEnvironmentData* envData, SystemData* system)
 	: mType(type), mPath(path), mSystem(system), mEnvData(envData), mSourceFileData(NULL), mParent(NULL), metadata(type == GAME ? GAME_METADATA : FOLDER_METADATA) // metadata is REALLY set in the constructor!
 {
 	// metadata needs at least a name field (since that's what getName() will return)
@@ -35,7 +36,7 @@ FileData::~FileData()
 
 std::string FileData::getDisplayName() const
 {
-	std::string stem = mPath.stem().generic_string();
+	std::string stem = Utils::FileSystem::getStem(mPath);
 	if(mSystem && mSystem->hasPlatformId(PlatformIds::ARCADE) || mSystem->hasPlatformId(PlatformIds::NEOGEO))
 		stem = PlatformIds::mameTitleSearch(stem.c_str());
 
@@ -254,9 +255,9 @@ void FileData::launchGame(Window* window)
 
 	std::string command = mEnvData->mLaunchCommand;
 
-	const std::string rom = Utils::FileSystem::getEscapedPath(getPath().generic_string());
+	const std::string rom      = Utils::FileSystem::getEscapedPath(getPath());
-	const std::string basename = getPath().stem().string();
+	const std::string basename = Utils::FileSystem::getStem(getPath());
-	const std::string rom_raw = boost::filesystem::path(getPath()).make_preferred().string();
+	const std::string rom_raw  = getPath();
 
 	command = Utils::String::replace(command, "%ROM%", rom);
 	command = Utils::String::replace(command, "%BASENAME%", basename);

es-app/src/FileData.h

@@ -2,6 +2,7 @@
 #ifndef ES_APP_FILE_DATA_H
 #define ES_APP_FILE_DATA_H
 
+#include "utils/FileSystemUtil.h"
 #include "MetaData.h"
 #include <unordered_map>
 
@@ -32,12 +33,12 @@ FileType stringToFileType(const char* str);
 class FileData
 {
 public:
-	FileData(FileType type, const boost::filesystem::path& path, SystemEnvironmentData* envData, SystemData* system);
+	FileData(FileType type, const std::string& path, SystemEnvironmentData* envData, SystemData* system);
 	virtual ~FileData();
 
 	virtual const std::string& getName();
 	inline FileType getType() const { return mType; }
-	inline const boost::filesystem::path& getPath() const { return mPath; }
+	inline const std::string& getPath() const { return mPath; }
 	inline FileData* getParent() const { return mParent; }
 	inline const std::unordered_map<std::string, FileData*>& getChildrenByFilename() const { return mChildrenByFilename; }
 	inline const std::vector<FileData*>& getChildren() const { return mChildren; }
@@ -59,8 +60,8 @@ public:
 	virtual inline void refreshMetadata() { return; };
 
 	virtual std::string getKey();
-	inline std::string getFullPath() { return getPath().string(); };
+	inline std::string getFullPath() { return getPath(); };
-	inline std::string getFileName() { return getPath().filename().string(); };
+	inline std::string getFileName() { return Utils::FileSystem::getFileName(getPath()); };
 	virtual FileData* getSourceFileData();
 	inline std::string getSystemName() const { return mSystemName; };
 
@@ -94,7 +95,7 @@ protected:
 
 private:
 	FileType mType;
-	boost::filesystem::path mPath;
+	std::string mPath;
 	SystemEnvironmentData* mEnvData;
 	SystemData* mSystem;
 	std::unordered_map<std::string,FileData*> mChildrenByFilename;

es-app/src/Gamelist.cpp

@@ -8,12 +8,12 @@
 #include "SystemData.h"
 #include <pugixml/src/pugixml.hpp>
 
-FileData* findOrCreateFile(SystemData* system, const boost::filesystem::path& path, FileType type)
+FileData* findOrCreateFile(SystemData* system, const std::string& path, FileType type)
 {
 	// first, verify that path is within the system's root folder
 	FileData* root = system->getRootFolder();
 	bool contains = false;
-	boost::filesystem::path relative = Utils::FileSystem::removeCommonPath(path.generic_string(), root->getPath().generic_string(), contains);
+	std::string relative = Utils::FileSystem::removeCommonPath(path, root->getPath(), contains);
 
 	if(!contains)
 	{
@@ -21,21 +21,22 @@ FileData* findOrCreateFile(SystemData* system, const boost::filesystem::path& pa
 		return NULL;
 	}
 
-	auto path_it = relative.begin();
+	Utils::FileSystem::stringList pathList = Utils::FileSystem::getPathList(relative);
+	auto path_it = pathList.begin();
 	FileData* treeNode = root;
 	bool found = false;
-	while(path_it != relative.end())
+	while(path_it != pathList.end())
 	{
 		const std::unordered_map<std::string, FileData*>& children = treeNode->getChildrenByFilename();
 
-		std::string key = path_it->string();
+		std::string key = *path_it;
 		found = children.find(key) != children.cend();
 		if (found) {
 			treeNode = children.at(key);
 		}
 
 		// this is the end
-		if(path_it == --relative.end())
+		if(path_it == --pathList.end())
 		{
 			if(found)
 				return treeNode;
@@ -62,7 +63,7 @@ FileData* findOrCreateFile(SystemData* system, const boost::filesystem::path& pa
 			}
 
 			// create missing folder
-			FileData* folder = new FileData(FOLDER, treeNode->getPath().stem() / *path_it, system->getSystemEnvData(), system);
+			FileData* folder = new FileData(FOLDER, Utils::FileSystem::getStem(treeNode->getPath()) + "/" + *path_it, system->getSystemEnvData(), system);
 			treeNode->addChild(folder);
 			treeNode = folder;
 		}
@@ -75,6 +76,7 @@ FileData* findOrCreateFile(SystemData* system, const boost::filesystem::path& pa
 
 void parseGamelist(SystemData* system)
 {
+	bool trustGamelist = Settings::getInstance()->getBool("ParseGamelistOnly");
 	std::string xmlpath = system->getGamelistPath(false);
 
 	if(!Utils::FileSystem::exists(xmlpath))
@@ -98,7 +100,7 @@ void parseGamelist(SystemData* system)
 		return;
 	}
 
-	boost::filesystem::path relativeTo = system->getStartPath();
+	std::string relativeTo = system->getStartPath();
 
 	const char* tagList[2] = { "game", "folder" };
 	FileType typeList[2] = { GAME, FOLDER };
@@ -108,9 +110,9 @@ void parseGamelist(SystemData* system)
 		FileType type = typeList[i];
 		for(pugi::xml_node fileNode = root.child(tag); fileNode; fileNode = fileNode.next_sibling(tag))
 		{
-			boost::filesystem::path path = Utils::FileSystem::resolveRelativePath(fileNode.child("path").text().get(), relativeTo.generic_string(), false);
+			const std::string path = Utils::FileSystem::resolveRelativePath(fileNode.child("path").text().get(), relativeTo, false);
 
-			if(!Utils::FileSystem::exists(path.generic_string()))
+			if(!trustGamelist && !Utils::FileSystem::exists(path))
 			{
 				LOG(LogWarning) << "File \"" << path << "\" does not exist! Ignoring.";
 				continue;
@@ -155,7 +157,7 @@ void addFileDataNode(pugi::xml_node& parent, const FileData* file, const char* t
 		//there's something useful in there so we'll keep the node, add the path
 
 		// try and make the path relative if we can so things still work if we change the rom folder location in the future
-		newNode.prepend_child("path").text().set(Utils::FileSystem::createRelativePath(file->getPath().generic_string(), system->getStartPath(), false).c_str());
+		newNode.prepend_child("path").text().set(Utils::FileSystem::createRelativePath(file->getPath(), system->getStartPath(), false).c_str());
 	}
 }
 
@@ -229,9 +231,11 @@ void updateGamelist(SystemData* system)
 					continue;
 				}
 
-				boost::filesystem::path nodePath = Utils::FileSystem::resolveRelativePath(pathNode.text().get(), system->getStartPath(), true);
+				std::string nodePath = Utils::FileSystem::resolveRelativePath(pathNode.text().get(), system->getStartPath(), true);
-				boost::filesystem::path gamePath((*fit)->getPath());
+				std::string gamePath = (*fit)->getPath();
-				if(nodePath == gamePath || (Utils::FileSystem::exists(nodePath.generic_string()) && Utils::FileSystem::exists(gamePath.generic_string()) && Utils::FileSystem::isEquivalent(nodePath.generic_string(), gamePath.generic_string())))
+				if(nodePath == gamePath || (Utils::FileSystem::exists(nodePath) &&
+				                            Utils::FileSystem::exists(gamePath) &&
+				                            Utils::FileSystem::isEquivalent(nodePath, gamePath)))
 				{
 					// found it
 					root.remove_child(fileNode);
@@ -248,8 +252,8 @@ void updateGamelist(SystemData* system)
 
 		if (numUpdated > 0) {
 			//make sure the folders leading up to this path exist (or the write will fail)
-			boost::filesystem::path xmlWritePath(system->getGamelistPath(true));
+			std::string xmlWritePath(system->getGamelistPath(true));
-			Utils::FileSystem::createDirectory(xmlWritePath.parent_path().generic_string());
+			Utils::FileSystem::createDirectory(Utils::FileSystem::getParent(xmlWritePath));
 
 			LOG(LogInfo) << "Added/Updated " << numUpdated << " entities in '" << xmlReadPath << "'";
 

es-app/src/MetaData.cpp

@@ -67,7 +67,7 @@ MetaDataList::MetaDataList(MetaDataListType type)
 }
 
 
-MetaDataList MetaDataList::createFromXML(MetaDataListType type, pugi::xml_node& node, const boost::filesystem::path& relativeTo)
+MetaDataList MetaDataList::createFromXML(MetaDataListType type, pugi::xml_node& node, const std::string& relativeTo)
 {
 	MetaDataList mdl(type);
 
@@ -82,7 +82,7 @@ MetaDataList MetaDataList::createFromXML(MetaDataListType type, pugi::xml_node&
 			std::string value = md.text().get();
 			if (iter->type == MD_PATH)
 			{
-				value = Utils::FileSystem::resolveRelativePath(value, relativeTo.generic_string(), true);
+				value = Utils::FileSystem::resolveRelativePath(value, relativeTo, true);
 			}
 			mdl.set(iter->key, value);
 		}else{
@@ -93,7 +93,7 @@ MetaDataList MetaDataList::createFromXML(MetaDataListType type, pugi::xml_node&
 	return mdl;
 }
 
-void MetaDataList::appendToXML(pugi::xml_node& parent, bool ignoreDefaults, const boost::filesystem::path& relativeTo) const
+void MetaDataList::appendToXML(pugi::xml_node& parent, bool ignoreDefaults, const std::string& relativeTo) const
 {
 	const std::vector<MetaDataDecl>& mdd = getMDD();
 
@@ -110,7 +110,7 @@ void MetaDataList::appendToXML(pugi::xml_node& parent, bool ignoreDefaults, cons
 			// try and make paths relative if we can
 			std::string value = mapIter->second;
 			if (mddIter->type == MD_PATH)
-				value = Utils::FileSystem::createRelativePath(value, relativeTo.generic_string(), true);
+				value = Utils::FileSystem::createRelativePath(value, relativeTo, true);
 
 			parent.append_child(mapIter->first.c_str()).text().set(value.c_str());
 		}

es-app/src/MetaData.h

@@ -2,8 +2,8 @@
 #ifndef ES_APP_META_DATA_H
 #define ES_APP_META_DATA_H
 
-#include <boost/filesystem/path.hpp>
 #include <map>
+#include <vector>
 
 namespace pugi { class xml_node; }
 
@@ -44,8 +44,8 @@ const std::vector<MetaDataDecl>& getMDDByType(MetaDataListType type);
 class MetaDataList
 {
 public:
-	static MetaDataList createFromXML(MetaDataListType type, pugi::xml_node& node, const boost::filesystem::path& relativeTo);
+	static MetaDataList createFromXML(MetaDataListType type, pugi::xml_node& node, const std::string& relativeTo);
-	void appendToXML(pugi::xml_node& parent, bool ignoreDefaults, const boost::filesystem::path& relativeTo) const;
+	void appendToXML(pugi::xml_node& parent, bool ignoreDefaults, const std::string& relativeTo) const;
 
 	MetaDataList(MetaDataListType type);
 	

es-app/src/SystemData.cpp

@@ -67,55 +67,40 @@ void SystemData::setIsGameSystemStatus()
 	mIsGameSystem = (mName != "retropie");
 }
 
-// test to see if a file is hidden
-bool isHidden(const boost::filesystem::path &filePath)
-{
-#ifdef WIN32
-	const DWORD Attributes = GetFileAttributes(filePath.generic_string().c_str());
-	return (Attributes != INVALID_FILE_ATTRIBUTES) && (Attributes & FILE_ATTRIBUTE_HIDDEN);
-#else
-	boost::filesystem::path::string_type fileName = filePath.filename().string();
-	return fileName[0] == '.';
-#endif
-}
-
 void SystemData::populateFolder(FileData* folder)
 {
-	const boost::filesystem::path& folderPath = folder->getPath();
+	const std::string& folderPath = folder->getPath();
-	if(!Utils::FileSystem::isDirectory(folderPath.generic_string()))
+	if(!Utils::FileSystem::isDirectory(folderPath))
 	{
 		LOG(LogWarning) << "Error - folder with path \"" << folderPath << "\" is not a directory!";
 		return;
 	}
 
-	const std::string folderStr = folderPath.generic_string();
-
 	//make sure that this isn't a symlink to a thing we already have
-	if(Utils::FileSystem::isSymlink(folderPath.generic_string()))
+	if(Utils::FileSystem::isSymlink(folderPath))
 	{
+		Utils::FileSystem::getCanonicalPath("/RetroGames/roms/nes/garbage/../smurf.nes");
+
 		//if this symlink resolves to somewhere that's at the beginning of our path, it's gonna recurse
-		if(folderStr.find(Utils::FileSystem::getCanonicalPath(folderPath.generic_string())) == 0)
+		if(folderPath.find(Utils::FileSystem::getCanonicalPath(folderPath)) == 0)
 		{
 			LOG(LogWarning) << "Skipping infinitely recursive symlink \"" << folderPath << "\"";
 			return;
 		}
 	}
 
-	boost::filesystem::path filePath;
+	std::string filePath;
 	std::string extension;
 	bool isGame;
 	bool showHidden = Settings::getInstance()->getBool("ShowHiddenFiles");
-	Utils::FileSystem::stringList dirContent = Utils::FileSystem::getDirContent(folderPath.generic_string());
+	Utils::FileSystem::stringList dirContent = Utils::FileSystem::getDirContent(folderPath);
 	for(Utils::FileSystem::stringList::const_iterator it = dirContent.cbegin(); it != dirContent.cend(); ++it)
 	{
 		filePath = *it;
 
-		if(filePath.stem().empty())
-			continue;
-
 		//this is a little complicated because we allow a list of extensions to be defined (delimited with a space)
 		//we first get the extension of the file itself:
-		extension = filePath.extension().string();
+		extension = Utils::FileSystem::getExtension(filePath);
 
 		//fyi, folders *can* also match the extension and be added as games - this is mostly just to support higan
 		//see issue #75: https://github.com/Aloshi/EmulationStation/issues/75
@@ -124,18 +109,18 @@ void SystemData::populateFolder(FileData* folder)
 		if(std::find(mEnvData->mSearchExtensions.cbegin(), mEnvData->mSearchExtensions.cend(), extension) != mEnvData->mSearchExtensions.cend())
 		{
 			// skip hidden files
-			if(!showHidden && isHidden(filePath))
+			if(!showHidden && Utils::FileSystem::isHidden(filePath))
 				continue;
 
-			FileData* newGame = new FileData(GAME, filePath.generic_string(), mEnvData, this);
+			FileData* newGame = new FileData(GAME, filePath, mEnvData, this);
 			folder->addChild(newGame);
 			isGame = true;
 		}
 
 		//add directories that also do not match an extension as folders
-		if(!isGame && Utils::FileSystem::isDirectory(filePath.generic_string()))
+		if(!isGame && Utils::FileSystem::isDirectory(filePath))
 		{
-			FileData* newFolder = new FileData(FOLDER, filePath.generic_string(), mEnvData, this);
+			FileData* newFolder = new FileData(FOLDER, filePath, mEnvData, this);
 			populateFolder(newFolder);
 
 			//ignore folders that do not contain games
@@ -261,8 +246,7 @@ bool SystemData::loadConfig()
 		}
 
 		//convert path to generic directory seperators
-		boost::filesystem::path genericPath(path);
+		path = Utils::FileSystem::getGenericPath(path);
-		path = genericPath.generic_string();
 
 		//expand home symbol if the startpath contains ~
 		if(path[0] == '~')
@@ -349,9 +333,9 @@ void SystemData::deleteSystems()
 
 std::string SystemData::getConfigPath(bool forWrite)
 {
-	boost::filesystem::path path = Utils::FileSystem::getHomePath() + "/.emulationstation/es_systems.cfg";
+	std::string path = Utils::FileSystem::getHomePath() + "/.emulationstation/es_systems.cfg";
-	if(forWrite || Utils::FileSystem::exists(path.generic_string()))
+	if(forWrite || Utils::FileSystem::exists(path))
-		return path.generic_string();
+		return path;
 
 	return "/etc/emulationstation/es_systems.cfg";
 }
@@ -386,17 +370,17 @@ SystemData* SystemData::getPrev() const
 
 std::string SystemData::getGamelistPath(bool forWrite) const
 {
-	boost::filesystem::path filePath;
+	std::string filePath;
 
-	filePath = mRootFolder->getPath() / "gamelist.xml";
+	filePath = mRootFolder->getPath() + "/gamelist.xml";
-	if(Utils::FileSystem::exists(filePath.generic_string()))
+	if(Utils::FileSystem::exists(filePath))
-		return filePath.generic_string();
+		return filePath;
 
 	filePath = Utils::FileSystem::getHomePath() + "/.emulationstation/gamelists/" + mName + "/gamelist.xml";
 	if(forWrite) // make sure the directory exists if we're going to write to it, or crashes will happen
-		Utils::FileSystem::createDirectory(filePath.parent_path().generic_string());
+		Utils::FileSystem::createDirectory(Utils::FileSystem::getParent(filePath));
-	if(forWrite || Utils::FileSystem::exists(filePath.generic_string()))
+	if(forWrite || Utils::FileSystem::exists(filePath))
-		return filePath.generic_string();
+		return filePath;
 
 	return "/etc/emulationstation/gamelists/" + mName + "/gamelist.xml";
 }
@@ -409,20 +393,20 @@ std::string SystemData::getThemePath() const
 	// 3. default system theme from currently selected theme set [CURRENT_THEME_PATH]/theme.xml
 
 	// first, check game folder
-	boost::filesystem::path localThemePath = mRootFolder->getPath() / "theme.xml";
+	std::string localThemePath = mRootFolder->getPath() + "/theme.xml";
-	if(Utils::FileSystem::exists(localThemePath.generic_string()))
+	if(Utils::FileSystem::exists(localThemePath))
-		return localThemePath.generic_string();
+		return localThemePath;
 
 	// not in game folder, try system theme in theme sets
 	localThemePath = ThemeData::getThemeFromCurrentSet(mThemeFolder);
 
-	if (Utils::FileSystem::exists(localThemePath.generic_string()))
+	if (Utils::FileSystem::exists(localThemePath))
-		return localThemePath.generic_string();
+		return localThemePath;
 
 	// not system theme, try default system theme in theme set
-	localThemePath = localThemePath.parent_path().parent_path() / "theme.xml";
+	localThemePath = Utils::FileSystem::getParent(Utils::FileSystem::getParent(localThemePath)) + "/theme.xml";
 
-	return localThemePath.generic_string();
+	return localThemePath;
 }
 
 bool SystemData::hasGamelist() const

es-app/src/SystemScreenSaver.cpp

@@ -16,6 +16,7 @@
 #include "SystemData.h"
 #include <pugixml/src/pugixml.hpp>
 #include <unordered_map>
+#include <time.h>
 
 #define FADE_TIME 			300
 

es-app/src/guis/GuiGameScraper.cpp

@@ -19,7 +19,7 @@ GuiGameScraper::GuiGameScraper(Window* window, ScraperSearchParams params, std::
 
 	// row 0 is a spacer
 
-	mGameName = std::make_shared<TextComponent>(mWindow, Utils::String::toUpper(mSearchParams.game->getPath().filename().generic_string()),
+	mGameName = std::make_shared<TextComponent>(mWindow, Utils::String::toUpper(Utils::FileSystem::getFileName(mSearchParams.game->getPath())),
 		Font::get(FONT_SIZE_MEDIUM), 0x777777FF, ALIGN_CENTER);
 	mGrid.setEntry(mGameName, Vector2i(0, 1), false, true);
 

es-app/src/guis/GuiGamelistOptions.cpp

@@ -194,7 +194,7 @@ void GuiGamelistOptions::openMetaDataEd()
 		};
 	}
 
-	mWindow->pushGui(new GuiMetaDataEd(mWindow, &file->metadata, file->metadata.getMDD(), p, file->getPath().filename().string(),
+	mWindow->pushGui(new GuiMetaDataEd(mWindow, &file->metadata, file->metadata.getMDD(), p, Utils::FileSystem::getFileName(file->getPath()),
 		std::bind(&IGameListView::onFileChanged, ViewController::get()->getGameListView(file->getSystem()).get(), file, FILE_METADATA_CHANGED), deleteBtnFunc));
 }
 

es-app/src/guis/GuiMetaDataEd.cpp

@@ -36,7 +36,7 @@ GuiMetaDataEd::GuiMetaDataEd(Window* window, MetaDataList* md, const std::vector
 	mHeaderGrid = std::make_shared<ComponentGrid>(mWindow, Vector2i(1, 5));
 
 	mTitle = std::make_shared<TextComponent>(mWindow, "EDIT METADATA", Font::get(FONT_SIZE_LARGE), 0x555555FF, ALIGN_CENTER);
-	mSubtitle = std::make_shared<TextComponent>(mWindow, Utils::String::toUpper(scraperParams.game->getPath().filename().generic_string()),
+	mSubtitle = std::make_shared<TextComponent>(mWindow, Utils::String::toUpper(Utils::FileSystem::getFileName(scraperParams.game->getPath())),
 		Font::get(FONT_SIZE_SMALL), 0x777777FF, ALIGN_CENTER);
 	mHeaderGrid->setEntry(mTitle, Vector2i(0, 1), false, true);
 	mHeaderGrid->setEntry(mSubtitle, Vector2i(0, 3), false, true);

es-app/src/guis/GuiScraperMulti.cpp

@@ -103,7 +103,7 @@ void GuiScraperMulti::doNextSearch()
 
 	// update subtitle
 	ss.str(""); // clear
-	ss << "GAME " << (mCurrentGame + 1) << " OF " << mTotalGames << " - " << Utils::String::toUpper(mSearchQueue.front().game->getPath().filename().string());
+	ss << "GAME " << (mCurrentGame + 1) << " OF " << mTotalGames << " - " << Utils::String::toUpper(Utils::FileSystem::getFileName(mSearchQueue.front().game->getPath()));
 	mSubtitle->setText(ss.str());
 
 	mSearchComp->search(mSearchQueue.front());

es-app/src/main.cpp

@@ -19,6 +19,7 @@
 #include <SDL_main.h>
 #include <SDL_timer.h>
 #include <iostream>
+#include <time.h>
 #ifdef WIN32
 #include <Windows.h>
 #endif
@@ -220,7 +221,6 @@ int main(int argc, char* argv[])
 	srand((unsigned int)time(NULL));
 
 	std::locale::global(std::locale("C"));
-	boost::filesystem::path::imbue(std::locale());
 
 	if(!parseArgs(argc, argv))
 		return 0;

es-app/src/scrapers/Scraper.cpp

@@ -1,10 +1,8 @@
 #include "scrapers/Scraper.h"
 
-#include "utils/FileSystemUtil.h"
 #include "FileData.h"
 #include "GamesDBScraper.h"
 #include "Log.h"
-#include "platform.h"
 #include "Settings.h"
 #include "SystemData.h"
 #include <FreeImage.h>
@@ -274,7 +272,7 @@ bool resizeImage(const std::string& path, int maxWidth, int maxHeight)
 std::string getSaveAsPath(const ScraperSearchParams& params, const std::string& suffix, const std::string& url)
 {
 	const std::string subdirectory = params.system->getName();
-	const std::string name = params.game->getPath().stem().generic_string() + "-" + suffix;
+	const std::string name = Utils::FileSystem::getStem(params.game->getPath()) + "-" + suffix;
 
 	std::string path = Utils::FileSystem::getHomePath() + "/.emulationstation/downloaded_images/";
 

es-app/src/scrapers/Scraper.h

@@ -5,7 +5,11 @@
 #include "AsyncHandle.h"
 #include "HttpReq.h"
 #include "MetaData.h"
+#include <functional>
+#include <memory>
 #include <queue>
+#include <utility>
+#include <assert.h>
 
 #define MAX_SCRAPER_RESULTS 7
 

es-app/src/views/gamelist/BasicGameListView.cpp

@@ -105,7 +105,7 @@ void BasicGameListView::launch(FileData* game)
 void BasicGameListView::remove(FileData *game, bool deleteFile)
 {
 	if (deleteFile)
-		Utils::FileSystem::removeFile(game->getPath().generic_string());  // actually delete the file on the filesystem
+		Utils::FileSystem::removeFile(game->getPath());  // actually delete the file on the filesystem
 	FileData* parent = game->getParent();
 	if (getCursor() == game)                     // Select next element in list, or prev if none
 	{

es-core/src/GuiComponent.cpp

@@ -6,6 +6,7 @@
 #include "Renderer.h"
 #include "ThemeData.h"
 #include "Window.h"
+#include <algorithm>
 
 GuiComponent::GuiComponent(Window* window) : mWindow(window), mParent(NULL), mOpacity(255),
 	mPosition(Vector3f::Zero()), mOrigin(Vector2f::Zero()), mRotationOrigin(0.5, 0.5),

es-core/src/HttpReq.h

@@ -35,7 +35,7 @@ public:
 		REQ_IN_PROGRESS,		//request is in progress
 		REQ_SUCCESS,			//request completed successfully, get it with getContent()
 
-		REQ_IO_ERROR,			//some boost::asio error happened, get it with getErrorMsg()
+		REQ_IO_ERROR,			//some error happened, get it with getErrorMsg()
 		REQ_BAD_STATUS_CODE,	//some invalid HTTP response status code happened (non-200)
 		REQ_INVALID_RESPONSE	//the HTTP response was invalid
 	};

es-core/src/ThemeData.cpp

@@ -7,6 +7,7 @@
 #include "platform.h"
 #include "Settings.h"
 #include <pugixml/src/pugixml.hpp>
+#include <algorithm>
 
 std::vector<std::string> ThemeData::sSupportedViews { { "system" }, { "basic" }, { "detailed" }, { "video" } };
 std::vector<std::string> ThemeData::sSupportedFeatures { { "video" }, { "carousel" }, { "z-index" } };
@@ -148,29 +149,6 @@ unsigned int getHexColor(const char* str)
 	return val;
 }
 
-// helper
-std::string resolvePath(const char* in, const boost::filesystem::path& relative)
-{
-	if(!in || in[0] == '\0')
-		return in;
-
-	boost::filesystem::path relPath = relative.parent_path();
-	
-	boost::filesystem::path path(in);
-	
-	// we use boost filesystem here instead of just string checks because 
-	// some directories could theoretically start with ~ or .
-	if(*path.begin() == "~")
-	{
-		path = Utils::FileSystem::getHomePath() + (in + 1);
-	}else if(*path.begin() == ".")
-	{
-		path = relPath / (in + 1);
-	}
-
-	return path.generic_string();
-}
-
 std::map<std::string, std::string> mVariables;
 
 std::string resolvePlaceholders(const char* in)
@@ -245,7 +223,7 @@ void ThemeData::parseIncludes(const pugi::xml_node& root)
 	for(pugi::xml_node node = root.child("include"); node; node = node.next_sibling("include"))
 	{
 		const char* relPath = node.text().get();
-		std::string path = resolvePath(relPath, mPaths.back());
+		std::string path = Utils::FileSystem::resolveRelativePath(relPath, mPaths.back(), true);
 		if(!ResourceManager::getInstance()->fileExists(path))
 			throw error << "Included file \"" << relPath << "\" not found! (resolved to \"" << path << "\")";
 
@@ -412,7 +390,7 @@ void ThemeData::parseElement(const pugi::xml_node& root, const std::map<std::str
 			break;
 		case PATH:
 		{
-			std::string path = resolvePath(str.c_str(), mPaths.back().string());
+			std::string path = Utils::FileSystem::resolveRelativePath(str, mPaths.back(), true);
 			if(!ResourceManager::getInstance()->fileExists(path))
 			{
 				std::stringstream ss;
@@ -535,17 +513,18 @@ std::map<std::string, ThemeSet> ThemeData::getThemeSets()
 	std::map<std::string, ThemeSet> sets;
 
 	static const size_t pathCount = 2;
-	boost::filesystem::path paths[pathCount] = { 
+	std::string paths[pathCount] =
+	{ 
 		"/etc/emulationstation/themes", 
 		Utils::FileSystem::getHomePath() + "/.emulationstation/themes" 
 	};
 
 	for(size_t i = 0; i < pathCount; i++)
 	{
-		if(!Utils::FileSystem::isDirectory(paths[i].generic_string()))
+		if(!Utils::FileSystem::isDirectory(paths[i]))
 			continue;
 
-		Utils::FileSystem::stringList dirContent = Utils::FileSystem::getDirContent(paths[i].generic_string());
+		Utils::FileSystem::stringList dirContent = Utils::FileSystem::getDirContent(paths[i]);
 
 		for(Utils::FileSystem::stringList::const_iterator it = dirContent.cbegin(); it != dirContent.cend(); ++it)
 		{
@@ -560,9 +539,9 @@ std::map<std::string, ThemeSet> ThemeData::getThemeSets()
 	return sets;
 }
 
-boost::filesystem::path ThemeData::getThemeFromCurrentSet(const std::string& system)
+std::string ThemeData::getThemeFromCurrentSet(const std::string& system)
 {
-	auto themeSets = ThemeData::getThemeSets();
+	std::map<std::string, ThemeSet> themeSets = ThemeData::getThemeSets();
 	if(themeSets.empty())
 	{
 		// no theme sets available

es-core/src/ThemeData.h

@@ -3,10 +3,12 @@
 #define ES_CORE_THEME_DATA_H
 
 #include "math/Vector2f.h"
-#include <boost/filesystem/path.hpp>
+#include "utils/FileSystemUtil.h"
 #include <deque>
 #include <map>
+#include <memory>
 #include <sstream>
+#include <vector>
 
 namespace pugi { class xml_node; }
 
@@ -53,11 +55,11 @@ public:
 	template<typename T>
 	friend ThemeException& operator<<(ThemeException& e, T msg);
 	
-	inline void setFiles(const std::deque<boost::filesystem::path>& deque)
+	inline void setFiles(const std::deque<std::string>& deque)
 	{
-		*this << "from theme \"" << deque.front().string() << "\"\n";
+		*this << "from theme \"" << deque.front() << "\"\n";
 		for(auto it = deque.cbegin() + 1; it != deque.cend(); it++)
-			*this << "  (from included file \"" << (*it).string() << "\")\n";
+			*this << "  (from included file \"" << (*it) << "\")\n";
 		*this << "    ";
 	}
 };
@@ -73,10 +75,10 @@ ThemeException& operator<<(ThemeException& e, T appendMsg)
 
 struct ThemeSet
 {
-	boost::filesystem::path path;
+	std::string path;
 
-	inline std::string getName() const { return path.stem().string(); }
+	inline std::string getName() const { return Utils::FileSystem::getStem(path); }
-	inline boost::filesystem::path getThemePath(const std::string& system) const { return path/system/"theme.xml"; }
+	inline std::string getThemePath(const std::string& system) const { return path + "/" + system + "/theme.xml"; }
 };
 
 class ThemeData
@@ -155,14 +157,14 @@ public:
 	static const std::shared_ptr<ThemeData>& getDefault();
 
 	static std::map<std::string, ThemeSet> getThemeSets();
-	static boost::filesystem::path getThemeFromCurrentSet(const std::string& system);
+	static std::string getThemeFromCurrentSet(const std::string& system);
 
 private:
 	static std::map< std::string, std::map<std::string, ElementPropertyType> > sElementMap;
 	static std::vector<std::string> sSupportedFeatures;
 	static std::vector<std::string> sSupportedViews;
 
-	std::deque<boost::filesystem::path> mPaths;
+	std::deque<std::string> mPaths;
 	float mVersion;
 
 	void parseFeatures(const pugi::xml_node& themeRoot);

es-core/src/Window.cpp

@@ -7,6 +7,7 @@
 #include "InputManager.h"
 #include "Log.h"
 #include "Renderer.h"
+#include <algorithm>
 #include <iomanip>
 
 Window::Window() : mNormalizeNextUpdate(false), mFrameTimeElapsed(0), mFrameCountElapsed(0), mAverageDeltaTime(10),

es-core/src/components/VideoComponent.cpp

@@ -101,8 +101,7 @@ void VideoComponent::onSizeChanged()
 bool VideoComponent::setVideo(std::string path)
 {
 	// Convert the path into a generic format
-	boost::filesystem::path fullPath = Utils::FileSystem::getCanonicalPath(path);
+	std::string fullPath = Utils::FileSystem::getCanonicalPath(path);
-	fullPath.make_preferred().native();
 
 	// Check that it's changed
 	if (fullPath == mVideoPath)
@@ -112,7 +111,7 @@ bool VideoComponent::setVideo(std::string path)
 	mVideoPath = fullPath;
 
 	// If the file exists then set the new video
-	if (!fullPath.empty() && ResourceManager::getInstance()->fileExists(fullPath.generic_string()))
+	if (!fullPath.empty() && ResourceManager::getInstance()->fileExists(fullPath))
 	{
 		// Return true to show that we are going to attempt to play a video
 		return true;

es-core/src/components/VideoComponent.h

@@ -4,7 +4,6 @@
 
 #include "components/ImageComponent.h"
 #include "GuiComponent.h"
-#include <boost/filesystem/path.hpp>
 #include <string>
 
 class TextureResource;
@@ -91,14 +90,14 @@ private:
 protected:
 	unsigned						mVideoWidth;
 	unsigned						mVideoHeight;
-	Vector2f					mTargetSize;
+	Vector2f						mTargetSize;
 	std::shared_ptr<TextureResource> mTexture;
 	float							mFadeIn;
 	std::string						mStaticImagePath;
 	ImageComponent					mStaticImage;
 
-	boost::filesystem::path			mVideoPath;
+	std::string						mVideoPath;
-	boost::filesystem::path			mPlayingVideoPath;
+	std::string						mPlayingVideoPath;
 	bool							mStartDelayed;
 	unsigned						mStartTime;
 	bool							mIsPlaying;

es-core/src/components/VideoPlayerComponent.cpp

@@ -6,6 +6,7 @@
 #include "Renderer.h"
 #include "Settings.h"
 #include <fcntl.h>
+#include <unistd.h>
 #include <wait.h>
 
 class VolumeControl

es-core/src/components/VideoVlcComponent.cpp

@@ -1,6 +1,7 @@
 #include "components/VideoVlcComponent.h"
 
 #include "resources/TextureResource.h"
+#include "utils/StringUtil.h"
 #include "PowerSaver.h"
 #include "Renderer.h"
 #include "Settings.h"
@@ -282,10 +283,9 @@ void VideoVlcComponent::startVideo()
 		mVideoHeight = 0;
 
 #ifdef WIN32
-		std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> wton;
+		std::string path(Utils::String::replace(mVideoPath, "/", "\\"));
-		std::string path = wton.to_bytes(mVideoPath.c_str());
 #else
-		std::string path(mVideoPath.c_str());
+		std::string path(mVideoPath);
 #endif
 		// Make sure we have a video path
 		if (mVLC && (path.size() > 0))

es-core/src/utils/FileSystemUtil.cpp

@@ -22,6 +22,21 @@ namespace Utils
 {
 	namespace FileSystem
 	{
+
+#if defined(_WIN32)
+		static std::string convertFromWideString(const std::wstring wstring)
+		{
+			int         numBytes = WideCharToMultiByte(CP_UTF8, 0, wstring.c_str(), (int)wstring.length(), nullptr, 0, nullptr, nullptr);
+			std::string string;
+
+			string.resize(numBytes);
+			WideCharToMultiByte(CP_UTF8, 0, wstring.c_str(), (int)wstring.length(), (char*)string.c_str(), numBytes, nullptr, nullptr);
+
+			return std::string(string);
+
+		} // convertFromWideString
+#endif // _WIN32
+
 		stringList getDirContent(const std::string& _path, const bool _recursive)
 		{
 			std::string path = getGenericPath(_path);
@@ -32,15 +47,16 @@ namespace Utils
 			{
 
 #if defined(_WIN32)
-				WIN32_FIND_DATA findData;
+				WIN32_FIND_DATAW findData;
-				HANDLE          hFind = FindFirstFile((path + "/*").c_str(), &findData);
+				std::string      wildcard = path + "/*";
+				HANDLE           hFind    = FindFirstFileW(std::wstring(wildcard.begin(), wildcard.end()).c_str(), &findData);
 
 				if(hFind != INVALID_HANDLE_VALUE)
 				{
 					// loop over all files in the directory
 					do
 					{
-						std::string name(findData.cFileName);
+						std::string name = convertFromWideString(findData.cFileName);
 
 						// ignore "." and ".."
 						if((name != ".") && (name != ".."))
@@ -52,7 +68,7 @@ namespace Utils
 								contentList.merge(getDirContent(fullName, true));
 						}
 					}
-					while(FindNextFile(hFind, &findData));
+					while(FindNextFileW(hFind, &findData));
 
 					FindClose(hFind);
 				}
@@ -93,6 +109,31 @@ namespace Utils
 
 		} // getDirContent
 
+		stringList getPathList(const std::string& _path)
+		{
+			stringList  pathList;
+			std::string path  = getGenericPath(_path);
+			size_t      start = 0;
+			size_t      end   = 0;
+
+			// split at '/'
+			while((end = path.find("/", start)) != std::string::npos)
+			{
+				if(end != start)
+					pathList.push_back(std::string(path, start, end - start));
+
+				start = end + 1;
+			}
+
+			// add last folder / file to pathList
+			if(start != path.size())
+				pathList.push_back(std::string(path, start, path.size() - start));
+
+			// return the path list
+			return pathList;
+
+		} // getPathList
+
 		std::string getHomePath()
 		{
 			static std::string path;
@@ -202,20 +243,7 @@ namespace Utils
 			bool scan = true;
 			while(scan)
 			{
-				stringList  pathList;
+				stringList pathList = getPathList(path);
-				size_t      start = 0;
-				size_t      end   = 0;
-
-				// split at '/'
-				while((end = path.find("/", start)) != std::string::npos)
-				{
-					pathList.push_back(std::string(path, start, end - start));
-					start = end + 1;
-				}
-
-				// add last folder / file to pathList
-				if(start != path.size())
-					pathList.push_back(std::string(path, start, path.size() - start));
 
 				path.clear();
 				scan = false;
@@ -356,12 +384,12 @@ namespace Utils
 				return path;
 
 			// replace '.' with relativeTo
-			if(path[0] == '.')
+			if((path[0] == '.') && (path[1] == '/'))
-				return (relativeTo + "/" + &(path[1]));
+				return (relativeTo + &(path[1]));
 
 			// replace '~' with homePath
-			if(_allowHome && (path[0] == '~'))
+			if(_allowHome && (path[0] == '~') && (path[1] == '/'))
-				return (getHomePath() + "/" + &(path[1]));
+				return (getHomePath() + &(path[1]));
 
 			// nothing to resolve
 			return path;
@@ -376,7 +404,7 @@ namespace Utils
 			if(contains)
 			{
 				// success
-				return ("." + path);
+				return ("./" + path);
 			}
 
 			if(_allowHome)
@@ -386,7 +414,7 @@ namespace Utils
 				if(contains)
 				{
 					// success
-					return ("~" + path);
+					return ("~/" + path);
 				}
 			}
 

es-core/src/utils/FileSystemUtil.h

@@ -12,6 +12,7 @@ namespace Utils
 		typedef std::list<std::string> stringList;
 
 		stringList  getDirContent      (const std::string& _path, const bool _recursive = false);
+		stringList  getPathList        (const std::string& _path);
 		std::string getHomePath        ();
 		std::string getCWDPath         ();
 		std::string getGenericPath     (const std::string& _path);