vnote/src/veditor.cpp

#include "veditor.h"

#include <QtWidgets>
#include <QTextDocument>

#include "vconfigmanager.h"
#include "utils/vutils.h"
#include "utils/veditutils.h"
#include "veditoperations.h"
#include "dialog/vinsertlinkdialog.h"
#include "utils/vmetawordmanager.h"
#include "utils/vvim.h"

extern VConfigManager *g_config;

extern VMetaWordManager *g_mwMgr;

VEditor::VEditor(VFile *p_file,
                 QWidget *p_editor,
                 const QSharedPointer<VTextEditCompleter> &p_completer)
    : m_editor(p_editor),
      m_object(new VEditorObject(this, p_editor)),
      m_file(p_file),
      m_editOps(nullptr),
      m_document(nullptr),
      m_enableInputMethod(true),
      m_timeStamp(0),
      m_trailingSpaceSelectionTS(0),
      m_completer(p_completer),
      m_trailingSpaceHighlightEnabled(false),
      m_tabHighlightEnabled(false)
{
}

VEditor::~VEditor()
{
    if (m_completer->widget() == m_editor) {
        m_completer->setWidget(NULL);
    }

    cleanUp();
}

void VEditor::cleanUp()
{
    for (auto const & file : m_tempFiles) {
        VUtils::deleteFile(file);
    }

    m_tempFiles.clear();
}

void VEditor::init()
{
    const int labelTimerInterval = 500;
    const int extraSelectionHighlightTimer = 500;
    const int trailingSpaceUpdateTimer = 500;
    const int labelSize = 64;

    m_document = documentW();
    QObject::connect(m_document, &QTextDocument::contentsChanged,
                     m_object, &VEditorObject::clearFindCache);

    m_selectedWordFg = QColor(g_config->getEditorSelectedWordFg());
    m_selectedWordBg = QColor(g_config->getEditorSelectedWordBg());

    m_searchedWordFg = QColor(g_config->getEditorSearchedWordFg());
    m_searchedWordBg = QColor(g_config->getEditorSearchedWordBg());

    m_searchedWordCursorFg = QColor(g_config->getEditorSearchedWordCursorFg());
    m_searchedWordCursorBg = QColor(g_config->getEditorSearchedWordCursorBg());

    m_incrementalSearchedWordFg = QColor(g_config->getEditorIncrementalSearchedWordFg());
    m_incrementalSearchedWordBg = QColor(g_config->getEditorIncrementalSearchedWordBg());

    m_trailingSpaceColor = QColor(g_config->getEditorTrailingSpaceBg());

    m_tabColor = g_config->getMdEditPalette().color(QPalette::Text);

    QPixmap wrapPixmap(":/resources/icons/search_wrap.svg");
    m_wrapLabel = new QLabel(m_editor);
    m_wrapLabel->setPixmap(wrapPixmap.scaled(labelSize, labelSize));
    m_wrapLabel->hide();
    m_labelTimer = new QTimer(m_editor);
    m_labelTimer->setSingleShot(true);
    m_labelTimer->setInterval(labelTimerInterval);
    QObject::connect(m_labelTimer, &QTimer::timeout,
                     m_object, &VEditorObject::labelTimerTimeout);

    m_highlightTimer = new QTimer(m_editor);
    m_highlightTimer->setSingleShot(true);
    m_highlightTimer->setInterval(extraSelectionHighlightTimer);
    QObject::connect(m_highlightTimer, &QTimer::timeout,
                     m_object, &VEditorObject::doHighlightExtraSelections);

    m_trailingSpaceTimer = new QTimer(m_editor);
    m_trailingSpaceTimer->setSingleShot(true);
    m_trailingSpaceTimer->setInterval(trailingSpaceUpdateTimer);
    QObject::connect(m_trailingSpaceTimer, &QTimer::timeout,
                     m_object, &VEditorObject::doUpdateTrailingSpaceAndTabHighlights);

    m_extraSelections.resize((int)SelectionId::MaxSelection);

    updateFontAndPalette();

    m_config.init(QFontMetrics(m_editor->font()), false);
    updateEditConfig();
}

void VEditor::labelTimerTimeout()
{
    m_wrapLabel->hide();
}

bool VEditor::needUpdateTrailingSpaceAndTabHighlights()
{
    bool ret = false;
    bool space = g_config->getEnableTrailingSpaceHighlight();
    if (m_trailingSpaceHighlightEnabled != space) {
        m_trailingSpaceHighlightEnabled = space;
        ret = true;
    }

    bool tab = g_config->getEnableTabHighlight();
    if (m_tabHighlightEnabled != tab) {
        m_tabHighlightEnabled = tab;
        ret = true;
    }

    if (m_trailingSpaceSelectionTS != m_timeStamp) {
        ret = true;
    }

    return ret;
}

void VEditor::updateTrailingSpaceAndTabHighlights()
{
    if (needUpdateTrailingSpaceAndTabHighlights()) {
        m_trailingSpaceTimer->start();
    } else {
        highlightExtraSelections(false);
    }
}

void VEditor::doHighlightExtraSelections()
{
    int nrExtra = m_extraSelections.size();
    Q_ASSERT(nrExtra == (int)SelectionId::MaxSelection);
    QList<QTextEdit::ExtraSelection> extraSelects;
    for (int i = 0; i < nrExtra; ++i) {
        if (i == (int)SelectionId::TrailingSpace) {
            filterTrailingSpace(extraSelects, m_extraSelections[i]);
        } else {
            extraSelects.append(m_extraSelections[i]);
        }
    }

    setExtraSelectionsW(extraSelects);
}

