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

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

+ * Copyright (c) 2010-2014 Kevin Smith

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

+ * Copyright (c) 2010-2014 Kevin Smith

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

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

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

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

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

+ * Copyright (c) 2010-2014 Kevin Smith

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

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

+ boost::shared_ptr<ChatMessageParser> chatMessageParser_;

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

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

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

+ /* do emoticon substitution */

+ parsedMessage = emoticonHighlight(parsedMessage);

+

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

+ /* do word-based color highlighting */

+ parsedMessage = splitHighlight(parsedMessage);

+ }

+

+ return parsedMessage;

+ }

+

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

+ {

+ ChatWindow::ChatMessage parsedMessage = message;

+

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

+ {

+ ChatWindow::ChatMessage parsedMessage = message;

+

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

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

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

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

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

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

+ }

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

+ ChatWindow::ChatMessage newMessage;

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

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

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

+ try {

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

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

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

+ while (regex_search(start, text.end(), match, regex)) {

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

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

+ if (start != matchStart) {

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

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

+ }

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

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

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

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

+ newMessage.append(highlightPart);

+ start = matchEnd;

+ }

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

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

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

+ }

+ }

+ catch (std::runtime_error) {

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

+ newMessage.append(part);

+ }

+ } else {

+ newMessage.append(part);

+ }

+ }

+ parsedMessage = newMessage;

+ }

+ }

+

+ return parsedMessage;

+ }

+ * Copyright (c) 2013-2014 Kevin Smith

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

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

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

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

+ HighlightRulesListPtr highlightRules_;

+ bool mucMode_;

+ emoticons_(emoticons),

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

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

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

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

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

+ boost::shared_ptr<ChatMessageParser> chatMessageParser,

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

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

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

+ CPPUNIT_ASSERT_EQUAL(text, part->text);

+ }

+

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

+ {

+ HighlightRule rule;

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

+ keywords.push_back(keyword);

+ rule.setKeywords(keywords);

+ rule.setMatchCase(matchCase);

+ rule.setMatchWholeWords(matchWholeWord);

+ rule.setMatchChat(true);

+ return rule;

+ }

+

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

+ {

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

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

+ return list;

+ }

+

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

+ {

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

+ list->addRule(rule1);

+ list->addRule(rule2);

+ return list;

+ }

+

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

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

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

+ assertText(result, 0, no_special_message);

+

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

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

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

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

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

+ assertText(result, 9, " ");

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

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

+

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

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

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

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

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

+

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

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

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

+

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

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

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

+

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

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

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

+

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

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

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

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

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

+

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

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

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

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

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

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

+

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

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

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

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

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

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

+

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

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

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

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

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

+

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

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

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

+

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

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

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

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

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

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

+

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

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

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

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

+

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

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

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

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

+

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

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

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

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

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

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

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

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

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

+ * Copyright (c) 2010-2014 Kevin Smith

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

+ boost::shared_ptr<ChatMessageParser> chatMessageParser_;

+/*

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

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

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

+

+ /**

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

+ */

+ /**

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

+ */

+ /**

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

+ */

+ friend class boost::serialization::access;

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

+

+ template<class Archive>

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

+ {

+ ar & highlightText_;

+ ar & textColor_;

+ ar & textBackground_;

+ ar & playSound_;

+ ar & soundFile_;

+ }

+

