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

+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)

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

+void ChatController::postHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent, const HighlightAction& highlight) {

+ if (!messageEvent->getConcluded()) {

+ highlighter_->handleHighlightAction(highlight);

+ }

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

+ myLastMessageUIID_ = addMessage(body, QT_TRANSLATE_NOOP("", "me"), true, labelsEnabled_ ? chatWindow_->getSelectedSecurityLabel().getLabel() : boost::shared_ptr<SecurityLabel>(), std::string(avatarManager_->getAvatarPath(selfJID_).string()), boost::posix_time::microsec_clock::universal_time(), HighlightAction());

+ class HighlightManager;

+ 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);

+ void postHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent, const HighlightAction&);

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

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

+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) : 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) {

+ highlighter_ = highlightManager->createHighlighter();

+std::string ChatControllerBase::addMessage(const std::string& message, const std::string& senderName, bool senderIsSelf, const boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) {

+ return chatWindow_->addAction(String::getSplittedAtFirst(message, ' ').second, senderName, senderIsSelf, label, avatarPath, time, highlight);

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

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

+ chatWindow_->replaceWithAction(String::getSplittedAtFirst(message, ' ').second, id, time, highlight);

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

+ HighlightAction highlight;

+ // Highlight

+ if (!isIncomingMessageFromMe(message)) {

+ highlight = highlighter_->findAction(body, senderDisplayNameFromMessage(from));

+ }

+

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

+ lastMessagesUIID_[from] = addMessage(body, senderDisplayNameFromMessage(from), isIncomingMessageFromMe(message), label, std::string(avatarManager_->getAvatarPath(from).string()), timeStamp, highlight);

+ postHandleIncomingMessage(messageEvent, highlight);

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

+ class HighlightManager;

+ class Highlighter;

+ std::string addMessage(const std::string& message, const std::string& senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight);

+ void replaceMessage(const std::string& message, const std::string& id, 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);

+ virtual void postHandleIncomingMessage(boost::shared_ptr<MessageEvent>, const HighlightAction&) {}

+ Highlighter* highlighter_;

+ WhiteboardManager* whiteboardManager,

+ HighlightManager* highlightManager) :

+ whiteboardManager_(whiteboardManager),

+ highlightManager_(highlightManager) {

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

+ MUCController* controller = new MUCController(jid_, muc, password, nick, stanzaChannel_, iqRouter_, chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_, roster_, historyController_, mucRegistry_, highlightManager_);

+ class HighlightManager;

+ ChatsManager(JID jid, StanzaChannel* stanzaChannel, IQRouter* iqRouter, EventController* eventController, ChatWindowFactory* chatWindowFactory, JoinMUCWindowFactory* joinMUCWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, PresenceSender* presenceSender, UIEventStream* uiEventStream, ChatListWindowFactory* chatListWindowFactory, bool useDelayForLatency, TimerFactory* timerFactory, MUCRegistry* mucRegistry, EntityCapsProvider* entityCapsProvider, MUCManager* mucManager, MUCSearchWindowFactory* mucSearchWindowFactory, ProfileSettingsProvider* profileSettings, FileTransferOverview* ftOverview, XMPPRoster* roster, bool eagleMode, SettingsProvider* settings, HistoryController* historyController_, WhiteboardManager* whiteboardManager, HighlightManager* highlightManager);

+ HighlightManager* highlightManager_;

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

+ MUCRegistry* mucRegistry,

+ HighlightManager* highlightManager) :

+ ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, timerFactory, entityCapsProvider, historyController, mucRegistry, highlightManager), muc_(muc), nick_(nick), desiredNick_(nick), password_(password) {

+ highlighter_->setMode(Highlighter::MUCMode);

+ highlighter_->setNick(nick_);

+ setNick(rejoinNick);

+ setNick(nick);

+void MUCController::postHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent, const HighlightAction& highlight) {

+ if (!messageEvent->getConcluded()) {

+ highlighter_->handleHighlightAction(highlight);

+ }

+ setNick(desiredNick_);

+ addMessage(message.getMessage(), senderDisplayNameFromMessage(message.getFromJID()), senderIsSelf, boost::shared_ptr<SecurityLabel>(new SecurityLabel()), std::string(avatarManager_->getAvatarPath(message.getFromJID()).string()), message.getTime() - boost::posix_time::hours(message.getOffset()), HighlightAction());

+void MUCController::setNick(const std::string& nick)

+{

+ nick_ = nick;

+ highlighter_->setNick(nick_);

+}

+

+ class HighlightManager;

+ 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);

+ void postHandleIncomingMessage(boost::shared_ptr<MessageEvent>, const HighlightAction&);

+ void setNick(const std::string& nick);

+ highlightManager_ = new HighlightManager(settings_);