void VEditor::doUpdateTrailingSpaceAndTabHighlights()
{
    bool needHighlight = false;

    // Trailing space.
    if (!m_trailingSpaceHighlightEnabled) {
        QList<QTextEdit::ExtraSelection> &selects = m_extraSelections[(int)SelectionId::TrailingSpace];
        if (!selects.isEmpty()) {
            selects.clear();
            needHighlight = true;
        }
    } else {
        needHighlight = true;
        QTextCharFormat format;
        format.setBackground(m_trailingSpaceColor);
        QString text("\\s+$");
        highlightTextAll(text,
                         FindOption::RegularExpression,
                         SelectionId::TrailingSpace,
                         format);
    }

    // Tab.
    if (!m_tabHighlightEnabled) {
        QList<QTextEdit::ExtraSelection> &selects = m_extraSelections[(int)SelectionId::Tab];
        if (!selects.isEmpty()) {
            selects.clear();
            needHighlight = true;
        }
    } else {
        needHighlight = true;
        QTextCharFormat format;
        format.setBackground(m_tabColor);
        QString text("\\t");
        highlightTextAll(text,
                         FindOption::RegularExpression,
                         SelectionId::Tab,
                         format);
    }

    m_trailingSpaceSelectionTS = m_timeStamp;

    if (needHighlight) {
        highlightExtraSelections(true);
    }
}

void VEditor::updateEditConfig()
{
    m_config.update(QFontMetrics(m_editor->font()));

    if (m_config.m_tabStopWidth > 0) {
        setTabStopWidthW(m_config.m_tabStopWidth);
    }

    emit m_object->configUpdated();
}

void VEditor::highlightOnCursorPositionChanged()
{
    static QTextCursor lastCursor;

    QTextCursor cursor = textCursorW();
    if (lastCursor.isNull() || cursor.blockNumber() != lastCursor.blockNumber()) {
        updateTrailingSpaceAndTabHighlights();
        highlightCurrentLine();
    } else {
        // Judge whether we have trailing space at current line.
        QString text = cursor.block().text();
        if (!text.isEmpty()) {
            auto it = text.rbegin();
            bool needUpdate = it->isSpace();
            if (!needUpdate
                && cursor.atBlockEnd()
                && text.size() > 1) {
                ++it;
                needUpdate = it->isSpace();
                // Input two chars at once in Chinese.
                if (!needUpdate && text.size() > 2) {
                    ++it;
                    needUpdate = it->isSpace();
                }
            }

            if (needUpdate) {
                updateTrailingSpaceAndTabHighlights();
            }
        }

        // Handle word-wrap in one block.
        // Highlight current line if in different visual line.
        if ((lastCursor.positionInBlock() - lastCursor.columnNumber()) !=
            (cursor.positionInBlock() - cursor.columnNumber())) {
            highlightCurrentLine();
        }
    }

    lastCursor = cursor;
}

void VEditor::updateTimeStamp()
{
    ++m_timeStamp;
}

void VEditor::highlightCurrentLine()
{
    QList<QTextEdit::ExtraSelection> &selects = m_extraSelections[(int)SelectionId::CurrentLine];
    if (g_config->getHighlightCursorLine()) {
        // Need to highlight current line.
        selects.clear();

        // A long block maybe splited into multiple visual lines.
        QTextEdit::ExtraSelection select;
        select.format.setBackground(m_config.m_cursorLineBg);
        select.format.setProperty(QTextFormat::FullWidthSelection, true);

        QTextCursor cursor = textCursorW();
        if (m_config.m_highlightWholeBlock) {
            cursor.movePosition(QTextCursor::StartOfBlock, QTextCursor::MoveAnchor, 1);
            QTextBlock block = cursor.block();
            int blockEnd = block.position() + block.length();
            int pos = -1;
            while (cursor.position() < blockEnd && pos != cursor.position()) {
                QTextEdit::ExtraSelection newSelect = select;
                newSelect.cursor = cursor;
                selects.append(newSelect);

                pos = cursor.position();
                cursor.movePosition(QTextCursor::Down, QTextCursor::MoveAnchor, 1);
            }
        } else {
            cursor.clearSelection();
            select.cursor = cursor;
            selects.append(select);
        }
    } else {
        // Need to clear current line highlight.
        if (selects.isEmpty()) {
            return;
        }

        selects.clear();
    }

    highlightExtraSelections(true);
}

void VEditor::filterTrailingSpace(QList<QTextEdit::ExtraSelection> &p_selects,
                                  const QList<QTextEdit::ExtraSelection> &p_src)
{
    QTextCursor cursor = textCursorW();
    bool blockEnd = cursor.atBlockEnd();
    int blockNum = cursor.blockNumber();
    for (auto it = p_src.begin(); it != p_src.end(); ++it) {
        if (it->cursor.blockNumber() == blockNum) {
            if (blockEnd) {
                // When cursor is at block end, we do not display any trailing space
                // at current line.
                continue;
            }

            QString text = cursor.block().text();
            if (text.isEmpty()) {
                continue;
            } else if (!text[text.size() - 1].isSpace()) {
                continue;
            }
        }

        p_selects.append(*it);
    }
}

void VEditor::highlightExtraSelections(bool p_now)
{
    m_highlightTimer->stop();
    if (p_now) {
        doHighlightExtraSelections();
    } else {
        m_highlightTimer->start();
    }
}

void VEditor::highlightTextAll(const QString &p_text,
                               uint p_options,
                               SelectionId p_id,
                               QTextCharFormat p_format,
                               void (*p_filter)(VEditor *,
                                                QList<QTextEdit::ExtraSelection> &))
{
    QList<QTextEdit::ExtraSelection> &selects = m_extraSelections[(int)p_id];
    if (!p_text.isEmpty()) {
        selects.clear();

        QList<QTextCursor> occurs = findTextAll(p_text, p_options);
        for (int i = 0; i < occurs.size(); ++i) {
            QTextEdit::ExtraSelection select;
            select.format = p_format;
            select.cursor = occurs[i];
            selects.append(select);
        }
    } else {
        if (selects.isEmpty()) {
            return;
        }
        selects.clear();
    }

    if (p_filter) {
        p_filter(this, selects);
    }

    highlightExtraSelections();
}

