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

Centralize legacy document layer bridge

Browse Source
This commit is contained in:
omigamedev
2026-06-03 21:16:07 +02:00
parent 855c388027
commit 7460453b80
8 changed files with 382 additions and 301 deletions
Download Patch File Download Diff File Expand all files Collapse all files

77
src/app_dialogs.cpp
View File

@@ -1,11 +1,11 @@
#include "pch.h"
#include "app.h"
#include "action.h"
#include "app_core/document_layer.h"
#include "app_core/document_resize.h"
#include "app_core/document_export.h"
#include "app_core/document_session.h"
#include "legacy_document_canvas_services.h"
#include "legacy_document_layer_services.h"
#include "legacy_history_services.h"
#include "settings.h"
#include "node_dialog_open.h"
@@ -52,78 +52,6 @@ namespace {
return false;
}
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_;
};
}
std::shared_ptr<NodeProgressBar> App::show_progress(const std::string& title, int total /*= 0*/)
@@ -683,8 +611,7 @@ void App::dialog_layer_rename()
const auto plan = pp::app::plan_document_layer_rename(old_name, dialog->get_name());
if (!plan)
return;
LegacyDocumentLayerRenameServices services(*this, dialog);
const auto status = pp::app::execute_document_layer_rename_plan(plan.value(), services);
const auto status = pp::panopainter::execute_legacy_document_layer_rename_plan(*this, plan.value(), dialog);
if (!status.ok())
LOG("Layer rename failed: %s", status.message);
};

221
src/app_layout.cpp
View File

@@ -19,6 +19,7 @@
#include "app_core/main_toolbar.h"
#include "app_core/tools_menu.h"
#include "legacy_document_canvas_services.h"
#include "legacy_document_layer_services.h"
#include "legacy_history_services.h"
#include "settings.h"
#include "serializer.h"
@@ -141,8 +142,6 @@ bool apply_brush_preset_plan(App& app, const std::shared_ptr<Brush>& brush)
return status.ok();
}
void execute_document_layer_merge_plan(App& app, const pp::app::DocumentLayerMergePlan& plan);
bool apply_document_export_menu_plan(App& app, pp::app::DocumentExportMenuKind kind)
{
class LegacyDocumentExportMenuServices final : public pp::app::DocumentExportMenuServices {
@@ -536,215 +535,6 @@ 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 = pp::panopainter::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;
execute_document_layer_merge_plan(app_, plan.value());
}
void show_merge_animated_not_supported() override
{
app_.message_box("Not supported", "Merging animated layers is not supported yet.");
}
private:
App& app_;
};
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 LegacyDocumentLayerOperationServices final : public pp::app::DocumentLayerOperationServices {
public:
LegacyDocumentLayerOperationServices(
App& app,
const std::shared_ptr<class 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<class Layer> pending_layer_;
};
void execute_main_toolbar_plan(App& app, const pp::app::MainToolbarPlan& plan)
{
LegacyMainToolbarServices services(app);
@@ -771,16 +561,14 @@ void execute_tools_menu_plan(App& app, const pp::app::ToolsMenuPlan& plan)
void execute_document_layer_menu_plan(App& app, const pp::app::DocumentLayerMenuPlan& plan)
{
LegacyDocumentLayerMenuServices services(app);
const auto status = pp::app::execute_document_layer_menu_plan(plan, services);
const auto status = pp::panopainter::execute_legacy_document_layer_menu_plan(app, plan);
if (!status.ok())
LOG("Layer menu action failed: %s", status.message);
}
void execute_document_layer_merge_plan(App& app, const pp::app::DocumentLayerMergePlan& plan)
{
LegacyDocumentLayerMergeServices services(app);
const auto status = pp::app::execute_document_layer_merge_plan(plan, services);
const auto status = pp::panopainter::execute_legacy_document_layer_merge_plan(app, plan);
if (!status.ok())
LOG("Layer merge failed: %s", status.message);
}
@@ -790,8 +578,7 @@ void execute_document_layer_operation_plan(
const pp::app::DocumentLayerOperationPlan& plan,
const std::shared_ptr<class Layer>& pending_layer = nullptr)
{
LegacyDocumentLayerOperationServices services(app, pending_layer);
const auto status = pp::app::execute_document_layer_operation_plan(plan, services);
const auto status = pp::panopainter::execute_legacy_document_layer_operation_plan(app, plan, pending_layer);
if (!status.ok())
LOG("Layer operation failed: %s", status.message);
}

330
src/legacy_document_layer_services.cpp Normal file
View File

@@ -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

29
src/legacy_document_layer_services.h Normal file
View File

@@ -0,0 +1,29 @@
#pragma once
#include "app_core/document_layer.h"
#include "foundation/result.h"
#include <memory>
class App;
class Layer;
class NodeDialogLayerRename;
namespace pp::panopainter {
[[nodiscard]] pp::foundation::Status execute_legacy_document_layer_rename_plan(
App& app,
const pp::app::DocumentLayerRenamePlan& plan,
const std::shared_ptr<NodeDialogLayerRename>& dialog);
[[nodiscard]] pp::foundation::Status execute_legacy_document_layer_menu_plan(
App& app,
const pp::app::DocumentLayerMenuPlan& plan);
[[nodiscard]] pp::foundation::Status execute_legacy_document_layer_merge_plan(
App& app,
const pp::app::DocumentLayerMergePlan& plan);
[[nodiscard]] pp::foundation::Status execute_legacy_document_layer_operation_plan(
App& app,
const pp::app::DocumentLayerOperationPlan& plan,
const std::shared_ptr<Layer>& pending_layer = nullptr);
} // namespace pp::panopainter