RedPanda-CPP/RedPandaIDE/qsynedit/SynEdit.cpp

/*
 * Copyright (C) 2020-2022 Roy Qu (royqh1979@gmail.com)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
#include "SynEdit.h"
#include "highlighter/cpp.h"
#include <QApplication>
#include <QFontMetrics>
#include <algorithm>
#include <cmath>
#include <QScrollBar>
#include <QPaintEvent>
#include <QPainter>
#include <QTimerEvent>
#include "highlighter/base.h"
#include "Constants.h"
#include "TextPainter.h"
#include <QClipboard>
#include <QDebug>
#include <QGuiApplication>
#include <QInputMethodEvent>
#include <QPaintEvent>
#include <QResizeEvent>
#include <QStyleHints>
#include <QMessageBox>
#include <QDrag>
#include <QMimeData>
#include <QDesktopWidget>
#include <QTextEdit>
#include <QMimeData>

SynEdit::SynEdit(QWidget *parent) : QAbstractScrollArea(parent),
    mDropped(false)
{
    mCharWidth=1;
    mTextHeight = 1;
    mLastKey = 0;
    mLastKeyModifiers = Qt::NoModifier;
    mModified = false;
    mPaintLock = 0;
    mPainterLock = 0;
    mPainting = false;
#ifdef Q_OS_WIN
    mFontDummy = QFont("Consolas",12);
#elif defined(Q_OS_LINUX)
    mFontDummy = QFont("terminal",14);
#elif defined(Q_OS_MACOS)
    mFontDummy = QFont("Menlo", 14);
#else
#error "Not supported!"
#endif
    mFontDummy.setStyleStrategy(QFont::PreferAntialias);
    mDocument = std::make_shared<SynDocument>(mFontDummy, this);
    //fPlugins := TList.Create;
    mMouseMoved = false;
    mUndoing = false;
    mDocument->connect(mDocument.get(), &SynDocument::changed, this, &SynEdit::onLinesChanged);
    mDocument->connect(mDocument.get(), &SynDocument::changing, this, &SynEdit::onLinesChanging);
    mDocument->connect(mDocument.get(), &SynDocument::cleared, this, &SynEdit::onLinesCleared);
    mDocument->connect(mDocument.get(), &SynDocument::deleted, this, &SynEdit::onLinesDeleted);
    mDocument->connect(mDocument.get(), &SynDocument::inserted, this, &SynEdit::onLinesInserted);
    mDocument->connect(mDocument.get(), &SynDocument::putted, this, &SynEdit::onLinesPutted);

    mGutterWidth = 0;
    mScrollBars = SynScrollStyle::ssBoth;



    mUndoList = std::make_shared<SynEditUndoList>();
    mUndoList->connect(mUndoList.get(), &SynEditUndoList::addedUndo, this, &SynEdit::onUndoAdded);
    mRedoList = std::make_shared<SynEditUndoList>();
    mRedoList->connect(mRedoList.get(), &SynEditUndoList::addedUndo, this, &SynEdit::onRedoAdded);

    mForegroundColor=palette().color(QPalette::Text);
    mBackgroundColor=palette().color(QPalette::Base);
    mCaretColor = Qt::red;
    mCaretUseTextColor = false;
    mActiveLineColor = Qt::blue;
    mSelectedBackground = palette().color(QPalette::Highlight);
    mSelectedForeground = palette().color(QPalette::HighlightedText);

    mBookMarkOpt.connect(&mBookMarkOpt, &SynBookMarkOpt::changed, this, &SynEdit::onBookMarkOptionsChanged);
    //  fRightEdge has to be set before FontChanged is called for the first time
    mRightEdge = 80;

    mMouseWheelScrollSpeed = 3;
    mMouseSelectionScrollSpeed = 1;

    mGutter.setRightOffset(21);
    mGutter.connect(&mGutter, &SynGutter::changed, this, &SynEdit::onGutterChanged);
    mGutterWidth = mGutter.realGutterWidth(charWidth());
    //ControlStyle := ControlStyle + [csOpaque, csSetCaption, csNeedsBorderPaint];
    //Height := 150;
    //Width := 200;
    this->setCursor(Qt::CursorShape::IBeamCursor);
    //TabStop := True;
    mInserting = true;
    mExtraLineSpacing = 0;

    this->setFrameShape(QFrame::Panel);
    this->setFrameShadow(QFrame::Sunken);
    this->setLineWidth(1);
    mInsertCaret = SynEditCaretType::ctVerticalLine;
    mOverwriteCaret = SynEditCaretType::ctBlock;
    mSelectionMode = SynSelectionMode::Normal;
    mActiveSelectionMode = SynSelectionMode::Normal;
    mReadOnly = false;

    //stop qt to auto fill background
    setAutoFillBackground(false);
    //fFocusList := TList.Create;
    //fKbdHandler := TSynEditKbdHandler.Create;
    //fMarkList.OnChange := MarkListChange;
    setDefaultKeystrokes();
    mRightEdgeColor = Qt::lightGray;

    mWantReturns = true;
    mWantTabs = false;
    mLeftChar = 1;
    mTopLine = 1;
    mCaretX = 1;
    mLastCaretColumn = 1;
    mCaretY = 1;
    mBlockBegin.ch = 1;
    mBlockBegin.line = 1;
    mBlockEnd = mBlockBegin;
    mOptions = eoAutoIndent
            | eoDragDropEditing | eoEnhanceEndKey | eoTabIndent |
             eoGroupUndo | eoKeepCaretX | eoSelectWordByDblClick
            | eoHideShowScrollbars ;

    mScrollTimer = new QTimer(this);
    //mScrollTimer->setInterval(100);
    connect(mScrollTimer, &QTimer::timeout,this, &SynEdit::onScrollTimeout);

    mScrollHintColor = Qt::yellow;
    mScrollHintFormat = SynScrollHintFormat::shfTopLineOnly;

    qreal dpr=devicePixelRatioF();
    mContentImage = std::make_shared<QImage>(clientWidth()*dpr,clientHeight()*dpr,QImage::Format_ARGB32);
    mContentImage->setDevicePixelRatio(dpr);

    mUseCodeFolding = true;
    m_blinkTimerId = 0;
    m_blinkStatus = 0;

    hideCaret();

    connect(horizontalScrollBar(),&QScrollBar::valueChanged,
            this, &SynEdit::onScrolled);
    connect(verticalScrollBar(),&QScrollBar::valueChanged,
            this, &SynEdit::onScrolled);
    //enable input method
    setAttribute(Qt::WA_InputMethodEnabled);

    //setMouseTracking(true);
    setAcceptDrops(true);

    setFont(mFontDummy);
    setFontForNonAscii(mFontDummy);
}

int SynEdit::displayLineCount() const
{
    if (mDocument->empty()) {
        return 0;
    }
    return lineToRow(mDocument->count());
}

DisplayCoord SynEdit::displayXY() const
{
    return bufferToDisplayPos(caretXY());
}

int SynEdit::displayX() const
{
    return displayXY().Column;
}

int SynEdit::displayY() const
{
    return displayXY().Row;
}

BufferCoord SynEdit::caretXY() const
{
    BufferCoord result;
    result.ch = caretX();
    result.line = caretY();
    return result;
}

int SynEdit::caretX() const
{
    return mCaretX;
}

int SynEdit::caretY() const
{
    return mCaretY;
}

void SynEdit::setCaretX(int value)
{
    setCaretXY({value,mCaretY});
}

void SynEdit::setCaretY(int value)
{
    setCaretXY({mCaretX,value});
}

void SynEdit::setCaretXY(const BufferCoord &value)
{
    setBlockBegin(value);
    setBlockEnd(value);
    setCaretXYEx(true,value);
}

void SynEdit::setCaretXYEx(bool CallEnsureCursorPosVisible, BufferCoord value)
{
    bool vTriggerPaint=true; //how to test it?

    if (vTriggerPaint)
        doOnPaintTransient(SynTransientType::ttBefore);
    int nMaxX;
    if (value.line > mDocument->count())
        value.line = mDocument->count();
    if (mActiveSelectionMode!=SynSelectionMode::Column) {
        if (value.line < 1) {
            // this is just to make sure if Lines stringlist should be empty
            value.line = 1;
            if (!mOptions.testFlag(SynEditorOption::eoScrollPastEol)) {
                nMaxX = 1;
            } else {
                nMaxX = getDisplayStringAtLine(value.line).length()+1;
            }
        } else {
            nMaxX = getDisplayStringAtLine(value.line).length()+1;
        }
        value.ch = std::min(value.ch,nMaxX);
    }
    value.ch = std::max(value.ch,1);
//    if ((value.Char > nMaxX) && (! (mOptions.testFlag(SynEditorOption::eoScrollPastEol)) ) )
//        value.Char = nMaxX;
//    if (value.Char < 1)
//        value.Char = 1;
    if ((value.ch != mCaretX) || (value.line != mCaretY)) {
        incPaintLock();
        auto action = finally([this]{
            decPaintLock();
        });
        // simply include the flags, fPaintLock is > 0
        if (mCaretX != value.ch) {
            mCaretX = value.ch;
            mStatusChanges.setFlag(SynStatusChange::scCaretX);
            invalidateLine(mCaretY);
        }
        if (mCaretY != value.line) {
            int oldCaretY = mCaretY;
            mCaretY = value.line;
            invalidateLine(mCaretY);
            invalidateGutterLine(mCaretY);
            invalidateLine(oldCaretY);
            invalidateGutterLine(oldCaretY);
            mStatusChanges.setFlag(SynStatusChange::scCaretY);
        }
        // Call UpdateLastCaretX before DecPaintLock because the event handler it
        // calls could raise an exception, and we don't want fLastCaretX to be
        // left in an undefined state if that happens.
        updateLastCaretX();
        if (CallEnsureCursorPosVisible)
            ensureCursorPosVisible();
        mStateFlags.setFlag(SynStateFlag::sfCaretChanged);
        mStateFlags.setFlag(SynStateFlag::sfScrollbarChanged);
    } else {
      // Also call UpdateLastCaretX if the caret didn't move. Apps don't know
      // anything about fLastCaretX and they shouldn't need to. So, to avoid any
      // unwanted surprises, always update fLastCaretX whenever CaretXY is
      // assigned to.
      // Note to SynEdit developers: If this is undesirable in some obscure
      // case, just save the value of fLastCaretX before assigning to CaretXY and
      // restore it afterward as appropriate.
      updateLastCaretX();
    }
    if (vTriggerPaint)
      doOnPaintTransient(SynTransientType::ttAfter);

}

void SynEdit::setCaretXYCentered(const BufferCoord &value)
{
    incPaintLock();
    auto action = finally([this] {
        decPaintLock();
    });
    mStatusChanges.setFlag(SynStatusChange::scSelection);
    setCaretXYEx(false,value);
    if (selAvail())
        invalidateSelection();
    mBlockBegin.ch = mCaretX;
    mBlockBegin.line = mCaretY;
    mBlockEnd = mBlockBegin;
    ensureCursorPosVisibleEx(true); // but here after block has been set
}

void SynEdit::uncollapseAroundLine(int line)
{
    while (true) { // Open up the closed folds around the focused line until we can see the line we're looking for
      PSynEditFoldRange fold = foldHidesLine(line);
      if (fold)
          uncollapse(fold);
      else
          break;
    }
}

PSynEditFoldRange SynEdit::foldHidesLine(int line)
{
    return foldAroundLineEx(line, true, false, true);
}

void SynEdit::setInsertMode(bool value)
{
    if (mInserting != value) {
        mInserting = value;
        updateCaret();
        emit statusChanged(scInsertMode);
    }
}

bool SynEdit::insertMode() const
{
    return mInserting;
}

bool SynEdit::canUndo() const
{
    return !mReadOnly && mUndoList->canUndo();
}

bool SynEdit::canRedo() const
{
    return !mReadOnly && mRedoList->canUndo();
}

int SynEdit::maxScrollWidth() const
{
    int maxLen = mDocument->lengthOfLongestLine();
    if (highlighter())
        maxLen = maxLen+stringColumns(highlighter()->foldString(),maxLen);
    if (mOptions.testFlag(eoScrollPastEol))
        return std::max(maxLen ,1);
    else
        return std::max(maxLen-mCharsInWindow+1, 1);
}

bool SynEdit::getHighlighterAttriAtRowCol(const BufferCoord &XY, QString &Token, PSynHighlighterAttribute &Attri)
{
    SynHighlighterTokenType TmpType;
    int TmpKind, TmpStart;
    return getHighlighterAttriAtRowColEx(XY, Token, TmpType, TmpKind,TmpStart, Attri);
}

bool SynEdit::getHighlighterAttriAtRowCol(const BufferCoord &XY, QString &Token, bool &tokenFinished, SynHighlighterTokenType &TokenType, PSynHighlighterAttribute &Attri)
{
    int PosX, PosY, endPos, Start;
    QString Line;
    PosY = XY.line - 1;
    if (mHighlighter && (PosY >= 0) && (PosY < mDocument->count())) {
        Line = mDocument->getString(PosY);
        if (PosY == 0) {
            mHighlighter->resetState();
        } else {
            mHighlighter->setState(mDocument->ranges(PosY-1));
        }
        mHighlighter->setLine(Line, PosY);
        PosX = XY.ch;
        if ((PosX > 0) && (PosX <= Line.length())) {
            while (!mHighlighter->eol()) {
                Start = mHighlighter->getTokenPos() + 1;
                Token = mHighlighter->getToken();
                endPos = Start + Token.length()-1;
                if ((PosX >= Start) && (PosX <= endPos)) {
                    Attri = mHighlighter->getTokenAttribute();
                    if (PosX == endPos)
                        tokenFinished = mHighlighter->getTokenFinished();
                    else
                        tokenFinished = false;
                    TokenType = mHighlighter->getTokenType();
                    return true;
                }
                mHighlighter->next();
            }
        }
    }
    Token = "";
    Attri = PSynHighlighterAttribute();
    tokenFinished = false;
    return false;
}

bool SynEdit::getHighlighterAttriAtRowColEx(const BufferCoord &XY, QString &Token, SynHighlighterTokenType &TokenType, SynTokenKind &TokenKind, int &Start, PSynHighlighterAttribute &Attri)
{
    int PosX, PosY, endPos;
    QString Line;
    PosY = XY.line - 1;
    if (mHighlighter && (PosY >= 0) && (PosY < mDocument->count())) {
        Line = mDocument->getString(PosY);
        if (PosY == 0) {
            mHighlighter->resetState();
        } else {
            mHighlighter->setState(mDocument->ranges(PosY-1));
        }
        mHighlighter->setLine(Line, PosY);
        PosX = XY.ch;
        if ((PosX > 0) && (PosX <= Line.length())) {
            while (!mHighlighter->eol()) {
                Start = mHighlighter->getTokenPos() + 1;
                Token = mHighlighter->getToken();
                endPos = Start + Token.length()-1;
                if ((PosX >= Start) && (PosX <= endPos)) {
                    Attri = mHighlighter->getTokenAttribute();
                    TokenKind = mHighlighter->getTokenKind();
                    TokenType = mHighlighter->getTokenType();
                    return true;
                }
                mHighlighter->next();
            }
        }
    }
    Token = "";
    Attri = PSynHighlighterAttribute();
    TokenKind = 0;
    TokenType = SynHighlighterTokenType::Default;
    return false;
}

void SynEdit::beginUndoBlock()
{
    mUndoList->beginBlock();
}

void SynEdit::endUndoBlock()
{
    mUndoList->endBlock();
}

void SynEdit::addCaretToUndo()
{
    BufferCoord p=caretXY();
    mUndoList->addChange(SynChangeReason::Caret,p,p,QStringList(), mActiveSelectionMode);
}

void SynEdit::addLeftTopToUndo()
{
    BufferCoord p;
    p.ch = leftChar();
    p.line = topLine();
    mUndoList->addChange(SynChangeReason::LeftTop,p,p,QStringList(), mActiveSelectionMode);
}

void SynEdit::addSelectionToUndo()
{
    mUndoList->addChange(SynChangeReason::Selection,mBlockBegin,
                         mBlockEnd,QStringList(),mActiveSelectionMode);
}

void SynEdit::beginUpdate()
{
    incPaintLock();
}

void SynEdit::endUpdate()
{
    decPaintLock();
}

BufferCoord SynEdit::getMatchingBracket()
{
    return getMatchingBracketEx(caretXY());
}

BufferCoord SynEdit::getMatchingBracketEx(BufferCoord APoint)
{
    QChar Brackets[] = {'(', ')', '[', ']', '{', '}', '<', '>'};
    QString Line;
    int i, PosX, PosY, Len;
    QChar Test, BracketInc, BracketDec;
    int NumBrackets;
    QString vDummy;
    PSynHighlighterAttribute attr;
    BufferCoord p;
    bool isCommentOrStringOrChar;
    int nBrackets = sizeof(Brackets) / sizeof(QChar);

    if (mDocument->count()<1)
        return BufferCoord{0,0};
    // get char at caret
    PosX = std::max(APoint.ch,1);
    PosY = std::max(APoint.line,1);
    Line = mDocument->getString(APoint.line - 1);
    if (Line.length() >= PosX ) {
        Test = Line[PosX-1];
        // is it one of the recognized brackets?
        for (i = 0; i<nBrackets; i++) {
            if (Test == Brackets[i]) {
                // this is the bracket, get the matching one and the direction
                BracketInc = Brackets[i];
                BracketDec = Brackets[i ^ 1]; // 0 -> 1, 1 -> 0, ...
                // search for the matching bracket (that is until NumBrackets = 0)
                NumBrackets = 1;
                if (i%2==1) {
                    while (true) {
                        // search until start of line
                        while (PosX > 1) {
                            PosX--;
                            Test = Line[PosX-1];
                            p.ch = PosX;
                            p.line = PosY;
                            if ((Test == BracketInc) || (Test == BracketDec)) {
                                isCommentOrStringOrChar = false;
                                if (getHighlighterAttriAtRowCol(p, vDummy, attr))
                                    isCommentOrStringOrChar =
                                        (attr == mHighlighter->stringAttribute()) ||
                                            (attr == mHighlighter->commentAttribute()) ||
                                            (attr->name() == SYNS_AttrCharacter);
                                if ((Test == BracketInc) && (!isCommentOrStringOrChar))
                                    NumBrackets++;
                                else if ((Test == BracketDec) && (!isCommentOrStringOrChar)) {
                                    NumBrackets--;
                                    if (NumBrackets == 0) {
                                        // matching bracket found, set caret and bail out
                                        return p;
                                    }
                                }
                            }
                        }
                        // get previous line if possible
                        if (PosY == 1)
                            break;
                        PosY--;
                        Line = mDocument->getString(PosY - 1);
                        PosX = Line.length() + 1;
                    }
                } else {
                    while (true) {
                        // search until end of line
                        Len = Line.length();
                        while (PosX < Len) {
                            PosX++;
                            Test = Line[PosX-1];
                            p.ch = PosX;
                            p.line = PosY;
                            if ((Test == BracketInc) || (Test == BracketDec)) {
                                isCommentOrStringOrChar = false;
                                if (getHighlighterAttriAtRowCol(p, vDummy, attr))
                                    isCommentOrStringOrChar =
                                        (attr == mHighlighter->stringAttribute()) ||
                                            (attr == mHighlighter->commentAttribute()) ||
                                            (attr->name() == SYNS_AttrCharacter);
                                else
                                    isCommentOrStringOrChar = false;
                                if ((Test == BracketInc) && (!isCommentOrStringOrChar))
                                    NumBrackets++;
                                else if ((Test == BracketDec) && (!isCommentOrStringOrChar)) {
                                    NumBrackets--;
                                    if (NumBrackets == 0) {
                                        // matching bracket found, set caret and bail out
                                        return p;
                                    }
                                }
                            }
                        }
                        // get next line if possible
                        if (PosY == mDocument->count())
                            break;
                        PosY++;
                        Line = mDocument->getString(PosY - 1);
                        PosX = 0;
                    }
                }
                // don't test the other brackets, we're done
                break;
            }
        }
    }
    return BufferCoord{0,0};
}

QStringList SynEdit::contents()
{
    return document()->contents();
}

QString SynEdit::text()
{
    return document()->text();
}

bool SynEdit::getPositionOfMouse(BufferCoord &aPos)
{
    QPoint point = QCursor::pos();
    point = mapFromGlobal(point);
    return pointToCharLine(point,aPos);
}

bool SynEdit::getLineOfMouse(int &line)
{
    QPoint point = QCursor::pos();
    point = mapFromGlobal(point);
    return pointToLine(point,line);
}

bool SynEdit::pointToCharLine(const QPoint &point, BufferCoord &coord)
{
    // Make sure it fits within the SynEdit bounds (and on the gutter)
    if ((point.x() < gutterWidth() + clientLeft())
            || (point.x()>clientWidth()+clientLeft())
            || (point.y() < clientTop())
            || (point.y() > clientTop()+clientHeight())) {
        return false;
    }

    coord = displayToBufferPos(pixelsToNearestRowColumn(point.x(),point.y()));
    return true;
}

bool SynEdit::pointToLine(const QPoint &point, int &line)
{
    // Make sure it fits within the SynEdit bounds
    if ((point.x() < clientLeft())
            || (point.x()>clientWidth()+clientLeft())
            || (point.y() < clientTop())
            || (point.y() > clientTop()+clientHeight())) {
        return false;
    }

    BufferCoord coord = displayToBufferPos(pixelsToNearestRowColumn(point.x(),point.y()));
    line = coord.line;
    return true;
}

void SynEdit::invalidateGutter()
{
    invalidateGutterLines(-1, -1);
}

void SynEdit::invalidateGutterLine(int aLine)
{
    if ((aLine < 1) || (aLine > mDocument->count()))
        return;

    invalidateGutterLines(aLine, aLine);
}

void SynEdit::invalidateGutterLines(int FirstLine, int LastLine)
{
    QRect rcInval;
    if (!isVisible())
        return;
    if (FirstLine == -1 && LastLine == -1) {
        rcInval = QRect(0, 0, mGutterWidth, clientHeight());
        if (mStateFlags.testFlag(SynStateFlag::sfLinesChanging))
            mInvalidateRect = mInvalidateRect.united(rcInval);
        else
            invalidateRect(rcInval);
    } else {
        // find the visible lines first
        if (LastLine < FirstLine)
            std::swap(LastLine, FirstLine);
        if (mUseCodeFolding) {
            FirstLine = lineToRow(FirstLine);
            if (LastLine <= mDocument->count())
              LastLine = lineToRow(LastLine);
            else
              LastLine = INT_MAX;
        }
        FirstLine = std::max(FirstLine, mTopLine);
        LastLine = std::min(LastLine, mTopLine + mLinesInWindow);
        // any line visible?
        if (LastLine >= FirstLine) {
            rcInval = {0, mTextHeight * (FirstLine - mTopLine),
                       mGutterWidth, mTextHeight * (LastLine - mTopLine + 1)};
            if (mStateFlags.testFlag(SynStateFlag::sfLinesChanging)) {
                mInvalidateRect =  mInvalidateRect.united(rcInval);
            } else {
                invalidateRect(rcInval);
            }
        }
    }
}

/**
 * @brief Convert point on the edit (x,y) to (row,column)
 * @param aX
 * @param aY
 * @return
 */

DisplayCoord SynEdit::pixelsToNearestRowColumn(int aX, int aY) const
{
    return {
        std::max(1, (int)(mLeftChar + round((aX - mGutterWidth - 2.0) / mCharWidth))),
        std::max(1, mTopLine + (aY / mTextHeight))
    };
}

DisplayCoord SynEdit::pixelsToRowColumn(int aX, int aY) const
{
    return {
        std::max(1, (int)(mLeftChar + (aX - mGutterWidth - 2.0) / mCharWidth)),
        std::max(1, mTopLine + (aY / mTextHeight))
    };

}

QPoint SynEdit::rowColumnToPixels(const DisplayCoord &coord) const
{
    QPoint result;
    result.setX((coord.Column - 1) * mCharWidth + textOffset());
    result.setY((coord.Row - mTopLine) * mTextHeight);
    return result;
}

/**
 * @brief takes a position in the text and transforms it into
 *  the row and column it appears to be on the screen
 * @param p
 * @return
 */
DisplayCoord SynEdit::bufferToDisplayPos(const BufferCoord &p) const
{
    DisplayCoord result {p.ch,p.line};
    // Account for tabs and charColumns
    if (p.line-1 <mDocument->count())
        result.Column = charToColumn(p.line,p.ch);
    // Account for code folding
    if (mUseCodeFolding)
        result.Row = foldLineToRow(result.Row);
    return result;
}

/**
 * @brief takes a position on screen and transfrom it into position of text
 * @param p
 * @return
 */
BufferCoord SynEdit::displayToBufferPos(const DisplayCoord &p) const
{
    BufferCoord Result{p.Column,p.Row};
    // Account for code folding
    if (mUseCodeFolding)
        Result.line = foldRowToLine(p.Row);
    // Account for tabs
    if (Result.line <= mDocument->count() ) {
        Result.ch = columnToChar(Result.line,p.Column);
    }
    return Result;
}

//ContentsCoord SynEdit::fromBufferCoord(const BufferCoord &p) const
//{
//    return createNormalizedBufferCoord(p.Char,p.Line);
//}

//ContentsCoord SynEdit::createNormalizedBufferCoord(int aChar, int aLine) const
//{
//    return ContentsCoord(this,aChar,aLine);
//}

//QStringList SynEdit::getContents(const ContentsCoord &pStart, const ContentsCoord &pEnd)
//{
//    QStringList result;
//    if (mDocument->count()==0)
//        return result;
//    if (pStart.line()>0) {
//        QString s = mDocument->getString(pStart.line()-1);
//        result += s.mid(pStart.ch()-1);
//    }
//    int endLine = std::min(pEnd.line(),mDocument->count());
//    for (int i=pStart.line();i<endLine-1;i++) {
//        result += mDocument->getString(i);
//    }
//    if (pEnd.line()<=mDocument->count()) {
//        result += mDocument->getString(pEnd.line()-1).mid(0,pEnd.ch()-1);
//    }
//    return result;
//}

//QString SynEdit::getJoinedContents(const ContentsCoord &pStart, const ContentsCoord &pEnd, const QString &joinStr)
//{
//    return getContents(pStart,pEnd).join(joinStr);
//}

int SynEdit::leftSpaces(const QString &line) const
{
    int result = 0;
    if (mOptions.testFlag(eoAutoIndent)) {
        for (QChar ch:line) {
            if (ch == '\t') {
                result += tabWidth() - (result % tabWidth());
            } else if (ch == ' ') {
                result ++;
            } else {
                break;
            }
        }
    }
    return result;
}

QString SynEdit::GetLeftSpacing(int charCount, bool wantTabs) const
{
    if (wantTabs && !mOptions.testFlag(eoTabsToSpaces) && tabWidth()>0) {
        return QString(charCount / tabWidth(),'\t') + QString(charCount % tabWidth(),' ');
    } else {
        return QString(charCount,' ');
    }
}

int SynEdit::charToColumn(int aLine, int aChar) const
{
    if (aLine>=1 && aLine <= mDocument->count()) {
        QString s = getDisplayStringAtLine(aLine);
        return charToColumn(s,aChar);
    }
    return aChar;
}

int SynEdit::charToColumn(const QString &s, int aChar) const
{
    int x = 0;
    int len = std::min(aChar-1,s.length());
    for (int i=0;i<len;i++) {
        if (s[i] == '\t')
            x+=tabWidth() - (x % tabWidth());
        else
            x+=charColumns(s[i]);
    }
    return x+1;
}

int SynEdit::columnToChar(int aLine, int aColumn) const
{
    Q_ASSERT( (aLine <= mDocument->count()) && (aLine >= 1));
    if (aLine <= mDocument->count()) {
        QString s = getDisplayStringAtLine(aLine);
        int x = 0;
        int len = s.length();
        int i;
        for (i=0;i<len;i++) {
            if (s[i] == '\t')
                x+=tabWidth() - (x % tabWidth());
            else
                x+=charColumns(s[i]);
            if (x>=aColumn) {
                break;
            }
        }
        return i+1;
    }
    return aColumn;
}

int SynEdit::stringColumns(const QString &line, int colsBefore) const
{
    return mDocument->stringColumns(line,colsBefore);
}

int SynEdit::getLineIndent(const QString &line) const
{
    int indents = 0;
    for (QChar ch:line) {
        switch(ch.unicode()) {
        case '\t':
            indents+=tabWidth();
            break;
        case ' ':
            indents+=1;
            break;
        default:
            return indents;
        }
    }
    return indents;
}

int SynEdit::rowToLine(int aRow) const
{
    if (mUseCodeFolding)
        return foldRowToLine(aRow);
    else
        return aRow;
    //return displayToBufferPos({1, aRow}).Line;
}

