File indexing completed on 2024-04-21 03:58:08

 /*
     SPDX-FileCopyrightText: KDE Developers
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "marks.h"
 #include "katedocument.h"
 #include "kateview.h"
 #include <vimode/inputmodemanager.h>
 #include <vimode/modes/normalvimode.h>
 
 #include <KLocalizedString>
 
 using namespace KateVi;
 
 namespace
 {
 const QChar BeginEditYanked = QLatin1Char('[');
 const QChar EndEditYanked = QLatin1Char(']');
 const QChar LastChange = QLatin1Char('.');
 const QChar InsertStopped = QLatin1Char('^');
 const QChar SelectionBegin = QLatin1Char('<');
 const QChar SelectionEnd = QLatin1Char('>');
 const QChar FirstUserMark = QLatin1Char('a');
 const QChar LastUserMark = QLatin1Char('z');
 const QChar BeforeJump = QLatin1Char('\'');
 const QChar BeforeJumpAlter = QLatin1Char('`');
 const QChar UserMarks[] = {QLatin1Char('a'), QLatin1Char('b'), QLatin1Char('c'), QLatin1Char('d'), QLatin1Char('e'), QLatin1Char('f'), QLatin1Char('g'),
                            QLatin1Char('h'), QLatin1Char('i'), QLatin1Char('j'), QLatin1Char('k'), QLatin1Char('l'), QLatin1Char('m'), QLatin1Char('n'),
                            QLatin1Char('o'), QLatin1Char('p'), QLatin1Char('q'), QLatin1Char('r'), QLatin1Char('s'), QLatin1Char('t'), QLatin1Char('u'),
                            QLatin1Char('v'), QLatin1Char('w'), QLatin1Char('x'), QLatin1Char('y'), QLatin1Char('z')};
 }
 
 Marks::Marks(InputModeManager *imm)
     : m_inputModeManager(imm)
     , m_doc(imm->view()->doc())
     , m_settingMark(false)
 {
     connect(m_doc, &KTextEditor::DocumentPrivate::markChanged, this, &Marks::markChanged);
 }
 
 void Marks::readSessionConfig(const KConfigGroup &config)
 {
     QStringList marks = config.readEntry("ViMarks", QStringList());
     for (int i = 0; i + 2 < marks.size(); i += 3) {
         KTextEditor::Cursor c(marks.at(i + 1).toInt(), marks.at(i + 2).toInt());
         setMark(marks.at(i).at(0), c);
     }
 
     syncViMarksAndBookmarks();
 }
 
 void Marks::writeSessionConfig(KConfigGroup &config) const
 {
     QStringList l;
     const auto keys = m_marks.keys();
     for (QChar key : keys) {
         l << key << QString::number(m_marks.value(key)->line()) << QString::number(m_marks.value(key)->column());
     }
     config.writeEntry("ViMarks", l);
 }
 
 void Marks::setMark(const QChar &_mark, const KTextEditor::Cursor pos)
 {
     // move on insert is type based, this allows to reuse cursors!
     // reuse is important for editing intensive things like replace-all
     const bool moveoninsert = _mark != BeginEditYanked;
 
     m_settingMark = true;
 
     // ` and ' is the same register (position before jump)
     const QChar mark = (_mark == BeforeJumpAlter) ? BeforeJump : _mark;
 
     // if we have already a cursor for this type: adjust it
     bool needToAdjustVisibleMark = true;
     if (KTextEditor::MovingCursor *oldCursor = m_marks.value(mark)) {
         // cleanup mark display only if line changes
         needToAdjustVisibleMark = oldCursor->line() != pos.line();
         if (needToAdjustVisibleMark) {
             int number_of_marks = 0;
             const auto keys = m_marks.keys();
             for (QChar c : keys) {
                 if (m_marks.value(c)->line() == oldCursor->line()) {
                     number_of_marks++;
                 }
             }
             if (number_of_marks == 1) {
                 m_doc->removeMark(oldCursor->line(), KTextEditor::Document::markType01);
             }
         }
 
         // adjust position
         oldCursor->setPosition(pos);
     } else {
         // if no old mark of that type, create new one
         const KTextEditor::MovingCursor::InsertBehavior behavior =
             moveoninsert ? KTextEditor::MovingCursor::MoveOnInsert : KTextEditor::MovingCursor::StayOnInsert;
         m_marks.insert(mark, m_doc->newMovingCursor(pos, behavior));
     }
 
     // Showing what mark we set, can be skipped if we did not change the line
     if (isShowable(mark)) {
         if (needToAdjustVisibleMark && !(m_doc->mark(pos.line()) & KTextEditor::Document::markType01)) {
             m_doc->addMark(pos.line(), KTextEditor::Document::markType01);
         }
 
         // only show message for active view
         if (m_inputModeManager->view()->viewInputMode() == KTextEditor::View::ViInputMode) {
             if (m_doc->activeView() == m_inputModeManager->view()) {
                 m_inputModeManager->getViNormalMode()->message(i18n("Mark set: %1", mark));
             }
         }
     }
 
     m_settingMark = false;
 }
 
 KTextEditor::Cursor Marks::getMarkPosition(const QChar &mark) const
 {
     if (m_marks.contains(mark)) {
         KTextEditor::MovingCursor *c = m_marks.value(mark);
         return KTextEditor::Cursor(c->line(), c->column());
     }
 
     return KTextEditor::Cursor::invalid();
 }
 
 void Marks::markChanged(KTextEditor::Document *doc, KTextEditor::Mark mark, KTextEditor::Document::MarkChangeAction action)
 {
     Q_UNUSED(doc)
 
     if (mark.type != KTextEditor::Document::Bookmark || m_settingMark) {
         return;
     }
 
     if (action == KTextEditor::Document::MarkRemoved) {
         const auto keys = m_marks.keys();
         for (QChar markerChar : keys) {
             if (m_marks.value(markerChar)->line() == mark.line) {
                 m_marks.remove(markerChar);
             }
         }
     } else if (action == KTextEditor::Document::MarkAdded) {
         bool freeMarkerCharFound = false;
 
         for (const QChar &markerChar : UserMarks) {
             if (!m_marks.value(markerChar)) {
                 setMark(markerChar, KTextEditor::Cursor(mark.line, 0));
                 freeMarkerCharFound = true;
                 break;
             }
         }
 
         // only show error when we are in Vi input mode
         if (!freeMarkerCharFound && m_inputModeManager->view()->viewInputMode() == KTextEditor::View::ViInputMode) {
             m_inputModeManager->getViNormalMode()->error(i18n("There are no more chars for the next bookmark."));
         }
     }
 }
 
 void Marks::syncViMarksAndBookmarks()
 {
     const QHash<int, KTextEditor::Mark *> &marks = m_doc->marks();
 
     //  Each bookmark should have a vi mark on the same line.
     for (auto mark : marks) {
         if (!(mark->type & KTextEditor::Document::markType01)) {
             continue;
         }
 
         bool thereIsViMarkForThisLine = false;
         for (auto cursor : std::as_const(m_marks)) {
             if (cursor->line() == mark->line) {
                 thereIsViMarkForThisLine = true;
                 break;
             }
         }
 
         if (thereIsViMarkForThisLine) {
             continue;
         }
 
         for (const QChar &markerChar : UserMarks) {
             if (!m_marks.value(markerChar)) {
                 setMark(markerChar, KTextEditor::Cursor(mark->line, 0));
                 break;
             }
         }
     }
 
     // For showable vi mark a line should be bookmarked.
     const auto keys = m_marks.keys();
     for (QChar markChar : keys) {
         if (!isShowable(markChar)) {
             continue;
         }
 
         bool thereIsKateMarkForThisLine = false;
         for (auto mark : marks) {
             if (!(mark->type & KTextEditor::Document::markType01)) {
                 continue;
             }
 
             if (m_marks.value(markChar)->line() == mark->line) {
                 thereIsKateMarkForThisLine = true;
                 break;
             }
         }
 
         if (!thereIsKateMarkForThisLine) {
             m_doc->addMark(m_marks.value(markChar)->line(), KTextEditor::Document::markType01);
         }
     }
 }
 
 QString Marks::getMarksOnTheLine(int line) const
 {
     QString res;
     const auto keys = m_marks.keys();
     for (QChar markerChar : keys) {
         if (m_marks.value(markerChar)->line() == line) {
             res += markerChar + QLatin1Char(':') + QString::number(m_marks.value(markerChar)->column()) + QLatin1Char(' ');
         }
     }
 
     return res;
 }
 
 bool Marks::isShowable(const QChar &mark)
 {
     return FirstUserMark <= mark && mark <= LastUserMark;
 }
 
 void Marks::setStartEditYanked(const KTextEditor::Cursor pos)
 {
     setMark(BeginEditYanked, pos);
 }
 
 void Marks::setFinishEditYanked(const KTextEditor::Cursor pos)
 {
     setMark(EndEditYanked, pos);
 }
 
 void Marks::setLastChange(const KTextEditor::Cursor pos)
 {
     setMark(LastChange, pos);
 }
 
 void Marks::setInsertStopped(const KTextEditor::Cursor pos)
 {
     setMark(InsertStopped, pos);
 }
 
 void Marks::setSelectionStart(const KTextEditor::Cursor pos)
 {
     setMark(SelectionBegin, pos);
 }
 
 void Marks::setSelectionFinish(const KTextEditor::Cursor pos)
 {
     setMark(SelectionEnd, pos);
 }
 
 void Marks::setUserMark(const QChar &mark, const KTextEditor::Cursor pos)
 {
     Q_ASSERT(FirstUserMark <= mark && mark <= LastUserMark);
     setMark(mark, pos);
 }
 
 KTextEditor::Cursor Marks::getStartEditYanked() const
 {
     return getMarkPosition(BeginEditYanked);
 }
 
 KTextEditor::Cursor Marks::getFinishEditYanked() const
 {
     return getMarkPosition(EndEditYanked);
 }
 
 KTextEditor::Cursor Marks::getSelectionStart() const
 {
     return getMarkPosition(SelectionBegin);
 }
 
 KTextEditor::Cursor Marks::getSelectionFinish() const
 {
     return getMarkPosition(SelectionEnd);
 }
 
 KTextEditor::Cursor Marks::getLastChange() const
 {
     return getMarkPosition(LastChange);
 }
 
 KTextEditor::Cursor Marks::getInsertStopped() const
 {
     return getMarkPosition(InsertStopped);
 }