+/*

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

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

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

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

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

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

+ delete highlightEditorWindow_;

+ highlightEditorWindow_ = NULL;

+ if (!highlightEditorWindow_) {

+ highlightEditorWindow_ = highlightEditorWindowFactory_->createHighlightEditorWindow();

+ highlightEditorWindow_->setHighlightManager(highlightManager_);

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

+ highlightEditorWindow_->show();

+ }

+}

+

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

+{

+ if (contactSuggester_) {

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

+/*

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

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+ class HighlightEditorWindowFactory;

+ class HighlightEditorWindow;

+ class ContactSuggester;

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

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

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

+ HighlightEditorWindowFactory* highlightEditorWindowFactory_;

+ HighlightEditorWindow* highlightEditorWindow_;

+ ContactSuggester* contactSuggester_;

+/*

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

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

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

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

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

+ std::stringstream stream;

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

+ archive << rules_->list_;

+ return stream.str();

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

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

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

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

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

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

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

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

+}

+

+void HighlightManager::storeSettings()

+{

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

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

+ storingSettings_ = false;

+}

+

+void HighlightManager::loadSettings()

+{

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

+ std::stringstream stream;

+ stream << rulesString;

+ try {

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

+ archive >> rules_->list_;

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

+ rules_->list_ = getDefaultRules();

+ }

+/*

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

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+

+ class HighlightRulesList {

+ public:

+ friend class HighlightManager;

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

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

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

+ void combineRules(const HighlightRulesList &rhs) {

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

+ }

+ private:

+ std::vector<HighlightRule> list_;

+ };

+

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

+

+ void storeSettings();

+ void loadSettings();

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

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

+

+/*

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

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+/*

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

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

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

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

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

+ friend class boost::serialization::access;

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

+

+ template<class Archive>

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

+ {

+ ar & senders_;

+ ar & keywords_;

+ ar & nickIsKeyword_;

+ ar & matchChat_;

+ ar & matchMUC_;

+ ar & matchCase_;

+ ar & matchWholeWords_;

+ ar & action_;

+ updateRegex();

+ }

+

+/*

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

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+ HighlightRulesListPtr rules = manager_->getRules();

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

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

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

+ return rule.getAction();

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

+ highlightEditorController_->setContactSuggester(contactSuggesterWithoutRoster_);

+ "UIInterfaces/HighlightEditorWindow.cpp",

+/*

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

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+namespace Swift {

+

+HighlightEditorWindow::HighlightEditorWindow()

+{

+}

+

+HighlightEditorWindow::~HighlightEditorWindow()

+{

+}

+

+}

+/*

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

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <vector>

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

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

+

+namespace Swift {

+

+class HighlightManager;

+

+class HighlightEditorWindow {

+public:

+ HighlightEditorWindow();

+ virtual ~HighlightEditorWindow();

+ virtual void show() = 0;

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

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

+

+public:

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

+};

+

+}

+/*

+ * Copyright (c) 2012 Mateusz Piękos

+ * Licensed under the simplified BSD license.

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

+ */

+

+/*

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

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+namespace Swift {

+ class HighlightEditorWindow;

+

+ class HighlightEditorWindowFactory {

+ public :

+ virtual ~HighlightEditorWindowFactory() {}

+

+ virtual HighlightEditorWindow* createHighlightEditorWindow() = 0;

+ };

+}

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

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

+ public HighlightEditorWindowFactory,

+/*

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

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

+/*

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

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <cassert>

+

+#include <boost/lexical_cast.hpp>

+

+#include <Swift/QtUI/UserSearch/QtSuggestingJIDInput.h>

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

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

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

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

+

+#include <QTreeWidgetItem>

+#include <QFileDialog>

+

+namespace Swift {

+

+QtHighlightEditor::QtHighlightEditor(QtSettingsProvider* settings, QWidget* parent)

+ : QWidget(parent), settings_(settings), previousRow_(-1)

+{

+ ui_.setupUi(this);

+

+ connect(ui_.listWidget, SIGNAL(currentRowChanged(int)), SLOT(onCurrentRowChanged(int)));

+

+ connect(ui_.newButton, SIGNAL(clicked()), SLOT(onNewButtonClicked()));

+ connect(ui_.deleteButton, SIGNAL(clicked()), SLOT(onDeleteButtonClicked()));

+

+ connect(ui_.buttonBox->button(QDialogButtonBox::Apply), SIGNAL(clicked()), SLOT(onApplyButtonClick()));

+ connect(ui_.buttonBox->button(QDialogButtonBox::Cancel), SIGNAL(clicked()), SLOT(onCancelButtonClick()));

+ connect(ui_.buttonBox->button(QDialogButtonBox::Ok), SIGNAL(clicked()), SLOT(onOkButtonClick()));

+

+ connect(ui_.noColorRadio, SIGNAL(clicked()), SLOT(colorOtherSelect()));

+ connect(ui_.defaultColorRadio, SIGNAL(clicked()), SLOT(colorOtherSelect()));

+ connect(ui_.customColorRadio, SIGNAL(clicked()), SLOT(colorCustomSelect()));

+

+ connect(ui_.noSoundRadio, SIGNAL(clicked()), SLOT(soundOtherSelect()));

+ connect(ui_.defaultSoundRadio, SIGNAL(clicked()), SLOT(soundOtherSelect()));

+ connect(ui_.customSoundRadio, SIGNAL(clicked()), SLOT(soundCustomSelect()));

+

+ /* replace the static line-edit control with the roster autocompleter */

+ ui_.dummySenderName->setVisible(false);

+ jid_ = new QtSuggestingJIDInput(this, settings);

+ ui_.senderName->addWidget(jid_);

+ jid_->onUserSelected.connect(boost::bind(&QtHighlightEditor::handleOnUserSelected, this, _1));

+

+ /* handle autocomplete */

+ connect(jid_, SIGNAL(textEdited(QString)), SLOT(handleContactSuggestionRequested(QString)));

+

+ /* we need to be notified if any of the state changes so that we can update our textual rule description */

