mirror of
https://gitee.com/vnotex/vnote.git
synced 2025-07-05 13:59:52 +08:00
1317 lines
38 KiB
C++
1317 lines
38 KiB
C++
#include <QtGui>
|
|
#include <QtDebug>
|
|
#include <QTextCursor>
|
|
#include <algorithm>
|
|
#include "hgmarkdownhighlighter.h"
|
|
#include "vconfigmanager.h"
|
|
#include "utils/vutils.h"
|
|
|
|
extern VConfigManager *g_config;
|
|
|
|
const int HGMarkdownHighlighter::initCapacity = 1024;
|
|
|
|
void HGMarkdownHighlighter::resizeBuffer(int newCap)
|
|
{
|
|
if (newCap == capacity) {
|
|
return;
|
|
}
|
|
if (capacity > 0) {
|
|
Q_ASSERT(content);
|
|
delete [] content;
|
|
}
|
|
capacity = newCap;
|
|
content = new char [capacity];
|
|
}
|
|
|
|
// Will be freeed by parent automatically
|
|
HGMarkdownHighlighter::HGMarkdownHighlighter(const QVector<HighlightingStyle> &styles,
|
|
const QHash<QString, QTextCharFormat> &codeBlockStyles,
|
|
int waitInterval,
|
|
QTextDocument *parent)
|
|
: QSyntaxHighlighter(parent),
|
|
highlightingStyles(styles),
|
|
m_codeBlockStyles(codeBlockStyles),
|
|
m_numOfCodeBlockHighlightsToRecv(0),
|
|
parsing(0),
|
|
m_blockHLResultReady(false),
|
|
waitInterval(waitInterval),
|
|
m_enableMathjax(false),
|
|
m_signalOut(false),
|
|
content(NULL),
|
|
capacity(0),
|
|
result(NULL)
|
|
{
|
|
codeBlockStartExp = QRegExp(VUtils::c_fencedCodeBlockStartRegExp);
|
|
codeBlockEndExp = QRegExp(VUtils::c_fencedCodeBlockEndRegExp);
|
|
|
|
m_mathjaxInlineExp = QRegExp(VUtils::c_mathjaxInlineRegExp);
|
|
m_mathjaxBlockExp = QRegExp(VUtils::c_mathjaxBlockRegExp);
|
|
|
|
m_codeBlockFormat.setForeground(QBrush(Qt::darkYellow));
|
|
for (int index = 0; index < styles.size(); ++index) {
|
|
switch (styles[index].type) {
|
|
case pmh_VERBATIM:
|
|
m_codeBlockFormat = styles[index].format;
|
|
break;
|
|
|
|
case pmh_LINK:
|
|
m_linkFormat = styles[index].format;
|
|
break;
|
|
|
|
case pmh_IMAGE:
|
|
m_imageFormat = styles[index].format;
|
|
break;
|
|
|
|
case pmh_CODE:
|
|
// Use inline code font family for MathJax format.
|
|
m_mathjaxFormat.setFontFamily(styles[index].format.fontFamily());
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
m_colorColumnFormat = m_codeBlockFormat;
|
|
m_colorColumnFormat.setForeground(QColor(g_config->getEditorColorColumnFg()));
|
|
m_colorColumnFormat.setBackground(QColor(g_config->getEditorColorColumnBg()));
|
|
|
|
m_mathjaxFormat.setForeground(QColor(g_config->getEditorMathjaxFg()));
|
|
|
|
m_headerStyles.resize(6);
|
|
for (auto const & it : highlightingStyles) {
|
|
if (it.type >= pmh_H1 && it.type <= pmh_H6) {
|
|
m_headerStyles[it.type - pmh_H1] = it.format;
|
|
}
|
|
}
|
|
|
|
resizeBuffer(initCapacity);
|
|
document = parent;
|
|
|
|
timer = new QTimer(this);
|
|
timer->setSingleShot(true);
|
|
timer->setInterval(this->waitInterval);
|
|
connect(timer, &QTimer::timeout,
|
|
this, [this]() {
|
|
startParseAndHighlight(false);
|
|
});
|
|
|
|
const int completeWaitTime = 400;
|
|
m_completeTimer = new QTimer(this);
|
|
m_completeTimer->setSingleShot(true);
|
|
m_completeTimer->setInterval(completeWaitTime);
|
|
connect(m_completeTimer, &QTimer::timeout,
|
|
this, &HGMarkdownHighlighter::completeHighlight);
|
|
|
|
connect(document, &QTextDocument::contentsChange,
|
|
this, &HGMarkdownHighlighter::handleContentChange);
|
|
}
|
|
|
|
HGMarkdownHighlighter::~HGMarkdownHighlighter()
|
|
{
|
|
if (result) {
|
|
pmh_free_elements(result);
|
|
result = NULL;
|
|
}
|
|
if (content) {
|
|
delete [] content;
|
|
capacity = 0;
|
|
content = NULL;
|
|
}
|
|
}
|
|
|
|
void HGMarkdownHighlighter::updateBlockUserData(int p_blockNum, const QString &p_text)
|
|
{
|
|
Q_UNUSED(p_text);
|
|
|
|
VTextBlockData *blockData = currentBlockData();
|
|
if (!blockData) {
|
|
blockData = new VTextBlockData();
|
|
setCurrentBlockUserData(blockData);
|
|
} else {
|
|
blockData->setCodeBlockIndentation(-1);
|
|
blockData->clearMathjax();
|
|
}
|
|
|
|
if (blockData->getPreviews().isEmpty()) {
|
|
m_possiblePreviewBlocks.remove(p_blockNum);
|
|
} else {
|
|
m_possiblePreviewBlocks.insert(p_blockNum);
|
|
}
|
|
}
|
|
|
|
void HGMarkdownHighlighter::highlightBlock(const QString &text)
|
|
{
|
|
QTextBlock curBlock = currentBlock();
|
|
int blockNum = curBlock.blockNumber();
|
|
if (m_blockHLResultReady && m_blockHighlights.size() > blockNum) {
|
|
// units are sorted by start position and length.
|
|
const QVector<HLUnit> &units = m_blockHighlights[blockNum];
|
|
if (!units.isEmpty()) {
|
|
for (int i = 0; i < units.size(); ++i) {
|
|
const HLUnit &unit = units[i];
|
|
if (i == 0) {
|
|
// No need to merge format.
|
|
setFormat(unit.start,
|
|
unit.length,
|
|
highlightingStyles[unit.styleIndex].format);
|
|
} else {
|
|
QTextCharFormat newFormat = highlightingStyles[unit.styleIndex].format;
|
|
for (int j = i - 1; j >= 0; --j) {
|
|
if (units[j].start + units[j].length <= unit.start) {
|
|
// It won't affect current unit.
|
|
continue;
|
|
} else {
|
|
// Merge the format.
|
|
QTextCharFormat tmpFormat(newFormat);
|
|
newFormat = highlightingStyles[units[j].styleIndex].format;
|
|
// tmpFormat takes precedence.
|
|
newFormat.merge(tmpFormat);
|
|
}
|
|
}
|
|
|
|
setFormat(unit.start, unit.length, newFormat);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// We use PEG Markdown Highlight as the main highlighter.
|
|
// We can use other highlighting methods to complement it.
|
|
|
|
// Set current block's user data.
|
|
updateBlockUserData(blockNum, text);
|
|
|
|
int preState = previousBlockState();
|
|
bool inCodeblock = preState == HighlightBlockState::CodeBlock
|
|
|| preState == HighlightBlockState::CodeBlockStart;
|
|
|
|
// If it is a block inside HTML comment, just skip it.
|
|
// Pay attention to distinguish the HTML comments inside a fenced code block.
|
|
if (!inCodeblock && isBlockInsideCommentRegion(curBlock)) {
|
|
setCurrentBlockState(HighlightBlockState::Comment);
|
|
goto exit;
|
|
}
|
|
|
|
setCurrentBlockState(HighlightBlockState::Normal);
|
|
|
|
highlightCodeBlock(blockNum, text);
|
|
|
|
if (currentBlockState() == HighlightBlockState::Normal) {
|
|
if (isVerbatimBlock(curBlock)) {
|
|
setCurrentBlockState(HighlightBlockState::Verbatim);
|
|
goto exit;
|
|
}
|
|
|
|
highlightHeaderFast(blockNum, text);
|
|
|
|
if (m_enableMathjax
|
|
&& currentBlockState() == HighlightBlockState::Normal) {
|
|
highlightMathJax(curBlock, text);
|
|
}
|
|
}
|
|
|
|
if (currentBlockState() != HighlightBlockState::CodeBlock) {
|
|
goto exit;
|
|
}
|
|
|
|
// Highlight CodeBlock using VCodeBlockHighlightHelper.
|
|
if (m_codeBlockHighlights.size() > blockNum) {
|
|
const QVector<HLUnitStyle> &units = m_codeBlockHighlights[blockNum];
|
|
if (!units.isEmpty()) {
|
|
QVector<QTextCharFormat *> formats(units.size(), NULL);
|
|
for (int i = 0; i < units.size(); ++i) {
|
|
const HLUnitStyle &unit = units[i];
|
|
auto it = m_codeBlockStyles.find(unit.style);
|
|
if (it == m_codeBlockStyles.end()) {
|
|
continue;
|
|
}
|
|
|
|
formats[i] = &(*it);
|
|
|
|
QTextCharFormat newFormat = m_codeBlockFormat;
|
|
newFormat.merge(*it);
|
|
for (int j = i - 1; j >= 0; --j) {
|
|
if (units[j].start + units[j].length <= unit.start) {
|
|
// It won't affect current unit.
|
|
continue;
|
|
} else {
|
|
// Merge the format.
|
|
if (formats[j]) {
|
|
QTextCharFormat tmpFormat(newFormat);
|
|
newFormat = *(formats[j]);
|
|
// tmpFormat takes precedence.
|
|
newFormat.merge(tmpFormat);
|
|
}
|
|
}
|
|
}
|
|
|
|
setFormat(unit.start, unit.length, newFormat);
|
|
}
|
|
}
|
|
}
|
|
|
|
highlightCodeBlockColorColumn(text);
|
|
|
|
exit:
|
|
highlightChanged();
|
|
}
|
|
|
|
static bool compHLUnit(const HLUnit &p_a, const HLUnit &p_b)
|
|
{
|
|
if (p_a.start < p_b.start) {
|
|
return true;
|
|
} else if (p_a.start == p_b.start) {
|
|
return p_a.length > p_b.length;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void HGMarkdownHighlighter::initBlockHighlightFromResult(int nrBlocks)
|
|
{
|
|
m_blockHighlights.resize(nrBlocks);
|
|
for (int i = 0; i < m_blockHighlights.size(); ++i) {
|
|
m_blockHighlights[i].clear();
|
|
}
|
|
|
|
if (!result) {
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < highlightingStyles.size(); i++)
|
|
{
|
|
const HighlightingStyle &style = highlightingStyles[i];
|
|
pmh_element *elem_cursor = result[style.type];
|
|
|
|
while (elem_cursor != NULL)
|
|
{
|
|
// elem_cursor->pos and elem_cursor->end is the start
|
|
// and end position of the element in document.
|
|
if (elem_cursor->end <= elem_cursor->pos) {
|
|
elem_cursor = elem_cursor->next;
|
|
continue;
|
|
}
|
|
|
|
initBlockHighlihgtOne(elem_cursor->pos, elem_cursor->end, i);
|
|
elem_cursor = elem_cursor->next;
|
|
}
|
|
}
|
|
|
|
// Sort m_blockHighlights.
|
|
for (int i = 0; i < m_blockHighlights.size(); ++i) {
|
|
if (m_blockHighlights[i].size() > 1) {
|
|
std::sort(m_blockHighlights[i].begin(), m_blockHighlights[i].end(), compHLUnit);
|
|
}
|
|
}
|
|
}
|
|
|
|
void HGMarkdownHighlighter::initHtmlCommentRegionsFromResult()
|
|
{
|
|
m_commentRegions.clear();
|
|
|
|
if (!result) {
|
|
return;
|
|
}
|
|
|
|
pmh_element *elem = result[pmh_COMMENT];
|
|
while (elem != NULL) {
|
|
if (elem->end <= elem->pos) {
|
|
elem = elem->next;
|
|
continue;
|
|
}
|
|
|
|
initBlockElementRegionOne(m_commentRegions, elem->pos, elem->end);
|
|
elem = elem->next;
|
|
}
|
|
}
|
|
|
|
void HGMarkdownHighlighter::initImageRegionsFromResult()
|
|
{
|
|
// From Qt5.7, the capacity is preserved.
|
|
m_imageRegions.clear();
|
|
|
|
if (!result) {
|
|
return;
|
|
}
|
|
|
|
pmh_element *elem = result[pmh_IMAGE];
|
|
while (elem != NULL) {
|
|
if (elem->end <= elem->pos) {
|
|
elem = elem->next;
|
|
continue;
|
|
}
|
|
|
|
m_imageRegions.push_back(VElementRegion(elem->pos, elem->end));
|
|
elem = elem->next;
|
|
}
|
|
}
|
|
|
|
void HGMarkdownHighlighter::initVerbatimBlocksFromResult()
|
|
{
|
|
m_verbatimBlocks.clear();
|
|
if (!result) {
|
|
return;
|
|
}
|
|
|
|
pmh_element *elem = result[pmh_VERBATIM];
|
|
while (elem != NULL) {
|
|
if (elem->end <= elem->pos) {
|
|
elem = elem->next;
|
|
continue;
|
|
}
|
|
|
|
// [firstBlock, lastBlock].
|
|
int firstBlock = document->findBlock(elem->pos).blockNumber();
|
|
int lastBlock = document->findBlock(elem->end - 1).blockNumber();
|
|
for (int i = firstBlock; i <= lastBlock; ++i) {
|
|
m_verbatimBlocks.insert(i);
|
|
}
|
|
|
|
elem = elem->next;
|
|
}
|
|
}
|
|
|
|
void HGMarkdownHighlighter::initFencedCodeBlocksFromResult()
|
|
{
|
|
m_codeBlocks.clear();
|
|
m_codeBlocksState.clear();
|
|
if (!result) {
|
|
return;
|
|
}
|
|
|
|
// Ordered by start position in ascending order.
|
|
QMap<int, VElementRegion> regs;
|
|
|
|
pmh_element *elem = result[pmh_FENCEDCODEBLOCK];
|
|
while (elem != NULL) {
|
|
if (elem->end <= elem->pos) {
|
|
elem = elem->next;
|
|
continue;
|
|
}
|
|
|
|
if (!regs.contains(elem->pos)) {
|
|
regs.insert(elem->pos, VElementRegion(elem->pos, elem->end));
|
|
}
|
|
|
|
elem = elem->next;
|
|
}
|
|
|
|
VCodeBlock item;
|
|
bool inBlock = false;
|
|
for (auto it = regs.begin(); it != regs.end(); ++it) {
|
|
// [firstBlock, lastBlock].
|
|
int firstBlock = document->findBlock(it.value().m_startPos).blockNumber();
|
|
int lastBlock = document->findBlock(it.value().m_endPos - 1).blockNumber();
|
|
|
|
QTextBlock block = document->findBlockByNumber(firstBlock);
|
|
while (block.isValid()) {
|
|
int blockNumber = block.blockNumber();
|
|
if (blockNumber > lastBlock) {
|
|
break;
|
|
}
|
|
|
|
HighlightBlockState state = HighlightBlockState::Normal;
|
|
QString text = block.text();
|
|
if (inBlock) {
|
|
item.m_text = item.m_text + "\n" + text;
|
|
int idx = codeBlockEndExp.indexIn(text);
|
|
if (idx >= 0) {
|
|
// End block.
|
|
inBlock = false;
|
|
state = HighlightBlockState::CodeBlockEnd;
|
|
item.m_endBlock = blockNumber;
|
|
m_codeBlocks.append(item);
|
|
} else {
|
|
// Within code block.
|
|
state = HighlightBlockState::CodeBlock;
|
|
}
|
|
} else {
|
|
int idx = codeBlockStartExp.indexIn(text);
|
|
if (idx >= 0) {
|
|
// Start block.
|
|
inBlock = true;
|
|
state = HighlightBlockState::CodeBlockStart;
|
|
item.m_startBlock = blockNumber;
|
|
item.m_startPos = block.position();
|
|
item.m_text = text;
|
|
if (codeBlockStartExp.captureCount() == 2) {
|
|
item.m_lang = codeBlockStartExp.capturedTexts()[2];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (state != HighlightBlockState::Normal) {
|
|
m_codeBlocksState.insert(blockNumber, state);
|
|
}
|
|
|
|
block = block.next();
|
|
}
|
|
}
|
|
}
|
|
|
|
void HGMarkdownHighlighter::initHeaderRegionsFromResult()
|
|
{
|
|
// From Qt5.7, the capacity is preserved.
|
|
m_headerBlocks.clear();
|
|
m_headerRegions.clear();
|
|
|
|
if (!result) {
|
|
return;
|
|
}
|
|
|
|
pmh_element_type hx[6] = {pmh_H1, pmh_H2, pmh_H3, pmh_H4, pmh_H5, pmh_H6};
|
|
for (int i = 0; i < 6; ++i) {
|
|
pmh_element *elem = result[hx[i]];
|
|
while (elem != NULL) {
|
|
if (elem->end <= elem->pos) {
|
|
elem = elem->next;
|
|
continue;
|
|
}
|
|
|
|
m_headerRegions.push_back(VElementRegion(elem->pos, elem->end));
|
|
|
|
QTextBlock block = document->findBlock(elem->pos);
|
|
if (block.isValid()) {
|
|
// Header element will contain the new line character.
|
|
m_headerBlocks.insert(block.blockNumber(), HeaderBlockInfo(i, elem->end - elem->pos - 1));
|
|
}
|
|
|
|
elem = elem->next;
|
|
}
|
|
}
|
|
|
|
std::sort(m_headerRegions.begin(), m_headerRegions.end());
|
|
}
|
|
|
|
void HGMarkdownHighlighter::initBlockHighlihgtOne(unsigned long pos,
|
|
unsigned long end,
|
|
int styleIndex)
|
|
{
|
|
// When the the highlight element is at the end of document, @end will equals
|
|
// to the characterCount.
|
|
unsigned int nrChar = (unsigned int)document->characterCount();
|
|
if (end >= nrChar && nrChar > 0) {
|
|
end = nrChar - 1;
|
|
}
|
|
|
|
int startBlockNum = document->findBlock(pos).blockNumber();
|
|
int endBlockNum = document->findBlock(end).blockNumber();
|
|
|
|
for (int i = startBlockNum; i <= endBlockNum; ++i)
|
|
{
|
|
QTextBlock block = document->findBlockByNumber(i);
|
|
int blockStartPos = block.position();
|
|
HLUnit unit;
|
|
if (i == startBlockNum) {
|
|
unit.start = pos - blockStartPos;
|
|
unit.length = (startBlockNum == endBlockNum) ?
|
|
(end - pos) : (block.length() - unit.start);
|
|
} else if (i == endBlockNum) {
|
|
unit.start = 0;
|
|
unit.length = end - blockStartPos;
|
|
} else {
|
|
unit.start = 0;
|
|
unit.length = block.length();
|
|
}
|
|
unit.styleIndex = styleIndex;
|
|
|
|
m_blockHighlights[i].append(unit);
|
|
}
|
|
}
|
|
|
|
void HGMarkdownHighlighter::highlightCodeBlock(int p_blockNumber, const QString &p_text)
|
|
{
|
|
auto it = m_codeBlocksState.find(p_blockNumber);
|
|
if (it != m_codeBlocksState.end()) {
|
|
VTextBlockData *blockData = currentBlockData();
|
|
Q_ASSERT(blockData);
|
|
|
|
HighlightBlockState state = it.value();
|
|
// Set code block indentation.
|
|
switch (state) {
|
|
case HighlightBlockState::CodeBlockStart:
|
|
{
|
|
int index = codeBlockStartExp.indexIn(p_text);
|
|
Q_ASSERT(index >= 0);
|
|
blockData->setCodeBlockIndentation(codeBlockStartExp.capturedTexts()[1].size());
|
|
break;
|
|
}
|
|
|
|
case HighlightBlockState::CodeBlock:
|
|
V_FALLTHROUGH;
|
|
case HighlightBlockState::CodeBlockEnd:
|
|
{
|
|
int startLeadingSpaces = 0;
|
|
VTextBlockData *preBlockData = previousBlockData();
|
|
if (preBlockData) {
|
|
startLeadingSpaces = preBlockData->getCodeBlockIndentation();
|
|
}
|
|
|
|
blockData->setCodeBlockIndentation(startLeadingSpaces);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
Q_ASSERT(false);
|
|
break;
|
|
}
|
|
|
|
// Set code block state.
|
|
setCurrentBlockState(state);
|
|
}
|
|
}
|
|
|
|
static bool intersect(const QList<QPair<int, int>> &p_indices, int &p_start, int &p_end)
|
|
{
|
|
for (auto const & range : p_indices) {
|
|
if (p_end <= range.first) {
|
|
return false;
|
|
} else if (p_start < range.second) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void HGMarkdownHighlighter::highlightMathJax(const QTextBlock &p_block, const QString &p_text)
|
|
{
|
|
const int blockMarkLength = 2;
|
|
const int inlineMarkLength = 1;
|
|
|
|
VTextBlockData *blockData = currentBlockData();
|
|
Q_ASSERT(blockData);
|
|
|
|
int blockNumber = p_block.blockNumber();
|
|
|
|
int startIdx = 0;
|
|
// Next position to search.
|
|
int pos = 0;
|
|
HighlightBlockState state = (HighlightBlockState)previousBlockState();
|
|
|
|
QList<QPair<int, int>> blockIdices;
|
|
|
|
bool fromPreBlock = true;
|
|
// Mathjax block formula.
|
|
if (state != HighlightBlockState::MathjaxBlock) {
|
|
fromPreBlock = false;
|
|
startIdx = findMathjaxMarker(blockNumber, p_text, pos, m_mathjaxBlockExp, blockMarkLength);
|
|
pos = startIdx + blockMarkLength;
|
|
}
|
|
|
|
while (startIdx >= 0) {
|
|
int endIdx = findMathjaxMarker(blockNumber, p_text, pos, m_mathjaxBlockExp, blockMarkLength);
|
|
int mathLength = 0;
|
|
MathjaxInfo info;
|
|
bool valid = false;
|
|
if (endIdx == -1) {
|
|
mathLength = p_text.length() - startIdx;
|
|
pos = p_text.length();
|
|
|
|
if (isValidMathjaxRegion(blockNumber, startIdx, pos)) {
|
|
valid = true;
|
|
setCurrentBlockState(HighlightBlockState::MathjaxBlock);
|
|
info.m_previewedAsBlock = false;
|
|
info.m_index = startIdx,
|
|
info.m_length = mathLength;
|
|
if (fromPreBlock) {
|
|
VTextBlockData *preBlockData = previousBlockData();
|
|
Q_ASSERT(preBlockData);
|
|
const MathjaxInfo &preInfo = preBlockData->getPendingMathjax();
|
|
info.m_text = preInfo.text() + "\n" + p_text.mid(startIdx, mathLength);
|
|
} else {
|
|
info.m_text = p_text.mid(startIdx, mathLength);
|
|
}
|
|
|
|
blockData->setPendingMathjax(info);
|
|
}
|
|
} else {
|
|
// Found end marker of a formula.
|
|
pos = endIdx + blockMarkLength;
|
|
mathLength = pos - startIdx;
|
|
|
|
if (isValidMathjaxRegion(blockNumber, startIdx, pos)) {
|
|
valid = true;
|
|
info.m_previewedAsBlock = false;
|
|
info.m_index = startIdx;
|
|
info.m_length = mathLength;
|
|
if (fromPreBlock) {
|
|
// A cross-block formula.
|
|
if (pos >= p_text.length()) {
|
|
info.m_previewedAsBlock = true;
|
|
}
|
|
|
|
VTextBlockData *preBlockData = previousBlockData();
|
|
Q_ASSERT(preBlockData);
|
|
const MathjaxInfo &preInfo = preBlockData->getPendingMathjax();
|
|
info.m_text = preInfo.text() + "\n" + p_text.mid(startIdx, mathLength);
|
|
} else {
|
|
// A formula within one block.
|
|
if (pos >= p_text.length() && startIdx == 0) {
|
|
info.m_previewedAsBlock = true;
|
|
}
|
|
|
|
info.m_text = p_text.mid(startIdx, mathLength);
|
|
}
|
|
|
|
blockData->addMathjax(info);
|
|
}
|
|
}
|
|
|
|
fromPreBlock = false;
|
|
|
|
if (valid) {
|
|
blockIdices.append(QPair<int, int>(startIdx, pos));
|
|
setFormat(startIdx, mathLength, m_mathjaxFormat);
|
|
startIdx = findMathjaxMarker(blockNumber, p_text, pos, m_mathjaxBlockExp, blockMarkLength);
|
|
pos = startIdx + blockMarkLength;
|
|
} else {
|
|
// Make the second mark as the first one and try again.
|
|
if (endIdx == -1) {
|
|
break;
|
|
}
|
|
|
|
startIdx = pos - blockMarkLength;
|
|
}
|
|
}
|
|
|
|
// Mathjax inline formula.
|
|
startIdx = 0;
|
|
pos = 0;
|
|
fromPreBlock = true;
|
|
if (state != HighlightBlockState::MathjaxInline) {
|
|
fromPreBlock = false;
|
|
startIdx = findMathjaxMarker(blockNumber, p_text, pos, m_mathjaxInlineExp, inlineMarkLength);
|
|
pos = startIdx + inlineMarkLength;
|
|
}
|
|
|
|
while (startIdx >= 0) {
|
|
int endIdx = findMathjaxMarker(blockNumber, p_text, pos, m_mathjaxInlineExp, inlineMarkLength);
|
|
int mathLength = 0;
|
|
bool valid = false;
|
|
if (endIdx == -1) {
|
|
mathLength = p_text.length() - startIdx;
|
|
pos = p_text.length();
|
|
} else {
|
|
pos = endIdx + inlineMarkLength;
|
|
mathLength = pos - startIdx;
|
|
}
|
|
|
|
valid = isValidMathjaxRegion(blockNumber, startIdx, pos);
|
|
// Check if it intersect with blocks.
|
|
if (valid && !intersect(blockIdices, startIdx, pos)) {
|
|
// A valid inline mathjax.
|
|
MathjaxInfo info;
|
|
if (endIdx == -1) {
|
|
setCurrentBlockState(HighlightBlockState::MathjaxInline);
|
|
|
|
info.m_previewedAsBlock = false;
|
|
info.m_index = startIdx,
|
|
info.m_length = mathLength;
|
|
if (fromPreBlock) {
|
|
VTextBlockData *preBlockData = previousBlockData();
|
|
Q_ASSERT(preBlockData);
|
|
const MathjaxInfo &preInfo = preBlockData->getPendingMathjax();
|
|
info.m_text = preInfo.text() + "\n" + p_text.mid(startIdx, mathLength);
|
|
} else {
|
|
info.m_text = p_text.mid(startIdx, mathLength);
|
|
}
|
|
|
|
blockData->setPendingMathjax(info);
|
|
} else {
|
|
info.m_previewedAsBlock = false;
|
|
info.m_index = startIdx;
|
|
info.m_length = mathLength;
|
|
if (fromPreBlock) {
|
|
// A cross-block formula.
|
|
if (pos >= p_text.length()) {
|
|
info.m_previewedAsBlock = true;
|
|
}
|
|
|
|
VTextBlockData *preBlockData = previousBlockData();
|
|
Q_ASSERT(preBlockData);
|
|
const MathjaxInfo &preInfo = preBlockData->getPendingMathjax();
|
|
info.m_text = preInfo.text() + "\n" + p_text.mid(startIdx, mathLength);
|
|
} else {
|
|
// A formula within one block.
|
|
if (pos >= p_text.length() && startIdx == 0) {
|
|
info.m_previewedAsBlock = true;
|
|
}
|
|
|
|
info.m_text = p_text.mid(startIdx, mathLength);
|
|
}
|
|
|
|
blockData->addMathjax(info);
|
|
}
|
|
|
|
setFormat(startIdx, mathLength, m_mathjaxFormat);
|
|
|
|
startIdx = m_mathjaxInlineExp.indexIn(p_text, pos);
|
|
pos = startIdx + m_mathjaxInlineExp.matchedLength();
|
|
startIdx = pos - inlineMarkLength;
|
|
} else {
|
|
// Make the second mark as the first one and try again.
|
|
if (endIdx == -1) {
|
|
break;
|
|
}
|
|
|
|
startIdx = pos - inlineMarkLength;
|
|
}
|
|
|
|
fromPreBlock = false;
|
|
}
|
|
}
|
|
|
|
void HGMarkdownHighlighter::highlightCodeBlockColorColumn(const QString &p_text)
|
|
{
|
|
int cc = g_config->getColorColumn();
|
|
if (cc <= 0 || currentBlockState() != HighlightBlockState::CodeBlock) {
|
|
return;
|
|
}
|
|
|
|
VTextBlockData *blockData = currentBlockData();
|
|
Q_ASSERT(blockData);
|
|
int indent = blockData->getCodeBlockIndentation();
|
|
if (indent == -1) {
|
|
return;
|
|
}
|
|
|
|
cc += indent;
|
|
if (p_text.size() < cc) {
|
|
return;
|
|
}
|
|
|
|
setFormat(cc - 1, 1, m_colorColumnFormat);
|
|
}
|
|
|
|
void HGMarkdownHighlighter::parse()
|
|
{
|
|
if (!parsing.testAndSetRelaxed(0, 1)) {
|
|
return;
|
|
}
|
|
|
|
if (highlightingStyles.isEmpty()) {
|
|
goto exit;
|
|
}
|
|
|
|
{
|
|
m_blockHLResultReady = false;
|
|
|
|
int nrBlocks = document->blockCount();
|
|
parseInternal();
|
|
|
|
initBlockHighlightFromResult(nrBlocks);
|
|
|
|
m_blockHLResultReady = true;
|
|
|
|
initHtmlCommentRegionsFromResult();
|
|
|
|
initImageRegionsFromResult();
|
|
|
|
initHeaderRegionsFromResult();
|
|
|
|
initVerbatimBlocksFromResult();
|
|
|
|
initFencedCodeBlocksFromResult();
|
|
|
|
initInlineCodeRegionsFromResult();
|
|
|
|
initBoldItalicRegionsFromResult();
|
|
|
|
initLinkRegionsFromResult();
|
|
|
|
if (result) {
|
|
pmh_free_elements(result);
|
|
result = NULL;
|
|
}
|
|
}
|
|
|
|
exit:
|
|
parsing.store(0);
|
|
}
|
|
|
|
void HGMarkdownHighlighter::parseInternal()
|
|
{
|
|
QString text = document->toPlainText();
|
|
QByteArray ba = text.toUtf8();
|
|
const char *data = (const char *)ba.data();
|
|
int len = ba.size();
|
|
|
|
if (result) {
|
|
pmh_free_elements(result);
|
|
result = NULL;
|
|
}
|
|
|
|
if (len == 0) {
|
|
return;
|
|
} else if (len >= capacity) {
|
|
resizeBuffer(qMax(2 * capacity, len * 2));
|
|
} else if (len < (capacity >> 2)) {
|
|
resizeBuffer(qMax(capacity >> 1, len * 2));
|
|
}
|
|
|
|
memcpy(content, data, len);
|
|
content[len] = '\0';
|
|
|
|
int exts = pmh_EXT_STRIKE | pmh_EXT_FRONTMATTER;
|
|
pmh_markdown_to_elements(content, exts, &result);
|
|
}
|
|
|
|
void HGMarkdownHighlighter::handleContentChange(int /* position */, int charsRemoved, int charsAdded)
|
|
{
|
|
if (charsRemoved == 0 && charsAdded == 0) {
|
|
return;
|
|
}
|
|
|
|
m_signalOut = false;
|
|
|
|
timer->stop();
|
|
timer->start();
|
|
}
|
|
|
|
void HGMarkdownHighlighter::startParseAndHighlight(bool p_fast)
|
|
{
|
|
qDebug() << "HGMarkdownHighlighter start a new parse (fast" << p_fast << ")";
|
|
parse();
|
|
|
|
m_signalOut = !p_fast;
|
|
|
|
if (!p_fast) {
|
|
updateCodeBlocks();
|
|
}
|
|
|
|
rehighlight();
|
|
}
|
|
|
|
void HGMarkdownHighlighter::updateHighlight()
|
|
{
|
|
timer->stop();
|
|
startParseAndHighlight(false);
|
|
}
|
|
|
|
void HGMarkdownHighlighter::updateHighlightFast()
|
|
{
|
|
timer->stop();
|
|
startParseAndHighlight(true);
|
|
}
|
|
|
|
bool HGMarkdownHighlighter::updateCodeBlocks()
|
|
{
|
|
if (!g_config->getEnableCodeBlockHighlight()) {
|
|
m_codeBlockHighlights.clear();
|
|
return false;
|
|
}
|
|
|
|
m_codeBlockHighlights.resize(document->blockCount());
|
|
for (int i = 0; i < m_codeBlockHighlights.size(); ++i) {
|
|
m_codeBlockHighlights[i].clear();
|
|
}
|
|
|
|
m_numOfCodeBlockHighlightsToRecv = m_codeBlocks.size();
|
|
emit codeBlocksUpdated(m_codeBlocks);
|
|
return m_numOfCodeBlockHighlightsToRecv > 0;
|
|
}
|
|
|
|
static bool compHLUnitStyle(const HLUnitStyle &a, const HLUnitStyle &b)
|
|
{
|
|
if (a.start < b.start) {
|
|
return true;
|
|
} else if (a.start == b.start) {
|
|
return a.length > b.length;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void HGMarkdownHighlighter::setCodeBlockHighlights(const QVector<HLUnitPos> &p_units)
|
|
{
|
|
if (p_units.isEmpty()) {
|
|
goto exit;
|
|
}
|
|
|
|
{
|
|
QVector<QVector<HLUnitStyle>> highlights(m_codeBlockHighlights.size());
|
|
|
|
for (auto const &unit : p_units) {
|
|
int pos = unit.m_position;
|
|
int end = unit.m_position + unit.m_length;
|
|
int startBlockNum = document->findBlock(pos).blockNumber();
|
|
int endBlockNum = document->findBlock(end).blockNumber();
|
|
|
|
// Text has been changed. Abandon the obsolete parsed result.
|
|
if (startBlockNum == -1 || endBlockNum >= highlights.size()) {
|
|
goto exit;
|
|
}
|
|
|
|
for (int i = startBlockNum; i <= endBlockNum; ++i)
|
|
{
|
|
QTextBlock block = document->findBlockByNumber(i);
|
|
int blockStartPos = block.position();
|
|
HLUnitStyle hl;
|
|
hl.style = unit.m_style;
|
|
if (i == startBlockNum) {
|
|
hl.start = pos - blockStartPos;
|
|
hl.length = (startBlockNum == endBlockNum) ?
|
|
(end - pos) : (block.length() - hl.start);
|
|
} else if (i == endBlockNum) {
|
|
hl.start = 0;
|
|
hl.length = end - blockStartPos;
|
|
} else {
|
|
hl.start = 0;
|
|
hl.length = block.length();
|
|
}
|
|
|
|
highlights[i].append(hl);
|
|
}
|
|
}
|
|
|
|
// Need to highlight in order.
|
|
for (int i = 0; i < highlights.size(); ++i) {
|
|
QVector<HLUnitStyle> &units = highlights[i];
|
|
if (!units.isEmpty()) {
|
|
if (units.size() > 1) {
|
|
std::sort(units.begin(), units.end(), compHLUnitStyle);
|
|
}
|
|
|
|
m_codeBlockHighlights[i].append(units);
|
|
}
|
|
}
|
|
}
|
|
|
|
exit:
|
|
--m_numOfCodeBlockHighlightsToRecv;
|
|
if (m_numOfCodeBlockHighlightsToRecv <= 0) {
|
|
rehighlight();
|
|
}
|
|
}
|
|
|
|
bool HGMarkdownHighlighter::isBlockInsideCommentRegion(const QTextBlock &p_block) const
|
|
{
|
|
if (!p_block.isValid()) {
|
|
return false;
|
|
}
|
|
|
|
auto it = m_commentRegions.find(p_block.blockNumber());
|
|
if (it != m_commentRegions.end()) {
|
|
const QVector<VElementRegion> ®s = it.value();
|
|
if (regs.size() == 1
|
|
&& regs[0].m_startPos == 0
|
|
&& regs[0].m_endPos == p_block.length()) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void HGMarkdownHighlighter::highlightChanged()
|
|
{
|
|
m_completeTimer->stop();
|
|
m_completeTimer->start();
|
|
}
|
|
|
|
bool HGMarkdownHighlighter::isValidHeader(const QString &p_text)
|
|
{
|
|
// There must exist spaces after #s.
|
|
// No more than 6 #s.
|
|
int nrNumberSign = 0;
|
|
for (int i = 0; i < p_text.size(); ++i) {
|
|
QChar ch = p_text[i];
|
|
if (ch.isSpace()) {
|
|
return nrNumberSign > 0;
|
|
} else if (ch == QChar('#')) {
|
|
if (++nrNumberSign > 6) {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void HGMarkdownHighlighter::highlightHeaderFast(int p_blockNumber, const QString &p_text)
|
|
{
|
|
auto it = m_headerBlocks.find(p_blockNumber);
|
|
if (it != m_headerBlocks.end()) {
|
|
const HeaderBlockInfo &info = it.value();
|
|
if (!isValidHeader(p_text)) {
|
|
// Set an empty format to clear formats. It seems to work.
|
|
setFormat(0, p_text.size(), QTextCharFormat());
|
|
} else {
|
|
if (info.m_length < p_text.size()) {
|
|
setFormat(info.m_length,
|
|
p_text.size() - info.m_length,
|
|
m_headerStyles[info.m_level]);
|
|
}
|
|
|
|
setCurrentBlockState(HighlightBlockState::Header);
|
|
}
|
|
}
|
|
}
|
|
|
|
void HGMarkdownHighlighter::updateMathjaxBlocks()
|
|
{
|
|
if (!m_enableMathjax) {
|
|
return;
|
|
}
|
|
|
|
QVector<VMathjaxBlock> blocks;
|
|
QTextBlock bl = document->firstBlock();
|
|
while (bl.isValid()) {
|
|
VTextBlockData *data = static_cast<VTextBlockData *>(bl.userData());
|
|
if (!data) {
|
|
bl = bl.next();
|
|
continue;
|
|
}
|
|
|
|
const QVector<MathjaxInfo> &info = data->getMathjax();
|
|
for (auto const & it : info) {
|
|
blocks.append(VMathjaxBlock(bl.blockNumber(), it));
|
|
}
|
|
|
|
bl = bl.next();
|
|
}
|
|
|
|
emit mathjaxBlocksUpdated(blocks);
|
|
}
|
|
|
|
void HGMarkdownHighlighter::initInlineCodeRegionsFromResult()
|
|
{
|
|
m_inlineCodeRegions.clear();
|
|
|
|
if (!result) {
|
|
return;
|
|
}
|
|
|
|
pmh_element *elem = result[pmh_CODE];
|
|
while (elem != NULL) {
|
|
if (elem->end <= elem->pos) {
|
|
elem = elem->next;
|
|
continue;
|
|
}
|
|
|
|
initBlockElementRegionOne(m_inlineCodeRegions, elem->pos, elem->end);
|
|
elem = elem->next;
|
|
}
|
|
}
|
|
|
|
void HGMarkdownHighlighter::initBoldItalicRegionsFromResult()
|
|
{
|
|
m_boldItalicRegions.clear();
|
|
|
|
if (!result) {
|
|
return;
|
|
}
|
|
|
|
pmh_element_type types[2] = {pmh_EMPH, pmh_STRONG};
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
pmh_element *elem = result[types[i]];
|
|
while (elem != NULL) {
|
|
if (elem->end <= elem->pos) {
|
|
elem = elem->next;
|
|
continue;
|
|
}
|
|
|
|
initBlockElementRegionOne(m_boldItalicRegions, elem->pos, elem->end);
|
|
elem = elem->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
void HGMarkdownHighlighter::initLinkRegionsFromResult()
|
|
{
|
|
m_linkRegions.clear();
|
|
|
|
if (!result) {
|
|
return;
|
|
}
|
|
|
|
pmh_element_type types[2] = {pmh_LINK, pmh_IMAGE};
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
pmh_element *elem = result[types[i]];
|
|
while (elem != NULL) {
|
|
if (elem->end <= elem->pos) {
|
|
elem = elem->next;
|
|
continue;
|
|
}
|
|
|
|
initBlockElementRegionOne(m_linkRegions, elem->pos, elem->end);
|
|
elem = elem->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
void HGMarkdownHighlighter::initBlockElementRegionOne(QHash<int, QVector<VElementRegion>> &p_regs,
|
|
unsigned long p_pos,
|
|
unsigned long p_end)
|
|
{
|
|
// When the the highlight element is at the end of document, @p_end will equals
|
|
// to the characterCount.
|
|
unsigned int nrChar = (unsigned int)document->characterCount();
|
|
if (p_end >= nrChar && nrChar > 0) {
|
|
p_end = nrChar - 1;
|
|
}
|
|
|
|
int startBlockNum = document->findBlock(p_pos).blockNumber();
|
|
int endBlockNum = document->findBlock(p_end).blockNumber();
|
|
|
|
for (int i = startBlockNum; i <= endBlockNum; ++i)
|
|
{
|
|
QTextBlock block = document->findBlockByNumber(i);
|
|
int blockStartPos = block.position();
|
|
|
|
QVector<VElementRegion> ®s = p_regs[i];
|
|
int start, end;
|
|
if (i == startBlockNum) {
|
|
start = p_pos - blockStartPos;
|
|
end = (startBlockNum == endBlockNum) ? (p_end - blockStartPos)
|
|
: block.length();
|
|
} else if (i == endBlockNum) {
|
|
start = 0;
|
|
end = p_end - blockStartPos;
|
|
} else {
|
|
start = 0;
|
|
end = block.length();
|
|
}
|
|
|
|
regs.append(VElementRegion(start, end));
|
|
}
|
|
}
|
|
|
|
static bool indexInsideRegion(const QVector<VElementRegion> &p_regions, int p_idx)
|
|
{
|
|
for (auto const & reg : p_regions) {
|
|
if (reg.contains(p_idx)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
int HGMarkdownHighlighter::findMathjaxMarker(int p_blockNumber,
|
|
const QString &p_text,
|
|
int p_pos,
|
|
QRegExp &p_reg,
|
|
int p_markerLength)
|
|
{
|
|
if (p_pos >= p_text.size()) {
|
|
return -1;
|
|
}
|
|
|
|
int idx = -1;
|
|
auto inlineCodeIt = m_inlineCodeRegions.find(p_blockNumber);
|
|
auto commentIt = m_commentRegions.find(p_blockNumber);
|
|
auto boldItalicIt = m_boldItalicRegions.find(p_blockNumber);
|
|
auto linkIt = m_linkRegions.find(p_blockNumber);
|
|
|
|
while (p_pos < p_text.size()) {
|
|
idx = p_reg.indexIn(p_text, p_pos);
|
|
if (idx == -1) {
|
|
return idx;
|
|
}
|
|
|
|
p_pos = idx + p_reg.matchedLength();
|
|
idx = p_pos - p_markerLength;
|
|
|
|
// Check if this idx is legal.
|
|
// Check inline code.
|
|
if (inlineCodeIt != m_inlineCodeRegions.end()) {
|
|
if (indexInsideRegion(inlineCodeIt.value(), idx)) {
|
|
idx = -1;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (commentIt != m_commentRegions.end()) {
|
|
if (indexInsideRegion(commentIt.value(), idx)) {
|
|
idx = -1;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (boldItalicIt != m_boldItalicRegions.end()) {
|
|
if (indexInsideRegion(boldItalicIt.value(), idx)) {
|
|
idx = -1;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (linkIt != m_linkRegions.end()) {
|
|
if (indexInsideRegion(linkIt.value(), idx)) {
|
|
idx = -1;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
return idx;
|
|
}
|
|
|
|
static bool intersectRegion(const QVector<VElementRegion> &p_regions,
|
|
int p_start,
|
|
int p_end)
|
|
{
|
|
for (auto const & reg : p_regions) {
|
|
if (reg.intersect(p_start, p_end)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool HGMarkdownHighlighter::isValidMathjaxRegion(int p_blockNumber,
|
|
int p_start,
|
|
int p_end)
|
|
{
|
|
auto inlineCodeIt = m_inlineCodeRegions.find(p_blockNumber);
|
|
if (inlineCodeIt != m_inlineCodeRegions.end()) {
|
|
if (intersectRegion(inlineCodeIt.value(), p_start, p_end)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
auto commentIt = m_commentRegions.find(p_blockNumber);
|
|
if (commentIt != m_commentRegions.end()) {
|
|
if (intersectRegion(commentIt.value(), p_start, p_end)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
auto boldItalicIt = m_boldItalicRegions.find(p_blockNumber);
|
|
if (boldItalicIt != m_boldItalicRegions.end()) {
|
|
if (intersectRegion(boldItalicIt.value(), p_start, p_end)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
auto linkIt = m_linkRegions.find(p_blockNumber);
|
|
if (linkIt != m_linkRegions.end()) {
|
|
if (intersectRegion(linkIt.value(), p_start, p_end)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void HGMarkdownHighlighter::completeHighlight()
|
|
{
|
|
if (m_signalOut) {
|
|
m_signalOut = false;
|
|
updateMathjaxBlocks();
|
|
emit imageLinksUpdated(m_imageRegions);
|
|
emit headersUpdated(m_headerRegions);
|
|
}
|
|
|
|
emit highlightCompleted();
|
|
}
|