1 files changed, 9 insertions, 33 deletions
diff --git a/Swift/Controllers/Chat/ChatControllerBase.cpp b/Swift/Controllers/Chat/ChatControllerBase.cpp
index da9064e..5839d6c 100644
--- a/Swift/Controllers/Chat/ChatControllerBase.cpp
+++ b/Swift/Controllers/Chat/ChatControllerBase.cpp
@@ -1,77 +1,77 @@
 /*
- * Copyright (c) 2010-2016 Isode Limited.
+ * Copyright (c) 2010-2017 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swift/Controllers/Chat/ChatControllerBase.h>
 
 #include <map>
 #include <memory>
 #include <sstream>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/bind.hpp>
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <Swiften/Avatars/AvatarManager.h>
 #include <Swiften/Base/Path.h>
 #include <Swiften/Base/format.h>
 #include <Swiften/Client/StanzaChannel.h>
 #include <Swiften/Disco/EntityCapsProvider.h>
 #include <Swiften/Elements/Delay.h>
 #include <Swiften/Elements/MUCInvitationPayload.h>
 #include <Swiften/Elements/MUCUserPayload.h>
 #include <Swiften/Queries/Requests/GetSecurityLabelsCatalogRequest.h>
 
 #include <Swift/Controllers/Chat/AutoAcceptMUCInviteDecider.h>
 #include <Swift/Controllers/Chat/ChatMessageParser.h>
-#include <Swift/Controllers/HighlightManager.h>
-#include <Swift/Controllers/Highlighter.h>
+#include <Swift/Controllers/Highlighting/HighlightManager.h>
+#include <Swift/Controllers/Highlighting/Highlighter.h>
 #include <Swift/Controllers/Intl.h>
 #include <Swift/Controllers/UIEvents/JoinMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindowFactory.h>
 #include <Swift/Controllers/XMPPEvents/EventController.h>
 #include <Swift/Controllers/XMPPEvents/MUCInviteEvent.h>
 
 namespace Swift {
 
-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, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), timerFactory_(timerFactory), entityCapsProvider_(entityCapsProvider), historyController_(historyController), mucRegistry_(mucRegistry), chatMessageParser_(chatMessageParser), autoAcceptMUCInviteDecider_(autoAcceptMUCInviteDecider), eventStream_(eventStream) {
+ChatControllerBase::ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), timerFactory_(timerFactory), entityCapsProvider_(entityCapsProvider), historyController_(historyController), mucRegistry_(mucRegistry), chatMessageParser_(chatMessageParser), autoAcceptMUCInviteDecider_(autoAcceptMUCInviteDecider), eventStream_(eventStream) {
     chatWindow_ = chatWindowFactory_->createChatWindow(toJID, eventStream);
     chatWindow_->onAllMessagesRead.connect(boost::bind(&ChatControllerBase::handleAllMessagesRead, this));
     chatWindow_->onSendMessageRequest.connect(boost::bind(&ChatControllerBase::handleSendMessageRequest, this, _1, _2));
     chatWindow_->onLogCleared.connect(boost::bind(&ChatControllerBase::handleLogCleared, this));
     entityCapsProvider_->onCapsChanged.connect(boost::bind(&ChatControllerBase::handleCapsChanged, this, _1));
-    highlighter_ = highlightManager->createHighlighter();
+    highlighter_ = highlightManager->createHighlighter(nickResolver);
     ChatControllerBase::setOnline(stanzaChannel->isAvailable() && iqRouter->isAvailable());
     createDayChangeTimer();
 }
 
 ChatControllerBase::~ChatControllerBase() {
     if (dateChangeTimer_) {
         dateChangeTimer_->onTick.disconnect(boost::bind(&ChatControllerBase::handleDayChangeTick, this));
         dateChangeTimer_->stop();
     }
 
     delete highlighter_;
     delete chatWindow_;
 }
 
 void ChatControllerBase::handleLogCleared() {
     cancelReplaces();
 }
 
 ChatWindow* ChatControllerBase::detachChatWindow() {
     ChatWindow* chatWindow = chatWindow_;
     chatWindow_ = nullptr;
     return chatWindow;
 }
 
 void ChatControllerBase::handleCapsChanged(const JID& jid) {
     if (jid.compare(toJID_, JID::WithoutResource) == 0) {
         handleBareJIDCapsChanged(jid);
     }
 }
 
@@ -177,84 +177,66 @@ void ChatControllerBase::handleSendMessageRequest(const std::string &body, bool
 }
 
 void ChatControllerBase::handleSecurityLabelsCatalogResponse(std::shared_ptr<SecurityLabelsCatalog> catalog, ErrorPayload::ref error) {
     if (catalog && !error) {
         if (catalog->getItems().size() == 0) {
             chatWindow_->setSecurityLabelsEnabled(false);
             labelsEnabled_ = false;
         } else {
             labelsEnabled_ = true;
             chatWindow_->setAvailableSecurityLabels(catalog->getItems());
             chatWindow_->setSecurityLabelsEnabled(true);
         }
     } else {
         labelsEnabled_ = false;
         chatWindow_->setSecurityLabelsError();
     }
 }
 
 void ChatControllerBase::showChatWindow() {
     chatWindow_->show();
 }
 
 void ChatControllerBase::activateChatWindow() {
     chatWindow_->activate();
 }
 
 bool ChatControllerBase::hasOpenWindow() const {
     return chatWindow_ && chatWindow_->isVisible();
 }
 
-ChatWindow::ChatMessage ChatControllerBase::buildChatWindowChatMessage(const std::string& message, bool senderIsSelf, const HighlightAction& fullMessageHighlightAction) {
+ChatWindow::ChatMessage ChatControllerBase::buildChatWindowChatMessage(const std::string& message, const std::string& senderName, bool senderIsSelf) {
     ChatWindow::ChatMessage chatMessage;
-    chatMessage = chatMessageParser_->parseMessageBody(message, highlighter_->getNick(), senderIsSelf);
-    chatMessage.setFullMessageHighlightAction(fullMessageHighlightAction);
+    chatMessage = chatMessageParser_->parseMessageBody(message, senderName, senderIsSelf);
     return chatMessage;
 }
 
-void ChatControllerBase::handleHighlightActions(const ChatWindow::ChatMessage& chatMessage) {
-    std::set<std::string> playedSounds;
-    if (chatMessage.getFullMessageHighlightAction().playSound()) {
-        highlighter_->handleHighlightAction(chatMessage.getFullMessageHighlightAction());
-        playedSounds.insert(chatMessage.getFullMessageHighlightAction().getSoundFile());
-    }
-    for (std::shared_ptr<ChatWindow::ChatMessagePart> part : chatMessage.getParts()) {
-        std::shared_ptr<ChatWindow::ChatHighlightingMessagePart> highlightMessage = std::dynamic_pointer_cast<ChatWindow::ChatHighlightingMessagePart>(part);
-        if (highlightMessage && highlightMessage->action.playSound()) {
-            if (playedSounds.find(highlightMessage->action.getSoundFile()) == playedSounds.end()) {
-                highlighter_->handleHighlightAction(highlightMessage->action);
-                playedSounds.insert(highlightMessage->action.getSoundFile());
-            }
-        }
-    }
-}
-
 void ChatControllerBase::updateMessageCount() {
     chatWindow_->setUnreadMessageCount(boost::numeric_cast<int>(unreadMessages_.size()));
     onUnreadCountChanged();
 }
 
 std::string ChatControllerBase::addMessage(const ChatWindow::ChatMessage& chatMessage, const std::string& senderName, bool senderIsSelf, const std::shared_ptr<SecurityLabel> label, const boost::filesystem::path& avatarPath, const boost::posix_time::ptime& time) {
     if (chatMessage.isMeCommand()) {
         return chatWindow_->addAction(chatMessage, senderName, senderIsSelf, label, pathToString(avatarPath), time);
     }
     else {
         return chatWindow_->addMessage(chatMessage, senderName, senderIsSelf, label, pathToString(avatarPath), time);
     }
 }
 
 void ChatControllerBase::replaceMessage(const ChatWindow::ChatMessage& chatMessage, const std::string& id, const boost::posix_time::ptime& time) {
     if (chatMessage.isMeCommand()) {
         chatWindow_->replaceWithAction(chatMessage, id, time);
     }
     else {
         chatWindow_->replaceMessage(chatMessage, id, time);
     }
 }
 
 bool ChatControllerBase::isFromContact(const JID& from) {
     return from.toBare() == toJID_.toBare();
 }
 
 void ChatControllerBase::handleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent) {
     preHandleIncomingMessage(messageEvent);
     if (messageEvent->isReadable() && !messageEvent->getConcluded()) {
@@ -287,79 +269,73 @@ void ChatControllerBase::handleIncomingMessage(std::shared_ptr<MessageEvent> mes
     else if (messageEvent->getStanza()->getPayload<MUCUserPayload>() && messageEvent->getStanza()->getPayload<MUCUserPayload>()->getInvite()) {
         handleMediatedMUCInvitation(messageEvent->getStanza());
         return;
     }
     else {
         if (!messageEvent->isReadable()) {
             return;
         }
         showChatWindow();
         JID from = message->getFrom();
         std::vector<std::shared_ptr<Delay> > delayPayloads = message->getPayloads<Delay>();
         for (size_t i = 0; useDelayForLatency_ && i < delayPayloads.size(); i++) {
             if (!delayPayloads[i]->getFrom()) {
                 continue;
             }
             boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();
             std::ostringstream s;
             s << "The following message took " << (now - delayPayloads[i]->getStamp()).total_milliseconds() / 1000.0 <<  " seconds to be delivered from " << delayPayloads[i]->getFrom()->toString() << ".";
             chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(std::string(s.str())), ChatWindow::DefaultDirection);
         }
         std::shared_ptr<SecurityLabel> label = message->getPayload<SecurityLabel>();
 
         // Determine the timestamp
         boost::posix_time::ptime timeStamp = boost::posix_time::microsec_clock::universal_time();
         boost::optional<boost::posix_time::ptime> messageTimeStamp = getMessageTimestamp(message);
         if (messageTimeStamp) {
             timeStamp = *messageTimeStamp;
         }
         onActivity(body);
 
-        // Highlight
-        HighlightAction fullMessageHighlight;
-        if (!isIncomingMessageFromMe(message)) {
-            fullMessageHighlight = highlighter_->findFirstFullMessageMatchAction(body, senderHighlightNameFromMessage(from));
-        }
-
         std::shared_ptr<Replace> replace = message->getPayload<Replace>();
         bool senderIsSelf = isIncomingMessageFromMe(message);
         if (replace) {
             // Should check if the user has a previous message
             std::map<JID, std::string>::iterator lastMessage;
             lastMessage = lastMessagesUIID_.find(from);
             if (lastMessage != lastMessagesUIID_.end()) {
-                chatMessage = buildChatWindowChatMessage(body, senderIsSelf, fullMessageHighlight);
+                chatMessage = buildChatWindowChatMessage(body, senderHighlightNameFromMessage(from), senderIsSelf);
                 replaceMessage(chatMessage, lastMessagesUIID_[from], timeStamp);
             }
         }
         else {
-            chatMessage = buildChatWindowChatMessage(body, senderIsSelf, fullMessageHighlight);
+            chatMessage = buildChatWindowChatMessage(body, senderHighlightNameFromMessage(from), senderIsSelf);
             addMessageHandleIncomingMessage(from, chatMessage, senderIsSelf, label, timeStamp);
         }
 
         logMessage(body, from, selfJID_, timeStamp, true);
     }
     chatWindow_->show();
     updateMessageCount();
     postHandleIncomingMessage(messageEvent, chatMessage);
 }
 
 void ChatControllerBase::addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) {
     lastMessagesUIID_[from] = addMessage(message, senderDisplayNameFromMessage(from), senderIsSelf, label, avatarManager_->getAvatarPath(from), timeStamp);
 }
 
 std::string ChatControllerBase::getErrorMessage(std::shared_ptr<ErrorPayload> error) {
     std::string defaultMessage = QT_TRANSLATE_NOOP("", "Error sending message");
     if (!error->getText().empty()) {
         return error->getText();
     }
     else {
         switch (error->getCondition()) {
             case ErrorPayload::BadRequest: return QT_TRANSLATE_NOOP("", "Bad request");
             case ErrorPayload::Conflict: return QT_TRANSLATE_NOOP("", "Conflict");
             case ErrorPayload::FeatureNotImplemented: return QT_TRANSLATE_NOOP("", "This feature is not implemented");
             case ErrorPayload::Forbidden: return QT_TRANSLATE_NOOP("", "Forbidden");
             case ErrorPayload::Gone: return QT_TRANSLATE_NOOP("", "Recipient can no longer be contacted");
             case ErrorPayload::InternalServerError: return QT_TRANSLATE_NOOP("", "Internal server error");
             case ErrorPayload::ItemNotFound: return QT_TRANSLATE_NOOP("", "Item not found");
             case ErrorPayload::JIDMalformed: return QT_TRANSLATE_NOOP("", "JID Malformed");
             case ErrorPayload::NotAcceptable: return QT_TRANSLATE_NOOP("", "Message was rejected");