static QTextDocument::FindFlags findOptionsToFlags(uint p_options, bool p_forward)
{
    QTextDocument::FindFlags findFlags;

    if (p_options & FindOption::CaseSensitive) {
        findFlags |= QTextDocument::FindCaseSensitively;
    }

    if (p_options & FindOption::WholeWordOnly) {
        findFlags |= QTextDocument::FindWholeWords;
    }

    if (!p_forward) {
        findFlags |= QTextDocument::FindBackward;
    }

    return findFlags;
}

QList<QTextCursor> VEditor::findTextAll(const QString &p_text,
                                        uint p_options,
                                        int p_start,
                                        int p_end)
{
    QList<QTextCursor> results;
    if (p_text.isEmpty()) {
        return results;
    }

    // Options
    bool caseSensitive = p_options & FindOption::CaseSensitive;
    QTextDocument::FindFlags findFlags = findOptionsToFlags(p_options, true);

    if (p_options & FindOption::RegularExpression) {
        QRegExp exp(p_text,
                    caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive);
        results = findTextAllInRange(m_document, exp, findFlags, p_start, p_end);
    } else {
        results = findTextAllInRange(m_document, p_text, findFlags, p_start, p_end);
    }

    return results;
}

static void mergeResult(QList<QTextCursor> &p_result, const QList<QTextCursor> &p_part)
{
    if (p_result.isEmpty()) {
        p_result = p_part;
        return;
    }

    int idx = 0;
    for (auto const & cur : p_part) {
        // Find position to insert into @p_result.
        while (idx < p_result.size()) {
            const QTextCursor &toCur = p_result[idx];
            if (cur.selectionEnd() <= toCur.selectionStart()) {
                // Insert it before toCur.
                p_result.insert(idx, cur);
                ++idx;
                break;
            } else if (cur.selectionStart() < toCur.selectionEnd()) {
                // Interleave. Abandon it.
                break;
            } else {
                ++idx;
            }
        }

        // Insert to the end.
        if (idx >= p_result.size()) {
            p_result.append(cur);
            idx = p_result.size();
        }
    }
}

QList<QTextCursor> VEditor::findTextAll(const VSearchToken &p_token,
                                        int p_start,
                                        int p_end)
{
    QList<QTextCursor> results;
    if (p_token.isEmpty()) {
        return results;
    }

    QTextDocument::FindFlags flags;
    if (p_token.m_caseSensitivity == Qt::CaseSensitive) {
        flags |= QTextDocument::FindCaseSensitively;
    }

    if (p_token.m_type == VSearchToken::RawString) {
        for (auto const & wd : p_token.m_keywords) {
            QList<QTextCursor> part = findTextAllInRange(m_document, wd, flags, p_start, p_end);
            mergeResult(results, part);
        }
    } else {
        // Regular expression.
        for (auto const & reg : p_token.m_regs) {
            QList<QTextCursor> part = findTextAllInRange(m_document, reg, flags, p_start, p_end);
            mergeResult(results, part);
        }
    }

    return results;
}

const QList<QTextCursor> &VEditor::findTextAllCached(const QString &p_text,
                                                     uint p_options,
                                                     int p_start,
                                                     int p_end)
{
    if (p_text.isEmpty()) {
        m_findInfo.clear();
        return m_findInfo.m_result;
    }

    if (m_findInfo.isCached(p_text, p_options, p_start, p_end)) {
        return m_findInfo.m_result;
    }

    QList<QTextCursor> result = findTextAll(p_text, p_options, p_start, p_end);
    m_findInfo.update(p_text, p_options, p_start, p_end, result);

    return m_findInfo.m_result;
}

const QList<QTextCursor> &VEditor::findTextAllCached(const VSearchToken &p_token,
                                                     int p_start,
                                                     int p_end)
{
    if (p_token.isEmpty()) {
        m_findInfo.clear();
        return m_findInfo.m_result;
    }

    if (m_findInfo.isCached(p_token, p_start, p_end)) {
        return m_findInfo.m_result;
    }

    QList<QTextCursor> result = findTextAll(p_token, p_start, p_end);
    m_findInfo.update(p_token, p_start, p_end, result);

    return m_findInfo.m_result;
}

void VEditor::highlightSelectedWord()
{
    QList<QTextEdit::ExtraSelection> &selects = m_extraSelections[(int)SelectionId::SelectedWord];
    if (!g_config->getHighlightSelectedWord()) {
        if (!selects.isEmpty()) {
            selects.clear();
            highlightExtraSelections(true);
        }

        return;
    }

    QString text = textCursorW().selectedText().trimmed();
    if (text.isEmpty() || wordInSearchedSelection(text)) {
        selects.clear();
        highlightExtraSelections(true);
        return;
    }

    QTextCharFormat format;
    format.setForeground(m_selectedWordFg);
    format.setBackground(m_selectedWordBg);
    highlightTextAll(text,
                     FindOption::CaseSensitive,
                     SelectionId::SelectedWord,
                     format);
}

bool VEditor::wordInSearchedSelection(const QString &p_text)
{
    QString text = p_text.trimmed();
    QList<QTextEdit::ExtraSelection> &selects = m_extraSelections[(int)SelectionId::SearchedKeyword];
    for (int i = 0; i < selects.size(); ++i) {
        QString searchedWord = selects[i].cursor.selectedText();
        if (text == searchedWord.trimmed()) {
            return true;
        }
    }

    return false;
}

bool VEditor::isModified() const
{
    return m_document->isModified();
}

void VEditor::setModified(bool p_modified)
{
    m_document->setModified(p_modified);
}

void VEditor::insertImage()
{
    if (m_editOps) {
        m_editOps->insertImage();
    }
}

