#include "TextEditor.hpp" #include "Utils.hpp" using namespace tp; bool tp::isNewLineChar(Char character) { return (character == '\n') || (character == '\r'); } void Input::getLineOffsets(Buffer& 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 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 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; }