Centralize legacy canvas tool bridge

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