+ * Copyright (c) 2010-2017 Isode Limited.

+#include <Swift/Controllers/Highlighting/Highlighter.h>

+ : ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, nickResolver, presenceOracle, avatarManager, useDelayForLatency, eventStream, eventController, timerFactory, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider), userWantsReceipts_(userWantsReceipts), settings_(settings), clientBlockListManager_(clientBlockListManager) {

+ highlighter_->handleSystemNotifications(chatMessage, messageEvent);

+ highlighter_->handleSoundNotifications(chatMessage);

+ * Copyright (c) 2010-2017 Isode Limited.

+#include <Swift/Controllers/Highlighting/HighlightManager.h>

+#include <Swift/Controllers/Highlighting/Highlighter.h>

+ChatControllerBase::ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), timerFactory_(timerFactory), entityCapsProvider_(entityCapsProvider), historyController_(historyController), mucRegistry_(mucRegistry), chatMessageParser_(chatMessageParser), autoAcceptMUCInviteDecider_(autoAcceptMUCInviteDecider), eventStream_(eventStream) {

+ highlighter_ = highlightManager->createHighlighter(nickResolver);

+ChatWindow::ChatMessage ChatControllerBase::buildChatWindowChatMessage(const std::string& message, const std::string& senderName, bool senderIsSelf) {

+ chatMessage = chatMessageParser_->parseMessageBody(message, senderName, senderIsSelf);

+ chatMessage = buildChatWindowChatMessage(body, senderHighlightNameFromMessage(from), senderIsSelf);

+ chatMessage = buildChatWindowChatMessage(body, senderHighlightNameFromMessage(from), senderIsSelf);

+ * Copyright (c) 2010-2017 Isode Limited.

+#include <Swift/Controllers/Highlighting/HighlightManager.h>

+ class AutoAcceptMUCInviteDecider;

+ class ChatMessageParser;

+ class ChatWindowFactory;

+ class EventController;

+ class IQRouter;

+ class NickResolver;

+ class StanzaChannel;

+ class UIEventStream;

+ ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider);

+ ChatWindow::ChatMessage buildChatWindowChatMessage(const std::string& message, const std::string& senderName, bool senderIsSelf);

+ * Copyright (c) 2013-2017 Isode Limited.

+#include <algorithm>

+#include <boost/regex.hpp>

+ ChatMessageParser::ChatMessageParser(const std::map<std::string, std::string>& emoticons, std::shared_ptr<HighlightConfiguration> highlightConfiguration, Mode mode) : emoticons_(emoticons), highlightConfiguration_(highlightConfiguration), mode_(mode) {

+ ChatWindow::ChatMessage ChatMessageParser::parseMessageBody(const std::string& body, const std::string& senderNickname, bool senderIsSelf) {

+

+ // Highlight keywords and own mentions.

+ parsedMessage = splitHighlight(parsedMessage);

+

+ // Highlight full message events like, specific sender, general

+ // incoming group message, or general incoming direct message.

+ parsedMessage = fullMessageHighlight(parsedMessage, senderNickname);

+ for (const auto& part : parsedMessage.getParts()) {

+

+ ChatWindow::ChatMessage ChatMessageParser::splitHighlight(const ChatWindow::ChatMessage& message) {

+ auto keywordToRegEx = [](const std::string& keyword, bool matchCaseSensitive) {

+ std::string escaped = Regex::escape(keyword);

+ boost::regex::flag_type flags = boost::regex::normal;

+ if (!matchCaseSensitive) {

+ flags |= boost::regex::icase;

+ return boost::regex("\\b" + escaped + "\\b", flags);

+ };

+

+ auto highlightKeywordInChatMessage = [&](const ChatWindow::ChatMessage& message, const std::string& keyword, bool matchCaseSensitive, const HighlightAction& action) {

+ ChatWindow::ChatMessage resultMessage;

+

+ for (const auto& part : message.getParts()) {

+ std::shared_ptr<ChatWindow::ChatTextMessagePart> textPart;

+ if ((textPart = std::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(part))) {

+ try {

+ boost::match_results<std::string::const_iterator> match;

+ const std::string& text = textPart->text;

+ std::string::const_iterator start = text.begin();

+ while (regex_search(start, text.end(), match, keywordToRegEx(keyword, matchCaseSensitive))) {

+ std::string::const_iterator matchStart = match[0].first;

+ std::string::const_iterator matchEnd = match[0].second;

+ if (start != matchStart) {

+ /* If we're skipping over plain text since the previous emoticon, record it as plain text */

+ resultMessage.append(std::make_shared<ChatWindow::ChatTextMessagePart>(std::string(start, matchStart)));

+ std::shared_ptr<ChatWindow::ChatHighlightingMessagePart> highlightPart = std::make_shared<ChatWindow::ChatHighlightingMessagePart>();

+ highlightPart->text = match.str();

+ highlightPart->action = action;

+ resultMessage.append(highlightPart);

+ start = matchEnd;

+ if (start != text.end()) {

+ /* If there's plain text after the last emoticon, record it */

+ resultMessage.append(std::make_shared<ChatWindow::ChatTextMessagePart>(std::string(start, text.end())));

+ catch (std::runtime_error) {

+ /* Basically too expensive to compute the regex results and it gave up, so pass through as text */

+ resultMessage.append(part);

+ }

+ } else {

+ resultMessage.append(part);

+ return resultMessage;

+ };

+

+ ChatWindow::ChatMessage parsedMessage = message;

+

+ // detect mentions of own nickname

+ HighlightAction ownMentionKeywordAction = highlightConfiguration_->ownMentionAction;

+ ownMentionKeywordAction.setSoundFilePath(boost::optional<std::string>());

+ ownMentionKeywordAction.setSystemNotificationEnabled(false);

+ if (!getNick().empty() && !highlightConfiguration_->ownMentionAction.isEmpty()) {

+ auto nicknameHighlightedMessage = highlightKeywordInChatMessage(parsedMessage, nick_, false, ownMentionKeywordAction);

+ auto highlightedParts = nicknameHighlightedMessage.getParts();

+ auto ownNicknamePart = std::find_if(highlightedParts.begin(), highlightedParts.end(), [&](std::shared_ptr<ChatWindow::ChatMessagePart>& part){

+ auto highlightPart = std::dynamic_pointer_cast<ChatWindow::ChatHighlightingMessagePart>(part);

+ if (highlightPart && highlightPart->text == nick_) {

+ return true;

+ }

+ return false;

+ });

+ if (ownNicknamePart != highlightedParts.end()) {

+ parsedMessage.setHighlightActionOwnMention(highlightConfiguration_->ownMentionAction);

+ }

+ parsedMessage.setParts(nicknameHighlightedMessage.getParts());

+ }

+

+ // detect keywords

+ for (const auto& keywordHighlight : highlightConfiguration_->keywordHighlights) {

+ if (keywordHighlight.keyword.empty() || keywordHighlight.action.isEmpty()) {

+ continue;

+ }

+ auto newMessage = highlightKeywordInChatMessage(parsedMessage, keywordHighlight.keyword, keywordHighlight.matchCaseSensitive, keywordHighlight.action);

+ parsedMessage.setParts(newMessage.getParts());

+

+ ChatWindow::ChatMessage ChatMessageParser::fullMessageHighlight(const ChatWindow::ChatMessage& parsedMessage, const std::string& sender) {

+ auto fullHighlightedMessage = parsedMessage;

+

+ // contact highlighting

+ for (const auto& contactHighlight : highlightConfiguration_->contactHighlights) {

+ if (sender == contactHighlight.name) {

+ fullHighlightedMessage.setHighlightActionSender(contactHighlight.action);

+ break;

+ }

+ }

+

+ // general incoming messages

+ HighlightAction groupAction;

+ HighlightAction chatAction;

+

+ switch (mode_) {

+ case Mode::GroupChat:

+ groupAction.setSoundFilePath(highlightConfiguration_->playSoundOnIncomingGroupchatMessages ? boost::optional<std::string>("") : boost::optional<std::string>());

+ groupAction.setSystemNotificationEnabled(highlightConfiguration_->showNotificationOnIncomingGroupchatMessages);

+ fullHighlightedMessage.setHighlightActionGroupMessage(groupAction);

+ break;

+

+ case Mode::Chat:

+ chatAction.setSoundFilePath(highlightConfiguration_->playSoundOnIncomingDirectMessages ? boost::optional<std::string>("") : boost::optional<std::string>());

+ chatAction.setSystemNotificationEnabled(highlightConfiguration_->showNotificationOnIncomingDirectMessages);

+ fullHighlightedMessage.setHighlightActonDirectMessage(chatAction);

+ break;

+ }

+

+ return fullHighlightedMessage;

+ }

+ * Copyright (c) 2013-2017 Isode Limited.

+#include <memory>

+#include <Swift/Controllers/Highlighting/HighlightConfiguration.h>

+ /**

+ * @brief The ChatMessageParser class takes an emoticon map, a \ref HighlightConfiguration, and a boolean that indicates if the message context is in a MUC or not.

+ * The class handles parsing a message string and identifies emoticons, URLs, and various highlights.

+ */

+ enum class Mode { Chat, GroupChat };

+

+ public:

+ ChatMessageParser(const std::map<std::string, std::string>& emoticons, std::shared_ptr<HighlightConfiguration> highlightConfiguration, Mode mode = Mode::Chat);

+

+ void setNick(const std::string& nick) { nick_ = nick; }

+ std::string getNick() const { return nick_; }

+

+ ChatWindow::ChatMessage parseMessageBody(const std::string& body, const std::string& sender = "", bool senderIsSelf = false);

+

+ ChatWindow::ChatMessage splitHighlight(const ChatWindow::ChatMessage& parsedMessage);

+ ChatWindow::ChatMessage fullMessageHighlight(const ChatWindow::ChatMessage& parsedMessage, const std::string& sender);

+

+ private:

+ std::shared_ptr<HighlightConfiguration> highlightConfiguration_;

+ Mode mode_;

+ std::string nick_;

+ * Copyright (c) 2010-2017 Isode Limited.

+ std::shared_ptr<ChatMessageParser> chatMessageParser = std::make_shared<ChatMessageParser>(emoticons_, highlightManager_->getConfiguration(), ChatMessageParser::Mode::Chat); /* a message parser that knows this is a chat (not a room/MUC) */

+ std::shared_ptr<ChatMessageParser> chatMessageParser = std::make_shared<ChatMessageParser>(emoticons_, highlightManager_->getConfiguration(), ChatMessageParser::Mode::GroupChat); /* a message parser that knows this is a room/MUC (not a chat) */

+ controller = new MUCController(jid_, muc, password, nick, stanzaChannel_, iqRouter_, reuseChatwindow ? chatWindowFactoryAdapter : chatWindowFactory_, nickResolver_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_, roster_, historyController_, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser, isImpromptu, autoAcceptMUCInviteDecider_, vcardManager_, mucBookmarkManager_);

+#include <Swift/Controllers/Highlighting/Highlighter.h>

+ NickResolver* nickResolver,

+ ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), nickResolver, presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, timerFactory, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider), muc_(muc), nick_(nick), desiredNick_(nick), password_(password), renameCounter_(0), isImpromptu_(isImpromptu), isImpromptuAlreadyConfigured_(false), clientBlockListManager_(clientBlockListManager), mucBookmarkManager_(mucBookmarkManager) {

+ chatMessageParser_->setNick(nick_);

+ highlighter_->handleSystemNotifications(chatMessage, messageEvent);

+ highlighter_->handleSoundNotifications(chatMessage);

+ chatMessageParser_->setNick(nick);

+ * Copyright (c) 2010-2017 Isode Limited.

+ MUCController(const JID& self, MUC::ref muc, const boost::optional<std::string>& password, const std::string &nick, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, XMPPRoster* xmppRoster, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, bool isImpromptu, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, VCardManager* vcardManager, MUCBookmarkManager* mucBookmarkManager);

+ * Copyright (c) 2013-2017 Isode Limited.

+#include <gtest/gtest.h>

+#include <Swift/Controllers/Highlighting/HighlightConfiguration.h>

+#include <Swift/Controllers/Highlighting/HighlightManager.h>

+#include <Swift/Controllers/Settings/DummySettingsProvider.h>

+// Common test state

+class ChatMessageParserTest : public ::testing::Test {

+protected:

+ virtual void SetUp() {

+ virtual void TearDown() {

+ static void assertText(const ChatWindow::ChatMessage& result, size_t index, const std::string& text) {

+ ASSERT_LT(index, result.getParts().size());

+ ASSERT_EQ(text, part->text);

+ static void assertEmoticon(const ChatWindow::ChatMessage& result, size_t index, const std::string& text, const std::string& path) {

+ ASSERT_LT(index, result.getParts().size());

+ ASSERT_NE(nullptr, part);

+ ASSERT_EQ(text, part->alternativeText);

+ ASSERT_EQ(path, part->imagePath);

+ static void assertURL(const ChatWindow::ChatMessage& result, size_t index, const std::string& text) {

+ ASSERT_LT(index, result.getParts().size());

+ ASSERT_EQ(text, part->target);

+ void assertHighlight(const ChatWindow::ChatMessage& result, size_t index, const std::string& text, const HighlightAction& action) {

+ ASSERT_LT(index, result.getParts().size());

+ std::shared_ptr<ChatWindow::ChatHighlightingMessagePart> part = std::dynamic_pointer_cast<ChatWindow::ChatHighlightingMessagePart>(result.getParts()[index]);

+ ASSERT_EQ(std::string(text), part->text);

+ ASSERT_EQ(action, part->action);

+ static const std::shared_ptr<HighlightConfiguration> highlightConfigFromKeyword(const std::string& keyword, bool matchCase) {

+ std::shared_ptr<HighlightConfiguration> config = std::make_shared<HighlightConfiguration>();

+ HighlightConfiguration::KeywordHightlight keywordHighlight;

+ keywordHighlight.keyword = keyword;

+ keywordHighlight.matchCaseSensitive = matchCase;

+ keywordHighlight.action.setFrontColor(std::string("#121212"));

+ config->keywordHighlights.push_back(keywordHighlight);

+ return config;

+ static const std::shared_ptr<HighlightConfiguration> mergeHighlightConfig(const std::shared_ptr<HighlightConfiguration>& configA, const std::shared_ptr<HighlightConfiguration>& configB) {

+ std::shared_ptr<HighlightConfiguration> config = std::make_shared<HighlightConfiguration>();

+ config->keywordHighlights.insert(config->keywordHighlights.end(), configA->keywordHighlights.begin(), configA->keywordHighlights.end());

+ config->keywordHighlights.insert(config->keywordHighlights.end(), configB->keywordHighlights.begin(), configB->keywordHighlights.end());

+ return config;

+TEST_F(ChatMessageParserTest, testNoHighlightingWithEmtpyConfiguration) {

+ const std::string no_special_message = "a message with no special content";

+ ChatMessageParser testling(emoticons_, std::make_shared<HighlightConfiguration>());

+ auto result = testling.parseMessageBody(no_special_message);

+ assertText(result, 0, no_special_message);

+}

+

+TEST_F(ChatMessageParserTest, testSimpleHighlightAndEmojiAndUrlParsing) {

+ auto highlightConfig = highlightConfigFromKeyword("trigger", false);

+ auto testling = ChatMessageParser(emoticons_, highlightConfig);

+ auto result = testling.parseMessageBody(":) shiny :( trigger :) http://wonderland.lit/blah http://denmark.lit boom boom");

+ assertEmoticon(result, 0, smile1_, smile1Path_);

+ assertText(result, 1, " shiny ");

+ assertEmoticon(result, 2, smile2_, smile2Path_);

+ assertText(result, 3, " ");

+ assertHighlight(result, 4, "trigger", highlightConfig->keywordHighlights[0].action);

+ assertText(result, 5, " ");

+ assertEmoticon(result, 6, smile1_, smile1Path_);

+ assertText(result, 7, " ");

+ assertURL(result, 8, "http://wonderland.lit/blah");

+ assertText(result, 9, " ");

+ assertURL(result, 10, "http://denmark.lit");

+ assertText(result, 11, " boom boom");

+}

+

+TEST_F(ChatMessageParserTest, testNoKeywordHighlightAsPartOfLongerWords) {

+ auto testling = ChatMessageParser(emoticons_, highlightConfigFromKeyword("trigger", false));

+ auto result = testling.parseMessageBody("testtriggermessage");

+ assertText(result, 0, "testtriggermessage");

+}

+

+TEST_F(ChatMessageParserTest, testCaseInsensitiveKeyordHighlight) {

+ auto config = highlightConfigFromKeyword("trigger", true);

+ auto testling = ChatMessageParser(emoticons_, config);

+ auto result = testling.parseMessageBody("TrIgGeR");

+ assertText(result, 0, "TrIgGeR");

+

+ testling = ChatMessageParser(emoticons_, highlightConfigFromKeyword("trigger", false));

+ result = testling.parseMessageBody("TrIgGeR");

+ assertHighlight(result, 0, "TrIgGeR", config->keywordHighlights[0].action);

+}

+

+TEST_F(ChatMessageParserTest, testMultipleKeywordHighlights) {

+ auto config = mergeHighlightConfig(highlightConfigFromKeyword("one", false), highlightConfigFromKeyword("three", false));

+ auto testling = ChatMessageParser(emoticons_, config);

+ auto result = testling.parseMessageBody("zero one two three");

+ assertText(result, 0, "zero ");

+ assertHighlight(result, 1, "one", config->keywordHighlights[0].action);

+ assertText(result, 2, " two ");

+ assertHighlight(result, 3, "three", config->keywordHighlights[0].action);

+}

+

+TEST_F(ChatMessageParserTest, testMultipleCaseInsensitiveKeywordHighlights) {

+ auto config = mergeHighlightConfig(highlightConfigFromKeyword("one", false), highlightConfigFromKeyword("three", false));

+ auto testling = ChatMessageParser(emoticons_, config);

+ auto result = testling.parseMessageBody("zero oNe two tHrEe");

+ assertText(result, 0, "zero ");

+ assertHighlight(result, 1, "oNe", config->keywordHighlights[0].action);

+ assertText(result, 2, " two ");

+ assertHighlight(result, 3, "tHrEe", config->keywordHighlights[0].action);

+}

+

+TEST_F(ChatMessageParserTest, testMultipleCaseSensitiveKeywordHighlights) {

+ auto config = mergeHighlightConfig(highlightConfigFromKeyword("one", false), highlightConfigFromKeyword("three", true));

+ auto testling = ChatMessageParser(emoticons_, config);

+ auto result = testling.parseMessageBody("zero oNe two tHrEe");

+ assertText(result, 0, "zero ");

+ assertHighlight(result, 1, "oNe", config->keywordHighlights[0].action);

+ assertText(result, 2, " two tHrEe");

+

+ config = mergeHighlightConfig(highlightConfigFromKeyword("one", true), highlightConfigFromKeyword("three", false));

+ testling = ChatMessageParser(emoticons_, config);

+ result = testling.parseMessageBody("zero oNe two tHrEe");

+ assertText(result, 0, "zero oNe two ");

+ assertHighlight(result, 1, "tHrEe", config->keywordHighlights[0].action);

+}

+

+TEST_F(ChatMessageParserTest, testOneEmoticon) {

+ auto testling = ChatMessageParser(emoticons_, std::make_shared<HighlightConfiguration>());

+ auto result = testling.parseMessageBody(" :) ");

+ assertText(result, 0, " ");

+ assertEmoticon(result, 1, smile1_, smile1Path_);

+ assertText(result, 2, " ");

+}

+

+TEST_F(ChatMessageParserTest, testBareEmoticon) {

+ auto testling = ChatMessageParser(emoticons_, std::make_shared<HighlightConfiguration>());

+ auto result = testling.parseMessageBody(":)");

+ assertEmoticon(result, 0, smile1_, smile1Path_);

+}

+

+TEST_F(ChatMessageParserTest, testHiddenEmoticon) {

+ auto testling = ChatMessageParser(emoticons_, std::make_shared<HighlightConfiguration>());

+ auto result = testling.parseMessageBody("b:)a");

+ assertText(result, 0, "b:)a");

+}

+

+TEST_F(ChatMessageParserTest, testEndlineEmoticon) {

+ auto testling = ChatMessageParser(emoticons_, std::make_shared<HighlightConfiguration>());

+ auto result = testling.parseMessageBody("Lazy:)");

+ assertText(result, 0, "Lazy");

+ assertEmoticon(result, 1, smile1_, smile1Path_);

+}

+

+TEST_F(ChatMessageParserTest, testBoundedEmoticons) {

+ auto testling = ChatMessageParser(emoticons_, std::make_shared<HighlightConfiguration>());

+ auto result = testling.parseMessageBody(":)Lazy:(");

+ assertEmoticon(result, 0, smile1_, smile1Path_);

+ assertText(result, 1, "Lazy");

+ assertEmoticon(result, 2, smile2_, smile2Path_);

+}

+

+TEST_F(ChatMessageParserTest, testEmoticonParenthesis) {

+ auto testling = ChatMessageParser(emoticons_, std::make_shared<HighlightConfiguration>());

+ auto result = testling.parseMessageBody("(Like this :))");

+ assertText(result, 0, "(Like this ");

+ assertEmoticon(result, 1, smile1_, smile1Path_);

+ assertText(result, 2, ")");

+}

+

+TEST_F(ChatMessageParserTest, testSenderAndKeywordHighlighting) {

+ auto config = std::make_shared<HighlightConfiguration>();

+ auto contactHighlight = HighlightConfiguration::ContactHighlight();

+ contactHighlight.action.setFrontColor(std::string("#f0f0f0"));

+ contactHighlight.action.setBackColor(std::string("#0f0f0f"));

+ contactHighlight.name = "Romeo";

+ config->contactHighlights.push_back(contactHighlight);

+ auto keywordHighlight = HighlightConfiguration::KeywordHightlight();

+ keywordHighlight.action.setFrontColor(std::string("#abcdef"));

+ keywordHighlight.action.setBackColor(std::string("#fedcba"));

+ keywordHighlight.keyword = "XMPP";

+ config->keywordHighlights.push_back(keywordHighlight);

+ auto testling = ChatMessageParser(emoticons_, config);

+ auto result = testling.parseMessageBody("Heard any news about xmpp recently?", "Romeo");

+ assertText(result, 0, "Heard any news about ");

+ assertHighlight(result, 1, "xmpp", keywordHighlight.action);

+ assertText(result, 2, " recently?");

+ ASSERT_EQ(contactHighlight.action, result.getHighlightActionSender());

+ ASSERT_EQ(HighlightAction(), result.getHighlightActionOwnMention());

+}

+

+TEST_F(ChatMessageParserTest, testKeywordWithEmptyActionIsIgnored) {

+ auto config = std::make_shared<HighlightConfiguration>();

+ auto keywordHighlight = HighlightConfiguration::KeywordHightlight();

+ keywordHighlight.keyword = "XMPP";

+ config->keywordHighlights.push_back(keywordHighlight);

+ auto testling = ChatMessageParser(emoticons_, config);

+ auto result = testling.parseMessageBody("Heard any news about xmpp recently?", "Romeo");

+ assertText(result, 0, "Heard any news about xmpp recently?");

+ ASSERT_EQ(HighlightAction(), result.getHighlightActionOwnMention());

+}

+

+TEST_F(ChatMessageParserTest, testMeMessageAndOwnMention) {

+ auto config = std::make_shared<HighlightConfiguration>();

+ config->ownMentionAction.setFrontColor(std::string("#f0f0f0"));

+ config->ownMentionAction.setBackColor(std::string("#0f0f0f"));

+ config->ownMentionAction.setSoundFilePath(std::string("someSoundFile.wav"));

+ auto ownMentionActionForPart = config->ownMentionAction;

+ ownMentionActionForPart.setSoundFilePath(boost::optional<std::string>());

+ auto testling = ChatMessageParser(emoticons_, config);

+ testling.setNick("Juliet");

+ auto result = testling.parseMessageBody("/me wonders when Juliet is coming?", "Romeo");

+ assertText(result, 0, "wonders when ");

+ assertHighlight(result, 1, "Juliet", ownMentionActionForPart);

+ assertText(result, 2, " is coming?");

+ ASSERT_EQ(true, result.isMeCommand());

+ ASSERT_EQ(config->ownMentionAction, result.getHighlightActionOwnMention());

+}

+

+TEST_F(ChatMessageParserTest, testSoundAndNotificationOnDirectMessage) {

+ auto defaultConfiguration = std::make_shared<HighlightConfiguration>();

+ defaultConfiguration->playSoundOnIncomingDirectMessages = true;

+ defaultConfiguration->showNotificationOnIncomingDirectMessages = true;

+ defaultConfiguration->ownMentionAction.setFrontColor(std::string("black"));

+ defaultConfiguration->ownMentionAction.setBackColor(std::string("yellow"));

+ defaultConfiguration->ownMentionAction.setSoundFilePath(std::string(""));

+ defaultConfiguration->ownMentionAction.setSystemNotificationEnabled(true);

+

+ auto testling = ChatMessageParser(emoticons_, defaultConfiguration, ChatMessageParser::Mode::Chat);

+ auto result = testling.parseMessageBody("I wonder when Juliet is coming?", "Romeo");

+

+ ASSERT_EQ(std::string(""), result.getHighlightActionDirectMessage().getSoundFilePath().get_value_or(std::string("somethingElse")));

+ ASSERT_EQ(true, result.getHighlightActionDirectMessage().isSystemNotificationEnabled());

+ ASSERT_EQ(HighlightAction(), result.getHighlightActionOwnMention());

+}

+

+TEST_F(ChatMessageParserTest, testWithDefaultConfiguration) {

+ DummySettingsProvider settings;

+ HighlightManager manager(&settings);

+ manager.resetToDefaultConfiguration();

+ auto testling = ChatMessageParser(emoticons_, manager.getConfiguration(), ChatMessageParser::Mode::GroupChat);

+ testling.setNick("Juliet");

+ auto result = testling.parseMessageBody("Hello, how is it going?", "Romeo");

+ assertText(result, 0, "Hello, how is it going?");

+ ASSERT_EQ(HighlightAction(), result.getHighlightActionOwnMention());

+ ASSERT_EQ(HighlightAction(), result.getHighlightActionDirectMessage());

+ ASSERT_EQ(HighlightAction(), result.getHighlightActionGroupMessage());

+ ASSERT_EQ(HighlightAction(), result.getHighlightActionSender());

+

+ result = testling.parseMessageBody("Juliet, seen the new interface design?", "Romeo");

+ auto mentionKeywordAction = manager.getConfiguration()->ownMentionAction;

+ mentionKeywordAction.setSoundFilePath(boost::optional<std::string>());

+ mentionKeywordAction.setSystemNotificationEnabled(false);

+ assertHighlight(result, 0, "Juliet", mentionKeywordAction);

+ assertText(result, 1, ", seen the new interface design?");

+ ASSERT_EQ(manager.getConfiguration()->ownMentionAction, result.getHighlightActionOwnMention());

+ ASSERT_EQ(HighlightAction(), result.getHighlightActionDirectMessage());

+ ASSERT_EQ(HighlightAction(), result.getHighlightActionGroupMessage());

+ ASSERT_EQ(HighlightAction(), result.getHighlightActionSender());

+}

+ * Copyright (c) 2010-2017 Isode Limited.

+ highlightManager_->resetToDefaultConfiguration();

+ HighlightConfiguration::KeywordHightlight keywordRuleA;

+ keywordRuleA.keyword = "Romeo";

+ keywordRuleA.action.setFrontColor(boost::optional<std::string>("yellow"));

+ keywordRuleA.action.setSoundFilePath(boost::optional<std::string>(""));

+ highlightManager_->getConfiguration()->keywordHighlights.push_back(keywordRuleA);

+

+ HighlightConfiguration::KeywordHightlight keywordRuleB;

+ keywordRuleB.keyword = "Juliet";

+ keywordRuleB.action.setFrontColor(boost::optional<std::string>("green"));

+ keywordRuleB.action.setSoundFilePath(boost::optional<std::string>("/tmp/someotherfile.wav"));

+ highlightManager_->getConfiguration()->keywordHighlights.push_back(keywordRuleB);

+ CPPUNIT_ASSERT(soundsPlayed_.find(keywordRuleA.action.getSoundFilePath().get_value_or("")) != soundsPlayed_.end());

+ CPPUNIT_ASSERT(soundsPlayed_.find(keywordRuleB.action.getSoundFilePath().get_value_or("")) != soundsPlayed_.end());

+ auto keywordRuleA = HighlightConfiguration::KeywordHightlight();

+ keywordRuleA.keyword = "Romeo";

+ keywordRuleA.action.setFrontColor(boost::optional<std::string>("yellow"));

+ keywordRuleA.action.setSoundFilePath(boost::optional<std::string>(""));

+ highlightManager_->getConfiguration()->keywordHighlights.push_back(keywordRuleA);

+

+ auto keywordRuleB = HighlightConfiguration::KeywordHightlight();

+ keywordRuleB.keyword = "Juliet";

+ keywordRuleB.action.setFrontColor(boost::optional<std::string>("green"));

+ keywordRuleB.action.setSoundFilePath(boost::optional<std::string>(""));

+ highlightManager_->getConfiguration()->keywordHighlights.push_back(keywordRuleB);

+ CPPUNIT_ASSERT(soundsPlayed_.find(keywordRuleA.action.getSoundFilePath().get_value_or("")) != soundsPlayed_.end());

+ CPPUNIT_ASSERT(soundsPlayed_.find(keywordRuleB.action.getSoundFilePath().get_value_or("")) != soundsPlayed_.end());

+ //highlightManager_->resetToDefaultConfiguration();

+

+ HighlightConfiguration::KeywordHightlight keywordHighlight;

+ keywordHighlight.keyword = "foo";

+ keywordHighlight.action.setBackColor(boost::optional<std::string>("green"));

+ highlightManager_->getConfiguration()->keywordHighlights.push_back(keywordHighlight);

+ if (action.getSoundFilePath()) {

+ soundsPlayed_.insert(action.getSoundFilePath().get_value_or(""));

+ * Copyright (c) 2010-2017 Isode Limited.

+ chatMessageParser_ = std::make_shared<ChatMessageParser>(std::map<std::string, std::string>(), highlightManager_->getConfiguration(), ChatMessageParser::Mode::GroupChat);

+ nickResolver_ = new NickResolver(self_, xmppRoster_, vcardManager_, mucRegistry_);

+ controller_ = new MUCController (self_, muc_, boost::optional<std::string>(), nick_, stanzaChannel_, iqRouter_, chatWindowFactory_, nickResolver_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory, eventController_, entityCapsProvider_, nullptr, nullptr, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser_, false, nullptr, vcardManager_, mucBookmarkManager_);

+ delete nickResolver_;

+ NickResolver* nickResolver_;

+ * Copyright (c) 2010-2017 Isode Limited.

+ for (const auto& notification : messageEvent->getNotifications()) {

+ notifier->showMessage(Notifier::IncomingMessage, notification.title, notification.message, avatarManager->getAvatarPath(jid), boost::bind(&EventNotifier::handleNotificationActivated, this, activationJID));

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+/*

+ * Copyright (c) 2015-2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swift/Controllers/Highlighting/HighlightAction.h>

+

+namespace Swift {

+

+

+

+bool operator ==(const HighlightAction& a, const HighlightAction& b) {

+ if (a.getFrontColor() != b.getFrontColor()) {

+ return false;

+ }

+ if (a.getBackColor() != b.getBackColor()) {

+ return false;

+ }

+ if (a.getSoundFilePath() != b.getSoundFilePath()) {

+ return false;

+ }

+ if (a.isSystemNotificationEnabled() != b.isSystemNotificationEnabled()) {

+ return false;

+ }

+ return true;

+}

+

+bool operator !=(const HighlightAction& a, const HighlightAction& b) {

+ return !(a == b);

+}

+

+void HighlightAction::setFrontColor(const boost::optional<std::string>& frontColor) {

+ frontColor_ = frontColor;

+}

+

+boost::optional<std::string> HighlightAction::getFrontColor() const {

+ return frontColor_;

+}

+

+void HighlightAction::setBackColor(const boost::optional<std::string>& backColor) {

+ backColor_ = backColor;

+}

+

+boost::optional<std::string> HighlightAction::getBackColor() const {

+ return backColor_;

+}

+

+void HighlightAction::setSoundFilePath(const boost::optional<std::string>& soundFilePath) {

+ soundFilePath_ = soundFilePath;

+}

+

+boost::optional<std::string> HighlightAction::getSoundFilePath() const {

+ return soundFilePath_;

+}

+

+void HighlightAction::setSystemNotificationEnabled(bool systemNotificationEnabled) {

+ systemNotificaitonEnabled_ = systemNotificationEnabled;

+}

+

+bool HighlightAction::isSystemNotificationEnabled() const {

+ return systemNotificaitonEnabled_;

+}

+

+bool HighlightAction::isEmpty() const {

+ return !frontColor_.is_initialized() && !backColor_.is_initialized() && !soundFilePath_.is_initialized() && !systemNotificaitonEnabled_;

+}

+

+}

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+/*

+ * Copyright (c) 2014-2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <string>

+

+#include <boost/archive/text_iarchive.hpp>

+#include <boost/archive/text_oarchive.hpp>

+#include <boost/optional.hpp>

+#include <boost/serialization/optional.hpp>

+

+namespace Swift {

+ class HighlightAction {

+ public:

+ void setFrontColor(const boost::optional<std::string>& frontColor);

+ boost::optional<std::string> getFrontColor() const;

+

+ void setBackColor(const boost::optional<std::string>& backColor);

+ boost::optional<std::string> getBackColor() const;

+

+ void setSoundFilePath(const boost::optional<std::string>& soundFilePath);

+ boost::optional<std::string> getSoundFilePath() const;

+

+ void setSystemNotificationEnabled(bool systemNotificationEnabled);

+ bool isSystemNotificationEnabled() const;

+

+ // @return returns true if the HighlightAction would result in no

+ // noticable action to the user.

+ bool isEmpty() const;

+

+ private:

+ friend class boost::serialization::access;

+ template<class Archive> void serialize(Archive & ar, const unsigned int version);

+

+ private:

+ // Highlight color.

+ boost::optional<std::string> frontColor_;

+ boost::optional<std::string> backColor_;

+

+ // Audio notification.

+ boost::optional<std::string> soundFilePath_;

+

+ // macOS Notification Center or similar.

+ bool systemNotificaitonEnabled_ = false;

+ };

+

+ bool operator ==(const HighlightAction& a, const HighlightAction& b);

+ bool operator !=(const HighlightAction& a, const HighlightAction& b);

+

+ template<class Archive>

+ void HighlightAction::serialize(Archive& ar, const unsigned int /*version*/) {

+ ar & frontColor_;

+ ar & backColor_;

+ ar & soundFilePath_;

+ ar & systemNotificaitonEnabled_;

+ }

+

+}

+/*

+ * Copyright (c) 2016-2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swift/Controllers/Highlighting/HighlightConfiguration.h>

+

+namespace Swift {

+

+bool operator ==(const HighlightConfiguration& a, const HighlightConfiguration& b) {

+ if (a.keywordHighlights != b.keywordHighlights) {

+ return false;

+ }

+ if (a.contactHighlights != b.contactHighlights) {

+ return false;

+ }

+ if (a.ownMentionAction != b.ownMentionAction) {

+ return false;

+ }

+ if (a.playSoundOnIncomingDirectMessages != b.playSoundOnIncomingDirectMessages) {

+ return false;

+ }

+ if (a.showNotificationOnIncomingDirectMessages != b.showNotificationOnIncomingDirectMessages) {

+ return false;

+ }

+ if (a.playSoundOnIncomingGroupchatMessages != b.playSoundOnIncomingGroupchatMessages) {

+ return false;

+ }

+ if (a.showNotificationOnIncomingGroupchatMessages != b.showNotificationOnIncomingGroupchatMessages) {

+ return false;

+ }

+ return true;

+}

+

+}

+/*

+ * Copyright (c) 2016-2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <string>

+#include <vector>

+

+#include <boost/archive/text_iarchive.hpp>

+#include <boost/archive/text_oarchive.hpp>

+

+#include <Swift/Controllers/Highlighting/HighlightAction.h>

+

+namespace Swift {

+

+class HighlightConfiguration {

+public:

+ class ContactHighlight {

+ public:

+ friend class boost::serialization::access;

+ template<class Archive> void serialize(Archive & ar, const unsigned int version);

+

+ public:

+ std::string name;

+ HighlightAction action;

+ };

+

+ class KeywordHightlight {

+ public:

+ friend class boost::serialization::access;

+ template<class Archive> void serialize(Archive & ar, const unsigned int version);

+

+ public:

+ std::string keyword;

+ bool matchCaseSensitive = false;

+ HighlightAction action;

+ };

+

+ friend class boost::serialization::access;

+ template<class Archive> void serialize(Archive & ar, const unsigned int version);

+

+public:

+ std::vector<KeywordHightlight> keywordHighlights;

+ std::vector<ContactHighlight> contactHighlights;

+ HighlightAction ownMentionAction;

+ bool playSoundOnIncomingDirectMessages = false;

+ bool showNotificationOnIncomingDirectMessages = false;

+ bool playSoundOnIncomingGroupchatMessages = false;

+ bool showNotificationOnIncomingGroupchatMessages = false;

+};

+

+bool operator ==(HighlightConfiguration const& a, HighlightConfiguration const& b);

+

+template<class Archive>

+void HighlightConfiguration::ContactHighlight::serialize(Archive& ar, const unsigned int /*version*/) {

+ ar & name;

+ ar & action;

+}

+

+template<class Archive>

+void HighlightConfiguration::KeywordHightlight::serialize(Archive& ar, const unsigned int /*version*/) {

+ ar & keyword;

+ ar & matchCaseSensitive;

+ ar & action;

+}

+

+template<class Archive>

+void HighlightConfiguration::serialize(Archive& ar, const unsigned int /*version*/) {

+ ar & keywordHighlights;

+ ar & contactHighlights;

+ ar & ownMentionAction;

+ ar & playSoundOnIncomingDirectMessages;

+ ar & showNotificationOnIncomingDirectMessages;

+ ar & playSoundOnIncomingGroupchatMessages;

+ ar & showNotificationOnIncomingGroupchatMessages;

+}

+

+}

+ * Copyright (c) 2014-2017 Isode Limited.

+#include <Swift/Controllers/Highlighting/HighlightEditorController.h>

+ * Copyright (c) 2014-2017 Isode Limited.

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+/*

+ * Copyright (c) 2014-2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swift/Controllers/Highlighting/HighlightManager.h>

+

+#include <cassert>

+#include <sstream>

+

+#include <boost/algorithm/string.hpp>

+#include <boost/archive/text_iarchive.hpp>

+#include <boost/archive/text_oarchive.hpp>

+#include <boost/bind.hpp>

+#include <boost/numeric/conversion/cast.hpp>

+#include <boost/regex.hpp>

+#include <boost/serialization/vector.hpp>

+

+#include <Swiften/Base/Log.h>

+

+#include <Swift/Controllers/Highlighting/HighlightConfiguration.h>

+#include <Swift/Controllers/Highlighting/Highlighter.h>

+#include <Swift/Controllers/SettingConstants.h>

+#include <Swift/Controllers/Settings/SettingsProvider.h>

+

+namespace Swift {

+

+HighlightManager::HighlightManager(SettingsProvider* settings)

+ : settings_(settings)

+ , storingSettings_(false) {

+ highlightConfiguration_ = std::make_shared<HighlightConfiguration>();

+ loadSettings();

+ handleSettingChangedConnection_ = settings_->onSettingChanged.connect(boost::bind(&HighlightManager::handleSettingChanged, this, _1));

+}

+

+void HighlightManager::handleSettingChanged(const std::string& settingPath) {

+ if (!storingSettings_ && SettingConstants::HIGHLIGHT_RULES.getKey() == settingPath) {

+ loadSettings();

+ }

+}

+

+HighlightConfiguration HighlightManager::getDefaultConfig() {

+ HighlightConfiguration defaultConfiguration;

+ defaultConfiguration.playSoundOnIncomingDirectMessages = true;

+ defaultConfiguration.showNotificationOnIncomingDirectMessages = true;

+ defaultConfiguration.ownMentionAction.setFrontColor(std::string("black"));

+ defaultConfiguration.ownMentionAction.setBackColor(std::string("yellow"));

+ defaultConfiguration.ownMentionAction.setSoundFilePath(std::string("/sounds/message-received.wav"));

+ defaultConfiguration.ownMentionAction.setSystemNotificationEnabled(true);

+ return defaultConfiguration;

+}

+

+void HighlightManager::storeSettings() {

+ storingSettings_ = true; // don't reload settings while saving

+ settings_->storeSetting(SettingConstants::HIGHLIGHT_RULES_V2, highlightConfigurationToString(*highlightConfiguration_));

+ storingSettings_ = false;

+}

+

+void HighlightManager::loadSettings() {

+ std::string configString = settings_->getSetting(SettingConstants::HIGHLIGHT_RULES_V2);

+ *highlightConfiguration_ = highlightConfigurationFromString(configString);

+}

+

+Highlighter* HighlightManager::createHighlighter(NickResolver* nickResolver) {

+ return new Highlighter(this, nickResolver);

+}

+

+void HighlightManager::resetToDefaultConfiguration() {

+ *highlightConfiguration_ = getDefaultConfig();

+}

+

+HighlightConfiguration HighlightManager::highlightConfigurationFromString(const std::string& dataString) {

+ std::stringstream stream;

+ stream << dataString;

+

+ HighlightConfiguration configuration;

+ try {

+ boost::archive::text_iarchive archive(stream);

+ archive >> configuration;

+ }

+ catch (boost::archive::archive_exception&) {

+ configuration = getDefaultConfig();

+ SWIFT_LOG(warning) << "Failed to load highlight configuration. Will use default configuration instead." << std::endl;

+ }

+ return configuration;

+}

+

+std::string HighlightManager::highlightConfigurationToString(const HighlightConfiguration& configuration) {

+ std::stringstream stream;

+ boost::archive::text_oarchive archive(stream);

+ archive & configuration;

+ return stream.str();

+}

+

+}

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+/*

+ * Copyright (c) 2014-2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <memory>

+#include <string>

+

+#include <boost/signals2.hpp>

+

+#include <Swift/Controllers/Highlighting/HighlightConfiguration.h>

+

+namespace Swift {

+

+ class NickResolver;

+ class SettingsProvider;

+ class Highlighter;

+

+ class HighlightManager {

+ public:

+ HighlightManager(SettingsProvider* settings);

+

+ Highlighter* createHighlighter(NickResolver* nickResolver);

+

+ std::shared_ptr<HighlightConfiguration> getConfiguration() const {

+ return highlightConfiguration_;

+ }

+

+ void setConfiguration(const HighlightConfiguration& config) {

+ *highlightConfiguration_ = config;

+ storeSettings();

+ }

+

+ void resetToDefaultConfiguration();

+

+ void storeSettings();

+ void loadSettings();

+

+ boost::signals2::signal<void (const HighlightAction&)> onHighlight;

+

+ private:

+ void handleSettingChanged(const std::string& settingPath);

+

+ static HighlightConfiguration getDefaultConfig();

+

+ static HighlightConfiguration highlightConfigurationFromString(const std::string& dataString);

+ static std::string highlightConfigurationToString(const HighlightConfiguration& configuration);

+

+ private:

+ SettingsProvider* settings_;

+ bool storingSettings_;

+ std::shared_ptr<HighlightConfiguration> highlightConfiguration_;

+ boost::signals2::scoped_connection handleSettingChangedConnection_;

+ };

+}

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+/*

+ * Copyright (c) 2014-2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swift/Controllers/Highlighting/Highlighter.h>

+

+#include <set>

+#include <string>

+

+#include <Swiften/Base/String.h>

+#include <Swiften/Base/format.h>

+#include <Swiften/Client/NickResolver.h>

+

+#include <Swift/Controllers/Highlighting/HighlightManager.h>

+#include <Swift/Controllers/Intl.h>

+#include <Swift/Controllers/XMPPEvents/MessageEvent.h>

+

+namespace Swift {

+

+Highlighter::Highlighter(HighlightManager* manager, NickResolver* nickResolver)

+ : manager_(manager), nickResolver_(nickResolver) {

+}

+

+void Highlighter::handleSystemNotifications(const ChatWindow::ChatMessage& message, std::shared_ptr<MessageEvent> event) {

+ if (std::shared_ptr<MessageEvent> messageEvent = std::dynamic_pointer_cast<MessageEvent>(event)) {

+ JID jid = messageEvent->getStanza()->getFrom();

+ std::string nickname = nickResolver_->jidToNick(jid);

+

+ std::string messageText = messageEvent->getStanza()->getBody().get_value_or("");

+ if (boost::starts_with(messageText, "/me ")) {

+ messageText = "*" + String::getSplittedAtFirst(messageText, ' ').second + "*";

+ }

+

+ if (message.getHighlightActionDirectMessage().isSystemNotificationEnabled()) {

+ // title: Romeo says

+ // message: message

+ std::string title = str(format(QT_TRANSLATE_NOOP("", "%1% says")) % nickname);

+ event->addNotification(title, messageText);

+ }

+ if (message.getHighlightActionGroupMessage().isSystemNotificationEnabled()) {

+ // title: Romeo in $roomJID says

+ // message: message

+ std::string roomName = jid.getNode();

+ std::string title = str(format(QT_TRANSLATE_NOOP("", "%1% in %2% says")) % nickname % roomName);

+ event->addNotification(title, messageText);

+ }

+ if (message.getHighlightActionOwnMention().isSystemNotificationEnabled()) {

+ // title: Romeo mentioned you in $roomJID

+ // message: message

+ std::string roomName = jid.getNode();

+ std::string title = str(format(QT_TRANSLATE_NOOP("", "%1% mentioned you in %2%")) % nickname % roomName);

+ event->addNotification(title, messageText);

+ }

+ if (message.getHighlightActionSender().isSystemNotificationEnabled()) {

+ // title: Romeo says

+ // message: message

+ auto title = str(format(QT_TRANSLATE_NOOP("", "%1% says")) % nickname);

+ event->addNotification(title, messageText);

+ }

+ for (auto&& part : message.getParts()) {

+ auto highlightPart = std::dynamic_pointer_cast<ChatWindow::ChatHighlightingMessagePart>(part);

+ if (highlightPart && highlightPart->action.isSystemNotificationEnabled()) {

+ // title: Romeo mentioned '$keyword'

+ // message: message

+ auto title = str(format(QT_TRANSLATE_NOOP("", "%1% mentioned '%2%'")) % nickname % highlightPart->text);

+ event->addNotification(title, messageText);

+ }

+ }

+ }

+}

+

+void Highlighter::handleSoundNotifications(const ChatWindow::ChatMessage& chatMessage) {

+ std::set<std::string> playedSoundPaths;

+ std::vector<HighlightAction> actionsToPlay;

+

+ // collect unique sounds to play

+ auto checkSoundActionAndQueueUnique = [&](const HighlightAction& action) {

+ if (action.getSoundFilePath()) {

+ auto soundFilePath = action.getSoundFilePath().get_value_or("");

+ if (playedSoundPaths.find(soundFilePath) == playedSoundPaths.end()) {

+ playedSoundPaths.insert(soundFilePath);

+ actionsToPlay.push_back(action);

+ }

+ }

+ };

+

+ for (auto&& part : chatMessage.getParts()) {

+ auto highlightMessage = std::dynamic_pointer_cast<ChatWindow::ChatHighlightingMessagePart>(part);

+ if (highlightMessage) {

+ checkSoundActionAndQueueUnique(highlightMessage->action);

+ }

+ }

+

+ checkSoundActionAndQueueUnique(chatMessage.getHighlightActionSender());

+ checkSoundActionAndQueueUnique(chatMessage.getHighlightActionOwnMention());

+ checkSoundActionAndQueueUnique(chatMessage.getHighlightActionDirectMessage());

+ checkSoundActionAndQueueUnique(chatMessage.getHighlightActionGroupMessage());

+

+ // play sounds

+ for (const auto& action : actionsToPlay) {

+ manager_->onHighlight(action);

+ }

+}

+

+}

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+/*

+ * Copyright (c) 2016-2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <string>

+

+#include <Swift/Controllers/Highlighting/HighlightConfiguration.h>

+#include <Swift/Controllers/UIInterfaces/ChatWindow.h>

+#include <Swift/Controllers/XMPPEvents/MessageEvent.h>

+

+namespace Swift {

+

+ class HighlightManager;

+ class NickResolver;

+

+ class Highlighter {

+ public:

+ Highlighter(HighlightManager* manager, NickResolver* nickResolver);

+

+ void handleSystemNotifications(const ChatWindow::ChatMessage& message, std::shared_ptr<MessageEvent> event);

+ void handleSoundNotifications(const ChatWindow::ChatMessage& chatMessage);

+

+ private:

+ HighlightManager* manager_;

+ NickResolver* nickResolver_;

+ };

+

+}

+ * Copyright (c) 2010-2017 Isode Limited.

+#include <Swift/Controllers/Highlighting/HighlightEditorController.h>

+#include <Swift/Controllers/Highlighting/HighlightManager.h>

+ "AdHocController.cpp",

+ "AdHocManager.cpp",

+ "BlockListController.cpp",

+ "Chat/ChatMessageParser.cpp",

+ "ChatMessageSummarizer.cpp",

+ "Contact.cpp",

+ "ContactProvider.cpp",

+ "ContactSuggester.cpp",

+ "ContactsFromXMPPRoster.cpp",

+ "EventNotifier.cpp",

+ "EventWindowController.cpp",

+ "FileTransferListController.cpp",

+ "Highlighting/HighlightAction.cpp",

+ "Highlighting/HighlightEditorController.cpp",

+ "Highlighting/HighlightManager.cpp",

+ "Highlighting/Highlighter.cpp",

+ "HistoryController.cpp",

+ "HistoryViewController.cpp",

+ "MainController.cpp",

+ "PresenceNotifier.cpp",

+ "PreviousStatusStore.cpp",

+ "ProfileController.cpp",

+ "ProfileSettingsProvider.cpp",

+ "Roster/RosterController.cpp",

+ "Roster/RosterGroupExpandinessPersister.cpp",

+ "Roster/RosterItem.cpp",

+ "SettingConstants.cpp",

+ "ShowProfileController.cpp",

+ "SoundEventController.cpp",

+ "StatusCache.cpp",

+ "StatusTracker.cpp",

+ "StatusUtil.cpp",

+ "Storages/AvatarFileStorage.cpp",

+ "Storages/CapsFileStorage.cpp",

+ "Storages/CertificateStorage.cpp",

+ "Storages/CertificateStorageFactory.cpp",

+ "SystemTrayController.cpp",

+ "UIEvents/UIEvent.cpp",

+ "UIInterfaces/ChatListWindow.cpp",

+ "UIInterfaces/HighlightEditorWindow.cpp",

+ "UIInterfaces/XMLConsoleWidget.cpp",

+ "XMLConsoleController.cpp",

+ "XMPPEvents/EventController.cpp",

+ "XMPPURIController.cpp",

+ File("Chat/UnitTest/ChatMessageParserTest.cpp"),

+ File("Roster/UnitTest/LeastCommonSubsequenceTest.cpp"),

+ File("Roster/UnitTest/RosterControllerTest.cpp"),

+ File("Roster/UnitTest/RosterTest.cpp"),

+ File("Roster/UnitTest/TableRosterTest.cpp"),

+ File("UnitTest/ChatMessageSummarizerTest.cpp"),

+ File("UnitTest/ContactSuggesterTest.cpp"),

+ File("UnitTest/MockChatWindow.cpp"),

+ File("UnitTest/PresenceNotifierTest.cpp"),

+ File("UnitTest/PreviousStatusStoreTest.cpp"),

+ * Copyright (c) 2012-2017 Isode Limited.

+const SettingsProvider::Setting<std::string> SettingConstants::HIGHLIGHT_RULES_V2("highlightRulesV2", "@");

+ * Copyright (c) 2012-2017 Isode Limited.

+ * The #HIGHLIGHT_RULES_V2 setting specifies the second version of highlight configuration

+ * rules, incompatible to old highlight rules.

+ *

+ * Its value is a Boost serialized representation.

+ */

+ static const SettingsProvider::Setting<std::string> HIGHLIGHT_RULES_V2;

+ /**

+ * Copyright (c) 2010-2017 Isode Limited.

+#include <Swift/Controllers/Highlighting/HighlightManager.h>

+ if (playSounds_ && action.getSoundFilePath()) {

+ soundPlayer_->playSound(SoundPlayer::MessageReceived, action.getSoundFilePath().get_value_or(""));

+ * Copyright (c) 2010-2017 Isode Limited.

+#include <Swift/Controllers/Highlighting/HighlightAction.h>

+

+

+ private:

+ * Copyright (c) 2010-2017 Isode Limited.

+#include <Swift/Controllers/Highlighting/HighlightManager.h>

+ void setHighlightActionSender(const HighlightAction& action) {

+ highlightActionSender_ = action;

+ const HighlightAction& getHighlightActionSender() const {

+ return highlightActionSender_;

+ }

+

+ void setHighlightActionOwnMention(const HighlightAction& action) {

+ highlightActionOwnMention_ = action;

+ }

+

+ const HighlightAction& getHighlightActionOwnMention() const {

+ return highlightActionOwnMention_;

+ }

+

+ void setHighlightActionGroupMessage(const HighlightAction& action) {

+ highlightActionGroupMessage_ = action;

+ }

+

+ const HighlightAction& getHighlightActionGroupMessage() const {

+ return highlightActionGroupMessage_;

+ }

+

+ void setHighlightActonDirectMessage(const HighlightAction& action) {

+ highlightActionDirectMessage_ = action;

+ }

+

+ const HighlightAction& getHighlightActionDirectMessage() const {

+ return highlightActionDirectMessage_;

+ HighlightAction highlightActionSender_;

+ HighlightAction highlightActionOwnMention_;

+ HighlightAction highlightActionGroupMessage_;

+ HighlightAction highlightActionDirectMessage_;

+ * Copyright (c) 2010-2017 Isode Limited.

+ class SystemNotification {

+ public:

+ SystemNotification(const std::string& title, const std::string& message) : title(title), message(message) {

+ }

+

+ public:

+ std::string title;

+ std::string message;

+ };

+

+ public:

+ void addNotification(const std::string& title, const std::string& message) {

+ systemNotifications_.push_back(SystemNotification(title, message));

+ }

+

+ const std::vector<SystemNotification>& getNotifications() const {

+ return systemNotifications_;

+ }

+

+ std::vector<SystemNotification> systemNotifications_;