Centralize legacy canvas tool bridge

src/app_layout.cpp

@@ -18,6 +18,7 @@
 #include "app_core/main_toolbar.h"
 #include "app_core/tools_menu.h"
 #include "legacy_app_shell_services.h"
+#include "legacy_canvas_tool_services.h"
 #include "legacy_document_layer_services.h"
 #include "legacy_history_services.h"
 #include "settings.h"
@@ -685,126 +686,11 @@ void App::init_sidebar()
         };
     }
 }
-void set_canvas_tool_button_active(Node* button, bool active)
-{
-    if (auto* custom = dynamic_cast<NodeButtonCustom*>(button)) {
-        custom->set_active(active);
-        return;
-    }
-    if (auto* regular = dynamic_cast<NodeButton*>(button)) {
-        regular->set_active(active);
-    }
-}
-
-void select_canvas_tool_button(Node* main, Node* button)
-{
-    main->find<NodeButtonCustom>("btn-pen")->set_active(false);
-    main->find<NodeButtonCustom>("btn-erase")->set_active(false);
-    main->find<NodeButtonCustom>("btn-line")->set_active(false);
-    main->find<NodeButton>("btn-cam")->set_active(false);
-    main->find<NodeButton>("btn-grid")->set_active(false);
-    main->find<NodeButton>("btn-copy")->set_active(false);
-    main->find<NodeButton>("btn-cut")->set_active(false);
-    main->find<NodeButtonCustom>("btn-mask-free")->set_active(false);
-    main->find<NodeButtonCustom>("btn-mask-line")->set_active(false);
-    main->find<NodeButtonCustom>("btn-bucket")->set_active(false);
-    set_canvas_tool_button_active(button, false);
-}
-
-kCanvasMode canvas_mode_from_tool(pp::app::CanvasToolMode mode)
-{
-    switch (mode) {
-    case pp::app::CanvasToolMode::draw:
-        return kCanvasMode::Draw;
-    case pp::app::CanvasToolMode::erase:
-        return kCanvasMode::Erase;
-    case pp::app::CanvasToolMode::line:
-        return kCanvasMode::Line;
-    case pp::app::CanvasToolMode::camera:
-        return kCanvasMode::Camera;
-    case pp::app::CanvasToolMode::grid:
-        return kCanvasMode::Grid;
-    case pp::app::CanvasToolMode::copy:
-        return kCanvasMode::Copy;
-    case pp::app::CanvasToolMode::cut:
-        return kCanvasMode::Cut;
-    case pp::app::CanvasToolMode::fill:
-        return kCanvasMode::Fill;
-    case pp::app::CanvasToolMode::mask_free:
-        return kCanvasMode::MaskFree;
-    case pp::app::CanvasToolMode::mask_line:
-        return kCanvasMode::MaskLine;
-    case pp::app::CanvasToolMode::flood_fill:
-        return kCanvasMode::FloodFill;
-    }
-    return kCanvasMode::Draw;
-}
-
-class LegacyCanvasToolServices final : public pp::app::CanvasToolServices {
-public:
-    LegacyCanvasToolServices(App& app, Node* toolbar_button = nullptr) noexcept
-        : app_(app)
-        , toolbar_button_(toolbar_button)
-    {
-    }
-
-    void select_toolbar_button(pp::app::CanvasToolMode) override
-    {
-        if (toolbar_button_)
-            select_canvas_tool_button(app_.layout[app_.main_id], toolbar_button_);
-    }
-
-    void set_transform_action(pp::app::CanvasToolTransformAction action) override
-    {
-        if (!app_.canvas || !app_.canvas->m_canvas)
-            return;
-
-        if (action == pp::app::CanvasToolTransformAction::copy) {
-            auto* transform = static_cast<CanvasModeTransform*>(
-                app_.canvas->m_canvas->modes[(int)kCanvasMode::Copy][0]);
-            transform->m_action = CanvasModeTransform::ActionType::Copy;
-        } else if (action == pp::app::CanvasToolTransformAction::cut) {
-            auto* transform = static_cast<CanvasModeTransform*>(
-                app_.canvas->m_canvas->modes[(int)kCanvasMode::Cut][0]);
-            transform->m_action = CanvasModeTransform::ActionType::Cut;
-        }
-    }
-
-    void set_canvas_mode(pp::app::CanvasToolMode mode) override
-    {
-        Canvas::set_mode(canvas_mode_from_tool(mode));
-    }
-
-    void toggle_picking() override
-    {
-        if (!app_.canvas || !app_.canvas->m_canvas)
-            return;
-
-        auto* mode = static_cast<CanvasModePen*>(
-            app_.canvas->m_canvas->modes[(int)kCanvasMode::Draw][0]);
-        if (mode)
-            mode->m_picking = !mode->m_picking;
-    }
-
-    void toggle_touch_lock() override
-    {
-        if (!app_.canvas || !app_.canvas->m_canvas)
-            return;
-
-        app_.canvas->m_canvas->m_touch_lock = !app_.canvas->m_canvas->m_touch_lock;
-    }
-
-private:
-    App& app_;
-    Node* toolbar_button_ = nullptr;
-};
-
 template<class T>
 void apply_canvas_tool_select(App& app, T* button, pp::app::CanvasToolMode mode)
 {
     const auto plan = pp::app::plan_canvas_tool_select(mode);
-    LegacyCanvasToolServices services(app, button);
-    const auto status = pp::app::execute_canvas_tool_plan(plan, services);
+    const auto status = pp::panopainter::execute_legacy_canvas_tool_plan(app, plan, button);
     if (!status.ok())
         LOG("Canvas tool select action failed: %s", status.message);
 }