int SynEdit::lineToRow(int aLine) const
{
    return bufferToDisplayPos({1, aLine}).Row;
}

int SynEdit::foldRowToLine(int Row) const
{
    int result = Row;
    for (int i=0;i<mAllFoldRanges.count();i++) {
        PSynEditFoldRange range = mAllFoldRanges[i];
        if (range->collapsed && !range->parentCollapsed() && range->fromLine < result) {
            result += range->linesCollapsed;
        }
    }
    return result;
}

int SynEdit::foldLineToRow(int Line) const
{
    int result = Line;
    for (int i=mAllFoldRanges.count()-1;i>=0;i--) {
        PSynEditFoldRange range =mAllFoldRanges[i];
        if (range->collapsed && !range->parentCollapsed()) {
            // Line is found after fold
            if (range->toLine < Line)
                result -= range->linesCollapsed;
            // Inside fold
            else if (range->fromLine < Line && Line <= range->toLine)
                result -= Line - range->fromLine;
        }
    }
    return result;
}

void SynEdit::setDefaultKeystrokes()
{
    mKeyStrokes.resetDefaults();
}

void SynEdit::setExtraKeystrokes()
{
    mKeyStrokes.setExtraKeyStrokes();
}

void SynEdit::invalidateLine(int Line)
{
    QRect rcInval;
    if (mPainterLock >0)
        return;
    if (Line<1 || (Line>mDocument->count() &&
                   Line!=1) || !isVisible())
        return;

    // invalidate text area of this line
    if (mUseCodeFolding)
        Line = foldLineToRow(Line);
    if (Line >= mTopLine && Line <= mTopLine + mLinesInWindow) {
        rcInval = { mGutterWidth,
                    mTextHeight * (Line - mTopLine),
                    clientWidth(),
                    mTextHeight};
        if (mStateFlags.testFlag(SynStateFlag::sfLinesChanging))
            mInvalidateRect = mInvalidateRect.united(rcInval);
        else
            invalidateRect(rcInval);
    }
}

void SynEdit::invalidateLines(int FirstLine, int LastLine)
{
    if (mPainterLock>0)
        return;

    if (!isVisible())
        return;
    if (FirstLine == -1 && LastLine == -1) {
        QRect rcInval = clientRect();
        rcInval.setLeft(rcInval.left()+mGutterWidth);
        if (mStateFlags.testFlag(SynStateFlag::sfLinesChanging)) {
            mInvalidateRect = mInvalidateRect.united(rcInval);
        } else {
            invalidateRect(rcInval);
        }
    } else {
        FirstLine = std::max(FirstLine, 1);
        LastLine = std::max(LastLine, 1);
        // find the visible lines first
        if (LastLine < FirstLine)
            std::swap(LastLine, FirstLine);

        if (LastLine >= mDocument->count())
          LastLine = INT_MAX; // paint empty space beyond last line

        if (mUseCodeFolding) {
          FirstLine = lineToRow(FirstLine);
          // Could avoid this conversion if (First = Last) and
          // (Length < CharsInWindow) but the dependency isn't worth IMO.
          if (LastLine < mDocument->count())
              LastLine = lineToRow(LastLine + 1) - 1;
        }

        // mTopLine is in display coordinates, so FirstLine and LastLine must be
        // converted previously.
        FirstLine = std::max(FirstLine, mTopLine);
        LastLine = std::min(LastLine, mTopLine + mLinesInWindow);

        // any line visible?
        if (LastLine >= FirstLine) {
            QRect rcInval = {
                clientLeft()+mGutterWidth,
                mTextHeight * (FirstLine - mTopLine),
                clientWidth(), mTextHeight * (LastLine - mTopLine + 1)
            };
            if (mStateFlags.testFlag(SynStateFlag::sfLinesChanging))
                mInvalidateRect = mInvalidateRect.united(rcInval);
            else
                invalidateRect(rcInval);
        }
    }
}

void SynEdit::invalidateSelection()
{
    if (mPainterLock>0)
        return;
    invalidateLines(blockBegin().line, blockEnd().line);
}

void SynEdit::invalidateRect(const QRect &rect)
{
    if (mPainterLock>0)
        return;
    viewport()->update(rect);
}

void SynEdit::invalidate()
{
    if (mPainterLock>0)
        return;
    viewport()->update();
}

void SynEdit::lockPainter()
{
    mPainterLock++;
}

void SynEdit::unlockPainter()
{
    Q_ASSERT(mPainterLock>0);
    mPainterLock--;
}

bool SynEdit::selAvail() const
{
    if (mBlockBegin.ch == mBlockEnd.ch && mBlockBegin.line == mBlockEnd.line)
        return false;
    // start line != end line  or start char != end char
    if (mActiveSelectionMode==SynSelectionMode::Column) {
        if (mBlockBegin.line != mBlockEnd.line) {
            DisplayCoord coordBegin = bufferToDisplayPos(mBlockBegin);
            DisplayCoord coordEnd = bufferToDisplayPos(mBlockEnd);
            return coordBegin.Column!=coordEnd.Column;
        } else
            return true;
    }
    return true;
}

bool SynEdit::colSelAvail() const
{
    if (mActiveSelectionMode != SynSelectionMode::Column)
        return false;
    if (mBlockBegin.ch == mBlockEnd.ch && mBlockBegin.line == mBlockEnd.line)
        return false;
    if (mBlockBegin.line == mBlockEnd.line && mBlockBegin.ch!=mBlockBegin.ch)
        return true;
    DisplayCoord coordBegin = bufferToDisplayPos(mBlockBegin);
    DisplayCoord coordEnd = bufferToDisplayPos(mBlockEnd);
    return coordBegin.Column!=coordEnd.Column;
}

QString SynEdit::wordAtCursor()
{
    return wordAtRowCol(caretXY());
}

QString SynEdit::wordAtRowCol(const BufferCoord &pos)
{
    if ((pos.line >= 1) && (pos.line <= mDocument->count())) {
        QString line = mDocument->getString(pos.line - 1);
        int len = line.length();
        if (len == 0)
            return "";
        if (pos.ch<1 || pos.ch>len)
            return "";

        int start = pos.ch - 1;
        if  ((start> 0) && !isIdentChar(line[start]))
             start--;

        if (isIdentChar(line[start])) {
            int stop = start;
            while ((stop < len) && isIdentChar(line[stop]))
                stop++;
            while ((start-1 >=0) && isIdentChar(line[start - 1]))
                start--;
            if (stop > start)
                return line.mid(start,stop-start);
        }
    }
    return "";
}

QChar SynEdit::charAt(const BufferCoord &pos)
{
    if ((pos.line >= 1) && (pos.line <= mDocument->count())) {
        QString line = mDocument->getString(pos.line-1);
        int len = line.length();
        if (len == 0)
            return QChar(0);
        if (pos.ch<1 || pos.ch>len)
            return QChar(0);
        return line[pos.ch-1];
    }
    return QChar(0);
}

QChar SynEdit::nextNonSpaceChar(int line, int ch)
{
    if (ch<0)
        return QChar();
    QString s = mDocument->getString(line);
    if (s.isEmpty())
        return QChar();
    int x=ch;
    while (x<s.length()) {
        QChar ch = s[x];
        if (!ch.isSpace())
            return ch;
        x++;
    }
    return QChar();
}

QChar SynEdit::lastNonSpaceChar(int line, int ch)
{
    if (line>=mDocument->count())
        return QChar();
    QString s = mDocument->getString(line);
    int x = std::min(ch-1,s.length()-1);
    while (line>=0) {
        while (x>=0) {
            QChar c = s[x];
            if (!c.isSpace())
                return c;
            x--;
        }
        line--;
        if (line>=0) {
            s = mDocument->getString(line);
            x = s.length()-1;
        }
    }
    return QChar();
}

void SynEdit::setCaretAndSelection(const BufferCoord &ptCaret, const BufferCoord &ptSelBegin, const BufferCoord &ptSelEnd)
{
    incPaintLock();
    internalSetCaretXY(ptCaret);
    setBlockBegin(ptSelBegin);
    setBlockEnd(ptSelEnd);
    decPaintLock();
}

bool SynEdit::inputMethodOn()
{
    return !mInputPreeditString.isEmpty();
}

void SynEdit::collapseAll()
{
    incPaintLock();
    for (int i = mAllFoldRanges.count()-1;i>=0;i--){
        collapse(mAllFoldRanges[i]);
    }
    decPaintLock();
}

void SynEdit::unCollpaseAll()
{
    incPaintLock();
    for (int i = mAllFoldRanges.count()-1;i>=0;i--){
        uncollapse(mAllFoldRanges[i]);
    }
    decPaintLock();
}

void SynEdit::processGutterClick(QMouseEvent *event)
{
    int X = event->pos().x();
    int Y = event->pos().y();
    DisplayCoord RowColumn = pixelsToNearestRowColumn(X, Y);
    int Line = rowToLine(RowColumn.Row);

    // Check if we clicked on a folding thing
    if (mUseCodeFolding) {
        PSynEditFoldRange foldRange = foldStartAtLine(Line);
        if (foldRange) {
            // See if we actually clicked on the rectangle...
            //rect.Left := Gutter.RealGutterWidth(CharWidth) - Gutter.RightOffset;
            QRect rect;
            rect.setLeft(mGutterWidth - mGutter.rightOffset());
            rect.setRight(rect.left() + mGutter.rightOffset() - 4);
            rect.setTop((RowColumn.Row - mTopLine) * mTextHeight);
            rect.setBottom(rect.top() + mTextHeight - 1);
            if (rect.contains(QPoint(X, Y))) {
                if (foldRange->collapsed)
                    uncollapse(foldRange);
                else
                    collapse(foldRange);
                return;
            }
        }
    }

    // If not, check gutter marks
    if (Line>=1 && Line <= mDocument->count()) {
        emit gutterClicked(event->button(),X,Y,Line);
    }
}

void SynEdit::clearUndo()
{
    mUndoList->clear();
    mRedoList->clear();
}

int SynEdit::findIndentsStartLine(int line, QVector<int> indents)
{
    line--;
    if (line<0 || line>=mDocument->count())
        return -1;
    while (line>=1) {
        SynRangeState range = mDocument->ranges(line);
        QVector<int> newIndents = range.indents.mid(range.firstIndentThisLine);
        int i = 0;
        int len = indents.length();
        while (i<len && !newIndents.isEmpty()) {
            int indent = indents[i];
            int idx = newIndents.lastIndexOf(indent);
            if (idx >=0) {
                newIndents.remove(idx,newIndents.size());
            } else {
                break;
            }
            i++;
        }
        if (i>=len) {
            return line+1;
        } else {
            indents = range.matchingIndents + indents.mid(i);
        }
        line--;
    }
    return -1;
}

BufferCoord SynEdit::getPreviousLeftBrace(int x, int y)
{
    QChar Test;
    QString vDummy;
    PSynHighlighterAttribute attr;
    BufferCoord p;
    bool isCommentOrStringOrChar;
    BufferCoord Result{0,0};
    // get char at caret
    int PosX = x-1;
    int PosY = y;
    if (PosX<1)
        PosY--;
    if (PosY<1 )
        return Result;
    QString Line = mDocument->getString(PosY - 1);
    if ((PosX > Line.length()) || (PosX<1))
        PosX = Line.length();
    int numBrackets = 1;
    while (true) {
        if (Line.isEmpty()){
            PosY--;
            if (PosY<1)
                return Result;
            Line = mDocument->getString(PosY - 1);
            PosX = Line.length();
            continue;
        }
        Test = Line[PosX-1];
        p.ch = PosX;
        p.line = PosY;
        if (Test=='{' || Test == '}') {
            if (getHighlighterAttriAtRowCol(p, vDummy, attr)) {
                isCommentOrStringOrChar =
                        (attr == mHighlighter->stringAttribute()) ||
                        (attr == mHighlighter->commentAttribute()) ||
                        (attr->name() == SYNS_AttrCharacter);
            } else
                isCommentOrStringOrChar = false;
            if ((Test == '{') && (! isCommentOrStringOrChar))
                numBrackets--;
            else if ((Test == '}') && (!isCommentOrStringOrChar))
                numBrackets++;
            if (numBrackets == 0) {
                return p;
            }
        }
        PosX--;
        if (PosX<1) {
            PosY--;
            if (PosY<1)
                return Result;
            Line = mDocument->getString(PosY - 1);
            PosX = Line.length();
        }
    }
}

int SynEdit::charColumns(QChar ch) const
{
    return mDocument->charColumns(ch);
}

void SynEdit::showCaret()
{
    if (m_blinkTimerId==0)
        m_blinkTimerId = startTimer(500);
    m_blinkStatus = 1;
    updateCaret();
}

void SynEdit::hideCaret()
{
    if (m_blinkTimerId!=0) {
        killTimer(m_blinkTimerId);
        m_blinkTimerId = 0;
        m_blinkStatus = 0;
        updateCaret();
    }
}

bool SynEdit::isPointInSelection(const BufferCoord &Value) const
{
    BufferCoord ptBegin = blockBegin();
    BufferCoord ptEnd = blockEnd();
    if ((Value.line >= ptBegin.line) && (Value.line <= ptEnd.line) &&
            ((ptBegin.line != ptEnd.line) || (ptBegin.ch != ptEnd.ch))) {
        if (mActiveSelectionMode == SynSelectionMode::Line)
            return true;
        else if (mActiveSelectionMode == SynSelectionMode::Column) {
            if (ptBegin.ch > ptEnd.ch)
                return (Value.ch >= ptEnd.ch) && (Value.ch < ptBegin.ch);
            else if (ptBegin.ch < ptEnd.ch)
                return (Value.ch >= ptBegin.ch) && (Value.ch < ptEnd.ch);
            else
                return false;
        } else
            return ((Value.line > ptBegin.line) || (Value.ch >= ptBegin.ch)) &&
      ((Value.line < ptEnd.line) || (Value.ch < ptEnd.ch));
    } else
        return false;
}

BufferCoord SynEdit::nextWordPos()
{
    return nextWordPosEx(caretXY());
}

BufferCoord SynEdit::nextWordPosEx(const BufferCoord &XY)
{
    int CX = XY.ch;
    int CY = XY.line;
    // valid line?
    if ((CY >= 1) && (CY <= mDocument->count())) {
        QString Line = mDocument->getString(CY - 1);
        int LineLen = Line.length();
        if (CX >= LineLen) {
            // find first IdentChar or multibyte char in the next line
            if (CY < mDocument->count()) {
                Line = mDocument->getString(CY);
                CY++;
                CX=StrScanForWordChar(Line,1);
                if (CX==0)
                    CX=1;
            }
        } else {
            // find next "whitespace" if current char is an IdentChar
            if (!Line[CX-1].isSpace())
                CX = StrScanForNonWordChar(Line,CX);
            // if "whitespace" found, find the next IdentChar
            if (CX > 0)
                CX = StrScanForWordChar(Line, CX);
            // if one of those failed position at the begin of next line
            if (CX == 0) {
                if (CY < mDocument->count()) {
                    Line = mDocument->getString(CY);
                    CY++;
                    CX=StrScanForWordChar(Line,1);
                    if (CX==0)
                        CX=1;
                } else {
                    CX=Line.length()+1;
                }
            }
        }
    }
    return BufferCoord{CX,CY};
}

BufferCoord SynEdit::wordStart()
{
    return wordStartEx(caretXY());
}

BufferCoord SynEdit::wordStartEx(const BufferCoord &XY)
{
    int CX = XY.ch;
    int CY = XY.line;
    // valid line?
    if ((CY >= 1) && (CY <= mDocument->count())) {
        QString Line = mDocument->getString(CY - 1);
        CX = std::min(CX, Line.length()+1);
        if (CX > 1) {
            if (isWordChar(Line[CX - 2]))
                CX = StrRScanForNonWordChar(Line, CX - 1) + 1;
        }
    }
    return BufferCoord{CX,CY};
}

BufferCoord SynEdit::wordEnd()
{
    return wordEndEx(caretXY());
}

BufferCoord SynEdit::wordEndEx(const BufferCoord &XY)
{
    int CX = XY.ch;
    int CY = XY.line;
    // valid line?
    if ((CY >= 1) && (CY <= mDocument->count())) {
        QString Line = mDocument->getString(CY - 1);
        if (CX <= Line.length() && CX-1>=0) {
            if (isWordChar(Line[CX - 1]))
                CX = StrScanForNonWordChar(Line, CX);
            if (CX == 0)
                CX = Line.length() + 1;
        }
    }
    return BufferCoord{CX,CY};
}

BufferCoord SynEdit::prevWordPos()
{
    return prevWordPosEx(caretXY());
}

BufferCoord SynEdit::prevWordPosEx(const BufferCoord &XY)
{
    int CX = XY.ch;
    int CY = XY.line;
    // valid line?
    if ((CY >= 1) && (CY <= mDocument->count())) {
        QString Line = mDocument->getString(CY - 1);
        CX = std::min(CX, Line.length());
        if (CX <= 1) {
            // find last IdentChar in the previous line
            if (CY > 1) {
                CY -- ;
                Line = mDocument->getString(CY - 1);
                CX = StrRScanForWordChar(Line, Line.length())+1;
            }
        } else {
            // if previous char is a "whitespace" search for the last IdentChar
            if (!isWordChar(Line[CX - 2]))
                CX = StrRScanForWordChar(Line, CX - 1);
            if (CX > 0) // search for the first IdentChar of this "word"
                CX = StrRScanForNonWordChar(Line, CX - 1)+1;
            if (CX == 0) {
                // find last IdentChar in the previous line
                if (CY > 1) {
                    CY -- ;
                    Line = mDocument->getString(CY - 1);
                    CX = StrRScanForWordChar(Line, Line.length())+1;
                } else {
                    CX = 1;
                }
            }
        }
    }
    return BufferCoord{CX,CY};
}

void SynEdit::setSelWord()
{
    setWordBlock(caretXY());
}

void SynEdit::setWordBlock(BufferCoord Value)
{
//    if (mOptions.testFlag(eoScrollPastEol))
//        Value.Char =
//    else
//        Value.Char = std::max(Value.Char, 1);
    Value.line = minMax(Value.line, 1, mDocument->count());
    Value.ch = std::max(Value.ch, 1);
    QString TempString = mDocument->getString(Value.line - 1); //needed for CaretX = LineLength +1
    if (Value.ch > TempString.length()) {
        internalSetCaretXY(BufferCoord{TempString.length()+1, Value.line});
        return;
    }

    BufferCoord v_WordStart = wordStartEx(Value);
    BufferCoord v_WordEnd = wordEndEx(Value);
    if ((v_WordStart.line == v_WordEnd.line) && (v_WordStart.ch < v_WordEnd.ch))
        setCaretAndSelection(v_WordEnd, v_WordStart, v_WordEnd);
}

int SynEdit::findCommentStartLine(int searchStartLine)
{
    int commentStartLine = searchStartLine;
    SynRangeState range;
    while (commentStartLine>=1) {
        range = mDocument->ranges(commentStartLine-1);
        if (!mHighlighter->isLastLineCommentNotFinished(range.state)){
            commentStartLine++;
            break;
        }
        if (!range.matchingIndents.isEmpty()
                || range.firstIndentThisLine<range.indents.length())
            break;
        commentStartLine--;
    }
    if (commentStartLine<1)
        commentStartLine = 1;
    return commentStartLine;
}

int SynEdit::calcIndentSpaces(int line, const QString& lineText, bool addIndent)
{
    if (!mHighlighter)
        return 0;
    line = std::min(line, mDocument->count()+1);
    if (line<=1)
        return 0;
    // find the first non-empty preceeding line
    int startLine = line-1;
    QString startLineText;
    while (startLine>=1) {
        startLineText = mDocument->getString(startLine-1);
        if (!startLineText.startsWith('#') && !startLineText.trimmed().isEmpty()) {
            break;
        }
        startLine -- ;
    }
    int indentSpaces = 0;
    if (startLine>=1) {
        //calculate the indents of last statement;
        indentSpaces = leftSpaces(startLineText);
        SynRangeState rangePreceeding = mDocument->ranges(startLine-1);
        mHighlighter->setState(rangePreceeding);
        if (addIndent) {
//            QString trimmedS = s.trimmed();
            QString trimmedLineText = lineText.trimmed();
            mHighlighter->setLine(trimmedLineText,line-1);
            int statePrePre;
            if (startLine>1) {
                statePrePre = mDocument->ranges(startLine-2).state;
            } else {
                statePrePre = 0;
            }
            SynRangeState rangeAfterFirstToken = mHighlighter->getRangeState();
            QString firstToken = mHighlighter->getToken();
            PSynHighlighterAttribute attr = mHighlighter->getTokenAttribute();
            if (attr == mHighlighter->keywordAttribute()
                                  &&  lineText.endsWith(':')
                                  && (
                                  firstToken == "public" || firstToken == "private"
                                  || firstToken == "protected" || firstToken == "case")) {
                // public: private: protecte: case: should indents like it's parent statement
                mHighlighter->setState(rangePreceeding);
                mHighlighter->setLine("}",line-1);
                rangeAfterFirstToken = mHighlighter->getRangeState();
                firstToken = mHighlighter->getToken();
                attr = mHighlighter->getTokenAttribute();
            }
            bool indentAdded = false;
            int additionIndent = 0;
            QVector<int> matchingIndents;
            int l;
            if (attr == mHighlighter->symbolAttribute()
                    && (firstToken == '}')) {
                // current line starts with '}', we should consider it to calc indents
                matchingIndents = rangeAfterFirstToken.matchingIndents;
                indentAdded = true;
                l = startLine;
            } else if (attr == mHighlighter->symbolAttribute()
                       && (firstToken == '{')
                       && (rangePreceeding.getLastIndent()==sitStatement)) {
                // current line starts with '{' and last statement not finished, we should consider it to calc indents
                matchingIndents = rangeAfterFirstToken.matchingIndents;
                indentAdded = true;
                l = startLine;
            } else if (mHighlighter->getClass() == SynHighlighterClass::CppHighlighter
                       && trimmedLineText.startsWith('#')
                       && attr == ((SynEditCppHighlighter *)mHighlighter.get())->preprocessorAttribute()) {
                indentAdded = true;
                indentSpaces=0;
                l=0;
            } else if (mHighlighter->getClass() == SynHighlighterClass::CppHighlighter
                       && mHighlighter->isLastLineCommentNotFinished(rangePreceeding.state)
                       ) {
                // last line is a not finished comment,
                if  (trimmedLineText.startsWith("*")) {
                    // this line start with "* "
                    // it means this line is a docstring, should indents according to
                    // the line the comment beginning , and add 1 additional space
                    additionIndent = 1;
                    int commentStartLine = findCommentStartLine(startLine-1);
                    SynRangeState range;
                    indentSpaces = leftSpaces(mDocument->getString(commentStartLine-1));
                    range = mDocument->ranges(commentStartLine-1);
                    matchingIndents = range.matchingIndents;
                    indentAdded = true;
                    l = commentStartLine;
                } else {
                    //indents according to the beginning of the comment and 2 additional space
                    additionIndent = 0;
                    int commentStartLine = findCommentStartLine(startLine-1);
                    SynRangeState range;
                    indentSpaces = leftSpaces(mDocument->getString(commentStartLine-1))+2;
                    range = mDocument->ranges(commentStartLine-1);
                    matchingIndents = range.matchingIndents;
                    indentAdded = true;
                    l = startLine;
                }
            } else if ( mHighlighter->isLastLineCommentNotFinished(statePrePre)
                        && rangePreceeding.matchingIndents.isEmpty()
                        && rangePreceeding.firstIndentThisLine>=rangePreceeding.indents.length()
                        && !mHighlighter->isLastLineCommentNotFinished(rangePreceeding.state)) {
                // the preceeding line is the end of comment
                // we should use the indents of the start line of the comment
                int commentStartLine = findCommentStartLine(startLine-2);
                SynRangeState range;
                indentSpaces = leftSpaces(mDocument->getString(commentStartLine-1));
                range = mDocument->ranges(commentStartLine-1);
                matchingIndents = range.matchingIndents;
                indentAdded = true;
                l = commentStartLine;
            } else {
                // we just use infos till preceeding line's end to calc indents
                matchingIndents = rangePreceeding.matchingIndents;
                l = startLine-1;
            }

            if (!matchingIndents.isEmpty()
                    ) {
                // find the indent's start line, and use it's indent as the default indent;
                while (l>=1) {
                    SynRangeState range = mDocument->ranges(l-1);
                    QVector<int> newIndents = range.indents.mid(range.firstIndentThisLine);
                    int i = 0;
                    int len = matchingIndents.length();
                    while (i<len && !newIndents.isEmpty()) {
                        int indent = matchingIndents[i];
                        int idx = newIndents.lastIndexOf(indent);
                        if (idx >=0) {
                            newIndents.remove(idx,newIndents.length()-idx);
                        } else {
                            break;
                        }
                        i++;
                    }
                    if (i>=len) {
                        // we found the where the indent started
                        if (len>0 && !range.matchingIndents.isEmpty()
                                &&
                                ( matchingIndents.back()== sitBrace
                                  || matchingIndents.back() == sitStatement
                                ) ) {
                            // but it's not a complete statement
                            matchingIndents = range.matchingIndents;
                        } else {
                            indentSpaces = leftSpaces(mDocument->getString(l-1));
                            if (newIndents.length()>0)
                                indentSpaces+=tabWidth();
                            break;
                        }
                    } else {
                        matchingIndents = range.matchingIndents + matchingIndents.mid(i);
                    }
                    l--;
                }
            }
            if (!indentAdded) {
                if (rangePreceeding.firstIndentThisLine < rangePreceeding.indents.length()) {
                    indentSpaces += tabWidth();
                    indentAdded = true;
                }
            }

            if (!indentAdded && !startLineText.isEmpty()) {
                BufferCoord coord;
                QString token;
                PSynHighlighterAttribute attr;
                coord.line = startLine;
                coord.ch = document()->getString(startLine-1).length();
                if (getHighlighterAttriAtRowCol(coord,token,attr)
                        && attr == mHighlighter->symbolAttribute()
                        && token == ":") {
                    indentSpaces += tabWidth();
                    indentAdded = true;
                }
            }
            indentSpaces += additionIndent;
        }
    }
    return std::max(0,indentSpaces);
}

void SynEdit::doSelectAll()
{
    BufferCoord LastPt;
    LastPt.ch = 1;
    if (mDocument->empty()) {
        LastPt.line = 1;
    } else {
        LastPt.line = mDocument->count();
        LastPt.ch = mDocument->getString(LastPt.line-1).length()+1;
    }
    setCaretAndSelection(caretXY(), BufferCoord{1, 1}, LastPt);
    // Selection should have changed...
    emit statusChanged(SynStatusChange::scSelection);
}

void SynEdit::doComment()
{
    BufferCoord origBlockBegin, origBlockEnd, origCaret;
    int endLine;
    if (mReadOnly)
        return;
    doOnPaintTransient(SynTransientType::ttBefore);
    mUndoList->beginBlock();
    auto action = finally([this]{
        mUndoList->endBlock();
    });
    origBlockBegin = blockBegin();
    origBlockEnd = blockEnd();
    origCaret = caretXY();
    // Ignore the last line the cursor is placed on
    if (origBlockEnd.ch == 1)
        endLine = std::max(origBlockBegin.line - 1, origBlockEnd.line - 2);
    else
        endLine = origBlockEnd.line - 1;
    for (int i = origBlockBegin.line - 1; i<=endLine; i++) {
        mDocument->putString(i, "//" + mDocument->getString(i));
        mUndoList->addChange(SynChangeReason::Insert,
              BufferCoord{1, i + 1},
              BufferCoord{3, i + 1},
              QStringList(), SynSelectionMode::Normal);
    }
    // When grouping similar commands, process one comment action per undo/redo
    mUndoList->addGroupBreak();
    // Move begin of selection
    if (origBlockBegin.ch > 1)
        origBlockBegin.ch+=2;
    // Move end of selection
    if (origBlockEnd.ch > 1)
        origBlockEnd.ch+=2;
    // Move caret
    if (origCaret.ch > 1)
          origCaret.ch+=2;
    setCaretAndSelection(origCaret, origBlockBegin, origBlockEnd);
}

