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

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);
}