+ connect(ui_.chatRadio, SIGNAL(clicked()), SLOT(widgetClick()));

+ connect(ui_.roomRadio, SIGNAL(clicked()), SLOT(widgetClick()));

+ connect(ui_.nickIsKeyword, SIGNAL(clicked()), SLOT(widgetClick()));

+ connect(ui_.allMsgRadio, SIGNAL(clicked()), SLOT(widgetClick()));

+ connect(ui_.senderRadio, SIGNAL(clicked()), SLOT(widgetClick()));

+ connect(jid_, SIGNAL(textChanged(const QString&)), SLOT(widgetClick()));

+ connect(ui_.keywordRadio, SIGNAL(clicked()), SLOT(widgetClick()));

+ connect(ui_.keyword, SIGNAL(textChanged(const QString&)), SLOT(widgetClick()));

+ connect(ui_.matchPartialWords, SIGNAL(clicked()), SLOT(widgetClick()));

+ connect(ui_.matchCase, SIGNAL(clicked()), SLOT(widgetClick()));

+ connect(ui_.noColorRadio, SIGNAL(clicked()), SLOT(widgetClick()));

+ connect(ui_.defaultColorRadio, SIGNAL(clicked()), SLOT(widgetClick()));

+ connect(ui_.customColorRadio, SIGNAL(clicked()), SLOT(widgetClick()));

+ connect(ui_.noSoundRadio, SIGNAL(clicked()), SLOT(widgetClick()));

+ connect(ui_.defaultSoundRadio, SIGNAL(clicked()), SLOT(widgetClick()));

+ connect(ui_.customSoundRadio, SIGNAL(clicked()), SLOT(widgetClick()));

+

+ /* allow selection of a custom sound file */

+ connect(ui_.soundFileButton, SIGNAL(clicked()), SLOT(selectSoundFile()));

+

+ /* if these are not needed, then they should be removed */

+ ui_.moveUpButton->setVisible(false);

+ ui_.moveDownButton->setVisible(false);

+

+ setWindowTitle(tr("Highlight Rules"));

+}

+

+QtHighlightEditor::~QtHighlightEditor()

+{

+}

+

+std::string formatShortDescription(const HighlightRule &rule)

+{

+ const std::string chatOrRoom = (rule.getMatchChat() ? "chat" : "room");

+

+ std::vector<std::string> senders = rule.getSenders();

+ std::vector<std::string> keywords = rule.getKeywords();

+

+ if (senders.empty() && keywords.empty() && !rule.getNickIsKeyword()) {

+ return std::string("All ") + chatOrRoom + " messages.";

+ }

+

+ if (rule.getNickIsKeyword()) {

+ return std::string("All ") + chatOrRoom + " messages that mention my name.";

+ }

+

+ if (!senders.empty()) {

+ return std::string("All ") + chatOrRoom + " messages from " + senders[0] + ".";

+ }

+

+ if (!keywords.empty()) {

+ return std::string("All ") + chatOrRoom + " messages mentioning the keyword '" + keywords[0] + "'.";

+ }

+

+ return "Unknown Rule";

+}

+

+void QtHighlightEditor::show()

+{

+ highlightManager_->loadSettings();

+

+ populateList();

+

+ if (ui_.listWidget->count()) {

+ selectRow(0);

+ }

+

+ /* prepare default states */

+ widgetClick();

+

+ QWidget::show();

+ QWidget::activateWindow();

+}

+

+void QtHighlightEditor::setHighlightManager(HighlightManager* highlightManager)

+{

+ highlightManager_ = highlightManager;

+}

+

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

+{

+ jid_->setSuggestions(suggestions);

+}

+

+void QtHighlightEditor::colorOtherSelect()

+{

+ ui_.foregroundColor->setEnabled(false);

+ ui_.backgroundColor->setEnabled(false);

+}

+

+void QtHighlightEditor::colorCustomSelect()

+{

+ ui_.foregroundColor->setEnabled(true);

+ ui_.backgroundColor->setEnabled(true);

+}

+

+void QtHighlightEditor::soundOtherSelect()

+{

+ ui_.soundFile->setEnabled(false);

+ ui_.soundFileButton->setEnabled(false);

+}

+

+void QtHighlightEditor::soundCustomSelect()

+{

+ ui_.soundFile->setEnabled(true);

+ ui_.soundFileButton->setEnabled(true);

+}

+

+void QtHighlightEditor::onNewButtonClicked()

+{

+ int row = getSelectedRow() + 1;

+ populateList();

+ HighlightRule newRule;

+ newRule.setMatchChat(true);

+ highlightManager_->insertRule(row, newRule);

+ QListWidgetItem *item = new QListWidgetItem();

+ item->setText(P2QSTRING(formatShortDescription(newRule)));

+ ui_.listWidget->insertItem(row, item);

+ selectRow(row);

+}