void SynEdit::doUncomment()
{
    BufferCoord origBlockBegin, origBlockEnd, origCaret;
    int endLine;
    QString s;
    QStringList changeText;
    changeText.append("//");
    if (mReadOnly)
        return;
    doOnPaintTransient(SynTransientType::ttBefore);
    mUndoList->beginBlock();
    auto action = finally([this]{
        mUndoList->endBlock();
    });
    origBlockBegin = blockBegin();
    origBlockEnd = blockEnd();
    origCaret = caretXY();
    // Ignore the last line the cursor is placed on
    if (origBlockEnd.ch == 1)
        endLine = std::max(origBlockBegin.line - 1, origBlockEnd.line - 2);
    else
        endLine = origBlockEnd.line - 1;
    for (int i = origBlockBegin.line - 1; i<= endLine; i++) {
        s = mDocument->getString(i);
        // Find // after blanks only
        int j = 0;
        while ((j+1 < s.length()) && (s[j] == '\n' || s[j] == '\t'))
            j++;
        if ((j + 1 < s.length()) && (s[j] == '/') && (s[j + 1] == '/')) {
            s.remove(j,2);
            mDocument->putString(i,s);
            mUndoList->addChange(SynChangeReason::Delete,
                                 BufferCoord{j+1, i + 1},
                                 BufferCoord{j + 3, i + 1},
                                 changeText, SynSelectionMode::Normal);
            // Move begin of selection
            if ((i == origBlockBegin.line - 1) && (origBlockBegin.ch > 1))
                origBlockBegin.ch-=2;
            // Move end of selection
            if ((i == origBlockEnd.line - 1) && (origBlockEnd.ch > 1))
                origBlockEnd.ch-=2;
            // Move caret
            if ((i == origCaret.line - 1) && (origCaret.ch > 1))
                origCaret.ch-=2;
        }
    }
    // When grouping similar commands, process one uncomment action per undo/redo
    mUndoList->addGroupBreak();
    setCaretAndSelection(origCaret,origBlockBegin,origBlockEnd);
}

void SynEdit::doToggleComment()
{
    BufferCoord origBlockBegin, origBlockEnd, origCaret;
    int endLine;
    QString s;
    bool allCommented = true;
    if (mReadOnly)
        return;
    doOnPaintTransient(SynTransientType::ttBefore);
    mUndoList->beginBlock();
    auto action = finally([this]{
        mUndoList->endBlock();
    });
    origBlockBegin = blockBegin();
    origBlockEnd = blockEnd();
    origCaret = caretXY();
    // Ignore the last line the cursor is placed on
    if (origBlockEnd.ch == 1)
        endLine = std::max(origBlockBegin.line - 1, origBlockEnd.line - 2);
    else
        endLine = origBlockEnd.line - 1;
    for (int i = origBlockBegin.line - 1; i<= endLine; i++) {
        s = mDocument->getString(i);
        // Find // after blanks only
        int j = 0;
        while ((j < s.length()) && (s[j] == '\n' || s[j] == '\t'))
            j++;
        if (j>= s.length())
            continue;
        if (s[j] != '/'){
            allCommented = false;
            break;
        }
        if (j+1>=s.length()) {
            allCommented = false;
            break;
        }
        if (s[j + 1] != '/') {
            allCommented = false;
            break;
        }
    }
    if (allCommented)
        doUncomment();
    else
        doComment();
}

void SynEdit::doToggleBlockComment()
{
    QString s;
    if (mReadOnly)
        return;
    doOnPaintTransient(SynTransientType::ttBefore);

    QString text=selText().trimmed();
    if (text.length()>4 && text.startsWith("/*") && text.endsWith("*/")) {
        QString newText=selText();
        int pos = newText.indexOf("/*");
        if (pos>=0) {
            newText.remove(pos,2);
        }
        pos = newText.lastIndexOf("*/");
        if (pos>=0) {
            newText.remove(pos,2);
        }
        setSelText(newText);
    } else {
        QString newText="/*"+selText()+"*/";
        setSelText(newText);
    }

}

void SynEdit::doMouseScroll(bool isDragging)
{
    if (mDropped) {
        mDropped=false;
        return;
    }
    if (!hasFocus())
        return;
    Qt::MouseButtons buttons = qApp->mouseButtons();
    if (!buttons.testFlag(Qt::LeftButton))
        return;
    QPoint iMousePos;
    DisplayCoord C;
    int X, Y;

    iMousePos = QCursor::pos();
    iMousePos = mapFromGlobal(iMousePos);
    C = pixelsToNearestRowColumn(iMousePos.x(), iMousePos.y());
    C.Row = minMax(C.Row, 1, displayLineCount());
    if (mScrollDeltaX != 0) {
        setLeftChar(leftChar() + mScrollDeltaX * mMouseSelectionScrollSpeed);
        X = leftChar();
        if (mScrollDeltaX > 0) // scrolling right?
            X+=charsInWindow();
        C.Column = X;
    }
    if (mScrollDeltaY != 0) {
        //qDebug()<<mScrollDeltaY;
        if (QApplication::queryKeyboardModifiers().testFlag(Qt::ShiftModifier))
          setTopLine(mTopLine + mScrollDeltaY * mLinesInWindow);
        else
          setTopLine(mTopLine + mScrollDeltaY * mMouseSelectionScrollSpeed);
        Y = mTopLine;
        if (mScrollDeltaY > 0)  // scrolling down?
            Y+=mLinesInWindow - 1;
        C.Row = minMax(Y, 1, displayLineCount());
    }
    BufferCoord vCaret = displayToBufferPos(C);
    if ((caretX() != vCaret.ch) || (caretY() != vCaret.line)) {
        if (mActiveSelectionMode == SynSelectionMode::Column) {
            int startLine=std::min(mBlockBegin.line,mBlockEnd.line);
            startLine = std::min(startLine,vCaret.line);
            int endLine=std::max(mBlockBegin.line,mBlockEnd.line);
            endLine = std::max(endLine,vCaret.line);

            int currentCol=displayXY().Column;
            for (int i=startLine;i<=endLine;i++) {
                QString s = mDocument->getString(i-1);
                int cols = stringColumns(s,0);
                if (cols+1<currentCol) {
                    computeScroll(isDragging);
                    return;
                }
            }

        }
        // changes to line / column in one go
        incPaintLock();
        auto action = finally([this]{
            decPaintLock();
        });
        internalSetCaretXY(vCaret);

        // if MouseCapture is True we're changing selection. otherwise we're dragging
        if (isDragging) {
            setBlockBegin(mDragSelBeginSave);
            setBlockEnd(mDragSelEndSave);
        } else
            setBlockEnd(caretXY());

        if (mOptions.testFlag(SynEditorOption::eoGroupUndo))
            mUndoList->addGroupBreak();
    }
    computeScroll(isDragging);
}

QString SynEdit::getDisplayStringAtLine(int line) const
{
    QString s = mDocument->getString(line-1);
    PSynEditFoldRange foldRange = foldStartAtLine(line);
    if ((foldRange) && foldRange->collapsed) {
        return s+highlighter()->foldString();
    }
    return s;
}

void SynEdit::doDeleteLastChar()
{
    if (mReadOnly)
        return ;
    doOnPaintTransientEx(SynTransientType::ttBefore, true);
    auto action = finally([this]{
        ensureCursorPosVisible();
        doOnPaintTransientEx(SynTransientType::ttAfter, true);
    });

    if (mActiveSelectionMode==SynSelectionMode::Column) {
        BufferCoord start=blockBegin();
        BufferCoord end=blockEnd();
        if (!selAvail()) {
            start.ch--;
            setBlockBegin(start);
            setBlockEnd(end);
        }
        setSelectedTextEmpty();
        return;
    }
    if (selAvail()) {
        setSelectedTextEmpty();
        return;
    }
    bool shouldAddGroupBreak=false;
    QString Temp = lineText();
    int Len = Temp.length();
    BufferCoord Caret = caretXY();
    QStringList helper;
    if (mCaretX > Len + 1) {
        // only move caret one column
        return;
    } else if (mCaretX == 1) {
        // join this line with the last line if possible
        if (mCaretY > 1) {
            internalSetCaretY(mCaretY - 1);
            internalSetCaretX(mDocument->getString(mCaretY - 1).length() + 1);
            mDocument->deleteAt(mCaretY);
            doLinesDeleted(mCaretY+1, 1);
            if (mOptions.testFlag(eoTrimTrailingSpaces))
                Temp = trimRight(Temp);
            setLineText(lineText() + Temp);
            helper.append("");
            helper.append("");
            shouldAddGroupBreak=true;
        }
    } else {
        // delete text before the caret
        int caretColumn = charToColumn(mCaretY,mCaretX);
        int SpaceCount1 = leftSpaces(Temp);
        int SpaceCount2 = 0;
        int newCaretX;

        if (SpaceCount1 == caretColumn - 1) {
                //how much till the next tab column
                int BackCounter = (caretColumn - 1) % tabWidth();
                if (BackCounter == 0)
                    BackCounter = tabWidth();
                SpaceCount2 = std::max(0,SpaceCount1 - tabWidth());
                newCaretX = columnToChar(mCaretY,SpaceCount2+1);
                helper.append(Temp.mid(newCaretX - 1, mCaretX - newCaretX));
                Temp.remove(newCaretX-1,mCaretX - newCaretX);
            properSetLine(mCaretY - 1, Temp);
            internalSetCaretX(newCaretX);
        } else {
            // delete char
            internalSetCaretX(mCaretX - 1);
            QChar ch=Temp[mCaretX-1];
            if (ch==' ' || ch=='\t')
                shouldAddGroupBreak=true;
            helper.append(QString(ch));
            Temp.remove(mCaretX-1,1);
            properSetLine(mCaretY - 1, Temp);
        }
    }
    if ((Caret.ch != mCaretX) || (Caret.line != mCaretY)) {
        mUndoList->addChange(SynChangeReason::Delete, caretXY(), Caret, helper,
                        mActiveSelectionMode);
        if (shouldAddGroupBreak)
            mUndoList->addGroupBreak();
    }
}

void SynEdit::doDeleteCurrentChar()
{
    QStringList helper;
    BufferCoord Caret;
    if (mReadOnly) {
        return;
    }
    doOnPaintTransient(SynTransientType::ttBefore);
    auto action = finally([this]{
        ensureCursorPosVisible();
        doOnPaintTransient(SynTransientType::ttAfter);
    });

    if (mActiveSelectionMode==SynSelectionMode::Column) {
        BufferCoord start=blockBegin();
        BufferCoord end=blockEnd();
        if (!selAvail()) {
            end.ch++;
            setBlockBegin(start);
            setBlockEnd(end);
        }
        setSelectedTextEmpty();
        return;
    }
    if (selAvail())
        setSelectedTextEmpty();
    else {
        bool shouldAddGroupBreak=false;
        // Call UpdateLastCaretX. Even though the caret doesn't move, the
        // current caret position should "stick" whenever text is modified.
        updateLastCaretX();
        QString Temp = lineText();
        int Len = Temp.length();
        if (mCaretX>Len+1) {
            return;
        } else if (mCaretX <= Len) {
            QChar ch = Temp[mCaretX-1];
            if (ch==' ' || ch=='\t')
                shouldAddGroupBreak=true;
            // delete char
            helper.append(QString(ch));
            Caret.ch = mCaretX + 1;
            Caret.line = mCaretY;
            Temp.remove(mCaretX-1, 1);
            properSetLine(mCaretY - 1, Temp);
        } else {
            // join line with the line after
            if (mCaretY < mDocument->count()) {
                shouldAddGroupBreak=true;
                properSetLine(mCaretY - 1, Temp + mDocument->getString(mCaretY));
                Caret.ch = 1;
                Caret.line = mCaretY + 1;
                helper.append("");
                helper.append("");
                mDocument->deleteAt(mCaretY);
                if (mCaretX==1)
                    doLinesDeleted(mCaretY, 1);
                else
                    doLinesDeleted(mCaretY + 1, 1);
            }
        }
        if ((Caret.ch != mCaretX) || (Caret.line != mCaretY)) {
            mUndoList->addChange(SynChangeReason::Delete, caretXY(), Caret,
                  helper, mActiveSelectionMode);
            if (shouldAddGroupBreak)
                mUndoList->addGroupBreak();
        }
    }
}

void SynEdit::doDeleteWord()
{
    if (mReadOnly)
        return;
    if (mCaretX>lineText().length()+1)
        return;

    BufferCoord start = wordStart();
    BufferCoord end = wordEnd();
    deleteFromTo(start,end);
}

void SynEdit::doDeleteToEOL()
{
    if (mReadOnly)
        return;
    if (mCaretX>lineText().length()+1)
        return;

    deleteFromTo(caretXY(),BufferCoord{lineText().length()+1,mCaretY});
}

void SynEdit::doDeleteToWordStart()
{
    if (mReadOnly)
        return;
    if (mCaretX>lineText().length()+1)
        return;

    BufferCoord start = wordStart();
    BufferCoord end = caretXY();
    if (start==end) {
        start = prevWordPos();
    }
    deleteFromTo(start,end);
}

void SynEdit::doDeleteToWordEnd()
{
    if (mReadOnly)
        return;
    if (mCaretX>lineText().length()+1)
        return;

    BufferCoord start = caretXY();
    BufferCoord end = wordEnd();
    if (start == end) {
        end = wordEndEx(nextWordPos());
    }
    deleteFromTo(start,end);
}

void SynEdit::doDeleteFromBOL()
{
    if (mReadOnly)
        return;
    if (mCaretX>lineText().length()+1)
        return;

    deleteFromTo(BufferCoord{1,mCaretY},caretXY());
}

void SynEdit::doDeleteLine()
{
    if (!mReadOnly && (mDocument->count() > 0)) {
        PSynEditFoldRange foldRange=foldStartAtLine(mCaretY);
        if (foldRange && foldRange->collapsed)
            return;
        doOnPaintTransient(SynTransientType::ttBefore);
        mUndoList->beginBlock();
        addCaretToUndo();
        addSelectionToUndo();
        if (selAvail())
            setBlockBegin(caretXY());
        QStringList helper(lineText());
        if (mCaretY == mDocument->count()) {
            if (mDocument->count()==1) {
                mDocument->putString(mCaretY - 1,"");
                mUndoList->addChange(SynChangeReason::Delete,
                                     BufferCoord{1, mCaretY},
                                     BufferCoord{helper.length() + 1, mCaretY},
                                     helper, SynSelectionMode::Normal);
            } else {
                QString s = mDocument->getString(mCaretY-2);
                mDocument->deleteAt(mCaretY - 1);
                helper.insert(0,"");
                mUndoList->addChange(SynChangeReason::Delete,
                                     BufferCoord{s.length()+1, mCaretY-1},
                                     BufferCoord{helper.length() + 1, mCaretY},
                                     helper, SynSelectionMode::Normal);
                doLinesDeleted(mCaretY, 1);
                mCaretY--;
            }
        } else {
            mDocument->deleteAt(mCaretY - 1);
            helper.append("");
            mUndoList->addChange(SynChangeReason::Delete,
                                 BufferCoord{1, mCaretY},
                                 BufferCoord{helper.length() + 1, mCaretY},
                                 helper, SynSelectionMode::Normal);
            doLinesDeleted(mCaretY, 1);
        }
        mUndoList->endBlock();
        internalSetCaretXY(BufferCoord{1, mCaretY}); // like seen in the Delphi editor
        doOnPaintTransient(SynTransientType::ttAfter);
    }
}

void SynEdit::doSelecteLine()
{
    setBlockBegin(BufferCoord{1,mCaretY});
    if (mCaretY==mDocument->count())
        setBlockEnd(BufferCoord{lineText().length()+1,mCaretY});
    else
        setBlockEnd(BufferCoord{1,mCaretY+1});
}

void SynEdit::doDuplicateLine()
{
    if (!mReadOnly && (mDocument->count() > 0)) {
        PSynEditFoldRange foldRange=foldStartAtLine(mCaretY);
        if (foldRange && foldRange->collapsed)
            return;
        QString s = lineText();
        doOnPaintTransient(SynTransientType::ttBefore);
        mDocument->insert(mCaretY, lineText());
        doLinesInserted(mCaretY + 1, 1);
        mUndoList->beginBlock();
        addCaretToUndo();
        mUndoList->addChange(SynChangeReason::LineBreak,
                             BufferCoord{s.length()+1,mCaretY},
                             BufferCoord{s.length()+1,mCaretY}, QStringList(), SynSelectionMode::Normal);
        mUndoList->addChange(SynChangeReason::Insert,
                             BufferCoord{1,mCaretY+1},
                             BufferCoord{s.length()+1,mCaretY+1}, QStringList(), SynSelectionMode::Normal);
        mUndoList->endBlock();
        internalSetCaretXY(BufferCoord{1, mCaretY}); // like seen in the Delphi editor
        doOnPaintTransient(SynTransientType::ttAfter);
    }
}

void SynEdit::doMoveSelUp()
{
    if (mActiveSelectionMode == SynSelectionMode::Column)
        return;
    if (!mReadOnly && (mDocument->count() > 0) && (blockBegin().line > 1)) {
        if (!mUndoing) {
            mUndoList->beginBlock();
            addCaretToUndo();
            addSelectionToUndo();
        }
        BufferCoord origBlockBegin = blockBegin();
        BufferCoord origBlockEnd = blockEnd();
        PSynEditFoldRange foldRange=foldStartAtLine(origBlockEnd.line);
        if (foldRange && foldRange->collapsed)
            return;
//        for (int line=origBlockBegin.Line;line<=origBlockEnd.Line;line++) {
//            PSynEditFoldRange foldRange=foldStartAtLine(line);
//            if (foldRange && foldRange->collapsed)
//                return;
//        }

        doOnPaintTransient(SynTransientType::ttBefore);

        // Delete line above selection
        QString s = mDocument->getString(origBlockBegin.line - 2); // before start, 0 based
        mDocument->deleteAt(origBlockBegin.line - 2); // before start, 0 based
        doLinesDeleted(origBlockBegin.line - 1, 1); // before start, 1 based

        // Insert line below selection
        mDocument->insert(origBlockEnd.line - 1, s);
        doLinesInserted(origBlockEnd.line, 1);
        // Restore caret and selection
        setCaretAndSelection(
                  BufferCoord{mCaretX, origBlockBegin.line - 1},
                  BufferCoord{origBlockBegin.ch, origBlockBegin.line - 1},
                  BufferCoord{origBlockEnd.ch, origBlockEnd.line - 1}
        );
        if (!mUndoing) {
            mUndoList->addChange(SynChangeReason::MoveSelectionUp,
                    origBlockBegin,
                    origBlockEnd,
                    QStringList(),
                    SynSelectionMode::Normal);
            mUndoList->endBlock();
        }

        doOnPaintTransient(SynTransientType::ttAfter);
    }
}

void SynEdit::doMoveSelDown()
{
    if (mActiveSelectionMode == SynSelectionMode::Column)
        return;
    if (!mReadOnly && (mDocument->count() > 0) && (blockEnd().line < mDocument->count())) {
        if (!mUndoing) {
            mUndoList->beginBlock();
            addCaretToUndo();
            addSelectionToUndo();
        }
        BufferCoord origBlockBegin = blockBegin();
        BufferCoord origBlockEnd = blockEnd();

        PSynEditFoldRange foldRange=foldStartAtLine(origBlockEnd.line);
        if (foldRange && foldRange->collapsed)
            return;

        doOnPaintTransient(SynTransientType::ttBefore);

        // Delete line below selection
        QString s = mDocument->getString(origBlockEnd.line); // after end, 0 based
        mDocument->deleteAt(origBlockEnd.line); // after end, 0 based
        doLinesDeleted(origBlockEnd.line, 1); // before start, 1 based

        // Insert line above selection
        mDocument->insert(origBlockBegin.line - 1, s);
        doLinesInserted(origBlockBegin.line, 1);

        // Restore caret and selection
        setCaretAndSelection(
                  BufferCoord{mCaretX, origBlockEnd.line + 1},
                  BufferCoord{origBlockBegin.ch, origBlockBegin.line + 1},
                  BufferCoord{origBlockEnd.ch, origBlockEnd.line + 1}
                    );

        if (!mUndoing) {
            mUndoList->addChange(SynChangeReason::MoveSelectionDown,
                    origBlockBegin,
                    origBlockEnd,
                    QStringList(),
                    SynSelectionMode::Normal);
            mUndoList->endBlock();
        }

        doOnPaintTransient(SynTransientType::ttAfter);
    }
}

void SynEdit::clearAll()
{
    mDocument->clear();
    mMarkList.clear();
    mUndoList->clear();
    mRedoList->clear();
    setModified(false);
}

void SynEdit::insertLine(bool moveCaret)
{
    if (mReadOnly)
        return;
    int nLinesInserted=0;
    if (!mUndoing)
        mUndoList->beginBlock();
    auto action = finally([this] {
        if (!mUndoing)
            mUndoList->endBlock();
    });
    QString helper;
    if (selAvail()) {
        helper = selText();
        setSelectedTextEmpty();
    }

    QString Temp = lineText();

    if (mCaretX>lineText().length()+1) {
        PSynEditFoldRange foldRange = foldStartAtLine(mCaretY);
        if ((foldRange) && foldRange->collapsed) {
            QString s = Temp+highlighter()->foldString();
            if (mCaretX > s.length()) {
                if (!mUndoing) {
                    addCaretToUndo();
                    addSelectionToUndo();
                }
                mCaretY=foldRange->toLine;
                if (mCaretY>mDocument->count()) {
                    mCaretY=mDocument->count();
                }
                Temp = lineText();
                mCaretX=Temp.length()+1;
            }
        }
    }

    QString Temp2 = Temp;
    QString Temp3;
    PSynHighlighterAttribute Attr;

    // This is sloppy, but the Right Thing would be to track the column of markers
    // too, so they could be moved depending on whether they are after the caret...
    int InsDelta = (mCaretX == 1)?1:0;
    QString leftLineText = lineText().mid(0, mCaretX - 1);
    QString rightLineText = lineText().mid(mCaretX-1);
    if (!mUndoing)
        mUndoList->addChange(SynChangeReason::LineBreak, caretXY(), caretXY(), QStringList(rightLineText),
              SynSelectionMode::Normal);
    bool notInComment=true;
    properSetLine(mCaretY-1,leftLineText);
    //update range stated for line mCaretY
    if (mHighlighter) {
        if (mCaretY==1) {
            mHighlighter->resetState();
        } else {
            mHighlighter->setState(mDocument->ranges(mCaretY-2));
        }
        mHighlighter->setLine(leftLineText, mCaretY-1);
        mHighlighter->nextToEol();
        mDocument->setRange(mCaretY-1,mHighlighter->getRangeState());
        notInComment = !mHighlighter->isLastLineCommentNotFinished(
                    mHighlighter->getRangeState().state)
                && !mHighlighter->isLastLineStringNotFinished(
                    mHighlighter->getRangeState().state);
    }
    int indentSpaces = 0;
    if (mOptions.testFlag(eoAutoIndent)) {
        rightLineText=trimLeft(rightLineText);
        indentSpaces = calcIndentSpaces(mCaretY+1,
                                        rightLineText,mOptions.testFlag(eoAutoIndent)
                                            );
    }
    QString indentSpacesForRightLineText = GetLeftSpacing(indentSpaces,true);
    mDocument->insert(mCaretY, indentSpacesForRightLineText+rightLineText);
    nLinesInserted++;

    if (!mUndoing) {
        //insert new line in middle of "/*" and "*/"
        if (!notInComment &&
                ( leftLineText.endsWith("/*") && rightLineText.startsWith("*/")
                 )) {
            indentSpaces = calcIndentSpaces(mCaretY+1, "" , mOptions.testFlag(eoAutoIndent));
            indentSpacesForRightLineText = GetLeftSpacing(indentSpaces,true);
            mDocument->insert(mCaretY, indentSpacesForRightLineText);
            nLinesInserted++;
            mUndoList->addChange(SynChangeReason::LineBreak, caretXY(), caretXY(), QStringList(),
                    SynSelectionMode::Normal);
        }
        //insert new line in middle of "{" and "}"
        if (notInComment &&
                ( leftLineText.endsWith('{') && rightLineText.startsWith('}')
                 )) {
            indentSpaces = calcIndentSpaces(mCaretY+1, "" , mOptions.testFlag(eoAutoIndent)
                                                                   && notInComment);
            indentSpacesForRightLineText = GetLeftSpacing(indentSpaces,true);
            mDocument->insert(mCaretY, indentSpacesForRightLineText);
            nLinesInserted++;
            mUndoList->addChange(SynChangeReason::LineBreak, caretXY(), caretXY(), QStringList(),
                    SynSelectionMode::Normal);
        }
    }
    if (moveCaret)
        internalSetCaretXY(BufferCoord{indentSpacesForRightLineText.length()+1,mCaretY + 1});

    doLinesInserted(mCaretY - InsDelta, nLinesInserted);
    setBlockBegin(caretXY());
    setBlockEnd(caretXY());
    ensureCursorPosVisible();
    updateLastCaretX();
}

void SynEdit::doTabKey()
{
    if (mActiveSelectionMode == SynSelectionMode::Column) {
        doAddChar('\t');
        return;
    }
    // Provide Visual Studio like block indenting
    if (mOptions.testFlag(eoTabIndent) && canDoBlockIndent()) {
        doBlockIndent();
        return;
    }
    int i = 0;
    {
        mUndoList->beginBlock();
        auto action = finally([this]{
            mUndoList->endBlock();
        });
        if (selAvail()) {
            setSelectedTextEmpty();
        }
        QString Spaces;
        int NewCaretX = 0;
        if (mOptions.testFlag(eoTabsToSpaces)) {
            int cols = charToColumn(mCaretY,mCaretX);
            i = tabWidth() - (cols) % tabWidth();
            Spaces = QString(i,' ');
            NewCaretX = mCaretX + i;
        } else {
            Spaces = '\t';
            NewCaretX = mCaretX + 1;
        }
        setSelTextPrimitive(QStringList(Spaces));
    }
    ensureCursorPosVisible();
}

void SynEdit::doShiftTabKey()
{
    // Provide Visual Studio like block indenting
    if (mOptions.testFlag(eoTabIndent) && canDoBlockIndent()) {
      doBlockUnindent();
      return;
    }

    //Don't un-tab if caret is not on line or is beyond line end
    if (mCaretY > mDocument->count() || mCaretX > lineText().length()+1)
        return;
    //Don't un-tab if no chars before the Caret
    if (mCaretX==1)
        return;
    QString s = lineText().mid(0,mCaretX-1);
    //Only un-tab if caret is at the begin of the line
    if (!s.trimmed().isEmpty())
        return;

    int NewX = 0;
    if (s[s.length()-1] == '\t') {
        NewX= mCaretX-1;
    } else {
        int colsBefore = charToColumn(mCaretY,mCaretX)-1;
        int spacesToRemove = colsBefore % tabWidth();
        if (spacesToRemove == 0)
            spacesToRemove = tabWidth();
        if (spacesToRemove > colsBefore )
            spacesToRemove = colsBefore;
        NewX = mCaretX;
        while (spacesToRemove > 0 && s[NewX-2] == ' ' ) {
            NewX--;
            spacesToRemove--;
        }
    }
    // perform un-tab

    if (NewX != mCaretX) {
        doDeleteText(BufferCoord{NewX, mCaretY},caretXY(),mActiveSelectionMode);
        internalSetCaretX(NewX);
    }
}


bool SynEdit::canDoBlockIndent()
{
    BufferCoord BB;
    BufferCoord BE;

    if (selAvail()) {
//        BB = blockBegin();
//        BE = blockEnd();
        return true;
    } else {
        BB = caretXY();
        BE = caretXY();
    }


    if (BB.line > mDocument->count() || BE.line > mDocument->count()) {
        return false;
    }

    if (mActiveSelectionMode == SynSelectionMode::Normal) {
        QString s = mDocument->getString(BB.line-1).mid(0,BB.ch-1);
        if (!s.trimmed().isEmpty())
            return false;
        if (BE.ch>1) {
            QString s1=mDocument->getString(BE.line-1).mid(BE.ch-1);
            QString s2=mDocument->getString(BE.line-1).mid(0,BE.ch-1);
            if (!s1.trimmed().isEmpty() && !s2.trimmed().isEmpty())
                return false;
        }
    }
    if (mActiveSelectionMode == SynSelectionMode::Column) {
        int startCol = charToColumn(BB.line,BB.ch);
        int endCol = charToColumn(BE.line,BE.ch);
        for (int i = BB.line; i<=BE.line;i++) {
            QString line = mDocument->getString(i-1);
            int startChar = columnToChar(i,startCol);
            QString s = line.mid(0,startChar-1);
            if (!s.trimmed().isEmpty())
                return false;

            int endChar = columnToChar(i,endCol);
            s=line.mid(endChar-1);
            if (!s.trimmed().isEmpty())
                return false;
        }
    }
    return true;
}

