+#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 <boost/numeric/conversion/cast.hpp>

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

+ dateChangeTimer_ = boost::shared_ptr<Timer>(timerFactory_->createTimer(boost::numeric_cast<int>(millisecondsUntilMidnight)));

+ return boost::numeric_cast<int>(targetedUnreadMessages_.size());

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

+ chatWindow_->setUnreadMessageCount(boost::numeric_cast<int>(unreadMessages_.size()));

+ postHandleIncomingMessage(messageEvent, highlight);

+ assert(false);

+ chatWindow_->setUnreadMessageCount(boost::numeric_cast<int>(unreadMessages_.size()));

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

+ virtual void setToJID(const JID& jid) {toJID_ = jid;}

+ 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 postSendMessage(const std::string&, boost::shared_ptr<Stanza>) {}

+ virtual void preHandleIncomingMessage(boost::shared_ptr<MessageEvent>) {}

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

+ virtual void preSendMessageRequest(boost::shared_ptr<Message>) {}

+ virtual void dayTicked() {}

+ 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/UIEvents/ShowProfileForRosterItemUIEvent.h>

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

+ actions.push_back(ChatWindow::ShowProfile);

+ case ChatWindow::ShowProfile: events_->send(boost::make_shared<ShowProfileForRosterItemUIEvent>(mucJID));break;

+#pragma clang diagnostic push

+#pragma clang diagnostic ignored "-Wswitch-enum"

+

+ setNick(rejoinNick);

+#pragma clang diagnostic pop

+

+ setNick(nick);

+ assert(false);

+ assert(false);

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

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

+ highlighter_->handleHighlightAction(highlight);

+ }

+ setNick(desiredNick_);

+ case PartThenJoin: break;

+ case JoinThenPart: break;

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

+ NickJoinPart(const std::string& nick, JoinPart type) : nick(nick), type(type) {}

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

+ MockChatListWindow() {}

+ virtual ~MockChatListWindow() {}

+ void addWhiteboardSession(const ChatListWindow::Chat& /*chat*/) {}

+ void removeWhiteboardSession(const JID& /*jid*/) {}

+ void playSound(SoundEffect sound) {}

+ void setUnreadMessages(bool some) {}

+ void setStatusType(StatusShow::Type type) {}

+#include <boost/filesystem.hpp>

+ assert(false);

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

+

+ completedBytes += boost::numeric_cast<boost::uintmax_t>(processedBytes);

