Extract app status planning into app core

src/app.cpp

@@ -5,6 +5,7 @@
 #include "node_dialog_open.h"
 #include "node_progress_bar.h"
 #include "mp4enc.h"
+#include "app_core/app_status.h"
 #include "app_core/document_recording.h"
 #include "app_core/document_route.h"
 #include "app_core/document_session.h"
@@ -682,9 +683,8 @@ void App::update_memory_usage(size_t bytes)
 {
     if (auto txt = layout[main_id]->find<NodeText>("txt-memory"))
     {
-        static char buffer[128];
-        sprintf(buffer, "History memory: %.2f Mb", bytes / 1024.f / 1024.f);
-        txt->set_text(buffer);
+        const auto label = pp::app::make_history_memory_label(bytes);
+        txt->set_text(label.c_str());
     }
 }
 
@@ -692,32 +692,30 @@ void App::update_rec_frames()
 {
     if (auto txt = layout[main_id]->find<NodeText>("txt-rec"))
     {
-        if (rec_running && Canvas::I->m_encoder)
-        {
-            static char buffer[128];
-            sprintf(buffer, "Recorded %d frames", Canvas::I->m_encoder->frames_count());
-            txt->set_text(buffer);
-        }
-        else
-        {
-            txt->set_text("");
-        }
+        const auto label = pp::app::make_recording_frame_label(
+            rec_running,
+            Canvas::I->m_encoder != nullptr,
+            Canvas::I->m_encoder ? Canvas::I->m_encoder->frames_count() : 0);
+        txt->set_text(label.text.c_str());
     }
 }
 
 int App::res_from_index(int i)
 {
-    return res_map[i];
+    const auto resolution = pp::app::display_resolution_from_index(i);
+    return resolution ? resolution.value() : pp::app::document_resolution_values.front();
 }
 
 int App::res_to_index(int res)
 {
-    return (int)std::distance(res_map.begin(), std::find(res_map.begin(), res_map.end(), res));
+    const auto index = pp::app::document_resolution_to_index(res);
+    return index ? static_cast<int>(index.value()) : static_cast<int>(pp::app::document_resolution_values.size());
 }
 
 std::string App::res_to_string(int res)
 {
-    return res_map_str[res_to_index(res)];
+    const auto label = pp::app::document_resolution_label(res);
+    return label ? std::string(label.value()) : std::string("unknown");
 }
 
 void App::renderdoc_frame_start()

src/app_core/app_status.h

@@ -0,0 +1,119 @@
+#pragma once
+
+#include "foundation/result.h"
+
+#include <array>
+#include <cstdio>
+#include <cstddef>
+#include <string>
+#include <string_view>
+
+namespace pp::app {
+
+inline constexpr std::array<int, 6> document_resolution_values {
+    512,
+    1024,
+    1536,
+    2048,
+    4096,
+    8192,
+};
+
+inline constexpr std::array<std::string_view, 6> document_resolution_labels {
+    "2K",
+    "4K",
+    "6K",
+    "8K",
+    "16K",
+    "32K",
+};
+
+struct RecordingFrameLabel {
+    bool visible = false;
+    std::string text;
+};
+
+[[nodiscard]] inline pp::foundation::Result<int> display_resolution_from_index(int index)
+{
+    if (index < 0 || static_cast<std::size_t>(index) >= document_resolution_values.size()) {
+        return pp::foundation::Result<int>::failure(
+            pp::foundation::Status::out_of_range("document resolution index is out of range"));
+    }
+    return pp::foundation::Result<int>::success(
+        document_resolution_values[static_cast<std::size_t>(index)]);
+}
+
+[[nodiscard]] inline pp::foundation::Result<std::size_t> document_resolution_to_index(int resolution)
+{
+    for (std::size_t index = 0; index < document_resolution_values.size(); ++index) {
+        if (document_resolution_values[index] == resolution) {
+            return pp::foundation::Result<std::size_t>::success(index);
+        }
+    }
+    return pp::foundation::Result<std::size_t>::failure(
+        pp::foundation::Status::out_of_range("document resolution is not supported"));
+}
+
+[[nodiscard]] inline pp::foundation::Result<std::string_view> document_resolution_label(int resolution)
+{
+    const auto index = document_resolution_to_index(resolution);
+    if (!index) {
+        return pp::foundation::Result<std::string_view>::failure(index.status());
+    }
+    return pp::foundation::Result<std::string_view>::success(document_resolution_labels[index.value()]);
+}
+
+[[nodiscard]] inline std::string make_document_title(
+    std::string_view document_name,
+    bool has_unsaved_changes,
+    int resolution)
+{
+    const auto label = document_resolution_label(resolution);
+    const auto resolution_label = label ? label.value() : std::string_view("unknown");
+    std::string title = "Panodoc: ";
+    title.append(document_name);
+    if (has_unsaved_changes) {
+        title.push_back('*');
+    }
+    title.append(" (");
+    title.append(resolution_label);
+    title.push_back(')');
+    return title;
+}
+
+[[nodiscard]] inline std::string make_dpi_label(float zoom)
+{
+    char buffer[64] {};
+    std::snprintf(buffer, sizeof(buffer), "%.1fx-dpi", zoom);
+    return buffer;
+}
+
+[[nodiscard]] inline std::string make_history_memory_label(std::size_t bytes)
+{
+    char buffer[128] {};
+    std::snprintf(
+        buffer,
+        sizeof(buffer),
+        "History memory: %.2f Mb",
+        static_cast<double>(bytes) / 1024.0 / 1024.0);
+    return buffer;
+}
+
+[[nodiscard]] inline RecordingFrameLabel make_recording_frame_label(
+    bool is_recording,
+    bool encoder_available,
+    int encoded_frames)
+{
+    if (!is_recording || !encoder_available) {
+        return {};
+    }
+
+    char buffer[128] {};
+    std::snprintf(buffer, sizeof(buffer), "Recorded %d frames", encoded_frames);
+    return {
+        true,
+        buffer,
+    };
+}
+
+}

src/app_layout.cpp

@@ -7,6 +7,7 @@
 #include "node_dialog_picker.h"
 #include "node_panel_floating.h"
 #include "app_core/app_preferences.h"
+#include "app_core/app_status.h"
 #include "settings.h"
 #include "serializer.h"
 #include "font.h"
@@ -17,12 +18,19 @@
 
 void App::title_update()
 {
-    static char str[256];
-    snprintf(str, 256, "Panodoc: %s%s (%s)", doc_name.c_str(), canvas->m_canvas->m_unsaved ? "*" : "", res_to_string(canvas->m_canvas->m_width).c_str());
     if (auto docname = layout[main_id]->find<NodeText>("txt-docname"))
-        docname->set_text(str);
+    {
+        const auto title = pp::app::make_document_title(
+            doc_name,
+            canvas->m_canvas->m_unsaved,
+            canvas->m_canvas->m_width);
+        docname->set_text(title.c_str());
+    }
     if (auto node = layout[main_id]->find<NodeText>("txt-dpi"))
-        node->set_text(fmt::format("{:.1f}x-dpi", zoom).c_str());
+    {
+        const auto label = pp::app::make_dpi_label(zoom);
+        node->set_text(label.c_str());
+    }
 }
 
 void App::init_toolbar_main()