QRect SynEdit::calculateCaretRect() const
{
    DisplayCoord coord = displayXY();
    if (!mInputPreeditString.isEmpty()) {
        QString sLine = lineText().left(mCaretX-1)
                + mInputPreeditString
                + lineText().mid(mCaretX-1);
        coord.Column = charToColumn(sLine,mCaretX+mInputPreeditString.length());
    }
    int rows=1;
    if (mActiveSelectionMode == SynSelectionMode::Column) {
        int startRow = lineToRow(std::min(blockBegin().line, blockEnd().line));
        int endRow = lineToRow(std::max(blockBegin().line, blockEnd().line));
        coord.Row = startRow;
        rows = endRow-startRow+1;
    }
    QPoint caretPos = rowColumnToPixels(coord);
    int caretWidth=mCharWidth;
    if (mCaretY <= mDocument->count() && mCaretX <= mDocument->getString(mCaretY-1).length()) {
        caretWidth = charColumns(getDisplayStringAtLine(mCaretY)[mCaretX-1])*mCharWidth;
    }
    if (mActiveSelectionMode == SynSelectionMode::Column) {
        return QRect(caretPos.x(),caretPos.y(),caretWidth,
                     mTextHeight*(rows));
    } else {
        return QRect(caretPos.x(),caretPos.y(),caretWidth,
                     mTextHeight);
    }
}

QRect SynEdit::calculateInputCaretRect() const
{
    DisplayCoord coord = displayXY();
    QPoint caretPos = rowColumnToPixels(coord);
    int caretWidth=mCharWidth;
    if (mCaretY <= mDocument->count() && mCaretX <= mDocument->getString(mCaretY-1).length()) {
        caretWidth = charColumns(mDocument->getString(mCaretY-1)[mCaretX-1])*mCharWidth;
    }
    return QRect(caretPos.x(),caretPos.y(),caretWidth,
                 mTextHeight);
}

void SynEdit::clearAreaList(SynEditingAreaList areaList)
{
    areaList.clear();
}

void SynEdit::computeCaret()
{
    QPoint iMousePos = QCursor::pos();
    iMousePos = mapFromGlobal(iMousePos);
    int X=iMousePos.x();
    int Y=iMousePos.y();

    BufferCoord oldCaret = caretXY();
    DisplayCoord vCaretNearestPos = pixelsToNearestRowColumn(X, Y);
    vCaretNearestPos.Row = minMax(vCaretNearestPos.Row, 1, displayLineCount());
    setInternalDisplayXY(vCaretNearestPos);
}

void SynEdit::computeScroll(bool isDragging)
{
    QPoint iMousePos = QCursor::pos();
    iMousePos = mapFromGlobal(iMousePos);
    int X=iMousePos.x();
    int Y=iMousePos.y();

    QRect iScrollBounds; // relative to the client area
    int dispX=2,dispY = 2;
//    if (isDragging) {
//        dispX = mCharWidth / 2 -1;
//        dispY = mTextHeight/ 2 -1;
//    }
    int left = mGutterWidth+frameWidth()+dispX;
    int top = frameWidth()+dispY;
    iScrollBounds = QRect(left,
                          top,
                          clientWidth()-left-dispX,
                          clientHeight()-top-dispY);

    if (X < iScrollBounds.left())
        mScrollDeltaX = (X - iScrollBounds.left()) / mCharWidth - 1;
    else if (X >= iScrollBounds.right())
        mScrollDeltaX = (X - iScrollBounds.right()) / mCharWidth + 1;
    else
        mScrollDeltaX = 0;

//    if (isDragging && (X<0 || X>clientRect().width())) {
//        mScrollDeltaX = 0;
//    }

    if (Y < iScrollBounds.top())
        mScrollDeltaY = (Y - iScrollBounds.top()) / mTextHeight - 1;
    else if (Y >= iScrollBounds.bottom())
        mScrollDeltaY = (Y - iScrollBounds.bottom()) / mTextHeight + 1;
    else
        mScrollDeltaY = 0;

//    if (isDragging && (Y<0 || Y>clientRect().height())) {
//        mScrollDeltaY = 0;
//    }


//    if (mScrollDeltaX!=0 || mScrollDeltaY!=0) {
    if (isDragging) {
        mScrollTimer->singleShot(100,this,&SynEdit::onDraggingScrollTimeout);
    } else  {
        mScrollTimer->singleShot(100,this,&SynEdit::onScrollTimeout);
    }
//    }
}

void SynEdit::doBlockIndent()
{
    BufferCoord  oldCaretPos;
    BufferCoord  BB, BE;
    QStringList strToInsert;
    int e,x,i;
    QString spaces;
    BufferCoord insertionPos;

    oldCaretPos = caretXY();

    // keep current selection detail
    if (selAvail()) {
        BB = blockBegin();
        BE = blockEnd();
    } else {
        BB = caretXY();
        BE = caretXY();
    }
    // build text to insert
    if (BE.ch == 1 && BE.line != BB.line) {
        e = BE.line - 1;
        x = 1;
    } else {
        e = BE.line;
        if (mOptions.testFlag(SynEditorOption::eoTabsToSpaces))
          x = caretX() + tabWidth();
        else
          x = caretX() + 1;
    }
    if (mOptions.testFlag(eoTabsToSpaces)) {
        spaces = QString(tabWidth(),' ') ;
    } else {
        spaces = "\t";
    }
    for (i = BB.line; i<e;i++) {
        strToInsert.append(spaces);
    }
    strToInsert.append(spaces);
    mUndoList->beginBlock();
    mUndoList->addChange(SynChangeReason::Caret, oldCaretPos, oldCaretPos,QStringList(), activeSelectionMode());
    mUndoList->addChange(SynChangeReason::Selection,mBlockBegin,mBlockEnd,QStringList(), activeSelectionMode());
    insertionPos.line = BB.line;
    if (mActiveSelectionMode == SynSelectionMode::Column)
      insertionPos.ch = std::min(BB.ch, BE.ch);
    else
      insertionPos.ch = 1;
    insertBlock(insertionPos, insertionPos, strToInsert);
    //adjust caret and selection
    oldCaretPos.ch = x;
    if (BB.ch > 1)
        BB.ch += spaces.length();
    if (BE.ch > 1)
      BE.ch+=spaces.length();
    setCaretAndSelection(oldCaretPos,
      BB, BE);
    mUndoList->endBlock();
}

void SynEdit::doBlockUnindent()
{
    int lastIndent = 0;
    int firstIndent = 0;

    BufferCoord BB,BE;
    // keep current selection detail
    if (selAvail()) {
        BB = blockBegin();
        BE = blockEnd();
    } else {
        BB = caretXY();
        BE = caretXY();
    }
    BufferCoord oldCaretPos = caretXY();
    int x = 0;
    mUndoList->beginBlock();
    mUndoList->addChange(SynChangeReason::Caret, oldCaretPos, oldCaretPos,QStringList(), activeSelectionMode());
    mUndoList->addChange(SynChangeReason::Selection,mBlockBegin,mBlockEnd,QStringList(), activeSelectionMode());

    int e = BE.line;
    // convert selection to complete lines
    if (BE.ch == 1)
        e = BE.line - 1;
    // build string to delete
    for (int i = BB.line; i<= e;i++) {
        QString line = mDocument->getString(i - 1);
        if (line.isEmpty())
            continue;
        if (line[0]!=' ' && line[0]!='\t')
            continue;
        int charsToDelete = 0;
        while (charsToDelete < tabWidth() &&
               charsToDelete < line.length() &&
               line[charsToDelete] == ' ')
            charsToDelete++;
        if (charsToDelete == 0)
            charsToDelete = 1;
        if (i==BB.line)
            firstIndent = charsToDelete;
        if (i==e)
            lastIndent = charsToDelete;
        if (i==oldCaretPos.line)
            x = charsToDelete;
        QString tempString = line.mid(charsToDelete);
        mDocument->putString(i-1,tempString);
        mUndoList->addChange(SynChangeReason::Delete,
                             BufferCoord{1,i},
                             BufferCoord{charsToDelete+1,i},
                             QStringList(line.left(charsToDelete)),
                             SynSelectionMode::Normal);
    }
  // restore selection
  //adjust the x position of orgcaretpos appropriately

    oldCaretPos.ch -= x;
    BB.ch -= firstIndent;
    BE.ch -= lastIndent;
    setCaretAndSelection(oldCaretPos, BB, BE);
    mUndoList->endBlock();
}

void SynEdit::doAddChar(QChar AChar)
{
    if (mReadOnly)
        return;
    if (!AChar.isPrint() && AChar!='\t')
        return;
    //DoOnPaintTransient(ttBefore);
    //mCaretX will change after setSelLength;
    if (mInserting == false && !selAvail()) {
        switch(mActiveSelectionMode) {
        case SynSelectionMode::Column: {
            //we can't use blockBegin()/blockEnd()
            BufferCoord start=mBlockBegin;
            BufferCoord end=mBlockEnd;
            if (start.line > end.line )
                std::swap(start,end);
            start.ch++; // make sure we select a whole char in the start line
            setBlockBegin(start);
            setBlockEnd(end);
        }
            break;
        case SynSelectionMode::Line:
            //do nothing;
            break;
        default:
            setSelLength(1);
        }
    }

    if (isIdentChar(AChar)) {
        doSetSelText(AChar);
    } else if (AChar.isSpace()) {
        // break group undo chain
        mUndoList->addGroupBreak();
        doSetSelText(AChar);
        // break group undo chain
//        if (mActiveSelectionMode!=SynSelectionMode::smColumn)
//            mUndoList->AddChange(SynChangeReason::crNothing,
//                                 BufferCoord{0, 0},
//                                 BufferCoord{0, 0},
//                                 "", SynSelectionMode::smNormal);
    } else {
        mUndoList->beginBlock();
        doSetSelText(AChar);
        int oldCaretX=mCaretX-1;
        int oldCaretY=mCaretY;
        // auto
        if (mActiveSelectionMode==SynSelectionMode::Normal
                && mOptions.testFlag(eoAutoIndent)
                && mHighlighter
                && mHighlighter->getClass()==SynHighlighterClass::CppHighlighter
                && (oldCaretY<=mDocument->count()) ) {

            //unindent if ':' at end of the line
            if (AChar == ':') {
                QString line = mDocument->getString(oldCaretY-1);
                if (line.length() <= oldCaretX) {
                    int indentSpaces = calcIndentSpaces(oldCaretY,line+":", true);
                    if (indentSpaces != leftSpaces(line)) {
                        QString newLine = GetLeftSpacing(indentSpaces,true) + trimLeft(line);
                        mDocument->putString(oldCaretY-1,newLine);
                        internalSetCaretXY(BufferCoord{newLine.length()+2,oldCaretY});
                        setBlockBegin(caretXY());
                        setBlockEnd(caretXY());
                        mUndoList->addChange(
                                    SynChangeReason::Delete,
                                    BufferCoord{1, oldCaretY},
                                    BufferCoord{line.length()+1, oldCaretY},
                                    QStringList(line),
                                    SynSelectionMode::Normal
                                    );
                        mUndoList->addChange(
                                    SynChangeReason::Insert,
                                    BufferCoord{1, oldCaretY},
                                    BufferCoord{newLine.length()+1, oldCaretY},
                                    QStringList(),
                                    SynSelectionMode::Normal
                                    );
                    }
                }
            } else if (AChar == '*') {
                QString line = mDocument->getString(oldCaretY-1);
                if (line.length() <= oldCaretX) {
                    int indentSpaces = calcIndentSpaces(oldCaretY,line+"*", true);
                    if (indentSpaces != leftSpaces(line)) {
                        QString newLine = GetLeftSpacing(indentSpaces,true) + trimLeft(line);
                        mDocument->putString(oldCaretY-1,newLine);
                        internalSetCaretXY(BufferCoord{newLine.length()+2,oldCaretY});
                        setBlockBegin(caretXY());
                        setBlockEnd(caretXY());
                        mUndoList->addChange(
                                    SynChangeReason::Delete,
                                    BufferCoord{1, oldCaretY},
                                    BufferCoord{line.length()+1, oldCaretY},
                                    QStringList(line),
                                    SynSelectionMode::Normal
                                    );
                        mUndoList->addChange(
                                    SynChangeReason::Insert,
                                    BufferCoord{1, oldCaretY},
                                    BufferCoord{newLine.length()+1, oldCaretY},
                                    QStringList(),
                                    SynSelectionMode::Normal
                                    );
                    }
                }
            } else if (AChar == '{' || AChar == '}' || AChar == '#') {
                //Reindent line when add '{' '}' and '#' at the beginning
                QString left = mDocument->getString(oldCaretY-1).mid(0,oldCaretX-1);
                // and the first nonblank char is this new {
                if (left.trimmed().isEmpty()) {
                    int indentSpaces = calcIndentSpaces(oldCaretY,AChar, true);
                    if (indentSpaces != leftSpaces(left)) {
                        QString right = mDocument->getString(oldCaretY-1).mid(oldCaretX-1);
                        QString newLeft = GetLeftSpacing(indentSpaces,true);
                        mDocument->putString(oldCaretY-1,newLeft+right);
                        BufferCoord newCaretPos =  BufferCoord{newLeft.length()+2,oldCaretY};
                        internalSetCaretXY(newCaretPos);
                        setBlockBegin(caretXY());
                        setBlockEnd(caretXY());
                        mUndoList->addChange(
                                    SynChangeReason::Delete,
                                    BufferCoord{1, oldCaretY},
                                    BufferCoord{left.length()+1, oldCaretY},
                                    QStringList(left),
                                    SynSelectionMode::Normal
                                    );
                        mUndoList->addChange(
                                    SynChangeReason::Insert,
                                    BufferCoord{1, oldCaretY},
                                    BufferCoord{newLeft.length()+1, oldCaretY},
                                    QStringList(""),
                                    SynSelectionMode::Normal
                                    );

                    }
                }
            }
        }
        mUndoList->endBlock();
    }
    //DoOnPaintTransient(ttAfter);
}

void SynEdit::doCutToClipboard()
{
    if (mReadOnly)
        return;
    mUndoList->beginBlock();
    addCaretToUndo();
    addSelectionToUndo();
    if (!selAvail()) {
        doSelecteLine();
    }
    internalDoCopyToClipboard(selText());
    setSelectedTextEmpty();
    mUndoList->endBlock();
    mUndoList->addGroupBreak();
}

void SynEdit::doCopyToClipboard()
{
    bool selected=selAvail();
    if (!selected)
        doSelecteLine();
    bool ChangeTrim = (mActiveSelectionMode == SynSelectionMode::Column) &&
            mOptions.testFlag(eoTrimTrailingSpaces);
    QString sText;
    {
        auto action = finally([&,this] {
            if (ChangeTrim)
                mOptions.setFlag(eoTrimTrailingSpaces);
        });
        if (ChangeTrim)
            mOptions.setFlag(eoTrimTrailingSpaces,false);
        sText = selText();
    }
    internalDoCopyToClipboard(sText);
    if (!selected) {
        setBlockBegin(caretXY());
        setBlockEnd(caretXY());
    }
}

void SynEdit::internalDoCopyToClipboard(const QString &s)
{
    QClipboard* clipboard=QGuiApplication::clipboard();
    clipboard->clear();
    clipboard->setText(s);
}

void SynEdit::doPasteFromClipboard()
{
    if (mReadOnly)
        return;
    QClipboard* clipboard = QGuiApplication::clipboard();
    QString text = clipboard->text();
    if (text.isEmpty())
        return;
    doOnPaintTransient(SynTransientType::ttBefore);
    mUndoList->beginBlock();
//    if (selAvail()) {
//        mUndoList->AddChange(
//                    SynChangeReason::crDelete,
//                    mBlockBegin,
//                    mBlockEnd,
//                    selText(),
//                    mActiveSelectionMode);
//    }
//        } else if (!colSelAvail())
//            setActiveSelectionMode(selectionMode());
    BufferCoord vStartOfBlock = blockBegin();
    BufferCoord vEndOfBlock = blockEnd();
    mBlockBegin = vStartOfBlock;
    mBlockEnd = vEndOfBlock;
    qDebug()<<textToLines(text);
    setSelTextPrimitive(splitStrings(text));
    mUndoList->endBlock();
}

void SynEdit::incPaintLock()
{
    if (mPaintLock==0) {
        onBeginFirstPaintLock();
    }
    mPaintLock ++ ;
}

void SynEdit::decPaintLock()
{
    Q_ASSERT(mPaintLock > 0);
    mPaintLock--;
    if (mPaintLock == 0 ) {
        if (mStateFlags.testFlag(SynStateFlag::sfScrollbarChanged)) {
            updateScrollbars();
            ensureCursorPosVisible();
        }
        if (mStateFlags.testFlag(SynStateFlag::sfCaretChanged))
            updateCaret();
        if (mStatusChanges!=0)
            doOnStatusChange(mStatusChanges);
        onEndFirstPaintLock();
    }
}

int SynEdit::clientWidth()
{
    return viewport()->size().width();
}

int SynEdit::clientHeight()
{
    return viewport()->size().height();
}

int SynEdit::clientTop()
{
    return 0;
}

int SynEdit::clientLeft()
{
    return 0;
}

QRect SynEdit::clientRect()
{
    return QRect(0,0, clientWidth(), clientHeight());
}

void SynEdit::synFontChanged()
{
    recalcCharExtent();
    onSizeOrFontChanged(true);
}

void SynEdit::doOnPaintTransient(SynTransientType TransientType)
{
    doOnPaintTransientEx(TransientType, false);
}

void SynEdit::updateLastCaretX()
{
    mLastCaretColumn = displayX();
}

void SynEdit::ensureCursorPosVisible()
{
    ensureCursorPosVisibleEx(false);
}

void SynEdit::ensureCursorPosVisibleEx(bool ForceToMiddle)
{
    incPaintLock();
    auto action = finally([this]{
        decPaintLock();
    });
    // Make sure X is visible
    int VisibleX = displayX();
    if (VisibleX < leftChar())
        setLeftChar(VisibleX);
    else if (VisibleX >= mCharsInWindow + leftChar() && mCharsInWindow > 0)
        setLeftChar(VisibleX - mCharsInWindow + 1);
    else
        setLeftChar(leftChar());
    // Make sure Y is visible
    int vCaretRow = displayY();
    if (ForceToMiddle) {
        if (vCaretRow < mTopLine || vCaretRow>(mTopLine + (mLinesInWindow - 1)))
            setTopLine( vCaretRow - (mLinesInWindow - 1) / 2);
    } else {
        if (vCaretRow < mTopLine)
          setTopLine(vCaretRow);
        else if (vCaretRow > mTopLine + (mLinesInWindow - 1) && mLinesInWindow > 0)
          setTopLine(vCaretRow - (mLinesInWindow - 1));
        else
          setTopLine(mTopLine);
    }
}

void SynEdit::scrollWindow(int dx, int dy)
{
    int nx = horizontalScrollBar()->value()+dx;
    int ny = verticalScrollBar()->value()+dy;
    horizontalScrollBar()->setValue(nx);
    verticalScrollBar()->setValue(ny);
}

void SynEdit::setInternalDisplayXY(const DisplayCoord &aPos)
{
    incPaintLock();
    internalSetCaretXY(displayToBufferPos(aPos));
    decPaintLock();
}

void SynEdit::internalSetCaretXY(const BufferCoord &Value)
{
    setCaretXYEx(true, Value);
}

void SynEdit::internalSetCaretX(int Value)
{
    internalSetCaretXY(BufferCoord{Value, mCaretY});
}

void SynEdit::internalSetCaretY(int Value)
{
    internalSetCaretXY(BufferCoord{mCaretX,Value});
}

void SynEdit::setStatusChanged(SynStatusChanges changes)
{
    mStatusChanges = mStatusChanges | changes;
    if (mPaintLock == 0)
        doOnStatusChange(mStatusChanges);
}

void SynEdit::doOnStatusChange(SynStatusChanges)
{
    if (mStatusChanges.testFlag(SynStatusChange::scCaretX)
            || mStatusChanges.testFlag(SynStatusChange::scCaretY)) {
        qApp->inputMethod()->update(Qt::ImCursorPosition);
    }
    emit statusChanged(mStatusChanges);
    mStatusChanges = SynStatusChange::scNone;
}

void SynEdit::insertBlock(const BufferCoord& startPos, const BufferCoord& endPos, const QStringList& blockText)
{
    setCaretAndSelection(startPos, startPos, startPos);
    setSelTextPrimitiveEx(SynSelectionMode::Column, blockText);
}

void SynEdit::updateScrollbars()
{
    int nMaxScroll;
    int nMin,nMax,nPage,nPos;
    if (mPaintLock!=0) {
        mStateFlags.setFlag(SynStateFlag::sfScrollbarChanged);
    } else {
        mStateFlags.setFlag(SynStateFlag::sfScrollbarChanged,false);
        if (mScrollBars != SynScrollStyle::ssNone) {
            if (mOptions.testFlag(eoHideShowScrollbars)) {
                setHorizontalScrollBarPolicy(Qt::ScrollBarPolicy::ScrollBarAsNeeded);
                setVerticalScrollBarPolicy(Qt::ScrollBarPolicy::ScrollBarAsNeeded);
            } else {
                setHorizontalScrollBarPolicy(Qt::ScrollBarPolicy::ScrollBarAlwaysOn);
                setVerticalScrollBarPolicy(Qt::ScrollBarPolicy::ScrollBarAlwaysOn);
            }
            if (mScrollBars == SynScrollStyle::ssBoth ||  mScrollBars == SynScrollStyle::ssHorizontal) {
                nMaxScroll = maxScrollWidth();
                if (nMaxScroll <= MAX_SCROLL) {
                    nMin = 1;
                    nMax = nMaxScroll;
                    nPage = mCharsInWindow;
                    nPos = mLeftChar;
                } else {
                    nMin = 0;
                    nMax = MAX_SCROLL;
                    nPage = mulDiv(MAX_SCROLL, mCharsInWindow, nMaxScroll);
                    nPos = mulDiv(MAX_SCROLL, mLeftChar, nMaxScroll);
                }
                horizontalScrollBar()->setMinimum(nMin);
                horizontalScrollBar()->setMaximum(nMax);
                horizontalScrollBar()->setPageStep(nPage);
                horizontalScrollBar()->setValue(nPos);
                horizontalScrollBar()->setSingleStep(1);
            } else
                setHorizontalScrollBarPolicy(Qt::ScrollBarPolicy::ScrollBarAlwaysOn);

            if (mScrollBars == SynScrollStyle::ssBoth ||  mScrollBars == SynScrollStyle::ssVertical) {
                nMaxScroll = maxScrollHeight();
                if (nMaxScroll <= MAX_SCROLL) {
                    nMin = 1;
                    nMax = std::max(1, nMaxScroll);
                    nPage = mLinesInWindow;
                    nPos = mTopLine;
                } else {
                    nMin = 0;
                    nMax = MAX_SCROLL;
                    nPage = mulDiv(MAX_SCROLL, mLinesInWindow, nMaxScroll);
                    nPos = mulDiv(MAX_SCROLL, mTopLine, nMaxScroll);
                }
                verticalScrollBar()->setMinimum(nMin);
                verticalScrollBar()->setMaximum(nMax);
                verticalScrollBar()->setPageStep(nPage);
                verticalScrollBar()->setValue(nPos);
                verticalScrollBar()->setSingleStep(1);
            } else
                setVerticalScrollBarPolicy(Qt::ScrollBarPolicy::ScrollBarAlwaysOff);
        } else {
            setHorizontalScrollBarPolicy(Qt::ScrollBarPolicy::ScrollBarAlwaysOff);
            setVerticalScrollBarPolicy(Qt::ScrollBarPolicy::ScrollBarAlwaysOff);
        }
    }
}

void SynEdit::updateCaret()
{
    mStateFlags.setFlag(SynStateFlag::sfCaretChanged,false);
    invalidateRect(calculateCaretRect());
}

void SynEdit::recalcCharExtent()
{
    SynFontStyle styles[] = {SynFontStyle::fsBold, SynFontStyle::fsItalic, SynFontStyle::fsStrikeOut, SynFontStyle::fsUnderline};
    bool hasStyles[] = {false,false,false,false};
    int size = 4;
    if (mHighlighter && mHighlighter->attributes().count()>0) {
        for (const PSynHighlighterAttribute& attribute: mHighlighter->attributes()) {
            for (int i=0;i<size;i++) {
                if (attribute->styles().testFlag(styles[i]))
                    hasStyles[i] = true;
            }
        }
    } else {
        hasStyles[0] = font().bold();
        hasStyles[1] = font().italic();
        hasStyles[2] = font().strikeOut();
        hasStyles[3] = font().underline();
    }

    mTextHeight  = 0;
    mCharWidth = 0;
    QFontMetrics fm(font());
    QFontMetrics fm2(font());
    mTextHeight = std::max(fm.lineSpacing(),fm2.lineSpacing());
    mCharWidth = fm.horizontalAdvance("M");

    if (hasStyles[0]) { // has bold font
        QFont f = font();
        f.setBold(true);
        QFontMetrics fm(f);
        QFont f2 = font();
        f2.setBold(true);
        QFontMetrics fm2(f);
        if (fm.lineSpacing()>mTextHeight)
            mTextHeight=fm.lineSpacing();
        if (fm2.lineSpacing()>mTextHeight)
            mTextHeight=fm2.lineSpacing();
        if (fm.horizontalAdvance("M")>mCharWidth)
            mCharWidth = fm.horizontalAdvance("M");
    }
    if (hasStyles[1]) { // has strike out font
        QFont f = font();
        f.setItalic(true);
        QFontMetrics fm(f);
        QFont f2 = font();
        f2.setItalic(true);
        QFontMetrics fm2(f);
        if (fm.lineSpacing()>mTextHeight)
            mTextHeight=fm.lineSpacing();
        if (fm2.lineSpacing()>mTextHeight)
            mTextHeight=fm2.lineSpacing();
        if (fm.horizontalAdvance("M")>mCharWidth)
            mCharWidth = fm.horizontalAdvance("M");
    }
    if (hasStyles[2]) { // has strikeout
        QFont f = font();
        f.setStrikeOut(true);
        QFontMetrics fm(f);
        QFont f2 = font();
        f2.setStrikeOut(true);
        QFontMetrics fm2(f);
        if (fm.lineSpacing()>mTextHeight)
            mTextHeight=fm.lineSpacing();
        if (fm2.lineSpacing()>mTextHeight)
            mTextHeight=fm2.lineSpacing();
        if (fm.horizontalAdvance("M")>mCharWidth)
            mCharWidth = fm.horizontalAdvance("M");
    }
    if (hasStyles[3]) { // has underline
        QFont f = font();
        f.setUnderline(true);
        QFontMetrics fm(f);
        QFont f2 = font();
        f2.setUnderline(true);
        QFontMetrics fm2(f);
        if (fm.lineSpacing()>mTextHeight)
            mTextHeight=fm.lineSpacing();
        if (fm2.lineSpacing()>mTextHeight)
            mTextHeight=fm2.lineSpacing();
        if (fm.horizontalAdvance("M")>mCharWidth)
            mCharWidth = fm.horizontalAdvance("M");
    }
    mTextHeight += mExtraLineSpacing;
}

QString SynEdit::expandAtWideGlyphs(const QString &S)
{
    QString Result(S.length()*2); // speed improvement
    int  j = 0;
    for (int i=0;i<S.length();i++) {
        int CountOfAvgGlyphs = ceil(fontMetrics().horizontalAdvance(S[i])/(double)mCharWidth);
        if (j+CountOfAvgGlyphs>=Result.length())
            Result.resize(Result.length()+128);
        // insert CountOfAvgGlyphs filling chars
        while (CountOfAvgGlyphs>1) {
            Result[j]=QChar(0xE000);
            j++;
            CountOfAvgGlyphs--;
        }
        Result[j]=S[i];
        j++;
    }
    Result.resize(j);
    return Result;
}

void SynEdit::updateModifiedStatus()
{
    setModified(!mUndoList->initialState());
}

int SynEdit::scanFrom(int Index, int canStopIndex)
{
    SynRangeState iRange;
    int Result = std::max(0,Index);
    if (Result >= mDocument->count())
        return Result;

    if (Result == 0) {
        mHighlighter->resetState();
    } else {
        mHighlighter->setState(mDocument->ranges(Result-1));
    }
    do {
        mHighlighter->setLine(mDocument->getString(Result), Result);
        mHighlighter->nextToEol();
        iRange = mHighlighter->getRangeState();
        if (Result > canStopIndex){
            if (mDocument->ranges(Result).state == iRange.state
                    && mDocument->ranges(Result).braceLevel == iRange.braceLevel
                    && mDocument->ranges(Result).parenthesisLevel == iRange.parenthesisLevel
                    && mDocument->ranges(Result).bracketLevel == iRange.bracketLevel
                    ) {
                if (mUseCodeFolding)
                    rescanFolds();
                return Result;// avoid the final Decrement
            }
        }
        mDocument->setRange(Result,iRange);
        Result ++ ;
    } while (Result < mDocument->count());
    Result--;
    if (mUseCodeFolding)
        rescanFolds();
    return Result;
}