+/*

+ * 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 && static_cast<size_t>(index) < rules_.size());

+ return rules_[static_cast<size_t>(index)];

+}

+

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

+{

+ assert(index >= 0 && static_cast<size_t>(index) < rules_.size());

+ rules_[static_cast<size_t>(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;

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

+ };

+

+}

+/*

+ * Copyright (c) 2013 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

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

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

+ showProfileController_ = NULL;

+

+ highlightManager_ = new HighlightManager(settings_);

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

+

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

+ delete highlightEditorController_;

+ delete highlightManager_;

+ delete showProfileController_;

+ showProfileController_ = NULL;

+ showProfileController_ = new ShowProfileController(client_->getVCardManager(), uiFactory_, uiEventStream_);

+ srand(static_cast<unsigned int>(time(NULL)));

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

+

+ assert(chatsManager_);

+ class ShowProfileController;

+ class HighlightManager;

+ class HighlightEditorController;

+ ShowProfileController* showProfileController_;

+ HighlightManager* highlightManager_;

+ HighlightEditorController* highlightEditorController_;

+ profileWindow->setEditable(true);

+ case StatusShow::Online: return StatusShow::Online;

+ case StatusShow::Away: return StatusShow::Away;

+ case StatusShow::XA: return StatusShow::Away;

+ case StatusShow::FFC: return StatusShow::Online;

+ case StatusShow::DND: return StatusShow::DND;

+ case StatusShow::None: return StatusShow::None;

+ * Copyright (c) 2011-2013 Remko Tronçon

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

+ size_t width = static_cast<size_t>(std::distance(xBegin, xEnd) + 1);

+ size_t height = static_cast<size_t>(std::distance(yBegin, yEnd) + 1);

+ result[i + j*width] = predicate(*(xBegin + boost::numeric_cast<long long>(i)-1), *(yBegin + boost::numeric_cast<long long >(j)-1)) ? result[(i-1) + (j-1)*width] + 1 : std::max(result[i + (j-1)*width], result[i-1 + (j*width)]);

+ updates.push_back(static_cast<size_t>(std::distance(x.begin(), xBegin)));

+ postUpdates.push_back(static_cast<size_t>(std::distance(y.begin(), yBegin)));

+ size_t prefixLength = static_cast<size_t>(std::distance(x.begin(), xBegin));

+ updates.push_back(static_cast<size_t>(std::distance(x.begin(), xEnd.base()) - 1));

+ postUpdates.push_back(static_cast<size_t>(std::distance(y.begin(), yEnd.base()) - 1));

+ size_t xLength = static_cast<size_t>(std::distance(xBegin, xEnd.base()));

+ size_t yLength = static_cast<size_t>(std::distance(yBegin, yEnd.base()));

+ size_t width = xLength + 1;

+ size_t oldDisplayedSize = group->getDisplayedChildren().size();

+ size_t newDisplayedSize = group->getDisplayedChildren().size();

+ void addFilter(RosterFilter *filter) {filters_.push_back(filter);filterAll();}

+ std::vector<RosterFilter*> getFilters() {return filters_;}

+ MainWindow* getWindow() {return mainWindow_;}

+ RosterItemOperation(bool requiresLookup = false, const JID& lookupJID = JID()) : requiresLookup_(requiresLookup), lookupJID_(lookupJID) {}

+ virtual ~RosterItemOperation() {}

+ bool requiresLookup() const {return requiresLookup_;}

+ const JID& lookupJID() const {return lookupJID_;}

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

+ std::transform(itemInserts.begin(), itemInserts.end(), update.insertedRows.begin() + boost::numeric_cast<long long>(end), CreateIndexForSection(sectionPostUpdates[i]));

+ std::transform(itemRemoves.begin(), itemRemoves.end(), update.deletedRows.begin() + boost::numeric_cast<long long>(end), CreateIndexForSection(sectionUpdates[i]));

+ std::transform(itemUpdates.begin(), itemUpdates.end(), update.updatedRows.begin() + boost::numeric_cast<long long>(end), CreateIndexForSection(sectionPostUpdates[i]));

+ }

+ }

+ }

+ }

+ }

+ }

+ }

+ }

+ }

+ }

+std::ostream& operator<<(std::ostream& os, const Swift::TableRoster::Index& i);

+

+ "ShowProfileController.cpp",

+ "WhiteboardManager.cpp",

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

+ }

+ }

+ }

+ }

+ }

+ }

+ SettingsProviderHierachyTest() : setting1("somekey", 42) {}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "ShowProfileController.h"

+

+#include <boost/bind.hpp>

+

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

+#include <Swiften/VCards/VCardManager.h>

+

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

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

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

+

+namespace Swift {

+

+ShowProfileController::ShowProfileController(VCardManager* vcardManager, ProfileWindowFactory* profileWindowFactory, UIEventStream* uiEventStream) : vcardManager(vcardManager), profileWindowFactory(profileWindowFactory), uiEventStream(uiEventStream) {

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

+ vcardManager->onVCardChanged.connect(boost::bind(&ShowProfileController::handleVCardChanged, this, _1, _2));

+}

+

+ShowProfileController::~ShowProfileController() {

+ typedef std::pair<JID, ProfileWindow*> JIDProfileWindowPair;

+ foreach(const JIDProfileWindowPair& jidWndPair, openedProfileWindows) {

+ jidWndPair.second->onWindowClosed.disconnect(boost::bind(&ShowProfileController::handleProfileWindowClosed, this, _1));

+ delete jidWndPair.second;

+ }

+

+ vcardManager->onVCardChanged.disconnect(boost::bind(&ShowProfileController::handleVCardChanged, this, _1, _2));

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

+}

+

+void ShowProfileController::handleUIEvent(UIEvent::ref event) {

+ ShowProfileForRosterItemUIEvent::ref showProfileEvent = boost::dynamic_pointer_cast<ShowProfileForRosterItemUIEvent>(event);

+ if (!showProfileEvent) {

+ return;

+ }

+

+ if (openedProfileWindows.find(showProfileEvent->getJID()) == openedProfileWindows.end()) {

+ ProfileWindow* newProfileWindow = profileWindowFactory->createProfileWindow();

+ newProfileWindow->setJID(showProfileEvent->getJID());

+ newProfileWindow->onWindowClosed.connect(boost::bind(&ShowProfileController::handleProfileWindowClosed, this, _1));

+ openedProfileWindows[showProfileEvent->getJID()] = newProfileWindow;

+ VCard::ref vcard = vcardManager->getVCardAndRequestWhenNeeded(showProfileEvent->getJID());

+ if (vcard) {

+ newProfileWindow->setVCard(vcard);

+ } else {

+ newProfileWindow->setProcessing(true);

+ }

+ newProfileWindow->show();

+ } else {

+ openedProfileWindows[showProfileEvent->getJID()]->show();

+ }

+}

+

+void ShowProfileController::handleVCardChanged(const JID& jid, VCard::ref vcard) {

+ if (openedProfileWindows.find(jid) == openedProfileWindows.end()) {

+ return;

+ }

+

+ ProfileWindow* profileWindow = openedProfileWindows[jid];

+ profileWindow->setVCard(vcard);

+ profileWindow->setProcessing(false);

+ profileWindow->show();

+}

+

+void ShowProfileController::handleProfileWindowClosed(const JID& profileJid) {

+ ProfileWindow* profileWindow = openedProfileWindows[profileJid];

+ openedProfileWindows.erase(profileJid);

+ delete profileWindow;

+}

+

+}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <Swiften/JID/JID.h>

+#include <Swiften/Elements/VCard.h>

+

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

+

+namespace Swift {

+ class VCardManager;

+ class ProfileWindow;

+ class ProfileWindowFactory;

+ class UIEventStream;

+

+ class ShowProfileController {

+ public:

+ ShowProfileController(VCardManager* vcardManager, ProfileWindowFactory* profileWindowFactory, UIEventStream* uiEventStream);

+ ~ShowProfileController();

+

+ private:

+ void handleUIEvent(UIEvent::ref event);

+ void handleVCardChanged(const JID&, VCard::ref);

+ void handleProfileWindowClosed(const JID& profileJid);

+

+ private:

+ VCardManager* vcardManager;

+ ProfileWindowFactory* profileWindowFactory;

+ UIEventStream* uiEventStream;

+ std::map<JID, ProfileWindow*> openedProfileWindows;

+ };

+}

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

+ bool getSoundEnabled() {return playSounds_;}

+ void handleHighlight(const HighlightAction& action);

+ HighlightManager* highlightManager_;

+#include <string>

+

+ virtual ~SoundPlayer() {}

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

+/*

+ * Copyright (c) 2012 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

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

+#include <boost/lexical_cast.hpp>

+#include <boost/filesystem/fstream.hpp>

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

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

+

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

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

+#include <SwifTools/Application/ApplicationPathProvider.h>

+

+namespace lambda = boost::lambda;

+

+namespace Swift {

+

+static const size_t MAX_ENTRIES = 200;

+

+StatusCache::StatusCache(ApplicationPathProvider* paths) {

+ paths_ = paths;

+ path_ = paths_->getDataDir() / "StatusCache";

+ loadRecents();

+}

+

+StatusCache::~StatusCache() {

+

+}

+

+std::vector<StatusCache::PreviousStatus> StatusCache::getMatches(const std::string& substring, size_t maxCount) const {

+ std::vector<PreviousStatus> matches;

+ foreach (const PreviousStatus& status, previousStatuses_) {

+ if (substring.empty() || (boost::algorithm::ifind_first(status.first, substring) && substring != status.first)) {

+ matches.push_back(status);

+ if (matches.size() == maxCount) {

+ break;

+ }

+ }

+ }

+ return matches;

+}

+

+void StatusCache::addRecent(const std::string& text, StatusShow::Type type) {

+ if (text.empty()) {

+ return;

+ }

+ previousStatuses_.remove_if(lambda::bind(&PreviousStatus::first, lambda::_1) == text && lambda::bind(&PreviousStatus::second, lambda::_1) == type);

+ previousStatuses_.push_front(PreviousStatus(text, type));

+ for (size_t i = previousStatuses_.size(); i > MAX_ENTRIES; i--) {

+ previousStatuses_.pop_back();

+ }

+ saveRecents();

+}

+

+void StatusCache::loadRecents() {

+ try {

+ if (boost::filesystem::exists(path_)) {

+ ByteArray data;

+ readByteArrayFromFile(data, path_.string());

+ std::string stringData = byteArrayToString(data);

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

+ boost::split(lines, stringData, boost::is_any_of("\n"));

+ foreach (const std::string& line, lines) {

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

+ boost::split(bits, line, boost::is_any_of("\t"));

+ if (bits.size() < 2) {

+ continue;

+ }

+ StatusShow::Type type;

+ type = static_cast<StatusShow::Type>(boost::lexical_cast<size_t>(bits[0]));

+ previousStatuses_.push_back(PreviousStatus(boost::trim_copy(bits[1]), type));

+ }

+ }

+ }

+ catch (const boost::filesystem::filesystem_error& e) {

+ std::cerr << "ERROR: " << e.what() << std::endl;

+ }

+}

+

+void StatusCache::saveRecents() {

+ try {

+ if (!boost::filesystem::exists(path_.parent_path())) {

+ boost::filesystem::create_directories(path_.parent_path());

+ }

+ boost::filesystem::ofstream file(path_);

+ foreach (const PreviousStatus& recent, previousStatuses_) {

+ std::string message = recent.first;

+ boost::replace_all(message, "\t", " ");

+ file << recent.second << "\t" << message << std::endl;

+ }

+ file.close();

+ }

+ catch (const boost::filesystem::filesystem_error& e) {

+ std::cerr << "ERROR: " << e.what() << std::endl;

+ }

+}

+

+}

+

+

+

+

+/*

+ * Copyright (c) 2012 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <string>

+#include <utility>

+#include <vector>

+#include <list>

+#include <iostream>

+

+#include <boost/filesystem/path.hpp>

+

+#include <Swiften/Elements/StatusShow.h>

+

+namespace Swift {

+ class ApplicationPathProvider;

+ class StatusCache {

+ public:

+ typedef std::pair<std::string, StatusShow::Type> PreviousStatus;

+ public:

+ StatusCache(ApplicationPathProvider* paths);

+ ~StatusCache();

+

+ std::vector<PreviousStatus> getMatches(const std::string& substring, size_t maxCount) const;

+ void addRecent(const std::string& text, StatusShow::Type type);

+ private:

+ void saveRecents();

+ void loadRecents();

+ private:

+ boost::filesystem::path path_;

+ std::list<PreviousStatus> previousStatuses_;

+ ApplicationPathProvider* paths_;

+ };

+}

+

+

+#include <cassert>

+ assert(false);

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

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

+ file.write(reinterpret_cast<const char*>(vecptr(data)), boost::numeric_cast<std::streamsize>(data.size()));

+ virtual ~SystemTray(){}

+static struct DefaultTranslator : public Translator {

+ AddContactUIEvent(const JID& jid, const std::string& name, const std::set<std::string>& groups) : jid_(jid), name_(name), groups_(groups) {}

+ }

+ }

+ AddMUCBookmarkUIEvent(const MUCBookmark& bookmark) : bookmark(bookmark) {}

+ EditMUCBookmarkUIEvent(const MUCBookmark& oldBookmark, const MUCBookmark& newBookmark) : oldBookmark(oldBookmark) , newBookmark(newBookmark) {}

+ const MUCBookmark& getOldBookmark() {return oldBookmark;}

+ const MUCBookmark& getNewBookmark() {return newBookmark;}

+ JoinMUCUIEvent(const JID& jid, const boost::optional<std::string>& password = boost::optional<std::string>(), const boost::optional<std::string>& nick = boost::optional<std::string>(), bool joinAutomaticallyInFuture = false, bool createAsReservedRoomIfNew = false) : jid_(jid), nick_(nick), joinAutomatically_(joinAutomaticallyInFuture), createAsReservedRoomIfNew_(createAsReservedRoomIfNew), password_(password) {}

+ RemoveMUCBookmarkUIEvent(const MUCBookmark& bookmark) : bookmark(bookmark) {}

+ RemoveRosterItemUIEvent(const JID& jid) : jid_(jid) {}

+ virtual ~RemoveRosterItemUIEvent() {}

+ JID getJID() {return jid_;}

+ RequestAdHocUIEvent(const DiscoItems::Item& command) : command_(command) {}

+ RequestAddUserDialogUIEvent(const JID& predefinedJID, const std::string& predefinedName) : preJID_(predefinedJID), preName_(predefinedName) {}

+ RequestAddUserDialogUIEvent() : preJID_(), preName_() {}

+ const JID& getPredefinedJID() const { return preJID_; }

+ const std::string& getPredefinedName() const { return preName_; }

+ RequestChatUIEvent(const JID& contact) : contact_(contact) {}

+/*

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

+ };

+

+}

+ RequestWhiteboardUIEvent(const JID& contact) : contact_(contact) {}

+/*

+ * Copyright (c) 2012 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <Swiften/JID/JID.h>

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

+

+namespace Swift {

+

+class ShowProfileForRosterItemUIEvent : public UIEvent {

+ public:

+ typedef boost::shared_ptr<ShowProfileForRosterItemUIEvent> ref;

+ public:

+ ShowProfileForRosterItemUIEvent(const JID& jid) : jid_(jid) {}

+ virtual ~ShowProfileForRosterItemUIEvent() {}

+ JID getJID() const {return jid_;}

+ private:

+ JID jid_;

+};

+

+}

+ ShowWhiteboardUIEvent(const JID& contact) : contact_(contact) {}

+ }

+ virtual ~AdHocCommandWindow() {}

+ }

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

+ enum OccupantAction {Kick, Ban, MakeModerator, MakeParticipant, MakeVisitor, AddContact, ShowProfile};

+ virtual ~ChatWindow() {}

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

+ virtual ~ChatWindowFactory() {}

+ virtual ~ContactEditWindowFactory() {}

+ virtual ~EventWindow() {}

+ virtual ~EventWindowFactory() {}

+/*

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

+ };

+

+}

+ virtual ~HistoryWindow() {}

+ virtual ~HistoryWindowFactory() {}

+ virtual ~InviteToChatWindow() {}

+ virtual ~JoinMUCWindow() {}

+ virtual ~JoinMUCWindowFactory() {}

+ virtual ~LoginWindow() {}

+ virtual ~LoginWindowFactory() {}

+ virtual ~MUCSearchWindow() {}

+ virtual ~MUCSearchWindowFactory() {}

+ virtual ~MainWindow() {}

+ virtual ~MainWindowFactory() {}

+ class JID;

+

+ virtual ~ProfileWindow() {}

+ virtual void setJID(const JID& jid) = 0;

+ virtual void setEditable(bool b) = 0;

+ boost::signal<void (const JID&)> onWindowClosed;

+ virtual ~ProfileWindowFactory() {}

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

+ public WhiteboardWindowFactory,

+ public HighlightEditorWidgetFactory {

+ virtual ~UserSearchWindowFactory() {}

+ virtual ~WhiteboardWindowFactory() {}

+ virtual ~XMLConsoleWidgetFactory() {}

+ ChatMessageSummarizerTest() {}

+/*

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

+ MockChatWindow() : labelsEnabled_(false) {}

+ 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 addSystemMessage(const std::string& /*message*/) {}

