Centralize legacy document layer bridge

src/legacy_document_layer_services.cpp

@@ -0,0 +1,330 @@
+#include "pch.h"
+
+#include "legacy_document_layer_services.h"
+
+#include "action.h"
+#include "app.h"
+#include "legacy_document_canvas_services.h"
+
+namespace pp::panopainter {
+namespace {
+
+struct LegacyActionLayerRename : public Action {
+    std::string m_old_name;
+    std::string m_new_name;
+    Layer* m_layer = nullptr;
+    std::shared_ptr<NodeLayer> m_layer_node;
+
+    LegacyActionLayerRename(
+        std::string old_name,
+        std::string new_name,
+        std::shared_ptr<NodeLayer> layer_node,
+        Layer* layer)
+        : m_old_name(std::move(old_name))
+        , m_new_name(std::move(new_name))
+        , m_layer(layer)
+        , m_layer_node(std::move(layer_node))
+    {
+    }
+
+    void run() override { }
+    size_t memory() override { return 0; }
+    void undo() override
+    {
+        if (m_layer_node)
+            m_layer_node->set_name(m_old_name.c_str());
+        if (m_layer)
+            m_layer->m_name = m_old_name;
+    }
+    Action* get_redo() override
+    {
+        return new LegacyActionLayerRename(m_new_name, m_old_name, m_layer_node, m_layer);
+    }
+};
+
+class LegacyDocumentLayerRenameServices final : public pp::app::DocumentLayerRenameServices {
+public:
+    LegacyDocumentLayerRenameServices(App& app, const std::shared_ptr<NodeDialogLayerRename>& dialog) noexcept
+        : app_(app)
+        , dialog_(dialog)
+    {
+    }
+
+    void rename_layer(std::string_view old_name, std::string_view new_name) override
+    {
+        if (!app_.layers || !app_.layers->m_current_layer || !app_.canvas || !app_.canvas->m_canvas)
+            return;
+
+        auto layer_node = std::static_pointer_cast<NodeLayer>(app_.layers->m_current_layer->shared_from_this());
+        auto* layer = app_.canvas->m_canvas->m_layers[app_.canvas->m_canvas->m_current_layer_idx].get();
+        const std::string old_name_copy(old_name);
+        const std::string new_name_copy(new_name);
+        ActionManager::add(new LegacyActionLayerRename(
+            old_name_copy,
+            new_name_copy,
+            layer_node,
+            layer));
+        layer_node->set_name(new_name_copy.c_str());
+        layer->m_name = new_name_copy;
+    }
+
+    void finish_layer_rename() override
+    {
+        if (dialog_)
+            dialog_->destroy();
+        app_.hideKeyboard();
+    }
+
+private:
+    App& app_;
+    std::shared_ptr<NodeDialogLayerRename> dialog_;
+};
+
+class LegacyDocumentLayerMergeServices final : public pp::app::DocumentLayerMergeServices {
+public:
+    explicit LegacyDocumentLayerMergeServices(App& app) noexcept
+        : app_(app)
+    {
+    }
+
+    void merge_layers(int from_index, int to_index, bool create_history) override
+    {
+        if (app_.layers)
+            app_.layers->merge(from_index, to_index, create_history);
+    }
+
+private:
+    App& app_;
+};
+
+class LegacyDocumentLayerMenuServices final : public pp::app::DocumentLayerMenuServices {
+public:
+    explicit LegacyDocumentLayerMenuServices(App& app) noexcept
+        : app_(app)
+    {
+    }
+
+    void clear_current_layer() override
+    {
+        const auto plan = pp::app::plan_document_canvas_clear(
+            app_.canvas && app_.canvas->m_canvas,
+            1.0F,
+            1.0F,
+            1.0F,
+            0.0F);
+        if (!plan)
+            return;
+
+        const auto status = execute_legacy_document_canvas_clear_plan(app_, plan.value());
+        if (!status.ok())
+            LOG("Canvas clear failed: %s", status.message);
+    }
+
+    void show_rename_dialog() override
+    {
+        app_.dialog_layer_rename();
+    }
+
+    void merge_with_lower_layer(int from_index, int to_index) override
+    {
+        const int layer_count = app_.canvas && app_.canvas->m_canvas
+            ? static_cast<int>(app_.canvas->m_canvas->m_layers.size())
+            : 0;
+        const int animation_duration = Canvas::I
+            ? Canvas::I->anim_duration()
+            : 0;
+        const auto plan = pp::app::plan_document_layer_merge(
+            layer_count,
+            from_index,
+            to_index,
+            animation_duration);
+        if (!plan)
+            return;
+
+        const auto status = execute_legacy_document_layer_merge_plan(app_, plan.value());
+        if (!status.ok())
+            LOG("Layer merge failed: %s", status.message);
+    }
+
+    void show_merge_animated_not_supported() override
+    {
+        app_.message_box("Not supported", "Merging animated layers is not supported yet.");
+    }
+
+private:
+    App& app_;
+};
+
+class LegacyDocumentLayerOperationServices final : public pp::app::DocumentLayerOperationServices {
+public:
+    LegacyDocumentLayerOperationServices(
+        App& app,
+        const std::shared_ptr<Layer>& pending_layer = nullptr) noexcept
+        : app_(app)
+        , pending_layer_(pending_layer)
+    {
+    }
+
+    void add_layer(std::string_view name, int insert_index) override
+    {
+        auto* canvas = legacy_canvas();
+        if (!canvas)
+            return;
+
+        canvas->layer_add(std::string(name), pending_layer_, insert_index);
+        canvas->anim_update();
+    }
+
+    void duplicate_layer(int source_index, int insert_index) override
+    {
+        auto* canvas = legacy_canvas();
+        if (!canvas)
+            return;
+
+        std::string duplicated_name = "Layer";
+        if (app_.layers && !app_.layers->m_layers.empty())
+            duplicated_name = app_.layers->m_layers.back()->m_label_text;
+
+        canvas->layer_add(duplicated_name, nullptr, insert_index);
+        auto& dst = canvas->m_layers[insert_index];
+        auto& src = canvas->m_layers[source_index];
+        for (int i = 1; i < src->frames_count(); i++)
+            dst->add_frame();
+        canvas->anim_update();
+        for (int frame = 0; frame < src->frames_count(); frame++)
+        {
+            for (int i = 0; i < 6; i++)
+            {
+                if (!src->face(i))
+                    continue;
+                bool loaded = src->frame(frame).gpu_load();
+                dst->frame(frame).gpu_load();
+                dst->rtt(i, frame).copy(src->rtt(i));
+                dst->face(i, frame) = src->face(i);
+                dst->box(i, frame) = src->box(i);
+                if (!loaded)
+                {
+                    dst->frame(frame).gpu_unload();
+                    src->frame(frame).gpu_unload();
+                }
+            }
+        }
+        dst->m_opacity = src->m_opacity;
+        dst->m_blend_mode = src->m_blend_mode;
+        dst->m_alpha_locked = src->m_alpha_locked;
+    }
+
+    void select_layer(int index) override
+    {
+        if (auto* canvas = legacy_canvas())
+            canvas->m_current_layer_idx = index;
+    }
+
+    void reorder_layer(int from_index, int to_index) override
+    {
+        if (auto* canvas = legacy_canvas())
+            canvas->layer_order(from_index, to_index);
+    }
+
+    void remove_layer(int index) override
+    {
+        if (auto* canvas = legacy_canvas())
+            canvas->layer_remove(index);
+    }
+
+    void set_layer_opacity(int index, float opacity) override
+    {
+        if (auto* canvas = legacy_canvas())
+            canvas->m_layers[index]->m_opacity = opacity;
+    }
+
+    void set_layer_visibility(int index, bool visible) override
+    {
+        if (auto* canvas = legacy_canvas())
+            canvas->m_layers[index]->m_visible = visible;
+    }
+
+    void set_layer_alpha_lock(int index, bool locked) override
+    {
+        if (auto* canvas = legacy_canvas())
+            canvas->m_layers[index]->m_alpha_locked = locked;
+    }
+
+    void set_layer_blend_mode(int index, int blend_mode) override
+    {
+        if (auto* canvas = legacy_canvas())
+            canvas->m_layers[index]->m_blend_mode = blend_mode;
+    }
+
+    void set_layer_highlight(int index, bool highlighted) override
+    {
+        if (auto* canvas = legacy_canvas())
+            canvas->m_layers[index]->m_hightlight = highlighted;
+    }
+
+    void mark_unsaved() override
+    {
+        if (auto* canvas = legacy_canvas())
+            canvas->m_unsaved = true;
+    }
+
+    void reload_animation_layers() override
+    {
+        if (app_.animation)
+            app_.animation->load_layers();
+    }
+
+    void update_title() override
+    {
+        app_.title_update();
+    }
+
+private:
+    [[nodiscard]] Canvas* legacy_canvas() const noexcept
+    {
+        if (app_.canvas && app_.canvas->m_canvas)
+            return app_.canvas->m_canvas.get();
+        return Canvas::I;
+    }
+
+    App& app_;
+    std::shared_ptr<Layer> pending_layer_;
+};
+
+} // namespace
+
+pp::foundation::Status execute_legacy_document_layer_rename_plan(
+    App& app,
+    const pp::app::DocumentLayerRenamePlan& plan,
+    const std::shared_ptr<NodeDialogLayerRename>& dialog)
+{
+    LegacyDocumentLayerRenameServices services(app, dialog);
+    return pp::app::execute_document_layer_rename_plan(plan, services);
+}
+
+pp::foundation::Status execute_legacy_document_layer_menu_plan(
+    App& app,
+    const pp::app::DocumentLayerMenuPlan& plan)
+{
+    LegacyDocumentLayerMenuServices services(app);
+    return pp::app::execute_document_layer_menu_plan(plan, services);
+}
+
+pp::foundation::Status execute_legacy_document_layer_merge_plan(
+    App& app,
+    const pp::app::DocumentLayerMergePlan& plan)
+{
+    LegacyDocumentLayerMergeServices services(app);
+    return pp::app::execute_document_layer_merge_plan(plan, services);
+}
+
+pp::foundation::Status execute_legacy_document_layer_operation_plan(
+    App& app,
+    const pp::app::DocumentLayerOperationPlan& plan,
+    const std::shared_ptr<Layer>& pending_layer)
+{
+    LegacyDocumentLayerOperationServices services(app, pending_layer);
+    return pp::app::execute_document_layer_operation_plan(plan, services);
+}
+
+} // namespace pp::panopainter