+

+void QtHighlightEditor::onDeleteButtonClicked()

+{

+ int selectedRow = getSelectedRow();

+ assert(selectedRow>=0 && selectedRow<ui_.listWidget->count());

+ delete ui_.listWidget->takeItem(selectedRow);

+ highlightManager_->removeRule(selectedRow);

+

+ if (!ui_.listWidget->count()) {

+ disableDialog();

+ ui_.deleteButton->setEnabled(false);

+ } else {

+ if (selectedRow == ui_.listWidget->count()) {

+ selectRow(ui_.listWidget->count() - 1);

+ } else {

+ selectRow(selectedRow);

+ }

+ }

+}

+

+void QtHighlightEditor::onCurrentRowChanged(int currentRow)

+{

+ ui_.deleteButton->setEnabled(currentRow != -1);

+ ui_.moveUpButton->setEnabled(currentRow != -1 && currentRow != 0);

+ ui_.moveDownButton->setEnabled(currentRow != -1 && currentRow != (ui_.listWidget->count()-1));

+

+ if (previousRow_ != -1) {

+ if (ui_.listWidget->count() > previousRow_) {

+ highlightManager_->setRule(previousRow_, ruleFromDialog());

+ }

+ }

+

+ if (currentRow != -1) {

+ HighlightRule rule = highlightManager_->getRule(currentRow);

+ ruleToDialog(rule);

+ if (ui_.listWidget->currentItem()) {

+ ui_.listWidget->currentItem()->setText(P2QSTRING(formatShortDescription(rule)));

+ }

+ }

+

+ /* grey the dialog if we have nothing selected */

+ if (currentRow == -1) {

+ disableDialog();

+ }

+

+ previousRow_ = currentRow;

+}

+

+void QtHighlightEditor::onApplyButtonClick()

+{

+ selectRow(getSelectedRow()); /* force save */

+ highlightManager_->storeSettings();

+}

+

+void QtHighlightEditor::onCancelButtonClick()

+{

+ close();

+}

+

+void QtHighlightEditor::onOkButtonClick()

+{

+ onApplyButtonClick();

+ close();

+}

+

+void QtHighlightEditor::setChildWidgetStates()

+{

+ /* disable appropriate radio button child widgets */

+

+ if (ui_.chatRadio->isChecked()) {

+ if (ui_.nickIsKeyword->isChecked()) {

+ /* switch to another choice before we disable this button */

+ ui_.allMsgRadio->setChecked(true);

+ }

+ ui_.nickIsKeyword->setEnabled(false);

+ } else if (ui_.roomRadio->isChecked()) {

+ ui_.nickIsKeyword->setEnabled(true);

+ } else { /* chats and rooms */

+ ui_.nickIsKeyword->setEnabled(true);

+ }

+

+ if (ui_.senderRadio->isChecked()) {

+ jid_->setEnabled(true);

+ } else {

+ jid_->setEnabled(false);

+ }

+

+ if (ui_.keywordRadio->isChecked()) {

+ ui_.keyword->setEnabled(true);

+ ui_.matchPartialWords->setEnabled(true);

+ ui_.matchCase->setEnabled(true);

+ } else {

+ ui_.keyword->setEnabled(false);

+ ui_.matchPartialWords->setEnabled(false);

+ ui_.matchCase->setEnabled(false);

+ }

+

+ if (ui_.chatRadio->isChecked()) {

+ ui_.allMsgRadio->setText(tr("Apply to all chat messages"));

+ } else {

+ ui_.allMsgRadio->setText(tr("Apply to all room messages"));

+ }

+}

+

+void QtHighlightEditor::widgetClick()

+{

+ setChildWidgetStates();

+

+ HighlightRule rule = ruleFromDialog();

+

+ if (ui_.listWidget->currentItem()) {

+ ui_.listWidget->currentItem()->setText(P2QSTRING(formatShortDescription(rule)));

+ }

+}

+

+void QtHighlightEditor::disableDialog()

+{

+ ui_.chatRadio->setEnabled(false);

+ ui_.roomRadio->setEnabled(false);

+ ui_.allMsgRadio->setEnabled(false);

+ ui_.nickIsKeyword->setEnabled(false);

+ ui_.senderRadio->setEnabled(false);

+ ui_.dummySenderName->setEnabled(false);

+ ui_.keywordRadio->setEnabled(false);

+ ui_.keyword->setEnabled(false);

+ ui_.matchPartialWords->setEnabled(false);

+ ui_.matchCase->setEnabled(false);

+ ui_.noColorRadio->setEnabled(false);

+ ui_.defaultColorRadio->setEnabled(false);

+ ui_.customColorRadio->setEnabled(false);

+ ui_.foregroundColor->setEnabled(false);

+ ui_.backgroundColor->setEnabled(false);

+ ui_.noSoundRadio->setEnabled(false);

+ ui_.defaultSoundRadio->setEnabled(false);

+ ui_.customSoundRadio->setEnabled(false);

+ ui_.soundFile->setEnabled(false);

+ ui_.soundFileButton->setEnabled(false);

+}

