204 lines
8.7 KiB
C++
204 lines
8.7 KiB
C++
#include "Document/ProjectWorkspace.h"
|
||
#include "Document/DocumentLimits.h"
|
||
#include "Document/LiveLayerMask.h"
|
||
#include "IO/ImageExporter.h"
|
||
#include "Logging.h"
|
||
#include <QFutureWatcher>
|
||
#include <QtConcurrent>
|
||
|
||
// Several rows are copied one after another, as Swift awaits.
|
||
void ProjectWorkspace::copyNext(std::vector<QUuid> ids, std::optional<QUuid> destination, std::optional<QPointF> point, std::function<void()> done)
|
||
{
|
||
if (ids.empty()) {
|
||
finish(done);
|
||
return;
|
||
}
|
||
const QUuid first = ids.front();
|
||
ids.erase(ids.begin());
|
||
copyLayer(first, destination, point, [self = QPointer(this), ids = std::move(ids), destination, point, done = std::move(done)]() mutable {
|
||
if (self)
|
||
self->copyNext(std::move(ids), destination, point, std::move(done));
|
||
});
|
||
}
|
||
|
||
std::optional<QUuid> ProjectWorkspace::draggedLayerSource(const QMimeData &data) const
|
||
{
|
||
const std::vector<QUuid> ids = layerIDs(data);
|
||
if (ids.empty())
|
||
return std::nullopt;
|
||
for (const std::shared_ptr<ProjectTab> &each : m_tabs) {
|
||
if (each->session.document() && indexOf(each->session.document()->layers, ids.front()) >= 0)
|
||
return each->id;
|
||
}
|
||
return std::nullopt;
|
||
}
|
||
|
||
bool ProjectWorkspace::canReceiveDrag(const QMimeData &data, std::optional<QUuid> destination) const
|
||
{
|
||
const std::optional<QUuid> source = draggedLayerSource(data);
|
||
return !destination || !source || *source != *destination;
|
||
}
|
||
|
||
void ProjectWorkspace::copyLayer(QUuid id, std::optional<QUuid> destination, std::optional<QPointF> point, std::function<void()> done)
|
||
{
|
||
copyLayers({id}, destination, point, std::move(done));
|
||
}
|
||
|
||
// Several keep their places relative to each other.
|
||
void ProjectWorkspace::copyLayers(const std::vector<QUuid> &ids, std::optional<QUuid> destination, std::optional<QPointF> point,
|
||
std::function<void()> done)
|
||
{
|
||
// A null pointer aborts when read; an iterator would not.
|
||
std::shared_ptr<ProjectTab> from;
|
||
for (const std::shared_ptr<ProjectTab> &each : m_tabs) {
|
||
if (!from && !ids.empty() && each->session.document() && indexOf(each->session.document()->layers, ids.front()) >= 0)
|
||
from = each;
|
||
}
|
||
if (!canSwitch() || !from || !from->session.canEditLayers() || destination == std::optional(from->id)) {
|
||
finish(done);
|
||
return;
|
||
}
|
||
Copy copy{.ids = ids, .from = from, .target = nullptr, .original = from->session.document().value(), .layers = {}, .included = {}, .point = point};
|
||
const ProjectSnapshot snapshot = copy.from->session.projectSnapshot().value();
|
||
copy.target = destination ? tab(*destination) : tab(addTab(false).id);
|
||
if (!copy.target || (destination && !copy.target->session.canStartProjectOperation())
|
||
|| (copy.target->session.document() && !copy.target->session.canEditLayers())) {
|
||
finish(done);
|
||
return;
|
||
}
|
||
for (const QUuid &id : ids) {
|
||
copy.included.insert(id);
|
||
copy.included.unite(copy.from->session.descendantIDs(id));
|
||
}
|
||
const auto pixels = [](const std::vector<ImageLayer> &layers) {
|
||
qint64 total = 0;
|
||
for (const ImageLayer &layer : layers)
|
||
total += layer.asset ? qint64(layer.asset->size().width()) * layer.asset->size().height() : 0;
|
||
return total;
|
||
};
|
||
for (const ImageLayer &layer : copy.original.layers) {
|
||
if (copy.included.contains(layer.id))
|
||
copy.layers.push_back(layer);
|
||
}
|
||
const qint64 used = copy.target->session.document() ? pixels(copy.target->session.document()->layers) : 0;
|
||
if (used + pixels(copy.layers) > DocumentLimits::documentPixelBudget()) {
|
||
copy.target->session.setImportError(QStringLiteral("The copied layers exceed this project’s %1-megapixel limit.").arg(DocumentLimits::documentBudgetMegapixels()));
|
||
finish(done);
|
||
return;
|
||
}
|
||
setManaging(true);
|
||
copy.from->session.setIsProjectBusy(true);
|
||
copy.target->session.setIsProjectBusy(true);
|
||
// A mask from outside the copy goes into the pixels.
|
||
std::vector<QUuid> outside;
|
||
for (const ImageLayer &layer : copy.layers) {
|
||
if (layer.maskSourceID && !copy.included.contains(*layer.maskSourceID))
|
||
outside.push_back(layer.id);
|
||
}
|
||
auto *watcher = new QFutureWatcher<Baked>(this);
|
||
connect(watcher, &QFutureWatcherBase::finished, this, [this, watcher, copy, done] {
|
||
watcher->deleteLater();
|
||
const Baked baked = watcher->result();
|
||
if (baked.failure) {
|
||
qCWarning(lcApp).noquote() << "cannot copy the layers:" << *baked.failure;
|
||
copy.target->session.setImportError(baked.failure);
|
||
} else {
|
||
place(copy, baked.images);
|
||
}
|
||
// Managing ends last: its signal sees both projects free.
|
||
copy.from->session.setIsProjectBusy(false);
|
||
copy.target->session.setIsProjectBusy(false);
|
||
setManaging(false);
|
||
finish(done);
|
||
});
|
||
watcher->setFuture(QtConcurrent::run([snapshot, outside]() -> Baked {
|
||
Baked result;
|
||
try {
|
||
for (const QUuid layer : outside) {
|
||
if (const std::optional<ImportedImage> image = LiveMaskBaker::bake(snapshot, layer))
|
||
result.images.insert({layer, *image});
|
||
}
|
||
} catch (const ExportError &error) {
|
||
result.failure = QString::fromUtf8(error.what());
|
||
}
|
||
return result;
|
||
}));
|
||
}
|
||
|
||
void ProjectWorkspace::place(const Copy ©, const EditorSession::BakedImages &baked)
|
||
{
|
||
QHash<QUuid, QUuid> mapping;
|
||
for (const ImageLayer &layer : copy.layers)
|
||
mapping.insert(layer.id, QUuid::createUuid());
|
||
EditorSession &into = copy.target->session;
|
||
const QSizeF size = into.document() ? into.document()->size() : copy.original.size();
|
||
// One layer anchors on its centre; several, on their box.
|
||
QRectF pictured;
|
||
for (const ImageLayer &layer : copy.layers) {
|
||
if (!layer.isGroup)
|
||
pictured = pictured.isNull() ? QRectF(layer.transform.origin, layer.transform.size) : pictured.united(QRectF(layer.transform.origin, layer.transform.size));
|
||
}
|
||
const QPointF anchor = copy.ids.size() == 1 || pictured.isNull() ? copy.layers[indexOf(copy.layers, copy.ids.front())].transform.center() : pictured.center();
|
||
const QPointF shift = copy.point.value_or(QPointF(size.width() / 2, size.height() / 2)) - anchor;
|
||
const auto mapped = [&](const std::optional<QUuid> &old) {
|
||
return old && mapping.contains(*old) ? std::optional(mapping.value(*old)) : std::nullopt;
|
||
};
|
||
std::vector<ImageLayer> layers;
|
||
for (ImageLayer layer : copy.layers) {
|
||
if (baked.contains(layer.id))
|
||
layer.asset = baked.at(layer.id);
|
||
layer.id = mapping.value(layer.id);
|
||
layer.transform.origin += shift;
|
||
if (layer.mask && layer.mask->placement)
|
||
layer.mask->placement->origin += shift;
|
||
// A parent or mask source outside the copy lets go.
|
||
layer.parentID = mapped(layer.parentID);
|
||
layer.maskSourceID = mapped(layer.maskSourceID);
|
||
layers.push_back(layer);
|
||
}
|
||
// Busy sessions refuse a new canvas: free it first.
|
||
into.setIsProjectBusy(false);
|
||
into.beginEdit(QStringLiteral("Copy Layers from Project"));
|
||
if (!into.document())
|
||
into.createDocument(int(size.width()), int(size.height()));
|
||
into.m_document->layers.insert(into.m_document->layers.end(), layers.begin(), layers.end());
|
||
into.setActiveLayerID(mapping.value(copy.ids.front()));
|
||
into.m_selectedLayerIDs.clear();
|
||
// A layer the source tab lacks was not copied.
|
||
for (const QUuid &id : copy.ids) {
|
||
if (mapping.contains(id))
|
||
into.m_selectedLayerIDs.insert(mapping.value(id));
|
||
}
|
||
into.endEdit();
|
||
// Announced by the caller, which stops managing next.
|
||
m_selectedID = copy.target->id;
|
||
}
|
||
|
||
// Ctrl+V with layers copied whole; false leaves Paste to pixels.
|
||
bool ProjectWorkspace::pasteCopiedLayer()
|
||
{
|
||
std::shared_ptr<ProjectTab> source;
|
||
for (const std::shared_ptr<ProjectTab> &each : m_tabs) {
|
||
const std::optional<CopiedLayer> &copied = each->session.copiedLayer();
|
||
if (!source && copied && EditorSession::clipboardHolds(copied->data))
|
||
source = each;
|
||
}
|
||
if (!source || !source->session.document())
|
||
return false;
|
||
std::vector<QUuid> ids;
|
||
for (const QUuid &id : source->session.copiedLayer()->ids) {
|
||
if (indexOf(source->session.document()->layers, id) >= 0)
|
||
ids.push_back(id);
|
||
}
|
||
if (ids.empty())
|
||
return false;
|
||
if (source->id == m_selectedID) {
|
||
if (!source->session.canEditLayers())
|
||
return false;
|
||
source->session.duplicateLayers(ids, QStringLiteral("Paste"));
|
||
return true;
|
||
}
|
||
copyLayers(ids, m_selectedID);
|
||
return true;
|
||
}
|