Aegisub/src/fold_controller.cpp

371 lines
11 KiB
C++

// Copyright (c) 2022, arch1t3cht <arch1t3cht@gmail.com>
//
// Permission to use, copy, modify, and distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
//
// Aegisub Project http://www.aegisub.org/
#include "fold_controller.h"
#include "ass_file.h"
#include "include/aegisub/context.h"
#include "format.h"
#include "subs_controller.h"
#include <algorithm>
#include <unordered_map>
#include <libaegisub/split.h>
#include <libaegisub/util.h>
const char *folds_key = "_aegi_folddata";
FoldController::FoldController(agi::Context *c)
: context(c)
, pre_commit_listener(c->ass->AddPreCommitListener(&FoldController::FixFoldsPreCommit, this))
{ }
bool FoldController::CanAddFold(AssDialogue& start, AssDialogue& end) {
if (start.Fold.valid || end.Fold.valid) {
return false;
}
int folddepth = 0;
for (auto it = std::next(context->ass->Events.begin(), start.Row); it->Row < end.Row; it++) {
if (it->Fold.valid) {
folddepth += it->Fold.side ? -1 : 1;
}
if (folddepth < 0) {
return false;
}
}
return folddepth == 0;
}
void FoldController::RawAddFold(AssDialogue& start, AssDialogue& end, bool collapsed) {
int id = ++max_fold_id;
context->ass->SetExtradataValue(start, folds_key, agi::format("0;%d;%d", int(collapsed), id));
context->ass->SetExtradataValue(end, folds_key, agi::format("1;%d;%d", int(collapsed), id));
}
void FoldController::UpdateLineExtradata(AssDialogue &line) {
if (line.Fold.extraExists)
context->ass->SetExtradataValue(line, folds_key, agi::format("%d;%d;%d", int(line.Fold.side), int(line.Fold.collapsed), int(line.Fold.id)));
else
context->ass->DeleteExtradataValue(line, folds_key);
}
void FoldController::InvalidateLineFold(AssDialogue &line) {
line.Fold.valid = false;
if (++line.Fold.invalidCount > 100) {
line.Fold.extraExists = false;
UpdateLineExtradata(line);
}
}
void FoldController::AddFold(AssDialogue& start, AssDialogue& end, bool collapsed) {
if (CanAddFold(start, end)) {
RawAddFold(start, end, true);
context->ass->Commit(_("add fold"), AssFile::COMMIT_FOLD);
}
}
void FoldController::DoForAllFolds(std::function<void(AssDialogue&)> action) {
for (AssDialogue& line : context->ass->Events) {
if (line.Fold.valid) {
action(line);
UpdateLineExtradata(line);
}
}
}
void FoldController::FixFoldsPreCommit(int type, const AssDialogue *single_line) {
if ((type & (AssFile::COMMIT_FOLD | AssFile::COMMIT_DIAG_ADDREM | AssFile::COMMIT_ORDER)) || type == AssFile::COMMIT_NEW) {
UpdateFoldInfo();
}
}
// For each line in lines, applies action() to the opening delimiter of the innermost fold containing this line.
//
// In general, this can leave the folds in an inconsistent state, so unless action() is read-only this should always
// be followed by a commit.
void FoldController::DoForFoldsAt(std::vector<AssDialogue *> const& lines, std::function<void(AssDialogue&)> action) {
std::map<int, bool> visited;
for (AssDialogue *line : lines) {
if (line->Fold.parent != nullptr && !(line->Fold.valid && !line->Fold.side)) {
line = line->Fold.parent;
}
if (visited.count(line->Row))
continue;
action(*line);
UpdateLineExtradata(*line);
visited[line->Row] = true;
}
}
void FoldController::UpdateFoldInfo() {
ReadFromExtradata();
FixFolds();
LinkFolds();
}
void FoldController::ReadFromExtradata() {
max_fold_id = 0;
for (auto line = context->ass->Events.begin(); line != context->ass->Events.end(); line++) {
line->Fold.extraExists = false;
for (auto const& extra : context->ass->GetExtradata(line->ExtradataIds)) {
if (extra.key == folds_key) {
std::vector<std::string> fields;
agi::Split(fields, extra.value, ';');
if (fields.size() != 3)
break;
int side;
int collapsed;
if (!agi::util::try_parse(fields[0], &side)) break;
if (!agi::util::try_parse(fields[1], &collapsed)) break;
if (!agi::util::try_parse(fields[2], &line->Fold.id)) break;
line->Fold.side = side;
line->Fold.collapsed = collapsed;
line->Fold.extraExists = true;
max_fold_id = std::max(max_fold_id, line->Fold.id);
break;
}
}
line->Fold.valid = line->Fold.extraExists;
}
}
void FoldController::FixFolds() {
// Stack of which folds we've desended into so far
std::vector<AssDialogue *> foldStack;
// ID's for which we've found starters
std::unordered_map<int, AssDialogue*> foldHeads;
// ID's for which we've either found a valid starter and ender,
// or determined that the respective fold is invalid. All further
// fold data with this ID is skipped and deleted.
std::unordered_map<int, bool> completedFolds;
// Map iteratively applied to all id's.
// Once some fold has been completely found, subsequent markers found with the same id will be mapped to this new id.
std::unordered_map<int, int> idRemap;
for (auto line = context->ass->Events.begin(); line != context->ass->Events.end(); line++) {
if (line->Fold.extraExists) {
bool needs_update = false;
while (idRemap.count(line->Fold.id)) {
line->Fold.id = idRemap[line->Fold.id];
needs_update = true;
}
if (completedFolds.count(line->Fold.id)) { // Duplicate entry - try to start a new one
idRemap[line->Fold.id] = ++max_fold_id;
line->Fold.id = idRemap[line->Fold.id];
needs_update = true;
}
if (!line->Fold.side) {
if (foldHeads.count(line->Fold.id)) { // Duplicate entry
InvalidateLineFold(*line);
} else {
foldHeads[line->Fold.id] = &*line;
foldStack.push_back(&*line);
}
} else {
if (!foldHeads.count(line->Fold.id)) { // Non-matching ender
// Deactivate it. Because we can, also push it to completedFolds:
// If its counterpart appears further below, we can delete it right away.
completedFolds[line->Fold.id] = true;
InvalidateLineFold(*line);
} else {
// We found a fold. Now we need to see if the stack matches.
// We scan our stack for the counterpart of the fold.
// If one exists, we assume all starters above it are invalid.
// If none exists, we assume this ender is invalid.
// If none of these assumptions are true, the folds are probably
// broken beyond repair.
completedFolds[line->Fold.id] = true;
bool found = false;
for (int i = foldStack.size() - 1; i >= 0; i--) {
if (foldStack[i]->Fold.id == line->Fold.id) {
// Erase all folds further inward
for (int j = foldStack.size() - 1; j > i; j--) {
completedFolds[foldStack[j]->Fold.id] = true;
InvalidateLineFold(*foldStack[j]);
foldStack.pop_back();
}
// Sync the found fold and pop the stack
if (line->Fold.collapsed != foldStack[i]->Fold.collapsed) {
line->Fold.collapsed = foldStack[i]->Fold.collapsed;
needs_update = true;
}
foldStack.pop_back();
found = true;
break;
}
}
if (!found) {
completedFolds[line->Fold.id] = true;
InvalidateLineFold(*line);
}
}
}
if (needs_update) {
UpdateLineExtradata(*line);
}
}
}
// All remaining lines are invalid
for (AssDialogue *line : foldStack) {
line->Fold.valid = false;
if (++line->Fold.invalidCount > 100) {
line->Fold.extraExists = false;
UpdateLineExtradata(*line);
}
}
}
void FoldController::LinkFolds() {
std::vector<AssDialogue *> foldStack;
AssDialogue *lastVisible = nullptr;
maxdepth = 0;
int visibleRow = 0;
int highestFolded = 1;
for (auto line = context->ass->Events.begin(); line != context->ass->Events.end(); line++) {
line->Fold.parent = foldStack.empty() ? nullptr : foldStack.back();
line->Fold.nextVisible = nullptr;
line->Fold.visible = highestFolded > (int) foldStack.size();
line->Fold.visibleRow = visibleRow;
if (line->Fold.visible) {
if (lastVisible != nullptr) {
lastVisible->Fold.nextVisible = &*line;
}
lastVisible = &*line;
visibleRow++;
}
if (line->Fold.valid && !line->Fold.side) {
foldStack.push_back(&*line);
if (!line->Fold.collapsed && highestFolded == (int) foldStack.size()) {
highestFolded++;
}
if ((int) foldStack.size() > maxdepth) {
maxdepth = foldStack.size();
}
}
if (line->Fold.valid && line->Fold.side) {
line->Fold.counterpart = foldStack.back();
(*foldStack.rbegin())->Fold.counterpart = &*line;
if (highestFolded >= (int) foldStack.size()) {
highestFolded = foldStack.size();
}
foldStack.pop_back();
}
}
}
int FoldController::GetMaxDepth() {
return maxdepth;
}
void FoldController::ClearAllFolds() {
DoForAllFolds([&](AssDialogue &line) {
line.Fold.extraExists = false; line.Fold.valid = false;
});
context->ass->Commit(_("clear all folds"), AssFile::COMMIT_FOLD);
}
void FoldController::OpenAllFolds() {
DoForAllFolds([&](AssDialogue &line) {
line.Fold.collapsed = false;
});
context->ass->Commit(_("open all folds"), AssFile::COMMIT_FOLD);
}
void FoldController::CloseAllFolds() {
DoForAllFolds([&](AssDialogue &line) {
line.Fold.collapsed = true;
});
context->ass->Commit(_("close all folds"), AssFile::COMMIT_FOLD);
}
bool FoldController::HasFolds() {
bool hasfold = false;
DoForAllFolds([&](AssDialogue &line) {
hasfold = hasfold || line.Fold.valid;
});
return hasfold;
}
void FoldController::ClearFoldsAt(std::vector<AssDialogue *> const& lines) {
DoForFoldsAt(lines, [&](AssDialogue &line) {
line.Fold.extraExists = false; line.Fold.valid = false;
if (line.Fold.counterpart) {
line.Fold.counterpart->Fold.extraExists = false;
line.Fold.counterpart->Fold.valid = false;
}
});
context->ass->Commit(_("clear folds"), AssFile::COMMIT_FOLD);
}
void FoldController::OpenFoldsAt(std::vector<AssDialogue *> const& lines) {
DoForFoldsAt(lines, [&](AssDialogue &line) {
line.Fold.collapsed = false;
if (line.Fold.counterpart)
line.Fold.counterpart->Fold.collapsed = line.Fold.collapsed;
});
context->ass->Commit(_("open folds"), AssFile::COMMIT_FOLD);
}
void FoldController::CloseFoldsAt(std::vector<AssDialogue *> const& lines) {
DoForFoldsAt(lines, [&](AssDialogue &line) {
line.Fold.collapsed = true;
if (line.Fold.counterpart)
line.Fold.counterpart->Fold.collapsed = line.Fold.collapsed;
});
context->ass->Commit(_("close folds"), AssFile::COMMIT_FOLD);
}
void FoldController::ToggleFoldsAt(std::vector<AssDialogue *> const& lines) {
DoForFoldsAt(lines, [&](AssDialogue &line) {
line.Fold.collapsed = !line.Fold.collapsed;
if (line.Fold.counterpart)
line.Fold.counterpart->Fold.collapsed = line.Fold.collapsed;
});
context->ass->Commit(_("toggle folds"), AssFile::COMMIT_FOLD);
}
bool FoldController::AreFoldsAt(std::vector<AssDialogue *> const& lines) {
bool hasfold = false;
DoForFoldsAt(lines, [&](AssDialogue &line) {
hasfold = hasfold || line.Fold.valid;
});
return hasfold;
}