void SynEdit::rescanRange(int line)
{
    if (!mHighlighter)
        return;
    line--;
    line = std::max(0,line);
    if (line >= mDocument->count())
        return;

    if (line == 0) {
        mHighlighter->resetState();
    } else {
        mHighlighter->setState(mDocument->ranges(line-1));
    }
    mHighlighter->setLine(mDocument->getString(line), line);
    mHighlighter->nextToEol();
    SynRangeState iRange = mHighlighter->getRangeState();
    mDocument->setRange(line,iRange);
}

void SynEdit::rescanRanges()
{
    if (mHighlighter && !mDocument->empty()) {
        mHighlighter->resetState();
        for (int i =0;i<mDocument->count();i++) {
            mHighlighter->setLine(mDocument->getString(i), i);
            mHighlighter->nextToEol();
            mDocument->setRange(i, mHighlighter->getRangeState());
        }
    }
    if (mUseCodeFolding)
        rescanFolds();
}

void SynEdit::uncollapse(PSynEditFoldRange FoldRange)
{
    FoldRange->linesCollapsed = 0;
    FoldRange->collapsed = false;

    // Redraw the collapsed line
    invalidateLines(FoldRange->fromLine, INT_MAX);

    // Redraw fold mark
    invalidateGutterLines(FoldRange->fromLine, INT_MAX);
    updateScrollbars();
}

void SynEdit::collapse(PSynEditFoldRange FoldRange)
{
    FoldRange->linesCollapsed = FoldRange->toLine - FoldRange->fromLine;
    FoldRange->collapsed = true;

    // Extract caret from fold
    if ((mCaretY > FoldRange->fromLine) && (mCaretY <= FoldRange->toLine)) {
          setCaretXY(BufferCoord{mDocument->getString(FoldRange->fromLine - 1).length() + 1,
                                 FoldRange->fromLine});
    }

    // Redraw the collapsed line
    invalidateLines(FoldRange->fromLine, INT_MAX);

    // Redraw fold mark
    invalidateGutterLines(FoldRange->fromLine, INT_MAX);

    updateScrollbars();
}

void SynEdit::foldOnListInserted(int Line, int Count)
{
    // Delete collapsed inside selection
    for (int i = mAllFoldRanges.count()-1;i>=0;i--) {
        PSynEditFoldRange range = mAllFoldRanges[i];
        if (range->fromLine == Line - 1) {// insertion starts at fold line
            if (range->collapsed)
                uncollapse(range);
        } else if (range->fromLine >= Line) // insertion of count lines above FromLine
            range->move(Count);
    }
}

void SynEdit::foldOnListDeleted(int Line, int Count)
{
    // Delete collapsed inside selection
    for (int i = mAllFoldRanges.count()-1;i>=0;i--) {
        PSynEditFoldRange range = mAllFoldRanges[i];
        if (range->fromLine == Line && Count == 1)  {// open up because we are messing with the starting line
            if (range->collapsed)
                uncollapse(range);
        } else if (range->fromLine >= Line - 1 && range->fromLine < Line + Count) // delete inside affectec area
            mAllFoldRanges.remove(i);
        else if (range->fromLine >= Line + Count) // Move after affected area
            range->move(-Count);

    }

}

void SynEdit::foldOnListCleared()
{
    mAllFoldRanges.clear();
}

void SynEdit::rescanFolds()
{
    if (!mUseCodeFolding)
        return;
    rescanForFoldRanges();
    invalidateGutter();
}

static void null_deleter(SynEditFoldRanges *) {}

void SynEdit::rescanForFoldRanges()
{
    // Delete all uncollapsed folds
//    for (int i=mAllFoldRanges.count()-1;i>=0;i--) {
//        PSynEditFoldRange range =mAllFoldRanges[i];
//        if (!range->collapsed && !range->parentCollapsed())
//            mAllFoldRanges.remove(i);
//    }

    // Did we leave any collapsed folds and are we viewing a code file?
    if (mAllFoldRanges.count() > 0) {
        SynEditFoldRanges ranges=mAllFoldRanges;
        mAllFoldRanges.clear();
        // Add folds to a separate list
        PSynEditFoldRanges TemporaryAllFoldRanges = std::make_shared<SynEditFoldRanges>();
        scanForFoldRanges(TemporaryAllFoldRanges);

        // Combine new with old folds, preserve parent order
        for (int i = 0; i< TemporaryAllFoldRanges->count();i++) {
            PSynEditFoldRange tempFoldRange=TemporaryAllFoldRanges->range(i);
            int j=0;
            while (j <ranges.count()) {
                PSynEditFoldRange foldRange = ranges[j];
                //qDebug()<<TemporaryAllFoldRanges->range(i)->fromLine<<ranges[j]->fromLine;
                if (tempFoldRange->fromLine == foldRange->fromLine
                        && tempFoldRange->toLine == foldRange->toLine) {
                    //qDebug()<<"-"<<foldRange->fromLine;
                    mAllFoldRanges.add(foldRange);
                    break;
                }
                j++;
            }
            if (j>=ranges.count()) {
                //qDebug()<<"--"<<tempFoldRange->fromLine;
                mAllFoldRanges.add(tempFoldRange);
            }
        }

    } else {

        // We ended up with no folds after deleting, just pass standard data...
        PSynEditFoldRanges temp(&mAllFoldRanges, null_deleter);
        scanForFoldRanges(temp);
    }
}

void SynEdit::scanForFoldRanges(PSynEditFoldRanges TopFoldRanges)
{
    PSynEditFoldRanges parentFoldRanges = TopFoldRanges;
    // Recursively scan for folds (all types)
    for (int i= 0 ; i< mCodeFolding.foldRegions.count() ; i++ ) {
        findSubFoldRange(TopFoldRanges, i,parentFoldRanges,PSynEditFoldRange());
    }
}

//this func should only be used in findSubFoldRange
int SynEdit::lineHasChar(int Line, int startChar, QChar character, const QString& highlighterAttrName) {
    QString CurLine = mDocument->getString(Line);
    if (!mHighlighter){
        for (int i=startChar; i<CurLine.length();i++) {
            if (CurLine[i]==character) {
                return i;
            }
        }

    } else {
        /*
        mHighlighter->setState(mLines->ranges(Line),
                               mLines->braceLevels(Line),
                               mLines->bracketLevels(Line),
                               mLines->parenthesisLevels(Line));
        mHighlighter->setLine(CurLine,Line);
        */
        QString token;
        while (!mHighlighter->eol()) {
            token = mHighlighter->getToken();
            PSynHighlighterAttribute attr = mHighlighter->getTokenAttribute();
            if (token == character && attr->name()==highlighterAttrName)
                return mHighlighter->getTokenPos();
            mHighlighter->next();
        }
    }
    return -1;
}

void SynEdit::findSubFoldRange(PSynEditFoldRanges TopFoldRanges, int FoldIndex,PSynEditFoldRanges& parentFoldRanges, PSynEditFoldRange Parent)
{
    PSynEditFoldRange  CollapsedFold;
    int Line = 0;
    QString CurLine;
    if (!mHighlighter)
        return;
    bool useBraces = ( mCodeFolding.foldRegions.get(FoldIndex)->openSymbol == "{"
            && mCodeFolding.foldRegions.get(FoldIndex)->closeSymbol == "}");

    while (Line < mDocument->count()) { // index is valid for LinesToScan and fLines
        // If there is a collapsed fold over here, skip it
        CollapsedFold = collapsedFoldStartAtLine(Line + 1); // only collapsed folds remain
        if (CollapsedFold) {
          Line = CollapsedFold->toLine;
          continue;
        }

        //we just use braceLevel
        if (useBraces) {
            // Find an opening character on this line
            CurLine = mDocument->getString(Line);
            if (mDocument->rightBraces(Line)>0) {
                for (int i=0; i<mDocument->rightBraces(Line);i++) {
                    // Stop the recursion if we find a closing char, and return to our parent
                    if (Parent) {
                      Parent->toLine = Line + 1;
                      Parent = Parent->parent;
                      if (!Parent) {
                          parentFoldRanges = TopFoldRanges;
                      } else {
                          parentFoldRanges = Parent->subFoldRanges;
                      }
                    }
                }
            }
            if (mDocument->leftBraces(Line)>0) {
                for (int i=0; i<mDocument->leftBraces(Line);i++) {
                    // Add it to the top list of folds
                    Parent = parentFoldRanges->addByParts(
                      Parent,
                      TopFoldRanges,
                      Line + 1,
                      mCodeFolding.foldRegions.get(FoldIndex),
                      Line + 1);
                    parentFoldRanges = Parent->subFoldRanges;
                }
            }
        } else {

            // Find an opening character on this line
            CurLine = mDocument->getString(Line);

            mHighlighter->setState(mDocument->ranges(Line));
            mHighlighter->setLine(CurLine,Line);

            QString token;
            int pos;
            while (!mHighlighter->eol()) {
                token = mHighlighter->getToken();
                pos = mHighlighter->getTokenPos()+token.length();
                PSynHighlighterAttribute attr = mHighlighter->getTokenAttribute();
                // We've found a starting character and it have proper highlighting (ignore stuff inside comments...)
                if (token == mCodeFolding.foldRegions.get(FoldIndex)->openSymbol && attr->name()==mCodeFolding.foldRegions.get(FoldIndex)->highlight) {
                    // And ignore lines with both opening and closing chars in them
                    if (lineHasChar(Line,pos,mCodeFolding.foldRegions.get(FoldIndex)->closeSymbol,
                                    mCodeFolding.foldRegions.get(FoldIndex)->highlight)<0) {
                        // Add it to the top list of folds
                        Parent = parentFoldRanges->addByParts(
                          Parent,
                          TopFoldRanges,
                          Line + 1,
                          mCodeFolding.foldRegions.get(FoldIndex),
                          Line + 1);
                        parentFoldRanges = Parent->subFoldRanges;

                        // Skip until a newline
                        break;
                    }

                } else if (token == mCodeFolding.foldRegions.get(FoldIndex)->closeSymbol && attr->name()==mCodeFolding.foldRegions.get(FoldIndex)->highlight) {
                    // And ignore lines with both opening and closing chars in them
                    if (lineHasChar(Line,pos,mCodeFolding.foldRegions.get(FoldIndex)->openSymbol,
                                    mCodeFolding.foldRegions.get(FoldIndex)->highlight)<0) {
                        // Stop the recursion if we find a closing char, and return to our parent
                        if (Parent) {
                          Parent->toLine = Line + 1;
                          Parent = Parent->parent;
                          if (!Parent) {
                              parentFoldRanges = TopFoldRanges;
                          } else {
                              parentFoldRanges = Parent->subFoldRanges;
                          }
                        }

                        // Skip until a newline
                        break;
                    }
                }
                mHighlighter->next();
            }
        }
        Line++;
    }
}

PSynEditFoldRange SynEdit::collapsedFoldStartAtLine(int Line)
{
    for (int i = 0; i< mAllFoldRanges.count() - 1; i++ ) {
        if (mAllFoldRanges[i]->fromLine == Line && mAllFoldRanges[i]->collapsed) {
            return mAllFoldRanges[i];
        } else if (mAllFoldRanges[i]->fromLine > Line) {
            break; // sorted by line. don't bother scanning further
        }
    }
    return PSynEditFoldRange();
}

void SynEdit::doOnPaintTransientEx(SynTransientType , bool )
{
    //todo: we can't draw to canvas outside paintEvent
}

void SynEdit::initializeCaret()
{
    //showCaret();
}

PSynEditFoldRange SynEdit::foldStartAtLine(int Line) const
{
    for (int i = 0; i<mAllFoldRanges.count();i++) {
        PSynEditFoldRange range = mAllFoldRanges[i];
        if (range->fromLine == Line ){
            return range;
        } else if (range->fromLine>Line)
            break; // sorted by line. don't bother scanning further
    }
    return PSynEditFoldRange();
}

bool SynEdit::foldCollapsedBetween(int startLine, int endLine) const
{
    for (int i = 0; i<mAllFoldRanges.count();i++) {
        PSynEditFoldRange range = mAllFoldRanges[i];
        if (startLine >=range->fromLine && range->fromLine<=endLine
                && (range->collapsed || range->parentCollapsed())){
            return true;
        } else if (range->fromLine>endLine)
            break; // sorted by line. don't bother scanning further
    }
    return false;
}

QString SynEdit::substringByColumns(const QString &s, int startColumn, int &colLen)
{

    int len = s.length();
    int columns = 0;
    int i = 0;
    int oldColumns=0;
    while (columns < startColumn) {
        oldColumns = columns;
        if (i>=len)
            break;
        if (s[i] == '\t')
            columns += tabWidth() - (columns % tabWidth());
        else
            columns += charColumns(s[i]);
        i++;
    }
    QString result;
    if (i>=len) {
        colLen = 0;
        return result;
    }
    if (colLen>result.capacity()) {
        result.resize(colLen);
    }
    int j=0;
    if (i>0) {
        result[0]=s[i-1];
        j++;
    }
    while (i<len && columns<startColumn+colLen) {
        result[j]=s[i];
        if (i < len && s[i] == '\t')
            columns += tabWidth() - (columns % tabWidth());
        else
            columns += charColumns(s[i]);
        i++;
        j++;
    }
    result.resize(j);
    colLen = columns-oldColumns;
    return result;
}

PSynEditFoldRange SynEdit::foldAroundLine(int Line)
{
    return foldAroundLineEx(Line,false,false,false);
}

PSynEditFoldRange SynEdit::foldAroundLineEx(int Line, bool WantCollapsed, bool AcceptFromLine, bool AcceptToLine)
{
    // Check global list
    PSynEditFoldRange Result = checkFoldRange(&mAllFoldRanges, Line, WantCollapsed, AcceptFromLine, AcceptToLine);

    // Found an item in the top level list?
    if (Result) {
        while (true) {
            PSynEditFoldRange ResultChild = checkFoldRange(Result->subFoldRanges.get(), Line, WantCollapsed, AcceptFromLine, AcceptToLine);
            if (!ResultChild)
                break;
            Result = ResultChild; // repeat for this one
        }
    }
    return Result;
}

PSynEditFoldRange SynEdit::checkFoldRange(SynEditFoldRanges *FoldRangeToCheck, int Line, bool WantCollapsed, bool AcceptFromLine, bool AcceptToLine)
{
    for (int i = 0; i< FoldRangeToCheck->count(); i++) {
        PSynEditFoldRange range = (*FoldRangeToCheck)[i];
        if (((range->fromLine < Line) || ((range->fromLine <= Line) && AcceptFromLine)) &&
          ((range->toLine > Line) || ((range->toLine >= Line) && AcceptToLine))) {
            if (range->collapsed == WantCollapsed) {
                return range;
            }
        }
    }
    return PSynEditFoldRange();
}

PSynEditFoldRange SynEdit::foldEndAtLine(int Line)
{
    for (int i = 0; i<mAllFoldRanges.count();i++) {
        PSynEditFoldRange range = mAllFoldRanges[i];
        if (range->toLine == Line ){
            return range;
        } else if (range->fromLine>Line)
            break; // sorted by line. don't bother scanning further
    }
    return PSynEditFoldRange();
}

void SynEdit::paintCaret(QPainter &painter, const QRect rcClip)
{
    if (m_blinkStatus!=1)
        return;
    painter.setClipRect(rcClip);
    SynEditCaretType ct;
    if (this->mInserting) {
        ct = mInsertCaret;
    } else {
        ct =mOverwriteCaret;
    }
    QColor caretColor;
    if (mCaretUseTextColor) {
        caretColor = mForegroundColor;
    } else {
        caretColor = mCaretColor;
    }
    switch(ct) {
    case SynEditCaretType::ctVerticalLine: {
        QRect caretRC;
        int size = std::max(1, mTextHeight/15);
        caretRC.setLeft(rcClip.left()+1);
        caretRC.setTop(rcClip.top());
        caretRC.setBottom(rcClip.bottom());
        caretRC.setRight(rcClip.left()+1+size);
        painter.fillRect(caretRC,caretColor);
        break;
    }
    case SynEditCaretType::ctHorizontalLine: {
        QRect caretRC;
        int size = std::max(1,mTextHeight/15);
        caretRC.setLeft(rcClip.left());
        caretRC.setTop(rcClip.bottom()-1+size);
        caretRC.setBottom(rcClip.bottom()-1);
        caretRC.setRight(rcClip.right());
        painter.fillRect(caretRC,caretColor);
        break;
    }
    case SynEditCaretType::ctBlock:
        painter.fillRect(rcClip, caretColor);
        break;
    case SynEditCaretType::ctHalfBlock:
        QRect rc=rcClip;
        rc.setTop(rcClip.top()+rcClip.height() / 2);
        painter.fillRect(rcClip, caretColor);
        break;
    }
}

int SynEdit::textOffset() const
{
    return mGutterWidth + 2 - (mLeftChar-1)*mCharWidth;
}

SynEditorCommand SynEdit::TranslateKeyCode(int key, Qt::KeyboardModifiers modifiers)
{
    PSynEditKeyStroke keyStroke = mKeyStrokes.findKeycode2(mLastKey,mLastKeyModifiers,
                                                           key, modifiers);
    SynEditorCommand cmd=SynEditorCommand::ecNone;
    if (keyStroke)
        cmd = keyStroke->command();
    else {
        keyStroke = mKeyStrokes.findKeycode(key,modifiers);
        if (keyStroke)
            cmd = keyStroke->command();
    }
    if (cmd == SynEditorCommand::ecNone) {
        mLastKey = key;
        mLastKeyModifiers = modifiers;
    } else {
        mLastKey = 0;
        mLastKeyModifiers = Qt::NoModifier;
    }
    return cmd;
}

void SynEdit::onSizeOrFontChanged(bool bFont)
{

    if (mCharWidth != 0) {
        mCharsInWindow = std::max(clientWidth() - mGutterWidth - 2, 0) / mCharWidth;
        mLinesInWindow = clientHeight() / mTextHeight;
        bool scrollBarChangedSettings = mStateFlags.testFlag(SynStateFlag::sfScrollbarChanged);
        if (bFont) {
            if (mGutter.showLineNumbers())
                onGutterChanged();
            else
                updateScrollbars();
            mStateFlags.setFlag(SynStateFlag::sfCaretChanged,false);
            invalidate();
        } else
            updateScrollbars();
        mStateFlags.setFlag(SynStateFlag::sfScrollbarChanged,scrollBarChangedSettings);
        //if (!mOptions.testFlag(SynEditorOption::eoScrollPastEol))
        setLeftChar(mLeftChar);
        //if (!mOptions.testFlag(SynEditorOption::eoScrollPastEof))
        setTopLine(mTopLine);
    }
}

void SynEdit::onChanged()
{
    emit changed();
}

void SynEdit::onScrolled(int)
{
    mLeftChar = horizontalScrollBar()->value();
    mTopLine = verticalScrollBar()->value();
    invalidate();
}

int SynEdit::mouseSelectionScrollSpeed() const
{
    return mMouseSelectionScrollSpeed;
}

void SynEdit::setMouseSelectionScrollSpeed(int newMouseSelectionScrollSpeed)
{
    mMouseSelectionScrollSpeed = newMouseSelectionScrollSpeed;
}

const QFont &SynEdit::fontForNonAscii() const
{
    return mFontForNonAscii;
}

void SynEdit::setFontForNonAscii(const QFont &newFontForNonAscii)
{
    mFontForNonAscii = newFontForNonAscii;
    mFontForNonAscii.setStyleStrategy(QFont::PreferAntialias);
}

const QColor &SynEdit::backgroundColor() const
{
    return mBackgroundColor;
}

void SynEdit::setBackgroundColor(const QColor &newBackgroundColor)
{
    mBackgroundColor = newBackgroundColor;
}

const QColor &SynEdit::foregroundColor() const
{
    return mForegroundColor;
}

void SynEdit::setForegroundColor(const QColor &newForegroundColor)
{
    mForegroundColor = newForegroundColor;
}

int SynEdit::mouseWheelScrollSpeed() const
{
    return mMouseWheelScrollSpeed;
}

void SynEdit::setMouseWheelScrollSpeed(int newMouseWheelScrollSpeed)
{
    mMouseWheelScrollSpeed = newMouseWheelScrollSpeed;
}

const PSynHighlighterAttribute &SynEdit::rainbowAttr3() const
{
    return mRainbowAttr3;
}

const PSynHighlighterAttribute &SynEdit::rainbowAttr2() const
{
    return mRainbowAttr2;
}

const PSynHighlighterAttribute &SynEdit::rainbowAttr1() const
{
    return mRainbowAttr1;
}

const PSynHighlighterAttribute &SynEdit::rainbowAttr0() const
{
    return mRainbowAttr0;
}

bool SynEdit::caretUseTextColor() const
{
    return mCaretUseTextColor;
}

void SynEdit::setCaretUseTextColor(bool newCaretUseTextColor)
{
    mCaretUseTextColor = newCaretUseTextColor;
}

const QColor &SynEdit::rightEdgeColor() const
{
    return mRightEdgeColor;
}

void SynEdit::setRightEdgeColor(const QColor &newRightEdgeColor)
{
    if (newRightEdgeColor!=mRightEdgeColor) {
        mRightEdgeColor = newRightEdgeColor;
    }
}

int SynEdit::rightEdge() const
{
    return mRightEdge;
}

void SynEdit::setRightEdge(int newRightEdge)
{
    if (mRightEdge != newRightEdge) {
        mRightEdge = newRightEdge;
        invalidate();
    }
}

const QColor &SynEdit::selectedBackground() const
{
    return mSelectedBackground;
}

void SynEdit::setSelectedBackground(const QColor &newSelectedBackground)
{
    mSelectedBackground = newSelectedBackground;
}

const QColor &SynEdit::selectedForeground() const
{
    return mSelectedForeground;
}

void SynEdit::setSelectedForeground(const QColor &newSelectedForeground)
{
    mSelectedForeground = newSelectedForeground;
}

int SynEdit::textHeight() const
{
    return mTextHeight;
}

bool SynEdit::readOnly() const
{
    return mReadOnly;
}

void SynEdit::setReadOnly(bool readOnly)
{
    if (mReadOnly != readOnly) {
        mReadOnly = readOnly;
        emit statusChanged(scReadOnly);
    }
}

SynGutter& SynEdit::gutter()
{
    return mGutter;
}

SynEditCaretType SynEdit::insertCaret() const
{
    return mInsertCaret;
}

void SynEdit::setInsertCaret(const SynEditCaretType &insertCaret)
{
    mInsertCaret = insertCaret;
}

SynEditCaretType SynEdit::overwriteCaret() const
{
    return mOverwriteCaret;
}

void SynEdit::setOverwriteCaret(const SynEditCaretType &overwriteCaret)
{
    mOverwriteCaret = overwriteCaret;
}

QColor SynEdit::activeLineColor() const
{
    return mActiveLineColor;
}

void SynEdit::setActiveLineColor(const QColor &activeLineColor)
{
    if (mActiveLineColor!=activeLineColor) {
        mActiveLineColor = activeLineColor;
        invalidateLine(mCaretY);
    }
}

QColor SynEdit::caretColor() const
{
    return mCaretColor;
}

void SynEdit::setCaretColor(const QColor &caretColor)
{
    mCaretColor = caretColor;
}

void SynEdit::setTabWidth(int newTabWidth)
{
    if (newTabWidth!=tabWidth()) {
        mDocument->setTabWidth(newTabWidth);
        invalidate();
    }
}

SynEditorOptions SynEdit::getOptions() const
{
    return mOptions;
}

void SynEdit::setOptions(const SynEditorOptions &Value)
{
    if (Value != mOptions) {
        //bool bSetDrag = mOptions.testFlag(eoDropFiles) != Value.testFlag(eoDropFiles);
        //if  (!mOptions.testFlag(eoScrollPastEol))
        setLeftChar(mLeftChar);
        //if (!mOptions.testFlag(eoScrollPastEof))
        setTopLine(mTopLine);

        bool bUpdateAll = Value.testFlag(eoShowSpecialChars) != mOptions.testFlag(eoShowSpecialChars);
        if (!bUpdateAll)
            bUpdateAll = Value.testFlag(eoShowRainbowColor) != mOptions.testFlag(eoShowRainbowColor);
        //bool bUpdateScroll = (Options * ScrollOptions)<>(Value * ScrollOptions);
        bool bUpdateScroll = true;
        mOptions = Value;

        // constrain caret position to MaxScrollWidth if eoScrollPastEol is enabled
        internalSetCaretXY(caretXY());
        if (mOptions.testFlag(eoScrollPastEol)) {
            BufferCoord vTempBlockBegin = blockBegin();
            BufferCoord vTempBlockEnd = blockEnd();
            setBlockBegin(vTempBlockBegin);
            setBlockEnd(vTempBlockEnd);
        }
        updateScrollbars();
      // (un)register HWND as drop target
//      if bSetDrag and not (csDesigning in ComponentState) and HandleAllocated then
//        DragAcceptFiles(Handle, (eoDropFiles in fOptions));
        if (bUpdateAll)
            invalidate();
        if (bUpdateScroll)
            updateScrollbars();
    }
}

void SynEdit::doAddStr(const QString &s)
{
    if (mInserting == false && !selAvail()) {
        switch(mActiveSelectionMode) {
        case SynSelectionMode::Column: {
            //we can't use blockBegin()/blockEnd()
            BufferCoord start=blockBegin();
            BufferCoord end=blockEnd();
            if (start.line > end.line )
                std::swap(start,end);
            start.ch+=s.length(); // make sure we select a whole char in the start line
            setBlockBegin(start);
            setBlockEnd(end);
        }
            break;
        case SynSelectionMode::Line:
            //do nothing;
            break;
        default:
            setSelLength(s.length());
        }
    }
    doSetSelText(s);
}

void SynEdit::doUndo()
{
    if (mReadOnly)
        return;

    //Remove Group Break;
    if (mUndoList->lastChangeReason() ==  SynChangeReason::GroupBreak) {
        int OldBlockNumber = mRedoList->blockChangeNumber();
        auto action = finally([&,this]{
           mRedoList->setBlockChangeNumber(OldBlockNumber);
        });
        PSynEditUndoItem item = mUndoList->popItem();
        mRedoList->setBlockChangeNumber(item->changeNumber());
        mRedoList->addGroupBreak();
    }

    PSynEditUndoItem item = mUndoList->peekItem();
    if (item) {
        int oldChangeNumber = item->changeNumber();
        int saveChangeNumber = mRedoList->blockChangeNumber();
        mRedoList->setBlockChangeNumber(item->changeNumber());
        {
            auto action = finally([&,this] {
               mRedoList->setBlockChangeNumber(saveChangeNumber);
            });
            //skip group chain breakers
            if (mUndoList->lastChangeReason()==SynChangeReason::GroupBreak) {
                while (!mUndoList->isEmpty() && mUndoList->lastChangeReason()==SynChangeReason::GroupBreak) {
                    doUndoItem();
                }
            }
            SynChangeReason  lastChange = mUndoList->lastChangeReason();
            bool keepGoing;
            do {
                doUndoItem();
                item = mUndoList->peekItem();
                if (!item)
                    keepGoing = false;
                else {
                    if (item->changeNumber() == oldChangeNumber)
                        keepGoing = true;
                    else {
                        keepGoing = (mOptions.testFlag(eoGroupUndo) &&
                            (lastChange == item->changeReason()) );
                    }
                    oldChangeNumber=item->changeNumber();
                    lastChange = item->changeReason();
                }
            } while (keepGoing);
        }
    }
}

