+ChatController::ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, SettingsProvider* settings, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, boost::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider)

+ replaceMessage(body, myLastMessageUIID_, true, boost::posix_time::microsec_clock::universal_time(), HighlightAction());

+ * Copyright (c) 2010-2014 Kevin Smith

+ ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, SettingsProvider* settings, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, boost::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider);

+ * Copyright (c) 2010-2014 Kevin Smith

+ChatControllerBase::ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, boost::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) {

+ return chatWindow_->addMessage(chatMessageParser_->parseMessageBody(message,senderIsSelf), senderName, senderIsSelf, label, pathToString(avatarPath), time, highlight);

+void ChatControllerBase::replaceMessage(const std::string& message, const std::string& id, bool senderIsSelf, const boost::posix_time::ptime& time, const HighlightAction& highlight) {

+ chatWindow_->replaceMessage(chatMessageParser_->parseMessageBody(message,senderIsSelf), id, time, highlight);

+ replaceMessage(body, lastMessagesUIID_[from], isIncomingMessageFromMe(message), timeStamp, highlight);

+ * Copyright (c) 2010-2014 Kevin Smith

+ void replaceMessage(const std::string& message, const std::string& id, bool senderIsSelf, const boost::posix_time::ptime& time, const HighlightAction& highlight);

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

+ boost::shared_ptr<ChatMessageParser> chatMessageParser_;

+ ChatMessageParser::ChatMessageParser(const std::map<std::string, std::string>& emoticons, HighlightRulesListPtr highlightRules, bool mucMode)

+ : emoticons_(emoticons), highlightRules_(highlightRules), mucMode_(mucMode) {

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

+ /* do emoticon substitution */

+ parsedMessage = emoticonHighlight(parsedMessage);

+

+ if (!senderIsSelf) { /* do not highlight our own messsages */

+ /* do word-based color highlighting */

+ parsedMessage = splitHighlight(parsedMessage);

+ }

+

+ return parsedMessage;

+ }

+

+ ChatWindow::ChatMessage ChatMessageParser::emoticonHighlight(const ChatWindow::ChatMessage& message)

+ {

+ ChatWindow::ChatMessage parsedMessage = message;

+

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

+ {

+ ChatWindow::ChatMessage parsedMessage = message;

+

+ for (size_t i = 0; i < highlightRules_->getSize(); ++i) {

+ const HighlightRule& rule = highlightRules_->getRule(i);

+ if (rule.getMatchMUC() && !mucMode_) {

+ continue; /* this rule only applies to MUC's, and this is a CHAT */

+ } else if (rule.getMatchChat() && mucMode_) {

+ continue; /* this rule only applies to CHAT's, and this is a MUC */

+ }

+ foreach(const boost::regex &regex, rule.getKeywordRegex()) {

+ ChatWindow::ChatMessage newMessage;

+ foreach (boost::shared_ptr<ChatWindow::ChatMessagePart> part, parsedMessage.getParts()) {

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

+ if ((textPart = boost::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, regex)) {

+ 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 */

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

+ }

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

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

+ highlightPart->foregroundColor = rule.getAction().getTextColor();

+ highlightPart->backgroundColor = rule.getAction().getTextBackground();

+ newMessage.append(highlightPart);

+ start = matchEnd;

+ }

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

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

+ newMessage.append(boost::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 */

+ newMessage.append(part);

+ }

+ } else {

+ newMessage.append(part);

+ }

+ }

+ parsedMessage = newMessage;

+ }

+ }

+

+ return parsedMessage;

+ }

+ * Copyright (c) 2013-2014 Kevin Smith

+ ChatMessageParser(const std::map<std::string, std::string>& emoticons, HighlightRulesListPtr highlightRules, bool mucMode = false);

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

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

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

+ HighlightRulesListPtr highlightRules_;

+ bool mucMode_;

+ emoticons_(emoticons),

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

+ ChatController* controller = new ChatController(jid_, stanzaChannel_, iqRouter_, chatWindowFactory_, contact, nickResolver_, presenceOracle_, avatarManager_, mucRegistry_->isMUC(contact.toBare()), useDelayForLatency_, uiEventStream_, eventController_, timerFactory_, entityCapsProvider_, userWantsReceipts_, settings_, historyController_, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser, autoAcceptMUCInviteDecider_);

+ boost::shared_ptr<ChatMessageParser> chatMessageParser = boost::make_shared<ChatMessageParser>(emoticons_, highlightManager_->getRules(), true); /* 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_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_, roster_, historyController_, mucRegistry_, highlightManager_, chatMessageParser, isImpromptu, autoAcceptMUCInviteDecider_, vcardManager_);

+ std::map<std::string, std::string> emoticons_;

+ boost::shared_ptr<ChatMessageParser> chatMessageParser,

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

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

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

+ CPPUNIT_ASSERT_EQUAL(text, part->text);

+ }

+

+ static HighlightRule ruleFromKeyword(const std::string& keyword, bool matchCase, bool matchWholeWord)

+ {

+ HighlightRule rule;

+ std::vector<std::string> keywords;

+ keywords.push_back(keyword);

+ rule.setKeywords(keywords);

+ rule.setMatchCase(matchCase);

+ rule.setMatchWholeWords(matchWholeWord);

+ rule.setMatchChat(true);

+ return rule;

+ }

+

+ static const HighlightRulesListPtr ruleListFromKeyword(const std::string& keyword, bool matchCase, bool matchWholeWord)

+ {

+ boost::shared_ptr<HighlightManager::HighlightRulesList> list = boost::make_shared<HighlightManager::HighlightRulesList>();

+ list->addRule(ruleFromKeyword(keyword, matchCase, matchWholeWord));

+ return list;

+ }

+

+ static const HighlightRulesListPtr ruleListFromKeywords(const HighlightRule &rule1, const HighlightRule &rule2)

+ {

+ boost::shared_ptr<HighlightManager::HighlightRulesList> list = boost::make_shared<HighlightManager::HighlightRulesList>();

+ list->addRule(rule1);

+ list->addRule(rule2);

+ return list;

+ }

+

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

+ ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

+ ChatWindow::ChatMessage result = testling.parseMessageBody(no_special_message);

+ assertText(result, 0, no_special_message);

+

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

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

+ assertHighlight(result, 4, "trigger");

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

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

+ assertText(result, 9, " ");

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

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

+

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

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

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

+ assertHighlight(result, 1, "trigger");

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

+

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

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

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

+

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

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

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

+

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

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

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

+

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

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

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

+ assertHighlight(result, 1, "TrIgGeR");

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

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, false), ruleFromKeyword("three", false, false)));

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

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

+ assertHighlight(result, 1, "one");

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

+ assertHighlight(result, 3, "three");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, false), ruleFromKeyword("three", false, false)));

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

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

+ assertHighlight(result, 1, "oNe");

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

+ assertHighlight(result, 3, "tHrEe");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, false), ruleFromKeyword("three", true, false)));

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

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

+ assertHighlight(result, 1, "oNe");

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

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", true, false), ruleFromKeyword("three", true, false)));

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

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

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, false), ruleFromKeyword("three", false, false)));

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

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

+ assertHighlight(result, 1, "one");

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

+ assertHighlight(result, 3, "three");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", true, false), ruleFromKeyword("three", false, false)));

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

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

+ assertHighlight(result, 1, "ThReE");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, true), ruleFromKeyword("three", false, false)));

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

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

+ assertHighlight(result, 1, "three");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, true), ruleFromKeyword("three", false, true)));

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

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

+ ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

+ ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

+ ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

+ ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

+ ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

+ ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

+ * Copyright (c) 2010-2014 Kevin Smith

+ chatMessageParser_ = boost::make_shared<ChatMessageParser>(std::map<std::string, std::string>(), highlightManager_->getRules(), true);

+ boost::shared_ptr<ChatMessageParser> chatMessageParser_;

+/*

+ * Copyright (c) 2014 Kevin Smith and Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

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

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

+

+ /**

+ * Gets the foreground highlight color. If the string is empty, assume a default color.

+ */

+ /**

+ * Gets the background highlight color. If the string is empty, assume a default color.

+ */

+ /**

+ * Gets the sound filename. If the string is empty, assume a default sound file.

+ */

+ friend class boost::serialization::access;

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

+

+ template<class Archive>

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

+ {

+ ar & highlightText_;

+ ar & textColor_;

+ ar & textBackground_;

+ ar & playSound_;

+ ar & soundFile_;

+ }

+

+/*

+ * Copyright (c) 2014 Kevin Smith and Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

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

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

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

+HighlightEditorController::HighlightEditorController(UIEventStream* uiEventStream, HighlightEditorWindowFactory* highlightEditorWindowFactory, HighlightManager* highlightManager)

+: highlightEditorWindowFactory_(highlightEditorWindowFactory), highlightEditorWindow_(NULL), highlightManager_(highlightManager), contactSuggester_(0)

+ delete highlightEditorWindow_;

+ highlightEditorWindow_ = NULL;

+ if (!highlightEditorWindow_) {

+ highlightEditorWindow_ = highlightEditorWindowFactory_->createHighlightEditorWindow();

+ highlightEditorWindow_->setHighlightManager(highlightManager_);

+ highlightEditorWindow_->onContactSuggestionsRequested.connect(boost::bind(&HighlightEditorController::handleContactSuggestionsRequested, this, _1));

+ highlightEditorWindow_->show();

+ }

+}

+

+void HighlightEditorController::handleContactSuggestionsRequested(const std::string& text)

+{

+ if (contactSuggester_) {

+ highlightEditorWindow_->setContactSuggestions(contactSuggester_->getSuggestions(text));

+/*

+ * Copyright (c) 2014 Kevin Smith and Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+ class HighlightEditorWindowFactory;

+ class HighlightEditorWindow;

+ class ContactSuggester;

+ HighlightEditorController(UIEventStream* uiEventStream, HighlightEditorWindowFactory* highlightEditorWindowFactory, HighlightManager* highlightManager);

+ void setContactSuggester(ContactSuggester *suggester) { contactSuggester_ = suggester; }

+ void handleContactSuggestionsRequested(const std::string& text);

+ HighlightEditorWindowFactory* highlightEditorWindowFactory_;

+ HighlightEditorWindow* highlightEditorWindow_;

+ ContactSuggester* contactSuggester_;

+/*

+ * Copyright (c) 2014 Kevin Smith and Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

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

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

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

+ rules_ = boost::make_shared<HighlightRulesList>();

+ std::stringstream stream;

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

+ archive << rules_->list_;

+ return stream.str();

+ assert(index >= 0 && static_cast<size_t>(index) < rules_->getSize());

+ return rules_->getRule(static_cast<size_t>(index));

+ assert(index >= 0 && static_cast<size_t>(index) < rules_->getSize());

+ rules_->list_[static_cast<size_t>(index)] = rule;

+ assert(index >= 0 && boost::numeric_cast<std::vector<std::string>::size_type>(index) <= rules_->getSize());

+ rules_->list_.insert(rules_->list_.begin() + index, rule);

+ assert(index >= 0 && boost::numeric_cast<std::vector<std::string>::size_type>(index) < rules_->getSize());

+ rules_->list_.erase(rules_->list_.begin() + index);

+}

+

+void HighlightManager::storeSettings()

+{

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

+ settings_->storeSetting(SettingConstants::HIGHLIGHT_RULES, rulesToString());

+ storingSettings_ = false;

+}

+

+void HighlightManager::loadSettings()

+{

+ std::string rulesString = settings_->getSetting(SettingConstants::HIGHLIGHT_RULES);

+ std::stringstream stream;

+ stream << rulesString;

+ try {

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

+ archive >> rules_->list_;

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

+ rules_->list_ = getDefaultRules();

+ }

+/*

+ * Copyright (c) 2014 Kevin Smith and Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+

+ class HighlightRulesList {

+ public:

+ friend class HighlightManager;

+ size_t getSize() const { return list_.size(); }

+ const HighlightRule& getRule(const size_t index) const { return list_[index]; }

+ void addRule(const HighlightRule &rule) { list_.push_back(rule); }

+ void combineRules(const HighlightRulesList &rhs) {

+ list_.insert(list_.end(), rhs.list_.begin(), rhs.list_.end());

+ }

+ private:

+ std::vector<HighlightRule> list_;

+ };

+

+ boost::shared_ptr<const HighlightManager::HighlightRulesList> getRules() const { return rules_; }

+

+ void storeSettings();

+ void loadSettings();

+ boost::shared_ptr<HighlightManager::HighlightRulesList> rules_;

+ typedef boost::shared_ptr<const HighlightManager::HighlightRulesList> HighlightRulesListPtr;

+

+/*

+ * Copyright (c) 2014 Kevin Smith and Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+/*

+ * Copyright (c) 2014 Kevin Smith and Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

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

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

+ const std::vector<boost::regex>& getSenderRegex() const { return senderRegex_; }

+ const std::vector<boost::regex>& getKeywordRegex() const { return keywordRegex_; }

+ friend class boost::serialization::access;

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

+

+ template<class Archive>

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

+ {

+ ar & senders_;

+ ar & keywords_;

+ ar & nickIsKeyword_;

+ ar & matchChat_;

+ ar & matchMUC_;

+ ar & matchCase_;

+ ar & matchWholeWords_;

+ ar & action_;

+ updateRegex();

+ }

+

+/*

+ * Copyright (c) 2014 Kevin Smith and Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+ HighlightRulesListPtr rules = manager_->getRules();

+ for (size_t i = 0; i < rules->getSize(); ++i) {

+ const HighlightRule& rule = rules->getRule(i);

+ if (rule.isMatch(body, sender, nick_, messageType_)) {

+ return rule.getAction();

+ * Copyright (c) 2010-2014 Kevin Smith and Remko Tronçon

+ highlightEditorController_->setContactSuggester(contactSuggesterWithoutRoster_);

+ "UIInterfaces/HighlightEditorWindow.cpp",

+/*

+ * Copyright (c) 2014 Kevin Smith and Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

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

+

+namespace Swift {

+

+HighlightEditorWindow::HighlightEditorWindow()

+{

+}

+

+HighlightEditorWindow::~HighlightEditorWindow()

+{

+}

+

+}

+/*

+ * Copyright (c) 2014 Kevin Smith and Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <vector>

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

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

+

+namespace Swift {

+

+class HighlightManager;

+

+class HighlightEditorWindow {

+public:

+ HighlightEditorWindow();

+ virtual ~HighlightEditorWindow();

+ virtual void show() = 0;

+ virtual void setHighlightManager(HighlightManager *highlightManager) = 0;

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

+

+public:

+ boost::signal<void (const std::string&)> onContactSuggestionsRequested;

+};

+

+}

+/*

+ * Copyright (c) 2012 Mateusz Piękos

+ * Licensed under the simplified BSD license.

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

+ */

+

+/*

+ * Copyright (c) 2014 Kevin Smith and Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+namespace Swift {

+ class HighlightEditorWindow;

+

+ class HighlightEditorWindowFactory {

+ public :

+ virtual ~HighlightEditorWindowFactory() {}

+

+ virtual HighlightEditorWindow* createHighlightEditorWindow() = 0;

+ };

+}

+ * Copyright (c) 2010-2014 Remko Tronçon

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

+ public HighlightEditorWindowFactory,

+/*

+ * Copyright (c) 2014 Kevin Smith and Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+ std::vector<std::string> senders;

+ CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("keyword1", "from", "nick", HighlightRule::ChatMessage), false);

+ CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("abc keyword1 xyz", "from", "nick", HighlightRule::ChatMessage), false);

+ CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("abckeyword1xyz", "from", "nick", HighlightRule::ChatMessage), false);

+ CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("KEYword1", "from", "nick", HighlightRule::ChatMessage), false);

+ CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("abc KEYword1 xyz", "from", "nick", HighlightRule::ChatMessage), false);

+ CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("abcKEYword1xyz", "from", "nick", HighlightRule::ChatMessage), false);

+ CPPUNIT_ASSERT_EQUAL(keywordChatRule->isMatch("keyword2", "from", "nick", HighlightRule::ChatMessage), false);

+ CPPUNIT_ASSERT_EQUAL(keywordNickChatRule->isMatch("keyword1", "from", "nick", HighlightRule::ChatMessage), false);

+ CPPUNIT_ASSERT_EQUAL(senderKeywordChatRule->isMatch("keyword1", "sender1", "nick", HighlightRule::ChatMessage), false);

+ CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("keyword1", "sender1", "nick", HighlightRule::ChatMessage), false);

+ CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("KEYword1", "SENDer1", "nick", HighlightRule::ChatMessage), false);

+ CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("keyword1", "sender1", "nick", HighlightRule::ChatMessage), false);

+ CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("xkeyword1", "xsender1", "nick", HighlightRule::ChatMessage), false);

+ CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("keyword1", "sender1", "nick", HighlightRule::ChatMessage), false);

+ CPPUNIT_ASSERT_EQUAL(senderKeywordNickMUCRule->isMatch("keyword1", "sender1", "nick", HighlightRule::MUCMessage), false);