+ * 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_;

+/*

+ * Copyright (c) 2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swift/QtUI/QtCheckBoxStyledItemDelegate.h>

+

+#include <array>

+

+#include <QApplication>

+#include <QEvent>

+#include <QPainter>

+

+namespace Swift {

+

+QtCheckBoxStyledItemDelegate::QtCheckBoxStyledItemDelegate(QObject* parent) : QStyledItemDelegate(parent) {

+

+}

+

+void QtCheckBoxStyledItemDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const {

+ QStyleOptionButton cbOpt;

+ cbOpt.rect = option.rect;

+ cbOpt.state = QStyle::State_Active;

+

+ auto copyFlags = std::array<QStyle::StateFlag, 2>({{QStyle::State_Enabled/*, QStyle::State_Sunken*/}});

+ for (auto flag : copyFlags) {

+ if (option.state && flag) {

+ cbOpt.state |= flag;

+ }

+ }

+

+ bool isChecked = index.data(DATA_ROLE).toBool();

+ if (isChecked) {

+ cbOpt.state |= QStyle::State_On;

+ }

+ else {

+ cbOpt.state |= QStyle::State_Off;

+ }

+ painter->fillRect(option.rect, option.state & QStyle::State_Selected ? option.palette.highlight() : option.palette.base());

+ QApplication::style()->drawControl(QStyle::CE_CheckBox, &cbOpt, painter);

+}

+

+bool QtCheckBoxStyledItemDelegate::editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& /*option*/, const QModelIndex& index) {

+ if (event->type() == QEvent::MouseButtonRelease) {

+ model->setData(index, !index.data(DATA_ROLE).toBool(), DATA_ROLE);

+ }

+ return true;

+}

+

+};

+/*

+ * Copyright (c) 2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <QStyledItemDelegate>

+

+namespace Swift {

+

+class QtCheckBoxStyledItemDelegate : public QStyledItemDelegate {

+ public:

+ QtCheckBoxStyledItemDelegate(QObject* parent = nullptr);

+

+ virtual void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex&) const;

+

+ public:

+ static const int DATA_ROLE = Qt::UserRole + 1;

+

+ protected:

+ virtual bool editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option, const QModelIndex& index);

+};

+

+}

+/*

+ * Copyright (c) 2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swift/QtUI/QtColorSelectionStyledItemDelegate.h>

+

+#include <QApplication>

+#include <QColorDialog>

+#include <QEvent>

+#include <QPainter>

+#include <QStyleOptionComboBox>

+

+namespace Swift {

+

+QtColorSelectionStyledItemDelegate::QtColorSelectionStyledItemDelegate(QObject* parent) : QStyledItemDelegate(parent) {

+

+}

+

+void QtColorSelectionStyledItemDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const {

+ // draw item selected background

+ painter->fillRect(option.rect, option.state & QStyle::State_Selected ? option.palette.highlight() : option.palette.base());

+

+ // draw combo box

+ QStyleOptionComboBox opt;

+ opt.rect = option.rect;

+ opt.state = QStyle::State_Active | QStyle::State_Enabled;

+ QApplication::style()->drawComplexControl(QStyle::CC_ComboBox, &opt, painter);

+

+ // draw currently selected color

+ auto contentRect = QApplication::style()->subControlRect(QStyle::CC_ComboBox, &opt, QStyle::SC_ComboBoxEditField);

+ auto currentColor = index.data(DATA_ROLE).value<QColor>();

+ painter->save();

+ painter->setClipRect(contentRect);

+ painter->fillRect(contentRect.adjusted(1, -4, -1, -3), currentColor);

+ painter->restore();

+}

+

+bool QtColorSelectionStyledItemDelegate::editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& /*option*/, const QModelIndex& index) {

+ if (event->type() == QEvent::MouseButtonRelease) {

+ auto currentColor = index.data(DATA_ROLE).value<QColor>();

+ auto newColor = QColorDialog::getColor(currentColor);

+ if (newColor.isValid()) {

+ model->setData(index, newColor, DATA_ROLE);

+ }

+

+ auto correspondingDialog = qobject_cast<QDialog*>(parent());

+ if (correspondingDialog) {

+ correspondingDialog->raise();

+ }

+ }

+ return true;

+}

+

+};