+ manager_ = new ChatsManager(jid_, stanzaChannel_, iqRouter_, eventController_, chatWindowFactory_, joinMUCWindowFactory_, nickResolver_, presenceOracle_, directedPresenceSender_, uiEventStream_, chatListWindowFactory_, true, NULL, mucRegistry_, entityCapsManager_, mucManager_, mucSearchWindowFactory_, profileSettings_, ftOverview_, xmppRoster_, false, settings_, NULL, wbManager_, highlightManager_);

+ delete highlightManager_;

+ HighlightManager* highlightManager_;

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

+ settings_ = new DummySettingsProvider();

+ highlightManager_ = new HighlightManager(settings_);

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

+ delete highlightManager_;

+ delete settings_;

+ DummySettingsProvider* settings_;

+ HighlightManager* highlightManager_;

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

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

+

+namespace Swift {

+

+void HighlightAction::setHighlightText(bool highlightText)

+{

+ highlightText_ = highlightText;

+ if (!highlightText_) {

+ textColor_.clear();

+ textBackground_.clear();

+ }

+}

+

+void HighlightAction::setPlaySound(bool playSound)

+{

+ playSound_ = playSound;

+ if (!playSound_) {

+ soundFile_.clear();

+ }

+}

+

+}

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <string>

+

+namespace Swift {

+

+ class HighlightRule;

+

+ class HighlightAction {

+ public:

+ HighlightAction() : highlightText_(false), playSound_(false) {}

+

+ bool highlightText() const { return highlightText_; }

+ void setHighlightText(bool highlightText);

+

+ const std::string& getTextColor() const { return textColor_; }

+ void setTextColor(const std::string& textColor) { textColor_ = textColor; }

+

+ const std::string& getTextBackground() const { return textBackground_; }

+ void setTextBackground(const std::string& textBackground) { textBackground_ = textBackground; }

+

+ bool playSound() const { return playSound_; }

+ void setPlaySound(bool playSound);

+

+ const std::string& getSoundFile() const { return soundFile_; }

+ void setSoundFile(const std::string& soundFile) { soundFile_ = soundFile; }

+

+ bool isEmpty() const { return !highlightText_ && !playSound_; }

+

+ private:

+ bool highlightText_;

+ std::string textColor_;

+ std::string textBackground_;

+

+ bool playSound_;

+ std::string soundFile_;

+ };

+

+}

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <boost/bind.hpp>

+

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

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

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

+#include <Swift/Controllers/UIEvents/RequestHighlightEditorUIEvent.h>

+#include <Swift/Controllers/UIEvents/UIEventStream.h>

+

+namespace Swift {

+

+HighlightEditorController::HighlightEditorController(UIEventStream* uiEventStream, HighlightEditorWidgetFactory* highlightEditorWidgetFactory, HighlightManager* highlightManager) : highlightEditorWidgetFactory_(highlightEditorWidgetFactory), highlightEditorWidget_(NULL), highlightManager_(highlightManager)

+{

+ uiEventStream->onUIEvent.connect(boost::bind(&HighlightEditorController::handleUIEvent, this, _1));

+}

+

+HighlightEditorController::~HighlightEditorController()

+{

+ delete highlightEditorWidget_;

+ highlightEditorWidget_ = NULL;

+}

+

+void HighlightEditorController::handleUIEvent(boost::shared_ptr<UIEvent> rawEvent)

+{

+ boost::shared_ptr<RequestHighlightEditorUIEvent> event = boost::dynamic_pointer_cast<RequestHighlightEditorUIEvent>(rawEvent);

+ if (event) {

+ if (!highlightEditorWidget_) {

+ highlightEditorWidget_ = highlightEditorWidgetFactory_->createHighlightEditorWidget();

+ highlightEditorWidget_->setHighlightManager(highlightManager_);

+ }

+ highlightEditorWidget_->show();

+ }

+}

+

+}

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+

+#include <Swift/Controllers/UIEvents/UIEvent.h>

+

+namespace Swift {

+

+ class UIEventStream;

+

+ class HighlightEditorWidgetFactory;

+ class HighlightEditorWidget;

+

+ class HighlightManager;

+

+ class HighlightEditorController {

+ public:

+ HighlightEditorController(UIEventStream* uiEventStream, HighlightEditorWidgetFactory* highlightEditorWidgetFactory, HighlightManager* highlightManager);

+ ~HighlightEditorController();

+

+ HighlightManager* getHighlightManager() const { return highlightManager_; }

+

+ private:

+ void handleUIEvent(boost::shared_ptr<UIEvent> event);

+

+ private:

+ HighlightEditorWidgetFactory* highlightEditorWidgetFactory_;

+ HighlightEditorWidget* highlightEditorWidget_;

+ HighlightManager* highlightManager_;

+ };

+

+}

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <cassert>

+

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

+#include <boost/regex.hpp>

+#include <boost/bind.hpp>

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

+

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

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

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

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

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

+