+

+void QtHighlightEditor::handleContactSuggestionRequested(const QString& text)

+{

+ std::string stdText = Q2PSTRING(text);

+ onContactSuggestionsRequested(stdText);

+}

+

+void QtHighlightEditor::selectSoundFile()

+{

+ QString path = QFileDialog::getOpenFileName(this, tr("Select sound file..."), QString(), "Sounds (*.wav)");

+ ui_.soundFile->setText(path);

+}

+

+void QtHighlightEditor::handleOnUserSelected(const JID& jid) {

+ /* this might seem like it should be standard behaviour for the suggesting input box, but is not desirable in all cases */

+ jid_->setText(P2QSTRING(jid.toString()));

+}

+

+void QtHighlightEditor::populateList()

+{

+ previousRow_ = -1;

+ ui_.listWidget->clear();

+ HighlightRulesListPtr rules = highlightManager_->getRules();

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

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

+ QListWidgetItem *item = new QListWidgetItem();

+ item->setText(P2QSTRING(formatShortDescription(rule)));

+ ui_.listWidget->addItem(item);

+ }

+}

+

+void QtHighlightEditor::selectRow(int row)

+{

+ for (int i = 0; i < ui_.listWidget->count(); ++i) {

+ if (i == row) {

+ ui_.listWidget->item(i)->setSelected(true);

+ onCurrentRowChanged(i);

+ } else {

+ ui_.listWidget->item(i)->setSelected(false);

+ }

+ }

+ ui_.listWidget->setCurrentRow(row);

+}

+

+int QtHighlightEditor::getSelectedRow() const

+{

+ for (int i = 0; i < ui_.listWidget->count(); ++i) {

+ if (ui_.listWidget->item(i)->isSelected()) {

+ return i;

+ }

+ }

+ return -1;

+}

+

+HighlightRule QtHighlightEditor::ruleFromDialog()

+{

+ HighlightRule rule;

+

+ if (ui_.chatRadio->isChecked()) {

+ rule.setMatchChat(true);

+ rule.setMatchMUC(false);

+ } else {

+ rule.setMatchChat(false);

+ rule.setMatchMUC(true);

+ }

+

+ if (ui_.senderRadio->isChecked()) {

+ QString senderName = jid_->text();

+ if (!senderName.isEmpty()) {

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

+ senders.push_back(Q2PSTRING(senderName));

+ rule.setSenders(senders);

+ }

+ }

+

+ if (ui_.keywordRadio->isChecked()) {

+ QString keywordString = ui_.keyword->text();

+ if (!keywordString.isEmpty()) {

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

+ keywords.push_back(Q2PSTRING(keywordString));

+ rule.setKeywords(keywords);

+ }

+ }

+

+ rule.setNickIsKeyword(ui_.nickIsKeyword->isChecked());

+ rule.setMatchWholeWords(!ui_.matchPartialWords->isChecked());

+ rule.setMatchCase(ui_.matchCase->isChecked());

+

+ HighlightAction& action = rule.getAction();

+

+ if (ui_.noColorRadio->isChecked()) {

+ action.setHighlightText(false);

+ action.setTextColor("");

+ action.setTextBackground("");

+ } else if (ui_.defaultColorRadio->isChecked()) {

+ action.setHighlightText(true);

+ action.setTextColor("");

+ action.setTextBackground("");

+ } else {

+ action.setHighlightText(true);

+ action.setTextColor(Q2PSTRING(ui_.foregroundColor->getColor().name()));

+ action.setTextBackground(Q2PSTRING(ui_.backgroundColor->getColor().name()));

+ }

+

+ if (ui_.noSoundRadio->isChecked()) {

+ action.setPlaySound(false);

+ } else if (ui_.defaultSoundRadio->isChecked()) {

+ action.setPlaySound(true);

+ action.setSoundFile("");

+ } else {

+ action.setPlaySound(true);

+ action.setSoundFile(Q2PSTRING(ui_.soundFile->text()));

+ }

+

+ return rule;

+}

+

+void QtHighlightEditor::ruleToDialog(const HighlightRule& rule)

