blakeridgway/supercell-wx
1
0
Fork 0
mirror of https://github.com/ciphervance/supercell-wx.git synced 2025-10-30 13:20:04 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Inheriting MapSettings and PaletteSettings from SettingsCategory, updating SettingsManager initialization

Browse source
This commit is contained in:
Dan Paulat 2022-12-18 08:44:31 -06:00
parent c93e776137
commit 891b6c839f
14 changed files with 231 additions and 269 deletions
Download patch file Download diff file Expand all files Collapse all files

16
scwx-qt/source/scwx/qt/main/main_window.cpp
View file

@ -77,7 +77,7 @@ public:
} }
std::string mapboxApiKey = std::string mapboxApiKey =
manager::SettingsManager::general_settings()->mapbox_api_key(); manager::SettingsManager::general_settings().mapbox_api_key();
settings_.resetToTemplate(QMapLibreGL::Settings::MapboxSettings); settings_.resetToTemplate(QMapLibreGL::Settings::MapboxSettings);
settings_.setApiKey(QString {mapboxApiKey.c_str()}); settings_.setApiKey(QString {mapboxApiKey.c_str()});
@ -172,7 +172,7 @@ MainWindow::MainWindow(QWidget* parent) :
ui->actionAlerts->setVisible(false); ui->actionAlerts->setVisible(false);
ui->menuDebug->menuAction()->setVisible( ui->menuDebug->menuAction()->setVisible(
manager::SettingsManager::general_settings()->debug_enabled()); manager::SettingsManager::general_settings().debug_enabled());
// Configure Resource Explorer Dock // Configure Resource Explorer Dock
ui->resourceExplorerDock->setVisible(false); ui->resourceExplorerDock->setVisible(false);
@ -211,12 +211,12 @@ MainWindow::MainWindow(QWidget* parent) :
// ImGui Debug Dialog // ImGui Debug Dialog
p->imGuiDebugDialog_ = new ui::ImGuiDebugDialog(this); p->imGuiDebugDialog_ = new ui::ImGuiDebugDialog(this);
auto mapSettings = manager::SettingsManager::map_settings(); auto& mapSettings = manager::SettingsManager::map_settings();
for (size_t i = 0; i < p->maps_.size(); i++) for (size_t i = 0; i < p->maps_.size(); i++)
{ {
p->SelectRadarProduct(p->maps_.at(i), p->SelectRadarProduct(p->maps_.at(i),
mapSettings->radar_product_group(i), mapSettings.radar_product_group(i),
mapSettings->radar_product(i), mapSettings.radar_product(i),
0); 0);
} }
@ -365,10 +365,10 @@ void MainWindow::on_resourceTreeExpandAllButton_clicked()
void MainWindowImpl::ConfigureMapLayout() void MainWindowImpl::ConfigureMapLayout()
{ {
auto generalSettings = manager::SettingsManager::general_settings(); auto& generalSettings = manager::SettingsManager::general_settings();
const int64_t gridWidth = generalSettings->grid_width(); const int64_t gridWidth = generalSettings.grid_width();
const int64_t gridHeight = generalSettings->grid_height(); const int64_t gridHeight = generalSettings.grid_height();
const int64_t mapCount = gridWidth * gridHeight; const int64_t mapCount = gridWidth * gridHeight;
size_t mapIndex = 0; size_t mapIndex = 0;

9
scwx-qt/source/scwx/qt/manager/resource_manager.cpp
View file

@ -1,6 +1,5 @@
#include <scwx/qt/manager/resource_manager.hpp> #include <scwx/qt/manager/resource_manager.hpp>
#include <scwx/qt/config/county_database.hpp> #include <scwx/qt/config/county_database.hpp>
#include <scwx/qt/manager/settings_manager.hpp>
#include <scwx/qt/model/imgui_context_model.hpp> #include <scwx/qt/model/imgui_context_model.hpp>
#include <scwx/qt/util/font.hpp> #include <scwx/qt/util/font.hpp>
#include <scwx/qt/util/texture_atlas.hpp> #include <scwx/qt/util/texture_atlas.hpp>
@ -37,12 +36,8 @@ static void LoadFonts()
util::Font::Create(":/res/fonts/din1451alt.ttf"); util::Font::Create(":/res/fonts/din1451alt.ttf");
util::Font::Create(":/res/fonts/din1451alt_g.ttf"); util::Font::Create(":/res/fonts/din1451alt_g.ttf");
if (manager::SettingsManager::general_settings()->debug_enabled()) ImFontAtlas* fontAtlas = model::ImGuiContextModel::Instance().font_atlas();
{ fontAtlas->AddFontDefault();
ImFontAtlas* fontAtlas =
model::ImGuiContextModel::Instance().font_atlas();
fontAtlas->AddFontDefault();
}
} }
static void LoadTextures() static void LoadTextures()

