void CompleteXDGMigration() {
fs::path sentinel = GetUserDataDir() / "MIGRATION_TO_XDG_IN_PROGRESS";
if (exists(sentinel)) {
fs::remove(sentinel);
// Update data dir in config file
const std::string options_save_dir = GetOptionsDB().Get<std::string>("save-dir");
const fs::path old_path = fs::path(getenv("HOME")) / ".freeorion";
if (fs::path(options_save_dir) == old_path)
GetOptionsDB().Set<std::string>("save-dir", GetUserDataDir().string());
}
}
wxString clStandardPaths::GetUserProjectTemplatesDir() const
{
#ifdef USE_POSIX_LAYOUT
wxFileName fn(GetUserDataDir() + wxT(INSTALL_DIR), "");
#else
wxFileName fn(GetUserDataDir(), "");
#endif
fn.AppendDir("templates");
fn.AppendDir("projects");
return fn.GetPath();
}
wxString clStandardPaths::GetUserProjectTemplatesDir() const
{
wxFileName fn(GetUserDataDir(), "");
fn.AppendDir("templates");
fn.AppendDir("projects");
return fn.GetPath();
}
fs::path GetPath(PathType path_type) {
switch (path_type) {
case PATH_BINARY:
return GetBinDir();
case PATH_RESOURCE:
return GetResourceDir();
case PATH_DATA_ROOT:
return GetRootDataDir();
case PATH_DATA_USER:
return GetUserDataDir();
case PATH_CONFIG:
return GetUserConfigDir();
case PATH_SAVE:
return GetSaveDir();
case PATH_TEMP:
return fs::temp_directory_path();
case PATH_PYTHON:
#if defined(FREEORION_MACOSX) || defined(FREEORION_WIN32)
return GetPythonHome();
#endif
case PATH_INVALID:
default:
ErrorLogger() << "Invalid path type " << path_type;
return fs::temp_directory_path();
}
}
// static member(s)
AIClientApp::AIClientApp(const std::vector<std::string>& args) :
m_player_name(""),
m_max_aggression(0)
{
if (args.size() < 2) {
std::cerr << "The AI client should not be executed directly! Run freeorion to start the game.";
ExitApp(1);
}
// read command line args
m_player_name = args.at(1);
if (args.size() >=3) {
m_max_aggression = boost::lexical_cast<int>(args.at(2));
}
// Force the log file if requested.
if (GetOptionsDB().Get<std::string>("log-file").empty()) {
const std::string AICLIENT_LOG_FILENAME((GetUserDataDir() / (m_player_name + ".log")).string());
GetOptionsDB().Set("log-file", AICLIENT_LOG_FILENAME);
}
// Force the log threshold if requested.
auto force_log_level = GetOptionsDB().Get<std::string>("log-level");
if (!force_log_level.empty())
OverrideAllLoggersThresholds(to_LogLevel(force_log_level));
InitLoggingSystem(GetOptionsDB().Get<std::string>("log-file"), "AI");
InitLoggingOptionsDBSystem();
InfoLogger() << FreeOrionVersionString();
DebugLogger() << PlayerName() + " ai client initialized.";
}
wxString GetConfigfileDir()
{
#ifdef __WXMSW__
return GetUserDataDir();
#else
return wxFormat( _T("%s/.%s") ) % wxStandardPaths::Get().GetUserConfigDir() % GetAppName(true);
#endif //__WXMSW__
}
// generate config file path
static void get_config_path(wxPathList &path, bool exists = true)
{
// local config dir first, then global
// locale-specific res first, then main
wxStandardPathsBase &stdp = wxStandardPaths::Get();
#define add_path(p) do { \
const wxString& s = stdp.p; \
wxFileName parent = wxFileName::DirName(s + wxT("//..")); \
parent.MakeAbsolute(); \
if((wxDirExists(s) && wxIsWritable(s)) || ((!exists || !wxDirExists(s)) && parent.IsDirWritable())) \
path.Add(s); \
} while(0)
// NOTE: this does not support XDG (freedesktop.org) paths
add_path(GetUserLocalDataDir());
add_path(GetUserDataDir());
add_path(GetLocalizedResourcesDir(wxGetApp().locale.GetCanonicalName()));
add_path(GetResourcesDir());
add_path(GetDataDir());
add_path(GetLocalDataDir());
add_path(GetPluginsDir());
}
void InitDirs(const std::string& argv0) {
if (g_initialized)
return;
/* store working dir. some implimentations get the value of initial_path
* from the value of current_path the first time initial_path is called,
* so it is necessary to call initial_path as soon as possible after
* starting the program, so that current_path doesn't have a chance to
* change before initial_path is initialized. */
fs::initial_path();
br_init(nullptr);
MigrateOldConfigDirsToXDGLocation();
fs::path cp = GetUserConfigDir();
if (!exists(cp)) {
fs::create_directories(cp);
}
fs::path p = GetUserDataDir();
if (!exists(p)) {
fs::create_directories(p);
}
p /= "save";
if (!exists(p)) {
fs::create_directories(p);
}
// Intentionally do not create the server save dir.
// The server save dir is publically accessible and should not be
// automatically created for the user.
InitBinDir(argv0);
g_initialized = true;
}
wxString wxStandardPathsBase::GetUserLocalDataDir() const
{
return GetUserDataDir();
}
void PATHMANAGER::Init(std::ostream & info_output, std::ostream & error_output)
{
typedef std::vector<fs::path> Paths;
// Set Ogre plugins dir
{
ogre_plugin_dir = "";
char *plugindir = getenv("OGRE_PLUGIN_DIR");
if (plugindir) {
ogre_plugin_dir = plugindir;
#ifndef _WIN32
} else if (fs::exists(fs::path(OGRE_PLUGIN_DIR) / "RenderSystem_GL.so")) {
ogre_plugin_dir = OGRE_PLUGIN_DIR;
#endif
} else {
#ifdef _WIN32
ogre_plugin_dir = ".";
#else
Paths dirs;
#if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(_M_X64)
dirs.push_back("/usr/local/lib64");
dirs.push_back("/usr/lib64");
#else
dirs.push_back("/usr/local/lib32");
dirs.push_back("/usr/lib32");
#endif
dirs.push_back("/usr/local");
dirs.push_back("/usr/lib");
// Loop through the paths and pick the first one that contain a plugin
for (Paths::const_iterator p = dirs.begin(); p != dirs.end(); ++p) {
if (fs::exists(*p / "OGRE/RenderSystem_GL.so")) {
ogre_plugin_dir = (*p / "OGRE").string();
break;
} else if (fs::exists(*p / "ogre/RenderSystem_GL.so")) {
ogre_plugin_dir = (*p / "ogre").string();
break;
}
}
#endif
}
}
fs::path shortDir = "stuntrally";
// Figure out the user's home directory
{
home_dir = "";
#ifndef _WIN32 // POSIX
char *homedir = getenv("HOME");
if (homedir == NULL)
{
home_dir = "/home/";
homedir = getenv("USER");
if (homedir == NULL) {
homedir = getenv("USERNAME");
if (homedir == NULL) {
error_output << "Could not find user's home directory!" << std::endl;
home_dir = "/tmp/";
}
}
}
#else // Windows
char *homedir = getenv("USERPROFILE");
if (homedir == NULL) homedir = "data"; // WIN 9x/Me
#endif
home_dir += homedir;
}
// Find user's config dir
#ifndef _WIN32 // POSIX
{
char const* conf = getenv("XDG_CONFIG_HOME");
if (conf) user_config_dir = (fs::path(conf) / "stuntrally").string();
else user_config_dir = (fs::path(home_dir) / ".config" / "stuntrally").string();
}
#else // Windows
{
// Open AppData directory
std::string str;
ITEMIDLIST* pidl;
char AppDir[MAX_PATH];
HRESULT hRes = SHGetSpecialFolderLocation(NULL, CSIDL_APPDATA|CSIDL_FLAG_CREATE , &pidl);
if (hRes == NOERROR)
{
SHGetPathFromIDList(pidl, AppDir);
int i;
for (i = 0; AppDir[i] != '\0'; i++) {
if (AppDir[i] == '\\') str += '/';
else str += AppDir[i];
}
user_config_dir = (fs::path(str) / "stuntrally").string();
}
}
#endif
// Create user's config dir
CreateDir(user_config_dir, error_output);
// Find user's data dir (for additional data)
#ifdef _WIN32
user_data_dir = user_config_dir; // APPDATA/stuntrally
#else
{
fs::path shareDir = SHARED_DATA_DIR;
char const* xdg_data_home = getenv("XDG_DATA_HOME");
user_data_dir = (xdg_data_home ? xdg_data_home / shortDir : fs::path(home_dir) / ".local" / shareDir).string();
}
#endif
// Create user's data dir and its children
CreateDir(user_data_dir, error_output);
CreateDir(GetTrackRecordsPath(), error_output);
CreateDir(GetScreenShotDir(), error_output);
CreateDir(GetTrackPathUser(), error_output); // user tracks
CreateDir(GetTrackPathUser()+"/_previews", error_output);
CreateDir(GetReplayPath(), error_output);
CreateDir(GetGhostsPath(), error_output);
// Find game data dir and defaults config dir
char *datadir = getenv("STUNTRALLY_DATA_ROOT");
if (datadir)
game_data_dir = std::string(datadir);
else
{ fs::path shareDir = SHARED_DATA_DIR;
Paths dirs;
// Adding users data dir
// TODO: Disabled for now until this is handled properly
//dirs.push_back(user_data_dir);
// Adding relative path from installed executable
dirs.push_back(execname().parent_path().parent_path() / shareDir);
// Adding relative path for running from sources
dirs.push_back(execname().parent_path().parent_path() / "data");
dirs.push_back(execname().parent_path().parent_path());
dirs.push_back(execname().parent_path() / "data");
dirs.push_back(execname().parent_path());
#ifndef _WIN32
// Adding XDG_DATA_DIRS
{
char const* xdg_data_dirs = getenv("XDG_DATA_DIRS");
std::istringstream iss(xdg_data_dirs ? xdg_data_dirs : "/usr/local/share/:/usr/share/");
for (std::string p; std::getline(iss, p, ':'); dirs.push_back(p / shortDir)) {}
}
#endif
// TODO: Adding path from config file
// Loop through the paths and pick the first one that contain some data
for (Paths::const_iterator p = dirs.begin(); p != dirs.end(); ++p) {
// Data dir
if (fs::exists(*p / "hud")) game_data_dir = p->string();
// Config dir
if (fs::exists(*p / "config"))
game_config_dir = (*p / "config").string();
// Check if both are found
if (!game_data_dir.empty() && !game_config_dir.empty()) break;
}
}
// Find cache dir
#ifdef _WIN32
cache_dir = user_config_dir + "/cache"; // APPDATA/stuntrally/cache
#else
char const* xdg_cache_home = getenv("XDG_CACHE_HOME");
cache_dir = (xdg_cache_home ? xdg_cache_home / shortDir : fs::path(home_dir) / ".cache" / shortDir).string();
#endif
// Create cache dir
CreateDir(cache_dir, error_output);
CreateDir(GetShaderCacheDir(), error_output);
// Print diagnostic info
std::stringstream out;
out << "--- Directories: ---" << ogre_plugin_dir << std::endl;
out << "Ogre plugin: " << ogre_plugin_dir << std::endl;
out << "Home: " << home_dir << std::endl;
out << "Default cfg: " << GetGameConfigDir() << std::endl;
out << "User cfg: " << GetUserConfigDir() << std::endl;
out << "Data: " << GetDataPath() << std::endl;
out << "User data: " << GetUserDataDir() << std::endl;
out << "Cache: " << GetCacheDir() << std::endl;
out << "Shader cache: " << GetShaderCacheDir() << std::endl;
out << "Log: " << GetLogDir() << std::endl;
info_output << out.str();
}
wxString clStandardPaths::GetUserLexersDir() const
{
wxFileName fn(GetUserDataDir(), "");
fn.AppendDir("lexers");
return fn.GetPath();
}