Route preference reads through adapter

src/app.cpp

@@ -19,6 +19,7 @@
 #include "legacy_document_open_services.h"
 #include "legacy_document_session_services.h"
 #include "legacy_gl_runtime_dispatch.h"
+#include "legacy_preference_storage.h"
 #include "legacy_recording_services.h"
 #include "legacy_ui_gl_dispatch.h"
 #include "platform_api/platform_services.h"
@@ -427,9 +428,9 @@ void App::init()
     });
 
     const auto startup_plan = pp::app::plan_app_startup(
-        Settings::value<Serializer::Integer>("run_counter"),
-        Settings::value_or<Serializer::Boolean>("auto-timelapse", true),
-        Settings::value_or<Serializer::Boolean>("vr-controllers-enabled", vr_controllers_enabled),
+        pp::panopainter::legacy_integer_preference("run_counter"),
+        pp::panopainter::legacy_boolean_preference_or("auto-timelapse", true),
+        pp::panopainter::legacy_boolean_preference_or("vr-controllers-enabled", vr_controllers_enabled),
         check_license());
     if (!startup_plan) {
         LOG("App startup plan failed: %s", startup_plan.status().message);

src/app_dialogs.cpp

@@ -625,7 +625,7 @@ void App::dialog_whatsnew(bool force_show)
     whatsnew->load_url(url, [this, whatsnew, force_show](bool success) {
         if (success)
         {
-            int last_id = Settings::value_or<Serializer::Integer>("whatsnew-id", 0);
+            int last_id = pp::panopainter::legacy_integer_preference_or("whatsnew-id", 0);
             if (force_show || (whatsnew->m_page_id <= g_version_build && whatsnew->m_page_id > last_id))
             {
                 whatsnew->set_title(fmt::format("What's new in version {}", g_version_number));

src/app_layout.cpp

@@ -1108,7 +1108,7 @@ void App::init_menu_tools()
                 if (auto btn = popup_time->find<NodeButtonCustom>("tools-timelapse"))
                 {
                     NodeCheckBox* cb = btn->find<NodeCheckBox>("tools-timelapse-check");
-                    cb->set_value(Settings::value_or<Serializer::Boolean>("auto-timelapse", true), false);
+                    cb->set_value(pp::panopainter::legacy_boolean_preference_or("auto-timelapse", true), false);
 
                     btn->on_click = [this, btn](Node* b)
                     {
@@ -1128,7 +1128,7 @@ void App::init_menu_tools()
 
                 if (auto mode = popup_time->find<NodeComboBox>("tools-show-cursor"))
                 {
-                    mode->set_index(Settings::value_or<Serializer::Integer>("show-cursor", 0));
+                    mode->set_index(pp::panopainter::legacy_integer_preference_or("show-cursor", 0));
 
                     mode->on_select = [mode](Node* target, int index)
                     {
@@ -1614,16 +1614,16 @@ void App::ui_save()
 
 void App::ui_restore()
 {
-    if (Settings::has("ui-rtl"))
-        set_ui_rtl(Settings::value<Serializer::Integer>("ui-rtl"));
+    if (pp::panopainter::has_legacy_preference("ui-rtl"))
+        set_ui_rtl(pp::panopainter::legacy_integer_preference("ui-rtl"));
     
-    if (!Settings::has("ui"))
+    if (!pp::panopainter::has_legacy_preference("ui"))
         return;
 
     auto floatings = layout[main_id]->find_ref("floatings");
     auto drop_left = layout[main_id]->find_ref("drop-left");
     auto drop_right = layout[main_id]->find_ref("drop-right");
-    auto d = Settings::get<Serializer::Descriptor>("ui");
+    auto d = pp::panopainter::get_legacy_descriptor_preference("ui");
     for (auto const& l : d->get<Serializer::List>("floatings")->items)
     {
         auto ld = std::static_pointer_cast<Serializer::Descriptor>(l);

src/legacy_preference_storage.cpp

@@ -7,6 +7,46 @@
 
 namespace pp::panopainter {
 
+bool has_legacy_preference(const char* key)
+{
+    return Settings::has(key);
+}
+
+int legacy_integer_preference(const char* key)
+{
+    return Settings::value<Serializer::Integer>(key);
+}
+
+int legacy_integer_preference_or(const char* key, int default_value)
+{
+    return Settings::value_or<Serializer::Integer>(key, default_value);
+}
+
+float legacy_float_preference(const char* key)
+{
+    return Settings::value<Serializer::Float>(key);
+}
+
+float legacy_float_preference_or(const char* key, float default_value)
+{
+    return Settings::value_or<Serializer::Float>(key, default_value);
+}
+
+bool legacy_boolean_preference_or(const char* key, bool default_value)
+{
+    return Settings::value_or<Serializer::Boolean>(key, default_value);
+}
+
+glm::ivec4 legacy_ivec4_preference(const char* key)
+{
+    return Settings::value<Serializer::IVec4>(key);
+}
+
+std::shared_ptr<Serializer::Descriptor> get_legacy_descriptor_preference(const char* key)
+{
+    return Settings::get<Serializer::Descriptor>(key);
+}
+
 void set_legacy_integer_preference(const char* key, int value)
 {
     Settings::set(key, Serializer::Integer(value));

src/legacy_preference_storage.h

@@ -4,6 +4,14 @@
 
 namespace pp::panopainter {
 
+bool has_legacy_preference(const char* key);
+int legacy_integer_preference(const char* key);
+int legacy_integer_preference_or(const char* key, int default_value);
+float legacy_float_preference(const char* key);
+float legacy_float_preference_or(const char* key, float default_value);
+bool legacy_boolean_preference_or(const char* key, bool default_value);
+glm::ivec4 legacy_ivec4_preference(const char* key);
+std::shared_ptr<Serializer::Descriptor> get_legacy_descriptor_preference(const char* key);
 void set_legacy_integer_preference(const char* key, int value);
 void set_legacy_ivec4_preference(const char* key, const glm::ivec4& value);
 void set_legacy_boolean_preference(const char* key, bool value);

src/main.cpp

@@ -802,22 +802,22 @@ int main(int argc, char** argv)
         GetDpiForMonitor_fn(monitor, MDT_EFFECTIVE_DPI, &x, &y);
     App::I->display_density = (float)x / 96.f;
 
-    if (Settings::has("ui-scale"))
-        App::I->zoom = Settings::value<Serializer::Float>("ui-scale");
+    if (pp::panopainter::has_legacy_preference("ui-scale"))
+        App::I->zoom = pp::panopainter::legacy_float_preference("ui-scale");
     else
         App::I->zoom = (float)x / 96.f;
 
     int show_cmd = SW_NORMAL;
-    Settings::value<Serializer::Integer>("window-show-cmd", show_cmd);
+    show_cmd = pp::panopainter::legacy_integer_preference_or("window-show-cmd", show_cmd);
     DWORD wnd_style = WS_OVERLAPPEDWINDOW;
     //if (show_cmd == SW_MAXIMIZE)
     //    wnd_style != WS_MAXIMIZE;
 
     RECT clientRect = { 0, 0, (int)App::I->width * App::I->zoom, (int)App::I->height * App::I->zoom };
     POINT clientPos = { CW_USEDEFAULT, CW_USEDEFAULT };
-    if (Settings::has("window-rect"))
+    if (pp::panopainter::has_legacy_preference("window-rect"))
     {
-        auto wnd_rect = Settings::value<Serializer::IVec4>("window-rect");
+        auto wnd_rect = pp::panopainter::legacy_ivec4_preference("window-rect");
         App::I->width = wnd_rect.z - wnd_rect.x;
         App::I->height = wnd_rect.w - wnd_rect.y;
         clientRect = { wnd_rect.x, wnd_rect.y, wnd_rect.z, wnd_rect.w };

src/node_canvas.cpp

@@ -12,6 +12,7 @@
 #include "app_core/document_animation.h"
 #include "app.h"
 #include "node_panel_grid.h"
+#include "legacy_preference_storage.h"
 #include "legacy_ui_gl_dispatch.h"
 #include "legacy_ui_overlay_services.h"
 #include "legacy_canvas_tool_services.h"
@@ -238,8 +239,8 @@ Node* NodeCanvas::clone_instantiate() const
 
 void NodeCanvas::init()
 {
-    m_density = Settings::value_or<Serializer::Float>("vp-scale", 1.f);
-    m_cursor_visibility = (kCursorVisibility)Settings::value_or<Serializer::Integer>("show-cursor", 0);
+    m_density = pp::panopainter::legacy_float_preference_or("vp-scale", 1.f);
+    m_cursor_visibility = (kCursorVisibility)pp::panopainter::legacy_integer_preference_or("show-cursor", 0);
 
     m_mouse_ignore = false;
     m_canvas = std::make_unique<Canvas>();