+ virtual void addErrorMessage(const std::string& /*message*/) {}

+ virtual void addPresenceMessage(const std::string& /*message*/) {}

+ virtual std::string addFileTransfer(const std::string& /*senderName*/, bool /*senderIsSelf*/,const std::string& /*filename*/, const boost::uintmax_t /*sizeInBytes*/) { return 0; }

+ virtual void setFileTransferProgress(std::string /*id*/, const int /*alreadyTransferedBytes*/) { }

+ virtual void setFileTransferStatus(std::string /*id*/, const FileTransferState /*state*/, const std::string& /*msg*/) { }

+ virtual void setContactChatState(ChatState::ChatStateType /*state*/) {}

+ virtual void setName(const std::string& name) {name_ = name;}

+ virtual void show() {}

+ virtual void activate() {}

+ virtual void setAvailableSecurityLabels(const std::vector<SecurityLabelsCatalog::Item>& labels) {labels_ = labels;}

+ virtual void setSecurityLabelsEnabled(bool enabled) {labelsEnabled_ = enabled;}

+ virtual void setUnreadMessageCount(int /*count*/) {}

+ virtual void convertToMUC() {}

+ virtual void setSecurityLabelsError() {}

+ virtual void setInputEnabled(bool /*enabled*/) {}

+ virtual void setRosterModel(Roster* /*roster*/) {}