void VEditor::insertLink()
{
    if (!m_editOps) {
        return;
    }

    QString text;
    QString linkText, linkUrl;
    QTextCursor cursor = textCursorW();
    if (cursor.hasSelection()) {
        text = VEditUtils::selectedText(cursor).trimmed();
        // Only pure space is accepted.
        QRegExp reg("[\\S ]*");
        if (reg.exactMatch(text)) {
            QUrl url = QUrl::fromUserInput(text,
                                           m_file->fetchBasePath());
            QRegExp urlReg("[\\.\\\\/]");
            if (url.isValid()
                && text.contains(urlReg)) {
                // Url.
                linkUrl = text;
            } else {
                // Text.
                linkText = text;
            }
        }
    }

    VInsertLinkDialog dialog(QObject::tr("Insert Link"),
                             "",
                             "",
                             linkText,
                             linkUrl,
                             false,
                             m_editor);
    if (dialog.exec() == QDialog::Accepted) {
        linkText = dialog.getLinkText();
        linkUrl = dialog.getLinkUrl();
        Q_ASSERT(!linkText.isEmpty() && !linkUrl.isEmpty());

        m_editOps->insertLink(linkText, linkUrl);
    }
}

bool VEditor::peekText(const QString &p_text, uint p_options, bool p_forward)
{
    if (p_text.isEmpty()) {
        makeBlockVisible(m_document->findBlock(textCursorW().selectionStart()));
        highlightIncrementalSearchedWord(QTextCursor());
        return false;
    }

    bool wrapped = false;
    QTextCursor retCursor;
    int start = textCursorW().position();
    int skipPosition = start;

    bool found = false;
    while (true) {
        found = findTextHelper(p_text, p_options, p_forward, start, wrapped, retCursor);
        if (found) {
            if (p_forward && retCursor.selectionStart() == skipPosition) {
                // Skip the first match.
                skipPosition = -1;
                start = retCursor.selectionEnd();
                continue;
            }

            makeBlockVisible(m_document->findBlock(retCursor.selectionStart()));
            highlightIncrementalSearchedWord(retCursor);
        }

        break;
    }

    return found;
}

// @p_cursors is in ascending order.
// If @p_forward is true, find the smallest cursor whose selection start is greater
// than @p_pos or the first cursor if wrapped.
// Otherwise, find the largest cursor whose selection start is smaller than @p_pos
// or the last cursor if wrapped.
static int selectCursor(const QList<QTextCursor> &p_cursors,
                        int p_pos,
                        bool p_forward,
                        bool &p_wrapped)
{
    Q_ASSERT(!p_cursors.isEmpty());

    p_wrapped = false;

    int first = 0, last = p_cursors.size() - 1;
    int lastMatch = -1;
    while (first <= last) {
        int mid = (first + last) / 2;
        const QTextCursor &cur = p_cursors.at(mid);
        if (p_forward) {
            if (cur.selectionStart() < p_pos) {
                first = mid + 1;
            } else if (cur.selectionStart() == p_pos) {
                // Next one is the right one.
                if (mid < p_cursors.size() - 1) {
                    lastMatch = mid + 1;
                } else {
                    lastMatch = 0;
                    p_wrapped = true;
                }
                break;
            } else {
                // It is a match.
                if (lastMatch == -1 || mid < lastMatch) {
                    lastMatch = mid;
                }

                last = mid - 1;
            }
        } else {
            if (cur.selectionStart() > p_pos) {
                last = mid - 1;
            } else if (cur.selectionStart() == p_pos) {
                // Previous one is the right one.
                if (mid > 0) {
                    lastMatch = mid - 1;
                } else {
                    lastMatch = p_cursors.size() - 1;
                    p_wrapped = true;
                }
                break;
            } else {
                // It is a match.
                if (lastMatch == -1 || mid > lastMatch) {
                    lastMatch = mid;
                }

                first = mid + 1;
            }
        }
    }

    if (lastMatch == -1) {
        p_wrapped = true;
        lastMatch = p_forward ? 0 : (p_cursors.size() - 1);
    }

    return lastMatch;
}

bool VEditor::findText(const QString &p_text,
                       uint p_options,
                       bool p_forward,
                       QTextCursor *p_cursor,
                       QTextCursor::MoveMode p_moveMode,
                       bool p_useLeftSideOfCursor)
{
    return findTextInRange(p_text,
                           p_options,
                           p_forward,
                           p_cursor,
                           p_moveMode,
                           p_useLeftSideOfCursor);
}

bool VEditor::findText(const VSearchToken &p_token, bool p_forward, bool p_fromStart)
{
    clearIncrementalSearchedWordHighlight();

    if (p_token.isEmpty()) {
        m_findInfo.clear();
        clearSearchedWordHighlight();
        return false;
    }

    const QList<QTextCursor> &result = findTextAllCached(p_token);

    if (result.isEmpty()) {
        clearSearchedWordHighlight();

        emit m_object->statusMessage(QObject::tr("No match found"));
    } else {
        // Locate to the right match and update current cursor.
        QTextCursor cursor = textCursorW();
        int pos = p_fromStart ? (m_document->characterCount() + 1) : cursor.position();
        bool wrapped = false;
        int idx = selectCursor(result, pos, p_forward, wrapped);
        const QTextCursor &tcursor = result.at(idx);
        if (wrapped && !p_fromStart) {
            showWrapLabel();
        }

        cursor.setPosition(tcursor.selectionStart(), QTextCursor::MoveAnchor);
        setTextCursorW(cursor);

        highlightSearchedWord(result);

        highlightSearchedWordUnderCursor(tcursor);

        emit m_object->statusMessage(QObject::tr("Match found: %1 of %2")
                                                .arg(idx + 1)
                                                .arg(result.size()));
    }

    return !result.isEmpty();
}

