qsyntaxhighlighter.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qsyntaxhighlighter.h"
 
#ifndef QT_NO_SYNTAXHIGHLIGHTER
#include <private/qobject_p.h>
#include <qtextdocument.h>
#include <private/qtextdocument_p.h>
#include <qtextlayout.h>
#include <qpointer.h>
#include <qscopedvaluerollback.h>
#include <qtextobject.h>
#include <qtextcursor.h>
#include <qdebug.h>
#include <qtimer.h>
 
#include <algorithm>
 
QT_BEGIN_NAMESPACE
 
class QSyntaxHighlighterPrivate : public QObjectPrivate
{
    Q_DECLARE_PUBLIC(QSyntaxHighlighter)
public:
    inline QSyntaxHighlighterPrivate()
        : rehighlightPending(false), inReformatBlocks(false)
    {}
 
    QPointer<QTextDocument> doc;
 
    void _q_reformatBlocks(int from, int charsRemoved, int charsAdded);
    void reformatBlocks(int from, int charsRemoved, int charsAdded);
    void reformatBlock(const QTextBlock &block);
 
    inline void rehighlight(QTextCursor &cursor, QTextCursor::MoveOperation operation)
    {
        QScopedValueRollback<bool> bg(inReformatBlocks, true);
        cursor.beginEditBlock();
        int from = cursor.position();
        cursor.movePosition(operation);
        reformatBlocks(from, 0, cursor.position() - from);
        cursor.endEditBlock();
    }
 
    inline void _q_delayedRehighlight() {
        if (!rehighlightPending)
            return;
        rehighlightPending = false;
        q_func()->rehighlight();
    }
 
    void applyFormatChanges();
    QList<QTextCharFormat> formatChanges;
    QTextBlock currentBlock;
    bool rehighlightPending;
    bool inReformatBlocks;
};
 
void QSyntaxHighlighterPrivate::applyFormatChanges()
{
    bool formatsChanged = false;
 
    QTextLayout *layout = currentBlock.layout();
 
    QList<QTextLayout::FormatRange> ranges = layout->formats();
 
    const int preeditAreaStart = layout->preeditAreaPosition();
    const int preeditAreaLength = layout->preeditAreaText().size();
 
    if (preeditAreaLength != 0) {
        auto isOutsidePreeditArea = [=](const QTextLayout::FormatRange &range) {
            return range.start < preeditAreaStart
                    || range.start + range.length > preeditAreaStart + preeditAreaLength;
        };
        if (ranges.removeIf(isOutsidePreeditArea) > 0)
            formatsChanged = true;
    } else if (!ranges.isEmpty()) {
        ranges.clear();
        formatsChanged = true;
    }
 
    int i = 0;
    while (i < formatChanges.size()) {
        QTextLayout::FormatRange r;
 
        while (i < formatChanges.size() && formatChanges.at(i) == r.format)
            ++i;
 
        if (i == formatChanges.size())
            break;
 
        r.start = i;
        r.format = formatChanges.at(i);
 
        while (i < formatChanges.size() && formatChanges.at(i) == r.format)
            ++i;
 
        Q_ASSERT(i <= formatChanges.size());
        r.length = i - r.start;
 
        if (preeditAreaLength != 0) {
            if (r.start >= preeditAreaStart)
                r.start += preeditAreaLength;
            else if (r.start + r.length >= preeditAreaStart)
                r.length += preeditAreaLength;
        }
 
        ranges << r;
        formatsChanged = true;
    }
 
    if (formatsChanged) {
        layout->setFormats(ranges);
        doc->markContentsDirty(currentBlock.position(), currentBlock.length());
    }
}
 
void QSyntaxHighlighterPrivate::_q_reformatBlocks(int from, int charsRemoved, int charsAdded)
{
    if (!inReformatBlocks && !rehighlightPending)
        reformatBlocks(from, charsRemoved, charsAdded);
}
 
void QSyntaxHighlighterPrivate::reformatBlocks(int from, int charsRemoved, int charsAdded)
{
    QTextBlock block = doc->findBlock(from);
    if (!block.isValid())
        return;
 
    int endPosition;
    QTextBlock lastBlock = doc->findBlock(from + charsAdded + (charsRemoved > 0 ? 1 : 0));
    if (lastBlock.isValid())
        endPosition = lastBlock.position() + lastBlock.length();
    else
        endPosition = QTextDocumentPrivate::get(doc)->length();
 
    bool forceHighlightOfNextBlock = false;
 
    while (block.isValid() && (block.position() < endPosition || forceHighlightOfNextBlock)) {
        const int stateBeforeHighlight = block.userState();
 
        reformatBlock(block);
 
        forceHighlightOfNextBlock = (block.userState() != stateBeforeHighlight);
 
        block = block.next();
    }
 
    formatChanges.clear();
}
 
void QSyntaxHighlighterPrivate::reformatBlock(const QTextBlock &block)
{
    Q_Q(QSyntaxHighlighter);
 
    Q_ASSERT_X(!currentBlock.isValid(), "QSyntaxHighlighter::reformatBlock()", "reFormatBlock() called recursively");
 
    currentBlock = block;
 
    formatChanges.fill(QTextCharFormat(), block.length() - 1);
    q->highlightBlock(block.text());
    applyFormatChanges();
 
    currentBlock = QTextBlock();
}
 
