From 6f6ec217e3937425b7be46c01b28a4182a4f19c2 Mon Sep 17 00:00:00 2001 From: John Preston Date: Tue, 22 May 2018 22:09:13 +0300 Subject: [PATCH] Support markdown replaces in Ui::InputField. --- .../chat_helpers/message_field.cpp | 40 +- Telegram/SourceFiles/data/data_drafts.cpp | 9 +- .../SourceFiles/history/history_widget.cpp | 7 +- Telegram/SourceFiles/ui/text/text.cpp | 4 +- Telegram/SourceFiles/ui/text/text_entity.cpp | 413 ++------ Telegram/SourceFiles/ui/text/text_entity.h | 13 +- .../SourceFiles/ui/widgets/input_fields.cpp | 925 ++++++++++++++---- .../SourceFiles/ui/widgets/input_fields.h | 35 +- 8 files changed, 902 insertions(+), 544 deletions(-) diff --git a/Telegram/SourceFiles/chat_helpers/message_field.cpp b/Telegram/SourceFiles/chat_helpers/message_field.cpp index f53abfa62..d174ad043 100644 --- a/Telegram/SourceFiles/chat_helpers/message_field.cpp +++ b/Telegram/SourceFiles/chat_helpers/message_field.cpp @@ -56,11 +56,25 @@ EntitiesInText ConvertTextTagsToEntities(const TextWithTags::Tags &tags) { result.reserve(tags.size()); auto mentionStart = qstr("mention://user."); - for_const (auto &tag, tags) { + for (const auto &tag : tags) { + const auto push = [&]( + EntityInTextType type, + const QString &data = QString()) { + result.push_back( + EntityInText(type, tag.offset, tag.length, data)); + }; if (tag.id.startsWith(mentionStart)) { if (auto match = qthelp::regex_match("^(\\d+\\.\\d+)(/|$)", tag.id.midRef(mentionStart.size()))) { - result.push_back(EntityInText(EntityInTextMentionName, tag.offset, tag.length, match->captured(1))); + push(EntityInTextMentionName, match->captured(1)); } + } else if (tag.id == Ui::InputField::kTagBold) { + push(EntityInTextBold); + } else if (tag.id == Ui::InputField::kTagItalic) { + push(EntityInTextItalic); + } else if (tag.id == Ui::InputField::kTagCode) { + push(EntityInTextCode); + } else if (tag.id == Ui::InputField::kTagPre) { + push(EntityInTextPre); } } return result; @@ -73,12 +87,21 @@ TextWithTags::Tags ConvertEntitiesToTextTags(const EntitiesInText &entities) { } result.reserve(entities.size()); - for_const (auto &entity, entities) { - if (entity.type() == EntityInTextMentionName) { + for (const auto &entity : entities) { + const auto push = [&](const QString &tag) { + result.push_back({ entity.offset(), entity.length(), tag }); + }; + switch (entity.type()) { + case EntityInTextMentionName: { auto match = QRegularExpression("^(\\d+\\.\\d+)$").match(entity.data()); if (match.hasMatch()) { - result.push_back({ entity.offset(), entity.length(), qstr("mention://user.") + entity.data() }); + push(qstr("mention://user.") + entity.data()); } + } break; + case EntityInTextBold: push(Ui::InputField::kTagBold); break; + case EntityInTextItalic: push(Ui::InputField::kTagItalic); break; + case EntityInTextCode: push(Ui::InputField::kTagCode); break; + case EntityInTextPre: push(Ui::InputField::kTagPre); break; } } return result; @@ -119,15 +142,16 @@ void InitMessageField(not_null field) { field->setTagMimeProcessor(std::make_unique()); field->document()->setDocumentMargin(4.); - const auto additional = convertScale(4) - 4; - field->rawTextEdit()->setStyleSheet( - qsl("QTextEdit { margin: %1px; }").arg(additional)); + field->setAdditionalMargin(convertScale(4) - 4); + field->customTab(true); field->setInstantReplaces(Ui::InstantReplaces::Default()); field->enableInstantReplaces(Global::ReplaceEmoji()); + field->enableMarkdownSupport(Global::ReplaceEmoji()); auto &changed = Global::RefReplaceEmojiChanged(); Ui::AttachAsChild(field, changed.add_subscription([=] { field->enableInstantReplaces(Global::ReplaceEmoji()); + field->enableMarkdownSupport(Global::ReplaceEmoji()); })); field->window()->activateWindow(); } diff --git a/Telegram/SourceFiles/data/data_drafts.cpp b/Telegram/SourceFiles/data/data_drafts.cpp index e6630b824..c9f45a5f2 100644 --- a/Telegram/SourceFiles/data/data_drafts.cpp +++ b/Telegram/SourceFiles/data/data_drafts.cpp @@ -45,8 +45,13 @@ Draft::Draft( void applyPeerCloudDraft(PeerId peerId, const MTPDdraftMessage &draft) { auto history = App::history(peerId); - auto text = TextWithEntities { qs(draft.vmessage), draft.has_entities() ? TextUtilities::EntitiesFromMTP(draft.ventities.v) : EntitiesInText() }; - auto textWithTags = TextWithTags { TextUtilities::ApplyEntities(text), ConvertEntitiesToTextTags(text.entities) }; + auto textWithTags = TextWithTags { + qs(draft.vmessage), + ConvertEntitiesToTextTags( + draft.has_entities() + ? TextUtilities::EntitiesFromMTP(draft.ventities.v) + : EntitiesInText()) + }; auto replyTo = draft.has_reply_to_msg_id() ? draft.vreply_to_msg_id.v : MsgId(0); auto cloudDraft = std::make_unique(textWithTags, replyTo, MessageCursor(QFIXED_MAX, QFIXED_MAX, QFIXED_MAX), draft.is_no_webpage()); cloudDraft->date = draft.vdate.v; diff --git a/Telegram/SourceFiles/history/history_widget.cpp b/Telegram/SourceFiles/history/history_widget.cpp index 67aa0c730..ca3c10759 100644 --- a/Telegram/SourceFiles/history/history_widget.cpp +++ b/Telegram/SourceFiles/history/history_widget.cpp @@ -5836,7 +5836,7 @@ void HistoryWidget::editMessage(not_null item) { const auto original = item->originalText(); const auto editData = TextWithTags { - TextUtilities::ApplyEntities(original), + original.text, ConvertEntitiesToTextTags(original.entities) }; const auto cursor = MessageCursor { @@ -6235,7 +6235,10 @@ void HistoryWidget::onCancel() { onInlineBotCancel(); } else if (_editMsgId) { auto original = _replyEditMsg ? _replyEditMsg->originalText() : TextWithEntities(); - auto editData = TextWithTags { TextUtilities::ApplyEntities(original), ConvertEntitiesToTextTags(original.entities) }; + auto editData = TextWithTags { + original.text, + ConvertEntitiesToTextTags(original.entities) + }; if (_replyEditMsg && editData != _field->getTextWithTags()) { Ui::show(Box( lang(lng_cancel_edit_post_sure), diff --git a/Telegram/SourceFiles/ui/text/text.cpp b/Telegram/SourceFiles/ui/text/text.cpp index fca72d591..4a3bf6b79 100644 --- a/Telegram/SourceFiles/ui/text/text.cpp +++ b/Telegram/SourceFiles/ui/text/text.cpp @@ -234,7 +234,9 @@ public: if (flags & flag) { createBlock(); flags &= ~flag; - if (flag == TextBlockFPre) { + if (flag == TextBlockFPre + && !_t->_blocks.empty() + && _t->_blocks.back()->type() != TextBlockTNewline) { newlineAwaited = true; } } diff --git a/Telegram/SourceFiles/ui/text/text_entity.cpp b/Telegram/SourceFiles/ui/text/text_entity.cpp index 4b96607b1..0b8a9f810 100644 --- a/Telegram/SourceFiles/ui/text/text_entity.cpp +++ b/Telegram/SourceFiles/ui/text/text_entity.cpp @@ -30,12 +30,39 @@ QString ExpressionMailNameAtEnd() { return qsl("[a-zA-Z\\-_\\.0-9]{1,256}$"); } -QString ExpressionSeparators(const QString &additional) { +QString Quotes() { // UTF8 quotes and ellipsis - const auto quotes = QString::fromUtf8("\xC2\xAB\xC2\xBB\xE2\x80\x9C\xE2\x80\x9D\xE2\x80\x98\xE2\x80\x99\xE2\x80\xA6"); + return QString::fromUtf8("\xC2\xAB\xC2\xBB\xE2\x80\x9C\xE2\x80\x9D\xE2\x80\x98\xE2\x80\x99\xE2\x80\xA6"); +} + +QString ExpressionSeparators(const QString &additional) { + static const auto quotes = Quotes(); return qsl("\\s\\.,:;<>|'\"\\[\\]\\{\\}\\~\\!\\?\\%\\^\\(\\)\\-\\+=\\x10") + quotes + additional; } +QString Separators(const QString &additional) { + static const auto quotes = Quotes(); + return qsl(" \x10\n\r\t.,:;<>|'\"[]{}~!?%^()-+=") + + QChar(0xfdd0) // QTextBeginningOfFrame + + QChar(0xfdd1) // QTextEndOfFrame + + QChar(QChar::ParagraphSeparator) + + QChar(QChar::LineSeparator) + + quotes + + additional; +} + +QString SeparatorsBold() { + return Separators(qsl("`/")); +} + +QString SeparatorsItalic() { + return Separators(qsl("`*/")); +} + +QString SeparatorsMono() { + return Separators(qsl("*/")); +} + QString ExpressionHashtag() { return qsl("(^|[") + ExpressionSeparators(qsl("`\\*/")) + qsl("])#[\\w]{2,64}([\\W]|$)"); } @@ -52,28 +79,12 @@ QString ExpressionBotCommand() { return qsl("(^|[") + ExpressionSeparators(qsl("`\\*")) + qsl("])/[A-Za-z_0-9]{1,64}(@[A-Za-z_0-9]{5,32})?([\\W]|$)"); } -QString ExpressionMarkdownBold() { - auto separators = ExpressionSeparators(qsl("`/")); - return qsl("(^|[") + separators + qsl("])(\\*\\*)[\\s\\S]+?(\\*\\*)([") + separators + qsl("]|$)"); -} - -QString ExpressionMarkdownItalic() { - auto separators = ExpressionSeparators(qsl("`\\*/")); - return qsl("(^|[") + separators + qsl("])(__)[\\s\\S]+?(__)([") + separators + qsl("]|$)"); -} - -QString ExpressionMarkdownMonoInline() { // code - auto separators = ExpressionSeparators(qsl("\\*/")); - return qsl("(^|[") + separators + qsl("])(`)[^\\n]+?(`)([") + separators + qsl("]|$)"); -} - -QString ExpressionMarkdownMonoBlock() { // pre - auto separators = ExpressionSeparators(qsl("\\*/")); - return qsl("(^|[") + separators + qsl("])(````?)[\\s\\S]+?(````?)([") + separators + qsl("]|$)"); -} - QRegularExpression CreateRegExp(const QString &expression) { - return QRegularExpression(expression, QRegularExpression::UseUnicodePropertiesOption); + auto result = QRegularExpression( + expression, + QRegularExpression::UseUnicodePropertiesOption); + result.optimize(); + return result; } QSet CreateValidProtocols() { @@ -1160,24 +1171,36 @@ const QRegularExpression &RegExpBotCommand() { return result; } -const QRegularExpression &RegExpMarkdownBold() { - static const auto result = CreateRegExp(ExpressionMarkdownBold()); - return result; +QString MarkdownBoldGoodBefore() { + return SeparatorsBold(); } -const QRegularExpression &RegExpMarkdownItalic() { - static const auto result = CreateRegExp(ExpressionMarkdownItalic()); - return result; +QString MarkdownBoldBadAfter() { + return qsl("*"); } -const QRegularExpression &RegExpMarkdownMonoInline() { - static const auto result = CreateRegExp(ExpressionMarkdownMonoInline()); - return result; +QString MarkdownItalicGoodBefore() { + return SeparatorsItalic(); } -const QRegularExpression &RegExpMarkdownMonoBlock() { - static const auto result = CreateRegExp(ExpressionMarkdownMonoBlock()); - return result; +QString MarkdownItalicBadAfter() { + return qsl("_"); +} + +QString MarkdownCodeGoodBefore() { + return SeparatorsMono(); +} + +QString MarkdownCodeBadAfter() { + return qsl("`\n\r"); +} + +QString MarkdownPreGoodBefore() { + return SeparatorsMono(); +} + +QString MarkdownPreBadAfter() { + return qsl("`"); } bool IsValidProtocol(const QString &protocol) { @@ -1546,252 +1569,6 @@ MTPVector EntitiesToMTP(const EntitiesInText &entities, Conver return MTP_vector(std::move(v)); } -struct MarkdownPart { - MarkdownPart() = default; - MarkdownPart(EntityInTextType type) : type(type), outerStart(-1) { - } - EntityInTextType type = EntityInTextInvalid; - int outerStart = 0; - int innerStart = 0; - int innerEnd = 0; - int outerEnd = 0; - bool addNewlineBefore = false; - bool addNewlineAfter = false; -}; - -MarkdownPart GetMarkdownPart(EntityInTextType type, const QString &text, int matchFromOffset, bool rich) { - auto result = MarkdownPart(); - auto regexp = [type] { - switch (type) { - case EntityInTextBold: return RegExpMarkdownBold(); - case EntityInTextItalic: return RegExpMarkdownItalic(); - case EntityInTextCode: return RegExpMarkdownMonoInline(); - case EntityInTextPre: return RegExpMarkdownMonoBlock(); - } - Unexpected("Type in GetMardownPart()"); - }; - - if (matchFromOffset > 1) { - // If matchFromOffset is after some separator that is allowed to - // start our markdown tag the tag itself will start where we want it. - // So we allow to see this separator and make a match. - --matchFromOffset; - } - auto match = regexp().match(text, matchFromOffset); - if (!match.hasMatch()) { - return result; - } - - result.outerStart = match.capturedStart(); - result.outerEnd = match.capturedEnd(); - if (!match.capturedRef(1).isEmpty()) { - ++result.outerStart; - } - if (!match.capturedRef(4).isEmpty()) { - --result.outerEnd; - } - result.innerStart = result.outerStart + match.capturedLength(2); - result.innerEnd = result.outerEnd - match.capturedLength(3); - result.type = type; - return result; -} - -void AdjustMarkdownPrePart(MarkdownPart &result, const TextWithEntities &text, bool rich) { - auto start = text.text.constData(); - auto length = text.text.size(); - auto lastEntityBeforeEnd = 0; - auto firstEntityInsideStart = result.innerEnd; - auto lastEntityInsideEnd = result.innerStart; - auto firstEntityAfterStart = length; - for_const (auto &entity, text.entities) { - if (entity.offset() < result.outerStart) { - lastEntityBeforeEnd = entity.offset() + entity.length(); - } else if (entity.offset() >= result.outerEnd) { - firstEntityAfterStart = entity.offset(); - break; - } else if (entity.offset() >= result.innerStart) { - accumulate_min(firstEntityInsideStart, entity.offset()); - lastEntityInsideEnd = entity.offset() + entity.length(); - } - } - while (result.outerStart > lastEntityBeforeEnd - && chIsSpace(*(start + result.outerStart - 1), rich) - && !chIsNewline(*(start + result.outerStart - 1))) { - --result.outerStart; - } - result.addNewlineBefore = (result.outerStart > 0 && !chIsNewline(*(start + result.outerStart - 1))); - - for (auto testInnerStart = result.innerStart; testInnerStart < firstEntityInsideStart; ++testInnerStart) { - if (chIsNewline(*(start + testInnerStart))) { - result.innerStart = testInnerStart + 1; - break; - } else if (!chIsSpace(*(start + testInnerStart))) { - break; - } - } - for (auto testInnerEnd = result.innerEnd; lastEntityInsideEnd < testInnerEnd;) { - --testInnerEnd; - if (chIsNewline(*(start + testInnerEnd))) { - result.innerEnd = testInnerEnd; - break; - } else if (!chIsSpace(*(start + testInnerEnd))) { - break; - } - } - - while (result.outerEnd < firstEntityAfterStart - && chIsSpace(*(start + result.outerEnd)) - && !chIsNewline(*(start + result.outerEnd))) { - ++result.outerEnd; - } - result.addNewlineAfter = (result.outerEnd < length && !chIsNewline(*(start + result.outerEnd))); -} - -void ParseMarkdown( - TextWithEntities &result, - const EntitiesInText &linkEntities, - bool rich) { - if (result.empty()) { - return; - } - auto newResult = TextWithEntities(); - - MarkdownPart computedParts[4] = { - { EntityInTextBold }, - { EntityInTextItalic }, - { EntityInTextPre }, - { EntityInTextCode }, - }; - - auto existingEntityIndex = 0; - auto existingEntitiesCount = result.entities.size(); - auto existingEntityShiftLeft = 0; - - auto copyFromOffset = 0; - auto matchFromOffset = 0; - auto length = result.text.size(); - auto nextCommandOffset = rich ? 0 : length; - auto inLink = false; - auto commandIsLink = false; - const auto start = result.text.constData(); - for (; matchFromOffset < length;) { - if (nextCommandOffset <= matchFromOffset) { - for (nextCommandOffset = matchFromOffset; nextCommandOffset != length; ++nextCommandOffset) { - if (*(start + nextCommandOffset) == TextCommand) { - inLink = commandIsLink; - commandIsLink = textcmdStartsLink(start, length, nextCommandOffset); - break; - } - } - if (nextCommandOffset >= length) { - inLink = commandIsLink; - commandIsLink = false; - } - } - auto part = MarkdownPart(); - auto checkType = [&part, &result, matchFromOffset, rich](MarkdownPart &computedPart) { - if (computedPart.type == EntityInTextInvalid) { - return; - } - if (matchFromOffset > computedPart.outerStart) { - computedPart = GetMarkdownPart(computedPart.type, result.text, matchFromOffset, rich); - if (computedPart.type == EntityInTextInvalid) { - return; - } - } - if (part.type == EntityInTextInvalid || part.outerStart > computedPart.outerStart) { - part = computedPart; - } - }; - for (auto &computedPart : computedParts) { - checkType(computedPart); - } - if (part.type == EntityInTextInvalid) { - break; - } - - // Check if start sequence intersects a command. - auto inCommand = checkTagStartInCommand( - start, - length, - part.outerStart, - nextCommandOffset, - commandIsLink, - inLink); - if (inCommand || inLink) { - matchFromOffset = nextCommandOffset; - continue; - } - - // Check if start or end sequences intersect any existing entity. - auto intersectedEntityEnd = 0; - for_const (auto &entity, result.entities) { - if (qMin(part.innerStart, entity.offset() + entity.length()) > qMax(part.outerStart, entity.offset()) || - qMin(part.outerEnd, entity.offset() + entity.length()) > qMax(part.innerEnd, entity.offset())) { - intersectedEntityEnd = entity.offset() + entity.length(); - break; - } - } - - // Check if any of sequence outer edges are inside a link. - for_const (auto &entity, linkEntities) { - const auto startIntersects = (part.outerStart >= entity.offset()) - && (part.outerStart < entity.offset() + entity.length()); - const auto endIntersects = (part.outerEnd > entity.offset()) - && (part.outerEnd <= entity.offset() + entity.length()); - if (startIntersects || endIntersects) { - intersectedEntityEnd = entity.offset() + entity.length(); - break; - } - } - - if (intersectedEntityEnd > 0) { - matchFromOffset = qMax(part.innerStart, intersectedEntityEnd); - continue; - } - - if (part.type == EntityInTextPre) { - AdjustMarkdownPrePart(part, result, rich); - } - - if (newResult.text.isEmpty()) newResult.text.reserve(result.text.size()); - for (; existingEntityIndex < existingEntitiesCount && result.entities[existingEntityIndex].offset() < part.innerStart; ++existingEntityIndex) { - auto &entity = result.entities[existingEntityIndex]; - newResult.entities.push_back(entity); - newResult.entities.back().shiftLeft(existingEntityShiftLeft); - } - if (part.outerStart > copyFromOffset) { - newResult.text.append(start + copyFromOffset, part.outerStart - copyFromOffset); - } - if (part.addNewlineBefore) newResult.text.append('\n'); - existingEntityShiftLeft += (part.innerStart - part.outerStart) - (part.addNewlineBefore ? 1 : 0); - - auto entityStart = newResult.text.size(); - auto entityLength = part.innerEnd - part.innerStart; - newResult.entities.push_back(EntityInText(part.type, entityStart, entityLength)); - - for (; existingEntityIndex < existingEntitiesCount && result.entities[existingEntityIndex].offset() <= part.innerEnd; ++existingEntityIndex) { - auto &entity = result.entities[existingEntityIndex]; - newResult.entities.push_back(entity); - newResult.entities.back().shiftLeft(existingEntityShiftLeft); - } - newResult.text.append(start + part.innerStart, entityLength); - if (part.addNewlineAfter) newResult.text.append('\n'); - existingEntityShiftLeft += (part.outerEnd - part.innerEnd) - (part.addNewlineAfter ? 1 : 0); - - copyFromOffset = matchFromOffset = part.outerEnd; - } - if (!newResult.empty()) { - newResult.text.append(start + copyFromOffset, length - copyFromOffset); - for (; existingEntityIndex < existingEntitiesCount; ++existingEntityIndex) { - auto &entity = result.entities[existingEntityIndex]; - newResult.entities.push_back(entity); - newResult.entities.back().shiftLeft(existingEntityShiftLeft); - } - result = std::move(newResult); - } -} - TextWithEntities ParseEntities(const QString &text, int32 flags) { const auto rich = ((flags & TextParseRichText) != 0); auto result = TextWithEntities{ text, EntitiesInText() }; @@ -1801,12 +1578,6 @@ TextWithEntities ParseEntities(const QString &text, int32 flags) { // Some code is duplicated in flattextarea.cpp! void ParseEntities(TextWithEntities &result, int32 flags, bool rich) { - if (flags & TextParseMarkdown) { // parse markdown entities (bold, italic, code and pre) - auto copy = TextWithEntities{ result.text, EntitiesInText() }; - ParseEntities(copy, TextParseLinks, false); - ParseMarkdown(result, copy.entities, rich); - } - constexpr auto kNotFound = std::numeric_limits::max(); auto newEntities = EntitiesInText(); @@ -2059,74 +1830,6 @@ void ParseEntities(TextWithEntities &result, int32 flags, bool rich) { } } -QString ApplyEntities(const TextWithEntities &text) { - if (text.entities.isEmpty()) return text.text; - - QMultiMap closingTags; - QMap tags; - tags.insert(EntityInTextCode, qsl("`")); - tags.insert(EntityInTextPre, qsl("```")); - tags.insert(EntityInTextBold, qsl("**")); - tags.insert(EntityInTextItalic, qsl("__")); - constexpr auto kLargestOpenCloseLength = 6; - - QString result; - int32 size = text.text.size(); - const QChar *b = text.text.constData(), *already = b, *e = b + size; - auto entity = text.entities.cbegin(), end = text.entities.cend(); - auto skipTillRelevantAndGetTag = [&entity, &end, size, &tags] { - while (entity != end) { - if (entity->length() <= 0 || entity->offset() >= size) { - ++entity; - continue; - } - auto it = tags.constFind(entity->type()); - if (it == tags.cend()) { - ++entity; - continue; - } - return it.value(); - } - return QString(); - }; - - auto tag = skipTillRelevantAndGetTag(); - while (entity != end || !closingTags.isEmpty()) { - auto nextOpenEntity = (entity == end) ? (size + 1) : entity->offset(); - auto nextCloseEntity = closingTags.isEmpty() ? (size + 1) : closingTags.cbegin().key(); - if (nextOpenEntity <= nextCloseEntity) { - if (result.isEmpty()) result.reserve(text.text.size() + text.entities.size() * kLargestOpenCloseLength); - - const QChar *offset = b + nextOpenEntity; - if (offset > already) { - result.append(already, offset - already); - already = offset; - } - result.append(tag); - closingTags.insert(qMin(entity->offset() + entity->length(), size), tag); - - ++entity; - tag = skipTillRelevantAndGetTag(); - } else { - const QChar *offset = b + nextCloseEntity; - if (offset > already) { - result.append(already, offset - already); - already = offset; - } - result.append(closingTags.cbegin().value()); - closingTags.erase(closingTags.begin()); - } - } - if (result.isEmpty()) { - return text.text; - } - const QChar *offset = b + size; - if (offset > already) { - result.append(already, offset - already); - } - return result; -} - void MoveStringPart(TextWithEntities &result, int to, int from, int count) { if (!count) return; if (to != from) { diff --git a/Telegram/SourceFiles/ui/text/text_entity.h b/Telegram/SourceFiles/ui/text/text_entity.h index ff3268753..bcfb08beb 100644 --- a/Telegram/SourceFiles/ui/text/text_entity.h +++ b/Telegram/SourceFiles/ui/text/text_entity.h @@ -163,10 +163,14 @@ const QRegularExpression &RegExpHashtag(); const QRegularExpression &RegExpHashtagExclude(); const QRegularExpression &RegExpMention(); const QRegularExpression &RegExpBotCommand(); -const QRegularExpression &RegExpMarkdownBold(); -const QRegularExpression &RegExpMarkdownItalic(); -const QRegularExpression &RegExpMarkdownMonoInline(); -const QRegularExpression &RegExpMarkdownMonoBlock(); +QString MarkdownBoldGoodBefore(); +QString MarkdownBoldBadAfter(); +QString MarkdownItalicGoodBefore(); +QString MarkdownItalicBadAfter(); +QString MarkdownCodeGoodBefore(); +QString MarkdownCodeBadAfter(); +QString MarkdownPreGoodBefore(); +QString MarkdownPreBadAfter(); inline void Append(TextWithEntities &to, TextWithEntities &&append) { auto entitiesShiftRight = to.text.size(); @@ -218,7 +222,6 @@ MTPVector EntitiesToMTP(const EntitiesInText &entities, Conver // Changes text if (flags & TextParseMarkdown). TextWithEntities ParseEntities(const QString &text, int32 flags); void ParseEntities(TextWithEntities &result, int32 flags, bool rich = false); -QString ApplyEntities(const TextWithEntities &text); void PrepareForSending(TextWithEntities &result, int32 flags); void Trim(TextWithEntities &result); diff --git a/Telegram/SourceFiles/ui/widgets/input_fields.cpp b/Telegram/SourceFiles/ui/widgets/input_fields.cpp index 201cb1ada..f10757d3e 100644 --- a/Telegram/SourceFiles/ui/widgets/input_fields.cpp +++ b/Telegram/SourceFiles/ui/widgets/input_fields.cpp @@ -24,10 +24,25 @@ constexpr auto kMaxUsernameLength = 32; constexpr auto kInstantReplaceRandomId = QTextFormat::UserProperty; constexpr auto kInstantReplaceWhatId = QTextFormat::UserProperty + 1; constexpr auto kInstantReplaceWithId = QTextFormat::UserProperty + 2; +constexpr auto kReplaceTagId = QTextFormat::UserProperty + 3; +constexpr auto kTagProperty = QTextFormat::UserProperty + 4; const auto kObjectReplacementCh = QChar(QChar::ObjectReplacementCharacter); const auto kObjectReplacement = QString::fromRawData( &kObjectReplacementCh, 1); +const auto &kTagBold = InputField::kTagBold; +const auto &kTagItalic = InputField::kTagItalic; +const auto &kTagCode = InputField::kTagCode; +const auto &kTagPre = InputField::kTagPre; +const auto kNewlineChars = QString("\r\n") + + QChar(0xfdd0) // QTextBeginningOfFrame + + QChar(0xfdd1) // QTextEndOfFrame + + QChar(QChar::ParagraphSeparator) + + QChar(QChar::LineSeparator); + +bool IsNewline(QChar ch) { + return (kNewlineChars.indexOf(ch) >= 0); +} class TagAccumulator { public: @@ -39,18 +54,24 @@ public: } void feed(const QString &randomTagId, int currentPosition) { - if (randomTagId == _currentTagId) return; + if (randomTagId == _currentTagId) { + return; + } if (!_currentTagId.isEmpty()) { - int randomPartPosition = _currentTagId.lastIndexOf('/'); - Assert(randomPartPosition > 0); + const auto randomPartPosition = _currentTagId.lastIndexOf('/'); + const auto tagId = _currentTagId.midRef( + 0, + (randomPartPosition > 0 + ? randomPartPosition + : _currentTagId.size())); bool tagChanged = true; if (_currentTag < _tags.size()) { auto &alreadyTag = _tags[_currentTag]; if (alreadyTag.offset == _currentStart && alreadyTag.length == currentPosition - _currentStart && - alreadyTag.id == _currentTagId.midRef(0, randomPartPosition)) { + alreadyTag.id == tagId) { tagChanged = false; } } @@ -59,7 +80,7 @@ public: const auto tag = TextWithTags::Tag { _currentStart, currentPosition - _currentStart, - _currentTagId.mid(0, randomPartPosition), + tagId.toString() }; if (_currentTag < _tags.size()) { _tags[_currentTag] = tag; @@ -90,6 +111,297 @@ private: }; +struct TagStartExpression { + QString tag; + QString goodBefore; + QString badAfter; +}; + +struct TagStartItem { + int offset = 0; + int position = -1; +}; + +constexpr auto kTagBoldIndex = 0; +constexpr auto kTagItalicIndex = 1; +constexpr auto kTagCodeIndex = 2; +constexpr auto kTagPreIndex = 3; +constexpr auto kInvalidPosition = std::numeric_limits::max() / 2; + +const std::vector &TagStartExpressions() { + static auto cached = std::vector { + { + kTagBold, + TextUtilities::MarkdownBoldGoodBefore(), + TextUtilities::MarkdownBoldBadAfter() + }, + { + kTagItalic, + TextUtilities::MarkdownItalicGoodBefore(), + TextUtilities::MarkdownItalicBadAfter() + }, + { + kTagCode, + TextUtilities::MarkdownCodeGoodBefore(), + TextUtilities::MarkdownCodeBadAfter() + }, + { + kTagPre, + TextUtilities::MarkdownPreGoodBefore(), + TextUtilities::MarkdownPreBadAfter() + }, + }; + return cached; +} + +const std::map> &TagFinishIndices() { + static auto cached = std::map> { + { kTagBold, { kTagBoldIndex, kTagCodeIndex, kTagPreIndex } }, + { kTagItalic, { kTagItalicIndex, kTagCodeIndex, kTagPreIndex } }, + { kTagCode, { kTagCodeIndex, kTagPreIndex } }, + { kTagPre, { kTagCodeIndex, kTagPreIndex } }, + }; + return cached; +} + +bool DoesTagFinishByNewline(const QString &tag) { + return (tag == kTagCode); +} + +class PossibleTagAccumulator { +public: + PossibleTagAccumulator(std::vector *tags) + : _tags(tags) + , _expressions(TagStartExpressions()) + , _finishIndices(TagFinishIndices()) + , _items(_expressions.size()) { + } + + void feed(const QString &text, const QString &textTag) { + if (!_tags) { + return; + } + const auto guard = gsl::finally([&] { + _currentLength += text.size(); + }); + if (!textTag.isEmpty()) { + finishTags(); + return; + } + for (auto &item : _items) { + item = TagStartItem(); + } + auto tagIndex = _currentTag; + while (true) { + for (; tagIndex != _currentFreeTag; ++tagIndex) { + auto &tag = (*_tags)[tagIndex]; + bumpOffsetByTag(tag, tag.start + 1); + + const auto finishIt = _finishIndices.find(tag.tag); + Assert(finishIt != end(_finishIndices)); + const auto &finishingIndices = finishIt->second; + for (const auto index : finishingIndices) { + fillItem(index, text); + } + if (finishByNewline(tagIndex, text, finishingIndices)) { + continue; + } + const auto min = minIndex(finishingIndices); + if (min >= 0) { + const auto minPosition = matchPosition(min); + finishTag(tagIndex, _currentLength + minPosition); + } else if (tag.tag == kTagPre || tag.tag == kTagCode) { + // We can't finish a mono tag, so we ignore all others. + return; + } + } + for (auto i = 0, count = int(_items.size()); i != count; ++i) { + fillItem(i, text); + } + const auto min = minIndex(); + if (min < 0) { + return; + } + startTag( + _currentLength + matchPosition(min), + _expressions[min].tag); + } + } + + void finish() { + if (!_tags) { + return; + } + finishTags(); + if (_currentTag < _tags->size()) { + _tags->resize(_currentTag); + } + } + +private: + void finishTag(int index, int end) { + Expects(_tags != nullptr); + Expects(index >= 0 && index < _tags->size()); + + auto &tag = (*_tags)[index]; + if (tag.length < 0) { + tag.length = end - tag.start; + } + if (index == _currentTag) { + ++_currentTag; + } + } + bool finishByNewline( + int index, + const QString &text, + const std::vector &finishingIndices) { + Expects(_tags != nullptr); + Expects(index >= 0 && index < _tags->size()); + + auto &tag = (*_tags)[index]; + + if (!DoesTagFinishByNewline(tag.tag)) { + return false; + } + const auto endPosition = newlinePosition( + text, + std::max(0, tag.start + 1 - _currentLength)); + for (const auto finishingIndex : finishingIndices) { + if (matchPosition(finishingIndex) <= endPosition) { + return false; + } + } + finishTag(index, _currentLength + endPosition); + return true; + } + void bumpOffsetByTag(const InputField::PossibleTag &tag, int end) { + const auto offset = end - _currentLength; + if (tag.tag == kTagPre || tag.tag == kTagCode) { + for (auto &item : _items) { + applyOffset(item, offset); + } + } else if (tag.tag == kTagBold) { + applyOffset(_items[kTagBoldIndex], offset); + } else if (tag.tag == kTagItalic) { + applyOffset(_items[kTagItalicIndex], offset); + } else { + Unexpected("Unsupported tag."); + } + } + void applyOffset(TagStartItem &item, int offset) { + if (matchPosition(item) < offset) { + item.position = -1; + } + accumulate_max(item.offset, offset); + } + void finishTags() { + while (_currentTag != _currentFreeTag) { + finishTag(_currentTag, _currentLength); + } + } + void startTag(int offset, const QString &tag) { + Expects(_tags != nullptr); + + if (_currentFreeTag < _tags->size()) { + (*_tags)[_currentFreeTag] = { offset, -1, tag }; + } else { + _tags->push_back({ offset, -1, tag }); + } + ++_currentFreeTag; + } + void fillItem(int index, const QString &text) { + Expects(index >= 0 && index < _items.size()); + + auto &item = _items[index]; + if (item.position >= 0) { + return; + } + const auto length = text.size(); + const auto &expression = _expressions[index]; + const auto &tag = expression.tag; + const auto &goodBefore = expression.goodBefore; + const auto &badAfter = expression.badAfter; + const auto tagLength = tag.size(); + while (true) { + item.position = text.indexOf(tag, item.offset); + if (item.position < 0) { + item.offset = item.position = kInvalidPosition; + break; + } + item.offset = item.position + tagLength; + if (item.position > 0) { + const auto before = text[item.position - 1]; + if (expression.goodBefore.indexOf(before) < 0) { + continue; + } + } + if (item.position + tagLength + 1 < length) { + const auto after = text[item.position + tagLength + 1]; + if (expression.badAfter.indexOf(after) >= 0) { + continue; + } + } + break; + } + item.offset = item.position + tagLength; + } + int matchPosition(int index) const { + Expects(index >= 0 && index < _items.size()); + + return matchPosition(_items[index]); + } + int matchPosition(const TagStartItem &item) const { + const auto position = item.position; + return (item.position >= 0) ? item.position : kInvalidPosition; + } + int newlinePosition(const QString &text, int offset) const { + const auto length = text.size(); + if (offset < length) { + auto ch = text.data() + offset; + for (const auto e = ch + length; ch != e; ++ch) { + if (IsNewline(*ch)) { + return (ch - text.data()); + } + } + } + return kInvalidPosition; + } + int minIndex() const { + auto result = -1; + auto minPosition = kInvalidPosition; + for (auto i = 0, count = int(_items.size()); i != count; ++i) { + const auto position = matchPosition(i); + if (position < minPosition) { + minPosition = position; + result = i; + } + } + return result; + } + int minIndex(const std::vector &indices) const { + auto result = -1; + auto minPosition = kInvalidPosition; + for (auto i : indices) { + const auto position = matchPosition(i); + if (position < minPosition) { + minPosition = position; + result = i; + } + } + return result; + } + + std::vector *_tags = nullptr; + const std::vector &_expressions; + const std::map> &_finishIndices; + std::vector _items; + + int _currentTag = 0; + int _currentFreeTag = 0; + int _currentLength = 0; + +}; + template class InputStyle : public QCommonStyle { public: @@ -162,7 +474,7 @@ void PrepareFormattingOptimization(not_null document) { } void RemoveDocumentTags( - style::color textFg, + const style::InputField &st, not_null document, int from, int end) { @@ -170,16 +482,66 @@ void RemoveDocumentTags( cursor.setPosition(end, QTextCursor::KeepAnchor); QTextCharFormat format; - format.setAnchor(false); - format.setAnchorName(QString()); - format.setForeground(textFg); + format.setProperty(kTagProperty, QString()); + format.setProperty(kReplaceTagId, QString()); + format.setForeground(st.textFg); + format.setFont(st.font); cursor.mergeCharFormat(format); } +style::font AdjustFont( + const style::font &font, + const style::font &original) { + return (font->size() != original->size() + || font->flags() != original->flags()) + ? style::font(original->size(), original->flags(), font->family()) + : font; +} + +QTextCharFormat PrepareTagFormat( + const style::InputField &st, + QString tag) { + auto result = QTextCharFormat(); + if (tag.indexOf(':') >= 0) { + tag += '/' + QString::number(rand_value()); + result.setForeground(st::defaultTextPalette.linkFg); + result.setFont(st.font); + } else if (tag == kTagBold) { + auto semibold = st::semiboldFont; + if (semibold->size() != st.font->size() + || semibold->flags() != st.font->flags()) { + semibold = style::font( + st.font->size(), + st.font->flags(), + semibold->family()); + } + result.setForeground(st.textFg); + result.setFont(AdjustFont(st::semiboldFont, st.font)); + } else if (tag == kTagItalic) { + result.setForeground(st.textFg); + result.setFont(st.font->italic()); + } else if (tag == kTagCode || tag == kTagPre) { + result.setForeground(st::defaultTextPalette.monoFg); + result.setFont(AdjustFont(App::monofont(), st.font)); + } else { + result.setForeground(st.textFg); + result.setFont(st.font); + } + result.setProperty(kTagProperty, tag); + return result; +} + +void ApplyTagFormat(QTextCharFormat &to, const QTextCharFormat &from) { + to.setProperty(kTagProperty, from.property(kTagProperty)); + to.setProperty(kReplaceTagId, from.property(kReplaceTagId)); + to.setFont(from.font()); + to.setForeground(from.foreground()); +} + // Returns the position of the first inserted tag or "changedEnd" value if none found. int ProcessInsertedTags( - style::color textFg, - QTextDocument *document, + const style::InputField &st, + not_null document, int changedPosition, int changedEnd, const TextWithTags::Tags &tags, @@ -198,23 +560,23 @@ int ProcessInsertedTags( PrepareFormattingOptimization(document); if (applyNoTagFrom < tagFrom) { - RemoveDocumentTags(textFg, document, applyNoTagFrom, tagFrom); + RemoveDocumentTags( + st, + document, + applyNoTagFrom, + tagFrom); } QTextCursor c(document->docHandle(), 0); c.setPosition(tagFrom); c.setPosition(tagTo, QTextCursor::KeepAnchor); - QTextCharFormat format; - format.setAnchor(true); - format.setAnchorName(tagId + '/' + QString::number(rand_value())); - format.setForeground(st::defaultTextPalette.linkFg); - c.mergeCharFormat(format); + c.mergeCharFormat(PrepareTagFormat(st, tagId)); applyNoTagFrom = tagTo; } } if (applyNoTagFrom < changedEnd) { - RemoveDocumentTags(textFg, document, applyNoTagFrom, changedEnd); + RemoveDocumentTags(st, document, applyNoTagFrom, changedEnd); } return firstTagStart; @@ -227,16 +589,19 @@ bool WasInsertTillTheEndOfTag( QTextBlock block, QTextBlock::iterator fragmentIt, int insertionEnd) { - auto insertTagName = fragmentIt.fragment().charFormat().anchorName(); + const auto format = fragmentIt.fragment().charFormat(); + const auto insertTagName = format.property(kTagProperty); while (true) { for (; !fragmentIt.atEnd(); ++fragmentIt) { - auto fragment = fragmentIt.fragment(); - bool fragmentOutsideInsertion = (fragment.position() >= insertionEnd); - if (fragmentOutsideInsertion) { - return (fragment.charFormat().anchorName() != insertTagName); + const auto fragment = fragmentIt.fragment(); + const auto position = fragment.position(); + const auto outsideInsertion = (position >= insertionEnd); + if (outsideInsertion) { + const auto format = fragment.charFormat(); + return (format.property(kTagProperty) != insertTagName); } - int fragmentEnd = fragment.position() + fragment.length(); - bool notFullFragmentInserted = (fragmentEnd > insertionEnd); + const auto end = position + fragment.length(); + const auto notFullFragmentInserted = (end > insertionEnd); if (notFullFragmentInserted) { return false; } @@ -265,6 +630,7 @@ struct FormattingAction { Type type = Type::Invalid; EmojiPtr emoji = nullptr; bool isTilde = false; + QString tildeTag; int intervalStart = 0; int intervalEnd = 0; @@ -272,6 +638,11 @@ struct FormattingAction { } // namespace +const QString InputField::kTagBold = qsl("**"); +const QString InputField::kTagItalic = qsl("__"); +const QString InputField::kTagCode = qsl("`"); +const QString InputField::kTagPre = qsl("```"); + class InputField::Inner final : public QTextEdit { public: Inner(not_null parent) : QTextEdit(parent) { @@ -322,11 +693,7 @@ private: void InsertEmojiAtCursor(QTextCursor cursor, EmojiPtr emoji) { const auto currentFormat = cursor.charFormat(); auto format = PrepareEmojiFormat(emoji, currentFormat.font()); - if (currentFormat.isAnchor()) { - format.setAnchor(true); - format.setAnchorName(currentFormat.anchorName()); - format.setForeground(st::defaultTextPalette.linkFg); - } + ApplyTagFormat(format, currentFormat); cursor.insertText(kObjectReplacement, format); } @@ -703,6 +1070,9 @@ InputField::InputField( _inner->setFont(_st.font->f); _inner->setAlignment(_st.textAlign); + _defaultCharFormat = _inner->textCursor().charFormat(); + _defaultCharFormat.merge(PrepareTagFormat(_st, QString())); + _inner->textCursor().setCharFormat(_defaultCharFormat); if (_mode == Mode::SingleLine) { _inner->setWordWrapMode(QTextOption::NoWrap); } @@ -733,7 +1103,6 @@ InputField::InputField( connect(&_touchTimer, SIGNAL(timeout()), this, SLOT(onTouchTimer())); connect(_inner->document(), SIGNAL(contentsChange(int,int,int)), this, SLOT(onDocumentContentsChange(int,int,int))); - connect(_inner->document(), SIGNAL(contentsChanged()), this, SLOT(onDocumentContentsChanged())); connect(_inner, SIGNAL(undoAvailable(bool)), this, SLOT(onUndoAvailable(bool))); connect(_inner, SIGNAL(redoAvailable(bool)), this, SLOT(onRedoAvailable(bool))); if (App::wnd()) connect(_inner, SIGNAL(selectionChanged()), App::wnd(), SLOT(updateGlobalMenu())); @@ -751,8 +1120,6 @@ InputField::InputField( setTextWithTags(_lastTextWithTags, HistoryAction::Clear); } - _defaultCharFormat = _inner->textCursor().charFormat(); - startBorderAnimation(); startPlaceholderAnimation(); finishAnimating(); @@ -801,6 +1168,10 @@ void InputField::onTouchTimer() { _touchRightButton = true; } +void InputField::enableMarkdownSupport(bool enabled) { + _markdownEnabled = enabled; +} + void InputField::setInstantReplaces(const InstantReplaces &replaces) { _mutableInstantReplaces = replaces; } @@ -814,6 +1185,12 @@ void InputField::setTagMimeProcessor( _tagMimeProcessor = std::move(processor); } +void InputField::setAdditionalMargin(int margin) { + _inner->setStyleSheet(qsl("QTextEdit { margin: %1px; }").arg(margin)); + _additionalMargin = margin; + checkContentHeight(); +} + void InputField::setMaxLength(int length) { _maxLength = length; } @@ -919,14 +1296,13 @@ bool InputField::heightAutoupdated() { SendPendingMoveResizeEvents(this); - int newh = ceil(document()->size().height()) + _st.textMargins.top() + _st.textMargins.bottom() + 2 * _fakeMargin; - if (newh > _maxHeight) { - newh = _maxHeight; - } else if (newh < _minHeight) { - newh = _minHeight; - } - if (height() != newh) { - resize(width(), newh); + const auto contentHeight = int(std::ceil(document()->size().height())) + + _st.textMargins.top() + + _st.textMargins.bottom() + + 2 * _additionalMargin; + const auto newHeight = snap(contentHeight, _minHeight, _maxHeight); + if (height() != newHeight) { + resize(width(), newHeight); return true; } return false; @@ -1165,17 +1541,25 @@ QString InputField::getTextPart( int start, int end, TagList &outTagsList, - bool &outTagsChanged) const { + bool &outTagsChanged, + std::vector *outPossibleTags) const { + Expects((start == 0 && end < 0) || outPossibleTags == nullptr); + if (end >= 0 && end <= start) { outTagsChanged = !outTagsList.isEmpty(); outTagsList.clear(); return QString(); } - if (start < 0) start = 0; + if (start < 0) { + start = 0; + } const auto full = (start == 0 && end < 0); + auto lastTag = QString(); TagAccumulator tagAccumulator(outTagsList); + PossibleTagAccumulator possibleTagAccumulator(outPossibleTags); + const auto newline = outPossibleTags ? QString(1, '\n') : QString(); const auto document = _inner->document(); const auto from = full ? document->begin() : document->findBlock(start); @@ -1189,13 +1573,13 @@ QString InputField::getTextPart( possibleLength += block.length(); } auto result = QString(); - result.reserve(possibleLength + 1); + result.reserve(possibleLength); if (!full && end < 0) { end = possibleLength; } bool tillFragmentEnd = full; - for (auto block = from; block != till; block = block.next()) { + for (auto block = from; block != till;) { for (auto item = block.begin(); !item.atEnd(); ++item) { const auto fragment = item.fragment(); if (!fragment.isValid()) { @@ -1210,62 +1594,81 @@ QString InputField::getTextPart( if (!full) { tillFragmentEnd = (fragmentEnd <= end); if (fragmentPosition == end) { - tagAccumulator.feed(format.anchorName(), result.size()); - } - if (fragmentPosition >= end) { + tagAccumulator.feed( + format.property(kTagProperty).toString(), + result.size()); + break; + } else if (fragmentPosition > end) { break; } else if (fragmentEnd <= start) { continue; } } + + const auto emojiText = [&] { + if (format.isImageFormat()) { + const auto imageName = format.toImageFormat().name(); + if (const auto emoji = Ui::Emoji::FromUrl(imageName)) { + return emoji->text(); + } + } + return QString(); + }(); + auto text = [&] { + const auto result = fragment.text(); + if (!full) { + if (fragmentPosition < start) { + return result.mid(start - fragmentPosition, end - start); + } else if (fragmentEnd > end) { + return result.mid(0, end - fragmentPosition); + } + } + return result; + }(); + if (full || fragmentPosition >= start) { - tagAccumulator.feed(format.anchorName(), result.size()); + lastTag = format.property(kTagProperty).toString(); + tagAccumulator.feed(lastTag, result.size()); + possibleTagAccumulator.feed(text, lastTag); } - QString emojiText; - auto t = fragment.text(); - if (!full) { - if (fragmentPosition < start) { - t = t.mid(start - fragmentPosition, end - start); - } else if (fragmentEnd > end) { - t = t.mid(0, end - fragmentPosition); - } - } - QChar *ub = t.data(), *uc = ub, *ue = uc + t.size(); - for (; uc != ue; ++uc) { - switch (uc->unicode()) { - case 0xfdd0: // QTextBeginningOfFrame - case 0xfdd1: // QTextEndOfFrame - case QChar::ParagraphSeparator: - case QChar::LineSeparator: { - *uc = QLatin1Char('\n'); - } break; + auto begin = text.data(); + auto ch = begin; + for (const auto end = begin + text.size(); ch != end; ++ch) { + if (IsNewline(*ch) && ch->unicode() != '\r') { + *ch = QLatin1Char('\n'); + } else switch (ch->unicode()) { case QChar::Nbsp: { - *uc = QLatin1Char(' '); + *ch = QLatin1Char(' '); } break; case QChar::ObjectReplacementCharacter: { - if (emojiText.isEmpty() && format.isImageFormat()) { - const auto imageName = format.toImageFormat().name(); - if (const auto emoji = Ui::Emoji::FromUrl(imageName)) { - emojiText = emoji->text(); - } + if (ch > begin) { + result.append(begin, ch - begin); } - if (uc > ub) result.append(ub, uc - ub); - if (!emojiText.isEmpty()) result.append(emojiText); - ub = uc + 1; + if (!emojiText.isEmpty()) { + result.append(emojiText); + } + begin = ch + 1; } break; } } - if (uc > ub) result.append(ub, uc - ub); + if (ch > begin) { + result.append(begin, ch - begin); + } + } + + block = block.next(); + if (block != till) { + result.append('\n'); + possibleTagAccumulator.feed(newline, lastTag); } - result.append('\n'); } - result.chop(1); if (tillFragmentEnd) { tagAccumulator.feed(QString(), result.size()); } tagAccumulator.finish(); + possibleTagAccumulator.finish(); outTagsChanged = tagAccumulator.changed(); return result; @@ -1281,10 +1684,11 @@ bool InputField::isRedoAvailable() const { void InputField::processFormatting(int insertPosition, int insertEnd) { // Tilde formatting. - auto tildeFormatting = !cRetina() && (font().pixelSize() == 13) && (font().family() == qstr("Open Sans")); + const auto tildeFormatting = !cRetina() + && (font().pixelSize() == 13) + && (font().family() == qstr("Open Sans")); auto isTildeFragment = false; - auto tildeRegularFont = tildeFormatting ? qsl("Open Sans") : QString(); - auto tildeFixedFont = tildeFormatting ? Fonts::GetOverride(qsl("Open Sans Semibold")) : QString(); + const auto tildeFixedFont = AdjustFont(st::semiboldFont, _st.font); // First tag handling (the one we inserted text to). bool startTagFound = false; @@ -1293,9 +1697,11 @@ void InputField::processFormatting(int insertPosition, int insertEnd) { auto document = _inner->document(); // Apply inserted tags. - auto insertedTagsProcessor = _insertedTagsAreFromMime ? _tagMimeProcessor.get() : nullptr; + auto insertedTagsProcessor = _insertedTagsAreFromMime + ? _tagMimeProcessor.get() + : nullptr; const auto breakTagOnNotLetterTill = ProcessInsertedTags( - _st.textFg, + _st, document, insertPosition, insertEnd, @@ -1325,8 +1731,14 @@ void InputField::processFormatting(int insertPosition, int insertEnd) { } auto format = fragment.charFormat(); + if (!format.hasProperty(kTagProperty)) { + action.type = ActionType::RemoveTag; + action.intervalStart = fragmentPosition; + action.intervalEnd = fragmentPosition + fragment.length(); + break; + } if (tildeFormatting) { - isTildeFragment = (format.fontFamily() == tildeFixedFont); + isTildeFragment = (format.font() == tildeFixedFont); } auto fragmentText = fragment.text(); @@ -1350,7 +1762,7 @@ void InputField::processFormatting(int insertPosition, int insertEnd) { if (!startTagFound) { startTagFound = true; - auto tagName = format.anchorName(); + auto tagName = format.property(kTagProperty).toString(); if (!tagName.isEmpty()) { breakTagOnNotLetter = WasInsertTillTheEndOfTag( block, @@ -1362,13 +1774,7 @@ void InputField::processFormatting(int insertPosition, int insertEnd) { auto *ch = textStart + qMax(changedPositionInFragment, 0); for (; ch < textEnd; ++ch) { const auto removeNewline = (_mode == Mode::SingleLine) - && (false - || ch->unicode() == 0xfdd0 // QTextBeginningOfFrame - || ch->unicode() == 0xfdd1 // QTextEndOfFrame - || ch->unicode() == QChar::ParagraphSeparator - || ch->unicode() == QChar::LineSeparator - || ch->unicode() == '\n' - || ch->unicode() == '\r'); + && (IsNewline(*ch)); if (removeNewline) { if (action.type == ActionType::Invalid) { action.type = ActionType::RemoveNewline; @@ -1410,6 +1816,7 @@ void InputField::processFormatting(int insertPosition, int insertEnd) { action.type = ActionType::TildeFont; action.intervalStart = fragmentPosition + (ch - textStart); action.intervalEnd = action.intervalStart + 1; + action.tildeTag = format.property(kTagProperty).toString(); action.isTilde = tilde; } else { ++action.intervalEnd; @@ -1454,24 +1861,21 @@ void InputField::processFormatting(int insertPosition, int insertEnd) { - 1; } } else if (action.type == ActionType::RemoveTag) { - QTextCharFormat format; - format.setAnchor(false); - format.setAnchorName(QString()); - format.setForeground(_st.textFg); - cursor.mergeCharFormat(format); + RemoveDocumentTags( + _st, + document, + action.intervalStart, + action.intervalEnd); } else if (action.type == ActionType::TildeFont) { - QTextCharFormat format; - format.setFontFamily(action.isTilde ? tildeFixedFont : tildeRegularFont); + auto format = QTextCharFormat(); + format.setFont(action.isTilde + ? tildeFixedFont + : PrepareTagFormat(_st, action.tildeTag).font()); cursor.mergeCharFormat(format); insertPosition = action.intervalEnd; } else if (action.type == ActionType::ClearInstantReplace) { auto format = _defaultCharFormat; - const auto current = cursor.charFormat(); - if (current.isAnchor()) { - format.setAnchor(true); - format.setAnchorName(current.anchorName()); - format.setForeground(st::defaultTextPalette.linkFg); - } + ApplyTagFormat(format, cursor.charFormat()); cursor.setCharFormat(format); } else if (action.type == ActionType::RemoveNewline) { cursor.removeSelectedText(); @@ -1490,7 +1894,9 @@ void InputField::onDocumentContentsChange( int position, int charsRemoved, int charsAdded) { - if (_correcting) return; + if (_correcting) { + return; + } const auto document = _inner->document(); @@ -1517,34 +1923,32 @@ void InputField::onDocumentContentsChange( const auto removePosition = position; const auto removeLength = charsRemoved; + _correcting = true; QTextCursor(document->docHandle(), 0).joinPreviousEditBlock(); const auto guard = gsl::finally([&] { + _correcting = false; QTextCursor(document->docHandle(), 0).endEditBlock(); + handleContentsChanged(); }); chopByMaxLength(insertPosition, insertLength); - if (document->availableRedoSteps() > 0 || insertLength <= 0) { - return; + if (document->availableRedoSteps() == 0 && insertLength > 0) { + const auto pageSize = document->pageSize(); + processFormatting(insertPosition, insertPosition + insertLength); + if (document->pageSize() != pageSize) { + document->setPageSize(pageSize); + } } - - _correcting = true; - auto pageSize = document->pageSize(); - processFormatting(insertPosition, insertPosition + insertLength); - if (document->pageSize() != pageSize) { - document->setPageSize(pageSize); - } - _correcting = false; } void InputField::chopByMaxLength(int insertPosition, int insertLength) { + Expects(_correcting); + if (_maxLength < 0) { return; } - _correcting = true; - const auto guard = gsl::finally([&] { _correcting = false; }); - auto cursor = QTextCursor(document()->docHandle(), 0); cursor.movePosition(QTextCursor::End); const auto fullSize = cursor.position(); @@ -1572,9 +1976,7 @@ void InputField::chopByMaxLength(int insertPosition, int insertLength) { } } -void InputField::onDocumentContentsChanged() { - if (_correcting) return; - +void InputField::handleContentsChanged() { setErrorShown(false); auto tagsChanged = false; @@ -1582,7 +1984,8 @@ void InputField::onDocumentContentsChanged() { 0, -1, _lastTextWithTags.tags, - tagsChanged); + tagsChanged, + _markdownEnabled ? &_textAreaPossibleTags : nullptr); if (tagsChanged || (_lastTextWithTags.text != currentText)) { _lastTextWithTags.text = currentText; @@ -1670,8 +2073,12 @@ QMimeData *InputField::createMimeDataFromSelectionInner() const { return result.release(); } -void InputField::customUpDown(bool custom) { - _customUpDown = custom; +void InputField::customUpDown(bool isCustom) { + _customUpDown = isCustom; +} + +void InputField::customTab(bool isCustom) { + _customTab = isCustom; } void InputField::setSubmitSettings(SubmitSettings settings) { @@ -1787,18 +2194,20 @@ void InputField::keyPressEventInner(QKeyEvent *e) { tc.removeSelectedText(); } else if (e->key() == Qt::Key_Backspace && e->modifiers() == 0 - && revertInstantReplace()) { + && revertFormatReplace()) { e->accept(); } else if (enter && enterSubmit) { emit submitted(ctrl && shift); } else if (e->key() == Qt::Key_Escape) { e->ignore(); emit cancelled(); - } else if (e->key() == Qt::Key_Tab || (ctrl && e->key() == Qt::Key_Backtab)) { + } else if (e->key() == Qt::Key_Tab || e->key() == Qt::Key_Backtab) { if (alt || ctrl) { e->ignore(); - } else { + } else if (_customTab) { emit tabbed(); + } else if (!focusNextPrevChild(e->key() == Qt::Key_Tab && !shift)) { + e->ignore(); } } else if (e->key() == Qt::Key_Search || e == QKeySequence::Find) { e->ignore(); @@ -1842,7 +2251,9 @@ void InputField::keyPressEventInner(QKeyEvent *e) { } } } - processInstantReplaces(text); + if (!processMarkdownReplaces(text)) { + processInstantReplaces(text); + } } } @@ -1850,14 +2261,53 @@ const InstantReplaces &InputField::instantReplaces() const { return _mutableInstantReplaces; } -void InputField::processInstantReplaces(const QString &text) { +bool InputField::processMarkdownReplaces(const QString &appended) { + if (appended.size() != 1 + || !_markdownEnabled) { + return false; + } + const auto ch = appended[0]; + if (ch == '`') { + return processMarkdownReplace(kTagCode) + || processMarkdownReplace(kTagPre); + } else if (ch == '*') { + return processMarkdownReplace(kTagBold); + } else if (ch == '_') { + return processMarkdownReplace(kTagItalic); + } + return false; +} + +bool InputField::processMarkdownReplace(const QString &tag) { + const auto position = textCursor().position(); + const auto tagLength = tag.size(); + const auto start = [&] { + for (const auto &possible : _textAreaPossibleTags) { + const auto end = possible.start + possible.length; + if (possible.start + 2 * tagLength >= position) { + return PossibleTag(); + } else if (end >= position || end + tagLength == position) { + if (possible.tag == tag) { + return possible; + } + } + } + return PossibleTag(); + }(); + if (start.tag.isEmpty()) { + return false; + } + return commitMarkdownReplacement(start.start, position, tag, tag); +} + +void InputField::processInstantReplaces(const QString &appended) { const auto &replaces = instantReplaces(); - if (text.size() != 1 + if (appended.size() != 1 || !_instantReplacesEnabled || !replaces.maxLength) { return; } - const auto it = replaces.reverseMap.tail.find(text[0]); + const auto it = replaces.reverseMap.tail.find(appended[0]); if (it == end(replaces.reverseMap.tail)) { return; } @@ -1869,7 +2319,7 @@ void InputField::processInstantReplaces(const QString &text) { auto i = typed.size(); do { if (!node->text.isEmpty()) { - applyInstantReplace(typed.mid(i) + text, node->text); + applyInstantReplace(typed.mid(i) + appended, node->text); return; } else if (!i) { return; @@ -1907,6 +2357,10 @@ void InputField::commitInstantReplacement( return; } + auto cursor = textCursor(); + cursor.setPosition(from); + cursor.setPosition(till, QTextCursor::KeepAnchor); + auto format = [&]() -> QTextCharFormat { auto emojiLength = 0; const auto emoji = Ui::Emoji::Find(with, &emojiLength); @@ -1932,27 +2386,124 @@ void InputField::commitInstantReplacement( format.setProperty(kInstantReplaceWhatId, original); format.setProperty(kInstantReplaceWithId, replacement); format.setProperty(kInstantReplaceRandomId, rand_value()); - auto cursor = textCursor(); - cursor.setPosition(from); - cursor.setPosition(till, QTextCursor::KeepAnchor); - const auto current = cursor.charFormat(); - if (current.isAnchor()) { - format.setAnchor(true); - format.setAnchorName(current.anchorName()); - format.setForeground(st::defaultTextPalette.linkFg); - } + ApplyTagFormat(format, cursor.charFormat()); cursor.insertText(replacement, format); } -bool InputField::revertInstantReplace() { +bool InputField::commitMarkdownReplacement( + int from, + int till, + const QString &tag, + const QString &edge) { + const auto end = [&] { + auto cursor = QTextCursor(document()->docHandle(), 0); + cursor.movePosition(QTextCursor::End); + return cursor.position(); + }(); + + // In case of 'pre' tag extend checked text by one symbol. + // So that we'll know if we need to insert additional newlines. + // "Test ```test``` Test" should become three-line text. + const auto blocktag = (tag == kTagPre); + const auto extendLeft = (blocktag && from > 0) ? 1 : 0; + const auto extendRight = (blocktag && till < end) ? 1 : 0; + const auto extended = getTextWithTagsPart( + from - extendLeft, + till + extendRight).text; + const auto outer = extended.midRef( + extendLeft, + extended.size() - extendLeft - extendRight); + if ((outer.size() <= 2 * edge.size()) + || (!edge.isEmpty() + && !(outer.startsWith(edge) && outer.endsWith(edge)))) { + return false; + } + + // In case of 'pre' tag check if we need to remove one of two newlines. + // "Test\n```\ntest\n```" should become two-line text + newline. + const auto innerRight = edge.size(); + const auto checkIfTwoNewlines = blocktag + && (extendLeft > 0) + && IsNewline(extended[0]); + const auto innerLeft = [&] { + const auto simple = edge.size(); + if (!checkIfTwoNewlines) { + return simple; + } + const auto last = outer.size() - innerRight; + for (auto check = simple; check != last; ++check) { + const auto ch = outer.at(check); + if (IsNewline(ch)) { + return check + 1; + } else if (!chIsSpace(ch)) { + break; + } + } + return simple; + }(); + const auto innerLength = outer.size() - innerLeft - innerRight; + + // Prepare the final "insert" replacement for the "outer" text part. + const auto newlineleft = blocktag + && (extendLeft > 0) + && !IsNewline(extended[0]) + && !IsNewline(outer.at(innerLeft)); + const auto newlineright = blocktag + && (!extendRight || !IsNewline(extended[extended.size() - 1])) + && !IsNewline(outer.at(outer.size() - innerRight - 1)); + const auto insert = (newlineleft ? "\n" : "") + + outer.mid(innerLeft, innerLength).toString() + + (newlineright ? "\n" : ""); + + // Trim inserted tag, so that all spaces and newlines are left outside. + _insertedTags.clear(); + auto tagFrom = newlineleft ? 1 : 0; + auto tagTill = insert.size() - (newlineright ? 1 : 0); + for (; tagFrom != tagTill; ++tagFrom) { + const auto ch = insert.at(tagFrom); + if (!IsNewline(ch) && !chIsSpace(ch)) { + break; + } + } + for (; tagTill != tagFrom; --tagTill) { + const auto ch = insert.at(tagTill - 1); + if (!IsNewline(ch) && !chIsSpace(ch)) { + break; + } + } + if (tagTill > tagFrom) { + _insertedTags.push_back({ + tagFrom, + tagTill - tagFrom, + tag, + }); + } + + // Replace. + auto cursor = _inner->textCursor(); + cursor.setPosition(from); + cursor.setPosition(till, QTextCursor::KeepAnchor); + auto format = _defaultCharFormat; + format.setProperty(kReplaceTagId, tag); + _insertedTagsAreFromMime = false; + cursor.insertText(insert, format); + _insertedTags.clear(); + + cursor.setCharFormat(_defaultCharFormat); + _inner->setTextCursor(cursor); + return true; +} + +bool InputField::revertFormatReplace() { const auto cursor = textCursor(); const auto position = cursor.position(); if (position <= 0 || cursor.anchor() != position) { return false; } const auto inside = position - 1; - const auto block = _inner->document()->findBlock(inside); - if (block == _inner->document()->end()) { + const auto document = _inner->document(); + const auto block = document->findBlock(inside); + if (block == document->end()) { return false; } for (auto i = block.begin(); !i.atEnd(); ++i) { @@ -1964,27 +2515,69 @@ bool InputField::revertInstantReplace() { } else if (fragmentStart > inside || fragmentEnd != position) { return false; } - const auto format = fragment.charFormat(); - const auto with = format.property(kInstantReplaceWithId); - if (!with.isValid()) { - return false; + const auto current = fragment.charFormat(); + if (current.hasProperty(kInstantReplaceWithId)) { + const auto with = current.property(kInstantReplaceWithId); + const auto string = with.toString(); + if (fragment.text() != string) { + return false; + } + auto replaceCursor = cursor; + replaceCursor.setPosition(fragmentStart); + replaceCursor.setPosition(fragmentEnd, QTextCursor::KeepAnchor); + const auto what = current.property(kInstantReplaceWhatId); + auto format = _defaultCharFormat; + ApplyTagFormat(format, current); + replaceCursor.insertText(what.toString(), format); + return true; + } else if (current.hasProperty(kReplaceTagId)) { + const auto tag = current.property(kReplaceTagId).toString(); + if (tag.isEmpty()) { + return false; + } else if (auto test = i; !(++test).atEnd()) { + const auto format = test.fragment().charFormat(); + if (format.property(kReplaceTagId).toString() == tag) { + return false; + } + } else if (auto test = block; test.next() != document->end()) { + const auto begin = test.begin(); + if (begin != test.end()) { + const auto format = begin.fragment().charFormat(); + if (format.property(kReplaceTagId).toString() == tag) { + return false; + } + } + } + + const auto first = [&] { + auto checkBlock = block; + auto checkLast = i; + while (true) { + for (auto j = checkLast; j != checkBlock.begin();) { + --j; + const auto format = j.fragment().charFormat(); + if (format.property(kReplaceTagId) != tag) { + return ++j; + } + } + if (checkBlock == document->begin()) { + return checkBlock.begin(); + } + checkBlock = checkBlock.previous(); + checkLast = checkBlock.end(); + } + }(); + const auto from = first.fragment().position(); + const auto till = fragmentEnd; + auto replaceCursor = cursor; + replaceCursor.setPosition(from); + replaceCursor.setPosition(till, QTextCursor::KeepAnchor); + replaceCursor.insertText( + tag + getTextWithTagsPart(from, till).text + tag, + _defaultCharFormat); + return true; } - const auto string = with.toString(); - if (fragment.text() != string) { - return false; - } - auto replaceCursor = cursor; - replaceCursor.setPosition(fragmentStart); - replaceCursor.setPosition(fragmentEnd, QTextCursor::KeepAnchor); - const auto what = format.property(kInstantReplaceWhatId).toString(); - auto replaceFormat = _defaultCharFormat; - if (format.isAnchor()) { - replaceFormat.setAnchor(true); - replaceFormat.setAnchorName(format.anchorName()); - replaceFormat.setForeground(st::defaultTextPalette.linkFg); - } - replaceCursor.insertText(what, replaceFormat); - return true; + return false; } return false; } diff --git a/Telegram/SourceFiles/ui/widgets/input_fields.h b/Telegram/SourceFiles/ui/widgets/input_fields.h index e5e06bd24..43336cc7e 100644 --- a/Telegram/SourceFiles/ui/widgets/input_fields.h +++ b/Telegram/SourceFiles/ui/widgets/input_fields.h @@ -122,6 +122,16 @@ public: }; using TagList = TextWithTags::Tags; + struct PossibleTag { + int start = 0; + int length = 0; + QString tag; + }; + static const QString kTagBold; + static const QString kTagItalic; + static const QString kTagCode; + static const QString kTagPre; + InputField( QWidget *parent, const style::InputField &st, @@ -174,6 +184,8 @@ public: }; void setTagMimeProcessor(std::unique_ptr &&processor); + void setAdditionalMargin(int margin); + void setInstantReplaces(const InstantReplaces &replaces); void enableInstantReplaces(bool enabled); void commitInstantReplacement( @@ -181,6 +193,11 @@ public: int till, const QString &with, base::optional checkOriginal = base::none); + bool commitMarkdownReplacement( + int from, + int till, + const QString &tag, + const QString &edge = QString()); const QString &getLastText() const { return _lastTextWithTags.text; @@ -212,6 +229,7 @@ public: Both, }; void setSubmitSettings(SubmitSettings settings); + void enableMarkdownSupport(bool enabled = true); void customUpDown(bool isCustom); not_null document(); @@ -246,7 +264,6 @@ private slots: void onTouchTimer(); void onDocumentContentsChange(int position, int charsRemoved, int charsAdded); - void onDocumentContentsChanged(); void onUndoAvailable(bool avail); void onRedoAvailable(bool avail); @@ -276,6 +293,7 @@ private: class Inner; friend class Inner; + void handleContentsChanged(); bool viewportEventInner(QEvent *e); QVariant loadResource(int type, const QUrl &name); void handleTouchEvent(QTouchEvent *e); @@ -305,7 +323,8 @@ private: int start, int end, TagList &outTagsList, - bool &outTagsChanged) const; + bool &outTagsChanged, + std::vector *outPossibleTags = nullptr) const; // After any characters added we must postprocess them. This includes: // 1. Replacing font family to semibold for ~ characters, if we used Open Sans 13px. @@ -318,12 +337,16 @@ private: void chopByMaxLength(int insertPosition, int insertLength); + bool processMarkdownReplaces(const QString &appended); + bool processMarkdownReplace(const QString &tag); + // We don't want accidentally detach InstantReplaces map. // So we access it only by const reference from this method. const InstantReplaces &instantReplaces() const; - void processInstantReplaces(const QString &text); + void processInstantReplaces(const QString &appended); void applyInstantReplace(const QString &what, const QString &with); - bool revertInstantReplace(); + + bool revertFormatReplace(); const style::InputField &_st; @@ -336,6 +359,7 @@ private: object_ptr _inner; TextWithTags _lastTextWithTags; + std::vector _textAreaPossibleTags; // Tags list which we should apply while setText() call or insert from mime data. TagList _insertedTags; @@ -349,11 +373,12 @@ private: std::unique_ptr _tagMimeProcessor; SubmitSettings _submitSettings = SubmitSettings::Enter; + bool _markdownEnabled = false; bool _undoAvailable = false; bool _redoAvailable = false; bool _inDrop = false; bool _inHeightCheck = false; - int _fakeMargin = 0; + int _additionalMargin = 0; bool _customUpDown = false;