bool VEditor::findTextInRange(const QString &p_text,
                              uint p_options,
                              bool p_forward,
                              QTextCursor *p_cursor,
                              QTextCursor::MoveMode p_moveMode,
                              bool p_useLeftSideOfCursor,
                              int p_start,
                              int p_end)
{
    clearIncrementalSearchedWordHighlight();

    if (p_text.isEmpty()) {
        m_findInfo.clear();
        clearSearchedWordHighlight();
        return false;
    }

    const QList<QTextCursor> &result = findTextAllCached(p_text, p_options, p_start, p_end);

    if (result.isEmpty()) {
        clearSearchedWordHighlight();

        emit m_object->statusMessage(QObject::tr("No match found"));
    } else {
        // Locate to the right match and update current cursor.
        QTextCursor cursor = textCursorW();
        int pos = p_cursor ? p_cursor->position() : cursor.position();
        if (p_useLeftSideOfCursor) {
            --pos;
        }

        bool wrapped = false;
        int idx = selectCursor(result, pos, p_forward, wrapped);
        const QTextCursor &tcursor = result.at(idx);
        if (wrapped) {
            showWrapLabel();
        }

        if (p_cursor) {
            p_cursor->setPosition(tcursor.selectionStart(), p_moveMode);
        } else {
            cursor.setPosition(tcursor.selectionStart(), p_moveMode);
            setTextCursorW(cursor);
        }

        highlightSearchedWord(result);

        highlightSearchedWordUnderCursor(tcursor);

        emit m_object->statusMessage(QObject::tr("Match found: %1 of %2")
                                                .arg(idx + 1)
                                                .arg(result.size()));
    }

    return !result.isEmpty();
}

bool VEditor::findTextOne(const QString &p_text, uint p_options, bool p_forward)
{
    clearIncrementalSearchedWordHighlight();

    if (p_text.isEmpty()) {
        clearSearchedWordHighlight();
        return false;
    }

    QTextCursor cursor = textCursorW();
    bool wrapped = false;
    QTextCursor retCursor;
    int start = cursor.position();
    bool found = findTextHelper(p_text, p_options, p_forward, start, wrapped, retCursor);
    if (found) {
        Q_ASSERT(!retCursor.isNull());
        if (wrapped) {
            showWrapLabel();
        }

        cursor.setPosition(retCursor.selectionStart(), QTextCursor::MoveAnchor);
        setTextCursorW(cursor);

        highlightSearchedWordUnderCursor(retCursor);
    } else {
        clearSearchedWordHighlight();
    }

    return found;
}

bool VEditor::findTextInRange(const QString &p_text,
                              uint p_options,
                              bool p_forward,
                              int p_start,
                              int p_end)
{
    return findTextInRange(p_text,
                           p_options,
                           p_forward,
                           nullptr,
                           QTextCursor::MoveAnchor,
                           false,
                           p_start,
                           p_end);
}

void VEditor::highlightIncrementalSearchedWord(const QTextCursor &p_cursor)
{
    QList<QTextEdit::ExtraSelection> &selects = m_extraSelections[(int)SelectionId::IncrementalSearchedKeyword];
    if (!g_config->getHighlightSearchedWord() || !p_cursor.hasSelection()) {
        if (!selects.isEmpty()) {
            selects.clear();
            highlightExtraSelections(true);
        }

        return;
    }

    selects.clear();
    QTextEdit::ExtraSelection select;
    select.format.setForeground(m_incrementalSearchedWordFg);
    select.format.setBackground(m_incrementalSearchedWordBg);
    select.cursor = p_cursor;
    selects.append(select);

    highlightExtraSelections(true);
}

static bool isRegularExpressionSupported(const QRegExp &p_reg)
{
    if (!p_reg.isValid()) {
        return false;
    }

    // FIXME: hang bug in Qt's find().
    QRegExp test("[$^]+");
    if (test.exactMatch(p_reg.pattern())) {
        return false;
    }

    return true;
}

// Use QPlainTextEdit::find() instead of QTextDocument::find() because the later has
// bugs in searching backward.
bool VEditor::findTextHelper(const QString &p_text,
                             uint p_options,
                             bool p_forward,
                             int p_start,
                             bool &p_wrapped,
                             QTextCursor &p_cursor)
{
    p_wrapped = false;
    bool found = false;

    // Options
    bool caseSensitive = p_options & FindOption::CaseSensitive;
    QTextDocument::FindFlags findFlags = findOptionsToFlags(p_options, p_forward);

    // Use regular expression
    bool useRegExp = p_options & FindOption::RegularExpression;
    QRegExp exp;
    if (useRegExp) {
        useRegExp = true;
        exp = QRegExp(p_text,
                      caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive);
        if (!isRegularExpressionSupported(exp)) {
            return false;
        }
    }

    // Store current state of the cursor.
    QTextCursor cursor = textCursorW();
    if (cursor.position() != p_start) {
        if (p_start < 0) {
            p_start = 0;
        } else if (p_start > m_document->characterCount()) {
            p_start = m_document->characterCount();
        }
    }

    QTextCursor startCursor = cursor;
    // Will clear the selection.
    startCursor.setPosition(p_start);
    setTextCursorW(startCursor);

    while (!found) {
        if (useRegExp) {
            found = findW(exp, findFlags);
        } else {
            found = findW(p_text, findFlags);
        }

        if (p_wrapped) {
            break;
        }

        if (!found) {
            // Wrap to the other end of the document to search again.
            p_wrapped = true;
            QTextCursor wrapCursor = textCursorW();
            if (p_forward) {
                wrapCursor.movePosition(QTextCursor::Start, QTextCursor::MoveAnchor);
            } else {
                wrapCursor.movePosition(QTextCursor::End, QTextCursor::MoveAnchor);
            }

            setTextCursorW(wrapCursor);
        }
    }

    if (found) {
        p_cursor = textCursorW();
    }

    // Restore the original cursor.
    setTextCursorW(cursor);

    return found;
}

void VEditor::clearIncrementalSearchedWordHighlight(bool p_now)
{
    QList<QTextEdit::ExtraSelection> &selects = m_extraSelections[(int)SelectionId::IncrementalSearchedKeyword];
    if (selects.isEmpty()) {
        return;
    }

    selects.clear();
    highlightExtraSelections(p_now);
}

void VEditor::clearSearchedWordHighlight()
{
    clearIncrementalSearchedWordHighlight(false);
    clearSearchedWordUnderCursorHighlight(false);

    QList<QTextEdit::ExtraSelection> &selects = m_extraSelections[(int)SelectionId::SearchedKeyword];
    if (selects.isEmpty()) {
        return;
    }

    selects.clear();
    highlightExtraSelections(true);
}

