Extract app preference planning into app core

tools/pano_cli/main.cpp

@@ -1,3 +1,4 @@
+#include "app_core/app_preferences.h"
 #include "app_core/document_export.h"
 #include "app_core/document_cloud.h"
 #include "app_core/document_platform_io.h"
@@ -186,6 +187,19 @@ struct PlanClipboardWriteArgs {
     std::string text;
 };
 
+struct PlanAppPreferencesArgs {
+    float ui_scale = 1.0F;
+    float display_density = 1.0F;
+    float current_scale = 1.0F;
+    std::vector<float> scale_options;
+    float viewport_scale = 1.0F;
+    bool right_to_left = false;
+    bool timelapse_enabled = true;
+    bool recording_running = false;
+    bool vr_controllers_enabled = true;
+    int cursor_mode = 0;
+};
+
 struct SimulateAppSessionArgs {
     bool has_canvas = true;
     bool new_document = false;
@@ -587,6 +601,32 @@ const char* clipboard_write_action_name(pp::app::ClipboardWriteAction action) no
     return "write-text";
 }
 
+const char* interface_direction_name(pp::app::InterfaceDirection direction) noexcept
+{
+    switch (direction) {
+    case pp::app::InterfaceDirection::left_to_right:
+        return "left-to-right";
+    case pp::app::InterfaceDirection::right_to_left:
+        return "right-to-left";
+    }
+
+    return "left-to-right";
+}
+
+const char* timelapse_recording_action_name(pp::app::TimelapseRecordingAction action) noexcept
+{
+    switch (action) {
+    case pp::app::TimelapseRecordingAction::no_op:
+        return "no-op";
+    case pp::app::TimelapseRecordingAction::start_recording:
+        return "start-recording";
+    case pp::app::TimelapseRecordingAction::stop_recording:
+        return "stop-recording";
+    }
+
+    return "no-op";
+}
+
 pp::foundation::Result<float> parse_float_arg(std::string_view text)
 {
     float value = 0.0F;
@@ -627,6 +667,7 @@ void print_help()
         << "  plan-cloud-browse [--no-canvas] [--selected-file FILE]\n"
         << "  plan-cloud-upload-all [--file-count N] [--no-progress-ui]\n"
         << "  plan-recording-session [--running] [--frame-count N] [--platform-deletes-recorded-files]\n"
+        << "  plan-app-preferences [--ui-scale N] [--display-density N] [--current-scale N] [--scale-option N] [--viewport-scale N] [--rtl] [--timelapse-disabled] [--recording-running] [--vr-controllers-disabled] [--cursor-mode N]\n"
         << "  plan-share-file [--path FILE]\n"
         << "  plan-picked-path [--path FILE]\n"
         << "  plan-display-file [--path FILE]\n"
@@ -1967,6 +2008,105 @@ int plan_recording_session(int argc, char** argv)
     return 0;
 }
 
