EditorHistory.cpp

浏览该文件的文档.

#include "editor/EditorHistory.h"
 
#include "common/Exception.h"
 
namespace eve::editor {
 
void EditorHistory::clear() {
    undoStack_.clear();
    redoStack_.clear();
    grouping_ = false;
    pending_ = Action{};
    hasLast_ = false;
    lastWasUndo_ = false;
    lastApplied_ = Action{};
}
 
void EditorHistory::trimRedo() { redoStack_.clear(); }
 
void EditorHistory::push(const std::string &name, const std::string &payload) {
    if (grouping_) throw Exception("EditorHistory::push: finish beginGroup/endGroup first");
    Action a;
    a.kind = "opaque";
    a.name = name;
    a.payload = payload;
    undoStack_.push_back(a);
    trimRedo();
}
 
void EditorHistory::beginGroup(const std::string &name) {
    if (grouping_) throw Exception("EditorHistory::beginGroup: already grouping");
    grouping_ = true;
    pending_ = Action{};
    pending_.kind = "tiles";
    pending_.name = name;
}
 
void EditorHistory::recordTile(int x, int y, int oldGid, int newGid) {
    if (!grouping_) throw Exception("EditorHistory::recordTile: call beginGroup first");
    TileChange t;
    t.x = x;
    t.y = y;
    t.oldGid = oldGid;
    t.newGid = newGid;
    pending_.tiles.push_back(t);
}
 
void EditorHistory::endGroup() {
    if (!grouping_) throw Exception("EditorHistory::endGroup: not grouping");
    grouping_ = false;
    if (!pending_.tiles.empty()) {
        undoStack_.push_back(pending_);
        trimRedo();
    }
    pending_ = Action{};
}
 
bool EditorHistory::canUndo() const { return !undoStack_.empty(); }
bool EditorHistory::canRedo() const { return !redoStack_.empty(); }
int EditorHistory::getUndoCount() const { return static_cast<int>(undoStack_.size()); }
int EditorHistory::getRedoCount() const { return static_cast<int>(redoStack_.size()); }
 
bool EditorHistory::undo() {
    if (undoStack_.empty()) return false;
    Action a = undoStack_.back();
    undoStack_.pop_back();
    redoStack_.push_back(a);
    lastApplied_ = a;
    hasLast_ = true;
    lastWasUndo_ = true;
    return true;
}
 
bool EditorHistory::redo() {
    if (redoStack_.empty()) return false;
    Action a = redoStack_.back();
    redoStack_.pop_back();
    undoStack_.push_back(a);
    lastApplied_ = a;
    hasLast_ = true;
    lastWasUndo_ = false;
    return true;
}
 
bool EditorHistory::applyLastToBuffer(TileBuffer *buffer) {
    if (!hasLast_ || !buffer) return false;
    if (lastApplied_.kind != "tiles") return false;
    for (const auto &t : lastApplied_.tiles) {
        if (!buffer->inBounds(t.x, t.y)) continue;
        buffer->setGid(t.x, t.y, lastWasUndo_ ? t.oldGid : t.newGid);
    }
    return true;
}
 
std::string EditorHistory::getLastActionName() const { return hasLast_ ? lastApplied_.name : ""; }
std::string EditorHistory::getLastActionKind() const { return hasLast_ ? lastApplied_.kind : ""; }
std::string EditorHistory::getLastPayload() const { return hasLast_ ? lastApplied_.payload : ""; }
 
int EditorHistory::getLastTileCount() const {
    return hasLast_ ? static_cast<int>(lastApplied_.tiles.size()) : 0;
}
 
bool EditorHistory::validLastTile(int index) const {
    return hasLast_ && index >= 0 && index < static_cast<int>(lastApplied_.tiles.size());
}
 
int EditorHistory::getLastTileX(int index) const {
    if (!validLastTile(index)) throw Exception("EditorHistory::getLastTileX: bad index");
    return lastApplied_.tiles[index].x;
}
int EditorHistory::getLastTileY(int index) const {
    if (!validLastTile(index)) throw Exception("EditorHistory::getLastTileY: bad index");
    return lastApplied_.tiles[index].y;
}
int EditorHistory::getLastTileOldGid(int index) const {
    if (!validLastTile(index)) throw Exception("EditorHistory::getLastTileOldGid: bad index");
    return lastApplied_.tiles[index].oldGid;
}
int EditorHistory::getLastTileNewGid(int index) const {
    if (!validLastTile(index)) throw Exception("EditorHistory::getLastTileNewGid: bad index");
    return lastApplied_.tiles[index].newGid;
}
 
}  // namespace eve::editor