+/* How does highlighting work?

+ *

+ * HighlightManager manages a list of if-then rules used to highlight messages.

+ * Rule is represented by HighlightRule. Action ("then" part) is HighlightAction.

+ *

+ *

+ * HighlightManager is also used as a factory for Highlighter objects.

+ * Each ChatControllerBase has its own Highlighter.

+ * Highligher may be customized by using setNick(), etc.

+ *

+ * ChatControllerBase passes incoming messages to Highlighter and gets HighlightAction in return

+ * (first matching rule is returned).

+ * If needed, HighlightAction is then passed back to Highlighter for further handling.

+ * This results in HighlightManager emiting onHighlight event,

+ * which is handled by SoundController to play sound notification

+ */

+

+namespace Swift {

+

+HighlightManager::HighlightManager(SettingsProvider* settings)

+ : settings_(settings)

+ , storingSettings_(false)

+{

+ loadSettings();

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

+}

+

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

+{

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

+ loadSettings();

+ }

+}

+

+void HighlightManager::loadSettings()

+{

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

+ if (highlightRules == "@") {

+ rules_ = getDefaultRules();

+ } else {

+ rules_ = rulesFromString(highlightRules);

+ }

+}

+

+std::string HighlightManager::rulesToString() const

+{

+ std::string s;

+ foreach (HighlightRule r, rules_) {

+ s += r.toString() + '\f';

+ }

+ if (s.size()) {

+ s.erase(s.end() - 1);

+ }

+ return s;

+}

+

+std::vector<HighlightRule> HighlightManager::rulesFromString(const std::string& rulesString)

+{

+ std::vector<HighlightRule> rules;

+ std::string s(rulesString);

+ typedef boost::split_iterator<std::string::iterator> split_iterator;

+ for (split_iterator it = boost::make_split_iterator(s, boost::first_finder("\f")); it != split_iterator(); ++it) {

+ HighlightRule r = HighlightRule::fromString(boost::copy_range<std::string>(*it));

+ if (!r.isEmpty()) {

+ rules.push_back(r);

+ }

+ }

+ return rules;

+}

+

+std::vector<HighlightRule> HighlightManager::getDefaultRules()

+{

+ std::vector<HighlightRule> rules;

+ HighlightRule r;

+ r.setMatchChat(true);

+ r.getAction().setPlaySound(true);

+ rules.push_back(r);

+ return rules;

+}

+

+void HighlightManager::storeSettings()

+{

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

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

+ storingSettings_ = false;

+}

+

+HighlightRule HighlightManager::getRule(int index) const

+{

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

+ return rules_[index];

+}

+

+void HighlightManager::setRule(int index, const HighlightRule& rule)

+{

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

+ rules_[index] = rule;

+ storeSettings();

+}

+

+void HighlightManager::insertRule(int index, const HighlightRule& rule)

+{

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

+ rules_.insert(rules_.begin() + index, rule);

+ storeSettings();

+}

+

+void HighlightManager::removeRule(int index)

+{

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

+ rules_.erase(rules_.begin() + index);

+ storeSettings();

+}

+

+Highlighter* HighlightManager::createHighlighter()

+{

+ return new Highlighter(this);

+}

+

+}

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <vector>

+#include <string>

+

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

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

+

+namespace Swift {

+

+ class SettingsProvider;

+ class Highlighter;

+

+ class HighlightManager {

+ public:

+ HighlightManager(SettingsProvider* settings);

+

+ Highlighter* createHighlighter();

+

+ const std::vector<HighlightRule>& getRules() const { return rules_; }

+ HighlightRule getRule(int index) const;

+ void setRule(int index, const HighlightRule& rule);

+ void insertRule(int index, const HighlightRule& rule);

+ void removeRule(int index);

+

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

+

+ private:

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

+

+ std::string rulesToString() const;

+ static std::vector<HighlightRule> rulesFromString(const std::string&);

+ static std::vector<HighlightRule> getDefaultRules();

+

+ SettingsProvider* settings_;

+ bool storingSettings_;

+ void storeSettings();

+ void loadSettings();

+

+ std::vector<HighlightRule> rules_;

+ };

+

+}

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <algorithm>

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

+#include <boost/lambda/lambda.hpp>

+

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

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

+