+pp::foundation::Status parse_plan_app_preferences_args(
+    int argc,
+    char** argv,
+    PlanAppPreferencesArgs& args)
+{
+    for (int i = 2; i < argc; ++i) {
+        const std::string_view key(argv[i]);
+        if (key == "--ui-scale" || key == "--display-density" || key == "--current-scale"
+            || key == "--scale-option" || key == "--viewport-scale") {
+            if (i + 1 >= argc) {
+                return pp::foundation::Status::invalid_argument("missing value for option");
+            }
+            const auto value = parse_float_arg(argv[++i]);
+            if (!value) {
+                return value.status();
+            }
+            if (key == "--ui-scale") {
+                args.ui_scale = value.value();
+            } else if (key == "--display-density") {
+                args.display_density = value.value();
+            } else if (key == "--current-scale") {
+                args.current_scale = value.value();
+            } else if (key == "--scale-option") {
+                args.scale_options.push_back(value.value());
+            } else {
+                args.viewport_scale = value.value();
+            }
+        } else if (key == "--rtl") {
+            args.right_to_left = true;
+        } else if (key == "--timelapse-disabled") {
+            args.timelapse_enabled = false;
+        } else if (key == "--recording-running") {
+            args.recording_running = true;
+        } else if (key == "--vr-controllers-disabled") {
+            args.vr_controllers_enabled = false;
+        } else if (key == "--cursor-mode") {
+            if (i + 1 >= argc) {
+                return pp::foundation::Status::invalid_argument("missing value for option");
+            }
+            const auto value = pp::foundation::parse_u32(argv[++i]);
+            if (!value) {
+                return value.status();
+            }
+            args.cursor_mode = static_cast<int>(value.value());
+        } else {
+            return pp::foundation::Status::invalid_argument("unknown option");
+        }
+    }
+
+    return pp::foundation::Status::success();
+}
+
+int plan_app_preferences(int argc, char** argv)
+{
+    PlanAppPreferencesArgs args;
+    const auto status = parse_plan_app_preferences_args(argc, argv, args);
+    if (!status.ok()) {
+        print_error("plan-app-preferences", status.message);
+        return 2;
+    }
+
+    const auto ui_scale = pp::app::plan_ui_scale(args.ui_scale, args.display_density);
+    const auto scale_selection = pp::app::plan_scale_option_selection(
+        args.current_scale,
+        args.scale_options);
+    const auto viewport_scale = pp::app::plan_viewport_scale(args.viewport_scale);
+    const auto direction = pp::app::plan_interface_direction(args.right_to_left);
+    const auto timelapse = pp::app::plan_timelapse_preference(
+        args.timelapse_enabled,
+        args.recording_running);
+    const auto vr_controllers = pp::app::plan_vr_controllers_preference(args.vr_controllers_enabled);
+    const auto cursor_mode = pp::app::plan_canvas_cursor_mode(args.cursor_mode);
+
+    std::cout << "{\"ok\":true,\"command\":\"plan-app-preferences\""
+              << ",\"state\":{\"uiScale\":" << args.ui_scale
+              << ",\"displayDensity\":" << args.display_density
+              << ",\"currentScale\":" << args.current_scale
+              << ",\"scaleOptions\":" << args.scale_options.size()
+              << ",\"viewportScale\":" << args.viewport_scale
+              << ",\"rtl\":" << json_bool(args.right_to_left)
+              << ",\"timelapseEnabled\":" << json_bool(args.timelapse_enabled)
+              << ",\"recordingRunning\":" << json_bool(args.recording_running)
+              << ",\"vrControllersEnabled\":" << json_bool(args.vr_controllers_enabled)
+              << ",\"cursorMode\":" << args.cursor_mode
+              << "},\"uiScale\":{\"scale\":" << ui_scale.scale
+              << ",\"displayDensity\":" << ui_scale.display_density
+              << ",\"fontScale\":" << ui_scale.font_scale
+              << "},\"scaleSelection\":{\"hasSelection\":" << json_bool(scale_selection.has_selection)
+              << ",\"index\":" << scale_selection.index
+              << "},\"viewportScale\":{\"scale\":" << viewport_scale.scale
+              << "},\"direction\":\"" << interface_direction_name(direction.direction)
+              << "\",\"timelapse\":{\"enabled\":" << json_bool(timelapse.enabled)
+              << ",\"recordingAction\":\"" << timelapse_recording_action_name(timelapse.recording_action)
+              << "\"},\"vrControllers\":{\"enabled\":" << json_bool(vr_controllers.value)
+              << "},\"cursor\":{\"mode\":" << cursor_mode.value
+              << "}}\n";
+    return 0;
+}
+
 pp::foundation::Status parse_plan_share_file_args(
     int argc,
     char** argv,
@@ -4359,6 +4499,10 @@ int main(int argc, char** argv)
         return plan_recording_session(argc, argv);
     }
 
+    if (command == "plan-app-preferences") {
+        return plan_app_preferences(argc, argv);
+    }
+
     if (command == "plan-share-file") {
         return plan_share_file(argc, argv);
     }