File indexing completed on 2024-05-12 04:02:20

 /*
     SPDX-FileCopyrightText: 2016 Volker Krause <vkrause@kde.org>
 
     SPDX-License-Identifier: MIT
 */
 
 #include "syntaxhighlighter.h"
 #include "abstracthighlighter_p.h"
 #include "definition.h"
 #include "definition_p.h"
 #include "foldingregion.h"
 #include "format.h"
 #include "format_p.h"
 #include "state.h"
 #include "theme.h"
 #include "themedata_p.h"
 
 Q_DECLARE_METATYPE(QTextBlock)
 
 using namespace KSyntaxHighlighting;
 
 namespace KSyntaxHighlighting
 {
 class TextBlockUserData : public QTextBlockUserData
 {
 public:
     State state;
     QList<FoldingRegion> foldingRegions;
 };
 
 class SyntaxHighlighterPrivate : public AbstractHighlighterPrivate
 {
 public:
     static FoldingRegion foldingRegion(const QTextBlock &startBlock);
     void initTextFormat(QTextCharFormat &tf, const Format &format);
     void computeTextFormats();
 
     struct TextFormat {
         QTextCharFormat tf;
         /**
          * id to check that the format belongs to the definition
          */
         std::intptr_t ptrId;
     };
 
     QList<FoldingRegion> foldingRegions;
     std::vector<TextFormat> tfs;
 };
 
 }
 
 FoldingRegion SyntaxHighlighterPrivate::foldingRegion(const QTextBlock &startBlock)
 {
     const auto data = dynamic_cast<TextBlockUserData *>(startBlock.userData());
     if (!data) {
         return FoldingRegion();
     }
     for (int i = data->foldingRegions.size() - 1; i >= 0; --i) {
         if (data->foldingRegions.at(i).type() == FoldingRegion::Begin) {
             return data->foldingRegions.at(i);
         }
     }
     return FoldingRegion();
 }
 
 void SyntaxHighlighterPrivate::initTextFormat(QTextCharFormat &tf, const Format &format)
 {
     // always set the foreground color to avoid palette issues
     tf.setForeground(format.textColor(m_theme));
 
     if (format.hasBackgroundColor(m_theme)) {
         tf.setBackground(format.backgroundColor(m_theme));
     }
     if (format.isBold(m_theme)) {
         tf.setFontWeight(QFont::Bold);
     }
     if (format.isItalic(m_theme)) {
         tf.setFontItalic(true);
     }
     if (format.isUnderline(m_theme)) {
         tf.setFontUnderline(true);
     }
     if (format.isStrikeThrough(m_theme)) {
         tf.setFontStrikeOut(true);
     }
 }
 
 void SyntaxHighlighterPrivate::computeTextFormats()
 {
     auto definitions = m_definition.includedDefinitions();
     definitions.append(m_definition);
 
     int maxId = 0;
     for (const auto &definition : std::as_const(definitions)) {
         for (const auto &format : std::as_const(DefinitionData::get(definition)->formats)) {
             maxId = qMax(maxId, format.id());
         }
     }
     tfs.clear();
     tfs.resize(maxId + 1);
 
     // initialize tfs
     for (const auto &definition : std::as_const(definitions)) {
         for (const auto &format : std::as_const(DefinitionData::get(definition)->formats)) {
             auto &tf = tfs[format.id()];
             tf.ptrId = FormatPrivate::ptrId(format);
             initTextFormat(tf.tf, format);
         }
     }
 }
 
 SyntaxHighlighter::SyntaxHighlighter(QObject *parent)
     : QSyntaxHighlighter(parent)
     , AbstractHighlighter(new SyntaxHighlighterPrivate)
 {
     qRegisterMetaType<QTextBlock>();
 }
 
 SyntaxHighlighter::SyntaxHighlighter(QTextDocument *document)
     : QSyntaxHighlighter(document)
     , AbstractHighlighter(new SyntaxHighlighterPrivate)
 {
     qRegisterMetaType<QTextBlock>();
 }
 
 SyntaxHighlighter::~SyntaxHighlighter()
 {
 }
 
 void SyntaxHighlighter::setDefinition(const Definition &def)
 {
     Q_D(SyntaxHighlighter);
 
     const auto needsRehighlight = d->m_definition != def;
     if (DefinitionData::get(d->m_definition) != DefinitionData::get(def)) {
         d->m_definition = def;
         d->tfs.clear();
     }
     if (needsRehighlight) {
         rehighlight();
     }
 }
 
 void SyntaxHighlighter::setTheme(const Theme &theme)
 {
     Q_D(SyntaxHighlighter);
     if (ThemeData::get(d->m_theme) != ThemeData::get(theme)) {
         d->m_theme = theme;
         d->tfs.clear();
     }
 }
 
 bool SyntaxHighlighter::startsFoldingRegion(const QTextBlock &startBlock) const
 {
     return SyntaxHighlighterPrivate::foldingRegion(startBlock).type() == FoldingRegion::Begin;
 }
 
 QTextBlock SyntaxHighlighter::findFoldingRegionEnd(const QTextBlock &startBlock) const
 {
     const auto region = SyntaxHighlighterPrivate::foldingRegion(startBlock);
 
     auto block = startBlock;
     int depth = 1;
     while (block.isValid()) {
         block = block.next();
         const auto data = dynamic_cast<TextBlockUserData *>(block.userData());
         if (!data) {
             continue;
         }
         for (const auto &foldingRegion : std::as_const(data->foldingRegions)) {
             if (foldingRegion.id() != region.id()) {
                 continue;
             }
             if (foldingRegion.type() == FoldingRegion::End) {
                 --depth;
             } else if (foldingRegion.type() == FoldingRegion::Begin) {
                 ++depth;
             }
             if (depth == 0) {
                 return block;
             }
         }
     }
 
     return QTextBlock();
 }
 
 void SyntaxHighlighter::highlightBlock(const QString &text)
 {
     Q_D(SyntaxHighlighter);
 
     static const State emptyState;
     const State *previousState = &emptyState;
     if (currentBlock().position() > 0) {
         const auto prevBlock = currentBlock().previous();
         const auto prevData = dynamic_cast<TextBlockUserData *>(prevBlock.userData());
         if (prevData) {
             previousState = &prevData->state;
         }
     }
     d->foldingRegions.clear();
     auto newState = highlightLine(text, *previousState);
 
     auto data = dynamic_cast<TextBlockUserData *>(currentBlockUserData());
     if (!data) { // first time we highlight this
         data = new TextBlockUserData;
         data->state = std::move(newState);
         data->foldingRegions = d->foldingRegions;
         setCurrentBlockUserData(data);
         return;
     }
 
     if (data->state == newState && data->foldingRegions == d->foldingRegions) { // we ended up in the same state, so we are done here
         return;
     }
     data->state = std::move(newState);
     data->foldingRegions = d->foldingRegions;
 
     const auto nextBlock = currentBlock().next();
     if (nextBlock.isValid()) {
         QMetaObject::invokeMethod(this, "rehighlightBlock", Qt::QueuedConnection, Q_ARG(QTextBlock, nextBlock));
     }
 }
 
 void SyntaxHighlighter::applyFormat(int offset, int length, const Format &format)
 {
     if (length == 0) {
         return;
     }
 
     Q_D(SyntaxHighlighter);
 
     if (Q_UNLIKELY(d->tfs.empty())) {
         d->computeTextFormats();
     }
 
     const auto id = static_cast<std::size_t>(format.id());
     // This doesn't happen when format comes from the definition.
     // But as the user can override the function to pass any format, this is a possible scenario.
     if (id < d->tfs.size() && d->tfs[id].ptrId == FormatPrivate::ptrId(format)) {
         QSyntaxHighlighter::setFormat(offset, length, d->tfs[id].tf);
     } else {
         QTextCharFormat tf;
         d->initTextFormat(tf, format);
         QSyntaxHighlighter::setFormat(offset, length, tf);
     }
 }
 
 void SyntaxHighlighter::applyFolding(int offset, int length, FoldingRegion region)
 {
     Q_UNUSED(offset);
     Q_UNUSED(length);
     Q_D(SyntaxHighlighter);
 
     if (region.type() == FoldingRegion::Begin) {
         d->foldingRegions.push_back(region);
     }
 
     if (region.type() == FoldingRegion::End) {
         for (int i = d->foldingRegions.size() - 1; i >= 0; --i) {
             if (d->foldingRegions.at(i).id() != region.id() || d->foldingRegions.at(i).type() != FoldingRegion::Begin) {
                 continue;
             }
             d->foldingRegions.remove(i);
             return;
         }
         d->foldingRegions.push_back(region);
     }
 }
 
 #include "moc_syntaxhighlighter.cpp"