+namespace Swift {

+

+HighlightRule::HighlightRule()

+ : nickIsKeyword_(false)

+ , matchCase_(false)

+ , matchWholeWords_(false)

+ , matchChat_(false)

+ , matchMUC_(false)

+{

+}

+

+boost::regex HighlightRule::regexFromString(const std::string & s) const

+{

+ // escape regex special characters: ^.$| etc

+ // these need to be escaped: [\^\$\|.........]

+ // and then C++ requires '\' to be escaped, too....

+ static const boost::regex esc("([\\^\\.\\$\\|\\(\\)\\[\\]\\*\\+\\?\\/\\{\\}\\\\])");

+ // matched character should be prepended with '\'

+ // replace matched special character with \\\1

+ // and escape once more for C++ rules...

+ static const std::string rep("\\\\\\1");

+ std::string escaped = boost::regex_replace(s , esc, rep);

+

+ std::string word = matchWholeWords_ ? "\\b" : "";

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

+ if (!matchCase_) {

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

+ }

+ return boost::regex(word + escaped + word, flags);

+}

+

+void HighlightRule::updateRegex() const

+{

+ keywordRegex_.clear();

+ foreach (const std::string & k, keywords_) {

+ keywordRegex_.push_back(regexFromString(k));

+ }

+ senderRegex_.clear();

+ foreach (const std::string & s, senders_) {

+ senderRegex_.push_back(regexFromString(s));

+ }

+}

+

+std::string HighlightRule::boolToString(bool b)

+{

+ return b ? "1" : "0";

+}

+

+bool HighlightRule::boolFromString(const std::string& s)

+{

+ return s == "1";

+}

+

+std::string HighlightRule::toString() const

+{

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

+ v.push_back(boost::join(senders_, "\t"));

+ v.push_back(boost::join(keywords_, "\t"));

+ v.push_back(boolToString(nickIsKeyword_));

+ v.push_back(boolToString(matchChat_));

+ v.push_back(boolToString(matchMUC_));

+ v.push_back(boolToString(matchCase_));

+ v.push_back(boolToString(matchWholeWords_));

+ v.push_back(boolToString(action_.highlightText()));

+ v.push_back(action_.getTextColor());

+ v.push_back(action_.getTextBackground());

+ v.push_back(boolToString(action_.playSound()));

+ v.push_back(action_.getSoundFile());

+ return boost::join(v, "\n");

+}

+

+HighlightRule HighlightRule::fromString(const std::string& s)

+{

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

+ boost::split(v, s, boost::is_any_of("\n"));

+

+ HighlightRule r;

+ int i = 0;

+ try {

+ boost::split(r.senders_, v.at(i++), boost::is_any_of("\t"));

+ r.senders_.erase(std::remove_if(r.senders_.begin(), r.senders_.end(), boost::lambda::_1 == ""), r.senders_.end());

+ boost::split(r.keywords_, v.at(i++), boost::is_any_of("\t"));

+ r.keywords_.erase(std::remove_if(r.keywords_.begin(), r.keywords_.end(), boost::lambda::_1 == ""), r.keywords_.end());

+ r.nickIsKeyword_ = boolFromString(v.at(i++));

+ r.matchChat_ = boolFromString(v.at(i++));

+ r.matchMUC_ = boolFromString(v.at(i++));

+ r.matchCase_ = boolFromString(v.at(i++));

+ r.matchWholeWords_ = boolFromString(v.at(i++));

+ r.action_.setHighlightText(boolFromString(v.at(i++)));

+ r.action_.setTextColor(v.at(i++));

+ r.action_.setTextBackground(v.at(i++));

+ r.action_.setPlaySound(boolFromString(v.at(i++)));

+ r.action_.setSoundFile(v.at(i++));

+ }

+ catch (std::out_of_range) {

+ // this may happen if more properties are added to HighlightRule object, etc...

+ // in such case, default values (set by default constructor) will be used

+ }

+

+ r.updateRegex();

+

+ return r;

+}

+

+bool HighlightRule::isMatch(const std::string& body, const std::string& sender, const std::string& nick, MessageType messageType) const

+{

+ if ((messageType == HighlightRule::ChatMessage && matchChat_) || (messageType == HighlightRule::MUCMessage && matchMUC_)) {

+

+ bool matchesKeyword = keywords_.empty() && (nick.empty() || !nickIsKeyword_);

+ bool matchesSender = senders_.empty();

+

+ foreach (const boost::regex & rx, keywordRegex_) {

+ if (boost::regex_search(body, rx)) {

+ matchesKeyword = true;

+ break;

+ }

+ }

+

+ if (!matchesKeyword && nickIsKeyword_ && !nick.empty()) {

+ if (boost::regex_search(body, regexFromString(nick))) {

+ matchesKeyword = true;

+ }

+ }

+

+ foreach (const boost::regex & rx, senderRegex_) {

+ if (boost::regex_search(sender, rx)) {

+ matchesSender = true;

+ break;

+ }

+ }

+

+ if (matchesKeyword && matchesSender) {

+ return true;

+ }

+ }

+

+ return false;

+}

+

+void HighlightRule::setSenders(const std::vector<std::string>& senders)

+{

+ senders_ = senders;

+ updateRegex();

+}

+

+void HighlightRule::setKeywords(const std::vector<std::string>& keywords)

+{

+ keywords_ = keywords;

+ updateRegex();

+}

+

+void HighlightRule::setNickIsKeyword(bool nickIsKeyword)

+{

+ nickIsKeyword_ = nickIsKeyword;

+ updateRegex();

+}

+

+void HighlightRule::setMatchCase(bool matchCase)

+{

+ matchCase_ = matchCase;

+ updateRegex();

+}

+

+void HighlightRule::setMatchWholeWords(bool matchWholeWords)

+{

+ matchWholeWords_ = matchWholeWords;

+ updateRegex();

+}

+

+void HighlightRule::setMatchChat(bool matchChat)

+{

+ matchChat_ = matchChat;

+ updateRegex();

+}

+

+void HighlightRule::setMatchMUC(bool matchMUC)

+{

+ matchMUC_ = matchMUC;

+ updateRegex();

+}

+

+bool HighlightRule::isEmpty() const

+{

+ return senders_.empty() && keywords_.empty() && !nickIsKeyword_ && !matchChat_ && !matchMUC_ && action_.isEmpty();

+}

+

+}

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <vector>

