(

MarkdownDocument* textDocument,

QWidget* parent

)

: QPlainTextEdit(parent),

textDocument(textDocument),

dictionary(DictionaryManager::instance().requestDictionary()),

autoMatchEnabled(true),

bulletPointCyclingEnabled(true),

mouseButtonDown(false)

{

setDocument(textDocument);

setAcceptDrops(true);

preferredLayout = new QGridLayout();

preferredLayout->setSpacing(0);

preferredLayout->setMargin(0);

preferredLayout->setContentsMargins(0, 0, 0, 0);

preferredLayout->addWidget(this, 0, 0);

blockquoteRegex.setPattern("^ {0,3}(>\\s*)+");

numberedListRegex.setPattern("^\\s*([0-9]+)[.)]\\s+");

bulletListRegex.setPattern("^\\s*[+*-]\\s+");

taskListRegex.setPattern("^\\s*[-*+] \\[([x ])\\]\\s+");

emptyBlockquoteRegex.setPattern("^ {0,3}(>\\s*)+$");

emptyNumberedListRegex.setPattern("^\\s*([0-9]+)[.)]\\s+$");

emptyBulletListRegex.setPattern("^\\s*[+*-]\\s+$");

emptyTaskListRegex.setPattern("^\\s*[-*+] \\[([x ])\\]\\s+$");

this->setWordWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);

this->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

// Make sure QPlainTextEdit does not draw a cursor. (We'll paint it manually.)

setCursorWidth(0);

setCenterOnScroll(true);

ensureCursorVisible();

spellCheckEnabled = false;

installEventFilter(this);

viewport()->installEventFilter(this);

hemingwayModeEnabled = false;

focusMode = FocusModeDisabled;

insertSpacesForTabs = false;

setTabulationWidth(4);

editorWidth = EditorWidthMedium;

editorCorners = InterfaceStyleRounded;

markupPairs.insert('"', '"');

markupPairs.insert('\'', '\'');

markupPairs.insert('(', ')');

markupPairs.insert('[', ']');

markupPairs.insert('{', '}');

markupPairs.insert('*', '*');

markupPairs.insert('_', '_');

markupPairs.insert('`', '`');

markupPairs.insert('<', '>');

// Set automatching for the above markup pairs to be

// enabled by default.

//

autoMatchFilter.insert('"', true);

autoMatchFilter.insert('\'', true);

autoMatchFilter.insert('(', true);

autoMatchFilter.insert('[', true);

autoMatchFilter.insert('{', true);

autoMatchFilter.insert('*', true);

autoMatchFilter.insert('_', true);

autoMatchFilter.insert('`', true);

autoMatchFilter.insert('<', true);

nonEmptyMarkupPairs.insert('*', '*');

nonEmptyMarkupPairs.insert('_', '_');

nonEmptyMarkupPairs.insert('<', '>');

connect(this, SIGNAL(cursorPositionChanged()), this, SLOT(onCursorPositionChanged()));

connect(this->document(), SIGNAL(contentsChange(int,int,int)), this, SLOT(onContentsChanged(int,int,int)));

connect(this->document(), SIGNAL(textBlockRemoved(const QTextBlock&)), this, SLOT(onTextBlockRemoved(const QTextBlock&)));

connect(this, SIGNAL(selectionChanged()), this, SLOT(onSelectionChanged()));

highlighter = new MarkdownHighlighter(this);

addWordToDictionaryAction = new QAction(tr("Add word to dictionary"), this);

checkSpellingAction = new QAction(tr("Check spelling..."), this);

typingPausedSignalSent = true;

typingHasPaused = true;

typingTimer = new QTimer(this);

connect

(

typingTimer,

SIGNAL(timeout()),

this,

SLOT(checkIfTypingPaused())

);

typingTimer->start(1000);

typingPausedScaledSignalSent = true;

scaledTypingHasPaused = true;

scaledTypingTimer = new QTimer(this);

connect

(

scaledTypingTimer,

SIGNAL(timeout()),

this,

SLOT(checkIfTypingPausedScaled())

);

scaledTypingTimer->start(1000);

setColorScheme

(

QColor(Qt::black),

QColor(Qt::white),

QColor(Qt::black),

QColor(Qt::blue),

QColor(Qt::black),

QColor(Qt::black),

QColor(Qt::black),

QColor(Qt::black),

QColor(Qt::red)

);

textCursorVisible = true;

cursorBlinkTimer = new QTimer(this);