+/*

+ * Copyright (c) 2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <QStyledItemDelegate>

+

+namespace Swift {

+

+class QtColorSelectionStyledItemDelegate : public QStyledItemDelegate {

+ public:

+ QtColorSelectionStyledItemDelegate(QObject* parent = nullptr);

+

+ virtual void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex&) const;

+

+ public:

+ static const int DATA_ROLE = Qt::UserRole + 1;

+

+ protected:

+ virtual bool editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option, const QModelIndex& index);

+};

+

+}

+/*

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

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#include <Swift/QtUI/QtHighlightNotificationConfigDialog.h>

+

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

+

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

+

+#include <Swift/QtUI/QtCheckBoxStyledItemDelegate.h>

+#include <Swift/QtUI/QtColorSelectionStyledItemDelegate.h>

+#include <Swift/QtUI/QtSoundSelectionStyledItemDelegate.h>

+#include <Swift/QtUI/QtSwiftUtil.h>

+

+namespace Swift {

+

+QtHighlightNotificationConfigDialog::QtHighlightNotificationConfigDialog(QtSettingsProvider* settings, QWidget* parent) : QDialog(parent), settings_(settings) {

+ ui_.setupUi(this);

+

+ // setup custom delegates for checkboxes, color selection, and sound selection

+ ui_.userHighlightTreeWidget->setItemDelegateForColumn(1, new QtColorSelectionStyledItemDelegate(this));

+ ui_.userHighlightTreeWidget->setItemDelegateForColumn(2, new QtColorSelectionStyledItemDelegate(this));

+ ui_.userHighlightTreeWidget->setItemDelegateForColumn(3, new QtSoundSelectionStyledItemDelegate(this));

+ ui_.userHighlightTreeWidget->setItemDelegateForColumn(4, new QtCheckBoxStyledItemDelegate(this));

+

+ ui_.keywordHighlightTreeWidget->setItemDelegateForColumn(1, new QtCheckBoxStyledItemDelegate(this));

+ ui_.keywordHighlightTreeWidget->setItemDelegateForColumn(2, new QtColorSelectionStyledItemDelegate(this));

+ ui_.keywordHighlightTreeWidget->setItemDelegateForColumn(3, new QtColorSelectionStyledItemDelegate(this));

+ ui_.keywordHighlightTreeWidget->setItemDelegateForColumn(4, new QtSoundSelectionStyledItemDelegate(this));

+ ui_.keywordHighlightTreeWidget->setItemDelegateForColumn(5, new QtCheckBoxStyledItemDelegate(this));

+

+ // user highlight edit slots

+ connect(ui_.addUserHighlightPushButton, &QPushButton::clicked, [&](bool) {

+ auto item = new QTreeWidgetItem();

+ item->setFlags(Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled);

+ item->setData(0, Qt::EditRole, "");

+ item->setData(1, QtColorSelectionStyledItemDelegate::DATA_ROLE, QColor("#000000"));

+ item->setData(2, QtColorSelectionStyledItemDelegate::DATA_ROLE, QColor("#ffff00"));

+ item->setData(3, Qt::EditRole, "");

+ item->setData(4, QtCheckBoxStyledItemDelegate::DATA_ROLE, QVariant(true));

+ ui_.userHighlightTreeWidget->addTopLevelItem(item);

+ });

+ connect(ui_.removeUserHighlightPushButton, &QPushButton::clicked, [&](bool) {

+ auto currentItem = ui_.userHighlightTreeWidget->currentItem();

+ if (currentItem) {

+ ui_.userHighlightTreeWidget->takeTopLevelItem(ui_.userHighlightTreeWidget->indexOfTopLevelItem(currentItem));

+ }

+ });

+ connect(ui_.userHighlightTreeWidget, &QTreeWidget::currentItemChanged, [&](QTreeWidgetItem* current, QTreeWidgetItem* ) {

+ ui_.removeUserHighlightPushButton->setEnabled(current != 0);

+ });

+

+ // keyword highlight edit slots

+ connect(ui_.addKeywordHighlightPushButton, &QPushButton::clicked, [&](bool) {

+ auto item = new QTreeWidgetItem();

+ item->setFlags(Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled);

+ item->setData(0, Qt::EditRole, "");

+ item->setData(1, QtCheckBoxStyledItemDelegate::DATA_ROLE, QVariant(false));

+ item->setData(2, QtColorSelectionStyledItemDelegate::DATA_ROLE, QColor("#000000"));

+ item->setData(3, QtColorSelectionStyledItemDelegate::DATA_ROLE, QColor("#ffff00"));

+ item->setData(4, Qt::EditRole, "");

+ item->setData(5, QtCheckBoxStyledItemDelegate::DATA_ROLE, QVariant(true));

+ ui_.keywordHighlightTreeWidget->addTopLevelItem(item);

+ });

+ connect(ui_.removeKeywordHighlightPushButton, &QPushButton::clicked, [&](bool) {

+ auto currentItem = ui_.keywordHighlightTreeWidget->currentItem();

+ if (currentItem) {

+ ui_.keywordHighlightTreeWidget->takeTopLevelItem(ui_.keywordHighlightTreeWidget->indexOfTopLevelItem(currentItem));

+ }

+ });

+ connect(ui_.keywordHighlightTreeWidget, &QTreeWidget::currentItemChanged, [&](QTreeWidgetItem* current, QTreeWidgetItem* ) {

+ ui_.removeKeywordHighlightPushButton->setEnabled(current != 0);

+ });

+

+ // setup slots for main dialog buttons

+ connect(ui_.buttonBox, &QDialogButtonBox::clicked, [&](QAbstractButton* clickedButton) {

+ if (clickedButton == ui_.buttonBox->button(QDialogButtonBox::RestoreDefaults)) {

+ if (highlightManager_) {

+ highlightManager_->resetToDefaultConfiguration();

+ setHighlightConfigurationToDialog(*highlightManager_->getConfiguration());

+ }

+ }

+ });

+ connect(this, &QDialog::accepted, [&]() {

+ if (highlightManager_) {

+ highlightManager_->setConfiguration(getHighlightConfigurationFromDialog());

+ }

+ });

+}

+

+QtHighlightNotificationConfigDialog::~QtHighlightNotificationConfigDialog() {

+}

+

+void QtHighlightNotificationConfigDialog::show() {

+ if (highlightManager_) {

+ setHighlightConfigurationToDialog(*(highlightManager_->getConfiguration()));

+ }

+ QWidget::show();

+ QWidget::activateWindow();

+}

+

+void QtHighlightNotificationConfigDialog::setHighlightManager(HighlightManager* highlightManager) {

+ highlightManager_ = highlightManager;

+}

+

+void QtHighlightNotificationConfigDialog::setContactSuggestions(const std::vector<Contact::ref>& /*suggestions*/) {

+

+}

