feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

TextEditor: Merge Base- and ThreadedSyntaxHighlighterRunner

Browse Source 
Change-Id: I38ad01a895eabba99b2e554f3ae9bef85f32bb3b
Reviewed-by: Artem Sokolovskii <artem.sokolovskii@qt.io>
This commit is contained in:
David Schulz
2024-01-04 14:50:45 +01:00
parent 1db28206c0
commit f4b3b85fee
13 changed files with 119 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/plugins/cppeditor/cppcompletion_test.cpp
View File

@@ -150,7 +150,7 @@ public:
return true;
return ::CppEditor::Tests::waitForSignalOrTimeout(
cppEditor->textDocument()->syntaxHighlighterRunner(),
&BaseSyntaxHighlighterRunner::highlightingFinished,
&SyntaxHighlighterRunner::highlightingFinished,
5000);
}

4
src/plugins/cppeditor/cppeditordocument.cpp
View File

@@ -164,7 +164,7 @@ QByteArray CppEditorDocument::contentsText() const
void CppEditorDocument::applyFontSettings()
{
if (TextEditor::BaseSyntaxHighlighterRunner *highlighter = syntaxHighlighterRunner())
if (TextEditor::SyntaxHighlighterRunner *highlighter = syntaxHighlighterRunner())
highlighter->clearAllExtraFormats(); // Clear all additional formats since they may have changed
TextDocument::applyFontSettings(); // rehighlights and updates additional formats
if (m_processor)
@@ -408,7 +408,7 @@ BaseEditorDocumentProcessor *CppEditorDocument::processor()
connect(m_processor.data(), &BaseEditorDocumentProcessor::cppDocumentUpdated, this,
[this](const CPlusPlus::Document::Ptr document) {
// Update syntax highlighter
if (BaseSyntaxHighlighterRunner *highlighter = syntaxHighlighterRunner())
if (SyntaxHighlighterRunner *highlighter = syntaxHighlighterRunner())
highlighter->setLanguageFeaturesFlags(document->languageFeatures().flags);
m_overviewModel.update(usesClangd() ? nullptr : document);

4
src/plugins/cppeditor/semantichighlighter.cpp
View File

@@ -112,7 +112,7 @@ void SemanticHighlighter::handleHighlighterResults()
QElapsedTimer t;
t.start();
BaseSyntaxHighlighterRunner *highlighter = m_baseTextDocument->syntaxHighlighterRunner();
SyntaxHighlighterRunner *highlighter = m_baseTextDocument->syntaxHighlighterRunner();
QTC_ASSERT(highlighter, return);
incrementalApplyExtraAdditionalFormats(highlighter, m_watcher->future(), from, to, m_formatMap);
@@ -200,7 +200,7 @@ void SemanticHighlighter::onHighlighterFinished()
t.start();
if (!m_watcher->isCanceled() && documentRevision() == m_revision) {
BaseSyntaxHighlighterRunner *highlighter = m_baseTextDocument->syntaxHighlighterRunner();
SyntaxHighlighterRunner *highlighter = m_baseTextDocument->syntaxHighlighterRunner();
if (QTC_GUARD(highlighter)) {
qCDebug(log) << "onHighlighterFinished() - clearing formats";
clearExtraAdditionalFormatsUntilEnd(highlighter, m_watcher->future());

4
src/plugins/languageclient/semantichighlightsupport.cpp
View File

@@ -183,7 +183,7 @@ void SemanticTokenSupport::queueDocumentReload(TextEditor::TextDocument *doc)
void SemanticTokenSupport::clearHighlight(TextEditor::TextDocument *doc)
{
if (m_tokens.contains(doc->filePath())){
if (TextEditor::BaseSyntaxHighlighterRunner *highlighter = doc->syntaxHighlighterRunner())
if (TextEditor::SyntaxHighlighterRunner *highlighter = doc->syntaxHighlighterRunner())
highlighter->clearAllExtraFormats();
}
}
@@ -413,7 +413,7 @@ void SemanticTokenSupport::highlight(const Utils::FilePath &filePath, bool force
TextDocument *doc = TextDocument::textDocumentForFilePath(filePath);
if (!doc || LanguageClientManager::clientForDocument(doc) != m_client)
return;
BaseSyntaxHighlighterRunner *highlighter = doc->syntaxHighlighterRunner();
SyntaxHighlighterRunner *highlighter = doc->syntaxHighlighterRunner();
if (!highlighter)
return;
const VersionedTokens versionedTokens = m_tokens.value(filePath);

6
src/plugins/texteditor/semantichighlighter.cpp
View File

@@ -75,7 +75,7 @@ const Ranges rangesForResult(
}
void SemanticHighlighter::incrementalApplyExtraAdditionalFormats(
BaseSyntaxHighlighterRunner *highlighter,
SyntaxHighlighterRunner *highlighter,
const QFuture<HighlightingResult> &future,
int from,
int to,
@@ -128,7 +128,7 @@ void SemanticHighlighter::incrementalApplyExtraAdditionalFormats(
highlighter->setExtraFormats(blockNumberMap);
}
void SemanticHighlighter::setExtraAdditionalFormats(BaseSyntaxHighlighterRunner *highlighter,
void SemanticHighlighter::setExtraAdditionalFormats(SyntaxHighlighterRunner *highlighter,
const QList<HighlightingResult> &results,
const QHash<int, QTextCharFormat> &kindToFormat)
{
@@ -151,7 +151,7 @@ void SemanticHighlighter::setExtraAdditionalFormats(BaseSyntaxHighlighterRunner
}
void SemanticHighlighter::clearExtraAdditionalFormatsUntilEnd(
BaseSyntaxHighlighterRunner *highlighter, const QFuture<HighlightingResult> &future)
SyntaxHighlighterRunner *highlighter, const QFuture<HighlightingResult> &future)
{
const QTextDocument * const doc = highlighter->document();
QTextBlock firstBlockToClear = doc->begin();

8
src/plugins/texteditor/semantichighlighter.h
View File

@@ -21,7 +21,7 @@ QT_END_NAMESPACE
namespace TextEditor {
class SyntaxHighlighter;
class BaseSyntaxHighlighterRunner;
class SyntaxHighlighterRunner;
class TEXTEDITOR_EXPORT HighlightingResult
{
@@ -74,7 +74,7 @@ using Splitter = std::function<const QList<std::pair<HighlightingResult, QTextBl
// the (to-1).line result.
// Requires that results of the Future are ordered by line.
void TEXTEDITOR_EXPORT
incrementalApplyExtraAdditionalFormats(BaseSyntaxHighlighterRunner *highlighter,
incrementalApplyExtraAdditionalFormats(SyntaxHighlighterRunner *highlighter,
const QFuture<HighlightingResult> &future,
int from,
int to,
@@ -85,7 +85,7 @@ incrementalApplyExtraAdditionalFormats(BaseSyntaxHighlighterRunner *highlighter,
// indicated by Result::kind and kindToFormat to the correct location using
// SyntaxHighlighter::setExtraFormats. In contrast to
// incrementalApplyExtraAdditionalFormats the results do not have to be ordered by line.
void TEXTEDITOR_EXPORT setExtraAdditionalFormats(BaseSyntaxHighlighterRunner *highlighter,
void TEXTEDITOR_EXPORT setExtraAdditionalFormats(SyntaxHighlighterRunner *highlighter,
const HighlightingResults &results,
const QHash<int, QTextCharFormat> &kindToFormat);
@@ -93,7 +93,7 @@ void TEXTEDITOR_EXPORT setExtraAdditionalFormats(BaseSyntaxHighlighterRunner *hi
// until the end of the document.
// Requires that results of the Future are ordered by line.
void TEXTEDITOR_EXPORT clearExtraAdditionalFormatsUntilEnd(
BaseSyntaxHighlighterRunner *highlighter, const QFuture<HighlightingResult> &future);
SyntaxHighlighterRunner *highlighter, const QFuture<HighlightingResult> &future);
} // namespace SemanticHighlighter
} // namespace TextEditor

132
src/plugins/texteditor/syntaxhighlighterrunner.cpp
View File

@@ -8,6 +8,7 @@
#include "texteditorsettings.h"
#include "highlighter.h"
#include <utils/algorithm.h>
#include <utils/textutils.h>
#include <QMetaObject>
@@ -21,19 +22,20 @@ class SyntaxHighlighterRunnerPrivate : public QObject
{
Q_OBJECT
public:
SyntaxHighlighterRunnerPrivate(BaseSyntaxHighlighterRunner::SyntaxHighLighterCreator creator,
SyntaxHighlighterRunnerPrivate(SyntaxHighlighterRunner::SyntaxHighlighterCreator creator,
QTextDocument *document,
bool async,
FontSettings fontSettings)
: m_document(document)
, m_fontSettings(fontSettings)
{
if (!m_document) {
if (async) {
m_document = new QTextDocument(this);
m_document->setDocumentLayout(new TextDocumentLayout(m_document));
} else {
m_document = document;
}
m_highlighter.reset(creator());
m_highlighter->setFontSettings(m_fontSettings);
m_highlighter->setFontSettings(fontSettings);
m_highlighter->setDocument(m_document);
m_highlighter->setParent(m_document);
@@ -46,7 +48,7 @@ public:
void changeDocument(int from,
int charsRemoved,
const QString textAdded,
const QMap<int, BaseSyntaxHighlighterRunner::BlockPreeditData> &blocksPreedit)
const QMap<int, SyntaxHighlighterRunner::BlockPreeditData> &blocksPreedit)
{
QTextCursor cursor(m_document);
cursor.setPosition(qMin(m_document->characterCount() - 1, from + charsRemoved));
@@ -95,28 +97,39 @@ public:
std::unique_ptr<SyntaxHighlighter> m_highlighter;
QTextDocument *m_document = nullptr;
FontSettings m_fontSettings;
signals:
void resultsReady(const QList<SyntaxHighlighter::Result> &result);
};
// ----------------------------- BaseSyntaxHighlighterRunner --------------------------------------
BaseSyntaxHighlighterRunner::BaseSyntaxHighlighterRunner(
BaseSyntaxHighlighterRunner::SyntaxHighLighterCreator creator,
SyntaxHighlighterRunner::SyntaxHighlighterRunner(SyntaxHighlighterCreator creator,
QTextDocument *document,
bool async,
const TextEditor::FontSettings &fontSettings)
: d(new SyntaxHighlighterRunnerPrivate(creator, document, fontSettings))
: d(new SyntaxHighlighterRunnerPrivate(creator, document, async, fontSettings))
, m_document(document)
{
m_useGenericHighlighter = qobject_cast<Highlighter *>(d->m_highlighter.get());
if (document == nullptr)
return;
if (async) {
m_thread.emplace();
d->moveToThread(&*m_thread);
connect(&*m_thread, &QThread::finished, d, &QObject::deleteLater);
m_thread->start();
connect(d.get(),
connect(d,
&SyntaxHighlighterRunnerPrivate::resultsReady,
this,
&SyntaxHighlighterRunner::applyFormatRanges);
changeDocument(0, 0, document->characterCount());
connect(document,
&QTextDocument::contentsChange,
this,
&SyntaxHighlighterRunner::changeDocument);
} else {
connect(d,
&SyntaxHighlighterRunnerPrivate::resultsReady,
this,
[this](const QList<SyntaxHighlighter::Result> &result) {
@@ -133,10 +146,20 @@ BaseSyntaxHighlighterRunner::BaseSyntaxHighlighterRunner(
m_syntaxInfoUpdated = SyntaxHighlighter::State::InProgress;
});
}
}
BaseSyntaxHighlighterRunner::~BaseSyntaxHighlighterRunner() = default;
SyntaxHighlighterRunner::~SyntaxHighlighterRunner()
{
if (m_thread) {
m_thread->requestInterruption();
m_thread->quit();
m_thread->wait();
} else {
delete d;
}
}
void BaseSyntaxHighlighterRunner::applyFormatRanges(const QList<SyntaxHighlighter::Result> &results)
void SyntaxHighlighterRunner::applyFormatRanges(const QList<SyntaxHighlighter::Result> &results)
{
if (m_document == nullptr)
return;
@@ -164,11 +187,11 @@ void BaseSyntaxHighlighterRunner::applyFormatRanges(const QList<SyntaxHighlighte
}
}
void BaseSyntaxHighlighterRunner::changeDocument(int from, int charsRemoved, int charsAdded)
void SyntaxHighlighterRunner::changeDocument(int from, int charsRemoved, int charsAdded)
{
QTC_ASSERT(m_document, return);
m_syntaxInfoUpdated = SyntaxHighlighter::State::InProgress;
QMap<int, BaseSyntaxHighlighterRunner::BlockPreeditData> blocksPreedit;
QMap<int, SyntaxHighlighterRunner::BlockPreeditData> blocksPreedit;
QTextBlock block = m_document->findBlock(from);
const QTextBlock endBlock = m_document->findBlock(from + charsAdded);
while (block.isValid() && block != endBlock) {
@@ -179,97 +202,64 @@ void BaseSyntaxHighlighterRunner::changeDocument(int from, int charsRemoved, int
block = block.next();
}
const QString text = Utils::Text::textAt(QTextCursor(m_document), from, charsAdded);
QMetaObject::invokeMethod(d.get(), [this, from, charsRemoved, text, blocksPreedit] {
QMetaObject::invokeMethod(d, [this, from, charsRemoved, text, blocksPreedit] {
d->changeDocument(from, charsRemoved, text, blocksPreedit);
});
}
bool BaseSyntaxHighlighterRunner::useGenericHighlighter() const
bool SyntaxHighlighterRunner::useGenericHighlighter() const
{
return m_useGenericHighlighter;
}
void BaseSyntaxHighlighterRunner::setExtraFormats(
void SyntaxHighlighterRunner::setExtraFormats(
const QMap<int, QList<QTextLayout::FormatRange>> &formatMap)
{
QMetaObject::invokeMethod(d.get(), [this, formatMap] { d->setExtraFormats(formatMap); });
QMetaObject::invokeMethod(d, [this, formatMap] { d->setExtraFormats(formatMap); });
}
void BaseSyntaxHighlighterRunner::clearExtraFormats(const QList<int> &blockNumbers)
void SyntaxHighlighterRunner::clearExtraFormats(const QList<int> &blockNumbers)
{
QMetaObject::invokeMethod(d.get(), [this, blockNumbers] { d->clearExtraFormats(blockNumbers); });
QMetaObject::invokeMethod(d, [this, blockNumbers] { d->clearExtraFormats(blockNumbers); });
}
void BaseSyntaxHighlighterRunner::clearAllExtraFormats()
void SyntaxHighlighterRunner::clearAllExtraFormats()
{
QMetaObject::invokeMethod(d.get(), [this] { d->clearAllExtraFormats(); });
QMetaObject::invokeMethod(d, [this] { d->clearAllExtraFormats(); });
}
void BaseSyntaxHighlighterRunner::setFontSettings(const TextEditor::FontSettings &fontSettings)
void SyntaxHighlighterRunner::setFontSettings(const TextEditor::FontSettings &fontSettings)
{
QMetaObject::invokeMethod(d.get(), [this, fontSettings] { d->setFontSettings(fontSettings); });
QMetaObject::invokeMethod(d, [this, fontSettings] { d->setFontSettings(fontSettings); });
}
void BaseSyntaxHighlighterRunner::setLanguageFeaturesFlags(unsigned int flags)
void SyntaxHighlighterRunner::setLanguageFeaturesFlags(unsigned int flags)
{
QMetaObject::invokeMethod(d.get(), [this, flags] { d->setLanguageFeaturesFlags(flags); });
QMetaObject::invokeMethod(d, [this, flags] { d->setLanguageFeaturesFlags(flags); });
}
void BaseSyntaxHighlighterRunner::setEnabled(bool enabled)
void SyntaxHighlighterRunner::setEnabled(bool enabled)
{
QMetaObject::invokeMethod(d.get(), [this, enabled] { d->setEnabled(enabled); });
QMetaObject::invokeMethod(d, [this, enabled] { d->setEnabled(enabled); });
}
void BaseSyntaxHighlighterRunner::rehighlight()
void SyntaxHighlighterRunner::rehighlight()
{
QMetaObject::invokeMethod(d.get(), [this] { d->rehighlight(); });
QMetaObject::invokeMethod(d, [this] { d->rehighlight(); });
}
QString BaseSyntaxHighlighterRunner::definitionName()
QString SyntaxHighlighterRunner::definitionName()
{
return m_definitionName;
}
void BaseSyntaxHighlighterRunner::setDefinitionName(const QString &name)
void SyntaxHighlighterRunner::setDefinitionName(const QString &name)
{
if (name.isEmpty())
return;
m_definitionName = name;
QMetaObject::invokeMethod(d.get(), [this, name] { d->setDefinitionName(name); });
}
// --------------------------- ThreadedSyntaxHighlighterRunner ------------------------------------
ThreadedSyntaxHighlighterRunner::ThreadedSyntaxHighlighterRunner(SyntaxHighLighterCreator creator,
QTextDocument *document)
: BaseSyntaxHighlighterRunner(creator, nullptr)
{
QTC_ASSERT(document, return);
d->moveToThread(&m_thread);
connect(&m_thread, &QThread::finished, d.get(), &QObject::deleteLater);
m_thread.start();
m_document = document;
connect(d.get(),
&SyntaxHighlighterRunnerPrivate::resultsReady,
this,
&ThreadedSyntaxHighlighterRunner::applyFormatRanges);
changeDocument(0, 0, document->characterCount());
connect(document,
&QTextDocument::contentsChange,
this,
&ThreadedSyntaxHighlighterRunner::changeDocument);
}
ThreadedSyntaxHighlighterRunner::~ThreadedSyntaxHighlighterRunner()
{
m_thread.requestInterruption();
m_thread.quit();
m_thread.wait();
d.release();
QMetaObject::invokeMethod(d, [this, name] { d->setDefinitionName(name); });
}
} // namespace TextEditor

29
src/plugins/texteditor/syntaxhighlighterrunner.h
View File

@@ -20,21 +20,22 @@ namespace TextEditor {
class SyntaxHighlighterRunnerPrivate;
class TEXTEDITOR_EXPORT BaseSyntaxHighlighterRunner : public QObject
class TEXTEDITOR_EXPORT SyntaxHighlighterRunner : public QObject
{
Q_OBJECT
public:
using SyntaxHighLighterCreator = std::function<SyntaxHighlighter *()>;
using SyntaxHighlighterCreator = std::function<SyntaxHighlighter *()>;
struct BlockPreeditData {
int position;
QString text;
};
BaseSyntaxHighlighterRunner(SyntaxHighLighterCreator creator,
SyntaxHighlighterRunner(SyntaxHighlighterCreator creator,
QTextDocument *document,
bool async,
const TextEditor::FontSettings &fontSettings
= TextEditorSettings::fontSettings());
virtual ~BaseSyntaxHighlighterRunner();
virtual ~SyntaxHighlighterRunner();
void setExtraFormats(const QMap<int, QList<QTextLayout::FormatRange>> &formats);
void clearExtraFormats(const QList<int> &blockNumbers);
@@ -55,28 +56,16 @@ public:
signals:
void highlightingFinished();
protected:
std::unique_ptr<SyntaxHighlighterRunnerPrivate> d;
QPointer<QTextDocument> m_document = nullptr;
private:
void applyFormatRanges(const QList<SyntaxHighlighter::Result> &results);
void changeDocument(int from, int charsRemoved, int charsAdded);
SyntaxHighlighterRunnerPrivate *d;
QPointer<QTextDocument> m_document = nullptr;
SyntaxHighlighter::State m_syntaxInfoUpdated = SyntaxHighlighter::State::Done;
private:
bool m_useGenericHighlighter = false;
QString m_definitionName;
};
class TEXTEDITOR_EXPORT ThreadedSyntaxHighlighterRunner : public BaseSyntaxHighlighterRunner
{
public:
ThreadedSyntaxHighlighterRunner(SyntaxHighLighterCreator SyntaxHighLighterCreator,
QTextDocument *document);
~ThreadedSyntaxHighlighterRunner();
private:
QThread m_thread;
std::optional<QThread> m_thread;
};
} // namespace TextEditor

15
src/plugins/texteditor/textdocument.cpp
View File

@@ -101,7 +101,7 @@ public:
TextMarks m_marksCache; // Marks not owned
Utils::Guard m_modificationChangedGuard;
BaseSyntaxHighlighterRunner *m_highlighterRunner = nullptr;
SyntaxHighlighterRunner *m_highlighterRunner = nullptr;
};
MultiTextCursor TextDocumentPrivate::indentOrUnindent(const MultiTextCursor &cursors,
@@ -635,7 +635,7 @@ QTextDocument *TextDocument::document() const
return &d->m_document;
}
BaseSyntaxHighlighterRunner *TextDocument::syntaxHighlighterRunner() const
SyntaxHighlighterRunner *TextDocument::syntaxHighlighterRunner() const
{
return d->m_highlighterRunner;
}
@@ -917,14 +917,11 @@ void TextDocument::resetSyntaxHighlighter(const std::function<SyntaxHighlighter
if (d->m_highlighterRunner)
delete d->m_highlighterRunner;
static const QString value
= qtcEnvironmentVariable("QTC_USE_THREADED_HIGHLIGHTER", "TRUE").toUpper();
if (threaded && value == QLatin1String("TRUE")) {
d->m_highlighterRunner = new ThreadedSyntaxHighlighterRunner(creator, document());
return;
}
static const bool envValue
= qtcEnvironmentVariable("QTC_USE_THREADED_HIGHLIGHTER", "TRUE").toUpper()
== QLatin1String("TRUE");
d->m_highlighterRunner = new BaseSyntaxHighlighterRunner(creator, document());
d->m_highlighterRunner = new SyntaxHighlighterRunner(creator, document(), threaded && envValue);
}
void TextDocument::cleanWhitespace(const QTextCursor &cursor)

4
src/plugins/texteditor/textdocument.h
View File

@@ -34,7 +34,7 @@ class FontSettings;
class IAssistProvider;
class StorageSettings;
class SyntaxHighlighter;
class BaseSyntaxHighlighterRunner;
class SyntaxHighlighterRunner;
class TabSettings;
class TextDocumentPrivate;
class TextMark;
@@ -128,7 +128,7 @@ public:
using SyntaxHighLighterCreator = std::function<SyntaxHighlighter *()>;
void resetSyntaxHighlighter(const SyntaxHighLighterCreator &creator, bool threaded = true);
BaseSyntaxHighlighterRunner *syntaxHighlighterRunner() const;
SyntaxHighlighterRunner *syntaxHighlighterRunner() const;
bool reload(QString *errorString, QTextCodec *codec);
void cleanWhitespace(const QTextCursor &cursor);

6
src/plugins/texteditor/texteditor.cpp
View File

@@ -1936,7 +1936,7 @@ void TextEditorWidgetPrivate::foldLicenseHeader()
QStringList commentMarker;
QStringList docMarker;
HighlighterHelper::Definition def;
if (BaseSyntaxHighlighterRunner *highlighter = q->textDocument()->syntaxHighlighterRunner())
if (SyntaxHighlighterRunner *highlighter = q->textDocument()->syntaxHighlighterRunner())
def = HighlighterHelper::definitionForName(highlighter->definitionName());
if (def.isValid()) {
@@ -3743,7 +3743,7 @@ void TextEditorWidgetPrivate::setupFromDefinition(const KSyntaxHighlighting::Def
KSyntaxHighlighting::Definition TextEditorWidgetPrivate::currentDefinition()
{
if (BaseSyntaxHighlighterRunner *highlighter = m_document->syntaxHighlighterRunner())
if (SyntaxHighlighterRunner *highlighter = m_document->syntaxHighlighterRunner())
return HighlighterHelper::definitionForName(highlighter->definitionName());
return {};
}
@@ -8132,7 +8132,7 @@ void TextEditorWidget::setDisplaySettings(const DisplaySettings &ds)
optionFlags.setFlag(QTextOption::AddSpaceForLineAndParagraphSeparators);
optionFlags.setFlag(QTextOption::ShowTabsAndSpaces, ds.m_visualizeWhitespace);
if (optionFlags != currentOptionFlags) {
if (BaseSyntaxHighlighterRunner *highlighter = textDocument()->syntaxHighlighterRunner())
if (SyntaxHighlighterRunner *highlighter = textDocument()->syntaxHighlighterRunner())
highlighter->rehighlight();
QTextOption option = document()->defaultTextOption();
option.setFlags(optionFlags);

2
src/plugins/vcsbase/vcsbaseeditor.cpp
View File

@@ -1100,7 +1100,7 @@ void VcsBaseEditorWidget::slotActivateAnnotation()
disconnect(this, &QPlainTextEdit::textChanged, this, &VcsBaseEditorWidget::slotActivateAnnotation);
if (BaseSyntaxHighlighterRunner *ah = textDocument()->syntaxHighlighterRunner()) {
if (SyntaxHighlighterRunner *ah = textDocument()->syntaxHighlighterRunner()) {
ah->rehighlight();
} else {
BaseAnnotationHighlighterCreator creator = annotationHighlighterCreator();

6
tests/auto/texteditor/highlighter/tst_highlighter.cpp
View File

@@ -32,7 +32,7 @@ private slots:
private:
QTextDocument *doc = nullptr;
BaseSyntaxHighlighterRunner *highlighterRunner = nullptr;
SyntaxHighlighterRunner *highlighterRunner = nullptr;
FontSettings fontsettings;
QHash<int, QTextCharFormat> formatHash;
QTextCharFormat whitespaceFormat;
@@ -59,8 +59,8 @@ Last)";
doc = new QTextDocument();
doc->setPlainText(text);
highlighterRunner = new BaseSyntaxHighlighterRunner(
[this] { return new SyntaxHighlighter(doc, fontsettings); }, doc, fontsettings);
highlighterRunner = new SyntaxHighlighterRunner(
[this] { return new SyntaxHighlighter(doc, fontsettings); }, doc, false, fontsettings);
}
static const HighlightingResults &highlightingResults()