void VEditor::clearSearchedWordUnderCursorHighlight(bool p_now)
{
    QList<QTextEdit::ExtraSelection> &selects = m_extraSelections[(int)SelectionId::SearchedKeywordUnderCursor];
    if (selects.isEmpty()) {
        return;
    }

    selects.clear();
    highlightExtraSelections(p_now);
}

void VEditor::showWrapLabel()
{
    int labelW = m_wrapLabel->width();
    int labelH = m_wrapLabel->height();
    int x = (m_editor->width() - labelW) / 2;
    int y = (m_editor->height() - labelH) / 2;
    if (x < 0) {
        x = 0;
    }

    if (y < 0) {
        y = 0;
    }

    m_wrapLabel->move(x, y);
    m_wrapLabel->show();
    m_labelTimer->stop();
    m_labelTimer->start();
}

void VEditor::highlightSearchedWord(const QList<QTextCursor> &p_matches)
{
    QList<QTextEdit::ExtraSelection> &selects = m_extraSelections[(int)SelectionId::SearchedKeyword];
    if (!g_config->getHighlightSearchedWord() || p_matches.isEmpty()) {
        if (!selects.isEmpty()) {
            selects.clear();
            highlightExtraSelections(true);
        }

        return;
    }

    selects.clear();

    QTextCharFormat format;
    format.setForeground(m_searchedWordFg);
    format.setBackground(m_searchedWordBg);

    for (int i = 0; i < p_matches.size(); ++i) {
        QTextEdit::ExtraSelection select;
        select.format = format;
        select.cursor = p_matches[i];
        selects.append(select);
    }

    highlightExtraSelections();
}

void VEditor::highlightSearchedWordUnderCursor(const QTextCursor &p_cursor)
{
    QList<QTextEdit::ExtraSelection> &selects = m_extraSelections[(int)SelectionId::SearchedKeywordUnderCursor];
    if (!p_cursor.hasSelection()) {
        if (!selects.isEmpty()) {
            selects.clear();
            highlightExtraSelections(true);
        }

        return;
    }

    selects.clear();
    QTextEdit::ExtraSelection select;
    select.format.setForeground(m_searchedWordCursorFg);
    select.format.setBackground(m_searchedWordCursorBg);
    select.cursor = p_cursor;
    selects.append(select);

    highlightExtraSelections(true);
}

static void fillReplaceTextWithBackReference(QString &p_replaceText,
                                             const QString &p_text,
                                             const QRegExp &p_exp)
{
    int idx = p_exp.indexIn(p_text);
    if (idx != 0) {
        return;
    }

    QStringList caps = p_exp.capturedTexts();
    if (caps.size() < 2) {
        return;
    }

    QChar sla('\\');
    int pos = 0;
    while (pos < p_replaceText.size()) {
        int idx = p_replaceText.indexOf(sla, pos);
        if (idx == -1 || idx == p_replaceText.size() - 1) {
            break;
        }

        QChar ne(p_replaceText[idx + 1]);
        if (ne == sla) {
            // \\ to \.
            p_replaceText.remove(idx, 1);
        } else if (ne.isDigit()) {
            // TODO: for now, we only support 1 - 9.
            int num = ne.digitValue();
            if (num > 0 && num < caps.size()) {
                // Replace it.
                p_replaceText.replace(idx, 2, caps[num]);
                pos = idx + caps[num].size() - 2;
                continue;
            }
        }

        pos = idx + 1;
    }
}

void VEditor::replaceText(const QString &p_text,
                          uint p_options,
                          const QString &p_replaceText,
                          bool p_findNext)
{
    QTextCursor cursor = textCursorW();
    bool wrapped = false;
    QTextCursor retCursor;
    QString newText(p_replaceText);
    bool useRegExp = p_options & FindOption::RegularExpression;
    QRegExp exp;
    if (useRegExp) {
        exp = QRegExp(p_text,
                      (p_options & FindOption::CaseSensitive) ? Qt::CaseSensitive : Qt::CaseInsensitive);
    }

    bool found = findTextHelper(p_text,
                                p_options,
                                true,
                                cursor.position(),
                                wrapped,
                                retCursor);
    if (found) {
        if (retCursor.selectionStart() == cursor.position()) {
            // Matched.
            if (useRegExp) {
                // Handle \1, \2 in replace text.
                fillReplaceTextWithBackReference(newText,
                                                 VEditUtils::selectedText(retCursor),
                                                 exp);
            }

            retCursor.beginEditBlock();
            retCursor.insertText(newText);
            retCursor.endEditBlock();
            setTextCursorW(retCursor);
        }

        if (p_findNext) {
            findTextOne(p_text, p_options, true);
        }
    }
}

void VEditor::replaceTextAll(const QString &p_text,
                             uint p_options,
                             const QString &p_replaceText)
{
    // Replace from the start to the end and restore the cursor.
    QTextCursor cursor = textCursorW();
    int nrReplaces = 0;
    QTextCursor tmpCursor = cursor;
    tmpCursor.setPosition(0);
    setTextCursorW(tmpCursor);
    int start = tmpCursor.position();

    QString newText;
    bool useRegExp = p_options & FindOption::RegularExpression;
    QRegExp exp;
    if (useRegExp) {
        exp = QRegExp(p_text,
                      (p_options & FindOption::CaseSensitive) ? Qt::CaseSensitive : Qt::CaseInsensitive);
    } else {
        newText = p_replaceText;
    }

    while (true) {
        bool wrapped = false;
        QTextCursor retCursor;
        bool found = findTextHelper(p_text,
                                    p_options,
                                    true,
                                    start,
                                    wrapped,
                                    retCursor);
        if (!found) {
            break;
        } else {
            if (wrapped) {
                // Wrap back.
                break;
            }

            if (useRegExp) {
                newText = p_replaceText;
                fillReplaceTextWithBackReference(newText,
                                                 VEditUtils::selectedText(retCursor),
                                                 exp);
            }

            nrReplaces++;
            retCursor.beginEditBlock();
            retCursor.insertText(newText);
            retCursor.endEditBlock();
            setTextCursorW(retCursor);
            start = retCursor.position();
        }
    }

    // Restore cursor position.
    cursor.clearSelection();
    setTextCursorW(cursor);
    qDebug() << "replace all" << nrReplaces << "occurences";

    emit m_object->statusMessage(QObject::tr("Replace %1 %2").arg(nrReplaces)
                                                             .arg(nrReplaces > 1 ? QObject::tr("occurences")
                                                                                 : QObject::tr("occurence")));
}