39
scwx-qt/source/scwx/qt/manager/settings_manager.cpp
View file

@ -20,14 +20,6 @@ namespace SettingsManager
static const std::string logPrefix_ = "scwx::qt::manager::settings_manager"; static const std::string logPrefix_ = "scwx::qt::manager::settings_manager";
static const auto logger_ = scwx::util::Logger::Create(logPrefix_); static const auto logger_ = scwx::util::Logger::Create(logPrefix_);
static const std::string kGeneralKey = "general";
static const std::string kMapKey = "maps";
static const std::string kPaletteKey = "palette";
static std::shared_ptr<settings::GeneralSettings> generalSettings_ = nullptr;
static std::shared_ptr<settings::MapSettings> mapSettings_ = nullptr;
static std::shared_ptr<settings::PaletteSettings> paletteSettings_ = nullptr;
static boost::json::value ConvertSettingsToJson(); static boost::json::value ConvertSettingsToJson();
static void GenerateDefaultSettings(); static void GenerateDefaultSettings();
static bool LoadSettings(const boost::json::object& settingsJson); static bool LoadSettings(const boost::json::object& settingsJson);
@ -79,18 +71,21 @@ void ReadSettings(const std::string& settingsPath)
}; };
} }
std::shared_ptr<settings::GeneralSettings> general_settings() settings::GeneralSettings& general_settings()
{ {
static settings::GeneralSettings generalSettings_;
return generalSettings_; return generalSettings_;
} }
std::shared_ptr<settings::MapSettings> map_settings() settings::MapSettings& map_settings()
{ {
static settings::MapSettings mapSettings_;
return mapSettings_; return mapSettings_;
} }
std::shared_ptr<settings::PaletteSettings> palette_settings() settings::PaletteSettings& palette_settings()
{ {
static settings::PaletteSettings paletteSettings_;
return paletteSettings_; return paletteSettings_;
} }
@ -98,9 +93,9 @@ static boost::json::value ConvertSettingsToJson()
{ {
boost::json::object settingsJson; boost::json::object settingsJson;
generalSettings_->WriteJson(settingsJson); general_settings().WriteJson(settingsJson);
settingsJson[kMapKey] = mapSettings_->ToJson(); map_settings().WriteJson(settingsJson);
settingsJson[kPaletteKey] = paletteSettings_->ToJson(); palette_settings().WriteJson(settingsJson);
return settingsJson; return settingsJson;
} }
@ -109,9 +104,9 @@ static void GenerateDefaultSettings()
{ {
logger_->info("Generating default settings"); logger_->info("Generating default settings");
generalSettings_ = std::make_shared<settings::GeneralSettings>(); general_settings().SetDefaults();
mapSettings_ = settings::MapSettings::Create(); map_settings().SetDefaults();
paletteSettings_ = settings::PaletteSettings::Create(); palette_settings().SetDefaults();
} }
static bool LoadSettings(const boost::json::object& settingsJson) static bool LoadSettings(const boost::json::object& settingsJson)
@ -120,13 +115,9 @@ static bool LoadSettings(const boost::json::object& settingsJson)
bool jsonDirty = false; bool jsonDirty = false;
generalSettings_ = std::make_shared<settings::GeneralSettings>(); jsonDirty |= !general_settings().ReadJson(settingsJson);
jsonDirty |= !map_settings().ReadJson(settingsJson);
jsonDirty |= !generalSettings_->ReadJson(settingsJson); jsonDirty |= !palette_settings().ReadJson(settingsJson);
mapSettings_ =
settings::MapSettings::Load(settingsJson.if_contains(kMapKey), jsonDirty);
paletteSettings_ = settings::PaletteSettings::Load(
settingsJson.if_contains(kPaletteKey), jsonDirty);
return jsonDirty; return jsonDirty;
} }

6
scwx-qt/source/scwx/qt/manager/settings_manager.hpp
View file

@ -16,9 +16,9 @@ namespace SettingsManager
void Initialize(); void Initialize();
void ReadSettings(const std::string& settingsPath); void ReadSettings(const std::string& settingsPath);
std::shared_ptr<settings::GeneralSettings> general_settings(); settings::GeneralSettings& general_settings();
std::shared_ptr<settings::MapSettings> map_settings(); settings::MapSettings& map_settings();
std::shared_ptr<settings::PaletteSettings> palette_settings(); settings::PaletteSettings& palette_settings();
} // namespace SettingsManager } // namespace SettingsManager
} // namespace manager } // namespace manager