void SynEdit::doUndoItem()
{
    mUndoing = true;
    bool ChangeScrollPastEol = ! mOptions.testFlag(eoScrollPastEol);

    PSynEditUndoItem item = mUndoList->popItem();
    if (item) {
        setActiveSelectionMode(item->changeSelMode());
        incPaintLock();
        auto action = finally([&,this]{
            mUndoing = false;
            if (ChangeScrollPastEol)
                mOptions.setFlag(eoScrollPastEol,false);
            decPaintLock();
        });
        mOptions.setFlag(eoScrollPastEol);
        switch(item->changeReason()) {
        case SynChangeReason::Caret:
            mRedoList->addChange(
                        item->changeReason(),
                        caretXY(),
                        caretXY(), QStringList(),
                        item->changeSelMode());
            internalSetCaretXY(item->changeStartPos());
            break;
        case SynChangeReason::LeftTop:
            BufferCoord p;
            p.ch = leftChar();
            p.line = topLine();
            mRedoList->addChange(
                        item->changeReason(),
                        p,
                        p, QStringList(),
                        item->changeSelMode());
            setLeftChar(item->changeStartPos().ch);
            setTopLine(item->changeStartPos().line);
            break;
        case SynChangeReason::Selection:
            mRedoList->addChange(
                        item->changeReason(),
                        mBlockBegin,
                        mBlockEnd,
                        QStringList(),
                        item->changeSelMode());
            setCaretAndSelection(caretXY(), item->changeStartPos(), item->changeEndPos());
            break;
        case SynChangeReason::Insert: {
            QStringList tmpText = getContent(item->changeStartPos(),item->changeEndPos(),item->changeSelMode());
            doDeleteText(item->changeStartPos(),item->changeEndPos(),item->changeSelMode());
            mRedoList->addChange(
                        item->changeReason(),
                        item->changeStartPos(),
                        item->changeEndPos(),
                        tmpText,
                        item->changeSelMode());
            internalSetCaretXY(item->changeStartPos());
            break;
        }
        case SynChangeReason::MoveSelectionUp:
            setBlockBegin(BufferCoord{item->changeStartPos().ch, item->changeStartPos().line-1});
            setBlockEnd(BufferCoord{item->changeEndPos().ch, item->changeEndPos().line-1});
            doMoveSelDown();
            mRedoList->addChange(
                        item->changeReason(),
                        item->changeStartPos(),
                        item->changeEndPos(),
                        item->changeText(),
                        item->changeSelMode());
            break;
        case SynChangeReason::MoveSelectionDown:
            setBlockBegin(BufferCoord{item->changeStartPos().ch, item->changeStartPos().line+1});
            setBlockEnd(BufferCoord{item->changeEndPos().ch, item->changeEndPos().line+1});
            doMoveSelUp();
            mRedoList->addChange(
                        item->changeReason(),
                        item->changeStartPos(),
                        item->changeEndPos(),
                        item->changeText(),
                        item->changeSelMode());
            break;
        case SynChangeReason::Delete: {
            // If there's no selection, we have to set
            // the Caret's position manualy.
//            qDebug()<<"undo delete";
//            qDebug()<<Item->changeText();
//            qDebug()<<Item->changeStartPos().Line<<Item->changeStartPos().Char;
            doInsertText(item->changeStartPos(),item->changeText(),item->changeSelMode(),
                         item->changeStartPos().line,
                         item->changeEndPos().line);
            internalSetCaretXY(item->changeEndPos());
            mRedoList->addChange(
                        item->changeReason(),
                        item->changeStartPos(),
                        item->changeEndPos(),
                        item->changeText(),
                        item->changeSelMode());
            ensureCursorPosVisible();
            break;
        }
        case SynChangeReason::LineBreak:{
            QString s;
            if (!item->changeText().isEmpty()) {
                s=item->changeText()[0];
            }
            // If there's no selection, we have to set
            // the Caret's position manualy.
            internalSetCaretXY(item->changeStartPos());
            if (mCaretY > 0) {
                QString TmpStr = mDocument->getString(mCaretY - 1);
                if ( (mCaretX > TmpStr.length() + 1) && (leftSpaces(s) == 0))
                    TmpStr = TmpStr + QString(mCaretX - 1 - TmpStr.length(), ' ');
                properSetLine(mCaretY - 1, TmpStr + s);
                mDocument->deleteAt(mCaretY);
                doLinesDeleted(mCaretY, 1);
            }
            mRedoList->addChange(
                        item->changeReason(),
                        item->changeStartPos(),
                        item->changeEndPos(),
                        item->changeText(),
                        item->changeSelMode());
            break;
        }
        default:
            break;
        }
    }
}

void SynEdit::doRedo()
{
    if (mReadOnly)
        return;

    PSynEditUndoItem item = mRedoList->peekItem();
    if (!item)
        return;
    int oldChangeNumber = item->changeNumber();
    int saveChangeNumber = mUndoList->blockChangeNumber();
    mUndoList->setBlockChangeNumber(item->changeNumber());
    {
        auto action = finally([&,this]{
            mUndoList->setBlockChangeNumber(saveChangeNumber);
        });
        //skip group chain breakers
        if (mRedoList->lastChangeReason()==SynChangeReason::GroupBreak) {
            while (!mRedoList->isEmpty() && mRedoList->lastChangeReason()==SynChangeReason::GroupBreak) {
                doRedoItem();
            }
        }
        SynChangeReason lastChange = mRedoList->lastChangeReason();
        bool keepGoing;
        do {
          doRedoItem();
          item = mRedoList->peekItem();
          if (!item)
              keepGoing = false;
          else {
            if (item->changeNumber() == oldChangeNumber)
                keepGoing = true;
            else {
                keepGoing = (mOptions.testFlag(eoGroupUndo) &&
                (lastChange == item->changeReason()));
            }
            oldChangeNumber=item->changeNumber();
            lastChange = item->changeReason();
          }
        } while (keepGoing);

    }
    //Remove Group Break
    if (mRedoList->lastChangeReason() == SynChangeReason::GroupBreak) {
        int OldBlockNumber = mUndoList->blockChangeNumber();
        item = mRedoList->popItem();
        {
            auto action2=finally([&,this]{
                mUndoList->setBlockChangeNumber(OldBlockNumber);
            });
            mUndoList->setBlockChangeNumber(item->changeNumber());
            mUndoList->addGroupBreak();
        }
        updateModifiedStatus();
    }
}

void SynEdit::doRedoItem()
{
    mUndoing = true;
    bool ChangeScrollPastEol = ! mOptions.testFlag(eoScrollPastEol);
    PSynEditUndoItem item = mRedoList->popItem();
    if (item) {
        setActiveSelectionMode(item->changeSelMode());
        incPaintLock();
        mOptions.setFlag(eoScrollPastEol);
        mUndoList->setInsideRedo(true);
        auto action = finally([&,this]{
            mUndoing = false;
            mUndoList->setInsideRedo(false);
            if (ChangeScrollPastEol)
                mOptions.setFlag(eoScrollPastEol,false);
            decPaintLock();
        });
        switch(item->changeReason()) {
        case SynChangeReason::Caret:
            mUndoList->addChange(
                        item->changeReason(),
                        caretXY(),
                        caretXY(),
                        QStringList(),
                        mActiveSelectionMode);
            internalSetCaretXY(item->changeStartPos());
            break;
        case SynChangeReason::LeftTop:
            BufferCoord p;
            p.ch = leftChar();
            p.line = topLine();
            mUndoList->addChange(
                        item->changeReason(),
                        p,
                        p, QStringList(),
                        item->changeSelMode());
            setLeftChar(item->changeStartPos().ch);
            setTopLine(item->changeStartPos().line);
            break;
        case SynChangeReason::Selection:
            mUndoList->addChange(
                        item->changeReason(),
                        mBlockBegin,
                        mBlockEnd,
                        QStringList(),
                        mActiveSelectionMode);
            setCaretAndSelection(
                        caretXY(),
                        item->changeStartPos(),
                        item->changeEndPos());
            break;
        case SynChangeReason::MoveSelectionUp:
            setBlockBegin(BufferCoord{item->changeStartPos().ch, item->changeStartPos().line});
            setBlockEnd(BufferCoord{item->changeEndPos().ch, item->changeEndPos().line});
            doMoveSelUp();
            mUndoList->addChange(
                        item->changeReason(),
                        item->changeStartPos(),
                        item->changeEndPos(),
                        item->changeText(),
                        item->changeSelMode());
            break;
        case SynChangeReason::MoveSelectionDown:
            setBlockBegin(BufferCoord{item->changeStartPos().ch, item->changeStartPos().line});
            setBlockEnd(BufferCoord{item->changeEndPos().ch, item->changeEndPos().line});
            doMoveSelDown();
            mUndoList->addChange(
                        item->changeReason(),
                        item->changeStartPos(),
                        item->changeEndPos(),
                        item->changeText(),
                        item->changeSelMode());
            break;
        case SynChangeReason::Insert:
            setCaretAndSelection(
                        item->changeStartPos(),
                        item->changeStartPos(),
                        item->changeStartPos());
            doInsertText(item->changeStartPos(),item->changeText(), item->changeSelMode(),
                         item->changeStartPos().line,
                         item->changeEndPos().line);
            internalSetCaretXY(item->changeEndPos());
            mUndoList->addChange(item->changeReason(),
                                 item->changeStartPos(),
                                 item->changeEndPos(),
                                 QStringList(),
                                 item->changeSelMode());
            break;
        case SynChangeReason::Delete: {
            doDeleteText(item->changeStartPos(),item->changeEndPos(),item->changeSelMode());
            mUndoList->addChange(item->changeReason(), item->changeStartPos(),
                                 item->changeEndPos(),item->changeText(),
                                 item->changeSelMode());
            internalSetCaretXY(item->changeStartPos());
            break;
        };
        case SynChangeReason::LineBreak: {
            BufferCoord CaretPt = item->changeStartPos();
            mUndoList->addChange(item->changeReason(), item->changeStartPos(),
                                 item->changeEndPos(),item->changeText(),
                                 item->changeSelMode());
            setCaretAndSelection(CaretPt, CaretPt, CaretPt);
            commandProcessor(SynEditorCommand::ecLineBreak);
            break;
        }
        default:
            break;
        }
    }
}

void SynEdit::doZoomIn()
{
    QFont newFont = font();
    int size = newFont.pixelSize();
    size++;
    newFont.setPixelSize(size);
    setFont(newFont);
}

void SynEdit::doZoomOut()
{
    QFont newFont = font();
    int size = newFont.pixelSize();
    size--;
    if (size<2)
        size = 2;
    newFont.setPixelSize(size);
    setFont(newFont);
}

SynSelectionMode SynEdit::selectionMode() const
{
    return mSelectionMode;
}

void SynEdit::setSelectionMode(SynSelectionMode value)
{
    if (mSelectionMode!=value) {
        mSelectionMode = value;
        setActiveSelectionMode(value);
    }
}

QString SynEdit::selText()
{
    if (!selAvail()) {
        return "";
    } else {
        int ColFrom = blockBegin().ch;
        int First = blockBegin().line - 1;
        //
        int ColTo = blockEnd().ch;
        int Last = blockEnd().line - 1;

        switch(mActiveSelectionMode) {
        case SynSelectionMode::Normal:{
            PSynEditFoldRange foldRange = foldStartAtLine(blockEnd().line);
            QString s = mDocument->getString(Last);
            if ((foldRange) && foldRange->collapsed && ColTo>s.length()) {
                s=s+highlighter()->foldString();
                if (ColTo>s.length()) {
                    Last = foldRange->toLine-1;
                    ColTo = mDocument->getString(Last).length()+1;
                }
            }
            if (First == Last)
                return  mDocument->getString(First).mid(ColFrom-1, ColTo - ColFrom);
            else {
                QString result = mDocument->getString(First).mid(ColFrom-1);
                result+= lineBreak();
                for (int i = First + 1; i<=Last - 1; i++) {
                    result += mDocument->getString(i);
                    result+=lineBreak();
                }
                result += mDocument->getString(Last).leftRef(ColTo-1);
                return result;
            }
        }
        case SynSelectionMode::Column:
        {
              First = blockBegin().line;
              ColFrom = charToColumn(blockBegin().line, blockBegin().ch);
              Last = blockEnd().line;
              ColTo = charToColumn(blockEnd().line, blockEnd().ch);
              if (ColFrom > ColTo)
                  std::swap(ColFrom, ColTo);
              if (First>Last)
                  std::swap(First,Last);
              QString result;
              for (int i = First; i <= Last; i++) {
                  int l = columnToChar(i,ColFrom);
                  int r = columnToChar(i,ColTo-1)+1;
                  QString s = mDocument->getString(i-1);
                  result += s.mid(l-1,r-l);
                  if (i<Last)
                      result+=lineBreak();
              }
              return result;
        }
        case SynSelectionMode::Line:
        {
            QString result;
            // If block selection includes LastLine,
            // line break code(s) of the last line will not be added.
            for (int i= First; i<=Last - 1;i++) {
                result += mDocument->getString(i);
                result+=lineBreak();
            }
            result += mDocument->getString(Last);
            if (Last < mDocument->count() - 1)
                result+=lineBreak();
            return result;
        }
        }
    }
    return "";
}

QStringList SynEdit::getContent(BufferCoord startPos, BufferCoord endPos, SynSelectionMode mode) const
{
    QStringList result;
    if (startPos==endPos) {
        return result;
    }
    if (startPos>endPos) {
        std::swap(startPos,endPos);
    }
    int ColFrom = startPos.ch;
    int First = startPos.line - 1;
    //
    int ColTo = endPos.ch;
    int Last = endPos.line - 1;

    switch(mode) {
    case SynSelectionMode::Normal:{
        PSynEditFoldRange foldRange = foldStartAtLine(endPos.line);
        QString s = mDocument->getString(Last);
        if ((foldRange) && foldRange->collapsed && ColTo>s.length()) {
            s=s+highlighter()->foldString();
            if (ColTo>s.length()) {
                Last = foldRange->toLine-1;
                ColTo = mDocument->getString(Last).length()+1;
            }
        }
    }
        if (First == Last) {
            result.append(mDocument->getString(First).mid(ColFrom-1, ColTo - ColFrom));
        } else {
            result.append(mDocument->getString(First).mid(ColFrom-1));
            for (int i = First + 1; i<=Last - 1; i++) {
                result.append(mDocument->getString(i));
            }
            result.append(mDocument->getString(Last).left(ColTo-1));
        }
        break;
    case SynSelectionMode::Column:
          First = blockBegin().line;
          ColFrom = charToColumn(blockBegin().line, blockBegin().ch);
          Last = blockEnd().line;
          ColTo = charToColumn(blockEnd().line, blockEnd().ch);
          if (ColFrom > ColTo)
              std::swap(ColFrom, ColTo);
          if (First>Last)
              std::swap(First,Last);
          for (int i = First; i <= Last; i++) {
              int l = columnToChar(i,ColFrom);
              int r = columnToChar(i,ColTo-1)+1;
              QString s = mDocument->getString(i-1);
              result.append(s.mid(l-1,r-l));
          }
          break;
    case SynSelectionMode::Line:
        // If block selection includes LastLine,
        // line break code(s) of the last line will not be added.
        for (int i= First; i<=Last - 1;i++) {
            result.append(mDocument->getString(i));
        }
        result.append(mDocument->getString(Last));
        if (Last < mDocument->count() - 1)
            result.append("");
        break;
    }
    return result;
}

QString SynEdit::lineBreak()
{
    return mDocument->lineBreak();
}

bool SynEdit::useCodeFolding() const
{
    return mUseCodeFolding;
}

void SynEdit::setUseCodeFolding(bool value)
{
    if (mUseCodeFolding!=value) {
        mUseCodeFolding = value;
    }
}

SynEditCodeFolding &SynEdit::codeFolding()
{
    return mCodeFolding;
}

QString SynEdit::displayLineText()
{
    if (mCaretY >= 1 && mCaretY <= mDocument->count()) {
        QString s= mDocument->getString(mCaretY - 1);
        PSynEditFoldRange foldRange = foldStartAtLine(mCaretY);
        if ((foldRange) && foldRange->collapsed) {
            return s+highlighter()->foldString();
        }
        return s;
    }
    return QString();
}

QString SynEdit::lineText() const
{
    if (mCaretY >= 1 && mCaretY <= mDocument->count())
        return mDocument->getString(mCaretY - 1);
    else
        return QString();
}

void SynEdit::setLineText(const QString s)
{
    if (mCaretY >= 1 && mCaretY <= mDocument->count())
        mDocument->putString(mCaretY-1,s);
}

PSynHighlighter SynEdit::highlighter() const
{
    return mHighlighter;
}

void SynEdit::setHighlighter(const PSynHighlighter &highlighter)
{
    PSynHighlighter oldHighlighter= mHighlighter;
    mHighlighter = highlighter;
    if (oldHighlighter && mHighlighter &&
            oldHighlighter->language() == highlighter->language()) {
    } else {
        recalcCharExtent();
        mDocument->beginUpdate();
        auto action=finally([this]{
            mDocument->endUpdate();
        });
        rescanRanges();
    }
    onSizeOrFontChanged(true);
    invalidate();
}

const PSynDocument& SynEdit::document() const
{
    return mDocument;
}

bool SynEdit::empty()
{
    return mDocument->empty();
}

void SynEdit::commandProcessor(SynEditorCommand Command, QChar AChar, void *pData)
{
    // first the program event handler gets a chance to process the command
    onProcessCommand(Command, AChar, pData);
    if (Command != SynEditorCommand::ecNone)
        ExecuteCommand(Command, AChar, pData);
    onCommandProcessed(Command, AChar, pData);
}

void SynEdit::moveCaretHorz(int DX, bool isSelection)
{
    BufferCoord ptO = caretXY();
    BufferCoord ptDst = ptO;
    QString s = displayLineText();
    int nLineLen = s.length();
    // only moving or selecting one char can change the line
    //bool bChangeY = !mOptions.testFlag(SynEditorOption::eoScrollPastEol);
    bool bChangeY=true;
    if (bChangeY && (DX == -1) && (ptO.ch == 1) && (ptO.line > 1)) {
        // end of previous line
        if (mActiveSelectionMode==SynSelectionMode::Column) {
            return;
        }
        int row = lineToRow(ptDst.line);
        row--;
        int line = rowToLine(row);
        if (line!=ptDst.line && line>=1) {
            ptDst.line = line;
            ptDst.ch = getDisplayStringAtLine(ptDst.line).length() + 1;
        }
    } else if (bChangeY && (DX == 1) && (ptO.ch > nLineLen) && (ptO.line < mDocument->count())) {
        // start of next line
        if (mActiveSelectionMode==SynSelectionMode::Column) {
            return;
        }
        int row = lineToRow(ptDst.line);
        row++;
        int line = rowToLine(row);
//        qDebug()<<line<<ptDst.Line;
        if (line!=ptDst.line && line<=mDocument->count()) {
            ptDst.line = line;
            ptDst.ch = 1;
        }
    } else {
        ptDst.ch = std::max(1, ptDst.ch + DX);
        // don't go past last char when ScrollPastEol option not set
        if ((DX > 0) && bChangeY)
          ptDst.ch = std::min(ptDst.ch, nLineLen + 1);
    }
    // set caret and block begin / end
    incPaintLock();
    if (mOptions.testFlag(eoAltSetsColumnMode) &&
                         (mActiveSelectionMode != SynSelectionMode::Line)) {
        if (qApp->keyboardModifiers().testFlag(Qt::AltModifier)) {
            setActiveSelectionMode(SynSelectionMode::Column);
        } else
            setActiveSelectionMode(selectionMode());
    }
    moveCaretAndSelection(mBlockBegin, ptDst, isSelection);
    decPaintLock();
}

void SynEdit::moveCaretVert(int DY, bool isSelection)
{
    DisplayCoord ptO = displayXY();
    DisplayCoord ptDst = ptO;


    ptDst.Row+=DY;
    if (DY >= 0) {
        if (rowToLine(ptDst.Row) > mDocument->count())
            ptDst.Row = std::max(1, displayLineCount());
    } else {
        if (ptDst.Row < 1)
            ptDst.Row = 1;
    }

    if (ptO.Row != ptDst.Row) {
        if (mOptions.testFlag(eoKeepCaretX))
            ptDst.Column = mLastCaretColumn;
    }
    BufferCoord vDstLineChar = displayToBufferPos(ptDst);

    if (mActiveSelectionMode==SynSelectionMode::Column) {
        QString s=mDocument->getString(vDstLineChar.line-1);
        int cols=stringColumns(s,0);
        if (cols+1<ptO.Column)
            return;
    }

    int SaveLastCaretX = mLastCaretColumn;

    // set caret and block begin / end
    incPaintLock();
    if (mOptions.testFlag(eoAltSetsColumnMode) &&
                         (mActiveSelectionMode != SynSelectionMode::Line)) {
        if (qApp->keyboardModifiers().testFlag(Qt::AltModifier))
            setActiveSelectionMode(SynSelectionMode::Column);
        else
            setActiveSelectionMode(selectionMode());
    }
    moveCaretAndSelection(mBlockBegin, vDstLineChar, isSelection);
    decPaintLock();

    // Restore fLastCaretX after moving caret, since
    // UpdateLastCaretX, called by SetCaretXYEx, changes them. This is the one
    // case where we don't want that.
    mLastCaretColumn = SaveLastCaretX;
}

void SynEdit::moveCaretAndSelection(const BufferCoord &ptBefore, const BufferCoord &ptAfter, bool isSelection)
{
    if (mOptions.testFlag(SynEditorOption::eoGroupUndo)) {
        mUndoList->addGroupBreak();
    }

    incPaintLock();
    if (isSelection) {
        if (!selAvail())
          setBlockBegin(ptBefore);
        setBlockEnd(ptAfter);
    } else
        setBlockBegin(ptAfter);
    internalSetCaretXY(ptAfter);
    decPaintLock();
}

void SynEdit::moveCaretToLineStart(bool isSelection)
{
    int newX;
    // home key enhancement
    if (mOptions.testFlag(SynEditorOption::eoEnhanceHomeKey)) {
        QString s = mDocument->getString(mCaretY - 1);

        int first_nonblank = 0;
        int vMaxX = s.length();
        while ((first_nonblank < vMaxX) && (s[first_nonblank] == ' ' || s[first_nonblank] == '\t')) {
            first_nonblank++;
        }
        newX = mCaretX;

        if ((newX > first_nonblank+1)
                || (newX == 1))
            newX = first_nonblank+1;
        else
            newX = 1;
    } else
        newX = 1;
    moveCaretAndSelection(caretXY(), BufferCoord{newX, mCaretY}, isSelection);
}

void SynEdit::moveCaretToLineEnd(bool isSelection)
{
    int vNewX;
    if (mOptions.testFlag(SynEditorOption::eoEnhanceEndKey)) {
        QString vText = displayLineText();
        int vLastNonBlank = vText.length()-1;
        int vMinX = 0;
        while ((vLastNonBlank >= vMinX) && (vText[vLastNonBlank] == ' ' || vText[vLastNonBlank] =='\t'))
            vLastNonBlank--;
        vLastNonBlank++;
        vNewX = mCaretX;
        if ((vNewX <= vLastNonBlank) || (vNewX == vText.length() + 1))
            vNewX = vLastNonBlank + 1;
        else
            vNewX = vText.length() + 1;
    } else
        vNewX = displayLineText().length() + 1;

    moveCaretAndSelection(caretXY(), BufferCoord{vNewX, mCaretY}, isSelection);
}

void SynEdit::setSelectedTextEmpty()
{
    BufferCoord startPos=blockBegin();
    BufferCoord endPos=blockEnd();
    doDeleteText(startPos,endPos,mActiveSelectionMode);
    internalSetCaretXY(startPos);
}

void SynEdit::setSelTextPrimitive(const QStringList &text)
{
    setSelTextPrimitiveEx(mActiveSelectionMode, text);
}

void SynEdit::setSelTextPrimitiveEx(SynSelectionMode mode, const QStringList &text)
{
    incPaintLock();
    bool groupUndo=false;
    BufferCoord startPos = blockBegin();
    BufferCoord endPos = blockEnd();
    if (selAvail()) {
        if (!mUndoing && !text.isEmpty()) {
            mUndoList->beginBlock();
            groupUndo=true;
        }
        doDeleteText(startPos,endPos,activeSelectionMode());
        if (mode == SynSelectionMode::Column) {
            int colBegin = charToColumn(startPos.line,startPos.ch);
            int colEnd = charToColumn(endPos.line,endPos.ch);
            if (colBegin<colEnd)
                internalSetCaretXY(startPos);
            else
                internalSetCaretXY(endPos);
        } else
            internalSetCaretXY(startPos);
    }
    if (!text.isEmpty()) {
        doInsertText(caretXY(),text,mode,mBlockBegin.line,mBlockEnd.line);
    }
    if (groupUndo) {
        mUndoList->endBlock();
    }
    decPaintLock();
    setStatusChanged(SynStatusChange::scSelection);
}

void SynEdit::doSetSelText(const QString &value)
{
    bool blockBeginned = false;
    auto action = finally([this, &blockBeginned]{
        if (blockBeginned)
            mUndoList->endBlock();
    });
    if (selAvail()) {
      mUndoList->beginBlock();
      blockBeginned = true;
//      mUndoList->AddChange(
//                  SynChangeReason::crDelete, mBlockBegin, mBlockEnd,
//                  selText(), mActiveSelectionMode);
    }
//    } else if (!colSelAvail())
//        setActiveSelectionMode(selectionMode());
    BufferCoord StartOfBlock = blockBegin();
    BufferCoord EndOfBlock = blockEnd();
    mBlockBegin = StartOfBlock;
    mBlockEnd = EndOfBlock;
    setSelTextPrimitive(splitStrings(value));
}

int SynEdit::searchReplace(const QString &sSearch, const QString &sReplace, SynSearchOptions sOptions, PSynSearchBase searchEngine,
                    SynSearchMathedProc matchedCallback, SynSearchConfirmAroundProc confirmAroundCallback)
{
    if (!searchEngine)
        return 0;

    // can't search for or replace an empty string
    if (sSearch.isEmpty()) {
        return 0;
    }
    int result = 0;
    // get the text range to search in, ignore the "Search in selection only"
    // option if nothing is selected
    bool bBackward = sOptions.testFlag(ssoBackwards);
    bool bFromCursor = !sOptions.testFlag(ssoEntireScope);
    BufferCoord ptCurrent;
    BufferCoord ptStart;
    BufferCoord ptEnd;
    if (!selAvail())
        sOptions.setFlag(ssoSelectedOnly,false);
    if (sOptions.testFlag(ssoSelectedOnly)) {
        ptStart = blockBegin();
        ptEnd = blockEnd();
        // search the whole line in the line selection mode
        if (mActiveSelectionMode == SynSelectionMode::Line) {
            ptStart.ch = 1;
            ptEnd.ch = mDocument->getString(ptEnd.line - 1).length();
        } else if (mActiveSelectionMode == SynSelectionMode::Column) {
            // make sure the start column is smaller than the end column
            if (ptStart.ch > ptEnd.ch)
                std::swap(ptStart.ch,ptEnd.ch);
        }
        // ignore the cursor position when searching in the selection
        if (bBackward) {
            ptCurrent = ptEnd;
        } else {
            ptCurrent = ptStart;
        }
    } else {
        ptStart.ch = 1;
        ptStart.line = 1;
        ptEnd.line = mDocument->count();
        ptEnd.ch = mDocument->getString(ptEnd.line - 1).length();
        if (bFromCursor) {
            if (bBackward)
                ptEnd = caretXY();
            else
                ptStart = caretXY();
        }
        if (bBackward)
            ptCurrent = ptEnd;
        else
            ptCurrent = ptStart;
    }
    BufferCoord originCaretXY=caretXY();
    // initialize the search engine
    searchEngine->setOptions(sOptions);
    searchEngine->setPattern(sSearch);
    // search while the current search position is inside of the search range
    bool dobatchReplace = false;
    doOnPaintTransient(SynTransientType::ttBefore);
    {
        auto action = finally([&,this]{
            if (dobatchReplace) {
                decPaintLock();
                mUndoList->endBlock();
            }
            doOnPaintTransient(SynTransientType::ttAfter);
        });
        int i;
        // If it's a search only we can leave the procedure now.
        SynSearchAction searchAction = SynSearchAction::Exit;
        while ((ptCurrent.line >= ptStart.line) && (ptCurrent.line <= ptEnd.line)) {
            int nInLine = searchEngine->findAll(mDocument->getString(ptCurrent.line - 1));
            int iResultOffset = 0;
            if (bBackward)
                i = searchEngine->resultCount()-1;
            else
                i = 0;
            // Operate on all results in this line.
            while (nInLine > 0) {
                // An occurrence may have been replaced with a text of different length
                int nFound = searchEngine->result(i) + 1 + iResultOffset;
                int nSearchLen = searchEngine->length(i);
                int nReplaceLen = 0;
                if (bBackward)
                    i--;
                else
                    i++;
                nInLine--;
                // Is the search result entirely in the search range?
                bool isInValidSearchRange = true;
                int first = nFound;
                int last = nFound + nSearchLen;
                if ((mActiveSelectionMode == SynSelectionMode::Normal)
                        || !sOptions.testFlag(ssoSelectedOnly)) {
                    if (((ptCurrent.line == ptStart.line) && (first < ptStart.ch)) ||
                            ((ptCurrent.line == ptEnd.line) && (last > ptEnd.ch)))
                        isInValidSearchRange = false;
                } else if (mActiveSelectionMode == SynSelectionMode::Column) {
                    // solves bug in search/replace when smColumn mode active and no selection
                    isInValidSearchRange = ((first >= ptStart.ch) && (last <= ptEnd.ch))
                            || (ptEnd.ch - ptStart.ch < 1);
                }
                if (!isInValidSearchRange)
                    continue;
                result++;
                // Select the text, so the user can see it in the OnReplaceText event
                // handler or as the search result.
                ptCurrent.ch = nFound;
                setBlockBegin(ptCurrent);

                //Be sure to use the Ex version of CursorPos so that it appears in the middle if necessary
                setCaretXYEx(false, BufferCoord{1, ptCurrent.line});
                ensureCursorPosVisibleEx(true);
                ptCurrent.ch += nSearchLen;
                setBlockEnd(ptCurrent);
                //internalSetCaretXY(ptCurrent);
                if (bBackward)
                    internalSetCaretXY(blockBegin());
                else
                    internalSetCaretXY(ptCurrent);

                QString replaceText = searchEngine->replace(selText(), sReplace);
                if (matchedCallback && !dobatchReplace) {
                    searchAction = matchedCallback(sSearch,replaceText,ptCurrent.line,
                                    nFound,nSearchLen);
                }
                if (searchAction==SynSearchAction::Exit) {
                    return result;
                } else if (searchAction == SynSearchAction::Skip) {
                    continue;
                } else if (searchAction == SynSearchAction::Replace
                           || searchAction == SynSearchAction::ReplaceAll) {
                    if (!dobatchReplace &&
                            (searchAction == SynSearchAction::ReplaceAll) ){
                        incPaintLock();
                        mUndoList->beginBlock();
                        dobatchReplace = true;
                    }
                    bool oldAutoIndent = mOptions.testFlag(SynEditorOption::eoAutoIndent);
                    mOptions.setFlag(SynEditorOption::eoAutoIndent,false);
                    doSetSelText(replaceText);
                    nReplaceLen = caretX() - nFound;
                    // fix the caret position and the remaining results
                    if (!bBackward) {
                        internalSetCaretX(nFound + nReplaceLen);
                        if ((nSearchLen != nReplaceLen)) {
                            iResultOffset += nReplaceLen - nSearchLen;
                            if ((mActiveSelectionMode != SynSelectionMode::Column) && (caretY() == ptEnd.line)) {
                                ptEnd.ch+=nReplaceLen - nSearchLen;
                                setBlockEnd(ptEnd);
                            }
                        }
                    }
                    mOptions.setFlag(SynEditorOption::eoAutoIndent,oldAutoIndent);
                }
            }
            // search next / previous line
            if (bBackward)
                ptCurrent.line--;
            else
                ptCurrent.line++;
            if (((ptCurrent.line < ptStart.line) || (ptCurrent.line > ptEnd.line))
                    && bFromCursor && sOptions.testFlag(ssoWrapAround)){
                if (confirmAroundCallback && !confirmAroundCallback())
                    break;
                //search start from cursor, search has finished but no result founds
                bFromCursor = false;
                ptStart.ch = 1;
                ptStart.line = 1;
                ptEnd.line = mDocument->count();
                ptEnd.ch = mDocument->getString(ptEnd.line - 1).length();
                if (bBackward) {
                    ptStart = originCaretXY;
                    ptCurrent = ptEnd;
                } else {
                    ptEnd= originCaretXY;
                    ptCurrent = ptStart;
                }
            }
        }
    }
    return result;
}

