From 78185b8fd50524b57e3bde570654d5f0b5ea040f Mon Sep 17 00:00:00 2001 From: omigamedev Date: Thu, 4 Jun 2026 14:44:37 +0200 Subject: [PATCH] Centralize legacy brush package export --- CMakeLists.txt | 1 + cmake/PanoPainterSources.cmake | 2 + docs/modernization/build-inventory.md | 10 ++ docs/modernization/debt.md | 1 + docs/modernization/roadmap.md | 14 +++ src/app_core/brush_package_export.h | 63 ++++++++++ src/app_dialogs.cpp | 42 +++---- src/legacy_brush_package_export_services.cpp | 100 ++++++++++++++++ src/legacy_brush_package_export_services.h | 30 +++++ tests/CMakeLists.txt | 41 +++++++ tests/app_core/brush_package_export_tests.cpp | 94 +++++++++++++++ ...li_plan_brush_package_export_failure.cmake | 24 ++++ tools/pano_cli/main.cpp | 109 ++++++++++++++++++ 13 files changed, 511 insertions(+), 20 deletions(-) create mode 100644 src/app_core/brush_package_export.h create mode 100644 src/legacy_brush_package_export_services.cpp create mode 100644 src/legacy_brush_package_export_services.h create mode 100644 tests/app_core/brush_package_export_tests.cpp create mode 100644 tests/cmake/expect_pano_cli_plan_brush_package_export_failure.cmake diff --git a/CMakeLists.txt b/CMakeLists.txt index f9f71e0..43399ed 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -227,6 +227,7 @@ add_library(pp_app_core STATIC src/app_core/app_preferences.h src/app_core/app_status.h src/app_core/app_startup.h + src/app_core/brush_package_export.h src/app_core/brush_ui.h src/app_core/canvas_hotkey.h src/app_core/canvas_tool_ui.h diff --git a/cmake/PanoPainterSources.cmake b/cmake/PanoPainterSources.cmake index 25744b2..f09c4d0 100644 --- a/cmake/PanoPainterSources.cmake +++ b/cmake/PanoPainterSources.cmake @@ -86,6 +86,8 @@ set(PP_PANOPAINTER_APP_SOURCES src/legacy_app_preference_services.h src/legacy_app_startup_services.cpp src/legacy_app_startup_services.h + src/legacy_brush_package_export_services.cpp + src/legacy_brush_package_export_services.h src/legacy_cloud_services.cpp src/legacy_cloud_services.h src/legacy_document_export_services.cpp diff --git a/docs/modernization/build-inventory.md b/docs/modernization/build-inventory.md index 4ff2e05..9367d10 100644 --- a/docs/modernization/build-inventory.md +++ b/docs/modernization/build-inventory.md @@ -639,6 +639,16 @@ Known local toolchain state: preserving desktop worker-thread timelapse behavior, mobile/Web save callbacks, `App::rec_export`, animation `Canvas::export_anim_mp4`, and success messages; retained video/export ownership is tracked by `DEBT-0044`. +- `src/legacy_brush_package_export_services.*` is the current app-shell bridge + between `pp_app_core` PPBR brush package export requests and live + `NodePanelBrushPreset::export_ppbr` execution. It preserves dialog metadata, + the retained legacy `Image` header object, desktop worker-thread export, + mobile/Web save completion, dialog lifetime, and success messages while brush + asset/storage/UI/platform ownership is tracked by `DEBT-0047`. +- `pp_app_core_brush_package_export_tests` covers PPBR export request path + validation, metadata preservation, legacy-flexible destination/export-data + combinations, service dispatch, and malformed request rejection without + requiring a window, brush preset panel, or filesystem write. - `src/legacy_history_services.*` is the current app-shell bridge between `pp_app_core` history plans and legacy `ActionManager`; toolbar and `NodeCanvas` hotkeys share it while document-history extraction remains diff --git a/docs/modernization/debt.md b/docs/modernization/debt.md index d395ef1..155e7cc 100644 --- a/docs/modernization/debt.md +++ b/docs/modernization/debt.md @@ -64,6 +64,7 @@ agent or engineer to remove them without reconstructing context from chat. | DEBT-0044 | Open | Modernization | Timelapse and animation MP4 export execution dispatch now consumes pure `pp_app_core` through `App::dialog_timelapse_export`, `App::dialog_export_mp4`, `pano_cli plan-export-menu`, `pano_cli plan-export-target --kind name`, `DocumentVideoExportServices`, and `src/legacy_document_export_services.*`, but the bridge still launches legacy desktop timelapse worker threads, calls `App::rec_export`, calls `Canvas::export_anim_mp4`, owns mobile/Web save callbacks, and emits success messages directly | Preserve current MP4/timelapse export behavior while video export moves toward app/document/renderer/video/platform/storage services | `pp_app_core_document_export_tests`; `pano_cli plan-export-menu --kind animation-mp4`; `pano_cli plan-export-menu --kind timelapse`; `pano_cli plan-export-target --kind name --doc-name demo --suffix -animation`; `pano_cli plan-export-target --kind name --doc-name demo --suffix -timelapse`; `ctest --preset desktop-fast --build-config Debug` | Timelapse and animation MP4 execution, desktop worker threading, frame readback/video encoding handoff, mobile/Web save callbacks, and success reporting are owned by injected app/document/renderer/video/platform/storage services with export dialogs acting only as UI adapters | | DEBT-0045 | Open | Modernization | Options-menu preference execution now consumes pure `pp_app_core` through UI scale, viewport scale, RTL direction, VR mode, VR-controller, auto-timelapse, and canvas cursor-mode callbacks plus `AppPreferenceServices` and `src/legacy_app_preference_services.*`, but the bridge still calls legacy `App::set_ui_scale`, `App::set_ui_rtl`, `App::vr_start`, `App::vr_stop`, `NodeCanvas::set_density`, `NodeCanvas::set_cursor_visibility`, `App::rec_start`, `App::rec_stop`, and `Settings::save` directly | Preserve current options-menu behavior while preferences move toward app/UI/platform/storage services | `pp_app_core_app_preferences_tests`; `pano_cli plan-app-preferences --ui-scale 1.5 --display-density 2 --current-scale 1.6 --scale-option 1 --scale-option 1.5 --rtl`; `ctest --preset desktop-fast --build-config Debug`; `cmake --build --preset windows-msvc-default --config Debug --target PanoPainter` | Preference persistence, UI/layout direction, viewport density, cursor mode, VR mode start/stop/failure handling, VR-controller state, and auto-timelapse recording side effects are owned by injected app/UI/platform/storage services with options-menu callbacks acting only as UI adapters | | DEBT-0046 | Open | Modernization | Startup preference/runtime execution now consumes pure `pp_app_core` through `App::init`, `pano_cli plan-app-startup`, `AppStartupServices`, and `src/legacy_app_startup_services.*`, but the bridge still calls legacy `Settings::set`, `Settings::save`, `App::rec_start`, app VR-controller state mutation, and message-box license warning execution directly | Preserve current startup behavior while app startup moves toward app/preferences/storage/recording/UI services | `pp_app_core_app_startup_tests`; `pano_cli plan-app-startup --run-counter 7 --vr-controllers-disabled --license-invalid`; `pano_cli plan-app-startup --run-counter -1`; `ctest --preset desktop-fast --build-config Debug`; `cmake --build --preset windows-msvc-default --config Debug --target PanoPainter` | Startup preference persistence, auto-timelapse startup, stored VR-controller state, license validation/warning, and startup UI/runtime side effects are owned by injected app/preferences/storage/recording/UI services with `App::init` acting only as orchestration | +| DEBT-0047 | Open | Modernization | PPBR brush package export request validation and execution dispatch now consume pure `pp_app_core` through `App::dialog_ppbr_export`, `pano_cli plan-brush-package-export`, `BrushPackageExportServices`, and `src/legacy_brush_package_export_services.*`, but the bridge still reads `NodeDialogExportPPBR`, carries the legacy `Image` header object outside the pure request, converts to `NodePanelBrushPreset::PPBRInfo`, calls `NodePanelBrushPreset::export_ppbr`, owns desktop worker-thread dispatch, dialog destruction, mobile/Web completion, and success-message behavior directly | Preserve current PPBR export behavior while brush assets, PPBR serialization, picker completion, and UI lifetime move toward asset/storage/UI/platform services | `pp_app_core_brush_package_export_tests`; `pano_cli plan-brush-package-export --path D:/Paint/clouds.ppbr --author Artist --dest-path D:/Paint/BrushPreviews --export-data --header-image`; `pano_cli plan-brush-package-export`; `pano_cli plan-brush-package-export --path D:/Paint/clouds.ppbr --dest-path D:/Paint/BrushPreviews --no-export-data`; `ctest --preset desktop-fast --build-config Debug`; `cmake --build --preset windows-msvc-default --config Debug --target PanoPainter` | PPBR metadata collection, header-image ownership, serialization, picker-selected path execution, desktop threading, dialog lifetime, and success UI are owned by injected brush asset/storage/UI/platform services with `App::dialog_ppbr_export` acting only as a UI adapter | ## Closed Debt diff --git a/docs/modernization/roadmap.md b/docs/modernization/roadmap.md index 2a4d625..fe5ead8 100644 --- a/docs/modernization/roadmap.md +++ b/docs/modernization/roadmap.md @@ -778,6 +778,12 @@ executor and `src/legacy_document_export_services.*`, preserving mobile/Web suggested-name save callbacks, desktop worker-thread timelapse export, `App::rec_export`, animation `Canvas::export_anim_mp4` dispatch, and existing success messages while retained execution remains tracked under `DEBT-0044`. +`App::dialog_ppbr_export` now routes picker-selected PPBR brush package exports +through the app-core brush package export executor and +`src/legacy_brush_package_export_services.*`, preserving dialog metadata +collection, legacy `Image` header ownership, desktop worker-thread export, +mobile/Web save completion, `NodePanelBrushPreset::export_ppbr`, and existing +success messages while retained execution remains tracked under `DEBT-0047`. Implementation tasks: @@ -1369,6 +1375,14 @@ Results: - Focused startup CTest coverage passed for `pp_app_core_app_startup_tests`, `pano_cli_plan_app_startup_smoke`, and `pano_cli_plan_app_startup_rejects_negative_counter`. +- `PanoPainter`, `pp_app_core_brush_package_export_tests`, and `pano_cli` built + after PPBR brush package export request validation and dispatch moved behind + app-core brush package services. +- Focused PPBR export CTest coverage passed for + `pp_app_core_brush_package_export_tests`, + `pano_cli_plan_brush_package_export_smoke`, + `pano_cli_plan_brush_package_export_rejects_empty_path`, and + `pano_cli_plan_brush_package_export_dest_without_data_smoke`. - `pp_app_core_document_recording_tests` passed, covering recording start/stop, clear, platform recorded-file cleanup, frame-count reset, export progress totals, and oversized progress-total clamping. diff --git a/src/app_core/brush_package_export.h b/src/app_core/brush_package_export.h new file mode 100644 index 0000000..7df8c47 --- /dev/null +++ b/src/app_core/brush_package_export.h @@ -0,0 +1,63 @@ +#pragma once + +#include "foundation/result.h" + +#include +#include + +namespace pp::app { + +struct BrushPackageExportRequest { + std::string author; + std::string email; + std::string url; + std::string description; + std::string destination_path; + bool export_data = false; + bool has_header_image = false; +}; + +class BrushPackageExportServices { +public: + virtual ~BrushPackageExportServices() = default; + + virtual void export_brush_package(std::string_view path, const BrushPackageExportRequest& request) = 0; +}; + +[[nodiscard]] inline pp::foundation::Status validate_brush_package_export_path(std::string_view path) noexcept +{ + if (path.empty()) { + return pp::foundation::Status::invalid_argument("brush package export path must not be empty"); + } + + return pp::foundation::Status::success(); +} + +[[nodiscard]] inline pp::foundation::Status validate_brush_package_export_request( + std::string_view path, + const BrushPackageExportRequest& request) noexcept +{ + (void)request; + const auto path_status = validate_brush_package_export_path(path); + if (!path_status.ok()) { + return path_status; + } + + return pp::foundation::Status::success(); +} + +[[nodiscard]] inline pp::foundation::Status execute_brush_package_export( + std::string_view path, + const BrushPackageExportRequest& request, + BrushPackageExportServices& services) +{ + const auto status = validate_brush_package_export_request(path, request); + if (!status.ok()) { + return status; + } + + services.export_brush_package(path, request); + return pp::foundation::Status::success(); +} + +} // namespace pp::app diff --git a/src/app_dialogs.cpp b/src/app_dialogs.cpp index d7b36d3..87a2fe2 100644 --- a/src/app_dialogs.cpp +++ b/src/app_dialogs.cpp @@ -5,6 +5,7 @@ #include "app_core/document_export.h" #include "app_core/document_session.h" #include "legacy_document_canvas_services.h" +#include "legacy_brush_package_export_services.h" #include "legacy_document_export_services.h" #include "legacy_document_layer_services.h" #include "legacy_document_session_services.h" @@ -520,33 +521,34 @@ void App::dialog_ppbr_export() auto root = layout[main_id]; auto dialog = root->add_child_ref(); dialog->btn_ok->on_click = [this, dialog] (Node*) { - NodePanelBrushPreset::PPBRInfo info; - info.author = dialog->txt_author->m_text; - info.url = dialog->txt_url->m_text; - info.email = dialog->txt_email->m_text; - info.descr = dialog->txt_descr->m_text; - info.header_image = dialog->m_header_image; - info.dest_path = dialog->m_dest_path; - if (dialog->export_check) - info.export_data = dialog->export_check->checked; + const auto request = pp::panopainter::make_legacy_brush_package_export_request(*dialog); #if __IOS__ || __WEB__ App::I->pick_file_save("ppbr", "exported-brushes", - [this, dialog, info] (std::string path) { - presets->export_ppbr(path, info); + [this, dialog, request] (std::string path) { + const auto status = pp::panopainter::execute_legacy_brush_package_export( + *this, + *dialog, + request, + path, + pp::panopainter::LegacyBrushPackageExportMode::inline_export_only); + if (!status.ok()) + LOG("PPBR export failed: %s", status.message); }, [dialog] (const std::string& path, bool saved) { - if (saved) - dialog->destroy(); + (void)path; + pp::panopainter::complete_legacy_brush_package_export(*dialog, saved); } ); #else - App::I->pick_file_save({ "ppbr" }, [this, dialog, info] (std::string path) { - std::thread([this, path, dialog, info] { - BT_SetTerminate(); - presets->export_ppbr(path, info); - dialog->destroy(); - App::I->message_box("Export PPBR", "Brushes exported to:\n" + path); - }).detach(); + App::I->pick_file_save({ "ppbr" }, [this, dialog, request] (std::string path) { + const auto status = pp::panopainter::execute_legacy_brush_package_export( + *this, + *dialog, + request, + path, + pp::panopainter::LegacyBrushPackageExportMode::desktop_async_close_and_message); + if (!status.ok()) + LOG("PPBR export failed: %s", status.message); }); #endif }; diff --git a/src/legacy_brush_package_export_services.cpp b/src/legacy_brush_package_export_services.cpp new file mode 100644 index 0000000..dafe3d8 --- /dev/null +++ b/src/legacy_brush_package_export_services.cpp @@ -0,0 +1,100 @@ +#include "pch.h" + +#include "legacy_brush_package_export_services.h" + +#include "app.h" +#include "node_dialog_export_ppbr.h" +#include "node_panel_brush.h" + +#include +#include + +namespace pp::panopainter { +namespace { + +NodePanelBrushPreset::PPBRInfo to_legacy_ppbr_info( + const pp::app::BrushPackageExportRequest& request, + const NodeDialogExportPPBR& dialog) +{ + NodePanelBrushPreset::PPBRInfo info; + info.author = request.author; + info.email = request.email; + info.url = request.url; + info.descr = request.description; + info.header_image = dialog.m_header_image; + info.export_data = request.export_data; + info.dest_path = request.destination_path; + return info; +} + +class LegacyBrushPackageExportServices final : public pp::app::BrushPackageExportServices { +public: + LegacyBrushPackageExportServices( + App& app, + NodeDialogExportPPBR& dialog, + LegacyBrushPackageExportMode mode) noexcept + : app_(app) + , dialog_(dialog) + , mode_(mode) + { + } + + void export_brush_package(std::string_view path, const pp::app::BrushPackageExportRequest& request) override + { + const auto path_string = std::string(path); + const auto info = to_legacy_ppbr_info(request, dialog_); + if (mode_ == LegacyBrushPackageExportMode::desktop_async_close_and_message) { + auto* app = &app_; + auto* dialog = &dialog_; + std::thread([app, dialog, path_string, info] { + BT_SetTerminate(); + app->presets->export_ppbr(path_string, info); + dialog->destroy(); + app->message_box("Export PPBR", "Brushes exported to:\n" + path_string); + }).detach(); + return; + } + + app_.presets->export_ppbr(path_string, info); + } + +private: + App& app_; + NodeDialogExportPPBR& dialog_; + LegacyBrushPackageExportMode mode_ = LegacyBrushPackageExportMode::inline_export_only; +}; + +} // namespace + +pp::app::BrushPackageExportRequest make_legacy_brush_package_export_request(const NodeDialogExportPPBR& dialog) +{ + pp::app::BrushPackageExportRequest request; + request.author = dialog.txt_author ? dialog.txt_author->m_text : std::string(); + request.email = dialog.txt_email ? dialog.txt_email->m_text : std::string(); + request.url = dialog.txt_url ? dialog.txt_url->m_text : std::string(); + request.description = dialog.txt_descr ? dialog.txt_descr->m_text : std::string(); + request.destination_path = dialog.m_dest_path; + request.export_data = dialog.export_check && dialog.export_check->checked; + request.has_header_image = static_cast(dialog.m_header_image); + return request; +} + +pp::foundation::Status execute_legacy_brush_package_export( + App& app, + NodeDialogExportPPBR& dialog, + const pp::app::BrushPackageExportRequest& request, + std::string_view path, + LegacyBrushPackageExportMode mode) +{ + LegacyBrushPackageExportServices services(app, dialog, mode); + return pp::app::execute_brush_package_export(path, request, services); +} + +void complete_legacy_brush_package_export(NodeDialogExportPPBR& dialog, bool saved) +{ + if (saved) { + dialog.destroy(); + } +} + +} // namespace pp::panopainter diff --git a/src/legacy_brush_package_export_services.h b/src/legacy_brush_package_export_services.h new file mode 100644 index 0000000..e97274c --- /dev/null +++ b/src/legacy_brush_package_export_services.h @@ -0,0 +1,30 @@ +#pragma once + +#include "app_core/brush_package_export.h" +#include "foundation/result.h" + +#include + +class App; +class NodeDialogExportPPBR; + +namespace pp::panopainter { + +enum class LegacyBrushPackageExportMode { + inline_export_only, + desktop_async_close_and_message, +}; + +[[nodiscard]] pp::app::BrushPackageExportRequest make_legacy_brush_package_export_request( + const NodeDialogExportPPBR& dialog); + +[[nodiscard]] pp::foundation::Status execute_legacy_brush_package_export( + App& app, + NodeDialogExportPPBR& dialog, + const pp::app::BrushPackageExportRequest& request, + std::string_view path, + LegacyBrushPackageExportMode mode); + +void complete_legacy_brush_package_export(NodeDialogExportPPBR& dialog, bool saved); + +} // namespace pp::panopainter diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index f634122..9127d83 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -288,6 +288,16 @@ add_test(NAME pp_app_core_brush_ui_tests COMMAND pp_app_core_brush_ui_tests) set_tests_properties(pp_app_core_brush_ui_tests PROPERTIES LABELS "app;paint;desktop-fast;fuzz") +add_executable(pp_app_core_brush_package_export_tests + app_core/brush_package_export_tests.cpp) +target_link_libraries(pp_app_core_brush_package_export_tests PRIVATE + pp_app_core + pp_test_harness) + +add_test(NAME pp_app_core_brush_package_export_tests COMMAND pp_app_core_brush_package_export_tests) +set_tests_properties(pp_app_core_brush_package_export_tests PROPERTIES + LABELS "app;paint;assets;desktop-fast;fuzz") + add_executable(pp_app_core_canvas_tool_ui_tests app_core/canvas_tool_ui_tests.cpp) target_link_libraries(pp_app_core_canvas_tool_ui_tests PRIVATE @@ -877,6 +887,37 @@ if(TARGET pano_cli) WILL_FAIL TRUE PASS_REGULAR_EXPRESSION "\"command\":\"plan-app-startup\".*\"message\":\"run counter must not be negative\"") + add_test(NAME pano_cli_plan_brush_package_export_smoke + COMMAND pano_cli plan-brush-package-export + --path D:/Paint/clouds.ppbr + --author Artist + --email artist@example.test + --url https://example.test/brushes + --description "Cloud brush set" + --dest-path D:/Paint/BrushPreviews + --export-data + --header-image) + set_tests_properties(pano_cli_plan_brush_package_export_smoke PROPERTIES + LABELS "app;paint;assets;integration;desktop-fast" + PASS_REGULAR_EXPRESSION "\"command\":\"plan-brush-package-export\".*\"path\":\"D:/Paint/clouds.ppbr\".*\"author\":\"Artist\".*\"destPath\":\"D:/Paint/BrushPreviews\".*\"exportData\":true.*\"hasHeaderImage\":true.*\"dispatches\":1") + + add_test(NAME pano_cli_plan_brush_package_export_rejects_empty_path + COMMAND "${CMAKE_COMMAND}" + -DPANO_CLI=$ + "-DEXPECTED_OUTPUT=brush package export path must not be empty" + -P "${CMAKE_CURRENT_SOURCE_DIR}/cmake/expect_pano_cli_plan_brush_package_export_failure.cmake") + set_tests_properties(pano_cli_plan_brush_package_export_rejects_empty_path PROPERTIES + LABELS "app;paint;assets;integration;desktop-fast;fuzz") + + add_test(NAME pano_cli_plan_brush_package_export_dest_without_data_smoke + COMMAND pano_cli plan-brush-package-export + --path D:/Paint/clouds.ppbr + --dest-path D:/Paint/BrushPreviews + --no-export-data) + set_tests_properties(pano_cli_plan_brush_package_export_dest_without_data_smoke PROPERTIES + LABELS "app;paint;assets;integration;desktop-fast;fuzz" + PASS_REGULAR_EXPRESSION "\"command\":\"plan-brush-package-export\".*\"destPath\":\"D:/Paint/BrushPreviews\".*\"exportData\":false.*\"dispatches\":1") + add_test(NAME pano_cli_plan_tools_menu_shortcuts_smoke COMMAND pano_cli plan-tools-menu --command shortcuts) set_tests_properties(pano_cli_plan_tools_menu_shortcuts_smoke PROPERTIES diff --git a/tests/app_core/brush_package_export_tests.cpp b/tests/app_core/brush_package_export_tests.cpp new file mode 100644 index 0000000..b9c9462 --- /dev/null +++ b/tests/app_core/brush_package_export_tests.cpp @@ -0,0 +1,94 @@ +#include "app_core/brush_package_export.h" +#include "test_harness.h" + +#include +#include + +namespace { + +class FakeBrushPackageExportServices final : public pp::app::BrushPackageExportServices { +public: + void export_brush_package(std::string_view path, const pp::app::BrushPackageExportRequest& request) override + { + exports += 1; + last_path = std::string(path); + last_request = request; + } + + int exports = 0; + std::string last_path; + pp::app::BrushPackageExportRequest last_request; +}; + +void validates_path_and_preserves_metadata_edges(pp::tests::Harness& harness) +{ + pp::app::BrushPackageExportRequest request; + request.author = "Pano Artist"; + request.email = "artist@example.test"; + request.url = "https://example.test/brushes"; + request.description = "Cloud brushes"; + request.export_data = true; + request.destination_path = "D:/Paint/BrushPreviews"; + request.has_header_image = true; + + PP_EXPECT(harness, pp::app::validate_brush_package_export_request("D:/Paint/clouds.ppbr", request).ok()); + PP_EXPECT(harness, !pp::app::validate_brush_package_export_request("", request).ok()); + + request.export_data = false; + PP_EXPECT(harness, pp::app::validate_brush_package_export_request("D:/Paint/clouds.ppbr", request).ok()); + + request.destination_path.clear(); + PP_EXPECT(harness, pp::app::validate_brush_package_export_request("D:/Paint/clouds.ppbr", request).ok()); +} + +void executor_dispatches_export_request(pp::tests::Harness& harness) +{ + FakeBrushPackageExportServices services; + pp::app::BrushPackageExportRequest request; + request.author = "Pano Artist"; + request.email = "artist@example.test"; + request.url = "https://example.test/brushes"; + request.description = "Cloud brushes"; + request.export_data = true; + request.destination_path = "D:/Paint/BrushPreviews"; + request.has_header_image = true; + + const auto status = pp::app::execute_brush_package_export("D:/Paint/clouds.ppbr", request, services); + PP_EXPECT(harness, status.ok()); + PP_EXPECT(harness, services.exports == 1); + PP_EXPECT(harness, services.last_path == "D:/Paint/clouds.ppbr"); + PP_EXPECT(harness, services.last_request.author == "Pano Artist"); + PP_EXPECT(harness, services.last_request.email == "artist@example.test"); + PP_EXPECT(harness, services.last_request.url == "https://example.test/brushes"); + PP_EXPECT(harness, services.last_request.description == "Cloud brushes"); + PP_EXPECT(harness, services.last_request.destination_path == "D:/Paint/BrushPreviews"); + PP_EXPECT(harness, services.last_request.export_data); + PP_EXPECT(harness, services.last_request.has_header_image); +} + +void executor_rejects_malformed_requests_before_dispatch(pp::tests::Harness& harness) +{ + FakeBrushPackageExportServices services; + pp::app::BrushPackageExportRequest empty_path_request; + PP_EXPECT(harness, !pp::app::execute_brush_package_export("", empty_path_request, services).ok()); + PP_EXPECT(harness, services.exports == 0); + + pp::app::BrushPackageExportRequest legacy_flexible_request; + legacy_flexible_request.destination_path = "D:/Paint/BrushPreviews"; + legacy_flexible_request.export_data = false; + PP_EXPECT( + harness, + pp::app::execute_brush_package_export("D:/Paint/clouds.ppbr", legacy_flexible_request, services).ok()); + PP_EXPECT(harness, services.exports == 1); +} + +} // namespace + +int main() +{ + pp::tests::Harness harness; + harness.run("validates path and preserves metadata edges", validates_path_and_preserves_metadata_edges); + harness.run("executor dispatches export request", executor_dispatches_export_request); + harness.run("executor rejects malformed requests before dispatch", executor_rejects_malformed_requests_before_dispatch); + return harness.finish(); +} diff --git a/tests/cmake/expect_pano_cli_plan_brush_package_export_failure.cmake b/tests/cmake/expect_pano_cli_plan_brush_package_export_failure.cmake new file mode 100644 index 0000000..569feec --- /dev/null +++ b/tests/cmake/expect_pano_cli_plan_brush_package_export_failure.cmake @@ -0,0 +1,24 @@ +if(NOT DEFINED PANO_CLI) + message(FATAL_ERROR "PANO_CLI must be set") +endif() + +if(NOT DEFINED EXPECTED_OUTPUT) + message(FATAL_ERROR "EXPECTED_OUTPUT must be set") +endif() + +execute_process( + COMMAND "${PANO_CLI}" plan-brush-package-export + RESULT_VARIABLE result + OUTPUT_VARIABLE output + ERROR_VARIABLE error) + +if(result EQUAL 0) + message(FATAL_ERROR "Expected pano_cli plan-brush-package-export to fail, but it exited 0") +endif() + +set(combined_output "${output}${error}") +string(FIND "${combined_output}" "${EXPECTED_OUTPUT}" expected_index) +if(expected_index LESS 0) + message(FATAL_ERROR + "Expected output to contain '${EXPECTED_OUTPUT}', got: ${combined_output}") +endif() diff --git a/tools/pano_cli/main.cpp b/tools/pano_cli/main.cpp index 62f097c..e8e7002 100644 --- a/tools/pano_cli/main.cpp +++ b/tools/pano_cli/main.cpp @@ -2,6 +2,7 @@ #include "app_core/app_preferences.h" #include "app_core/app_status.h" #include "app_core/app_startup.h" +#include "app_core/brush_package_export.h" #include "app_core/brush_ui.h" #include "app_core/canvas_hotkey.h" #include "app_core/canvas_tool_ui.h" @@ -235,6 +236,17 @@ struct PlanAppStartupArgs { bool license_valid = true; }; +struct PlanBrushPackageExportArgs { + std::string path; + std::string author; + std::string email; + std::string url; + std::string description; + std::string destination_path; + bool export_data = false; + bool has_header_image = false; +}; + struct PlanAppStatusArgs { std::string document_name = "no-name"; bool unsaved = false; @@ -1862,6 +1874,7 @@ void print_help() << " 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-app-startup [--run-counter N] [--auto-timelapse-disabled] [--vr-controllers-disabled] [--license-invalid]\n" << " plan-app-status [--doc-name NAME] [--unsaved] [--resolution N] [--resolution-index N] [--zoom N] [--history-bytes N] [--recording-running] [--encoder-available] [--encoded-frames N] [--framebuffer-fetch] [--float32] [--float32-linear] [--float16]\n" + << " plan-brush-package-export --path FILE [--author NAME] [--email EMAIL] [--url URL] [--description TEXT] [--dest-path DIR] [--export-data|--no-export-data] [--header-image]\n" << " plan-tools-menu --command panels|options|clear-grids|reset-camera|shortcuts|sonarpen [--sonarpen-available]\n" << " plan-tools-panel --panel presets|color|color-advanced|layers|brush|grids|animation [--already-visible]\n" << " plan-about-menu --command help|about|news|crash|performance [--version-major N] [--version-minor N] [--version-fix N] [--no-diagnostics] [--no-canvas]\n" @@ -3489,6 +3502,98 @@ int plan_app_startup(int argc, char** argv) return 0; } +pp::foundation::Status parse_plan_brush_package_export_args( + int argc, + char** argv, + PlanBrushPackageExportArgs& args) +{ + for (int i = 2; i < argc; ++i) { + const std::string_view key(argv[i]); + if (key == "--path" || key == "--author" || key == "--email" || key == "--url" + || key == "--description" || key == "--dest-path") { + if (i + 1 >= argc) { + return pp::foundation::Status::invalid_argument("missing value for option"); + } + if (key == "--path") { + args.path = argv[++i]; + } else if (key == "--author") { + args.author = argv[++i]; + } else if (key == "--email") { + args.email = argv[++i]; + } else if (key == "--url") { + args.url = argv[++i]; + } else if (key == "--description") { + args.description = argv[++i]; + } else { + args.destination_path = argv[++i]; + } + } else if (key == "--export-data") { + args.export_data = true; + } else if (key == "--no-export-data") { + args.export_data = false; + } else if (key == "--header-image") { + args.has_header_image = true; + } else { + return pp::foundation::Status::invalid_argument("unknown option"); + } + } + + return pp::foundation::Status::success(); +} + +class CliBrushPackageExportServices final : public pp::app::BrushPackageExportServices { +public: + void export_brush_package(std::string_view path, const pp::app::BrushPackageExportRequest& request) override + { + exports += 1; + last_path = std::string(path); + last_request = request; + } + + int exports = 0; + std::string last_path; + pp::app::BrushPackageExportRequest last_request; +}; + +int plan_brush_package_export(int argc, char** argv) +{ + PlanBrushPackageExportArgs args; + const auto status = parse_plan_brush_package_export_args(argc, argv, args); + if (!status.ok()) { + print_error("plan-brush-package-export", status.message); + return 2; + } + + pp::app::BrushPackageExportRequest request; + request.author = args.author; + request.email = args.email; + request.url = args.url; + request.description = args.description; + request.destination_path = args.destination_path; + request.export_data = args.export_data; + request.has_header_image = args.has_header_image; + + CliBrushPackageExportServices services; + const auto export_status = pp::app::execute_brush_package_export(args.path, request, services); + if (!export_status.ok()) { + print_error("plan-brush-package-export", export_status.message); + return 2; + } + + std::cout << "{\"ok\":true,\"command\":\"plan-brush-package-export\"" + << ",\"request\":{\"path\":\"" << json_escape(services.last_path) + << "\",\"author\":\"" << json_escape(services.last_request.author) + << "\",\"email\":\"" << json_escape(services.last_request.email) + << "\",\"url\":\"" << json_escape(services.last_request.url) + << "\",\"description\":\"" << json_escape(services.last_request.description) + << "\",\"destPath\":\"" << json_escape(services.last_request.destination_path) + << "\",\"exportData\":" << json_bool(services.last_request.export_data) + << ",\"hasHeaderImage\":" << json_bool(services.last_request.has_header_image) + << "},\"dispatches\":" << services.exports + << "}\n"; + return 0; +} + pp::foundation::Status parse_plan_tools_menu_args( int argc, char** argv, @@ -8569,6 +8674,10 @@ int main(int argc, char** argv) return plan_app_startup(argc, argv); } + if (command == "plan-brush-package-export") { + return plan_brush_package_export(argc, argv); + } + if (command == "plan-app-status") { return plan_app_status(argc, argv); }