395 lines
14 KiB
C++
395 lines
14 KiB
C++
#include "IO/ProjectController.h"
|
||
#include "Document/ProjectWorkspace.h"
|
||
#include "IO/ProjectStore.h"
|
||
#include "Logging.h"
|
||
#include <QFileDialog>
|
||
#include <QFileInfo>
|
||
#include <QFutureWatcher>
|
||
#include <QMessageBox>
|
||
#include <QPushButton>
|
||
#include <QTimer>
|
||
#include <QtConcurrent>
|
||
|
||
bool ProjectController::isProject(const QUrl &url)
|
||
{
|
||
return QFileInfo(url.adjusted(QUrl::StripTrailingSlash).path()).suffix().toLower() == QLatin1String("comp");
|
||
}
|
||
|
||
bool ProjectController::samePlace(const std::optional<QString> &path, const QString &other)
|
||
{
|
||
// Nothing there resolves to nothing: compare the names then.
|
||
const auto resolved = [](const QString &place) {
|
||
const QString canonical = QFileInfo(place).canonicalFilePath();
|
||
return canonical.isEmpty() ? QFileInfo(place).absoluteFilePath() : canonical;
|
||
};
|
||
return path && resolved(*path) == resolved(other);
|
||
}
|
||
|
||
ProjectController::ProjectController(EditorSession &session) : session(session)
|
||
{
|
||
externalChanges.recheck = new QTimer(this);
|
||
externalChanges.recheck->setSingleShot(true);
|
||
externalChanges.recheck->setTimerType(Qt::PreciseTimer);
|
||
connect(externalChanges.recheck, &QTimer::timeout, this, &ProjectController::noteExternalChange);
|
||
}
|
||
|
||
bool ProjectController::canStart() const
|
||
{
|
||
return session.canStartProjectOperation() && !(workspace && workspace->isManaging());
|
||
}
|
||
|
||
std::optional<QUuid> ProjectController::ownTab() const
|
||
{
|
||
if (!workspace)
|
||
return std::nullopt;
|
||
for (const std::shared_ptr<ProjectTab> &tab : workspace->tabs()) {
|
||
if (&tab->controller == this)
|
||
return tab->id;
|
||
}
|
||
return std::nullopt;
|
||
}
|
||
|
||
bool ProjectController::begin()
|
||
{
|
||
if (!session.canStartProjectOperation())
|
||
return false;
|
||
session.cancelCrop();
|
||
session.commitTransform();
|
||
session.setIsProjectBusy(true);
|
||
return true;
|
||
}
|
||
|
||
void ProjectController::finish(const std::function<void(bool)> &done, bool value)
|
||
{
|
||
// The caller goes on first, like a resumed Swift task.
|
||
if (done)
|
||
QMetaObject::invokeMethod(this, [done, value] { done(value); }, Qt::QueuedConnection);
|
||
}
|
||
|
||
void ProjectController::save(bool asNew, std::function<void(bool)> done)
|
||
{
|
||
if (!session.document() || !begin()) {
|
||
finish(done, false);
|
||
return;
|
||
}
|
||
saveCurrent(asNew, [this, done](bool saved) {
|
||
session.setIsProjectBusy(false);
|
||
finish(done, saved);
|
||
});
|
||
}
|
||
|
||
void ProjectController::saveCurrent(bool asNew, std::function<void(bool)> then)
|
||
{
|
||
const std::optional<ProjectSnapshot> snapshot = session.projectSnapshot();
|
||
if (!snapshot) {
|
||
then(true);
|
||
return;
|
||
}
|
||
if (!asNew && session.projectPath()) {
|
||
write(*snapshot, *session.projectPath(), then);
|
||
return;
|
||
}
|
||
auto *panel = new QFileDialog(window, asNew ? QStringLiteral("Save Project As") : QStringLiteral("Save Project"));
|
||
panel->setAttribute(Qt::WA_DeleteOnClose);
|
||
panel->setAcceptMode(QFileDialog::AcceptSave);
|
||
panel->setDefaultSuffix(QStringLiteral("comp"));
|
||
panel->selectFile(session.projectPath() ? QFileInfo(*session.projectPath()).fileName() : QStringLiteral("Untitled.comp"));
|
||
connect(panel, &QDialog::finished, this, [this, panel, snapshot = *snapshot, then](int result) {
|
||
if (result != QDialog::Accepted) {
|
||
then(false);
|
||
return;
|
||
}
|
||
// The panel only suggests the suffix; a project needs it.
|
||
const QString chosen = panel->selectedFiles().value(0);
|
||
if (isProject(QUrl::fromLocalFile(chosen))) {
|
||
write(snapshot, chosen, then);
|
||
return;
|
||
}
|
||
// The panel never saw this name: nothing there is replaced.
|
||
const QFileInfo renamed(chosen + QStringLiteral(".comp"));
|
||
// A link that leads nowhere is still in the way.
|
||
if (renamed.exists() || renamed.isSymLink()) {
|
||
showError(QStringLiteral("Couldn’t save the project"),
|
||
QStringLiteral("“%1” already exists. Choose another name.").arg(renamed.fileName()), [then] { then(false); });
|
||
return;
|
||
}
|
||
write(snapshot, renamed.filePath(), then);
|
||
});
|
||
panel->open();
|
||
}
|
||
|
||
void ProjectController::write(const ProjectSnapshot &snapshot, const QString &destination, std::function<void(bool)> then)
|
||
{
|
||
// Our own save changes the package: its events are ours.
|
||
externalChanges.saving = true;
|
||
auto *watcher = new QFutureWatcher<std::optional<QString>>(this);
|
||
connect(watcher, &QFutureWatcherBase::finished, this, [this, watcher, destination, then] {
|
||
watcher->deleteLater();
|
||
if (const std::optional<QString> failure = watcher->result()) {
|
||
// Swift's defer: the guard lasts until the alert is answered.
|
||
showError(QStringLiteral("Couldn’t save the project"), *failure, [this, then] {
|
||
externalChanges.saving = false;
|
||
then(false);
|
||
});
|
||
return;
|
||
}
|
||
session.setProjectPath(destination);
|
||
session.history.markSaved();
|
||
m_saveGeneration += 1;
|
||
rememberProjectDigest(destination, [this, destination, then] {
|
||
watchProject(destination);
|
||
externalChanges.saving = false;
|
||
then(true);
|
||
});
|
||
});
|
||
// The store blocks on the disk: off the UI thread.
|
||
watcher->setFuture(QtConcurrent::run([snapshot, destination]() -> std::optional<QString> {
|
||
try {
|
||
ProjectStore::save(snapshot, destination);
|
||
return std::nullopt;
|
||
} catch (const std::runtime_error &error) {
|
||
return QString::fromUtf8(error.what());
|
||
}
|
||
}));
|
||
}
|
||
|
||
void ProjectController::load(const QString &path, std::function<void(Loaded)> then)
|
||
{
|
||
auto *watcher = new QFutureWatcher<Loaded>(this);
|
||
connect(watcher, &QFutureWatcherBase::finished, this, [watcher, then] {
|
||
watcher->deleteLater();
|
||
then(watcher->result());
|
||
});
|
||
watcher->setFuture(QtConcurrent::run([path]() -> Loaded {
|
||
try {
|
||
return {ProjectStore::load(path), QString()};
|
||
} catch (const std::runtime_error &error) {
|
||
return {std::nullopt, QString::fromUtf8(error.what())};
|
||
}
|
||
}));
|
||
}
|
||
|
||
void ProjectController::open(std::optional<QString> path, std::function<void(bool)> done)
|
||
{
|
||
if (workspace) {
|
||
workspace->open(path, done);
|
||
return;
|
||
}
|
||
if (!begin()) {
|
||
finish(done, false);
|
||
return;
|
||
}
|
||
const auto end = [this, done](bool opened) {
|
||
session.setIsProjectBusy(false);
|
||
finish(done, opened);
|
||
};
|
||
const auto refuse = [this, end](const QString &failure) {
|
||
showError(QStringLiteral("Couldn’t open the project"), failure, [end] { end(false); });
|
||
};
|
||
const auto read = [this, end, refuse](QString source) {
|
||
// A folder's trailing slash would leave it without a name.
|
||
while (source.endsWith(QLatin1Char('/')))
|
||
source.chop(1);
|
||
// Validated first: a corrupt project never discards the live document.
|
||
load(source, [this, end, refuse, source](const Loaded &first) {
|
||
if (!first.snapshot) {
|
||
refuse(first.failure);
|
||
return;
|
||
}
|
||
const int previousSave = m_saveGeneration;
|
||
confirmReplacement([this, end, refuse, source, first, previousSave](bool proceed) {
|
||
if (!proceed) {
|
||
end(false);
|
||
return;
|
||
}
|
||
// Saving in the confirmation can replace the opened file.
|
||
if (m_saveGeneration == previousSave || !samePlace(session.projectPath(), source)) {
|
||
session.installProject(*first.snapshot, source);
|
||
rememberProjectDigest(source, [this, source, end] {
|
||
watchProject(source);
|
||
end(true);
|
||
});
|
||
return;
|
||
}
|
||
load(source, [this, end, refuse, source](const Loaded &again) {
|
||
if (!again.snapshot) {
|
||
refuse(again.failure);
|
||
return;
|
||
}
|
||
session.installProject(*again.snapshot, source);
|
||
rememberProjectDigest(source, [this, source, end] {
|
||
watchProject(source);
|
||
end(true);
|
||
});
|
||
});
|
||
});
|
||
});
|
||
};
|
||
if (path) {
|
||
read(*path);
|
||
return;
|
||
}
|
||
// A project is a folder here: one a dialog.
|
||
auto *panel = new QFileDialog(window, QStringLiteral("Open Project"));
|
||
panel->setAttribute(Qt::WA_DeleteOnClose);
|
||
panel->setFileMode(QFileDialog::Directory);
|
||
connect(panel, &QDialog::finished, this, [panel, read, end](int result) {
|
||
if (result != QDialog::Accepted) {
|
||
end(false);
|
||
return;
|
||
}
|
||
read(panel->selectedFiles().value(0));
|
||
});
|
||
panel->open();
|
||
}
|
||
|
||
void ProjectController::newCanvas()
|
||
{
|
||
if (workspace) {
|
||
workspace->newCanvas();
|
||
return;
|
||
}
|
||
if (!begin())
|
||
return;
|
||
confirmReplacement([this](bool proceed) {
|
||
session.setIsProjectBusy(false);
|
||
if (!proceed)
|
||
return;
|
||
session.clearProject();
|
||
stopWatchingProject();
|
||
});
|
||
}
|
||
|
||
void ProjectController::close(QWidget *closing)
|
||
{
|
||
if (const std::optional<QUuid> tab = ownTab()) {
|
||
workspace->close(*tab);
|
||
return;
|
||
}
|
||
if (!begin())
|
||
return;
|
||
confirmReplacement([this, closing = QPointer<QWidget>(closing)](bool proceed) {
|
||
session.setIsProjectBusy(false);
|
||
if (!proceed)
|
||
return;
|
||
session.clearProject();
|
||
stopWatchingProject();
|
||
if (closing)
|
||
closing->close();
|
||
});
|
||
}
|
||
|
||
void ProjectController::confirmQuit(std::function<void(bool)> done)
|
||
{
|
||
if (!begin()) {
|
||
finish(done, false);
|
||
return;
|
||
}
|
||
confirmReplacement([this, done](bool proceed) {
|
||
session.setIsProjectBusy(false);
|
||
finish(done, proceed);
|
||
});
|
||
}
|
||
|
||
void ProjectController::confirmReplacement(std::function<void(bool)> then)
|
||
{
|
||
if (!session.isModified() || !session.document()) {
|
||
then(true);
|
||
return;
|
||
}
|
||
const QString name = session.projectPath() ? QFileInfo(*session.projectPath()).fileName() : QStringLiteral("Untitled");
|
||
auto *alert = new QMessageBox(window);
|
||
alert->setAttribute(Qt::WA_DeleteOnClose);
|
||
alert->setIcon(QMessageBox::Warning);
|
||
alert->setText(QStringLiteral("Save changes to %1?").arg(name));
|
||
alert->setInformativeText(QStringLiteral("Your changes will be lost if you don’t save them."));
|
||
const QPushButton *save = alert->addButton(QStringLiteral("Save"), QMessageBox::AcceptRole);
|
||
alert->addButton(QStringLiteral("Cancel"), QMessageBox::RejectRole);
|
||
const QPushButton *discard = alert->addButton(QStringLiteral("Don’t Save"), QMessageBox::DestructiveRole);
|
||
connect(alert, &QDialog::finished, this, [this, alert, save, discard, then] {
|
||
if (alert->clickedButton() == save)
|
||
saveCurrent(false, then);
|
||
else
|
||
then(alert->clickedButton() == discard);
|
||
});
|
||
alert->open();
|
||
}
|
||
|
||
void ProjectController::showError(const QString &title, const QString &message, std::function<void()> then)
|
||
{
|
||
qCWarning(lcIO).noquote() << title + QStringLiteral(": ") + message;
|
||
auto *alert = new QMessageBox(window);
|
||
alert->setAttribute(Qt::WA_DeleteOnClose);
|
||
alert->setIcon(QMessageBox::Warning);
|
||
alert->setText(title);
|
||
alert->setInformativeText(message);
|
||
alert->addButton(QStringLiteral("OK"), QMessageBox::AcceptRole);
|
||
connect(alert, &QDialog::finished, this, std::move(then));
|
||
alert->open();
|
||
}
|
||
|
||
void ProjectController::receive(const QList<QUrl> &urls, std::optional<QPointF> point, std::function<void()> done)
|
||
{
|
||
if (const std::optional<QUuid> tab = ownTab()) {
|
||
workspace->receive(urls, tab, point, done);
|
||
return;
|
||
}
|
||
if (urls.isEmpty()) {
|
||
if (done)
|
||
QMetaObject::invokeMethod(this, done, Qt::QueuedConnection);
|
||
return;
|
||
}
|
||
m_incoming.push_back({urls, point, std::move(done)});
|
||
if (m_processing)
|
||
return;
|
||
m_processing = true;
|
||
QMetaObject::invokeMethod(this, &ProjectController::drainIncoming, Qt::QueuedConnection);
|
||
}
|
||
|
||
void ProjectController::drainIncoming()
|
||
{
|
||
if (m_incoming.empty()) {
|
||
m_processing = false;
|
||
return;
|
||
}
|
||
const Incoming request = m_incoming.front();
|
||
m_incoming.pop_front();
|
||
// The session keeps this waiter, perhaps longer than the controller.
|
||
session.waitForFileRequest([self = QPointer<ProjectController>(this), request] {
|
||
if (self)
|
||
self->handle(request);
|
||
});
|
||
}
|
||
|
||
void ProjectController::handle(const Incoming &request)
|
||
{
|
||
QList<QUrl> projects, images;
|
||
for (const QUrl &url : request.urls)
|
||
(isProject(url) ? projects : images) << url;
|
||
const auto next = [this, done = request.done] {
|
||
if (done)
|
||
QMetaObject::invokeMethod(this, done, Qt::QueuedConnection);
|
||
drainIncoming();
|
||
};
|
||
if (projects.size() > 1) {
|
||
showError(QStringLiteral("Open one project at a time"), QString::fromUtf8(ProjectError(ProjectError::Kind::invalid).what()), next);
|
||
return;
|
||
}
|
||
// Beside a project the images go to the centre.
|
||
const auto bringIn = [this, images, next, point = projects.isEmpty() ? request.point : std::nullopt](bool proceed) {
|
||
if (!proceed) {
|
||
next();
|
||
return;
|
||
}
|
||
// The session keeps this callback as well.
|
||
session.importImages(images, point, [self = QPointer<ProjectController>(this), next] {
|
||
if (self)
|
||
next();
|
||
});
|
||
};
|
||
if (projects.isEmpty())
|
||
bringIn(true);
|
||
else
|
||
open(projects.constFirst().toLocalFile(), bringIn);
|
||
}
|