void SynEdit::doLinesDeleted(int firstLine, int count)
{
    emit linesDeleted(firstLine, count);
//    // gutter marks
//    for i := 0 to Marks.Count - 1 do begin
//      if Marks[i].Line >= FirstLine + Count then
//        Marks[i].Line := Marks[i].Line - Count
//      else if Marks[i].Line > FirstLine then
//        Marks[i].Line := FirstLine;
//    end;
//    // plugins
//    if fPlugins <> nil then begin
//      for i := 0 to fPlugins.Count - 1 do
//        TSynEditPlugin(fPlugins[i]).LinesDeleted(FirstLine, Count);
    //    end;
}

void SynEdit::doLinesInserted(int firstLine, int count)
{
    emit linesInserted(firstLine, count);
//    // gutter marks
//    for i := 0 to Marks.Count - 1 do begin
//      if Marks[i].Line >= FirstLine then
//        Marks[i].Line := Marks[i].Line + Count;
//    end;
//    // plugins
//    if fPlugins <> nil then begin
//      for i := 0 to fPlugins.Count - 1 do
//        TSynEditPlugin(fPlugins[i]).LinesInserted(FirstLine, Count);
//    end;
}

void SynEdit::properSetLine(int ALine, const QString &ALineText, bool notify)
{
    if (mOptions.testFlag(eoTrimTrailingSpaces)) {
        mDocument->putString(ALine,trimRight(ALineText),notify);
    } else {
        mDocument->putString(ALine,ALineText,notify);
    }
}

void SynEdit::doDeleteText(BufferCoord startPos, BufferCoord endPos, SynSelectionMode mode)
{
    bool UpdateMarks = false;
    int MarkOffset = 0;
    if (mode == SynSelectionMode::Normal) {
        PSynEditFoldRange foldRange = foldStartAtLine(endPos.line);
        QString s = mDocument->getString(endPos.line-1);
        if ((foldRange) && foldRange->collapsed && endPos.ch>s.length()) {
            QString newS=s+highlighter()->foldString();
            if ((startPos.ch<=s.length() || startPos.line<endPos.line)
                    && endPos.ch>newS.length() ) {
                //selection has whole block
                endPos.line = foldRange->toLine;
                endPos.ch = mDocument->getString(endPos.line-1).length()+1;
            } else {
                return;
            }
        }
    }
    QStringList deleted=getContent(startPos,endPos,mode);
    switch(mode) {
    case SynSelectionMode::Normal:
        if (mDocument->count() > 0) {
            // Create a string that contains everything on the first line up
            // to the selection mark, and everything on the last line after
            // the selection mark.
            QString TempString = mDocument->getString(startPos.line - 1).mid(0, startPos.ch - 1)
                + mDocument->getString(endPos.line - 1).mid(endPos.ch-1);
//            bool collapsed=foldCollapsedBetween(BB.Line,BE.Line);
            // Delete all lines in the selection range.
            mDocument->deleteLines(startPos.line, endPos.line - startPos.line);
            properSetLine(startPos.line-1,TempString);
            UpdateMarks = true;
            internalSetCaretXY(startPos);
//            if (collapsed) {
//                PSynEditFoldRange foldRange = foldStartAtLine(BB.Line);
//                if (!foldRange
//                        || (!foldRange->collapsed))
//                    uncollapseAroundLine(BB.Line);
//            }
        }
        break;
    case SynSelectionMode::Column:
    {
        int First = startPos.line - 1;
        int ColFrom = charToColumn(startPos.line, startPos.ch);
        int Last = endPos.line - 1;
        int ColTo = charToColumn(endPos.line, endPos.ch);
        if (ColFrom > ColTo)
            std::swap(ColFrom, ColTo);
        if (First > Last)
            std::swap(First,Last);
        QString result;
        for (int i = First; i <= Last; i++) {
            int l = columnToChar(i+1,ColFrom);
            int r = columnToChar(i+1,ColTo-1)+1;
            QString s = mDocument->getString(i);
            s.remove(l-1,r-l);
            properSetLine(i,s);
        }
        // Lines never get deleted completely, so keep caret at end.
        internalSetCaretXY(startPos);
        // Column deletion never removes a line entirely, so no mark
        // updating is needed here.
        break;
    }
    case SynSelectionMode::Line:
        if (endPos.line == mDocument->count()) {
            mDocument->putString(endPos.line - 1,"");
            mDocument->deleteLines(startPos.line-1,endPos.line-startPos.line);
        } else {
            mDocument->deleteLines(startPos.line-1,endPos.line-startPos.line+1);
        }
        // smLine deletion always resets to first column.
        internalSetCaretXY(BufferCoord{1, startPos.line});
        UpdateMarks = true;
        MarkOffset = 1;
        break;
    }
    // Update marks
    if (UpdateMarks)
        doLinesDeleted(startPos.line, endPos.line - startPos.line + MarkOffset);
    if (!mUndoing) {
        mUndoList->addChange(SynChangeReason::Delete,
                             startPos,
                             endPos,
                             deleted,
                             mode);
    }
}

void SynEdit::doInsertText(const BufferCoord& pos,
                           const QStringList& text,
                           SynSelectionMode mode, int startLine, int endLine) {
    if (text.isEmpty())
        return;
    if (startLine>endLine)
        std::swap(startLine,endLine);

    if (mode == SynSelectionMode::Normal) {
        PSynEditFoldRange foldRange = foldStartAtLine(pos.line);
        QString s = mDocument->getString(pos.line-1);
        if ((foldRange) && foldRange->collapsed && pos.ch>s.length()+1)
            return;
    }
    int insertedLines = 0;
    BufferCoord newPos;
    switch(mode){
    case SynSelectionMode::Normal:
        insertedLines = doInsertTextByNormalMode(pos,text, newPos);
        doLinesInserted(pos.line+1, insertedLines);
        break;
    case SynSelectionMode::Column:
        insertedLines = doInsertTextByColumnMode(pos,text, newPos, startLine,endLine);
        doLinesInserted(endLine-insertedLines+1,insertedLines);
        break;
    case SynSelectionMode::Line:
        insertedLines = doInsertTextByLineMode(pos,text, newPos);
        doLinesInserted(pos.line, insertedLines);
        break;
    }
    internalSetCaretXY(newPos);
    ensureCursorPosVisible();
}

int SynEdit::doInsertTextByNormalMode(const BufferCoord& pos, const QStringList& text, BufferCoord &newPos)
{
    QString sLeftSide;
    QString sRightSide;
    QString str;
    bool bChangeScroll;
//    int SpaceCount;
    int result = 0;
    int startLine = pos.line;
    QString line=mDocument->getString(pos.line-1);
    sLeftSide = line.mid(0, pos.ch - 1);
    if (pos.ch - 1 > sLeftSide.length()) {
        if (stringIsBlank(sLeftSide))
            sLeftSide = GetLeftSpacing(displayX() - 1, true);
        else
            sLeftSide += QString(pos.ch - 1 - sLeftSide.length(),' ');
    }
    sRightSide = line.mid(pos.ch - 1);
//    if (mUndoing) {
//        SpaceCount = 0;
//    } else {
//        SpaceCount = leftSpaces(sLeftSide);
//    }
    int caretY=pos.line;
    // step1: insert the first line of Value into current line
    if (text.length()>1) {
        if (!mUndoing && mHighlighter && mOptions.testFlag(eoAutoIndent)) {
            QString s = trimLeft(text[0]);
            if (sLeftSide.isEmpty()) {
                sLeftSide = GetLeftSpacing(calcIndentSpaces(caretY,s,true),true);
            }
            str = sLeftSide + s;
        } else
            str = sLeftSide + text[0];
        properSetLine(caretY - 1, str);
        mDocument->insertLines(caretY, text.length()-1);
    } else {
        str = sLeftSide + text[0] + sRightSide;
        properSetLine(caretY - 1, str);
    }
    rescanRange(caretY);
    // step2: insert remaining lines of Value
    for (int i=1;i<text.length();i++) {
        bool notInComment = true;
//        if (mHighlighter) {
//            notInComment = !mHighlighter->isLastLineCommentNotFinished(
//                    mHighlighter->getRangeState().state)
//                && !mHighlighter->isLastLineStringNotFinished(
//                    mHighlighter->getRangeState().state);
//        }
        caretY=pos.line+i;
//        mStatusChanges.setFlag(SynStatusChange::scCaretY);
        if (text[i].isEmpty()) {
            if (i==text.length()-1) {
                str = sRightSide;
            } else {
                if (!mUndoing && mHighlighter && mOptions.testFlag(eoAutoIndent) && notInComment) {
                    str = GetLeftSpacing(calcIndentSpaces(caretY,"",true),true);
                } else {
                    str = "";
                }
            }
        } else {
            str = text[i];
            if (i==text.length()-1)
                str += sRightSide;
            if (!mUndoing && mHighlighter && mOptions.testFlag(eoAutoIndent) && notInComment) {
                int indentSpaces = calcIndentSpaces(caretY,str,true);
                str = GetLeftSpacing(indentSpaces,true)+trimLeft(str);
            }
        }
        properSetLine(caretY - 1, str,false);
        rescanRange(caretY);
        result++;
    }
    bChangeScroll = !mOptions.testFlag(eoScrollPastEol);
    mOptions.setFlag(eoScrollPastEol);
    auto action = finally([&,this]{
        if (bChangeScroll)
            mOptions.setFlag(eoScrollPastEol,false);
    });
    if (mOptions.testFlag(eoTrimTrailingSpaces) && (sRightSide == "")) {
        newPos=BufferCoord{mDocument->getString(caretY-1).length()+1,caretY};
    } else
        newPos=BufferCoord{str.length() - sRightSide.length()+1,caretY};
    onLinesPutted(startLine-1,result+1);
    if (!mUndoing) {
        mUndoList->addChange(
                    SynChangeReason::Insert,
                    pos,newPos,
                    QStringList(),SynSelectionMode::Normal);
    }
    return result;
}

int SynEdit::doInsertTextByColumnMode(const BufferCoord& pos, const QStringList& text, BufferCoord &newPos, int startLine, int endLine)
{
    QString str;
    QString tempString;
    int line;
    int len;
    BufferCoord  lineBreakPos;
    int result = 0;
    DisplayCoord insertCoord = bufferToDisplayPos(caretXY());
    int insertCol = insertCoord.Column;
    line = startLine;
    if (!mUndoing) {
        mUndoList->beginBlock();
    }
    int i=0;
    while(line<=endLine) {
        str = text[i];
        int insertPos = 0;
        if (line > mDocument->count()) {
            result++;
            tempString = QString(insertCol - 1,' ') + str;
            mDocument->add("");
            if (!mUndoing) {
                result++;
                lineBreakPos.line = line - 1;
                lineBreakPos.ch = mDocument->getString(line - 2).length() + 1;
                mUndoList->addChange(SynChangeReason::LineBreak,
                                 lineBreakPos,
                                 lineBreakPos,
                                 QStringList(), SynSelectionMode::Normal);
            }
        } else {
            tempString = mDocument->getString(line - 1);
            len = stringColumns(tempString,0);
            if (len < insertCol) {
                insertPos = tempString.length()+1;
                tempString = tempString + QString(insertCol - len - 1,' ') + str;
            } else {
                insertPos = columnToChar(line,insertCol);
                tempString.insert(insertPos-1,str);
            }
        }
        properSetLine(line - 1, tempString);
        // Add undo change here from PasteFromClipboard
        if (!mUndoing) {
            mUndoList->addChange(
                        SynChangeReason::Insert,
                        BufferCoord{insertPos, line},
                        BufferCoord{insertPos+str.length(), line},
                        QStringList(),
                        SynSelectionMode::Normal);
        }
        if (i<text.length()-1) {
            i++;
        }
        line++;
    }
    newPos=pos;
    if (!text[0].isEmpty()) {
        newPos.ch+=text[0].length();
//        mCaretX+=firstLineLen;
//        mStatusChanges.setFlag(SynStatusChange::scCaretX);
    }
    if (!mUndoing) {
        mUndoList->endBlock();
    }
    return result;
}

int SynEdit::doInsertTextByLineMode(const BufferCoord& pos, const QStringList& text, BufferCoord &newPos)
{
    QString Str;
    int Result = 0;
    newPos=pos;
    newPos.ch=1;
//    mCaretX = 1;
//    emit statusChanged(SynStatusChange::scCaretX);
    // Insert string before current line
    for (int i=0;i<text.length();i++) {
        if ((mCaretY == mDocument->count()) || mInserting) {
            mDocument->insert(mCaretY - 1, "");
            Result++;
        }
        properSetLine(mCaretY - 1, Str);
        newPos.line++;
//        mCaretY++;
//        mStatusChanges.setFlag(SynStatusChange::scCaretY);
    }
    if (!mUndoing) {
        mUndoList->addChange(
                    SynChangeReason::Insert,
                    BufferCoord{1,pos.line},newPos,
                    QStringList(),SynSelectionMode::Line);
    }
    return Result;
}

void SynEdit::deleteFromTo(const BufferCoord &start, const BufferCoord &end)
{
    if (mReadOnly)
        return;
    doOnPaintTransient(SynTransientType::ttBefore);
    if ((start.ch != end.ch) || (start.line != end.line)) {
        mUndoList->beginBlock();
        addCaretToUndo();
        addSelectionToUndo();
        setBlockBegin(start);
        setBlockEnd(end);
        doDeleteText(start,end,SynSelectionMode::Normal);
        mUndoList->endBlock();
        internalSetCaretXY(start);
    }
    doOnPaintTransient(SynTransientType::ttAfter);
}

bool SynEdit::onGetSpecialLineColors(int, QColor &, QColor &)
{
    return false;
}

void SynEdit::onGetEditingAreas(int, SynEditingAreaList &)
{

}

void SynEdit::onGutterGetText(int , QString &)
{

}

void SynEdit::onGutterPaint(QPainter &, int , int , int )
{

}

void SynEdit::onPaint(QPainter &)
{

}

void SynEdit::onPreparePaintHighlightToken(int , int , const QString &,
                                           PSynHighlighterAttribute , SynFontStyles &, QColor &, QColor &)
{

}

void SynEdit::onProcessCommand(SynEditorCommand , QChar , void *)
{

}

void SynEdit::onCommandProcessed(SynEditorCommand , QChar , void *)
{

}

void SynEdit::ExecuteCommand(SynEditorCommand Command, QChar AChar, void *pData)
{
    hideCaret();
    incPaintLock();

    auto action=finally([this] {
        decPaintLock();
        showCaret();
    });
    switch(Command) {
    //horizontal caret movement or selection
    case SynEditorCommand::ecLeft:
    case SynEditorCommand::ecSelLeft:
        moveCaretHorz(-1, Command == SynEditorCommand::ecSelLeft);
        break;
    case SynEditorCommand::ecRight:
    case SynEditorCommand::ecSelRight:
        moveCaretHorz(1, Command == SynEditorCommand::ecSelRight);
        break;
    case SynEditorCommand::ecPageLeft:
    case SynEditorCommand::ecSelPageLeft:
        moveCaretHorz(-mCharsInWindow, Command == SynEditorCommand::ecSelPageLeft);
        break;
    case SynEditorCommand::ecPageRight:
    case SynEditorCommand::ecSelPageRight:
        moveCaretHorz(mCharsInWindow, Command == SynEditorCommand::ecSelPageRight);
        break;
    case SynEditorCommand::ecLineStart:
    case SynEditorCommand::ecSelLineStart:
        moveCaretToLineStart(Command == SynEditorCommand::ecSelLineStart);
        break;
    case SynEditorCommand::ecLineEnd:
    case SynEditorCommand::ecSelLineEnd:
        moveCaretToLineEnd(Command == SynEditorCommand::ecSelLineEnd);
        break;
    // vertical caret movement or selection
    case SynEditorCommand::ecUp:
    case SynEditorCommand::ecSelUp:
        moveCaretVert(-1, Command == SynEditorCommand::ecSelUp);
        break;
    case SynEditorCommand::ecDown:
    case SynEditorCommand::ecSelDown:
        moveCaretVert(1, Command == SynEditorCommand::ecSelDown);
        break;
    case SynEditorCommand::ecPageUp:
    case SynEditorCommand::ecSelPageUp:
    case SynEditorCommand::ecPageDown:
    case SynEditorCommand::ecSelPageDown:
    {
        int counter = mLinesInWindow;
        if (mOptions.testFlag(eoHalfPageScroll))
            counter /= 2;
        if (mOptions.testFlag(eoScrollByOneLess)) {
            counter -=1;
        }
        if (counter<0)
            break;
        if (Command == SynEditorCommand::ecPageUp || Command == SynEditorCommand::ecSelPageUp) {
            counter = -counter;
        }
        moveCaretVert(counter, Command == SynEditorCommand::ecSelPageUp || Command == SynEditorCommand::ecSelPageDown);
        break;
    }
    case SynEditorCommand::ecPageTop:
    case SynEditorCommand::ecSelPageTop:
        moveCaretVert(mTopLine-mCaretY, Command == SynEditorCommand::ecSelPageTop);
        break;
    case SynEditorCommand::ecPageBottom:
    case SynEditorCommand::ecSelPageBottom:
        moveCaretVert(mTopLine+mLinesInWindow-1-mCaretY, Command == SynEditorCommand::ecSelPageBottom);
        break;
    case SynEditorCommand::ecEditorStart:
    case SynEditorCommand::ecSelEditorStart:
        moveCaretVert(1-mCaretY, Command == SynEditorCommand::ecSelEditorStart);
        moveCaretToLineStart(Command == SynEditorCommand::ecSelEditorStart);
        break;
    case SynEditorCommand::ecEditorEnd:
    case SynEditorCommand::ecSelEditorEnd:
        if (!mDocument->empty()) {
            moveCaretVert(mDocument->count()-mCaretY, Command == SynEditorCommand::ecSelEditorEnd);
            moveCaretToLineEnd(Command == SynEditorCommand::ecSelEditorEnd);
        }
        break;
    // goto special line / column position
    case SynEditorCommand::ecGotoXY:
    case SynEditorCommand::ecSelGotoXY:
        if (pData)
            moveCaretAndSelection(caretXY(), *((BufferCoord *)(pData)), Command == SynEditorCommand::ecSelGotoXY);
        break;
    // word selection
    case SynEditorCommand::ecWordLeft:
    case SynEditorCommand::ecSelWordLeft:
    {
        BufferCoord CaretNew = prevWordPos();
        moveCaretAndSelection(caretXY(), CaretNew, Command == SynEditorCommand::ecSelWordLeft);
        break;
    }
    case SynEditorCommand::ecWordRight:
    case SynEditorCommand::ecSelWordRight:
    {
        BufferCoord CaretNew = nextWordPos();
        moveCaretAndSelection(caretXY(), CaretNew, Command == SynEditorCommand::ecSelWordRight);
        break;
    }
    case SynEditorCommand::ecSelWord:
        setSelWord();
        break;
    case SynEditorCommand::ecSelectAll:
        doSelectAll();
        break;
    case SynEditorCommand::ecDeleteLastChar:
        doDeleteLastChar();
        break;
    case SynEditorCommand::ecDeleteChar:
        doDeleteCurrentChar();
        break;
    case SynEditorCommand::ecDeleteWord:
        doDeleteWord();
        break;
    case SynEditorCommand::ecDeleteEOL:
        doDeleteToEOL();
        break;
    case SynEditorCommand::ecDeleteWordStart:
        doDeleteToWordStart();
        break;
    case SynEditorCommand::ecDeleteWordEnd:
        doDeleteToWordEnd();
        break;
    case SynEditorCommand::ecDeleteBOL:
        doDeleteFromBOL();
        break;
    case SynEditorCommand::ecDeleteLine:
        doDeleteLine();
        break;
    case SynEditorCommand::ecDuplicateLine:
        doDuplicateLine();
        break;
    case SynEditorCommand::ecMoveSelUp:
        doMoveSelUp();
        break;
    case SynEditorCommand::ecMoveSelDown:
        doMoveSelDown();
        break;
    case SynEditorCommand::ecClearAll:
        clearAll();
        break;
    case SynEditorCommand::ecInsertLine:
        insertLine(false);
        break;
    case SynEditorCommand::ecLineBreak:
        insertLine(true);
        break;
    case SynEditorCommand::ecLineBreakAtEnd:
        mUndoList->beginBlock();
        addCaretToUndo();
        addSelectionToUndo();
        moveCaretToLineEnd(false);
        insertLine(true);
        mUndoList->endBlock();
        break;
    case SynEditorCommand::ecTab:
        doTabKey();
        break;
    case SynEditorCommand::ecShiftTab:
        doShiftTabKey();
        break;
    case SynEditorCommand::ecChar:
        doAddChar(AChar);
        break;
    case SynEditorCommand::ecInsertMode:
        if (!mReadOnly)
            setInsertMode(true);
        break;
    case SynEditorCommand::ecOverwriteMode:
        if (!mReadOnly)
            setInsertMode(false);
        break;
    case SynEditorCommand::ecToggleMode:
        if (!mReadOnly) {
            setInsertMode(!mInserting);
        }
        break;
    case SynEditorCommand::ecCut:
        if (!mReadOnly)
            doCutToClipboard();
        break;
    case SynEditorCommand::ecCopy:
        doCopyToClipboard();
        break;
    case SynEditorCommand::ecPaste:
        if (!mReadOnly)
            doPasteFromClipboard();
        break;
    case SynEditorCommand::ecImeStr:
    case SynEditorCommand::ecString:
        if (!mReadOnly)
            doAddStr(*((QString*)pData));
        break;
    case SynEditorCommand::ecUndo:
        if (!mReadOnly)
            doUndo();
        break;
    case SynEditorCommand::ecRedo:
        if (!mReadOnly)
            doRedo();
        break;
    case SynEditorCommand::ecZoomIn:
        doZoomIn();
        break;
    case SynEditorCommand::ecZoomOut:
        doZoomOut();
        break;
    case SynEditorCommand::ecComment:
        doComment();
        break;
    case SynEditorCommand::ecUncomment:
        doUncomment();
        break;
    case SynEditorCommand::ecToggleComment:
        doToggleComment();
        break;
    case SynEditorCommand::ecToggleBlockComment:
        doToggleBlockComment();
        break;
    case SynEditorCommand::ecNormalSelect:
        setSelectionMode(SynSelectionMode::Normal);
        break;
    case SynEditorCommand::ecLineSelect:
        setSelectionMode(SynSelectionMode::Line);
        break;
    case SynEditorCommand::ecColumnSelect:
        setSelectionMode(SynSelectionMode::Column);
        break;
    case SynEditorCommand::ecScrollLeft:
        horizontalScrollBar()->setValue(horizontalScrollBar()->value()-mMouseWheelScrollSpeed);
        break;
    case SynEditorCommand::ecScrollRight:
        horizontalScrollBar()->setValue(horizontalScrollBar()->value()+mMouseWheelScrollSpeed);
        break;
    case SynEditorCommand::ecScrollUp:
        verticalScrollBar()->setValue(verticalScrollBar()->value()-mMouseWheelScrollSpeed);
        break;
    case SynEditorCommand::ecScrollDown:
        verticalScrollBar()->setValue(verticalScrollBar()->value()+mMouseWheelScrollSpeed);
        break;
    case SynEditorCommand::ecMatchBracket:
        {
        BufferCoord coord = getMatchingBracket();
        if (coord.ch!=0 && coord.line!=0)
            internalSetCaretXY(coord);
        }
        break;
    default:
        break;
    }


}

void SynEdit::onEndFirstPaintLock()
{

}

void SynEdit::onBeginFirstPaintLock()
{

}

bool SynEdit::isIdentChar(const QChar &ch)
{
    if (mHighlighter) {
        return mHighlighter->isIdentChar(ch);
    } else {
        if (ch == '_') {
            return true;
        }
        if ((ch>='0') && (ch <= '9')) {
            return true;
        }
        if ((ch>='a') && (ch <= 'z')) {
            return true;
        }
        if ((ch>='A') && (ch <= 'Z')) {
            return true;
        }
        return false;
    }
}

void SynEdit::setRainbowAttrs(const PSynHighlighterAttribute &attr0, const PSynHighlighterAttribute &attr1, const PSynHighlighterAttribute &attr2, const PSynHighlighterAttribute &attr3)
{
    mRainbowAttr0 = attr0;
    mRainbowAttr1 = attr1;
    mRainbowAttr2 = attr2;
    mRainbowAttr3 = attr3;
}

void SynEdit::updateMouseCursor(){
    QPoint p = mapFromGlobal(cursor().pos());
    if (p.y() >= clientHeight() || p.x()>= clientWidth()) {
        setCursor(Qt::ArrowCursor);
    } else if (p.x() > mGutterWidth) {
        setCursor(Qt::IBeamCursor);
    } else {
        setCursor(Qt::ArrowCursor);
    }
}

bool SynEdit::isCaretVisible()
{
    if (mCaretY < mTopLine)
        return false;
    if (mCaretY >= mTopLine + mLinesInWindow )
        return false;
    if (mCaretX < mLeftChar)
        return false;
    if (mCaretX >= mLeftChar + mCharsInWindow)
        return false;
    return true;
}

