sdl_prefs.cpp

 
#include <iostream>
#include <fstream>
#if __has_include(<filesystem>)
#include <filesystem>
#include <utility>
namespace fs = std::filesystem;
#elif __has_include(<experimental/filesystem>)
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#error Could not find system header "<filesystem>" or "<experimental/filesystem>"
#endif
 
#include "sdl_prefs.hpp"
 
#include <winpr/path.h>
#include <winpr/config.h>
#include <winpr/json.h>
 
#include <freerdp/version.h>
#include <freerdp/settings.h>
#include <freerdp/utils/helpers.h>
 
SdlPref::WINPR_JSONPtr SdlPref::get(bool systemConfigOnly) const
{
  auto config = get_pref_file(systemConfigOnly);
  return { WINPR_JSON_ParseFromFile(config.c_str()), WINPR_JSON_Delete };
}
 
WINPR_JSON* SdlPref::get_item(const std::string& key, bool systemConfigOnly) const
{
  /* If we request a system setting or user settings are disabled */
  if (systemConfigOnly || !is_user_config_enabled())
    return get_item(_system_config, key);
 
  /* Get the user setting */
  auto res = get_item(_config, key);
 
  /* User setting does not exist, fall back to system setting */
  if (!res)
    res = get_item(_system_config, key);
  return res;
}
 
WINPR_JSON* SdlPref::get_item(const WINPR_JSONPtr& config, const std::string& key) const
{
  if (!config)
    return nullptr;
  return WINPR_JSON_GetObjectItem(config.get(), key.c_str());
}
 
bool SdlPref::get_bool(const WINPR_JSONPtr& config, const std::string& key, bool fallback) const
{
  auto item = get_item(config, key);
  if (!item || !WINPR_JSON_IsBool(item))
    return fallback;
  return WINPR_JSON_IsTrue(item);
}
 
bool SdlPref::is_user_config_enabled() const
{
  auto& config = _system_config;
  if (!config)
    return true;
  return get_bool(config, "isUserConfigEnabled", true);
}
 
std::string SdlPref::item_to_str(WINPR_JSON* item, const std::string& fallback)
{
  if (!item || !WINPR_JSON_IsString(item))
    return fallback;
  auto str = WINPR_JSON_GetStringValue(item);
  if (!str)
    return {};
  return str;
}
 
std::string SdlPref::get_string(const std::string& key, const std::string& fallback,
                                bool systemConfigOnly) const
{
  auto item = get_item(key, systemConfigOnly);
  return item_to_str(item, fallback);
}
 
bool SdlPref::get_bool(const std::string& key, bool fallback, bool systemConfigOnly) const
{
  auto& config = systemConfigOnly ? _system_config : _config;
  return get_bool(config, key, fallback);
}
 
int64_t SdlPref::get_int(const std::string& key, int64_t fallback, bool systemConfigOnly) const
{
  auto item = get_item(key, systemConfigOnly);
  if (!item || !WINPR_JSON_IsNumber(item))
    return fallback;
  auto val = WINPR_JSON_GetNumberValue(item);
  return static_cast<int64_t>(val);
}
 
std::vector<std::string> SdlPref::get_array(const std::string& key,
                                            const std::vector<std::string>& fallback,
                                            bool systemConfigOnly) const
{
  auto item = get_item(key, systemConfigOnly);
  if (!item || !WINPR_JSON_IsArray(item))
    return fallback;
 
  std::vector<std::string> values;
  for (size_t x = 0; x < WINPR_JSON_GetArraySize(item); x++)
  {
    auto cur = WINPR_JSON_GetArrayItem(item, x);
    values.push_back(item_to_str(cur));
  }
 
  return values;
}
 