+#include <string>

+

+#include <boost/regex.hpp>

+

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

+

+namespace Swift {

+

+ class HighlightRule {

+ public:

+ HighlightRule();

+

+ enum MessageType { ChatMessage, MUCMessage };

+

+ bool isMatch(const std::string& body, const std::string& sender, const std::string& nick, MessageType) const;

+

+ const HighlightAction& getAction() const { return action_; }

+ HighlightAction& getAction() { return action_; }

+

+ static HighlightRule fromString(const std::string&);

+ std::string toString() const;

+

+ const std::vector<std::string>& getSenders() const { return senders_; }

+ void setSenders(const std::vector<std::string>&);

+

+ const std::vector<std::string>& getKeywords() const { return keywords_; }

+ void setKeywords(const std::vector<std::string>&);

+

+ bool getNickIsKeyword() const { return nickIsKeyword_; }

+ void setNickIsKeyword(bool);

+

+ bool getMatchCase() const { return matchCase_; }

+ void setMatchCase(bool);

+

+ bool getMatchWholeWords() const { return matchWholeWords_; }

+ void setMatchWholeWords(bool);

+

+ bool getMatchChat() const { return matchChat_; }

+ void setMatchChat(bool);

+

+ bool getMatchMUC() const { return matchMUC_; }

+ void setMatchMUC(bool);

+

+ bool isEmpty() const;

+

+ private:

+ static std::string boolToString(bool);

+ static bool boolFromString(const std::string&);

+

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

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

+ bool nickIsKeyword_;

+

+ mutable std::vector<boost::regex> senderRegex_;

+ mutable std::vector<boost::regex> keywordRegex_;

+ void updateRegex() const;

+ boost::regex regexFromString(const std::string&) const;

+

+ bool matchCase_;

+ bool matchWholeWords_;

+

+ bool matchChat_;

+ bool matchMUC_;

+

+ HighlightAction action_;

+ };

+

+}

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

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

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

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

+

+namespace Swift {

+

+Highlighter::Highlighter(HighlightManager* manager)

+ : manager_(manager)

+{

+ setMode(ChatMode);

+}

+

+void Highlighter::setMode(Mode mode)

+{

+ mode_ = mode;

+ messageType_ = mode_ == ChatMode ? HighlightRule::ChatMessage : HighlightRule::MUCMessage;

+}

+

+HighlightAction Highlighter::findAction(const std::string& body, const std::string& sender) const

+{

+ foreach (const HighlightRule & r, manager_->getRules()) {

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

+ return r.getAction();

+ }

+ }

+

+ return HighlightAction();

+}

+

+void Highlighter::handleHighlightAction(const HighlightAction& action)

+{

+ manager_->onHighlight(action);

+}

+

+}

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <string>

+

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

+

+namespace Swift {

+

+ class HighlightManager;

+

+ class Highlighter {

+ public:

+ Highlighter(HighlightManager* manager);

+

+ enum Mode { ChatMode, MUCMode };

+ void setMode(Mode mode);

+

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

+

+ HighlightAction findAction(const std::string& body, const std::string& sender) const;

+

+ void handleHighlightAction(const HighlightAction& action);

+

+ private:

+ HighlightManager* manager_;

+ Mode mode_;

+ HighlightRule::MessageType messageType_;

+ std::string nick_;

+ };

+

+}

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

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

+

+ highlightManager_ = new HighlightManager(settings_);

+ highlightEditorController_ = new HighlightEditorController(uiEventStream_, uiFactory_, highlightManager_);

+

+ soundEventController_ = new SoundEventController(eventController_, soundPlayer, settings, highlightManager_);

+ delete highlightEditorController_;

+ delete highlightManager_;

+ chatsManager_ = new ChatsManager(jid_, client_->getStanzaChannel(), client_->getIQRouter(), eventController_, uiFactory_, uiFactory_, client_->getNickResolver(), client_->getPresenceOracle(), client_->getPresenceSender(), uiEventStream_, uiFactory_, useDelayForLatency_, networkFactories_->getTimerFactory(), client_->getMUCRegistry(), client_->getEntityCapsProvider(), client_->getMUCManager(), uiFactory_, profileSettings_, ftOverview_, client_->getRoster(), !settings_->getSetting(SettingConstants::REMEMBER_RECENT_CHATS), settings_, historyController_, whiteboardManager_, highlightManager_);