QSyntaxHighlighter::QSyntaxHighlighter(QObject *parent)
    : QObject(*new QSyntaxHighlighterPrivate, parent)
{
    if (parent && parent->inherits("QTextEdit")) {
        QTextDocument *doc = qvariant_cast<QTextDocument *>(parent->property("document"));
        if (doc)
            setDocument(doc);
    }
}
 
QSyntaxHighlighter::QSyntaxHighlighter(QTextDocument *parent)
    : QObject(*new QSyntaxHighlighterPrivate, parent)
{
    setDocument(parent);
}
 
QSyntaxHighlighter::~QSyntaxHighlighter()
{
    setDocument(nullptr);
}
 
void QSyntaxHighlighter::setDocument(QTextDocument *doc)
{
    Q_D(QSyntaxHighlighter);
    if (d->doc) {
        disconnect(d->doc, SIGNAL(contentsChange(int,int,int)),
                   this, SLOT(_q_reformatBlocks(int,int,int)));
 
        QTextCursor cursor(d->doc);
        cursor.beginEditBlock();
        for (QTextBlock blk = d->doc->begin(); blk.isValid(); blk = blk.next())
            blk.layout()->clearFormats();
        cursor.endEditBlock();
    }
    d->doc = doc;
    if (d->doc) {
        connect(d->doc, SIGNAL(contentsChange(int,int,int)),
                this, SLOT(_q_reformatBlocks(int,int,int)));
        if (!d->doc->isEmpty()) {
            d->rehighlightPending = true;
            QTimer::singleShot(0, this, SLOT(_q_delayedRehighlight()));
        }
    }
}
 
QTextDocument *QSyntaxHighlighter::document() const
{
    Q_D(const QSyntaxHighlighter);
    return d->doc;
}
 
void QSyntaxHighlighter::rehighlight()
{
    Q_D(QSyntaxHighlighter);
    if (!d->doc)
        return;
 
    QTextCursor cursor(d->doc);
    d->rehighlight(cursor, QTextCursor::End);
    d->rehighlightPending = false; // user manually did a full rehighlight
}
 
void QSyntaxHighlighter::rehighlightBlock(const QTextBlock &block)
{
    Q_D(QSyntaxHighlighter);
    if (!d->doc || !block.isValid() || block.document() != d->doc)
        return;
 
    const bool rehighlightPending = d->rehighlightPending;
 
    QTextCursor cursor(block);
    d->rehighlight(cursor, QTextCursor::EndOfBlock);
 
    if (rehighlightPending)
        d->rehighlightPending = rehighlightPending;
}
 
void QSyntaxHighlighter::setFormat(int start, int count, const QTextCharFormat &format)
{
    Q_D(QSyntaxHighlighter);
    if (start < 0 || start >= d->formatChanges.size())
        return;
 
    const int end = qMin(start + count, d->formatChanges.size());
    for (int i = start; i < end; ++i)
        d->formatChanges[i] = format;
}
 
void QSyntaxHighlighter::setFormat(int start, int count, const QColor &color)
{
    QTextCharFormat format;
    format.setForeground(color);
    setFormat(start, count, format);
}
 
void QSyntaxHighlighter::setFormat(int start, int count, const QFont &font)
{
    QTextCharFormat format;
    format.setFont(font);
    setFormat(start, count, format);
}
 
QTextCharFormat QSyntaxHighlighter::format(int pos) const
{
    Q_D(const QSyntaxHighlighter);
    if (pos < 0 || pos >= d->formatChanges.size())
        return QTextCharFormat();
    return d->formatChanges.at(pos);
}
 
int QSyntaxHighlighter::previousBlockState() const
{
    Q_D(const QSyntaxHighlighter);
    if (!d->currentBlock.isValid())
        return -1;
 
    const QTextBlock previous = d->currentBlock.previous();
    if (!previous.isValid())
        return -1;
 
    return previous.userState();
}
 
int QSyntaxHighlighter::currentBlockState() const
{
    Q_D(const QSyntaxHighlighter);
    if (!d->currentBlock.isValid())
        return -1;
 
    return d->currentBlock.userState();
}
 
void QSyntaxHighlighter::setCurrentBlockState(int newState)
{
    Q_D(QSyntaxHighlighter);
    if (!d->currentBlock.isValid())
        return;
 
    d->currentBlock.setUserState(newState);
}
 
void QSyntaxHighlighter::setCurrentBlockUserData(QTextBlockUserData *data)
{
    Q_D(QSyntaxHighlighter);
    if (!d->currentBlock.isValid())
        return;
 
    d->currentBlock.setUserData(data);
}
 
QTextBlockUserData *QSyntaxHighlighter::currentBlockUserData() const
{
    Q_D(const QSyntaxHighlighter);
    if (!d->currentBlock.isValid())
        return nullptr;
 
    return d->currentBlock.userData();
}
 
QTextBlock QSyntaxHighlighter::currentBlock() const
{
    Q_D(const QSyntaxHighlighter);
    return d->currentBlock;
}
 
QT_END_NAMESPACE
 
#include "moc_qsyntaxhighlighter.cpp"
 
#endif // QT_NO_SYNTAXHIGHLIGHTER