+

+HighlightConfiguration QtHighlightNotificationConfigDialog::getHighlightConfigurationFromDialog() const {

+ auto qtColorToOptionalString = [&](const QColor& color) {

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

+ if (color.isValid()) {

+ colorString = Q2PSTRING(color.name(QColor::HexRgb));

+ }

+ return colorString;

+ };

+

+ auto getHighlightActionFromWidgetItem = [&](const QTreeWidgetItem* item, int startingColumn) {

+ HighlightAction action;

+

+ action.setFrontColor(qtColorToOptionalString(item->data(startingColumn, QtColorSelectionStyledItemDelegate::DATA_ROLE).value<QColor>()));

+ action.setBackColor(qtColorToOptionalString(item->data(startingColumn + 1, QtColorSelectionStyledItemDelegate::DATA_ROLE).value<QColor>()));

+

+ std::string soundFilePath = Q2PSTRING(item->data(startingColumn + 2, Qt::EditRole).toString());

+ if (soundFilePath == "defaultSound") {

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

+ }

+ else if (soundFilePath.empty()) {

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

+ }

+ else {

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

+ }

+

+ action.setSystemNotificationEnabled(item->data(startingColumn + 3, QtCheckBoxStyledItemDelegate::DATA_ROLE).toBool());

+ return action;

+ };

+

+ HighlightConfiguration uiConfiguration;

+

+ // contact highlights

+ for (int i = 0; i < ui_.userHighlightTreeWidget->topLevelItemCount(); i++) {

+ auto item = ui_.userHighlightTreeWidget->topLevelItem(i);

+ HighlightConfiguration::ContactHighlight contactHighlight;

+ contactHighlight.name = Q2PSTRING(item->data(0, Qt::EditRole).toString());

+ contactHighlight.action = getHighlightActionFromWidgetItem(item, 1);

+ uiConfiguration.contactHighlights.push_back(contactHighlight);

+ }

+

+ // keyword highlights

+ for (int i = 0; i < ui_.keywordHighlightTreeWidget->topLevelItemCount(); i++) {

+ auto item = ui_.keywordHighlightTreeWidget->topLevelItem(i);

+ HighlightConfiguration::KeywordHightlight keywordHighlight;

+ keywordHighlight.keyword = Q2PSTRING(item->data(0, Qt::EditRole).toString());

+ keywordHighlight.matchCaseSensitive = item->data(1, QtCheckBoxStyledItemDelegate::DATA_ROLE).toBool();

+ keywordHighlight.action = getHighlightActionFromWidgetItem(item, 2);

+ uiConfiguration.keywordHighlights.push_back(keywordHighlight);

+ }

+

+ // general configuration

+ uiConfiguration.playSoundOnIncomingDirectMessages = ui_.playSoundOnDirectMessagesCheckBox->isChecked();

+ uiConfiguration.showNotificationOnIncomingDirectMessages = ui_.notificationOnDirectMessagesCheckBox->isChecked();

+ uiConfiguration.playSoundOnIncomingGroupchatMessages = ui_.playSoundOnGroupMessagesCheckBox->isChecked();

+ uiConfiguration.showNotificationOnIncomingGroupchatMessages = ui_.notificationOnGroupMessagesCheckBox->isChecked();

+

+ uiConfiguration.ownMentionAction.setFrontColor(qtColorToOptionalString(ui_.mentionTextColorColorButton->getColor()));

+ uiConfiguration.ownMentionAction.setBackColor(qtColorToOptionalString(ui_.mentionBackgroundColorButton->getColor()));

+ uiConfiguration.ownMentionAction.setSoundFilePath(ui_.playSoundOnMentionCheckBox->isChecked() ? boost::optional<std::string>("") : boost::optional<std::string>());

+ uiConfiguration.ownMentionAction.setSystemNotificationEnabled(ui_.notificationOnMentionCheckBox->isChecked());

+ return uiConfiguration;

+}

