342 lines
9.9 KiB
C++
342 lines
9.9 KiB
C++
#include "pch.h"
|
|
|
|
#include "legacy_document_layer_services.h"
|
|
|
|
#include "action.h"
|
|
#include "app.h"
|
|
#include "legacy_document_canvas_services.h"
|
|
#include "legacy_ui_overlay_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 record_layer_rename_undo(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));
|
|
}
|
|
|
|
void set_current_layer_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 new_name_copy(new_name);
|
|
layer_node->set_name(new_name_copy.c_str());
|
|
layer->m_name = new_name_copy;
|
|
}
|
|
|
|
void finish_layer_rename() override
|
|
{
|
|
if (dialog_)
|
|
pp::panopainter::close_legacy_dialog_node(*dialog_);
|
|
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
|