+ virtual void setTabComplete(TabComplete*) {}

+ virtual void replaceLastMessage(const std::string&) {}

+ 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&) {}

+ void setAckState(const std::string& /*id*/, AckState /*state*/) {}

+ virtual void flash() {}

+ virtual void setAlert(const std::string& /*alertText*/, const std::string& /*buttonText*/) {}

+ virtual void cancelAlert() {}

+ virtual void addMUCInvitation(const std::string& /*senderName*/, const JID& /*jid*/, const std::string& /*reason*/, const std::string& /*password*/, bool = true) {}

+ virtual std::string addWhiteboardRequest(bool) {return "";}

+ virtual void setWhiteboardSessionStatus(std::string, const ChatWindow::WhiteboardSessionState){}

+ virtual void setAvailableRoomActions(const std::vector<RoomAction> &) {}

+ MockMainWindow() : roster(NULL) {}

+ virtual ~MockMainWindow() {}

+ virtual void setRosterModel(Roster* roster) {this->roster = roster;}

+ virtual void setMyNick(const std::string& /*name*/) {}

+ virtual void setMyJID(const JID& /*jid*/) {}

+ virtual void setMyAvatarPath(const std::string& /*path*/) {}

+ virtual void setMyStatusText(const std::string& /*status*/) {}