+{

+ ui_.chatRadio->setEnabled(true);

+ ui_.roomRadio->setEnabled(true);

+

+ if (rule.getMatchMUC()) {

+ ui_.chatRadio->setChecked(false);

+ ui_.roomRadio->setChecked(true);

+ } else {

+ ui_.chatRadio->setChecked(true);

+ ui_.roomRadio->setChecked(false);

+ }

+

+ ui_.allMsgRadio->setEnabled(true);

+ ui_.allMsgRadio->setChecked(true); /* this is the default radio button */

+ jid_->setText("");

+ ui_.keyword->setText("");

+ ui_.matchPartialWords->setChecked(false);

+ ui_.matchCase->setChecked(false);

+

+ ui_.nickIsKeyword->setEnabled(true);

+ if (rule.getNickIsKeyword()) {

+ ui_.nickIsKeyword->setChecked(true);

+ }

+

+ ui_.senderRadio->setEnabled(true);

+ std::vector<std::string> senders = rule.getSenders();

+ if (!senders.empty()) {

+ ui_.senderRadio->setChecked(true);

+ jid_->setText(P2QSTRING(senders[0]));

+ }

+

+ ui_.keywordRadio->setEnabled(true);

+ std::vector<std::string> keywords = rule.getKeywords();

+ if (!keywords.empty()) {

+ ui_.keywordRadio->setChecked(true);

+ ui_.keyword->setText(P2QSTRING(keywords[0]));

+ ui_.matchPartialWords->setChecked(!rule.getMatchWholeWords());

+ ui_.matchCase->setChecked(rule.getMatchCase());

+ }

+

+ const HighlightAction& action = rule.getAction();

+

+ ui_.noColorRadio->setEnabled(true);

+ ui_.defaultColorRadio->setEnabled(true);

+ ui_.customColorRadio->setEnabled(true);

+ if (action.highlightText()) {

+ if (action.getTextColor().empty() && action.getTextBackground().empty()) {

+ ui_.defaultColorRadio->setChecked(true);

+ ui_.foregroundColor->setEnabled(false);

+ ui_.backgroundColor->setEnabled(false);

+ } else {

+ ui_.foregroundColor->setEnabled(true);

+ ui_.backgroundColor->setEnabled(true);

+ QColor foregroundColor(P2QSTRING(action.getTextColor()));

+ ui_.foregroundColor->setColor(foregroundColor);

+ QColor backgroundColor(P2QSTRING(action.getTextBackground()));

+ ui_.backgroundColor->setColor(backgroundColor);

+ ui_.customColorRadio->setChecked(true);

+ }

+ } else {

+ ui_.noColorRadio->setChecked(true);

+ ui_.foregroundColor->setEnabled(false);

+ ui_.backgroundColor->setEnabled(false);

+ }

+

+ ui_.noSoundRadio->setEnabled(true);

+ ui_.defaultSoundRadio->setEnabled(true);

+ ui_.customSoundRadio->setEnabled(true);

+ ui_.soundFile->setText("");

+ ui_.soundFile->setEnabled(false);

+ ui_.soundFileButton->setEnabled(false);

+ if (action.playSound()) {

+ if (action.getSoundFile().empty()) {

+ ui_.defaultSoundRadio->setChecked(true);

+ } else {

+ ui_.customSoundRadio->setChecked(true);

+ ui_.soundFile->setText(P2QSTRING(action.getSoundFile()));

+ ui_.soundFile->setEnabled(true);

+ ui_.soundFileButton->setEnabled(true);

+ }

+ } else {

+ ui_.noSoundRadio->setChecked(true);

+ }

+

+ /* set radio button child option states */

+ setChildWidgetStates();

+}

+

+}

+/*

+ * Copyright (c) 2012 Maciej Niedzielski

+ * Licensed under the simplified BSD license.

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

+ */

+