+

+void QtHighlightNotificationConfigDialog::setHighlightConfigurationToDialog(const HighlightConfiguration& config) {

+ auto optionalStringToQtColor = [](const boost::optional<std::string>& colorString) {

+ QColor qtColor;

+ if (colorString) {

+ qtColor = QColor(P2QSTRING(colorString.get_value_or(std::string(""))));

+ }

+ return qtColor;

+ };

+

+ auto optionalSoundPathStringToQString = [](const boost::optional<std::string>& soundPath) {

+ QString ret;

+ if (soundPath) {

+ if (soundPath.get_value_or("").empty()) {

+ ret = "defaultSound";

+ }

+ else {

+ ret = P2QSTRING(soundPath.get_value_or(""));

+ }

+ }

+ return ret;

+ };

+

+ auto setHighlightActionOnTreeWidgetItem = [&](QTreeWidgetItem* item, int startingColumn, const HighlightAction& action) {

+ item->setData(startingColumn, QtColorSelectionStyledItemDelegate::DATA_ROLE, optionalStringToQtColor(action.getFrontColor()));

+ item->setData(startingColumn + 1, QtColorSelectionStyledItemDelegate::DATA_ROLE, optionalStringToQtColor(action.getBackColor()));

+ item->setData(startingColumn + 2, Qt::DisplayRole, P2QSTRING(action.getSoundFilePath().get_value_or(std::string(""))));

+ item->setData(startingColumn + 2, Qt::EditRole, optionalSoundPathStringToQString(action.getSoundFilePath()));

+ item->setData(startingColumn + 3, QtCheckBoxStyledItemDelegate::DATA_ROLE, action.isSystemNotificationEnabled());

+ };

+

+ // contact highlights

+ ui_.userHighlightTreeWidget->clear();

+ for (const auto& contactHighlight : config.contactHighlights) {

+ auto item = new QTreeWidgetItem();

+ item->setFlags(Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled);

+ item->setData(0, Qt::DisplayRole, P2QSTRING(contactHighlight.name));

+ item->setData(0, Qt::EditRole, P2QSTRING(contactHighlight.name));

+

+ setHighlightActionOnTreeWidgetItem(item, 1, contactHighlight.action);

+

+ ui_.userHighlightTreeWidget->addTopLevelItem(item);

+ }

+

+ // keyword highlights

+ ui_.keywordHighlightTreeWidget->clear();

+ for (const auto& keywordHighlight : config.keywordHighlights) {

+ auto item = new QTreeWidgetItem();

+ item->setFlags(Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled);

+ item->setData(0, Qt::DisplayRole, P2QSTRING(keywordHighlight.keyword));

+ item->setData(0, Qt::EditRole, P2QSTRING(keywordHighlight.keyword));

+ item->setData(1, QtCheckBoxStyledItemDelegate::DATA_ROLE, keywordHighlight.matchCaseSensitive);

+

+ setHighlightActionOnTreeWidgetItem(item, 2, keywordHighlight.action);

+

+ ui_.keywordHighlightTreeWidget->addTopLevelItem(item);

+ }

+

+ // general configuration

+ ui_.playSoundOnDirectMessagesCheckBox->setChecked(config.playSoundOnIncomingDirectMessages);

+ ui_.notificationOnDirectMessagesCheckBox->setChecked(config.showNotificationOnIncomingDirectMessages);

+ ui_.playSoundOnGroupMessagesCheckBox->setChecked(config.playSoundOnIncomingGroupchatMessages);

+ ui_.notificationOnGroupMessagesCheckBox->setChecked(config.showNotificationOnIncomingGroupchatMessages);

+

+ ui_.mentionTextColorColorButton->setColor(optionalStringToQtColor(config.ownMentionAction.getFrontColor()));

+ ui_.mentionBackgroundColorButton->setColor(optionalStringToQtColor(config.ownMentionAction.getBackColor()));

+ ui_.playSoundOnMentionCheckBox->setChecked(config.ownMentionAction.getSoundFilePath().is_initialized());

+ ui_.notificationOnMentionCheckBox->setChecked(config.ownMentionAction.isSystemNotificationEnabled());

+}