+ virtual void setMyStatusType(StatusShow::Type /*type*/) {}

+ virtual void setAvailableAdHocCommands(const std::vector<DiscoItems::Item>& /*commands*/) {}

+ virtual void setConnecting() {}

+ MockMainWindowFactory() : last(NULL) {}

+ virtual ~MockMainWindowFactory() {}

+ virtual MainWindow* createMainWindow(UIEventStream*) {last = new MockMainWindow();return last;}

+ ErrorEvent(const JID& jid, const std::string& text) : jid_(jid), text_(text){}

+ virtual ~ErrorEvent(){}

+ const JID& getJID() const {return jid_;}

+ const std::string& getText() const {return text_;}

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

+ onEventQueueLengthChange(boost::numeric_cast<int>(events_.size()));

+ onEventQueueLengthChange(boost::numeric_cast<int>(events_.size()));

+ MessageEvent(boost::shared_ptr<Message> stanza) : stanza_(stanza), targetsMe_(true) {}

+ StanzaEvent() : time_(boost::posix_time::microsec_clock::universal_time()) {concluded_ = false;}

+ virtual ~StanzaEvent() {}

+ void conclude() {concluded_ = true; onConclusion();}

+ bool getConcluded() {return concluded_;}

+ SubscriptionRequestEvent(const JID& jid, const std::string& reason) : jid_(jid), reason_(reason){}

+ virtual ~SubscriptionRequestEvent(){}

+ const JID& getJID() const {return jid_;}

+ const std::string& getReason() const {return reason_;}

+ }

+ }