omar/panopainter
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Extract main toolbar action planning

Browse Source
This commit is contained in:
omigamedev
2026-06-03 12:37:32 +02:00
parent b5bd6d42f7
commit 62561624ed
8 changed files with 536 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@@ -243,6 +243,7 @@ add_library(pp_app_core STATIC
src/app_core/file_menu.h
src/app_core/grid_ui.h
src/app_core/history_ui.h
src/app_core/main_toolbar.h
src/app_core/quick_ui.h
src/app_core/tools_menu.h)
target_include_directories(pp_app_core

3
docs/modernization/debt.md
View File

File diff suppressed because one or more lines are too long

13
docs/modernization/roadmap.md
View File

@@ -534,6 +534,11 @@ updates, nanort lightmap baking, and `Canvas::draw_objects` execution continue.
`pano_cli plan-history-operation` exposes app-core planning for undo, redo, and
clear-history availability used by toolbar buttons and canvas shortcuts before
legacy `ActionManager` stack execution continues.
`pano_cli plan-main-toolbar` exposes app-core planning for the live main
toolbar/status-bar shell, including open/save dialogs, undo/redo availability,
clear-history availability, clear-canvas no-canvas blocking, message-box
creation, and settings dialog routing before legacy dialogs, `ActionManager`,
and `Canvas` execution continue.
`pano_cli plan-quick-operation` exposes app-core planning for quick brush/color
slot selection versus popup opening, plus quick mini-state restore/reset
validation used by the live quick panel before legacy `Brush`, color picker,
@@ -1286,6 +1291,14 @@ Results:
`pano_cli_plan_about_menu_crash_disabled_smoke`, and
`pano_cli_plan_about_menu_rejects_unknown` passed and expose live About menu
planning as JSON automation.
- `pp_app_core_main_toolbar_tests` passed, covering live toolbar/status direct
dialog routing, undo/redo availability, clear-history availability, no-canvas
clear blocking, and negative history metric rejection.
- `pano_cli_plan_main_toolbar_undo_smoke`,
`pano_cli_plan_main_toolbar_redo_empty_smoke`,
`pano_cli_plan_main_toolbar_clear_canvas_no_canvas_smoke`, and
`pano_cli_plan_main_toolbar_rejects_negative_count` passed and expose live
toolbar/status planning as JSON automation.
- `pp_app_core_document_sharing_tests` passed, covering saved-path gating before
platform share execution.
- `pano_cli_plan_share_file_unsaved_smoke` and

146
src/app_core/main_toolbar.h Normal file
View File

@@ -0,0 +1,146 @@
#pragma once
#include "app_core/document_canvas.h"
#include "app_core/history_ui.h"
#include "foundation/result.h"
#include <string>
namespace pp::app {
enum class MainToolbarCommand {
open_document,
save_document,
undo,
redo,
clear_history,
clear_canvas,
show_message_box,
show_settings,
};
enum class MainToolbarAction {
show_open_dialog,
show_save_dialog,
invoke_undo,
invoke_redo,
clear_history,
clear_canvas,
show_message_box,
show_settings_dialog,
no_op_unavailable,
};
struct MainToolbarPlan {
MainToolbarCommand command = MainToolbarCommand::open_document;
MainToolbarAction action = MainToolbarAction::show_open_dialog;
std::string label;
bool requires_canvas = false;
bool updates_memory_label = false;
bool updates_title = false;
bool records_undo = false;
bool marks_unsaved = false;
bool no_op = false;
};
[[nodiscard]] inline pp::foundation::Result<MainToolbarPlan> plan_main_toolbar_command(
MainToolbarCommand command,
int undo_count = 0,
int redo_count = 0,
int memory_bytes = 0,
bool has_canvas = true)
{
MainToolbarPlan plan;
plan.command = command;
switch (command) {
case MainToolbarCommand::open_document:
plan.action = MainToolbarAction::show_open_dialog;
plan.label = "Open";
return pp::foundation::Result<MainToolbarPlan>::success(plan);
case MainToolbarCommand::save_document:
plan.action = MainToolbarAction::show_save_dialog;
plan.label = "Save";
return pp::foundation::Result<MainToolbarPlan>::success(plan);
case MainToolbarCommand::undo:
{
const auto history = plan_history_undo(undo_count);
if (!history) {
return pp::foundation::Result<MainToolbarPlan>::failure(history.status());
}
plan.action = history.value().invokes_undo
? MainToolbarAction::invoke_undo
: MainToolbarAction::no_op_unavailable;
plan.label = history.value().invokes_undo ? "Undo" : "Undo (No history)";
plan.updates_memory_label = history.value().updates_memory_label;
plan.updates_title = history.value().updates_title;
plan.no_op = history.value().no_op;
return pp::foundation::Result<MainToolbarPlan>::success(plan);
}
case MainToolbarCommand::redo:
{
const auto history = plan_history_redo(redo_count);
if (!history) {
return pp::foundation::Result<MainToolbarPlan>::failure(history.status());
}
plan.action = history.value().invokes_redo
? MainToolbarAction::invoke_redo
: MainToolbarAction::no_op_unavailable;
plan.label = history.value().invokes_redo ? "Redo" : "Redo (No history)";
plan.updates_memory_label = history.value().updates_memory_label;
plan.updates_title = history.value().updates_title;
plan.no_op = history.value().no_op;
return pp::foundation::Result<MainToolbarPlan>::success(plan);
}
case MainToolbarCommand::clear_history:
{
const auto history = plan_history_clear(undo_count, redo_count, memory_bytes);
if (!history) {
return pp::foundation::Result<MainToolbarPlan>::failure(history.status());
}
plan.action = history.value().clears_history
? MainToolbarAction::clear_history
: MainToolbarAction::no_op_unavailable;
plan.label = history.value().clears_history ? "Clear History" : "Clear History (Empty)";
plan.updates_memory_label = history.value().updates_memory_label;
plan.no_op = history.value().no_op;
return pp::foundation::Result<MainToolbarPlan>::success(plan);
}
case MainToolbarCommand::clear_canvas:
{
const auto clear = plan_document_canvas_clear(has_canvas);
if (!clear) {
return pp::foundation::Result<MainToolbarPlan>::failure(clear.status());
}
plan.action = clear.value().clears_canvas
? MainToolbarAction::clear_canvas
: MainToolbarAction::no_op_unavailable;
plan.label = clear.value().clears_canvas ? "Clear Canvas" : "Clear Canvas (No canvas)";
plan.requires_canvas = true;
plan.records_undo = clear.value().records_undo;
plan.marks_unsaved = clear.value().marks_unsaved;
plan.no_op = clear.value().no_op;
return pp::foundation::Result<MainToolbarPlan>::success(plan);
}
case MainToolbarCommand::show_message_box:
plan.action = MainToolbarAction::show_message_box;
plan.label = "Show Message Box";
return pp::foundation::Result<MainToolbarPlan>::success(plan);
case MainToolbarCommand::show_settings:
plan.action = MainToolbarAction::show_settings_dialog;
plan.label = "Settings";
return pp::foundation::Result<MainToolbarPlan>::success(plan);
}
return pp::foundation::Result<MainToolbarPlan>::failure(
pp::foundation::Status::invalid_argument("unknown main toolbar command"));
}
} // namespace pp::app

54
src/app_layout.cpp
View File

@@ -17,6 +17,7 @@
#include "app_core/file_menu.h"
#include "app_core/app_status.h"
#include "app_core/history_ui.h"
#include "app_core/main_toolbar.h"
#include "app_core/tools_menu.h"
#include "settings.h"
#include "serializer.h"
@@ -281,39 +282,51 @@ void App::init_toolbar_main()
if (auto* button = layout[main_id]->find<NodeButton>("btn-open"))
{
button->on_click = [this, button](Node*) {
dialog_open();
const auto plan = pp::app::plan_main_toolbar_command(
pp::app::MainToolbarCommand::open_document);
if (plan && plan.value().action == pp::app::MainToolbarAction::show_open_dialog)
dialog_open();
};
}
if (auto* button = layout[main_id]->find<NodeButton>("btn-save"))
{
button->on_click = [this, button](Node*) {
dialog_save();
const auto plan = pp::app::plan_main_toolbar_command(
pp::app::MainToolbarCommand::save_document);
if (plan && plan.value().action == pp::app::MainToolbarAction::show_save_dialog)
dialog_save();
};
}
if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-undo"))
{
button->on_click = [this, button](Node*) {
const auto plan = pp::app::plan_history_undo(static_cast<int>(ActionManager::I.m_actions.size()));
if (plan && plan.value().invokes_undo)
const auto plan = pp::app::plan_main_toolbar_command(
pp::app::MainToolbarCommand::undo,
static_cast<int>(ActionManager::I.m_actions.size()));
if (plan && plan.value().action == pp::app::MainToolbarAction::invoke_undo)
ActionManager::undo();
};
}
if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-redo"))
{
button->on_click = [this, button](Node*) {
const auto plan = pp::app::plan_history_redo(static_cast<int>(ActionManager::I.m_redos.size()));
if (plan && plan.value().invokes_redo)
const auto plan = pp::app::plan_main_toolbar_command(
pp::app::MainToolbarCommand::redo,
0,
static_cast<int>(ActionManager::I.m_redos.size()));
if (plan && plan.value().action == pp::app::MainToolbarAction::invoke_redo)
ActionManager::redo();
};
}
if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-clean-memory"))
{
button->on_click = [this](Node*) {
const auto plan = pp::app::plan_history_clear(
const auto plan = pp::app::plan_main_toolbar_command(
pp::app::MainToolbarCommand::clear_history,
static_cast<int>(ActionManager::I.m_actions.size()),
static_cast<int>(ActionManager::I.m_redos.size()),
static_cast<int>(ActionManager::I.m_memory));
if (plan && plan.value().clears_history)
if (plan && plan.value().action == pp::app::MainToolbarAction::clear_history)
ActionManager::clear();
};
}
@@ -321,18 +334,27 @@ void App::init_toolbar_main()
{
button->on_click = [this](Node*) {
//exit(0);
const auto plan = pp::app::plan_document_canvas_clear(static_cast<bool>(canvas));
if (plan && plan.value().clears_canvas)
const auto plan = pp::app::plan_main_toolbar_command(
pp::app::MainToolbarCommand::clear_canvas,
0,
0,
0,
static_cast<bool>(canvas));
if (plan && plan.value().action == pp::app::MainToolbarAction::clear_canvas)
canvas->m_canvas->clear({
plan.value().r,
plan.value().g,
plan.value().b,
plan.value().a });
0.0F,
0.0F,
0.0F,
0.0F });
};
}
if (auto* button = layout[main_id]->find<NodeButton>("btn-popup"))
{
button->on_click = [this](Node*) {
const auto plan = pp::app::plan_main_toolbar_command(
pp::app::MainToolbarCommand::show_message_box);
if (!plan || plan.value().action != pp::app::MainToolbarAction::show_message_box)
return;
msgbox = new NodeMessageBox();
msgbox->set_manager(&layout);
msgbox->init();
@@ -342,6 +364,10 @@ void App::init_toolbar_main()
if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-settings"))
{
button->on_click = [this](Node*) {
const auto plan = pp::app::plan_main_toolbar_command(
pp::app::MainToolbarCommand::show_settings);
if (!plan || plan.value().action != pp::app::MainToolbarAction::show_settings_dialog)
return;
settings = new NodeSettings();
settings->set_manager(&layout);
settings->init();

34
tests/CMakeLists.txt
View File

@@ -318,6 +318,16 @@ add_test(NAME pp_app_core_history_ui_tests COMMAND pp_app_core_history_ui_tests)
set_tests_properties(pp_app_core_history_ui_tests PROPERTIES
LABELS "app;document;ui;desktop-fast;fuzz")
add_executable(pp_app_core_main_toolbar_tests
app_core/main_toolbar_tests.cpp)
target_link_libraries(pp_app_core_main_toolbar_tests PRIVATE
pp_app_core
pp_test_harness)
add_test(NAME pp_app_core_main_toolbar_tests COMMAND pp_app_core_main_toolbar_tests)
set_tests_properties(pp_app_core_main_toolbar_tests PROPERTIES
LABELS "app;document;ui;desktop-fast;fuzz")
add_executable(pp_app_core_quick_ui_tests
app_core/quick_ui_tests.cpp)
target_link_libraries(pp_app_core_quick_ui_tests PRIVATE
@@ -1182,6 +1192,30 @@ if(TARGET pano_cli)
LABELS "app;document;ui;integration;desktop-fast;fuzz"
WILL_FAIL TRUE)
add_test(NAME pano_cli_plan_main_toolbar_undo_smoke
COMMAND pano_cli plan-main-toolbar --command undo --undo-count 2)
set_tests_properties(pano_cli_plan_main_toolbar_undo_smoke PROPERTIES
LABELS "app;document;ui;integration;desktop-fast;fuzz"
PASS_REGULAR_EXPRESSION "\"command\":\"plan-main-toolbar\".*\"command\":\"undo\".*\"action\":\"invoke-undo\".*\"updatesMemoryLabel\":true.*\"updatesTitle\":true.*\"noOp\":false")
add_test(NAME pano_cli_plan_main_toolbar_redo_empty_smoke
COMMAND pano_cli plan-main-toolbar --command redo)
set_tests_properties(pano_cli_plan_main_toolbar_redo_empty_smoke PROPERTIES
LABELS "app;document;ui;integration;desktop-fast;fuzz"
PASS_REGULAR_EXPRESSION "\"command\":\"plan-main-toolbar\".*\"command\":\"redo\".*\"action\":\"no-op-unavailable\".*\"label\":\"Redo \\(No history\\)\".*\"noOp\":true")
add_test(NAME pano_cli_plan_main_toolbar_clear_canvas_no_canvas_smoke
COMMAND pano_cli plan-main-toolbar --command clear-canvas --no-canvas)
set_tests_properties(pano_cli_plan_main_toolbar_clear_canvas_no_canvas_smoke PROPERTIES
LABELS "app;document;ui;integration;desktop-fast;fuzz"
PASS_REGULAR_EXPRESSION "\"command\":\"plan-main-toolbar\".*\"hasCanvas\":false.*\"action\":\"no-op-unavailable\".*\"label\":\"Clear Canvas \\(No canvas\\)\".*\"requiresCanvas\":true.*\"recordsUndo\":false.*\"marksUnsaved\":false.*\"noOp\":true")
add_test(NAME pano_cli_plan_main_toolbar_rejects_negative_count
COMMAND pano_cli plan-main-toolbar --command undo --undo-count -1)
set_tests_properties(pano_cli_plan_main_toolbar_rejects_negative_count PROPERTIES
LABELS "app;document;ui;integration;desktop-fast;fuzz"
WILL_FAIL TRUE)
add_test(NAME pano_cli_plan_quick_operation_select_brush_smoke
COMMAND pano_cli plan-quick-operation --kind brush --current-index 0 --slot-index 2)
set_tests_properties(pano_cli_plan_quick_operation_select_brush_smoke PROPERTIES

114
tests/app_core/main_toolbar_tests.cpp Normal file
View File

@@ -0,0 +1,114 @@
#include "app_core/main_toolbar.h"
#include "test_harness.h"
namespace {
void direct_dialog_commands_are_available(pp::tests::Harness& harness)
{
const auto open = pp::app::plan_main_toolbar_command(pp::app::MainToolbarCommand::open_document);
PP_EXPECT(harness, open);
if (open) {
PP_EXPECT(harness, open.value().action == pp::app::MainToolbarAction::show_open_dialog);
PP_EXPECT(harness, open.value().label == "Open");
PP_EXPECT(harness, !open.value().no_op);
}
const auto save = pp::app::plan_main_toolbar_command(pp::app::MainToolbarCommand::save_document);
PP_EXPECT(harness, save);
if (save) {
PP_EXPECT(harness, save.value().action == pp::app::MainToolbarAction::show_save_dialog);
PP_EXPECT(harness, save.value().label == "Save");
}
const auto settings = pp::app::plan_main_toolbar_command(pp::app::MainToolbarCommand::show_settings);
PP_EXPECT(harness, settings);
if (settings) {
PP_EXPECT(harness, settings.value().action == pp::app::MainToolbarAction::show_settings_dialog);
PP_EXPECT(harness, settings.value().label == "Settings");
}
}
void history_commands_reuse_history_breakpoints(pp::tests::Harness& harness)
{
const auto undo = pp::app::plan_main_toolbar_command(pp::app::MainToolbarCommand::undo, 2);
PP_EXPECT(harness, undo);
if (undo) {
PP_EXPECT(harness, undo.value().action == pp::app::MainToolbarAction::invoke_undo);
PP_EXPECT(harness, undo.value().updates_memory_label);
PP_EXPECT(harness, undo.value().updates_title);
PP_EXPECT(harness, !undo.value().no_op);
}
const auto redo_empty = pp::app::plan_main_toolbar_command(pp::app::MainToolbarCommand::redo, 0, 0);
PP_EXPECT(harness, redo_empty);
if (redo_empty) {
PP_EXPECT(harness, redo_empty.value().action == pp::app::MainToolbarAction::no_op_unavailable);
PP_EXPECT(harness, redo_empty.value().label == "Redo (No history)");
PP_EXPECT(harness, redo_empty.value().no_op);
}
const auto clear = pp::app::plan_main_toolbar_command(
pp::app::MainToolbarCommand::clear_history,
0,
0,
2048);
PP_EXPECT(harness, clear);
if (clear) {
PP_EXPECT(harness, clear.value().action == pp::app::MainToolbarAction::clear_history);
PP_EXPECT(harness, clear.value().updates_memory_label);
PP_EXPECT(harness, !clear.value().updates_title);
}
}
void canvas_clear_requires_live_canvas(pp::tests::Harness& harness)
{
const auto clear = pp::app::plan_main_toolbar_command(
pp::app::MainToolbarCommand::clear_canvas,
0,
0,
0,
true);
PP_EXPECT(harness, clear);
if (clear) {
PP_EXPECT(harness, clear.value().action == pp::app::MainToolbarAction::clear_canvas);
PP_EXPECT(harness, clear.value().requires_canvas);
PP_EXPECT(harness, clear.value().records_undo);
PP_EXPECT(harness, clear.value().marks_unsaved);
PP_EXPECT(harness, !clear.value().no_op);
}
const auto missing_canvas = pp::app::plan_main_toolbar_command(
pp::app::MainToolbarCommand::clear_canvas,
0,
0,
0,
false);
PP_EXPECT(harness, missing_canvas);
if (missing_canvas) {
PP_EXPECT(harness, missing_canvas.value().action == pp::app::MainToolbarAction::no_op_unavailable);
PP_EXPECT(harness, missing_canvas.value().label == "Clear Canvas (No canvas)");
PP_EXPECT(harness, missing_canvas.value().requires_canvas);
PP_EXPECT(harness, !missing_canvas.value().records_undo);
PP_EXPECT(harness, !missing_canvas.value().marks_unsaved);
PP_EXPECT(harness, missing_canvas.value().no_op);
}
}
void rejects_negative_history_metrics(pp::tests::Harness& harness)
{
PP_EXPECT(harness, !pp::app::plan_main_toolbar_command(pp::app::MainToolbarCommand::undo, -1));
PP_EXPECT(harness, !pp::app::plan_main_toolbar_command(pp::app::MainToolbarCommand::redo, 0, -1));
PP_EXPECT(harness, !pp::app::plan_main_toolbar_command(pp::app::MainToolbarCommand::clear_history, 0, 0, -1));
}
} // namespace
int main()
{
pp::tests::Harness harness;
harness.run("direct dialog commands are available", direct_dialog_commands_are_available);
harness.run("history commands reuse history breakpoints", history_commands_reuse_history_breakpoints);
harness.run("canvas clear requires live canvas", canvas_clear_requires_live_canvas);
harness.run("rejects negative history metrics", rejects_negative_history_metrics);
return harness.finish();
}

186
tools/pano_cli/main.cpp
View File

@@ -18,6 +18,7 @@
#include "app_core/file_menu.h"
#include "app_core/grid_ui.h"
#include "app_core/history_ui.h"
#include "app_core/main_toolbar.h"
#include "app_core/quick_ui.h"
#include "app_core/tools_menu.h"
#include "assets/image_format.h"
@@ -322,6 +323,14 @@ struct PlanHistoryOperationArgs {
int memory_bytes = 0;
};
struct PlanMainToolbarArgs {
std::string command = "undo";
int undo_count = 0;
int redo_count = 0;
int memory_bytes = 0;
bool has_canvas = true;
};
struct PlanCanvasToolArgs {
std::string kind = "draw";
bool current_mode_draw = false;
@@ -1107,6 +1116,56 @@ const char* history_ui_operation_name(pp::app::HistoryUiOperation operation) noe
return "undo";
}
const char* main_toolbar_command_name(pp::app::MainToolbarCommand command) noexcept
{
switch (command) {
case pp::app::MainToolbarCommand::open_document:
return "open";
case pp::app::MainToolbarCommand::save_document:
return "save";
case pp::app::MainToolbarCommand::undo:
return "undo";
case pp::app::MainToolbarCommand::redo:
return "redo";
case pp::app::MainToolbarCommand::clear_history:
return "clear-history";
case pp::app::MainToolbarCommand::clear_canvas:
return "clear-canvas";
case pp::app::MainToolbarCommand::show_message_box:
return "message-box";
case pp::app::MainToolbarCommand::show_settings:
return "settings";
}
return "open";
}
const char* main_toolbar_action_name(pp::app::MainToolbarAction action) noexcept
{
switch (action) {
case pp::app::MainToolbarAction::show_open_dialog:
return "show-open-dialog";
case pp::app::MainToolbarAction::show_save_dialog:
return "show-save-dialog";
case pp::app::MainToolbarAction::invoke_undo:
return "invoke-undo";
case pp::app::MainToolbarAction::invoke_redo:
return "invoke-redo";
case pp::app::MainToolbarAction::clear_history:
return "clear-history";
case pp::app::MainToolbarAction::clear_canvas:
return "clear-canvas";
case pp::app::MainToolbarAction::show_message_box:
return "show-message-box";
case pp::app::MainToolbarAction::show_settings_dialog:
return "show-settings-dialog";
case pp::app::MainToolbarAction::no_op_unavailable:
return "no-op-unavailable";
}
return "no-op-unavailable";
}
const char* quick_ui_slot_kind_name(pp::app::QuickUiSlotKind kind) noexcept
{
switch (kind) {
@@ -1494,6 +1553,7 @@ void print_help()
<< " plan-canvas-tool-state [--mode draw|erase|line|camera|grid|copy|cut|fill|mask-free|mask-line|bucket] [--picking] [--touch-lock]\n"
<< " plan-grid-operation --kind pick|load|reload|clear|render|commit [--path FILE] [--no-heightmap] [--no-canvas] [--float32] [--float16] [--texture-resolution N] [--samples N]\n"
<< " plan-history-operation --kind undo|redo|clear [--undo-count N] [--redo-count N] [--memory-bytes N]\n"
<< " plan-main-toolbar --command open|save|undo|redo|clear-history|clear-canvas|message-box|settings [--undo-count N] [--redo-count N] [--memory-bytes N] [--no-canvas]\n"
<< " plan-quick-operation --kind brush|color|restore|reset [--current-index N] [--slot-index N] [--brush-index N] [--color-index N] [--slot-count N] [--fire-event]\n"
<< " plan-share-file [--path FILE]\n"
<< " plan-picked-path [--path FILE]\n"
@@ -4458,6 +4518,128 @@ int plan_history_operation(int argc, char** argv)
return 0;
}
pp::foundation::Result<pp::app::MainToolbarCommand> parse_main_toolbar_command(std::string_view command)
{
if (command == "open") {
return pp::foundation::Result<pp::app::MainToolbarCommand>::success(
pp::app::MainToolbarCommand::open_document);
}
if (command == "save") {
return pp::foundation::Result<pp::app::MainToolbarCommand>::success(
pp::app::MainToolbarCommand::save_document);
}
if (command == "undo") {
return pp::foundation::Result<pp::app::MainToolbarCommand>::success(
pp::app::MainToolbarCommand::undo);
}
if (command == "redo") {
return pp::foundation::Result<pp::app::MainToolbarCommand>::success(
pp::app::MainToolbarCommand::redo);
}
if (command == "clear-history") {
return pp::foundation::Result<pp::app::MainToolbarCommand>::success(
pp::app::MainToolbarCommand::clear_history);
}
if (command == "clear-canvas") {
return pp::foundation::Result<pp::app::MainToolbarCommand>::success(
pp::app::MainToolbarCommand::clear_canvas);
}
if (command == "message-box") {
return pp::foundation::Result<pp::app::MainToolbarCommand>::success(
pp::app::MainToolbarCommand::show_message_box);
}
if (command == "settings") {
return pp::foundation::Result<pp::app::MainToolbarCommand>::success(
pp::app::MainToolbarCommand::show_settings);
}
return pp::foundation::Result<pp::app::MainToolbarCommand>::failure(
pp::foundation::Status::invalid_argument("unknown main toolbar command"));
}
pp::foundation::Status parse_plan_main_toolbar_args(
int argc,
char** argv,
PlanMainToolbarArgs& args)
{
for (int i = 2; i < argc; ++i) {
const std::string_view key(argv[i]);
if (key == "--command") {
if (i + 1 >= argc) {
return pp::foundation::Status::invalid_argument("missing value for option");
}
args.command = argv[++i];
} else if (key == "--undo-count" || key == "--redo-count" || key == "--memory-bytes") {
if (i + 1 >= argc) {
return pp::foundation::Status::invalid_argument("missing value for option");
}
const auto value = parse_i32_arg(argv[++i]);
if (!value) {
return value.status();
}
if (key == "--undo-count") {
args.undo_count = value.value();
} else if (key == "--redo-count") {
args.redo_count = value.value();
} else {
args.memory_bytes = value.value();
}
} else if (key == "--no-canvas") {
args.has_canvas = false;
} else {
return pp::foundation::Status::invalid_argument("unknown option");
}
}
return pp::foundation::Status::success();
}
int plan_main_toolbar(int argc, char** argv)
{
PlanMainToolbarArgs args;
const auto status = parse_plan_main_toolbar_args(argc, argv, args);
if (!status.ok()) {
print_error("plan-main-toolbar", status.message);
return 2;
}
const auto command = parse_main_toolbar_command(args.command);
if (!command) {
print_error("plan-main-toolbar", command.status().message);
return 2;
}
const auto plan = pp::app::plan_main_toolbar_command(
command.value(),
args.undo_count,
args.redo_count,
args.memory_bytes,
args.has_canvas);
if (!plan) {
print_error("plan-main-toolbar", plan.status().message);
return 2;
}
const auto& value = plan.value();
std::cout << "{\"ok\":true,\"command\":\"plan-main-toolbar\""
<< ",\"state\":{\"command\":\"" << json_escape(args.command)
<< "\",\"undoCount\":" << args.undo_count
<< ",\"redoCount\":" << args.redo_count
<< ",\"memoryBytes\":" << args.memory_bytes
<< ",\"hasCanvas\":" << json_bool(args.has_canvas)
<< "},\"plan\":{\"command\":\"" << main_toolbar_command_name(value.command)
<< "\",\"action\":\"" << main_toolbar_action_name(value.action)
<< "\",\"label\":\"" << json_escape(value.label)
<< "\",\"requiresCanvas\":" << json_bool(value.requires_canvas)
<< ",\"updatesMemoryLabel\":" << json_bool(value.updates_memory_label)
<< ",\"updatesTitle\":" << json_bool(value.updates_title)
<< ",\"recordsUndo\":" << json_bool(value.records_undo)
<< ",\"marksUnsaved\":" << json_bool(value.marks_unsaved)
<< ",\"noOp\":" << json_bool(value.no_op)
<< "}}\n";
return 0;
}
pp::foundation::Status parse_plan_quick_operation_args(
int argc,
char** argv,
@@ -7042,6 +7224,10 @@ int main(int argc, char** argv)
return plan_history_operation(argc, argv);
}
if (command == "plan-main-toolbar") {
return plan_main_toolbar(argc, argv);
}
if (command == "plan-quick-operation") {
return plan_quick_operation(argc, argv);
}