@@ -818,8 +704,7 @@ void App::init_toolbar_draw()
         };
         //button->set_active(true);
         const auto plan = pp::app::plan_canvas_tool_select(pp::app::CanvasToolMode::draw);
-        LegacyCanvasToolServices services(*this);
-        const auto status = pp::app::execute_canvas_tool_plan(plan, services);
+        const auto status = pp::panopainter::execute_legacy_canvas_tool_plan(*this, plan);
         if (!status.ok())
             LOG("Canvas default tool action failed: %s", status.message);
     }
@@ -828,8 +713,7 @@ void App::init_toolbar_draw()
         button->on_click = [this](Node*) {
             const auto plan = pp::app::plan_canvas_tool_pick_toggle(
                 canvas->m_canvas->m_current_mode == kCanvasMode::Draw);
-            LegacyCanvasToolServices services(*this);
-            const auto status = pp::app::execute_canvas_tool_plan(plan, services);
+            const auto status = pp::panopainter::execute_legacy_canvas_tool_plan(*this, plan);
             if (!status.ok())
                 LOG("Canvas pick action failed: %s", status.message);
         };
@@ -838,8 +722,7 @@ void App::init_toolbar_draw()
     {
         button->on_click = [this](Node*) {
             const auto plan = pp::app::plan_canvas_tool_touch_lock_toggle();
-            LegacyCanvasToolServices services(*this);
-            const auto status = pp::app::execute_canvas_tool_plan(plan, services);
+            const auto status = pp::panopainter::execute_legacy_canvas_tool_plan(*this, plan);
             if (!status.ok())
                 LOG("Canvas touch-lock action failed: %s", status.message);
         };

src/legacy_canvas_tool_services.cpp

@@ -0,0 +1,224 @@
+#include "pch.h"
+
+#include "legacy_canvas_tool_services.h"
+
+#include "app.h"
+#include "legacy_history_services.h"
+
+namespace pp::panopainter {
+namespace {
+
+void set_canvas_tool_button_active(Node* button, bool active)
+{
+    if (auto* custom = dynamic_cast<NodeButtonCustom*>(button)) {
+        custom->set_active(active);
+        return;
+    }
+    if (auto* regular = dynamic_cast<NodeButton*>(button)) {
+        regular->set_active(active);
+    }
+}
+
+void select_canvas_tool_button(Node* main, Node* button)
+{
+    main->find<NodeButtonCustom>("btn-pen")->set_active(false);
+    main->find<NodeButtonCustom>("btn-erase")->set_active(false);
+    main->find<NodeButtonCustom>("btn-line")->set_active(false);
+    main->find<NodeButton>("btn-cam")->set_active(false);
+    main->find<NodeButton>("btn-grid")->set_active(false);
+    main->find<NodeButton>("btn-copy")->set_active(false);
+    main->find<NodeButton>("btn-cut")->set_active(false);
+    main->find<NodeButtonCustom>("btn-mask-free")->set_active(false);
+    main->find<NodeButtonCustom>("btn-mask-line")->set_active(false);
+    main->find<NodeButtonCustom>("btn-bucket")->set_active(false);
+    set_canvas_tool_button_active(button, false);
+}
+
+kCanvasMode canvas_mode_from_tool(pp::app::CanvasToolMode mode)
+{
+    switch (mode) {
+    case pp::app::CanvasToolMode::draw:
+        return kCanvasMode::Draw;
+    case pp::app::CanvasToolMode::erase:
+        return kCanvasMode::Erase;
+    case pp::app::CanvasToolMode::line:
+        return kCanvasMode::Line;
+    case pp::app::CanvasToolMode::camera:
+        return kCanvasMode::Camera;
+    case pp::app::CanvasToolMode::grid:
+        return kCanvasMode::Grid;
+    case pp::app::CanvasToolMode::copy:
+        return kCanvasMode::Copy;
+    case pp::app::CanvasToolMode::cut:
+        return kCanvasMode::Cut;
+    case pp::app::CanvasToolMode::fill:
+        return kCanvasMode::Fill;
+    case pp::app::CanvasToolMode::mask_free:
+        return kCanvasMode::MaskFree;
+    case pp::app::CanvasToolMode::mask_line:
+        return kCanvasMode::MaskLine;
+    case pp::app::CanvasToolMode::flood_fill:
+        return kCanvasMode::FloodFill;
+    }
+    return kCanvasMode::Draw;
+}
+
+class LegacyCanvasToolServices final : public pp::app::CanvasToolServices {
+public:
+    LegacyCanvasToolServices(App* app, Node* toolbar_button = nullptr) noexcept
+        : app_(app)
+        , toolbar_button_(toolbar_button)
+    {
+    }
+
+    void select_toolbar_button(pp::app::CanvasToolMode) override
+    {
+        if (app_ && toolbar_button_)
+            select_canvas_tool_button(app_->layout[app_->main_id], toolbar_button_);
+    }
+
+    void set_transform_action(pp::app::CanvasToolTransformAction action) override
+    {
+        if (!app_ || !app_->canvas || !app_->canvas->m_canvas)
+            return;
+
+        if (action == pp::app::CanvasToolTransformAction::copy) {
+            auto* transform = static_cast<CanvasModeTransform*>(
+                app_->canvas->m_canvas->modes[(int)kCanvasMode::Copy][0]);
+            transform->m_action = CanvasModeTransform::ActionType::Copy;
+        } else if (action == pp::app::CanvasToolTransformAction::cut) {
+            auto* transform = static_cast<CanvasModeTransform*>(
+                app_->canvas->m_canvas->modes[(int)kCanvasMode::Cut][0]);
+            transform->m_action = CanvasModeTransform::ActionType::Cut;
+        }
+    }
+
+    void set_canvas_mode(pp::app::CanvasToolMode mode) override
+    {
+        Canvas::set_mode(canvas_mode_from_tool(mode));
+    }
+
+    void toggle_picking() override
+    {
+        if (!app_ || !app_->canvas || !app_->canvas->m_canvas)
+            return;
+
+        auto* mode = static_cast<CanvasModePen*>(
+            app_->canvas->m_canvas->modes[(int)kCanvasMode::Draw][0]);
+        if (mode)
+            mode->m_picking = !mode->m_picking;
+    }
+
+    void toggle_touch_lock() override
+    {
+        if (!app_ || !app_->canvas || !app_->canvas->m_canvas)
+            return;
+
+        app_->canvas->m_canvas->m_touch_lock = !app_->canvas->m_canvas->m_touch_lock;
+    }
+
+private:
+    App* app_ = nullptr;
+    Node* toolbar_button_ = nullptr;
+};
+
+class LegacyCanvasInputToolServices final : public pp::app::CanvasToolServices {
+public:
+    void select_toolbar_button(pp::app::CanvasToolMode) override
+    {
+    }
+
+    void set_transform_action(pp::app::CanvasToolTransformAction) override
+    {
+    }
+
+    void set_canvas_mode(pp::app::CanvasToolMode mode) override
+    {
+        switch (mode) {
+        case pp::app::CanvasToolMode::draw:
+            Canvas::set_mode(kCanvasMode::Draw);
+            return;
+        case pp::app::CanvasToolMode::erase:
+            Canvas::set_mode(kCanvasMode::Erase);
+            return;
+        default:
+            return;
+        }
+    }
+
+    void toggle_picking() override
+    {
+    }
+
+    void toggle_touch_lock() override
+    {
+    }
+};
+
+class LegacyCanvasHotkeyServices final : public pp::app::CanvasHotkeyServices {
+public:
+    pp::foundation::Status execute_tool(const pp::app::CanvasToolPlan& plan) override
+    {
+        return execute_legacy_canvas_input_tool_plan(plan);
+    }
+
+    pp::foundation::Status execute_history(const pp::app::HistoryUiPlan& plan) override
+    {
+        return execute_legacy_history_plan(plan);
+    }
+
+    void save_document(pp::app::DocumentSaveIntent intent) override
+    {
+        if (App::I)
+            App::I->save_document(intent);
+    }
+
+    void toggle_ui() override
+    {
+        if (App::I)
+            App::I->toggle_ui();
+    }
+
+    void adjust_brush_size(float delta) override
+    {
+        if (!App::I || !App::I->stroke || !App::I->stroke->m_tip_size)
+            return;
+
+        const float value = App::I->stroke->m_tip_size->get_value();
+        const float next_value = glm::clamp<float>(value + delta, 0.0F, 1.0F);
+        App::I->stroke->set_size(next_value, true, true);
+    }
+
+    void show_cursor() override
+    {
+        if (App::I)
+            App::I->show_cursor();
+    }
+};
+
+} // namespace
+
+pp::foundation::Status execute_legacy_canvas_tool_plan(
+    App& app,
+    const pp::app::CanvasToolPlan& plan,
+    Node* toolbar_button)
+{
+    LegacyCanvasToolServices services(&app, toolbar_button);
+    return pp::app::execute_canvas_tool_plan(plan, services);
+}
+
+pp::foundation::Status execute_legacy_canvas_input_tool_plan(
+    const pp::app::CanvasToolPlan& plan)
+{
+    LegacyCanvasInputToolServices services;
+    return pp::app::execute_canvas_tool_plan(plan, services);
+}
+
+pp::foundation::Status execute_legacy_canvas_hotkey_plan(
+    const pp::app::CanvasHotkeyPlan& plan)
+{
+    LegacyCanvasHotkeyServices services;
+    return pp::app::execute_canvas_hotkey_plan(plan, services);
+}
+
+} // namespace pp::panopainter

src/legacy_canvas_tool_services.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "app_core/canvas_hotkey.h"
+#include "app_core/canvas_tool_ui.h"
+#include "foundation/result.h"
+
+class App;
+class Node;
+
+namespace pp::panopainter {
+
+[[nodiscard]] pp::foundation::Status execute_legacy_canvas_tool_plan(
+    App& app,
+    const pp::app::CanvasToolPlan& plan,
+    Node* toolbar_button = nullptr);
+[[nodiscard]] pp::foundation::Status execute_legacy_canvas_input_tool_plan(
+    const pp::app::CanvasToolPlan& plan);
+[[nodiscard]] pp::foundation::Status execute_legacy_canvas_hotkey_plan(
+    const pp::app::CanvasHotkeyPlan& plan);
+
+} // namespace pp::panopainter

src/node_canvas.cpp

@@ -8,6 +8,7 @@
 #include "app_core/canvas_hotkey.h"
 #include "app_core/canvas_tool_ui.h"
 #include "app.h"
+#include "legacy_canvas_tool_services.h"
 #include "legacy_history_services.h"
 #include "log.h"
 #include "node_canvas.h"
@@ -70,78 +71,6 @@ pp::paint_renderer::CanvasBlendGatePlan node_canvas_blend_gate_plan(
     return fallback;
 }
 
-class LegacyNodeCanvasToolServices final : public pp::app::CanvasToolServices {
-public:
-    void select_toolbar_button(pp::app::CanvasToolMode) override
-    {
-    }
-
-    void set_transform_action(pp::app::CanvasToolTransformAction) override
-    {
-    }
-
-    void set_canvas_mode(pp::app::CanvasToolMode mode) override
-    {
-        switch (mode) {
-        case pp::app::CanvasToolMode::draw:
-            Canvas::set_mode(kCanvasMode::Draw);
-            return;
-        case pp::app::CanvasToolMode::erase:
-            Canvas::set_mode(kCanvasMode::Erase);
-            return;
-        default:
-            return;
-        }
-    }
-
-    void toggle_picking() override
-    {
-    }
-
-    void toggle_touch_lock() override
-    {
-    }
-};
-
-class LegacyNodeCanvasHotkeyServices final : public pp::app::CanvasHotkeyServices {
-public:
-    pp::foundation::Status execute_tool(const pp::app::CanvasToolPlan& plan) override
-    {
-        LegacyNodeCanvasToolServices services;
-        return pp::app::execute_canvas_tool_plan(plan, services);
-    }
-
-    pp::foundation::Status execute_history(const pp::app::HistoryUiPlan& plan) override
-    {
-        return pp::panopainter::execute_legacy_history_plan(plan);
-    }
-
-    void save_document(pp::app::DocumentSaveIntent intent) override
-    {
-        App::I->save_document(intent);
-    }
-
-    void toggle_ui() override
-    {
-        App::I->toggle_ui();
-    }
-
-    void adjust_brush_size(float delta) override
-    {
-        if (!App::I || !App::I->stroke || !App::I->stroke->m_tip_size)
-            return;
-
-        const float value = App::I->stroke->m_tip_size->get_value();
-        const float next_value = glm::clamp<float>(value + delta, 0.0F, 1.0F);
-        App::I->stroke->set_size(next_value, true, true);
-    }
-
-    void show_cursor() override
-    {
-        App::I->show_cursor();
-    }
-};
-
 pp::app::CanvasHotkeyKey canvas_hotkey_key(kKey key) noexcept
 {
     switch (key) {
@@ -181,8 +110,7 @@ pp::app::CanvasHotkeyState canvas_hotkey_state(bool mouse_focused, int touch_fin
 
 void execute_canvas_hotkey_plan(const pp::app::CanvasHotkeyPlan& plan)
 {
-    LegacyNodeCanvasHotkeyServices services;
-    const auto status = pp::app::execute_canvas_hotkey_plan(plan, services);
+    const auto status = pp::panopainter::execute_legacy_canvas_hotkey_plan(plan);
     if (!status.ok())
         LOG("Canvas hotkey action failed: %s", status.message);
 }
@@ -206,8 +134,7 @@ void run_canvas_hotkey(
 void run_canvas_tool_mode(pp::app::CanvasToolMode mode)
 {
     const auto plan = pp::app::plan_canvas_tool_select(mode);
-    LegacyNodeCanvasToolServices services;
-    const auto status = pp::app::execute_canvas_tool_plan(plan, services);
+    const auto status = pp::panopainter::execute_legacy_canvas_input_tool_plan(plan);
     if (!status.ok())
         LOG("Canvas input tool action failed: %s", status.message);
 }