+ chatsManager_ = new ChatsManager(jid_, client_->getStanzaChannel(), client_->getIQRouter(), eventController_, uiFactory_, uiFactory_, client_->getNickResolver(), client_->getPresenceOracle(), client_->getPresenceSender(), uiEventStream_, uiFactory_, useDelayForLatency_, networkFactories_->getTimerFactory(), client_->getMUCRegistry(), client_->getEntityCapsProvider(), client_->getMUCManager(), uiFactory_, profileSettings_, ftOverview_, client_->getRoster(), !settings_->getSetting(SettingConstants::REMEMBER_RECENT_CHATS), settings_, NULL, whiteboardManager_, highlightManager_);

+ class HighlightManager;

+ class HighlightEditorController;

+ HighlightManager* highlightManager_;

+ HighlightEditorController* highlightEditorController_;

+ "StatusCache.cpp",

+ "HighlightAction.cpp",

+ "HighlightEditorController.cpp",

+ "HighlightManager.cpp",

+ "HighlightRule.cpp",

+ "Highlighter.cpp"

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

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

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

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

+SoundEventController::SoundEventController(EventController* eventController, SoundPlayer* soundPlayer, SettingsProvider* settings, HighlightManager* highlightManager) {

+ highlightManager_ = highlightManager;

+ highlightManager_->onHighlight.connect(boost::bind(&SoundEventController::handleHighlight, this, _1));

+

+void SoundEventController::handleEventQueueEventAdded(boost::shared_ptr<StanzaEvent> /*event*/) {

+ // message received sound is now played via highlighting

+ //if (playSounds_ && !event->getConcluded()) {

+ // soundPlayer_->playSound(SoundPlayer::MessageReceived);

+ //}

+}

+

+void SoundEventController::handleHighlight(const HighlightAction& action) {

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

+ soundPlayer_->playSound(SoundPlayer::MessageReceived, action.getSoundFile());

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

+ class HighlightManager;

+ SoundEventController(EventController* eventController, SoundPlayer* soundPlayer, SettingsProvider* settings, HighlightManager* highlightManager);

+ void handleHighlight(const HighlightAction& action);

+ HighlightManager* highlightManager_;

+#include <string>

+

+ virtual void playSound(SoundEffect sound, const std::string& soundResource) = 0;

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <Swift/Controllers/UIEvents/UIEvent.h>

+

+namespace Swift {

+

+ class RequestHighlightEditorUIEvent : public UIEvent {

+ };

+

+}

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

+ virtual std::string addMessage(const std::string& message, const std::string& senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) = 0;

+ virtual std::string addAction(const std::string& message, const std::string& senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) = 0;

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

+ virtual void replaceWithAction(const std::string& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& highlight) = 0;

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+namespace Swift {

+

+ class HighlightManager;

+

+ class HighlightEditorWidget {

+ public:

+ virtual ~HighlightEditorWidget() {}

+

+ virtual void show() = 0;

+

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

+ };

+

+}

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+namespace Swift {

+

+ class HighlightEditorWidget;

+

+ class HighlightEditorWidgetFactory {

+ public:

+ virtual ~HighlightEditorWidgetFactory() {}

+

+ virtual HighlightEditorWidget* createHighlightEditorWidget() = 0;

+ };

+

+}

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

+ public WhiteboardWindowFactory,

+ public HighlightEditorWidgetFactory {

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <vector>

+#include <string>

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

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

+

+using namespace Swift;

+

+class HighlightRuleTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(HighlightRuleTest);

+ CPPUNIT_TEST(testEmptyRuleNeverMatches);

+ CPPUNIT_TEST(testKeyword);

+ CPPUNIT_TEST(testNickKeyword);

+ CPPUNIT_TEST(testNickWithoutOtherKeywords);

+ CPPUNIT_TEST(testSender);

+ CPPUNIT_TEST(testSenderAndKeyword);

+ CPPUNIT_TEST(testWholeWords);

+ CPPUNIT_TEST(testCase);

+ CPPUNIT_TEST(testWholeWordsAndCase);

+ CPPUNIT_TEST(testMUC);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

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

+ keywords.push_back("keyword1");

+ keywords.push_back("KEYWORD2");

+

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

+ senders.push_back("sender1");

+ senders.push_back("SENDER2");

+

+ emptyRule = new HighlightRule();

+

+ keywordRule = new HighlightRule();

+ keywordRule->setKeywords(keywords);

+

+ keywordChatRule = new HighlightRule();

+ keywordChatRule->setKeywords(keywords);

+ keywordChatRule->setMatchChat(true);

+

+ keywordNickChatRule = new HighlightRule();

+ keywordNickChatRule->setKeywords(keywords);

+ keywordNickChatRule->setNickIsKeyword(true);

+ keywordNickChatRule->setMatchChat(true);

+

+ nickChatRule = new HighlightRule();

+ nickChatRule->setNickIsKeyword(true);

+ nickChatRule->setMatchChat(true);

+

+ nickRule = new HighlightRule();

+ nickRule->setNickIsKeyword(true);

+

+ senderRule = new HighlightRule();

+ senderRule->setSenders(senders);

+

+ senderChatRule = new HighlightRule();

+ senderChatRule->setSenders(senders);

+ senderChatRule->setMatchChat(true);

+

+ senderKeywordChatRule = new HighlightRule();

+ senderKeywordChatRule->setSenders(senders);

+ senderKeywordChatRule->setKeywords(keywords);

+ senderKeywordChatRule->setMatchChat(true);

+

+ senderKeywordNickChatRule = new HighlightRule();

+ senderKeywordNickChatRule->setSenders(senders);

+ senderKeywordNickChatRule->setKeywords(keywords);

+ senderKeywordNickChatRule->setNickIsKeyword(true);

+ senderKeywordNickChatRule->setMatchChat(true);

+

+ senderKeywordNickWordChatRule = new HighlightRule();

+ senderKeywordNickWordChatRule->setSenders(senders);

+ senderKeywordNickWordChatRule->setKeywords(keywords);

+ senderKeywordNickWordChatRule->setNickIsKeyword(true);

+ senderKeywordNickWordChatRule->setMatchWholeWords(true);

+ senderKeywordNickWordChatRule->setMatchChat(true);

+

+ senderKeywordNickCaseChatRule = new HighlightRule();

+ senderKeywordNickCaseChatRule->setSenders(senders);

+ senderKeywordNickCaseChatRule->setKeywords(keywords);

+ senderKeywordNickCaseChatRule->setNickIsKeyword(true);

+ senderKeywordNickCaseChatRule->setMatchCase(true);

+ senderKeywordNickCaseChatRule->setMatchChat(true);

+

+ senderKeywordNickCaseWordChatRule = new HighlightRule();

+ senderKeywordNickCaseWordChatRule->setSenders(senders);

+ senderKeywordNickCaseWordChatRule->setKeywords(keywords);

+ senderKeywordNickCaseWordChatRule->setNickIsKeyword(true);

+ senderKeywordNickCaseWordChatRule->setMatchCase(true);

+ senderKeywordNickCaseWordChatRule->setMatchWholeWords(true);

+ senderKeywordNickCaseWordChatRule->setMatchChat(true);

+

+ senderKeywordNickMUCRule = new HighlightRule();

+ senderKeywordNickMUCRule->setSenders(senders);

+ senderKeywordNickMUCRule->setKeywords(keywords);

+ senderKeywordNickMUCRule->setNickIsKeyword(true);

+ senderKeywordNickMUCRule->setMatchMUC(true);

+ }

+

+ void tearDown() {

+ delete emptyRule;

+

+ delete keywordRule;

+ delete keywordChatRule;

+ delete keywordNickChatRule;

+ delete nickChatRule;

+ delete nickRule;

+

+ delete senderRule;

+ delete senderChatRule;

+ delete senderKeywordChatRule;

+ delete senderKeywordNickChatRule;

+

+ delete senderKeywordNickWordChatRule;

+ delete senderKeywordNickCaseChatRule;

+ delete senderKeywordNickCaseWordChatRule;

+

+ delete senderKeywordNickMUCRule;

+ }

+

+ void testEmptyRuleNeverMatches() {

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

+ CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "from", "nick", HighlightRule::MUCMessage), false);

+

+ CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "from", "", HighlightRule::ChatMessage), false);

+ CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "from", "", HighlightRule::MUCMessage), false);

+

+ CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "", "nick", HighlightRule::ChatMessage), false);

+ CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "", "nick", HighlightRule::MUCMessage), false);

+

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

+ CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "from", "nick", HighlightRule::MUCMessage), false);

+

+ CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "", "", HighlightRule::ChatMessage), false);

+ CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("body", "", "", HighlightRule::MUCMessage), false);

+

+ CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "from", "", HighlightRule::ChatMessage), false);

+ CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "from", "", HighlightRule::MUCMessage), false);

+

+ CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "", "nick", HighlightRule::ChatMessage), false);

+ CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "", "nick", HighlightRule::MUCMessage), false);

+

+ CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "", "", HighlightRule::ChatMessage), false);

+ CPPUNIT_ASSERT_EQUAL(emptyRule->isMatch("", "", "", HighlightRule::MUCMessage), false);

+ }

+

+ void testKeyword() {

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

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

+

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

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

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

+

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

+

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

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

+

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

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

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

+

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

+ }

+

+ void testNickKeyword() {

+ CPPUNIT_ASSERT_EQUAL(keywordNickChatRule->isMatch("body contains nick", "from", "nick", HighlightRule::ChatMessage), true);

+ CPPUNIT_ASSERT_EQUAL(keywordNickChatRule->isMatch("body contains nick", "from", "nick", HighlightRule::MUCMessage), false);

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

+

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

+

+ CPPUNIT_ASSERT_EQUAL(keywordNickChatRule->isMatch("body", "sender contains nick", "nick", HighlightRule::ChatMessage), false);

+

+ CPPUNIT_ASSERT_EQUAL(keywordNickChatRule->isMatch("body contains mixed-case NiCk", "sender", "nick", HighlightRule::ChatMessage), true);

+

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

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

+

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

+ }