+

+}

+/*

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

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

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

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

+

+#include <Swift/QtUI/ui_QtHighlightNotificationConfigDialog.h>

+

+namespace Swift {

+

+ class QtSettingsProvider;

+ class QtSuggestingJIDInput;

+

+ class QtHighlightNotificationConfigDialog : public QDialog, public HighlightEditorWindow {

+ Q_OBJECT

+

+ public:

+ QtHighlightNotificationConfigDialog(QtSettingsProvider* settings, QWidget* parent = nullptr);

+ virtual ~QtHighlightNotificationConfigDialog();

+

+ virtual void show();

+ virtual void setHighlightManager(HighlightManager* highlightManager);

+ virtual void setContactSuggestions(const std::vector<Contact::ref>& suggestions);

+

+ private:

+ HighlightConfiguration getHighlightConfigurationFromDialog() const;

+ void setHighlightConfigurationToDialog(const HighlightConfiguration& config);

+

+ private:

+ Ui::QtHighlightNotificationConfigDialog ui_;

+ QtSettingsProvider* settings_;

+ HighlightManager* highlightManager_ = nullptr;

+ QtSuggestingJIDInput* jid_ = nullptr;

+ };

+

+}

+<?xml version="1.0" encoding="UTF-8"?>

+<ui version="4.0">

+ <class>QtHighlightNotificationConfigDialog</class>

+ <widget class="QDialog" name="QtHighlightNotificationConfigDialog">

+ <property name="geometry">

+ <rect>

+ <x>0</x>

+ <y>0</y>

+ <width>629</width>

+ <height>515</height>

+ </rect>

+ </property>

+ <property name="windowTitle">

+ <string>Highlight and Notification Configuration</string>

+ </property>

+ <property name="sizeGripEnabled">

+ <bool>false</bool>

+ </property>

+ <property name="modal">

+ <bool>false</bool>

+ </property>

+ <layout class="QVBoxLayout" name="verticalLayout">

+ <item>

+ <widget class="QGroupBox" name="groupBox">

+ <property name="title">

+ <string>Highlight messages from these people</string>

+ </property>

+ <property name="flat">

+ <bool>true</bool>

+ </property>

+ <layout class="QVBoxLayout" name="verticalLayout_3">

+ <property name="spacing">

+ <number>6</number>

+ </property>

+ <property name="leftMargin">

+ <number>0</number>

+ </property>

+ <item>

+ <widget class="QTreeWidget" name="userHighlightTreeWidget">

+ <property name="tabKeyNavigation">

+ <bool>true</bool>

+ </property>

+ <property name="showDropIndicator" stdset="0">

+ <bool>false</bool>

+ </property>

+ <property name="dragEnabled">

+ <bool>true</bool>

+ </property>

+ <property name="dragDropMode">

+ <enum>QAbstractItemView::InternalMove</enum>

+ </property>

+ <property name="defaultDropAction">

+ <enum>Qt::MoveAction</enum>

+ </property>

+ <property name="indentation">

+ <number>0</number>

+ </property>

+ <property name="uniformRowHeights">

+ <bool>true</bool>

+ </property>

+ <property name="itemsExpandable">

+ <bool>false</bool>

+ </property>

+ <property name="animated">

+ <bool>true</bool>

+ </property>

+ <property name="headerHidden">

+ <bool>false</bool>

+ </property>

+ <property name="expandsOnDoubleClick">

+ <bool>false</bool>

+ </property>

+ <attribute name="headerCascadingSectionResizes">

+ <bool>false</bool>

+ </attribute>

+ <attribute name="headerDefaultSectionSize">

+ <number>80</number>

+ </attribute>

+ <attribute name="headerHighlightSections">

+ <bool>false</bool>

+ </attribute>

+ <attribute name="headerMinimumSectionSize">

+ <number>15</number>

+ </attribute>

+ <column>

+ <property name="text">

+ <string>User</string>

+ </property>

+ </column>

+ <column>

+ <property name="text">

+ <string>Text color</string>

+ </property>

+ </column>

+ <column>

+ <property name="text">

+ <string>Background color</string>

+ </property>

+ </column>

+ <column>

+ <property name="text">

+ <string>Play sound</string>

+ </property>

+ </column>

+ <column>

+ <property name="text">

+ <string>Create notification</string>

+ </property>

+ </column>

+ </widget>

+ </item>

+ <item>

+ <layout class="QHBoxLayout" name="horizontalLayout">

+ <property name="spacing">

+ <number>12</number>

+ </property>

+ <property name="topMargin">

+ <number>0</number>

+ </property>

+ <item>

+ <widget class="QPushButton" name="addUserHighlightPushButton">

+ <property name="sizePolicy">

+ <sizepolicy hsizetype="Minimum" vsizetype="Minimum">

+ <horstretch>0</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ <property name="maximumSize">

+ <size>

+ <width>26</width>

+ <height>26</height>

+ </size>

+ </property>

+ <property name="sizeIncrement">

+ <size>

+ <width>1</width>

+ <height>1</height>

+ </size>

+ </property>

+ <property name="baseSize">

+ <size>

+ <width>0</width>

+ <height>0</height>

+ </size>

+ </property>

+ <property name="font">

+ <font>

+ <pointsize>13</pointsize>

+ <weight>50</weight>

+ <italic>false</italic>

+ <bold>false</bold>

+ <underline>false</underline>

+ <strikeout>false</strikeout>

+ <kerning>true</kerning>

+ </font>

+ </property>

+ <property name="text">

+ <string>+</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QPushButton" name="removeUserHighlightPushButton">

+ <property name="enabled">

+ <bool>false</bool>

+ </property>

+ <property name="maximumSize">

+ <size>

+ <width>26</width>

+ <height>26</height>

+ </size>

+ </property>

+ <property name="text">

+ <string>-</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <spacer name="horizontalSpacer_3">

+ <property name="orientation">

+ <enum>Qt::Horizontal</enum>

+ </property>

+ <property name="sizeHint" stdset="0">

+ <size>

+ <width>40</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ </layout>

+ </item>

+ </layout>

+ </widget>

+ </item>

+ <item>

+ <widget class="QGroupBox" name="groupBox_2">

+ <property name="title">

+ <string>Highlight messages containing these keywords</string>

+ </property>

+ <property name="flat">

+ <bool>true</bool>

+ </property>

+ <layout class="QVBoxLayout" name="verticalLayout_2">

+ <property name="spacing">

+ <number>6</number>

+ </property>

+ <property name="leftMargin">

+ <number>0</number>

+ </property>

+ <item>

+ <widget class="QTreeWidget" name="keywordHighlightTreeWidget">

+ <property name="maximumSize">

+ <size>

+ <width>16777215</width>