Restores the piece-table text editor from agent-work on the merged Containers AVL tree, with the test build no longer gated behind the undefined MODULES_BUILD_TESTS option. The module is registered in the root build.
506 lines
12 KiB
C++
506 lines
12 KiB
C++
#include "TextEditor.hpp"
|
|
|
|
#include "Utils.hpp"
|
|
|
|
using namespace tp;
|
|
|
|
bool tp::isNewLineChar(Char character) { return (character == '\n') || (character == '\r'); }
|
|
|
|
void Input::getLineOffsets(Buffer<Index>& out) const {
|
|
out.append(0);
|
|
|
|
for (Index idx = 0; idx < mLen; idx++) {
|
|
if (isNewLineChar(mInput[idx])) {
|
|
out.append(idx + 1);
|
|
}
|
|
}
|
|
|
|
out.append(mLen);
|
|
}
|
|
|
|
// ---------------------- Pointer ---------------------- //
|
|
|
|
Pointer::Pointer() :
|
|
mLine(0),
|
|
mCol(0) {}
|
|
|
|
Pointer::Pointer(LineId aLine, ColumnId aCol) :
|
|
mLine(aLine),
|
|
mCol(aCol) {}
|
|
|
|
Pointer::Pointer(const Input& aInput) :
|
|
Pointer() {
|
|
for (Index idx = 0; idx < aInput.mLen; idx++) {
|
|
*this += aInput.mInput[idx];
|
|
}
|
|
}
|
|
|
|
void Pointer::operator+=(Char achar) {
|
|
if (isNewLineChar(achar)) {
|
|
mLine += 1;
|
|
mCol = 0;
|
|
return;
|
|
}
|
|
|
|
mCol += 1;
|
|
}
|
|
|
|
void Pointer::operator+=(const Pointer& ap) { *this = *this + ap; }
|
|
|
|
Pointer Pointer::operator-(const Pointer& in) const {
|
|
if (mLine == in.mLine) {
|
|
return { 0, mCol - in.mCol };
|
|
}
|
|
return { mLine - in.mLine, mCol };
|
|
}
|
|
|
|
Pointer Pointer::operator+(const Pointer& ap) const {
|
|
if (ap.mLine == 0) {
|
|
return { mLine, mCol + ap.mCol };
|
|
}
|
|
return { mLine + ap.mLine, ap.mCol };
|
|
}
|
|
|
|
bool Pointer::operator==(const Pointer& in) const { return in.mCol == mCol && in.mLine == mLine; }
|
|
|
|
bool Pointer::operator!=(const Pointer& in) const { return !(*this == in); }
|
|
|
|
bool Pointer::operator>(const Pointer& in) const {
|
|
if (mLine != in.mLine) {
|
|
return mLine > in.mLine;
|
|
}
|
|
return mCol > in.mCol;
|
|
}
|
|
|
|
bool Pointer::operator>=(const Pointer& in) const { return *this > in || *this == in; }
|
|
|
|
Pointer Piece::diffPtr() const { return mEnd - mStart; }
|
|
|
|
LineId Piece::nLines() const { return mEnd.mLine - mStart.mLine; }
|
|
|
|
// ---------------------- Piece Key ---------------------- //
|
|
|
|
PieceKey PieceKey::forLookup(Pointer position) {
|
|
PieceKey out;
|
|
out.mLookupPosition = position;
|
|
return out;
|
|
}
|
|
|
|
bool PieceKey::descentRight(const PieceKey& query) const { return query.mLookupPosition >= mLeftSpan + mSpan; }
|
|
|
|
bool PieceKey::exactNode(const PieceKey& query) const {
|
|
return query.mLookupPosition >= mLeftSpan && mLeftSpan + mSpan > query.mLookupPosition;
|
|
}
|
|
|
|
PieceKey PieceKey::keyInRightSubtree(const PieceKey& query) const {
|
|
return forLookup(query.mLookupPosition - (mLeftSpan + mSpan));
|
|
}
|
|
|
|
PieceKey PieceKey::keyInLeftSubtree(const PieceKey& query) const { return query; }
|
|
|
|
Pointer PieceKey::span() const { return mSpan; }
|
|
|
|
Pointer PieceKey::leftSpan() const { return mLeftSpan; }
|
|
|
|
Pointer PieceKey::subtreeSpan() const { return (mLeftSpan + mSpan) + mRightSpan; }
|
|
|
|
// ---------------------- Pieces ---------------------- //
|
|
|
|
auto PiecesDS::find(Pointer position) const -> Node* { return mTree.find(PieceKey::forLookup(position)); }
|
|
|
|
auto PiecesDS::first() const -> Node* { return mTree.minNode(mTree.head()); }
|
|
|
|
auto PiecesDS::last() const -> Node* { return mTree.maxNode(mTree.head()); }
|
|
|
|
auto PiecesDS::next(Node* node) const -> Node* { return mTree.next(node); }
|
|
|
|
auto PiecesDS::prev(Node* node) const -> Node* { return mTree.prev(node); }
|
|
|
|
Pointer PiecesDS::position(const Node* node) const {
|
|
Pointer out = node->key.leftSpan();
|
|
|
|
for (const Node* iter = node; iter->mParent; iter = iter->mParent) {
|
|
const Node* parent = iter->mParent;
|
|
if (parent->mRight == iter) {
|
|
out = (parent->key.leftSpan() + parent->key.span()) + out;
|
|
}
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
Pointer PiecesDS::ptrSum() const {
|
|
if (!mTree.head()) {
|
|
return { 0, 0 };
|
|
}
|
|
return mTree.head()->key.subtreeSpan();
|
|
}
|
|
|
|
ualni PiecesDS::nPieces() const { return mTree.size(); }
|
|
|
|
auto PiecesDS::insertAfter(Node* predecessor, const Piece& piece) -> Node* {
|
|
return mTree.insertAfter(predecessor, PieceKey(), piece);
|
|
}
|
|
|
|
void PiecesDS::remove(Node* node) { mTree.removeNode(node); }
|
|
|
|
void PiecesDS::resize(Node* node, Pointer newEnd) {
|
|
node->data.mEnd = newEnd;
|
|
mTree.refreshNode(node);
|
|
}
|
|
|
|
// ---------------------- Add Buff ---------------------- //
|
|
|
|
AddBuff::AddBuff() {
|
|
Input empty;
|
|
empty.getLineOffsets(mLineOffsets);
|
|
}
|
|
|
|
void AddBuff::append(const Input& aInput) {
|
|
Buffer<Index> inputOffsets;
|
|
aInput.getLineOffsets(inputOffsets);
|
|
|
|
const auto appendStart = Index(mBuff.size());
|
|
|
|
mLineOffsets.pop();
|
|
for (ualni idx = 1; idx < inputOffsets.size(); idx++) {
|
|
mLineOffsets.append(appendStart + inputOffsets[idx]);
|
|
}
|
|
|
|
for (Index idx = 0; idx < aInput.mLen; idx++) {
|
|
mBuff.append(aInput.mInput[idx]);
|
|
}
|
|
}
|
|
|
|
Pointer AddBuff::endPtr() const {
|
|
const auto lastLine = mLineOffsets.size() - 2;
|
|
return { LineId(lastLine), mLineOffsets.last() - mLineOffsets[lastLine] };
|
|
}
|
|
|
|
// ---------------------- Orig Buff ---------------------- //
|
|
|
|
OrigBuff::OrigBuff(Input aOriginal) :
|
|
mOriginal(aOriginal) {
|
|
mOriginal.getLineOffsets(mLineOffsets);
|
|
mPtrStart = { 0, 0 };
|
|
mPtrEnd = Pointer(mOriginal);
|
|
}
|
|
|
|
void OrigBuff::makeOwnOriginalInput() {
|
|
if (mOwnsInput) {
|
|
return;
|
|
}
|
|
|
|
auto inputCopy = new Char[mOriginal.mLen + 1];
|
|
memCopy(inputCopy, mOriginal.mInput, mOriginal.mLen);
|
|
inputCopy[mOriginal.mLen] = '\0';
|
|
|
|
mOriginal.mInput = inputCopy;
|
|
mOwnsInput = true;
|
|
}
|
|
|
|
OrigBuff::~OrigBuff() {
|
|
if (mOwnsInput) {
|
|
delete[] mOriginal.mInput;
|
|
}
|
|
}
|
|
|
|
// ---------------------- Editor ---------------------- //
|
|
|
|
TextEditor::TextEditor() :
|
|
mOrigBuff(Input()) {}
|
|
|
|
TextEditor::TextEditor(Input original) :
|
|
mOrigBuff(original) {
|
|
if (original.mLen) {
|
|
mPieces.insertAfter(nullptr, { false, mOrigBuff.mPtrStart, mOrigBuff.mPtrEnd });
|
|
}
|
|
mPieces.pushUndoPoint();
|
|
}
|
|
|
|
PieceCrs TextEditor::findPiece(Pointer ptr) const {
|
|
PieceCrs out;
|
|
if (!mPieces.nPieces()) {
|
|
return out;
|
|
}
|
|
|
|
out.piece = mPieces.ptrSum() == ptr ? mPieces.last() : mPieces.find(ptr);
|
|
if (!out.piece) {
|
|
return out;
|
|
}
|
|
|
|
out.piece_ptr = mPieces.position(out.piece);
|
|
out.ptr = ptr;
|
|
out.offset = out.ptr - out.piece_ptr;
|
|
return out;
|
|
}
|
|
|
|
Index TextEditor::mNLines() const { return mPieces.ptrSum().mLine; }
|
|
|
|
Pointer TextEditor::getCursor() const { return mCursor; }
|
|
|
|
Pointer TextEditor::getCursorEnd() const { return mCursorEnd; }
|
|
|
|
void TextEditor::clampPtr(Pointer& ptr) const {
|
|
if (!mPieces.nPieces()) {
|
|
ptr = { 0, 0 };
|
|
return;
|
|
}
|
|
|
|
ptr.mLine = clamp(ptr.mLine, 0, mNLines());
|
|
|
|
auto crs = findPiece(Pointer{ ptr.mLine, 0 });
|
|
Index lineLength = getPieceLineLen(crs.piece->data, crs.offset.mLine);
|
|
|
|
auto piece = crs.piece;
|
|
auto nextStart = nextPiecePtr(piece);
|
|
while (mPieces.next(piece) && ptr.mLine == nextStart.mLine) {
|
|
piece = mPieces.next(piece);
|
|
nextStart = nextPiecePtr(piece);
|
|
lineLength += getPieceLineLen(piece->data, 0);
|
|
}
|
|
|
|
if (ptr.mLine != mNLines()) {
|
|
lineLength -= 1;
|
|
}
|
|
|
|
ptr.mCol = clamp(ptr.mCol, 0, lineLength);
|
|
}
|
|
|
|
void TextEditor::setCursor(Pointer ptr) {
|
|
clampPtr(ptr);
|
|
mCursor = ptr;
|
|
}
|
|
|
|
void TextEditor::setCursorEnd(Pointer ptr) {
|
|
clampPtr(ptr);
|
|
mCursorEnd = ptr;
|
|
mCursor = mCursorEnd;
|
|
}
|
|
|
|
const Char* TextEditor::getBuffLine(const Piece& piece, LineId line) const {
|
|
if (piece.mAddedBuff) {
|
|
return mAddBuff.mBuff.getBuff() + mAddBuff.mLineOffsets[line];
|
|
}
|
|
return mOrigBuff.mOriginal.mInput + mOrigBuff.mLineOffsets[line];
|
|
}
|
|
|
|
const Char* TextEditor::getPieceLine(const Piece& piece, LineId line) const {
|
|
if (line == 0) {
|
|
return getBuffLine(piece, piece.mStart.mLine) + piece.mStart.mCol;
|
|
}
|
|
if (line > piece.nLines()) {
|
|
return getBuffLine(piece, piece.mEnd.mLine) + piece.mEnd.mCol;
|
|
}
|
|
return getBuffLine(piece, piece.mStart.mLine + line);
|
|
}
|
|
|
|
LineId TextEditor::getPieceLineLen(const Piece& piece, LineId line) const {
|
|
return LineId(getPieceLine(piece, line + 1) - getPieceLine(piece, line));
|
|
}
|
|
|
|
Pointer TextEditor::prevPiecePtr(PiecesDS::Node* pieceNode) const {
|
|
auto previous = mPieces.prev(pieceNode);
|
|
if (!previous) {
|
|
return { 0, 0 };
|
|
}
|
|
return mPieces.position(previous);
|
|
}
|
|
|
|
Pointer TextEditor::nextPiecePtr(PiecesDS::Node* pieceNode) const {
|
|
return mPieces.position(pieceNode) + pieceNode->data.diffPtr();
|
|
}
|
|
|
|
void TextEditor::insert(Input aInput) {
|
|
remove(true);
|
|
|
|
auto startRef = mAddBuff.endPtr();
|
|
mAddBuff.append(aInput);
|
|
auto endRef = mAddBuff.endPtr();
|
|
auto inputDiff = endRef - startRef;
|
|
|
|
auto crs = findPiece(mCursor);
|
|
|
|
if (crs.piece && mPieces.prev(crs.piece) && crs.offset == Pointer{ 0, 0 }) {
|
|
crs.piece = mPieces.prev(crs.piece);
|
|
crs.piece_ptr = mPieces.position(crs.piece);
|
|
crs.offset = crs.ptr - crs.piece_ptr;
|
|
}
|
|
|
|
PiecesDS::Node* predecessor = nullptr;
|
|
bool extended = false;
|
|
|
|
if (crs.piece) {
|
|
const Piece& piece = crs.piece->data;
|
|
|
|
if (crs.offset == Pointer{ 0, 0 }) {
|
|
predecessor = mPieces.prev(crs.piece);
|
|
} else if (crs.offset == piece.diffPtr()) {
|
|
const bool continuesLastInsertion = mLastInsertionCrs == crs.ptr && piece.mAddedBuff && piece.mEnd == startRef;
|
|
if (continuesLastInsertion) {
|
|
mPieces.resize(crs.piece, piece.mEnd + inputDiff);
|
|
extended = true;
|
|
} else {
|
|
predecessor = crs.piece;
|
|
}
|
|
} else {
|
|
predecessor = splitPiece(crs.piece, crs.offset);
|
|
}
|
|
}
|
|
|
|
if (!extended) {
|
|
mPieces.insertAfter(predecessor, { true, startRef, endRef });
|
|
}
|
|
|
|
mCursor = mCursor + inputDiff;
|
|
mCursorEnd = mCursor;
|
|
mLastInsertionCrs = mCursor;
|
|
mPieces.pushUndoPoint();
|
|
}
|
|
|
|
PiecesDS::Node* TextEditor::splitPiece(PiecesDS::Node* piece, Pointer splitPtr) {
|
|
auto span = piece->data.diffPtr();
|
|
|
|
if (span == splitPtr || splitPtr == Pointer{ 0, 0 }) {
|
|
return nullptr;
|
|
}
|
|
|
|
const Piece original = piece->data;
|
|
const Pointer splitAt = original.mStart + splitPtr;
|
|
|
|
mPieces.resize(piece, splitAt);
|
|
mPieces.insertAfter(piece, { original.mAddedBuff, splitAt, original.mEnd });
|
|
|
|
return piece;
|
|
}
|
|
|
|
void TextEditor::removeRange(PiecesDS::Node* first, PiecesDS::Node* last) {
|
|
Buffer<PiecesDS::Node*> doomed;
|
|
|
|
for (auto iter = first; iter; iter = mPieces.next(iter)) {
|
|
doomed.append(iter);
|
|
if (iter == last) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (auto node : doomed) {
|
|
mPieces.remove(node.data());
|
|
}
|
|
}
|
|
|
|
void TextEditor::remove(bool only_selection, Dir dir, DirUnit unit) {
|
|
if (!mPieces.nPieces()) {
|
|
return;
|
|
}
|
|
|
|
if (mCursor == mCursorEnd) {
|
|
if (only_selection) {
|
|
return;
|
|
}
|
|
|
|
Pointer neighbour = mCursor;
|
|
|
|
if (dir == LEFT) {
|
|
if (mCursor == Pointer(0, 0)) {
|
|
return;
|
|
}
|
|
|
|
if (mCursor.mCol == 0) {
|
|
neighbour = Pointer{ mCursor.mLine - 1, ENV_HALNI_MAX };
|
|
clampPtr(neighbour);
|
|
} else {
|
|
neighbour = Pointer{ mCursor.mLine, mCursor.mCol - 1 };
|
|
}
|
|
} else if (dir == RIGHT) {
|
|
Pointer lineEnd{ mCursor.mLine, ENV_HALNI_MAX };
|
|
clampPtr(lineEnd);
|
|
|
|
if (mCursor.mCol < lineEnd.mCol) {
|
|
neighbour = Pointer{ mCursor.mLine, mCursor.mCol + 1 };
|
|
} else if (mCursor.mLine < mNLines()) {
|
|
neighbour = Pointer{ mCursor.mLine + 1, 0 };
|
|
} else {
|
|
return;
|
|
}
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
mCursorEnd = neighbour;
|
|
}
|
|
|
|
if (mCursor > mCursorEnd) {
|
|
swapV(mCursor, mCursorEnd);
|
|
}
|
|
|
|
auto crs = findPiece(mCursor);
|
|
|
|
PiecesDS::Node* firstRemoved = nullptr;
|
|
if (crs.offset == Pointer{ 0, 0 }) {
|
|
firstRemoved = crs.piece;
|
|
} else if (crs.piece->data.diffPtr() == crs.offset) {
|
|
firstRemoved = mPieces.next(crs.piece);
|
|
} else {
|
|
firstRemoved = mPieces.next(splitPiece(crs.piece, crs.offset));
|
|
}
|
|
|
|
auto crsEnd = findPiece(mCursorEnd);
|
|
|
|
PiecesDS::Node* lastRemoved = nullptr;
|
|
if (crsEnd.offset == Pointer{ 0, 0 }) {
|
|
lastRemoved = mPieces.prev(crsEnd.piece);
|
|
} else if (crsEnd.piece->data.diffPtr() == crsEnd.offset) {
|
|
lastRemoved = crsEnd.piece;
|
|
} else {
|
|
lastRemoved = splitPiece(crsEnd.piece, crsEnd.offset);
|
|
}
|
|
|
|
DEBUG_ASSERT(firstRemoved && lastRemoved);
|
|
removeRange(firstRemoved, lastRemoved);
|
|
|
|
mCursorEnd = mCursor;
|
|
mPieces.pushUndoPoint();
|
|
}
|
|
|
|
void TextEditor::undo() { mPieces.undo(); }
|
|
|
|
void TextEditor::redo() { mPieces.redo(); }
|
|
|
|
// ------------------------------ ITERATOR ------------------------------ //
|
|
|
|
TextEditor::Iterator TextEditor::begin() const { return Iterator(this); }
|
|
|
|
TextEditor::IteratorEnd TextEditor::end() const { return {}; }
|
|
|
|
TextEditor::Iterator::Iterator(const TextEditor* self) :
|
|
mSelf(self),
|
|
mNode(self->mPieces.first()) {
|
|
loadCharacter();
|
|
}
|
|
|
|
void TextEditor::Iterator::loadCharacter() {
|
|
if (!mNode) {
|
|
return;
|
|
}
|
|
mVal = mSelf->getPieceLine(mNode->data, mOffset.mLine)[mOffset.mCol];
|
|
}
|
|
|
|
Char TextEditor::Iterator::character() const { return mVal; }
|
|
|
|
void TextEditor::Iterator::operator++() {
|
|
mOffset += mVal;
|
|
|
|
if (mOffset == mNode->data.diffPtr()) {
|
|
mNode = mSelf->mPieces.next(mNode);
|
|
mOffset = { 0, 0 };
|
|
}
|
|
|
|
loadCharacter();
|
|
}
|
|
|
|
bool TextEditor::Iterator::operator!=(const IteratorEnd&) const { return mNode != nullptr; }
|
|
|
|
bool TextEditor::Iterator::operator==(const IteratorEnd&) const { return mNode == nullptr; }
|
|
|
|
const TextEditor::Iterator& TextEditor::Iterator::operator*() const { return *this; }
|