connect(cursorBlinkTimer, SIGNAL(timeout()), this, SLOT(toggleCursorBlink()));

cursorBlinkTimer->start(500);

{

QPainter painter(viewport());

QRect viewportRect = viewport()->rect();

painter.fillRect(viewportRect, Qt::transparent);

QPointF offset(contentOffset());

QTextBlock block = firstVisibleBlock();

bool firstVisible = true;

QRectF blockAreaRect; // Code or block quote rect.

bool inBlockArea = false;

BlockType blockType = BlockTypeNone;

bool clipTop = false;

bool drawBlock = false;

int dy = 0;

bool done = false;

int cornerRadius = 5;

if (InterfaceStyleSquare == editorCorners)

{

cornerRadius = 0;

}

// Draw text block area backgrounds for code blocks and block quotes.

// The backgrounds are drawn per each block area (consisting of multiple

// text blocks or lines), rather than one rectangle area per text block/

// line in case there are margins between each text block. This way,

// the background will extend to cover the margins between text blocks

// as well.

//

// NOTE: Algorithm for looping through text blocks is a partial lift from

// Qt's QPlainTextEdit paintEvent() code. Please refer to the

// LGPL v. 3 license for the original Qt code.

//

while (block.isValid() && !done)

{

QRectF r = blockBoundingRect(block).translated(offset);

// If the block begins a new text block area...

if (!inBlockArea && atBlockAreaStart(block, blockType))

{

blockAreaRect = r;

dy = 0;

inBlockArea = true;

BlockType prevType;

// If this is the first visible block within the viewport

// and if the previous block is part of the text block area,

// then the rectangle to draw for the block area will have

// its top clipped by the viewport and will need to be

// drawn specially.

//

if

(

firstVisible

&& atBlockAreaStart(block.previous(), prevType)

&& (blockType == prevType)

)

{

clipTop = true;

}

}

// Else if the block ends a text block area...

else if (inBlockArea && atBlockAreaEnd(block, blockType))

{

drawBlock = true;

inBlockArea = false;

blockAreaRect.setHeight(dy);

}

// If the block is at the end of the document and ends a text

// block area...

//

if (inBlockArea && (block == this->document()->lastBlock()))

{

drawBlock = true;

inBlockArea = false;

dy += r.height();

blockAreaRect.setHeight(dy);

}

offset.ry() += r.height();

dy += r.height();

// If this is the last text block visible within the viewport...

if (offset.y() > viewportRect.height())

{

if (inBlockArea)

{

blockAreaRect.setHeight(dy);

drawBlock = true;

}

// Finished drawing.

done = true;

}

if (drawBlock)

{

painter.setCompositionMode(QPainter::CompositionMode_SourceOver);

painter.setPen(Qt::NoPen);

painter.setBrush(QBrush(blockColor));

// If the first visible block is "clipped" such that the previous block

// is part of the text block area, then only draw a rectangle with the

// bottom corners rounded, and with the top corners square to reflect

// that the first visible block is part of a larger block of text.

//

if (clipTop)

{

QPainterPath path;

path.setFillRule(Qt::WindingFill);

path.addRoundedRect(blockAreaRect, cornerRadius, cornerRadius);

qreal adjustedHeight = blockAreaRect.height() / 2;

path.addRect(blockAreaRect.adjusted(0, 0, 0, -adjustedHeight));

painter.drawPath(path.simplified());

clipTop = false;

}

// Else draw the entire rectangle with all corners rounded.

else

{

painter.drawRoundedRect(blockAreaRect, cornerRadius, cornerRadius);

}

drawBlock = false;

}

// This fixes the RTL bug of QPlainTextEdit

// https://bugreports.qt.io/browse/QTBUG-7516.

//

// Credit goes to Patrizio Bekerle (qmarkdowntextedit) for discovering

// this workaround.

//

if (block.text().isRightToLeft())

{

QTextLayout* layout = block.layout();

QTextOption opt = document()->defaultTextOption();

opt = QTextOption(Qt::AlignRight);

opt.setTextDirection(Qt::RightToLeft);

layout->setTextOption(opt);

}

block = block.next();

firstVisible = false;

}

painter.end();

// Draw the visible editor text.

QPlainTextEdit::paintEvent(event);

// Draw the text cursor/caret.

if (textCursorVisible && this->hasFocus())

{

// Get the cursor rect so that we have the ideal height for it,

// and then set it to be 2 pixels wide. (The width will be zero,

// because we set it to be that in the constructor so that

// QPlainTextEdit will not draw another cursor underneath this one.)

//

QRect r = cursorRect();

r.setWidth(2);

QPainter painter(viewport());

painter.fillRect(r, QBrush(cursorColor));

painter.end();

}

{

dictionary = DictionaryManager::instance().requestDictionary(language);

highlighter->setDictionary(dictionary);

{

focusMode = mode;

if (FocusModeDisabled != mode)

{

connect(this, SIGNAL(cursorPositionChanged()), this, SLOT(focusText()));

connect(this, SIGNAL(selectionChanged()), this, SLOT(focusText()));

connect(this, SIGNAL(textChanged()), this, SLOT(focusText()));

focusText();

}

else

{

disconnect(this, SIGNAL(cursorPositionChanged()), this, SLOT(focusText()));

disconnect(this, SIGNAL(selectionChanged()), this, SLOT(focusText()));

disconnect(this, SIGNAL(textChanged()), this, SLOT(focusText()));

this->setExtraSelections(QList<QTextEdit::ExtraSelection>());

}

(

const QColor& defaultTextColor,

const QColor& backgroundColor,

const QColor& markupColor,

const QColor& linkColor,

const QColor& headingColor,

const QColor& emphasisColor,

const QColor& blockquoteColor,

const QColor& codeColor,

const QColor& spellingErrorColor

)

{

highlighter->setColorScheme

(

defaultTextColor,

backgroundColor,

markupColor,

linkColor,

headingColor,

emphasisColor,

blockquoteColor,

codeColor,

spellingErrorColor

);

this->cursorColor = linkColor;

blockColor = defaultTextColor;

int blockAlpha = 20;

if (backgroundColor.alpha() < 255)

{

blockAlpha = 18;

}

else if (ColorHelper::getLuminance(blockColor) < 0.5)

{

blockAlpha = 10;

}

blockColor.setAlpha(blockAlpha);

QColor fadedForegroundColor = defaultTextColor;

fadedForegroundColor.setAlpha(100);

fadeColor = QBrush(fadedForegroundColor);

focusText();

{

QFont font(family, pointSize);

QPlainTextEdit::setFont(font);

highlighter->setFont(family, pointSize);

setTabulationWidth(tabWidth);

{

QTextOption option = textDocument->defaultTextOption();

if (enabled)

{

option.setFlags(option.flags() | QTextOption::ShowTabsAndSpaces);

}

else

{

option.setFlags(option.flags() & ~QTextOption::ShowTabsAndSpaces);

}

textDocument->setDefaultTextOption(option);

{

if (EditorWidthFull == editorWidth)

{

preferredLayout->setContentsMargins(0, 0, 0, 0);

setViewportMargins(0, 0, 0, 0);

return;

}

int screenWidth = QGuiApplication::primaryScreen()->size().width();

int proposedEditorWidth = width;

int margin = 0;

switch (editorWidth)

{

case EditorWidthNarrow:

proposedEditorWidth = screenWidth / 3;

break;

case EditorWidthMedium:

proposedEditorWidth = screenWidth / 2;

break;

case EditorWidthWide:

proposedEditorWidth = 2 * (screenWidth / 3);

break;

default:

break;

}

if (proposedEditorWidth <= width)

{

margin = (width - proposedEditorWidth) / 2;

}

if (EditorAspectStretch == aspect)

{

preferredLayout->setContentsMargins(0, 0, 0, 0);

setViewportMargins(margin, 20, margin, 0);

}

else

{

preferredLayout->setContentsMargins(margin, 20, margin, 20);

setViewportMargins(10, 10, 10, 10);

}

{

if (e->mimeData()->hasUrls())

{

e->acceptProposedAction();

}

else

{

QPlainTextEdit::dragEnterEvent(e);

}

{

if (e->mimeData()->hasUrls() && (e->mimeData()->urls().size() == 1))

{

e->acceptProposedAction();

QUrl url = e->mimeData()->urls().first();

QString path = url.toLocalFile();

bool isRelativePath = false;

QFileInfo fileInfo(path);

QString fileExtension = fileInfo.suffix().toLower();

QTextCursor dropCursor = cursorForPosition(e->pos());

// If the file extension indicates an image type, then insert an

// image link into the text.

if

(

(fileExtension == "jpg") ||

(fileExtension == "jpeg") ||

(fileExtension == "gif") ||

(fileExtension == "bmp") ||

(fileExtension == "png") ||

(fileExtension == "tif") ||

(fileExtension == "tiff") ||

(fileExtension == "svg")

)

{

if (!textDocument->isNew())

{

QFileInfo docInfo(textDocument->getFilePath());

if (docInfo.exists())

{

path = docInfo.dir().relativeFilePath(path);

isRelativePath = true;

}

}

if (!isRelativePath)

{

path = url.toString();

}

dropCursor.insertText(QString("").arg(path));

// We have to call the super class so that clean up occurs,

// otherwise the editor's cursor will freeze. We also have to use

// a dummy drop event with dummy MIME data, otherwise the parent

// class will insert the file path into the document.

//

QMimeData* dummyMimeData = new QMimeData();

dummyMimeData->setText("");

QDropEvent* dummyEvent =

new QDropEvent

(

e->pos(),

e->possibleActions(),

dummyMimeData,

e->mouseButtons(),

e->keyboardModifiers()

);

QPlainTextEdit::dropEvent(dummyEvent);

delete dummyEvent;

delete dummyMimeData;

}

// Else insert URL path as normal, using the parent class.

else

{

QPlainTextEdit::dropEvent(e);

}

}

else

{

QPlainTextEdit::dropEvent(e);

}

{

int key = e->key();

QTextCursor cursor(this->textCursor());

switch (key)

{

case Qt::Key_Return:

if (!cursor.hasSelection())

{

if (e->modifiers() & Qt::ShiftModifier)

{

// Insert Markdown-style line break

cursor.insertText(" ");

highlighter->rehighlightBlock(cursor.block());

}

if (e->modifiers() & Qt::ControlModifier)

{

cursor.insertText("\n");

}

else

{

handleCarriageReturn();

}

}

else

{

QPlainTextEdit::keyPressEvent(e);

}

break;

case Qt::Key_Delete:

if (!hemingwayModeEnabled)

{

QPlainTextEdit::keyPressEvent(e);

}

break;

case Qt::Key_Backspace:

if (!hemingwayModeEnabled)

{

if (!handleBackspaceKey())

{

QPlainTextEdit::keyPressEvent(e);

}

}

break;

case Qt::Key_Tab:

if (!handleWhitespaceInEmptyMatch('\t'))

{

indentText();

}

break;

case Qt::Key_Backtab:

unindentText();

break;

case Qt::Key_Space:

if (!handleWhitespaceInEmptyMatch(' '))

{

QPlainTextEdit::keyPressEvent(e);

}

break;

default:

if (e->text().size() == 1)

{

QChar ch = e->text().at(0);

if (!handleEndPairCharacterTyped(ch) && !insertPairedCharacters(ch))

{

QPlainTextEdit::keyPressEvent(e);

}

}

else

{

QPlainTextEdit::keyPressEvent(e);

}

break;

}

{

if (event->type() == QEvent::MouseButtonPress)

{

mouseButtonDown = true;

}

else if (event->type() == QEvent::MouseButtonRelease)

{

mouseButtonDown = false;

}

else if (event->type() == QEvent::MouseButtonDblClick)

{

mouseButtonDown = true;

}

if (event->type() != QEvent::ContextMenu || !spellCheckEnabled || this->isReadOnly())

{

return QPlainTextEdit::eventFilter(watched, event);

}

else

{

// Check spelling of text block under mouse

QContextMenuEvent* contextEvent = static_cast<QContextMenuEvent*>(event);

// If the context menu event was triggered by pressing the menu key,

// use the current text cursor rather than the event position to get

// a cursor position, since the event position is the mouse position

// rather than the text cursor position.

//

if (QContextMenuEvent::Keyboard == contextEvent->reason())

{

cursorForWord = this->textCursor();

}

// Else process as mouse event.

//

else

{

cursorForWord = cursorForPosition(contextEvent->pos());

}

QTextCharFormat::UnderlineStyle spellingErrorUnderlineStyle =

(QTextCharFormat::UnderlineStyle)

QApplication::style()->styleHint

(

QStyle::SH_SpellCheckUnderlineStyle

);

// Get the formatting for the cursor position under the mouse,

// and see if it has the spell check error underline style.

//

bool wordHasSpellingError = false;

int blockPosition = cursorForWord.positionInBlock();

#if (QT_VERSION_MAJOR == 5) && (QT_VERSION_MINOR < 6)

QList<QTextLayout::FormatRange> formatList =

cursorForWord.block().layout()->additionalFormats();

#else

QVector<QTextLayout::FormatRange> formatList =

cursorForWord.block().layout()->formats();

#endif

int mispelledWordStartPos = 0;

int mispelledWordLength = 0;

for (int i = 0; i < formatList.length(); i++)

{

QTextLayout::FormatRange formatRange = formatList[i];

if

(

(blockPosition >= formatRange.start)

&& (blockPosition <= (formatRange.start + formatRange.length))

&& (formatRange.format.underlineStyle() == spellingErrorUnderlineStyle)

)

{

mispelledWordStartPos = formatRange.start;

mispelledWordLength = formatRange.length;

wordHasSpellingError = true;

break;

}

}

// The word under the mouse is spelled correctly, so use the default

// processing for the context menu and return.

//

if (!wordHasSpellingError)

{

return QPlainTextEdit::eventFilter(watched, event);

}

// Select the misspelled word.

cursorForWord.movePosition

(

QTextCursor::PreviousCharacter,

QTextCursor::MoveAnchor,

blockPosition - mispelledWordStartPos

);

cursorForWord.movePosition

(

QTextCursor::NextCharacter,

QTextCursor::KeepAnchor,

mispelledWordLength

);

wordUnderMouse = cursorForWord.selectedText();

QStringList suggestions = dictionary.suggestions(wordUnderMouse);

QMenu* popupMenu = createStandardContextMenu();

QAction* firstAction = popupMenu->actions().first();

spellingActions.clear();

if (!suggestions.empty())

{

for (int i = 0; i < suggestions.size(); i++)

{

QAction* suggestionAction = new QAction(suggestions[i], this);

// Need the following line because KDE Plasma 5 will insert a hidden ampersand

// into the menu text as a keyboard accelerator. Go off of the data in the

// QAction rather than the text to avoid this.

//

suggestionAction->setData(suggestions[i]);

spellingActions.append(suggestionAction);

popupMenu->insertAction(firstAction, suggestionAction);

}

}

else

{

QAction* noSuggestionsAction =

new QAction(tr("No spelling suggestions found"), this);

noSuggestionsAction->setEnabled(false);

spellingActions.append(noSuggestionsAction);

popupMenu->insertAction(firstAction, noSuggestionsAction);

}

popupMenu->insertSeparator(firstAction);

popupMenu->insertAction(firstAction, addWordToDictionaryAction);

popupMenu->insertSeparator(firstAction);

popupMenu->insertAction(firstAction, checkSpellingAction);

popupMenu->insertSeparator(firstAction);

// Show menu

connect(popupMenu, SIGNAL(triggered(QAction*)), this, SLOT(suggestSpelling(QAction*)));

QPoint menuPos;

// If event was triggered by a key press, use the text cursor

// coordinates to display the popup menu.

//

if (QContextMenuEvent::Keyboard == contextEvent->reason())

{

QRect cr = this->cursorRect();

menuPos.setX(cr.x());

menuPos.setY(cr.y() + (cr.height() / 2));

menuPos = viewport()->mapToGlobal(menuPos);

}

// Else use the mouse coordinates from the context menu event.

//

else

{

menuPos = viewport()->mapToGlobal(contextEvent->pos());

}

popupMenu->exec(menuPos);

delete popupMenu;

for (int i = 0; i < spellingActions.size(); i++)

{

delete spellingActions[i];

}

spellingActions.clear();

return true;

}

{

Qt::KeyboardModifiers modifier = e->modifiers();

#if QT_VERSION >= 0x050000

int numDegrees = 0;

QPoint angleDelta = e->angleDelta();

if (!angleDelta.isNull())

{

numDegrees = angleDelta.y();

}

#else

int numDegrees = e->delta();

#endif

if ((Qt::ControlModifier == modifier) && (0 != numDegrees))

{

int fontSize = this->font().pointSize();

if (numDegrees > 0)

{

fontSize += 1;

}

else

{

fontSize -= 1;

}

// check for negative value

if (fontSize <= 0)

{

fontSize = 1;

}

setFont(this->font().family(), fontSize);

emit fontSizeChanged(fontSize);

}

else

{

QPlainTextEdit::wheelEvent(e);

}

{

QTextCursor cursor = this->textCursor();

cursor.setPosition(position);

this->setTextCursor(cursor);

this->activateWindow();

{

QTextCursor cursor = this->textCursor();

if (cursor.hasSelection())

{

QString text = cursor.selectedText();

text = QString("<!-- " + text + " -->");

cursor.insertText(text);

}

else

{

cursor.insertText("<!-- -->");

cursor.movePosition(QTextCursor::PreviousCharacter, QTextCursor::MoveAnchor, 4);

this->setTextCursor(cursor);

}