+

+ void testNickWithoutOtherKeywords() {

+ CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("body contains nick", "from", "nick", HighlightRule::ChatMessage), true);

+ CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("body contains nick", "from", "nick", HighlightRule::MUCMessage), false);

+ CPPUNIT_ASSERT_EQUAL(nickRule->isMatch("body contains nick", "from", "nick", HighlightRule::ChatMessage), false);

+

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

+

+ CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("body", "sender contains nick but it does't matter", "nick", HighlightRule::ChatMessage), false);

+

+ CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("body contains mixed-case NiCk", "from", "nick", HighlightRule::ChatMessage), true);

+

+ CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("nickname", "from", "nick", HighlightRule::ChatMessage), true);

+ CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("NIckNAME", "from", "nick", HighlightRule::ChatMessage), true);

+

+ // there are no keywords in this rule and empty nick is not treated as a keyword, so we don't check for keywords to get a match

+ CPPUNIT_ASSERT_EQUAL(nickChatRule->isMatch("body", "from", "", HighlightRule::ChatMessage), true);

+ }

+

+ void testSender() {

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

+ CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "from", "nick", HighlightRule::MUCMessage), false);

+

+ CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "sender1", "nick", HighlightRule::ChatMessage), true);

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

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

+

+ CPPUNIT_ASSERT_EQUAL(senderRule->isMatch("body contains sender1", "from", "nick", HighlightRule::ChatMessage), false);

+

+ CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "abc sender1 xyz", "nick", HighlightRule::ChatMessage), true);

+ CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "abcsender1xyz", "nick", HighlightRule::ChatMessage), true);

+

+ CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "SENDer1", "nick", HighlightRule::ChatMessage), true);

+ CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "abc SENDer1 xyz", "nick", HighlightRule::ChatMessage), true);

+ CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "abcSENDer1xyz", "nick", HighlightRule::ChatMessage), true);

+

+ CPPUNIT_ASSERT_EQUAL(senderChatRule->isMatch("body", "sender2", "nick", HighlightRule::ChatMessage), true);

+ }

+

+ void testSenderAndKeyword() {

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

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

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

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

+ }

+

+ void testWholeWords() {

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

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

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

+

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

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

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

+

+ CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("body contains nick", "sender1", "nick", HighlightRule::ChatMessage), true);

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

+

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

+ CPPUNIT_ASSERT_EQUAL(senderKeywordNickWordChatRule->isMatch("body contains NiCk", "sender1", "nick", HighlightRule::ChatMessage), true);

+ }

+

+ void testCase() {

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

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

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

+

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

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

+

+ CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("body contains nick", "sender1", "nick", HighlightRule::ChatMessage), true);

+ CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseChatRule->isMatch("body contains xnick", "sender1", "nick", HighlightRule::ChatMessage), true);

+

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

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

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

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

+ }

+

+ void testWholeWordsAndCase() {

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

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

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

+

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

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

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

+

+ CPPUNIT_ASSERT_EQUAL(senderKeywordNickCaseWordChatRule->isMatch("body contains nick", "sender1", "nick", HighlightRule::ChatMessage), true);

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

+

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

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

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

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

+ }

+

+ void testMUC() {

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

+

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

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

+ CPPUNIT_ASSERT_EQUAL(senderKeywordNickMUCRule->isMatch("body contains nick", "sender1", "nick", HighlightRule::MUCMessage), true);

+ }

+

+ private:

+ HighlightRule* emptyRule;

+

+ HighlightRule* keywordRule;

+ HighlightRule* keywordChatRule;

+ HighlightRule* keywordNickChatRule;

+ HighlightRule* nickChatRule;

+ HighlightRule* nickRule;

+

+ HighlightRule* senderRule;

+ HighlightRule* senderChatRule;

+ HighlightRule* senderKeywordChatRule;

+ HighlightRule* senderKeywordNickChatRule;

+

+ HighlightRule* senderKeywordNickWordChatRule;

+ HighlightRule* senderKeywordNickCaseChatRule;

+ HighlightRule* senderKeywordNickCaseWordChatRule;

+

+ HighlightRule* senderKeywordNickMUCRule;

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(HighlightRuleTest);

+ virtual std::string addMessage(const std::string& message, const std::string& /*senderName*/, bool /*senderIsSelf*/, boost::shared_ptr<SecurityLabel> /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime&, const HighlightAction&) {lastMessageBody_ = message; return "";}

+ virtual std::string addAction(const std::string& message, const std::string& /*senderName*/, bool /*senderIsSelf*/, boost::shared_ptr<SecurityLabel> /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime&, const HighlightAction&) {lastMessageBody_ = message; return "";}

+ virtual void replaceMessage(const std::string&, const std::string&, const boost::posix_time::ptime&, const HighlightAction&) {}

+ virtual void replaceWithAction(const std::string& /*message*/, const std::string& /*id*/, const boost::posix_time::ptime& /*time*/, const HighlightAction&) {}