void SynEdit::paintEvent(QPaintEvent *event)
{
    if (mPainterLock>0)
        return;
    if (mPainting)
        return;
    mPainting = true;
    auto action = finally([&,this] {
        mPainting = false;
    });

    // Now paint everything while the caret is hidden.
    QPainter painter(viewport());
    //Get the invalidated rect.
    QRect rcClip = event->rect();
    QRect rcCaret = calculateCaretRect();

    if (rcCaret == rcClip) {
        // only update caret
        // calculate the needed invalid area for caret
        //qDebug()<<"update caret"<<rcCaret;
        QRectF cacheRC;
        qreal dpr = mContentImage->devicePixelRatioF();
        cacheRC.setLeft(rcClip.left()*dpr);
        cacheRC.setTop(rcClip.top()*dpr);
        cacheRC.setWidth(rcClip.width()*dpr);
        cacheRC.setHeight(rcClip.height()*dpr);
        painter.drawImage(rcCaret,*mContentImage,cacheRC);
    } else {
        QRect rcDraw;
        int nL1, nL2, nC1, nC2;
        // Compute the invalid area in lines / columns.
        // columns
        nC1 = mLeftChar;
        if (rcClip.left() > mGutterWidth + 2 )
            nC1 += (rcClip.left() - mGutterWidth - 2 ) / mCharWidth;
        nC2 = mLeftChar +
          (rcClip.right() - mGutterWidth - 2 + mCharWidth - 1) / mCharWidth;
        // lines
        nL1 = minMax(mTopLine + rcClip.top() / mTextHeight, mTopLine, displayLineCount());
        nL2 = minMax(mTopLine + (rcClip.bottom() + mTextHeight - 1) / mTextHeight, 1, displayLineCount());

        //qDebug()<<"Paint:"<<nL1<<nL2<<nC1<<nC2;

        QPainter cachePainter(mContentImage.get());
        cachePainter.setFont(font());
        SynEditTextPainter textPainter(this, &cachePainter,
                                       nL1,nL2,nC1,nC2);
        // First paint paint the text area if it was (partly) invalidated.
        if (rcClip.right() > mGutterWidth ) {
            rcDraw = rcClip;
            rcDraw.setLeft( std::max(rcDraw.left(), mGutterWidth));
            textPainter.paintTextLines(rcDraw);
        }

        // Then the gutter area if it was (partly) invalidated.
        if (rcClip.left() < mGutterWidth) {
            rcDraw = rcClip;
            rcDraw.setRight(mGutterWidth-1);
            textPainter.paintGutter(rcDraw);
        }

        //PluginsAfterPaint(Canvas, rcClip, nL1, nL2);
        // If there is a custom paint handler call it.
        onPaint(painter);
        doOnPaintTransient(SynTransientType::ttAfter);
        QRectF cacheRC;
        qreal dpr = mContentImage->devicePixelRatioF();
        cacheRC.setLeft(rcClip.left()*dpr);
        cacheRC.setTop(rcClip.top()*dpr);
        cacheRC.setWidth(rcClip.width()*dpr);
        cacheRC.setHeight(rcClip.height()*dpr);
        painter.drawImage(rcClip,*mContentImage,cacheRC);
    }
    paintCaret(painter, rcCaret);
}

void SynEdit::resizeEvent(QResizeEvent *)
{
    //resize the cache image
    qreal dpr = devicePixelRatioF();
    std::shared_ptr<QImage> image = std::make_shared<QImage>(clientWidth()*dpr,clientHeight()*dpr,
                                                            QImage::Format_ARGB32);
    image->setDevicePixelRatio(dpr);
    QRect newRect = image->rect().intersected(mContentImage->rect());

    QPainter painter(image.get());

    painter.drawImage(newRect,*mContentImage);

    mContentImage = image;

    onSizeOrFontChanged(false);
}

void SynEdit::timerEvent(QTimerEvent *event)
{
    if (event->timerId() == m_blinkTimerId) {
        m_blinkStatus = 1- m_blinkStatus;
        updateCaret();
    }
}

bool SynEdit::event(QEvent *event)
{
    switch(event->type()) {
    case QEvent::KeyPress:{
        QKeyEvent* keyEvent = static_cast<QKeyEvent *>(event);
        if(keyEvent->key() == Qt::Key_Tab || keyEvent->key() == Qt::Key_Backtab)
        {
            // process tab key presse event
            keyPressEvent(keyEvent);
            return true;
        }
    }
        break;
    case QEvent::FontChange:
        synFontChanged();
        if (mDocument)
            mDocument->setFontMetrics(font());
        break;
    case QEvent::MouseMove: {
        updateMouseCursor();
        break;
    }
    default:
        break;
    }
    return QAbstractScrollArea::event(event);
}

void SynEdit::focusInEvent(QFocusEvent *)
{
    showCaret();
}

void SynEdit::focusOutEvent(QFocusEvent *)
{
    hideCaret();
}

void SynEdit::keyPressEvent(QKeyEvent *event)
{
    if (event->key() == Qt::Key_Escape && mActiveSelectionMode != mSelectionMode) {
        setActiveSelectionMode(selectionMode());
        setBlockBegin(caretXY());
        setBlockEnd(caretXY());
        event->accept();
    } else {
        SynEditorCommand cmd=TranslateKeyCode(event->key(),event->modifiers());
        if (cmd!=SynEditorCommand::ecNone) {
            commandProcessor(cmd,QChar(),nullptr);
            event->accept();
        } else if (!event->text().isEmpty()) {
            QChar c = event->text().at(0);
            if (c=='\t' || c.isPrint()) {
                commandProcessor(SynEditorCommand::ecChar,c,nullptr);
                event->accept();
            }
        }
    }
    if (!event->isAccepted()) {
        QAbstractScrollArea::keyPressEvent(event);
    }
}

void SynEdit::mousePressEvent(QMouseEvent *event)
{
    bool bWasSel = false;
    bool bStartDrag = false;
    mMouseMoved = false;
    Qt::MouseButton button = event->button();
    int X=event->pos().x();
    int Y=event->pos().y();

    QAbstractScrollArea::mousePressEvent(event);


    BufferCoord oldCaret=caretXY();
    if (button == Qt::RightButton) {
        if (mOptions.testFlag(eoRightMouseMovesCursor) &&
                ( (selAvail() && ! isPointInSelection(displayToBufferPos(pixelsToRowColumn(X, Y))))
                  || ! selAvail())) {
            invalidateSelection();
            //mBlockEnd=mBlockBegin;
            computeCaret();
        }else {
            return;
        }
    } else if (button == Qt::LeftButton) {
        if (selAvail()) {
            //remember selection state, as it will be cleared later
            bWasSel = true;
            mMouseDownPos = event->pos();
        }
        computeCaret();
        mStateFlags.setFlag(SynStateFlag::sfWaitForDragging,false);
        if (bWasSel && mOptions.testFlag(eoDragDropEditing) && (X >= mGutterWidth + 2)
                && (mSelectionMode == SynSelectionMode::Normal) && isPointInSelection(displayToBufferPos(pixelsToRowColumn(X, Y))) ) {
            bStartDrag = true;
        }
        if (bStartDrag) {
            mStateFlags.setFlag(SynStateFlag::sfWaitForDragging);
        } else {
            if (event->modifiers() == Qt::ShiftModifier) {
                //BlockBegin and BlockEnd are restored to their original position in the
                //code from above and SetBlockEnd will take care of proper invalidation
                setBlockEnd(caretXY());
            } else if (mOptions.testFlag(eoAltSetsColumnMode) &&
                     (mActiveSelectionMode != SynSelectionMode::Line)) {
                if (event->modifiers() == Qt::AltModifier)
                    setActiveSelectionMode(SynSelectionMode::Column);
                else
                    setActiveSelectionMode(selectionMode());
                //Selection mode must be set before calling SetBlockBegin
                setBlockBegin(caretXY());
            }
            computeScroll(false);
        }
    }
    if (oldCaret!=caretXY()) {
        if (mOptions.testFlag(SynEditorOption::eoGroupUndo))
            mUndoList->addGroupBreak();
    }
}

void SynEdit::mouseReleaseEvent(QMouseEvent *event)
{
    QAbstractScrollArea::mouseReleaseEvent(event);
    int X=event->pos().x();
    /* int Y=event->pos().y(); */

    if (!mMouseMoved && (X < mGutterWidth + 2)) {
        processGutterClick(event);
    }

    BufferCoord oldCaret=caretXY();
    if (mStateFlags.testFlag(SynStateFlag::sfWaitForDragging) &&
            !mStateFlags.testFlag(SynStateFlag::sfDblClicked)) {
        computeCaret();
        if (! (event->modifiers() & Qt::ShiftModifier))
            setBlockBegin(caretXY());
        setBlockEnd(caretXY());
        mStateFlags.setFlag(SynStateFlag::sfWaitForDragging, false);
    }
    mStateFlags.setFlag(SynStateFlag::sfDblClicked,false);
    if (oldCaret!=caretXY()) {
        if (mOptions.testFlag(SynEditorOption::eoGroupUndo))
            mUndoList->addGroupBreak();
    }
}

void SynEdit::mouseMoveEvent(QMouseEvent *event)
{
    QAbstractScrollArea::mouseMoveEvent(event);
    mMouseMoved = true;
    Qt::MouseButtons buttons = event->buttons();
    if ((mStateFlags.testFlag(SynStateFlag::sfWaitForDragging))) {
        if ( ( event->pos() - mMouseDownPos).manhattanLength()>=QApplication::startDragDistance()) {
            mStateFlags.setFlag(SynStateFlag::sfWaitForDragging,false);
            QDrag *drag = new QDrag(this);
            QMimeData *mimeData = new QMimeData;

            mimeData->setText(selText());
            drag->setMimeData(mimeData);

            drag->exec(Qt::CopyAction | Qt::MoveAction);
        }
    } else if ((buttons == Qt::LeftButton)) {
        if (mOptions.testFlag(eoAltSetsColumnMode) &&
                (mActiveSelectionMode != SynSelectionMode::Line)) {
                if (event->modifiers() == Qt::AltModifier)
                    setActiveSelectionMode(SynSelectionMode::Column);
                else
                    setActiveSelectionMode(selectionMode());
        }
    } else if (buttons == Qt::NoButton) {
        updateMouseCursor();
    }
}

void SynEdit::mouseDoubleClickEvent(QMouseEvent *event)
{
    QAbstractScrollArea::mouseDoubleClickEvent(event);
    QPoint ptMouse = event->pos();
    if (ptMouse.x() >= mGutterWidth + 2) {
          setWordBlock(caretXY());
          mStateFlags.setFlag(SynStateFlag::sfDblClicked);
    }
}

void SynEdit::inputMethodEvent(QInputMethodEvent *event)
{
//    qDebug()<<event->replacementStart()<<":"<<event->replacementLength()<<" - "
//           << event->preeditString()<<" - "<<event->commitString();

    QString oldString = mInputPreeditString;
    mInputPreeditString = event->preeditString();
    if (oldString!=mInputPreeditString) {
        if (mActiveSelectionMode==SynSelectionMode::Column) {
            BufferCoord selBegin = blockBegin();
            BufferCoord selEnd = blockEnd();
            invalidateLines(selBegin.line,selEnd.line);
        } else
            invalidateLine(mCaretY);
    }
    QString s = event->commitString();
    if (!s.isEmpty()) {
        commandProcessor(SynEditorCommand::ecImeStr,QChar(),&s);
//        for (QChar ch:s) {
//            CommandProcessor(SynEditorCommand::ecChar,ch);
//        }
    }
}

void SynEdit::leaveEvent(QEvent *)
{
    setCursor(Qt::ArrowCursor);
}

void SynEdit::wheelEvent(QWheelEvent *event)
{
    if (event->modifiers() == Qt::ShiftModifier) {
        if (event->angleDelta().y()>0) {
            horizontalScrollBar()->setValue(horizontalScrollBar()->value()-mMouseWheelScrollSpeed);
            event->accept();
            return;
        } else if (event->angleDelta().y()<0) {
            horizontalScrollBar()->setValue(horizontalScrollBar()->value()+mMouseWheelScrollSpeed);
            event->accept();
            return;
        }
    } else {
        if (event->angleDelta().y()>0) {
            verticalScrollBar()->setValue(verticalScrollBar()->value()-mMouseWheelScrollSpeed);
            event->accept();
            return;
        } else if (event->angleDelta().y()<0) {
            verticalScrollBar()->setValue(verticalScrollBar()->value()+mMouseWheelScrollSpeed);
            event->accept();
            return;
        }
    }
    QAbstractScrollArea::wheelEvent(event);
}

bool SynEdit::viewportEvent(QEvent * event)
{
//    switch (event->type()) {
//        case QEvent::Resize:
//            sizeOrFontChanged(false);
//        break;
//    }
    return QAbstractScrollArea::viewportEvent(event);
}

QVariant SynEdit::inputMethodQuery(Qt::InputMethodQuery property) const
{
    QRect rect = calculateInputCaretRect();

    switch(property) {
    case Qt::ImCursorRectangle:
        return rect;
    default:
        return QWidget::inputMethodQuery(property);
    }

}

void SynEdit::dragEnterEvent(QDragEnterEvent *event)
{
    if (event->mimeData()->hasFormat("text/plain")) {
        event->acceptProposedAction();
        mDragCaretSave = caretXY();
        mDragSelBeginSave = blockBegin();
        mDragSelEndSave = blockEnd();
        BufferCoord coord = displayToBufferPos(pixelsToNearestRowColumn(event->pos().x(),
                                                                        event->pos().y()));
        internalSetCaretXY(coord);
        setBlockBegin(mDragSelBeginSave);
        setBlockEnd(mDragSelEndSave);
        showCaret();
        computeScroll(true);
    }
}

void SynEdit::dropEvent(QDropEvent *event)
{
    //mScrollTimer->stop();

    BufferCoord coord = displayToBufferPos(pixelsToNearestRowColumn(event->pos().x(),
                                                                    event->pos().y()));
    if (coord>=mDragSelBeginSave && coord<=mDragSelEndSave) {
        //do nothing if drag onto itself
        event->acceptProposedAction();
        mDropped = true;
        return;
    }
    int topLine = mTopLine;
    int leftChar = mLeftChar;
    QStringList text=splitStrings(event->mimeData()->text());
    mUndoList->beginBlock();
    addLeftTopToUndo();
    addCaretToUndo();
    addSelectionToUndo();
    internalSetCaretXY(coord);
    if (event->proposedAction() == Qt::DropAction::CopyAction) {
        //just copy it
        doInsertText(coord,text,mActiveSelectionMode,coord.line,coord.line+text.length()-1);
    } else if (event->proposedAction() == Qt::DropAction::MoveAction)  {
        if (coord < mDragSelBeginSave ) {
            //delete old
            doDeleteText(mDragSelBeginSave,mDragSelEndSave,mActiveSelectionMode);
            //paste to new position
            doInsertText(coord,text,mActiveSelectionMode,coord.line,coord.line+text.length()-1);
        } else {
            //paste to new position
            doInsertText(coord,text,mActiveSelectionMode,coord.line,coord.line+text.length()-1);
            //delete old
            doDeleteText(mDragSelBeginSave,mDragSelEndSave,mActiveSelectionMode);
            //set caret to right pos
            if (mDragSelBeginSave.line == mDragSelEndSave.line) {
                if (coord.line == mDragSelEndSave.line) {
                    coord.ch -= mDragSelEndSave.ch-mDragSelBeginSave.ch;
                }
            } else {
                if (coord.line == mDragSelEndSave.line) {
                    coord.ch -= mDragSelEndSave.ch-1;
                } else {
                    coord.line -= mDragSelEndSave.line-mDragSelBeginSave.line;
                    topLine -= mDragSelEndSave.line-mDragSelBeginSave.line;
                }
            }
        }
        mUndoList->endBlock();

    }
    event->acceptProposedAction();
    mDropped = true;
    setTopLine(topLine);
    setLeftChar(leftChar);
    internalSetCaretXY(coord);
}

void SynEdit::dragMoveEvent(QDragMoveEvent *event)
{
    if (event->keyboardModifiers() ==  Qt::ControlModifier) {
        event->setDropAction(Qt::CopyAction);
    } else {
        event->setDropAction(Qt::MoveAction);
    }
    // should we begin scrolling?
//    computeScroll(event->pos().x(),
//                  event->pos().y(),true);

    QPoint iMousePos = QCursor::pos();
    iMousePos = mapFromGlobal(iMousePos);
    int X=iMousePos.x();
    int Y=iMousePos.y();
    BufferCoord coord = displayToBufferPos(pixelsToNearestRowColumn(X,Y));
    internalSetCaretXY(coord);
    setBlockBegin(mDragSelBeginSave);
    setBlockEnd(mDragSelEndSave);
    showCaret();
}

void SynEdit::dragLeaveEvent(QDragLeaveEvent *)
{
//    setCaretXY(mDragCaretSave);
//    setBlockBegin(mDragSelBeginSave);
//    setBlockEnd(mDragSelEndSave);
    //    showCaret();
}

int SynEdit::maxScrollHeight() const
{
    if (mOptions.testFlag(eoScrollPastEof))
        return std::max(displayLineCount(),1);
    else
        return std::max(displayLineCount()-mLinesInWindow+1, 1);
}

bool SynEdit::modified() const
{
    return mModified;
}

void SynEdit::setModified(bool Value)
{
    if (Value) {
        mLastModifyTime = QDateTime::currentDateTime();
        emit statusChanged(SynStatusChange::scModified);
    }
    if (Value != mModified) {
        mModified = Value;
        if (mOptions.testFlag(SynEditorOption::eoGroupUndo) && (!Value) ) {
            mUndoList->addGroupBreak();
        }
        mUndoList->setInitialState(!Value);
        emit statusChanged(SynStatusChange::scModifyChanged);
    }
}

int SynEdit::gutterWidth() const
{
    return mGutterWidth;
}

void SynEdit::setGutterWidth(int Value)
{
    Value = std::max(Value, 0);
    if (mGutterWidth != Value) {
        mGutterWidth = Value;
        onSizeOrFontChanged(false);
        invalidate();
    }
}

int SynEdit::charWidth() const
{
    return mCharWidth;
}

void SynEdit::setUndoLimit(int size)
{
    mUndoList->setMaxUndoActions(size);

    mRedoList->setMaxUndoActions(size);
}

int SynEdit::charsInWindow() const
{
    return mCharsInWindow;
}

void SynEdit::onBookMarkOptionsChanged()
{
    invalidateGutter();
}

void SynEdit::onLinesChanged()
{
    SynSelectionMode vOldMode;
    mStateFlags.setFlag(SynStateFlag::sfLinesChanging, false);

    updateScrollbars();
    if (mActiveSelectionMode == SynSelectionMode::Column) {
        BufferCoord oldBlockStart = blockBegin();
        BufferCoord oldBlockEnd = blockEnd();
        oldBlockStart.ch = mCaretX;
        int colEnd = charToColumn(oldBlockStart.line,oldBlockStart.ch);
        int charEnd = columnToChar(oldBlockEnd.line,colEnd);
        oldBlockEnd.ch =  charEnd;
        setBlockBegin(oldBlockStart);
        setBlockEnd(oldBlockEnd);
    } else {
        vOldMode = mActiveSelectionMode;
        setBlockBegin(caretXY());
        mActiveSelectionMode = vOldMode;
    }
    if (mInvalidateRect.width()==0)
        invalidate();
    else
        invalidateRect(mInvalidateRect);
    mInvalidateRect = {0,0,0,0};
    if (mGutter.showLineNumbers() && (mGutter.autoSize()))
        mGutter.autoSizeDigitCount(mDocument->count());
    //if (!mOptions.testFlag(SynEditorOption::eoScrollPastEof))
    setTopLine(mTopLine);
}

void SynEdit::onLinesChanging()
{
    mStateFlags.setFlag(SynStateFlag::sfLinesChanging);
}

void SynEdit::onLinesCleared()
{
    if (mUseCodeFolding)
        foldOnListCleared();
    clearUndo();
    // invalidate the *whole* client area
    mInvalidateRect={0,0,0,0};
    invalidate();
    // set caret and selected block to start of text
    setCaretXY({1,1});
    // scroll to start of text
    setTopLine(1);
    setLeftChar(1);
    mStatusChanges.setFlag(SynStatusChange::scAll);
}

void SynEdit::onLinesDeleted(int index, int count)
{
    if (mUseCodeFolding)
        foldOnListDeleted(index + 1, count);
    if (mHighlighter && mDocument->count() > 0)
        scanFrom(index, index+1);
    invalidateLines(index + 1, INT_MAX);
    invalidateGutterLines(index + 1, INT_MAX);
}

void SynEdit::onLinesInserted(int index, int count)
{
    if (mUseCodeFolding)
        foldOnListInserted(index + 1, count);
    if (mHighlighter && mDocument->count() > 0) {
//        int vLastScan = index;
//        do {
          scanFrom(index, index+count);
//            vLastScan++;
//        } while (vLastScan < index + count) ;
    }
    invalidateLines(index + 1, INT_MAX);
    invalidateGutterLines(index + 1, INT_MAX);
}

void SynEdit::onLinesPutted(int index, int count)
{
    int vEndLine = index + 1;
    if (mHighlighter) {
        vEndLine = std::max(vEndLine, scanFrom(index, index+count) + 1);
    }
    invalidateLines(index + 1, vEndLine);
}

void SynEdit::onUndoAdded()
{
    updateModifiedStatus();

    // we have to clear the redo information, since adding undo info removes
    // the necessary context to undo earlier edit actions
    if (! mUndoList->insideRedo() &&
            mUndoList->peekItem() && (mUndoList->peekItem()->changeReason()!=SynChangeReason::GroupBreak))
        mRedoList->clear();
    if (mUndoList->blockCount() == 0 )
        onChanged();
}

SynSelectionMode SynEdit::activeSelectionMode() const
{
    return mActiveSelectionMode;
}

void SynEdit::setActiveSelectionMode(const SynSelectionMode &Value)
{
    if (mActiveSelectionMode != Value) {
        if (selAvail())
            invalidateSelection();
        mActiveSelectionMode = Value;
        if (selAvail())
            invalidateSelection();
        setStatusChanged(SynStatusChange::scSelection);
    }
}

BufferCoord SynEdit::blockEnd() const
{
    if (mActiveSelectionMode==SynSelectionMode::Column)
        return mBlockEnd;
    if ((mBlockEnd.line < mBlockBegin.line)
      || ((mBlockEnd.line == mBlockBegin.line) && (mBlockEnd.ch < mBlockBegin.ch)))
        return mBlockBegin;
    else
        return mBlockEnd;
}

void SynEdit::setBlockEnd(BufferCoord Value)
{
    //setActiveSelectionMode(mSelectionMode);
    Value.line = minMax(Value.line, 1, mDocument->count());
    if (mActiveSelectionMode == SynSelectionMode::Normal) {
      if (Value.line >= 1 && Value.line <= mDocument->count())
          Value.ch = std::min(Value.ch, getDisplayStringAtLine(Value.line).length() + 1);
      else
          Value.ch = 1;
    } else {
        int maxLen = mDocument->lengthOfLongestLine();
        if (highlighter())
            maxLen = maxLen+stringColumns(highlighter()->foldString(),maxLen);
        Value.ch = minMax(Value.ch, 1, maxLen+1);
    }
    if (Value.ch != mBlockEnd.ch || Value.line != mBlockEnd.line) {
        if (mActiveSelectionMode == SynSelectionMode::Column && Value.ch != mBlockEnd.ch) {
            invalidateLines(
                        std::min(mBlockBegin.line, std::min(mBlockEnd.line, Value.line)),
                        std::max(mBlockBegin.line, std::max(mBlockEnd.line, Value.line)));
            mBlockEnd = Value;
        } else {
            int nLine = mBlockEnd.line;
            mBlockEnd = Value;
            if (mActiveSelectionMode != SynSelectionMode::Column || mBlockBegin.ch != mBlockEnd.ch)
                invalidateLines(nLine, mBlockEnd.line);
        }
        setStatusChanged(SynStatusChange::scSelection);
    }
}

void SynEdit::setSelLength(int Value)
{
    if (mBlockBegin.line>mDocument->count() || mBlockBegin.line<=0)
        return;

    if (Value >= 0) {
        int y = mBlockBegin.line;
        int ch = mBlockBegin.ch;
        int x = ch + Value;
        QString line;
        while (y<=mDocument->count()) {
            line = mDocument->getString(y-1);
            if (x <= line.length()+2) {
                if (x==line.length()+2)
                    x = line.length()+1;
                break;
            }
            x -= line.length()+2;
            y ++;
        }
        if (y>mDocument->count()) {
            y = mDocument->count();
            x = mDocument->getString(y-1).length()+1;
        }
        BufferCoord iNewEnd{x,y};
        setCaretAndSelection(iNewEnd, mBlockBegin, iNewEnd);
    } else {
        int y = mBlockBegin.line;
        int ch = mBlockBegin.ch;
        int x = ch + Value;
        QString line;
        while (y>=1) {
            if (x>=0) {
                if (x==0)
                    x = 1;
                break;
            }
            y--;
            line = mDocument->getString(y-1);
            x += line.length()+2;
        }
        if (y>mDocument->count()) {
            y = mDocument->count();
            x = mDocument->getString(y-1).length()+1;
        }
        BufferCoord iNewStart{x,y};
        setCaretAndSelection(iNewStart, iNewStart, mBlockBegin);
    }
}

void SynEdit::setSelText(const QString &text)
{
    doSetSelText(text);
}

BufferCoord SynEdit::blockBegin() const
{
    if (mActiveSelectionMode==SynSelectionMode::Column)
        return mBlockBegin;
    if ((mBlockEnd.line < mBlockBegin.line)
      || ((mBlockEnd.line == mBlockBegin.line) && (mBlockEnd.ch < mBlockBegin.ch)))
        return mBlockEnd;
    else
        return mBlockBegin;
}

void SynEdit::setBlockBegin(BufferCoord value)
{
    int nInval1, nInval2;
    bool SelChanged;
    //setActiveSelectionMode(mSelectionMode);
    value.line = minMax(value.line, 1, mDocument->count());
    if (mActiveSelectionMode == SynSelectionMode::Normal) {
        if (value.line >= 1 && value.line <= mDocument->count())
            value.ch = std::min(value.ch, getDisplayStringAtLine(value.line).length() + 1);
        else
            value.ch = 1;
    } else {
        int maxLen = mDocument->lengthOfLongestLine();
        if (highlighter())
            maxLen = maxLen+stringColumns(highlighter()->foldString(),maxLen);
        value.ch = minMax(value.ch, 1, maxLen+1);
    }
    if (selAvail()) {
        if (mBlockBegin.line < mBlockEnd.line) {
            nInval1 = std::min(value.line, mBlockBegin.line);
            nInval2 = std::max(value.line, mBlockEnd.line);
        } else {
            nInval1 = std::min(value.line, mBlockEnd.line);
            nInval2 = std::max(value.line, mBlockBegin.line);
        };
        mBlockBegin = value;
        mBlockEnd = value;
        invalidateLines(nInval1, nInval2);
        SelChanged = true;
    } else {
        SelChanged =
          (mBlockBegin.ch != value.ch) || (mBlockBegin.line != value.line) ||
          (mBlockEnd.ch != value.ch) || (mBlockEnd.line != value.line);
        mBlockBegin = value;
        mBlockEnd = value;
    }
    if (SelChanged)
        setStatusChanged(SynStatusChange::scSelection);
}

int SynEdit::leftChar() const
{
    return mLeftChar;
}

void SynEdit::setLeftChar(int Value)
{
    //int MaxVal;
    //QRect iTextArea;
    Value = std::min(Value,maxScrollWidth());
    if (Value != mLeftChar) {
        horizontalScrollBar()->setValue(Value);
        setStatusChanged(SynStatusChange::scLeftChar);
    }
}

int SynEdit::linesInWindow() const
{
    return mLinesInWindow;
}

int SynEdit::topLine() const
{
    return mTopLine;
}

void SynEdit::setTopLine(int Value)
{
    Value = std::min(Value,maxScrollHeight());
//    if (mOptions.testFlag(SynEditorOption::eoScrollPastEof))
//        Value = std::min(Value, displayLineCount());
//    else
//        Value = std::min(Value, displayLineCount() - mLinesInWindow + 1);
    Value = std::max(Value, 1);
    if (Value != mTopLine) {
        verticalScrollBar()->setValue(Value);
        setStatusChanged(SynStatusChange::scTopLine);
    }
}

void SynEdit::onRedoAdded()
{
    updateModifiedStatus();

    if (mRedoList->blockCount() == 0 )
        onChanged();
}

void SynEdit::onGutterChanged()
{
    if (mGutter.showLineNumbers() && mGutter.autoSize())
        mGutter.autoSizeDigitCount(mDocument->count());
    int nW;
    if (mGutter.useFontStyle()) {
        QFontMetrics fm=QFontMetrics(mGutter.font());
        nW = mGutter.realGutterWidth(fm.averageCharWidth());
    } else {
        nW = mGutter.realGutterWidth(mCharWidth);
    }
    if (nW == mGutterWidth)
        invalidateGutter();
    else
        setGutterWidth(nW);
}

void SynEdit::onScrollTimeout()
{
    doMouseScroll(false);
}

void SynEdit::onDraggingScrollTimeout()
{
    doMouseScroll(true);
}