4
scwx-qt/source/scwx/qt/map/map_widget.cpp
View file

@ -81,7 +81,7 @@ public:
prevPitch_ {0.0} prevPitch_ {0.0}
{ {
SetRadarSite(scwx::qt::manager::SettingsManager::general_settings() SetRadarSite(scwx::qt::manager::SettingsManager::general_settings()
->default_radar_site()); .default_radar_site());
// Create ImGui Context // Create ImGui Context
static size_t currentMapId_ {0u}; static size_t currentMapId_ {0u};
@ -835,7 +835,7 @@ void MapWidgetImpl::InitializeNewRadarProductView(
auto radarProductView = context_->radar_product_view(); auto radarProductView = context_->radar_product_view();
std::string colorTableFile = std::string colorTableFile =
manager::SettingsManager::palette_settings()->palette(colorPalette); manager::SettingsManager::palette_settings().palette(colorPalette);
if (!colorTableFile.empty()) if (!colorTableFile.empty())
{ {
std::shared_ptr<common::ColorTable> colorTable = std::shared_ptr<common::ColorTable> colorTable =

4
scwx-qt/source/scwx/qt/settings/general_settings.cpp
View file

@ -1,7 +1,4 @@
#include <scwx/qt/settings/general_settings.hpp> #include <scwx/qt/settings/general_settings.hpp>
#include <scwx/qt/util/json.hpp>
#include <scwx/util/logger.hpp>
#include <scwx/qt/settings/settings_container.hpp> #include <scwx/qt/settings/settings_container.hpp>
namespace scwx namespace scwx
@ -12,7 +9,6 @@ namespace settings
{ {
static const std::string logPrefix_ = "scwx::qt::settings::general_settings"; static const std::string logPrefix_ = "scwx::qt::settings::general_settings";
static const auto logger_ = scwx::util::Logger::Create(logPrefix_);
class GeneralSettingsImpl class GeneralSettingsImpl
{ {

230
scwx-qt/source/scwx/qt/settings/map_settings.cpp
View file

@ -1,5 +1,6 @@
#include <scwx/qt/settings/map_settings.hpp> #include <scwx/qt/settings/map_settings.hpp>
#include <scwx/qt/config/radar_site.hpp> #include <scwx/qt/config/radar_site.hpp>
#include <scwx/qt/settings/settings_variable.hpp>
#include <scwx/qt/util/json.hpp> #include <scwx/qt/util/json.hpp>
#include <scwx/util/logger.hpp> #include <scwx/util/logger.hpp>
@ -16,11 +17,16 @@ namespace settings
static const std::string logPrefix_ = "scwx::qt::settings::map_settings"; static const std::string logPrefix_ = "scwx::qt::settings::map_settings";
static const auto logger_ = scwx::util::Logger::Create(logPrefix_); static const auto logger_ = scwx::util::Logger::Create(logPrefix_);
static constexpr size_t kCount_ = 4u; static constexpr std::size_t kCount_ = 4u;
static const std::string kDefaultRadarSite_ = "KLSX"; static const std::string kDefaultRadarSite_ = "KLSX";
static const common::RadarProductGroup kDefaultRadarProductGroup_ = static const std::string kRadarSiteName_ {"radar_site"};
static const std::string kRadarProductGroupName_ {"radar_product_group"};
static const std::string kRadarProductName_ {"radar_product"};
static constexpr common::RadarProductGroup kDefaultRadarProductGroup_ =
common::RadarProductGroup::Level3; common::RadarProductGroup::Level3;
static const std::string kDefaultRadarProductGroupString_ = "L3";
static const std::array<std::string, kCount_> kDefaultRadarProduct_ { static const std::array<std::string, kCount_> kDefaultRadarProduct_ {
"N0B", "N0G", "N0C", "N0X"}; "N0B", "N0G", "N0C", "N0X"};
@ -29,180 +35,182 @@ class MapSettingsImpl
public: public:
struct MapData struct MapData
{ {
std::string radarSite_; SettingsVariable<std::string> radarSite_ {kRadarSiteName_};
common::RadarProductGroup radarProductGroup_; SettingsVariable<std::string> radarProductGroup_ {
std::string radarProduct_; kRadarProductGroupName_};
SettingsVariable<std::string> radarProduct_ {kRadarProductName_};
}; };
explicit MapSettingsImpl() { SetDefaults(); } explicit MapSettingsImpl()
~MapSettingsImpl() {}
void SetDefaults(size_t i)
{ {
map_[i].radarSite_ = kDefaultRadarSite_; for (std::size_t i = 0; i < kCount_; i++)
map_[i].radarProductGroup_ = kDefaultRadarProductGroup_;
map_[i].radarProduct_ = kDefaultRadarProduct_[i];
}
void SetDefaults()
{
for (size_t i = 0; i < kCount_; i++)
{ {
SetDefaults(i); map_[i].radarSite_.SetDefault(kDefaultRadarSite_);
map_[i].radarProductGroup_.SetDefault(
kDefaultRadarProductGroupString_);
map_[i].radarProduct_.SetDefault(kDefaultRadarProduct_[i]);
map_[i].radarSite_.SetValidator(
[](const std::string& value)
{
// Radar site must exist
return config::RadarSite::Get(value) != nullptr;
});
map_[i].radarProductGroup_.SetValidator(
[](const std::string& value)
{
// Radar product group must be valid
common::RadarProductGroup radarProductGroup =
common::GetRadarProductGroup(value);
return radarProductGroup != common::RadarProductGroup::Unknown;
});
map_[i].radarProduct_.SetValidator(
[this, i](const std::string& value)
{
common::RadarProductGroup radarProductGroup =
common::GetRadarProductGroup(
map_[i].radarProductGroup_.GetValue());
if (radarProductGroup == common::RadarProductGroup::Level2)
{
// Radar product must be valid
return common::GetLevel2Product(value) !=
common::Level2Product::Unknown;
}
else
{
// TODO: Validate level 3 product
return true;
}
});
variables_.insert(variables_.cend(),
{&map_[i].radarSite_,
&map_[i].radarProductGroup_,
&map_[i].radarProduct_});
} }
} }
std::array<MapData, kCount_> map_; ~MapSettingsImpl() {}
void SetDefaults(std::size_t i)
{
map_[i].radarSite_.SetValueToDefault();
map_[i].radarProductGroup_.SetValueToDefault();
map_[i].radarProduct_.SetValueToDefault();
}
std::array<MapData, kCount_> map_ {};
std::vector<SettingsVariableBase*> variables_ {};
}; };
MapSettings::MapSettings() : p(std::make_unique<MapSettingsImpl>()) {} MapSettings::MapSettings() :
SettingsCategory("maps"), p(std::make_unique<MapSettingsImpl>())
{
RegisterVariables(p->variables_);
SetDefaults();
p->variables_.clear();
}
MapSettings::~MapSettings() = default; MapSettings::~MapSettings() = default;
MapSettings::MapSettings(MapSettings&&) noexcept = default; MapSettings::MapSettings(MapSettings&&) noexcept = default;
MapSettings& MapSettings::operator=(MapSettings&&) noexcept = default; MapSettings& MapSettings::operator=(MapSettings&&) noexcept = default;
size_t MapSettings::count() const std::size_t MapSettings::count() const
{ {
return kCount_; return kCount_;
} }
std::string MapSettings::radar_site(size_t i) const std::string MapSettings::radar_site(std::size_t i) const
{ {
return p->map_[i].radarSite_; return p->map_[i].radarSite_.GetValue();
} }
common::RadarProductGroup MapSettings::radar_product_group(size_t i) const common::RadarProductGroup MapSettings::radar_product_group(std::size_t i) const
{ {
return p->map_[i].radarProductGroup_; return common::GetRadarProductGroup(
p->map_[i].radarProductGroup_.GetValue());
} }
std::string MapSettings::radar_product(size_t i) const std::string MapSettings::radar_product(std::size_t i) const
{ {
return p->map_[i].radarProduct_; return p->map_[i].radarProduct_.GetValue();
} }
boost::json::value MapSettings::ToJson() const bool MapSettings::ReadJson(const boost::json::object& json)
{ {
boost::json::value json; bool validated = true;
json = boost::json::value_from(p->map_); const boost::json::value* value = json.if_contains(name());
return json; if (value != nullptr && value->is_array())
}
std::shared_ptr<MapSettings> MapSettings::Create()
{
std::shared_ptr<MapSettings> generalSettings =
std::make_shared<MapSettings>();
generalSettings->p->SetDefaults();
return generalSettings;
}
std::shared_ptr<MapSettings> MapSettings::Load(const boost::json::value* json,
bool& jsonDirty)
{
std::shared_ptr<MapSettings> mapSettings = std::make_shared<MapSettings>();
if (json != nullptr && json->is_array())
{ {
const boost::json::array& mapArray = json->as_array(); const boost::json::array& mapArray = value->as_array();
for (size_t i = 0; i < kCount_; ++i) for (std::size_t i = 0; i < kCount_; ++i)
{ {
if (i < mapArray.size() && mapArray.at(i).is_object()) if (i < mapArray.size() && mapArray.at(i).is_object())
{ {
const boost::json::object& mapRecord = mapArray.at(i).as_object(); const boost::json::object& mapRecord = mapArray.at(i).as_object();
MapSettingsImpl::MapData& mapRecordSettings = MapSettingsImpl::MapData& mapRecordSettings = p->map_[i];
mapSettings->p->map_[i];
std::string radarProductGroup;
// Load JSON Elements // Load JSON Elements
jsonDirty |= validated &= mapRecordSettings.radarSite_.ReadValue(mapRecord);
!util::json::FromJsonString(mapRecord, validated &=
"radar_site", mapRecordSettings.radarProductGroup_.ReadValue(mapRecord);
mapRecordSettings.radarSite_,
kDefaultRadarSite_);
jsonDirty |= !util::json::FromJsonString(mapRecord,
"radar_product_group",
radarProductGroup,
kDefaultRadarSite_);
jsonDirty |=
!util::json::FromJsonString(mapRecord,
"radar_product",
mapRecordSettings.radarProduct_,
kDefaultRadarProduct_[i]);
// Validate Radar Site bool productValidated =
if (config::RadarSite::Get(mapRecordSettings.radarSite_) == nullptr) mapRecordSettings.radarProduct_.ReadValue(mapRecord);
if (!productValidated)
{ {
mapRecordSettings.radarSite_ = kDefaultRadarSite_; // Product was set to default, reset group to default to match
jsonDirty = true; mapRecordSettings.radarProductGroup_.SetValueToDefault();
validated = false;
} }
// Validate Radar Product Group
mapRecordSettings.radarProductGroup_ =
common::GetRadarProductGroup(radarProductGroup);
if (mapRecordSettings.radarProductGroup_ ==
common::RadarProductGroup::Unknown)
{
mapRecordSettings.radarProductGroup_ =
kDefaultRadarProductGroup_;
jsonDirty = true;
}
// Validate Radar Product
if (mapRecordSettings.radarProductGroup_ ==
common::RadarProductGroup::Level2 &&
common::GetLevel2Product(mapRecordSettings.radarProduct_) ==
common::Level2Product::Unknown)
{
mapRecordSettings.radarProductGroup_ =
kDefaultRadarProductGroup_;
mapRecordSettings.radarProduct_ = kDefaultRadarProduct_[i];
jsonDirty = true;
}
// TODO: Validate level 3 product
} }
else else
{ {
logger_->warn( logger_->warn(
"Too few array entries, resetting record {} to defaults", i + 1); "Too few array entries, resetting record {} to defaults", i + 1);
jsonDirty = true; validated = false;
mapSettings->p->SetDefaults(i); p->SetDefaults(i);
} }
} }
} }
else else
{ {
if (json == nullptr) if (value == nullptr)
{ {
logger_->warn("Key is not present, resetting to defaults"); logger_->warn("Key is not present, resetting to defaults");
} }
else if (!json->is_array()) else if (!value->is_array())
{ {
logger_->warn("Invalid json, resetting to defaults"); logger_->warn("Invalid json, resetting to defaults");
} }
mapSettings->p->SetDefaults(); SetDefaults();
jsonDirty = true; validated = false;
} }
return mapSettings; return validated;
}
void MapSettings::WriteJson(boost::json::object& json) const
{
boost::json::value object = boost::json::value_from(p->map_);
json.insert_or_assign(name(), object);
} }
void tag_invoke(boost::json::value_from_tag, void tag_invoke(boost::json::value_from_tag,
boost::json::value& jv, boost::json::value& jv,
const MapSettingsImpl::MapData& data) const MapSettingsImpl::MapData& data)
{ {
jv = {{"radar_site", data.radarSite_}, jv = {{kRadarSiteName_, data.radarSite_.GetValue()},
{"radar_product_group", {kRadarProductGroupName_, data.radarProductGroup_.GetValue()},
common::GetRadarProductGroupName(data.radarProductGroup_)}, {kRadarProductName_, data.radarProduct_.GetValue()}};
{"radar_product", data.radarProduct_}};
} }
bool operator==(const MapSettings& lhs, const MapSettings& rhs) bool operator==(const MapSettings& lhs, const MapSettings& rhs)

34
scwx-qt/source/scwx/qt/settings/map_settings.hpp
View file

@ -1,12 +1,11 @@
#pragma once #pragma once
#include <scwx/common/products.hpp> #include <scwx/common/products.hpp>
#include <scwx/qt/settings/settings_category.hpp>
#include <memory> #include <memory>
#include <string> #include <string>
#include <boost/json.hpp>
namespace scwx namespace scwx
{ {
namespace qt namespace qt
@ -16,28 +15,39 @@ namespace settings
class MapSettingsImpl; class MapSettingsImpl;
class MapSettings class MapSettings : public SettingsCategory
{ {
public: public:
explicit MapSettings(); explicit MapSettings();
~MapSettings(); ~MapSettings();
MapSettings(const MapSettings&) = delete; MapSettings(const MapSettings&) = delete;
MapSettings& operator=(const MapSettings&) = delete; MapSettings& operator=(const MapSettings&) = delete;
MapSettings(MapSettings&&) noexcept; MapSettings(MapSettings&&) noexcept;
MapSettings& operator=(MapSettings&&) noexcept; MapSettings& operator=(MapSettings&&) noexcept;
size_t count() const; std::size_t count() const;
std::string radar_site(size_t i) const; std::string radar_site(std::size_t i) const;
common::RadarProductGroup radar_product_group(size_t i) const; common::RadarProductGroup radar_product_group(std::size_t i) const;
std::string radar_product(size_t i) const; std::string radar_product(std::size_t i) const;
boost::json::value ToJson() const; /**
* Reads the variables from the JSON object.
*
* @param json JSON object to read
*
* @return true if the values read are valid, false if any values were
* modified.
*/
bool ReadJson(const boost::json::object& json) override;
static std::shared_ptr<MapSettings> Create(); /**
static std::shared_ptr<MapSettings> Load(const boost::json::value* json, * Writes the variables to the JSON object.
bool& jsonDirty); *
* @param json JSON object to write
*/
void WriteJson(boost::json::object& json) const override;
friend bool operator==(const MapSettings& lhs, const MapSettings& rhs); friend bool operator==(const MapSettings& lhs, const MapSettings& rhs);

105
scwx-qt/source/scwx/qt/settings/palette_settings.cpp
View file

@ -1,6 +1,5 @@
#include <scwx/qt/settings/palette_settings.hpp> #include <scwx/qt/settings/palette_settings.hpp>
#include <scwx/qt/util/json.hpp> #include <scwx/qt/settings/settings_variable.hpp>
#include <scwx/util/logger.hpp>
namespace scwx namespace scwx
{ {
@ -10,7 +9,6 @@ namespace settings
{ {
static const std::string logPrefix_ = "scwx::qt::settings::palette_settings"; static const std::string logPrefix_ = "scwx::qt::settings::palette_settings";
static const auto logger_ = scwx::util::Logger::Create(logPrefix_);
static const std::vector<std::string> paletteNames_ = { static const std::vector<std::string> paletteNames_ = {
// Level 2 / Common Products // Level 2 / Common Products
@ -33,29 +31,43 @@ static const std::vector<std::string> paletteNames_ = {
"VIL", "VIL",
"???"}; "???"};
static const std::string DEFAULT_KEY = "Default"; static const std::string kDefaultKey = "???";
static const std::string DEFAULT_PALETTE = ""; static const std::string kDefaultPalette = "";
class PaletteSettingsImpl class PaletteSettingsImpl
{ {
public: public:
explicit PaletteSettingsImpl() {} explicit PaletteSettingsImpl()
~PaletteSettingsImpl() {}
void SetDefaults()
{ {
std::for_each(paletteNames_.cbegin(), std::for_each(paletteNames_.cbegin(),
paletteNames_.cend(), paletteNames_.cend(),
[&](const std::string& name) [&](const std::string& name)
{ palette_[name] = DEFAULT_PALETTE; }); {
auto result = palette_.emplace(
name, SettingsVariable<std::string> {name});
SettingsVariable<std::string>& settingsVariable =
result.first->second;
settingsVariable.SetDefault(kDefaultPalette);
variables_.push_back(&settingsVariable);
});
} }
std::unordered_map<std::string, std::string> palette_; ~PaletteSettingsImpl() {}
std::unordered_map<std::string, SettingsVariable<std::string>> palette_;
std::vector<SettingsVariableBase*> variables_;
}; };
PaletteSettings::PaletteSettings() : p(std::make_unique<PaletteSettingsImpl>()) PaletteSettings::PaletteSettings() :
SettingsCategory("palette"), p(std::make_unique<PaletteSettingsImpl>())
{ {
RegisterVariables(p->variables_);
SetDefaults();
p->variables_.clear();
} }
PaletteSettings::~PaletteSettings() = default; PaletteSettings::~PaletteSettings() = default;
@ -63,80 +75,21 @@ PaletteSettings::PaletteSettings(PaletteSettings&&) noexcept = default;
PaletteSettings& PaletteSettings&
PaletteSettings::operator=(PaletteSettings&&) noexcept = default; PaletteSettings::operator=(PaletteSettings&&) noexcept = default;
const std::string& PaletteSettings::palette(const std::string& name) const std::string PaletteSettings::palette(const std::string& name) const
{ {
auto palette = p->palette_.find(name); auto palette = p->palette_.find(name);
if (palette == p->palette_.cend()) if (palette == p->palette_.cend())
{ {
palette = p->palette_.find("Default"); palette = p->palette_.find(kDefaultKey);
} }
if (palette == p->palette_.cend()) if (palette == p->palette_.cend())
{ {
return DEFAULT_PALETTE; return kDefaultPalette;
} }
return palette->second; return palette->second.GetValue();
}
boost::json::value PaletteSettings::ToJson() const
{
boost::json::object json;
std::for_each(paletteNames_.cbegin(),
paletteNames_.cend(),
[&](const std::string& name)
{ json[name] = p->palette_[name]; });
return json;
}
std::shared_ptr<PaletteSettings> PaletteSettings::Create()
{
std::shared_ptr<PaletteSettings> generalSettings =
std::make_shared<PaletteSettings>();
generalSettings->p->SetDefaults();
return generalSettings;
}
std::shared_ptr<PaletteSettings>
PaletteSettings::Load(const boost::json::value* json, bool& jsonDirty)
{
std::shared_ptr<PaletteSettings> generalSettings =
std::make_shared<PaletteSettings>();
if (json != nullptr && json->is_object())
{
std::for_each(paletteNames_.cbegin(),
paletteNames_.cend(),
[&](const std::string& name)
{
jsonDirty |= !util::json::FromJsonString(
json->as_object(),
name,
generalSettings->p->palette_[name],
DEFAULT_PALETTE);
});
}
else
{
if (json == nullptr)
{
logger_->warn("Key is not present, resetting to defaults");
}
else if (!json->is_object())
{
logger_->warn("Invalid json, resetting to defaults");
}
generalSettings->p->SetDefaults();
jsonDirty = true;
}
return generalSettings;
} }
bool operator==(const PaletteSettings& lhs, const PaletteSettings& rhs) bool operator==(const PaletteSettings& lhs, const PaletteSettings& rhs)

16
scwx-qt/source/scwx/qt/settings/palette_settings.hpp
View file

@ -1,10 +1,10 @@
#pragma once #pragma once
#include <scwx/qt/settings/settings_category.hpp>
#include <memory> #include <memory>
#include <string> #include <string>
#include <boost/json.hpp>
namespace scwx namespace scwx
{ {
namespace qt namespace qt
@ -14,25 +14,19 @@ namespace settings
class PaletteSettingsImpl; class PaletteSettingsImpl;
class PaletteSettings class PaletteSettings : public SettingsCategory
{ {
public: public:
explicit PaletteSettings(); explicit PaletteSettings();
~PaletteSettings(); ~PaletteSettings();
PaletteSettings(const PaletteSettings&) = delete; PaletteSettings(const PaletteSettings&) = delete;
PaletteSettings& operator=(const PaletteSettings&) = delete; PaletteSettings& operator=(const PaletteSettings&) = delete;
PaletteSettings(PaletteSettings&&) noexcept; PaletteSettings(PaletteSettings&&) noexcept;
PaletteSettings& operator=(PaletteSettings&&) noexcept; PaletteSettings& operator=(PaletteSettings&&) noexcept;
const std::string& palette(const std::string& name) const; std::string palette(const std::string& name) const;
boost::json::value ToJson() const;
static std::shared_ptr<PaletteSettings> Create();
static std::shared_ptr<PaletteSettings> Load(const boost::json::value* json,
bool& jsonDirty);
friend bool operator==(const PaletteSettings& lhs, friend bool operator==(const PaletteSettings& lhs,
const PaletteSettings& rhs); const PaletteSettings& rhs);

12
scwx-qt/source/scwx/qt/settings/settings_category.cpp
View file

@ -34,6 +34,11 @@ SettingsCategory::SettingsCategory(SettingsCategory&&) noexcept = default;
SettingsCategory& SettingsCategory&
SettingsCategory::operator=(SettingsCategory&&) noexcept = default; SettingsCategory::operator=(SettingsCategory&&) noexcept = default;
std::string SettingsCategory::name() const
{
return p->name_;
}
void SettingsCategory::SetDefaults() void SettingsCategory::SetDefaults()
{ {
for (auto& variable : p->variables_) for (auto& variable : p->variables_)
@ -95,6 +100,13 @@ void SettingsCategory::RegisterVariables(
p->variables_.insert(p->variables_.end(), variables); p->variables_.insert(p->variables_.end(), variables);
} }
void SettingsCategory::RegisterVariables(
std::vector<SettingsVariableBase*> variables)
{
p->variables_.insert(
p->variables_.end(), variables.cbegin(), variables.cend());
}
} // namespace settings } // namespace settings
} // namespace qt } // namespace qt
} // namespace scwx } // namespace scwx

5
scwx-qt/source/scwx/qt/settings/settings_category.hpp
View file

@ -26,10 +26,12 @@ public:
SettingsCategory(SettingsCategory&&) noexcept; SettingsCategory(SettingsCategory&&) noexcept;
SettingsCategory& operator=(SettingsCategory&&) noexcept; SettingsCategory& operator=(SettingsCategory&&) noexcept;
std::string name() const;
/** /**
* Set all variables to their defaults. * Set all variables to their defaults.
*/ */
virtual void SetDefaults(); void SetDefaults();
/** /**
* Reads the variables from the JSON object. * Reads the variables from the JSON object.
@ -51,6 +53,7 @@ public:
protected: protected:
void void
RegisterVariables(std::initializer_list<SettingsVariableBase*> variables); RegisterVariables(std::initializer_list<SettingsVariableBase*> variables);
void RegisterVariables(std::vector<SettingsVariableBase*> variables);
private: private:
class Impl; class Impl;

2
scwx-qt/source/scwx/qt/util/font.cpp
View file

@ -311,7 +311,7 @@ std::shared_ptr<Font> Font::Create(const std::string& resource)
font->p->CreateImGuiFont( font->p->CreateImGuiFont(
fontFile, fontFile,
fontData, fontData,
manager::SettingsManager::general_settings()->font_sizes()); manager::SettingsManager::general_settings().font_sizes());
font->p->atlas_ = ftgl::texture_atlas_new(512, 512, 1); font->p->atlas_ = ftgl::texture_atlas_new(512, 512, 1);
ftgl::texture_font_t* textureFont = ftgl::texture_font_new_from_memory( ftgl::texture_font_t* textureFont = ftgl::texture_font_new_from_memory(

18
test/source/scwx/qt/manager/settings_manager.test.cpp
View file

@ -36,13 +36,13 @@ class BadSettingsTest :
void VerifyDefaults() void VerifyDefaults()
{ {
std::shared_ptr<settings::GeneralSettings> defaultGeneralSettings = settings::GeneralSettings defaultGeneralSettings {};
std::make_shared<settings::GeneralSettings>(); settings::MapSettings defaultMapSettings {};
std::shared_ptr<settings::PaletteSettings> defaultPaletteSettings = settings::PaletteSettings defaultPaletteSettings {};
settings::PaletteSettings::Create();
EXPECT_EQ(*defaultGeneralSettings, *SettingsManager::general_settings()); EXPECT_EQ(defaultGeneralSettings, SettingsManager::general_settings());
EXPECT_EQ(*defaultPaletteSettings, *SettingsManager::palette_settings()); EXPECT_EQ(defaultMapSettings, SettingsManager::map_settings());
EXPECT_EQ(defaultPaletteSettings, SettingsManager::palette_settings());
} }
void CompareFiles(const std::string& file1, const std::string& file2) void CompareFiles(const std::string& file1, const std::string& file2)
@ -85,10 +85,10 @@ TEST_F(SettingsManagerTest, SettingsKeax)
SettingsManager::ReadSettings(filename); SettingsManager::ReadSettings(filename);
EXPECT_EQ(SettingsManager::general_settings()->default_radar_site(), "KEAX"); EXPECT_EQ(SettingsManager::general_settings().default_radar_site(), "KEAX");
for (size_t i = 0; i < SettingsManager::map_settings()->count(); ++i) for (size_t i = 0; i < SettingsManager::map_settings().count(); ++i)
{ {
EXPECT_EQ(SettingsManager::map_settings()->radar_site(i), "KEAX"); EXPECT_EQ(SettingsManager::map_settings().radar_site(i), "KEAX");
} }
} }