void VEditor::evaluateMagicWords()
{
    QString text;
    QTextCursor cursor = textCursorW();
    if (!cursor.hasSelection()) {
        // Get the WORD in current cursor.
        int start, end;
        VEditUtils::findCurrentWORD(cursor, start, end);

        if (start == end) {
            return;
        } else {
            cursor.setPosition(start);
            cursor.setPosition(end, QTextCursor::KeepAnchor);
        }
    }

    text = VEditUtils::selectedText(cursor);
    Q_ASSERT(!text.isEmpty());
    QString evaText = g_mwMgr->evaluate(text);
    if (text != evaText) {
        qDebug() << "evaluateMagicWords" << text << evaText;

        cursor.insertText(evaText);

        if (m_editOps) {
            m_editOps->setVimMode(VimMode::Insert);
        }

        setTextCursorW(cursor);
    }
}

void VEditor::setReadOnlyAndHighlightCurrentLine(bool p_readonly)
{
    setReadOnlyW(p_readonly);
    highlightCurrentLine();
}

bool VEditor::handleMousePressEvent(QMouseEvent *p_event)
{
    if (p_event->button() == Qt::LeftButton
        && p_event->modifiers() == Qt::ControlModifier
        && !textCursorW().hasSelection()) {
        m_oriMouseX = p_event->x();
        m_oriMouseY = p_event->y();
        m_readyToScroll = true;
        m_mouseMoveScrolled = false;
        p_event->accept();
        return true;
    }

    m_readyToScroll = false;
    m_mouseMoveScrolled = false;

    return false;
}

bool VEditor::handleMouseReleaseEvent(QMouseEvent *p_event)
{
    if (m_mouseMoveScrolled || m_readyToScroll) {
        viewportW()->setCursor(Qt::IBeamCursor);
        m_readyToScroll = false;
        m_mouseMoveScrolled = false;
        p_event->accept();
        return true;
    }

    m_readyToScroll = false;
    m_mouseMoveScrolled = false;

    return false;
}

bool VEditor::handleMouseMoveEvent(QMouseEvent *p_event)
{
    const int threshold = 5;

    if (m_readyToScroll) {
        int deltaX = p_event->x() - m_oriMouseX;
        int deltaY = p_event->y() - m_oriMouseY;

        if (qAbs(deltaX) >= threshold || qAbs(deltaY) >= threshold) {
            m_oriMouseX = p_event->x();
            m_oriMouseY = p_event->y();

            if (!m_mouseMoveScrolled) {
                m_mouseMoveScrolled = true;
                viewportW()->setCursor(Qt::SizeAllCursor);
            }

            QScrollBar *verBar = verticalScrollBarW();
            QScrollBar *horBar = horizontalScrollBarW();
            if (verBar->isVisible()) {
                verBar->setValue(verBar->value() - deltaY);
            }

            if (horBar->isVisible()) {
                horBar->setValue(horBar->value() - deltaX);
            }
        }

        p_event->accept();
        return true;
    }

    return false;
}

bool VEditor::handleWheelEvent(QWheelEvent *p_event)
{
    Qt::KeyboardModifiers modifiers = p_event->modifiers();
    if (modifiers == Qt::ShiftModifier) {
        // Scroll horizontally.
        QPoint numPixels = p_event->pixelDelta();
        QPoint numDegrees = p_event->angleDelta() / 8;

        QScrollBar *horBar = horizontalScrollBarW();
        int steps = 0;
        if (!numPixels.isNull()) {
            steps = numPixels.y();
        } else if (!numDegrees.isNull()) {
            QPoint numSteps = numDegrees / 15;
            steps = numSteps.y() * horBar->singleStep();
        }

        if (horBar->minimum() != horBar->maximum()) {
            horBar->setValue(horBar->value() - steps);
        }

        p_event->accept();
        return true;
    } else if (modifiers == Qt::ControlModifier) {
        // Zoom in/out.
        QPoint angle = p_event->angleDelta();
        if (!angle.isNull() && (angle.y() != 0)) {
            if (angle.y() > 0) {
                zoomInW();
            } else {
                zoomOutW();
            }
        }

        p_event->accept();
        return true;
    }

    return false;
}

void VEditor::requestUpdateVimStatus()
{
    if (m_editOps) {
        m_editOps->requestUpdateVimStatus();
    } else {
        emit m_object->vimStatusUpdated(NULL);
    }
}

bool VEditor::handleInputMethodQuery(Qt::InputMethodQuery p_query,
                                     QVariant &p_var) const
{
    if (p_query == Qt::ImEnabled) {
        p_var = m_enableInputMethod;
        return true;
    }

    return false;
}

void VEditor::setInputMethodEnabled(bool p_enabled)
{
    if (m_enableInputMethod != p_enabled) {
        m_enableInputMethod = p_enabled;

        QInputMethod *im = QGuiApplication::inputMethod();
        im->reset();

        // Ask input method to query current state, which will call inputMethodQuery().
        im->update(Qt::ImEnabled);
    }
}

void VEditor::decorateText(TextDecoration p_decoration, int p_level)
{
    if (m_editOps) {
        m_editOps->decorateText(p_decoration, p_level);
    }
}

void VEditor::updateConfig()
{
    updateEditConfig();
}