void SdlPref::print_config_file_help(int version)
{
#if defined(WITH_WINPR_JSON)
  const std::string url = "https://wiki.libsdl.org/SDL" + std::to_string(version);
  std::cout << "GLOBAL CONFIGURATION FILE" << std::endl;
  std::cout << std::endl;
  std::cout << "  The SDL client supports some system defined configuration options."
            << std::endl;
  std::cout << "  Settings are stored in JSON format" << std::endl;
  std::cout << "  The location is a system configuration file. Location for current machine is "
            << SdlPref::instance()->get_pref_file(true) << std::endl;
  std::cout << std::endl;
  std::cout << "  The following configuration options are supported:" << std::endl;
  std::cout << std::endl;
  std::cout << "    isUserConfigEnabled" << std::endl;
  std::cout << "      Allows to enable/disable user specific configuration files." << std::endl;
  std::cout << "      Default enabled" << std::endl;
  std::cout << std::endl;
  std::cout << "    All options of the following user configuration file are also supported here."
            << std::endl;
  std::cout << std::endl;
 
  std::cout << "CONFIGURATION FILE" << std::endl;
  std::cout << std::endl;
  std::cout << "  The SDL client supports some user defined configuration options." << std::endl;
  std::cout << "  Settings are stored in JSON format" << std::endl;
  std::cout << "  The location is a per user file. Location for current user is "
            << SdlPref::instance()->get_pref_file() << std::endl;
  std::cout
      << "  The XDG_CONFIG_HOME environment variable can be used to override the base directory."
      << std::endl;
  std::cout << std::endl;
  std::cout << "  The following configuration options are supported:" << std::endl;
  std::cout << std::endl;
  std::cout << "    SDL_KeyModMask" << std::endl;
  std::cout << "      Defines the key combination required for SDL client shortcuts."
            << std::endl;
  std::cout << "      Default KMOD_RSHIFT" << std::endl;
  std::cout << "      An array of SDL_Keymod strings as defined at "
               ""
            << url << "/SDL_Keymod" << std::endl;
  std::cout << std::endl;
  std::cout << "    SDL_Fullscreen" << std::endl;
  std::cout << "      Toggles client fullscreen state." << std::endl;
  std::cout << "      Default SDL_SCANCODE_RETURN." << std::endl;
  std::cout << "      A string as "
               "defined at "
            << url << "/SDLScancodeLookup" << std::endl;
  std::cout << std::endl;
  std::cout << "    SDL_Minimize" << std::endl;
  std::cout << "      Minimizes client windows." << std::endl;
  std::cout << "      Default SDL_SCANCODE_M." << std::endl;
  std::cout << "      A string as "
               "defined at "
            << url << "/SDLScancodeLookup" << std::endl;
  std::cout << std::endl;
  std::cout << "    SDL_Resizeable" << std::endl;
  std::cout << "      Toggles local window resizeable state." << std::endl;
  std::cout << "      Default SDL_SCANCODE_R." << std::endl;
  std::cout << "      A string as "
               "defined at "
            << url << "/SDLScancodeLookup" << std::endl;
  std::cout << std::endl;
  std::cout << "    SDL_Grab" << std::endl;
  std::cout << "      Toggles keyboard and mouse grab state." << std::endl;
  std::cout << "      Default SDL_SCANCODE_G." << std::endl;
  std::cout << "      A string as "
               "defined at "
            << url << "/SDLScancodeLookup" << std::endl;
  std::cout << std::endl;
  std::cout << "    SDL_Disconnect" << std::endl;
  std::cout << "      Disconnects from the RDP session." << std::endl;
  std::cout << "      Default SDL_SCANCODE_D." << std::endl;
  std::cout << "      A string as defined at " << url << "/SDLScancodeLookup" << std::endl;
 
#endif
}
 
SdlPref::SdlPref(std::string file)
    : _name(std::move(file)), _system_name(get_default_file(true)), _config(get(false)),
      _system_config(get(true))
{
}
 
std::string SdlPref::get_pref_dir(bool systemConfigOnly)
{
  using CStringPtr = std::unique_ptr<char, decltype(&free)>;
  CStringPtr path(freerdp_GetConfigFilePath(systemConfigOnly, ""), free);
  if (!path)
    return {};
 
  fs::path config{ path.get() };
  return config.string();
}
 
std::string SdlPref::get_default_file(bool systemConfigOnly)
{
  fs::path config{ SdlPref::get_pref_dir(systemConfigOnly) };
  config /= "sdl-freerdp.json";
  return config.string();
}
 
std::shared_ptr<SdlPref> SdlPref::instance(const std::string& name)
{
  static std::shared_ptr<SdlPref> _instance;
  if (!_instance || (_instance->get_pref_file() != name))
    _instance.reset(new SdlPref(name));
  return _instance;
}
 
std::string SdlPref::get_pref_file(bool systemConfigOnly) const
{
  if (systemConfigOnly)
    return _system_name;
 
  return _name;
}