+/*

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

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

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

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

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

+

+namespace Swift {

+

+ class QtSettingsProvider;

+ class QtSuggestingJIDInput;

+ class QtWebKitChatView;

+

+ class QtHighlightEditor : public QWidget, public HighlightEditorWindow {

+ Q_OBJECT

+

+ public:

+ QtHighlightEditor(QtSettingsProvider* settings, QWidget* parent = NULL);

+ virtual ~QtHighlightEditor();

+

+ virtual void show();

+ virtual void setHighlightManager(HighlightManager* highlightManager);

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

+

+ private slots:

+ void colorOtherSelect();

+ void colorCustomSelect();

+ void soundOtherSelect();

+ void soundCustomSelect();

+ void onNewButtonClicked();

+ void onDeleteButtonClicked();

+ void onCurrentRowChanged(int currentRow);

+ void onApplyButtonClick();

+ void onCancelButtonClick();

+ void onOkButtonClick();

+ void setChildWidgetStates();

+ void widgetClick();

+ void disableDialog();

+ void handleContactSuggestionRequested(const QString& text);

+ void selectSoundFile();

+

+ private:

+ void handleOnUserSelected(const JID& jid);

+ void populateList();

+ void updateChatPreview();

+ void selectRow(int row);

+ int getSelectedRow() const;

+ HighlightRule ruleFromDialog();

+ void ruleToDialog(const HighlightRule& rule);

+

+ Ui::QtHighlightEditor ui_;

+ QtSettingsProvider* settings_;

+ HighlightManager* highlightManager_;

+ QtSuggestingJIDInput* jid_;

+ int previousRow_;

+ };

+

+}

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

+<ui version="4.0">

+ <class>QtHighlightEditor</class>

+ <widget class="QWidget" name="QtHighlightEditor">

+ <property name="geometry">

+ <rect>

+ <x>0</x>

+ <y>0</y>

+ <width>439</width>

+ <height>836</height>

+ </rect>

+ </property>

+ <property name="sizePolicy">

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

+ <horstretch>0</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ <property name="minimumSize">

+ <size>

+ <width>439</width>

+ <height>836</height>

+ </size>

+ </property>

+ <property name="windowTitle">

+ <string>Form</string>

+ </property>

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

+ <item>

+ <widget class="QLabel" name="label_5">

+ <property name="text">

+ <string>Incoming messages are checked against the following rules. First rule that matches will be executed.</string>

+ </property>

+ <property name="wordWrap">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QListWidget" name="listWidget"/>

+ </item>

+ <item>

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

+ <item>

+ <spacer name="horizontalSpacer_8">

+ <property name="orientation">

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

+ </property>

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

+ <size>

+ <width>40</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ <item>

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

+ <property name="text">

+ <string>New Rule</string>

+ </property>

+ </widget>

+ </item>

+ <item>

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

+ <property name="text">

+ <string>Remove Rule</string>

+ </property>

+ </widget>

+ </item>

+ <item>

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

+ <property name="text">

+ <string>Move Up</string>

+ </property>

+ </widget>

+ </item>

+ <item>

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

+ <property name="text">

+ <string>Move Down</string>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ <item>

+ <widget class="Line" name="line_3">

+ <property name="orientation">

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

+ </property>

+ </widget>

+ </item>

+ <item>

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

+ <property name="sizePolicy">

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

+ <horstretch>0</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ <property name="title">

+ <string>Apply Rule To</string>

+ </property>

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

+ <item>

+ <widget class="QRadioButton" name="chatRadio">

+ <property name="text">

+ <string>Chats</string>

+ </property>

+ <property name="checked">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QRadioButton" name="roomRadio">

+ <property name="text">

+ <string>Rooms</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <spacer name="horizontalSpacer">

+ <property name="orientation">

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

+ </property>

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

+ <size>

+ <width>246</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ </layout>

+ </widget>

+ </item>

+ <item>

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

+ <property name="sizePolicy">

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

+ <horstretch>0</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ <property name="title">

+ <string>Rule Conditions</string>

+ </property>

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

+ <item>

+ <widget class="QRadioButton" name="allMsgRadio">

+ <property name="text">

+ <string>Apply to all messages</string>

+ </property>

+ <property name="checked">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QRadioButton" name="nickIsKeyword">

+ <property name="text">

+ <string>Only messages mentioning me</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QRadioButton" name="senderRadio">

+ <property name="text">

+ <string>Messages from this sender:</string>

+ </property>

+ </widget>

+ </item>

+ <item>

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

+ <property name="sizeConstraint">

+ <enum>QLayout::SetMinimumSize</enum>

+ </property>

+ <item>

+ <widget class="QLineEdit" name="dummySenderName"/>

+ </item>

+ </layout>

+ </item>

+ <item>

+ <widget class="QRadioButton" name="keywordRadio">

+ <property name="text">

+ <string>Messages containing this keyword:</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QLineEdit" name="keyword"/>

+ </item>

+ <item>

+ <widget class="QCheckBox" name="matchPartialWords">

+ <property name="text">

+ <string>Match keyword within longer words</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QCheckBox" name="matchCase">

+ <property name="text">

+ <string>Keyword is case sensitive</string>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </widget>

+ </item>

+ <item>

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

+ <property name="sizePolicy">

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

+ <horstretch>0</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ <property name="title">

+ <string>Highlight Action</string>

+ </property>

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

+ <item>

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

+ <item>

+ <widget class="QRadioButton" name="noColorRadio">

+ <property name="text">

+ <string>No Highlight</string>

+ </property>

+ <property name="checked">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QRadioButton" name="defaultColorRadio">

+ <property name="text">

+ <string>Default Color</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QRadioButton" name="customColorRadio">

+ <property name="text">

+ <string>Custom Color</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <spacer name="horizontalSpacer_5">

+ <property name="orientation">

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

+ </property>

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

+ <size>

+ <width>40</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ </layout>

+ </item>

+ <item>

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

+ <item>

+ <spacer name="horizontalSpacer_2">

+ <property name="orientation">

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

+ </property>

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

+ <size>

+ <width>40</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ <item>

+ <widget class="Swift::QtColorToolButton" name="foregroundColor">

+ <property name="enabled">

+ <bool>false</bool>

+ </property>

+ <property name="text">

+ <string>&amp;Text</string>

+ </property>

+ <property name="toolButtonStyle">

+ <enum>Qt::ToolButtonTextBesideIcon</enum>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="Swift::QtColorToolButton" name="backgroundColor">

+ <property name="enabled">

+ <bool>false</bool>

+ </property>

+ <property name="text">

+ <string>&amp;Background</string>

+ </property>

+ <property name="toolButtonStyle">

+ <enum>Qt::ToolButtonTextBesideIcon</enum>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ </layout>

+ </widget>

+ </item>

+ <item>

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

+ <property name="sizePolicy">

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

+ <horstretch>0</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ <property name="title">

+ <string>Sound Action</string>

+ </property>

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

+ <item>

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

+ <item>

+ <widget class="QRadioButton" name="noSoundRadio">

+ <property name="text">

+ <string>No Sound</string>

+ </property>

+ <property name="checked">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QRadioButton" name="defaultSoundRadio">

+ <property name="text">

+ <string>Default Sound</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QRadioButton" name="customSoundRadio">

+ <property name="text">

+ <string>Custom Sound</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <spacer name="horizontalSpacer_6">

+ <property name="orientation">

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

+ </property>

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

+ <size>

+ <width>40</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ </layout>

+ </item>

+ <item>

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

+ <item>

+ <spacer name="horizontalSpacer_3">

+ <property name="orientation">

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

+ </property>

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

+ <size>

+ <width>40</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ <item>

+ <widget class="QLineEdit" name="soundFile">

+ <property name="enabled">

+ <bool>false</bool>

+ </property>

+ <property name="readOnly">

+ <bool>false</bool>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QToolButton" name="soundFileButton">

+ <property name="enabled">

+ <bool>false</bool>

+ </property>

+ <property name="text">

+ <string>...</string>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ </layout>

+ </widget>

+ </item>

+ <item>

+ <widget class="Line" name="line_2">

+ <property name="orientation">

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

+ </property>

+ </widget>

+ </item>

+ <item>

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

+ <item>

+ <spacer name="horizontalSpacer_4">

+ <property name="orientation">

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

+ </property>

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

+ <size>

+ <width>40</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ <item>

+ <widget class="QDialogButtonBox" name="buttonBox">

+ <property name="standardButtons">

+ <set>QDialogButtonBox::Apply|QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ </layout>

+ </widget>

+ <customwidgets>

+ <customwidget>

+ <class>Swift::QtColorToolButton</class>

+ <extends>QToolButton</extends>

+ <header>QtColorToolButton.h</header>

+ </customwidget>

+ </customwidgets>

+ <resources/>

+ <connections/>

+</ui>

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

+HighlightEditorWindow* QtUIFactory::createHighlightEditorWindow() {

+ return new QtHighlightEditor(qtOnlySettings);

+ virtual HighlightEditorWindow* createHighlightEditorWindow();

+QString QtWebKitChatView::getHighlightSpanStart(const std::string& text, const std::string& background) {

+ QString ecsapeColor = QtUtilities::htmlEscape(P2QSTRING(text));

+ QString escapeBackground = QtUtilities::htmlEscape(P2QSTRING(background));

+ if (ecsapeColor.isEmpty()) {

+ ecsapeColor = "black";

+ }

+ if (escapeBackground.isEmpty()) {

+ escapeBackground = "yellow";

+ }

+ return QString("<span style=\"color: %1; background: %2\">").arg(ecsapeColor).arg(escapeBackground);

+}

+

+QString QtWebKitChatView::getHighlightSpanStart(const HighlightAction& highlight) {

+ return getHighlightSpanStart(highlight.getTextColor(), highlight.getTextBackground());

+}

+

+ QString spanStart = getHighlightSpanStart(highlightPart->foregroundColor, highlightPart->backgroundColor);

+ result += spanStart + QtUtilities::htmlEscape(P2QSTRING(highlightPart->text)) + "</span>";

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

+ QString getHighlightSpanStart(const std::string& text, const std::string& background);

+ QString chatMessageToHTML(const ChatWindow::ChatMessage& message);

+ "QtHighlightEditor.cpp",

+myenv.Uic4("QtHighlightEditor.ui")