void VEditor::setVimMode(VimMode p_mode)
{
    if (m_editOps) {
        m_editOps->setVimMode(p_mode);
    }
}

VVim *VEditor::getVim() const
{
    if (m_editOps) {
        return m_editOps->getVim();
    }

    return NULL;
}

bool VEditor::setCursorPosition(int p_blockNumber, int p_posInBlock)
{
    QTextDocument *doc = documentW();
    QTextBlock block = doc->findBlockByNumber(p_blockNumber);
    if (!block.isValid() || block.length() <= p_posInBlock) {
        return false;
    }

    QTextCursor cursor = textCursorW();
    cursor.setPosition(block.position() + p_posInBlock);
    setTextCursorW(cursor);
    return true;
}

static Qt::CaseSensitivity completionCaseSensitivity(const QString &p_text)
{
    bool upperCase = false;
    for (int i = 0; i < p_text.size(); ++i) {
        if (p_text[i].isUpper()) {
            upperCase = true;
            break;
        }
    }

    return upperCase ? Qt::CaseSensitive : Qt::CaseInsensitive;
}

void VEditor::requestCompletion(bool p_reversed)
{
    QTextCursor cursor = textCursorW();
    cursor.clearSelection();
    setTextCursorW(cursor);

    QStringList words = generateCompletionCandidates(p_reversed);
    QString prefix = fetchCompletionPrefix();
    // Smart case.
    Qt::CaseSensitivity cs = completionCaseSensitivity(prefix);

    cursor.movePosition(QTextCursor::PreviousCharacter, QTextCursor::MoveAnchor, prefix.size());
    QRect popupRect = cursorRectW(cursor);
    popupRect.setLeft(popupRect.left() + lineNumberAreaWidth());

    m_completer->performCompletion(words, prefix, cs, p_reversed, popupRect, this);
}

bool VEditor::isCompletionActivated() const
{
    if (m_completer->widget() == m_editor
        && m_completer->isPopupVisible()) {
        return true;
    }

    return false;
}

QStringList VEditor::generateCompletionCandidates(bool p_reversed) const
{
    QString content = getContent();
    QTextCursor cursor = textCursorW();
    int start, end;
    VEditUtils::findCurrentWord(cursor, start, end, true);

    QRegExp reg("\\W+");

    QStringList above = content.left(start).split(reg, QString::SkipEmptyParts);
    QStringList below = content.mid(end).split(reg, QString::SkipEmptyParts);

    if (p_reversed) {
        QStringList rev;
        rev.reserve(above.size() + below.size());
        for (auto it = above.rbegin(); it != above.rend(); ++it) {
            rev.append(*it);
        }

        for (auto it = below.rbegin(); it != below.rend(); ++it) {
            rev.append(*it);
        }

        rev.removeDuplicates();

        QStringList res;
        res.reserve(rev.size());
        for (auto it = rev.rbegin(); it != rev.rend(); ++it) {
            res.append(*it);
        }

        return res;
    } else {
        // below + above.
        below.append(above);
        below.removeDuplicates();
        return below;
    }
}

QString VEditor::fetchCompletionPrefix() const
{
    QTextCursor cursor = textCursorW();
    if (cursor.atBlockStart()) {
        return QString();
    }

    int pos = cursor.position() - 1;
    int blockPos = cursor.block().position();
    QString prefix;
    while (pos >= blockPos) {
        QChar ch = m_document->characterAt(pos);
        if (VEditUtils::isSpaceOrWordSeparator(ch)) {
            break;
        }

        prefix.prepend(ch);
        --pos;
    }

    return prefix;
}

// @p_prefix may be longer than @p_completion.
void VEditor::insertCompletion(const QString &p_prefix, const QString &p_completion)
{
    QTextCursor cursor = textCursorW();

    cursor.joinPreviousEditBlock();
    cursor.movePosition(QTextCursor::PreviousCharacter, QTextCursor::KeepAnchor, p_prefix.size());
    cursor.insertText(p_completion);
    cursor.endEditBlock();

    setTextCursorW(cursor);
}

QList<QTextCursor> VEditor::findTextAllInRange(const QTextDocument *p_doc,
                                               const QString &p_text,
                                               QTextDocument::FindFlags p_flags,
                                               int p_start,
                                               int p_end)
{
    QList<QTextCursor> results;
    if (p_text.isEmpty()) {
        return results;
    }

    int start = p_start;
    int end = p_end == -1 ? p_doc->characterCount() + 1 : p_end;

    while (start < end) {
        QTextCursor cursor = p_doc->find(p_text, start, p_flags);
        if (cursor.isNull()) {
            break;
        } else {
            start = cursor.selectionEnd();
            if (start <= end) {
                results.append(cursor);
            }
        }
    }

    return results;
}

QList<QTextCursor> VEditor::findTextAllInRange(const QTextDocument *p_doc,
                                               const QRegExp &p_reg,
                                               QTextDocument::FindFlags p_flags,
                                               int p_start,
                                               int p_end)
{
    QList<QTextCursor> results;
    if (!isRegularExpressionSupported(p_reg)) {
        return results;
    }

    int start = p_start;
    int end = p_end == -1 ? p_doc->characterCount() + 1 : p_end;

    while (start < end) {
        QTextCursor cursor = p_doc->find(p_reg, start, p_flags);
        if (cursor.isNull()) {
            break;
        } else {
            start = cursor.selectionEnd();
            if (start <= end) {
                results.append(cursor);
            }
        }
    }

    return results;
}

void VEditor::clearFindCache()
{
    m_findInfo.clearResult();
}

void VEditor::nextMatch(bool p_forward)
{
    if (m_findInfo.isNull()) {
        return;
    }

    if (m_findInfo.m_useToken) {
        findText(m_findInfo.m_token, p_forward, false);
    } else {
        findTextInRange(m_findInfo.m_text,
                        m_findInfo.m_options,
                        p_forward,
                        m_findInfo.m_start,
                        m_findInfo.m_end);
    }
}