12 files changed, 223 insertions, 47 deletions
diff --git a/Swift/Controllers/Chat/ChatController.cpp b/Swift/Controllers/Chat/ChatController.cpp
index 2367761..9df7708 100644
--- a/Swift/Controllers/Chat/ChatController.cpp
+++ b/Swift/Controllers/Chat/ChatController.cpp
@@ -17,71 +17,71 @@
 #include <Swiften/Base/format.h>
 #include <Swiften/Base/Log.h>
 #include <Swiften/Chat/ChatStateNotifier.h>
 #include <Swiften/Chat/ChatStateTracker.h>
 #include <Swiften/Client/ClientBlockListManager.h>
 #include <Swiften/Client/NickResolver.h>
 #include <Swiften/Client/StanzaChannel.h>
 #include <Swiften/Disco/EntityCapsProvider.h>
 #include <Swiften/Elements/DeliveryReceipt.h>
 #include <Swiften/Elements/DeliveryReceiptRequest.h>
 #include <Swiften/Elements/Idle.h>
 #include <Swiften/FileTransfer/FileTransferManager.h>
 
 #include <Swift/Controllers/Intl.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindowFactory.h>
 #include <Swift/Controllers/XMPPEvents/EventController.h>
 #include <Swift/Controllers/FileTransfer/FileTransferController.h>
 #include <Swift/Controllers/StatusUtil.h>
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 #include <Swift/Controllers/UIEvents/SendFileUIEvent.h>
 #include <Swift/Controllers/UIEvents/AcceptWhiteboardSessionUIEvent.h>
 #include <Swift/Controllers/UIEvents/CancelWhiteboardSessionUIEvent.h>
 #include <Swift/Controllers/UIEvents/ShowWhiteboardUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestChangeBlockStateUIEvent.h>
 #include <Swift/Controllers/UIEvents/InviteToMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestInviteToMUCUIEvent.h>
 #include <Swift/Controllers/SettingConstants.h>
 #include <Swift/Controllers/Highlighter.h>
 #include <Swift/Controllers/Chat/ChatMessageParser.h>
 
 namespace Swift {
 	
 /**
  * The controller does not gain ownership of the stanzaChannel, nor the factory.
  */
-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, ChatMessageParser* chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider)
+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)
 	: ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, presenceOracle, avatarManager, useDelayForLatency, eventStream, eventController, timerFactory, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider), eventStream_(eventStream), userWantsReceipts_(userWantsReceipts), settings_(settings), clientBlockListManager_(clientBlockListManager) {
 	isInMUC_ = isInMUC;
 	lastWasPresence_ = false;
 	chatStateNotifier_ = new ChatStateNotifier(stanzaChannel, contact, entityCapsProvider);
 	chatStateTracker_ = new ChatStateTracker();
 	nickResolver_ = nickResolver;
 	presenceOracle_->onPresenceChange.connect(boost::bind(&ChatController::handlePresenceChange, this, _1));
 	chatStateTracker_->onChatStateChange.connect(boost::bind(&ChatWindow::setContactChatState, chatWindow_, _1));
 	stanzaChannel_->onStanzaAcked.connect(boost::bind(&ChatController::handleStanzaAcked, this, _1));
 	nickResolver_->onNickChanged.connect(boost::bind(&ChatController::handleContactNickChanged, this, _1, _2));
 	std::string nick = nickResolver_->jidToNick(toJID_);
 	chatWindow_->setName(nick);
 	std::string startMessage;
 	Presence::ref theirPresence;
 	if (isInMUC) {
 		startMessage = str(format(QT_TRANSLATE_NOOP("", "Starting chat with %1% in chatroom %2%")) % nick % contact.toBare().toString());
 		theirPresence = presenceOracle->getLastPresence(contact);
 	} else {
 		startMessage = str(format(QT_TRANSLATE_NOOP("", "Starting chat with %1% - %2%")) % nick % contact.toBare().toString());
 		theirPresence = contact.isBare() ? presenceOracle->getHighestPriorityPresence(contact.toBare()) : presenceOracle->getLastPresence(contact);
 	}
 	Idle::ref idle;
 	if (theirPresence && (idle = theirPresence->getPayload<Idle>())) {
 		startMessage += str(format(QT_TRANSLATE_NOOP("", ", who has been idle since %1%")) % dateTimeToLocalString(idle->getSince()));
 	}
 	startMessage += ": " + statusShowTypeToFriendlyName(theirPresence ? theirPresence->getShow() : StatusShow::None);
 	if (theirPresence && !theirPresence->getStatus().empty()) {
 		startMessage += " (" + theirPresence->getStatus() + ")";
 	}
 	lastShownStatus_ = theirPresence ? theirPresence->getShow() : StatusShow::None;
 	chatStateNotifier_->setContactIsOnline(theirPresence && theirPresence->getType() == Presence::Available);
 	startMessage += ".";
 	chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(startMessage), ChatWindow::DefaultDirection);
 	chatWindow_->onUserTyping.connect(boost::bind(&ChatStateNotifier::setUserIsTyping, chatStateNotifier_));
 	chatWindow_->onUserCancelsTyping.connect(boost::bind(&ChatStateNotifier::userCancelledNewMessage, chatStateNotifier_));
@@ -286,71 +286,71 @@ void ChatController::handleBlockingItemRemoved(const JID& jid) {
 }
 
 void ChatController::handleBlockUserRequest() {
 	if (isInMUC_) {
 		eventStream_->send(boost::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Blocked, toJID_));
 	} else {
 		eventStream_->send(boost::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Blocked, toJID_.toBare()));
 	}
 }
 
 void ChatController::handleUnblockUserRequest() {
 	if (isInMUC_) {
 		eventStream_->send(boost::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Unblocked, toJID_));
 	} else {
 		eventStream_->send(boost::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Unblocked, toJID_.toBare()));
 	}
 }
 
 void ChatController::handleInviteToChat(const std::vector<JID>& droppedJIDs) {
 	boost::shared_ptr<UIEvent> event(new RequestInviteToMUCUIEvent(toJID_.toBare(), droppedJIDs, RequestInviteToMUCUIEvent::Impromptu));
 	eventStream_->send(event);
 }
 
 void ChatController::handleUIEvent(boost::shared_ptr<UIEvent> event) {
 	boost::shared_ptr<InviteToMUCUIEvent> inviteEvent = boost::dynamic_pointer_cast<InviteToMUCUIEvent>(event);
 	if (inviteEvent && inviteEvent->getRoom() == toJID_.toBare()) {
 		onConvertToMUC(detachChatWindow(), inviteEvent->getInvites(), inviteEvent->getReason());
 	}
 }
 
 
 void ChatController::postSendMessage(const std::string& body, boost::shared_ptr<Stanza> sentStanza) {
 	boost::shared_ptr<Replace> replace = sentStanza->getPayload<Replace>();
 	if (replace) {
 		eraseIf(unackedStanzas_, PairSecondEquals<boost::shared_ptr<Stanza>, std::string>(myLastMessageUIID_));
-		replaceMessage(body, myLastMessageUIID_, boost::posix_time::microsec_clock::universal_time(), HighlightAction());
+		replaceMessage(body, myLastMessageUIID_, true, boost::posix_time::microsec_clock::universal_time(), HighlightAction());
 	} else {
 		myLastMessageUIID_ = addMessage(body, QT_TRANSLATE_NOOP("", "me"), true, labelsEnabled_ ? chatWindow_->getSelectedSecurityLabel().getLabel() : boost::shared_ptr<SecurityLabel>(), avatarManager_->getAvatarPath(selfJID_), boost::posix_time::microsec_clock::universal_time(), HighlightAction());
 	}
 
 	if (stanzaChannel_->getStreamManagementEnabled() && !myLastMessageUIID_.empty() ) {
 		chatWindow_->setAckState(myLastMessageUIID_, ChatWindow::Pending);
 		unackedStanzas_[sentStanza] = myLastMessageUIID_;
 	}
 
 	if (sentStanza->getPayload<DeliveryReceiptRequest>()) {
 		requestedReceipts_[sentStanza->getID()] = myLastMessageUIID_;
 		chatWindow_->setMessageReceiptState(myLastMessageUIID_, ChatWindow::ReceiptRequested);
 	}
 
 	lastWasPresence_ = false;
 	chatStateNotifier_->userSentMessage();
 }
 
 void ChatController::handleStanzaAcked(boost::shared_ptr<Stanza> stanza) {
 	std::map<boost::shared_ptr<Stanza>, std::string>::iterator unackedStanza = unackedStanzas_.find(stanza);
 	if (unackedStanza != unackedStanzas_.end()) {
 		chatWindow_->setAckState(unackedStanza->second, ChatWindow::Received);
 		unackedStanzas_.erase(unackedStanza);
 	}
 }
 
 void ChatController::setOnline(bool online) {
 	if (!online) {
 		std::map<boost::shared_ptr<Stanza>, std::string>::iterator it = unackedStanzas_.begin();
 		for ( ; it != unackedStanzas_.end(); ++it) {
 			chatWindow_->setAckState(it->second, ChatWindow::Failed);
 		}
 		unackedStanzas_.clear();
 
 		Presence::ref fakeOffline(new Presence());
diff --git a/Swift/Controllers/Chat/ChatController.h b/Swift/Controllers/Chat/ChatController.h
index f8b6d8b..8b1bb9a 100644
--- a/Swift/Controllers/Chat/ChatController.h
+++ b/Swift/Controllers/Chat/ChatController.h
@@ -1,66 +1,66 @@
 /*
- * Copyright (c) 2010-2013 Kevin Smith
+ * Copyright (c) 2010-2014 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <Swift/Controllers/Chat/ChatControllerBase.h>
 
 #include <map>
 #include <string>
 
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 
 namespace Swift {
 	class AvatarManager;
 	class ChatStateNotifier;
 	class ChatStateTracker;
 	class NickResolver;
 	class EntityCapsProvider;
 	class FileTransferController;
 	class SettingsProvider;
 	class HistoryController;
 	class HighlightManager;
 	class ClientBlockListManager;
 	class UIEvent;
 
 	class ChatController : public ChatControllerBase {
 		public:
-			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, ChatMessageParser* chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider);
+			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);
 			virtual ~ChatController();
 			virtual void setToJID(const JID& jid);
 			virtual void setAvailableServerFeatures(boost::shared_ptr<DiscoInfo> info);
 			virtual void setOnline(bool online);
 			virtual void handleNewFileTransferController(FileTransferController* ftc);
 			virtual void handleWhiteboardSessionRequest(bool senderIsSelf);
 			virtual void handleWhiteboardStateChange(const ChatWindow::WhiteboardSessionState state);
 			virtual void setContactIsReceivingPresence(bool /*isReceivingPresence*/);
 			virtual ChatWindow* detachChatWindow();
 
 		protected:
 			void cancelReplaces();
 			JID getBaseJID();
 			void logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming);
 
 		private:
 			void handlePresenceChange(boost::shared_ptr<Presence> newPresence);
 			std::string getStatusChangeString(boost::shared_ptr<Presence> presence);
 			bool isIncomingMessageFromMe(boost::shared_ptr<Message> message);
 			void postSendMessage(const std::string &body, boost::shared_ptr<Stanza> sentStanza);
 			void preHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent);
 			void postHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent, const HighlightAction&);
 			void preSendMessageRequest(boost::shared_ptr<Message>);
 			std::string senderDisplayNameFromMessage(const JID& from);
 			virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(boost::shared_ptr<Message>) const;
 			void handleStanzaAcked(boost::shared_ptr<Stanza> stanza);
 			void dayTicked() {lastWasPresence_ = false;}
 			void handleContactNickChanged(const JID& jid, const std::string& /*oldNick*/);
 			void handleBareJIDCapsChanged(const JID& jid);
 
 			void handleFileTransferCancel(std::string /* id */);
 			void handleFileTransferStart(std::string /* id */, std::string /* description */);
 			void handleFileTransferAccept(std::string /* id */, std::string /* filename */);
 			void handleSendFileRequest(std::string filename);
 
diff --git a/Swift/Controllers/Chat/ChatControllerBase.cpp b/Swift/Controllers/Chat/ChatControllerBase.cpp
index 23137dc..5363e0c 100644
--- a/Swift/Controllers/Chat/ChatControllerBase.cpp
+++ b/Swift/Controllers/Chat/ChatControllerBase.cpp
@@ -1,80 +1,80 @@
 /*
- * Copyright (c) 2010-2013 Kevin Smith
+ * Copyright (c) 2010-2014 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include <Swift/Controllers/Chat/ChatControllerBase.h>
 
 #include <sstream>
 #include <map>
 
 #include <boost/bind.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
 #include <boost/numeric/conversion/cast.hpp>
 #include <boost/algorithm/string.hpp>
 
 #include <Swiften/Base/format.h>
 #include <Swiften/Base/Path.h>
 #include <Swiften/Base/String.h>
 #include <Swiften/Client/StanzaChannel.h>
 #include <Swiften/Elements/Delay.h>
 #include <Swiften/Elements/MUCInvitationPayload.h>
 #include <Swiften/Elements/MUCUserPayload.h>
 #include <Swiften/Base/foreach.h>
 #include <Swiften/Disco/EntityCapsProvider.h>
 #include <Swiften/Queries/Requests/GetSecurityLabelsCatalogRequest.h>
 #include <Swiften/Avatars/AvatarManager.h>
 
 #include <Swift/Controllers/Intl.h>
 #include <Swift/Controllers/XMPPEvents/EventController.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/MUCInviteEvent.h>
 #include <Swift/Controllers/HighlightManager.h>
 #include <Swift/Controllers/Highlighter.h>
 #include <Swift/Controllers/Chat/AutoAcceptMUCInviteDecider.h>
 #include <Swift/Controllers/Chat/ChatMessageParser.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, 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, 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) {
 	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();
 	setOnline(stanzaChannel->isAvailable() && iqRouter->isAvailable());
 	createDayChangeTimer();
 }
 
 ChatControllerBase::~ChatControllerBase() {
 	delete chatWindow_;
 }
 
 void ChatControllerBase::handleLogCleared() {
 	cancelReplaces();
 }
 
 ChatWindow* ChatControllerBase::detachChatWindow() {
 	ChatWindow* chatWindow = chatWindow_;
 	chatWindow_ = NULL;
 	return chatWindow;
 }
 
 void ChatControllerBase::handleCapsChanged(const JID& jid) {
 	if (jid.compare(toJID_, JID::WithoutResource) == 0) {
 		handleBareJIDCapsChanged(jid);
 	}
 }
 
 void ChatControllerBase::setCanStartImpromptuChats(bool supportsImpromptu) {
 	if (chatWindow_) {
 		chatWindow_->setCanInitiateImpromptuChats(supportsImpromptu);
 	}
 }
@@ -169,150 +169,150 @@ void ChatControllerBase::handleSendMessageRequest(const std::string &body, bool
 	onActivity(message->getBody());
 
 #ifdef SWIFT_EXPERIMENTAL_HISTORY
 	logMessage(body, selfJID_, toJID_, now, false);
 #endif
 }
 
 void ChatControllerBase::handleSecurityLabelsCatalogResponse(boost::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();
 }
 
 std::string ChatControllerBase::addMessage(const std::string& message, const std::string& senderName, bool senderIsSelf, const boost::shared_ptr<SecurityLabel> label, const boost::filesystem::path& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) {
 	if (boost::starts_with(message, "/me ")) {
 		return chatWindow_->addAction(chatMessageParser_->parseMessageBody(String::getSplittedAtFirst(message, ' ').second), senderName, senderIsSelf, label, pathToString(avatarPath), time, highlight);
 	} else {
-		return chatWindow_->addMessage(chatMessageParser_->parseMessageBody(message), senderName, senderIsSelf, label, pathToString(avatarPath), time, highlight);
+		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, const boost::posix_time::ptime& time, const HighlightAction& highlight) {
+void ChatControllerBase::replaceMessage(const std::string& message, const std::string& id, bool senderIsSelf, const boost::posix_time::ptime& time, const HighlightAction& highlight) {
 	if (boost::starts_with(message, "/me ")) {
 		chatWindow_->replaceWithAction(chatMessageParser_->parseMessageBody(String::getSplittedAtFirst(message, ' ').second), id, time, highlight);
 	} else {
-		chatWindow_->replaceMessage(chatMessageParser_->parseMessageBody(message), id, time, highlight);
+		chatWindow_->replaceMessage(chatMessageParser_->parseMessageBody(message,senderIsSelf), id, time, highlight);
 	}
 }
 
 bool ChatControllerBase::isFromContact(const JID& from) {
 	return from.toBare() == toJID_.toBare();
 }
 
 void ChatControllerBase::handleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent) {
 	preHandleIncomingMessage(messageEvent);
 	if (messageEvent->isReadable() && !messageEvent->getConcluded()) {
 		unreadMessages_.push_back(messageEvent);
 		if (messageEvent->targetsMe()) {
 			targetedUnreadMessages_.push_back(messageEvent);
 		}
 	}
 	boost::shared_ptr<Message> message = messageEvent->getStanza();
 	std::string body = message->getBody();
 	HighlightAction highlight;
 	if (message->isError()) {
 		if (!message->getTo().getResource().empty()) {
 			std::string errorMessage = str(format(QT_TRANSLATE_NOOP("", "Couldn't send message: %1%")) % getErrorMessage(message->getPayload<ErrorPayload>()));
 			chatWindow_->addErrorMessage(chatMessageParser_->parseMessageBody(errorMessage));
 		}
 	}
 	else if (messageEvent->getStanza()->getPayload<MUCInvitationPayload>()) {
 		handleMUCInvitation(messageEvent->getStanza());
 		return;
 	}
 	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<boost::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);
 		}
 		boost::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
 		if (!isIncomingMessageFromMe(message)) {
 			 highlight = highlighter_->findAction(body, senderDisplayNameFromMessage(from));
 		}
 
  		boost::shared_ptr<Replace> replace = message->getPayload<Replace>();
 		if (replace) {
 			std::string body = message->getBody();
 			// Should check if the user has a previous message
 			std::map<JID, std::string>::iterator lastMessage;
 			lastMessage = lastMessagesUIID_.find(from);
 			if (lastMessage != lastMessagesUIID_.end()) {
-				replaceMessage(body, lastMessagesUIID_[from], timeStamp, highlight);
+				replaceMessage(body, lastMessagesUIID_[from], isIncomingMessageFromMe(message), timeStamp, highlight);
 			}
 		}
 		else {
 			lastMessagesUIID_[from] = addMessage(body, senderDisplayNameFromMessage(from), isIncomingMessageFromMe(message), label, avatarManager_->getAvatarPath(from), timeStamp, highlight);
 		}
 
 		logMessage(body, from, selfJID_, timeStamp, true);
 	}
 	chatWindow_->show();
 	chatWindow_->setUnreadMessageCount(boost::numeric_cast<int>(unreadMessages_.size()));
 	onUnreadCountChanged();
 	postHandleIncomingMessage(messageEvent, highlight);
 }
 
 std::string ChatControllerBase::getErrorMessage(boost::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");
 			case ErrorPayload::NotAllowed: return QT_TRANSLATE_NOOP("", "Not allowed");
 			case ErrorPayload::NotAuthorized: return QT_TRANSLATE_NOOP("", "Not authorized");
 			case ErrorPayload::PaymentRequired: return QT_TRANSLATE_NOOP("", "Payment is required");
 			case ErrorPayload::RecipientUnavailable: return QT_TRANSLATE_NOOP("", "Recipient is unavailable");
 			case ErrorPayload::Redirect: return QT_TRANSLATE_NOOP("", "Redirect");
diff --git a/Swift/Controllers/Chat/ChatControllerBase.h b/Swift/Controllers/Chat/ChatControllerBase.h
index 7db94a4..cf0a4d2 100644
--- a/Swift/Controllers/Chat/ChatControllerBase.h
+++ b/Swift/Controllers/Chat/ChatControllerBase.h
@@ -1,134 +1,134 @@
 /*
- * Copyright (c) 2010-2013 Kevin Smith
+ * Copyright (c) 2010-2014 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <map>
 #include <vector>
 #include <string>
 
 #include <boost/shared_ptr.hpp>
 #include <boost/filesystem/path.hpp>
 #include <boost/optional.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
 
 #include <Swiften/Network/Timer.h>
 #include <Swiften/Network/TimerFactory.h>
 #include <Swiften/Elements/Stanza.h>
 #include <Swiften/Base/boost_bsignals.h>
 #include <Swiften/Elements/DiscoInfo.h>
 #include <Swiften/JID/JID.h>
 #include <Swiften/Elements/SecurityLabelsCatalog.h>
 #include <Swiften/Elements/ErrorPayload.h>
 #include <Swiften/Presence/PresenceOracle.h>
 #include <Swiften/Queries/IQRouter.h>
 #include <Swiften/Base/IDGenerator.h>
 #include <Swiften/MUC/MUCRegistry.h>
 
 #include <Swift/Controllers/XMPPEvents/MessageEvent.h>
 #include <Swift/Controllers/XMPPEvents/MUCInviteEvent.h>
 #include <Swift/Controllers/HistoryController.h>
 #include <Swift/Controllers/HighlightManager.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 
 namespace Swift {
 	class IQRouter;
 	class StanzaChannel;
 	class ChatWindowFactory;
 	class AvatarManager;
 	class UIEventStream;
 	class EventController;
 	class EntityCapsProvider;
 	class HighlightManager;
 	class Highlighter;
 	class ChatMessageParser;
 	class AutoAcceptMUCInviteDecider;
 
 	class ChatControllerBase : public boost::bsignals::trackable {
 		public:
 			virtual ~ChatControllerBase();
 			void showChatWindow();
 			void activateChatWindow();
 			virtual void setAvailableServerFeatures(boost::shared_ptr<DiscoInfo> info);
 			void handleIncomingMessage(boost::shared_ptr<MessageEvent> message);
 			std::string addMessage(const std::string& message, const std::string& senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const boost::filesystem::path& 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);
+			void replaceMessage(const std::string& message, const std::string& id, bool senderIsSelf, const boost::posix_time::ptime& time, const HighlightAction& highlight);
 			virtual void setOnline(bool online);
 			virtual void setEnabled(bool enabled);
 			virtual void setToJID(const JID& jid) {toJID_ = jid;}
 			/** Used for determining when something is recent.*/
 			boost::signal<void (const std::string& /*activity*/)> onActivity;
 			boost::signal<void ()> onUnreadCountChanged;
 			int getUnreadCount();
 			const JID& getToJID() {return toJID_;}
 			void handleCapsChanged(const JID& jid);
 			void setCanStartImpromptuChats(bool supportsImpromptu);
 			virtual ChatWindow* detachChatWindow();
 			boost::signal<void(ChatWindow* /*window to reuse*/, const std::vector<JID>& /*invite people*/, const std::string& /*reason*/)> onConvertToMUC;
 
 		protected:
-			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, ChatMessageParser* chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider);
+			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);
 
 			/**
 			 * Pass the Message appended, and the stanza used to send it.
 			 */
 			virtual void postSendMessage(const std::string&, boost::shared_ptr<Stanza>) {}
 			virtual std::string senderDisplayNameFromMessage(const JID& from) = 0;
 			virtual bool isIncomingMessageFromMe(boost::shared_ptr<Message>) = 0;
 			virtual void preHandleIncomingMessage(boost::shared_ptr<MessageEvent>) {}
 			virtual void postHandleIncomingMessage(boost::shared_ptr<MessageEvent>, const HighlightAction&) {}
 			virtual void preSendMessageRequest(boost::shared_ptr<Message>) {}
 			virtual bool isFromContact(const JID& from);
 			virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(boost::shared_ptr<Message>) const = 0;
 			virtual void dayTicked() {}
 			virtual void handleBareJIDCapsChanged(const JID& jid) = 0;
 			std::string getErrorMessage(boost::shared_ptr<ErrorPayload>);
 			virtual void setContactIsReceivingPresence(bool /* isReceivingPresence */) {}
 			virtual void cancelReplaces() = 0;
 			/** JID any iq for account should go to - bare except for PMs */
 			virtual JID getBaseJID();
 			virtual void logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming) = 0;
 
 		private:
 			IDGenerator idGenerator_;
 			std::string lastSentMessageStanzaID_;
 			void createDayChangeTimer();
 			void handleSendMessageRequest(const std::string &body, bool isCorrectionMessage);
 			void handleAllMessagesRead();
 			void handleSecurityLabelsCatalogResponse(boost::shared_ptr<SecurityLabelsCatalog>, ErrorPayload::ref error);
 			void handleDayChangeTick();
 			void handleMUCInvitation(Message::ref message);
 			void handleMediatedMUCInvitation(Message::ref message);
 			void handleGeneralMUCInvitation(MUCInviteEvent::ref event);
 			void handleLogCleared();
 
 		protected:
 			JID selfJID_;
 			std::vector<boost::shared_ptr<StanzaEvent> > unreadMessages_;
 			std::vector<boost::shared_ptr<StanzaEvent> > targetedUnreadMessages_;
 			StanzaChannel* stanzaChannel_;
 			IQRouter* iqRouter_;
 			ChatWindowFactory* chatWindowFactory_;
 			ChatWindow* chatWindow_;
 			JID toJID_;
 			bool labelsEnabled_;
 			std::map<JID, std::string> lastMessagesUIID_;
 			PresenceOracle* presenceOracle_;
 			AvatarManager* avatarManager_;
 			bool useDelayForLatency_;
 			EventController* eventController_;
 			boost::shared_ptr<Timer> dateChangeTimer_;
 			TimerFactory* timerFactory_;
 			EntityCapsProvider* entityCapsProvider_;
 			SecurityLabelsCatalog::Item lastLabel_; 
 			HistoryController* historyController_;
 			MUCRegistry* mucRegistry_;
 			Highlighter* highlighter_;
-			ChatMessageParser* chatMessageParser_;
+			boost::shared_ptr<ChatMessageParser> chatMessageParser_;
 			AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider_;
 			UIEventStream* eventStream_;
 	};
 }
diff --git a/Swift/Controllers/Chat/ChatMessageParser.cpp b/Swift/Controllers/Chat/ChatMessageParser.cpp
index 698b766..09d93ac 100644
--- a/Swift/Controllers/Chat/ChatMessageParser.cpp
+++ b/Swift/Controllers/Chat/ChatMessageParser.cpp
@@ -1,90 +1,103 @@
 /*
  * Copyright (c) 2013-2014 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include <Swift/Controllers/Chat/ChatMessageParser.h>
 
 #include <vector>
 #include <utility>
 
 #include <boost/smart_ptr/make_shared.hpp>
 #include <boost/algorithm/string.hpp>
 
 #include <Swiften/Base/Regex.h>
 #include <Swiften/Base/foreach.h>
 
 #include <SwifTools/Linkify.h>
 
 
 namespace Swift {
 
-	ChatMessageParser::ChatMessageParser(const std::map<std::string, std::string>& emoticons) : emoticons_(emoticons) {
-
+	ChatMessageParser::ChatMessageParser(const std::map<std::string, std::string>& emoticons, HighlightRulesListPtr highlightRules, bool mucMode)
+	: emoticons_(emoticons), highlightRules_(highlightRules), mucMode_(mucMode) {
 	}
 
 	typedef std::pair<std::string, std::string> StringPair;
 
-	ChatWindow::ChatMessage ChatMessageParser::parseMessageBody(const std::string& body) {
+	ChatWindow::ChatMessage ChatMessageParser::parseMessageBody(const std::string& body, bool senderIsSelf) {
 		ChatWindow::ChatMessage parsedMessage;
 		std::string remaining = body;
 		/* Parse one, URLs */
 		while (!remaining.empty()) {
 			bool found = false;
 			std::pair<std::vector<std::string>, size_t> links = Linkify::splitLink(remaining);
 			remaining = "";
 			for (size_t i = 0; i < links.first.size(); i++) {
 				const std::string& part = links.first[i];
 				if (found) {
 					// Must be on the last part, then
 					remaining = part;
 				}
 				else {
 					if (i == links.second) {
 						found = true;
 						parsedMessage.append(boost::make_shared<ChatWindow::ChatURIMessagePart>(part));
 					}
 					else {
 						parsedMessage.append(boost::make_shared<ChatWindow::ChatTextMessagePart>(part));
 					}
 				}
 			}
 		}
-		
 
+		/* 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;
 
 		std::string regexString;
 		/* Parse two, emoticons */
 		foreach (StringPair emoticon, emoticons_) {
 			/* Construct a regexp that finds an instance of any of the emoticons inside a group
 			 * at the start or end of the line, or beside whitespace.
 			 */
 			regexString += regexString.empty() ? "" : "|";
 			std::string escaped = "(" + Regex::escape(emoticon.first) + ")";
 			regexString += "^" + escaped + "|";
 			regexString += escaped + "$|";
 			regexString += "\\s" + escaped + "|";
 			regexString += escaped + "\\s";
 
 		}
 		if (!regexString.empty()) {
 			regexString += "";
 			boost::regex emoticonRegex(regexString);
 
 			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, emoticonRegex)) {
 							int matchIndex = 0;
 							for (matchIndex = 1; matchIndex < static_cast<int>(match.size()); matchIndex++) {
 								if (match[matchIndex].length() > 0) {
 									//This is the matching subgroup
 									break;
 								}
 							}
@@ -92,36 +105,90 @@ namespace Swift {
 							std::string::const_iterator matchEnd = match[matchIndex].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::ChatEmoticonMessagePart> emoticonPart = boost::make_shared<ChatWindow::ChatEmoticonMessagePart>();
 							std::string matchString = match[matchIndex].str();
 							std::map<std::string, std::string>::const_iterator emoticonIterator = emoticons_.find(matchString);
 							assert (emoticonIterator != emoticons_.end());
 							const StringPair& emoticon = *emoticonIterator;
 							emoticonPart->imagePath = emoticon.second;
 							emoticonPart->alternativeText = emoticon.first;
 							newMessage.append(emoticonPart);
 							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;
 	}
+
+	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;
+	}
 }
diff --git a/Swift/Controllers/Chat/ChatMessageParser.h b/Swift/Controllers/Chat/ChatMessageParser.h
index c9b9456..cff4ffa 100644
--- a/Swift/Controllers/Chat/ChatMessageParser.h
+++ b/Swift/Controllers/Chat/ChatMessageParser.h
@@ -1,23 +1,26 @@
 /*
- * Copyright (c) 2013 Kevin Smith
+ * Copyright (c) 2013-2014 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <string>
 
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 
 namespace Swift {
 
 	class ChatMessageParser {
 		public:
-			ChatMessageParser(const std::map<std::string, std::string>& emoticons);
-			ChatWindow::ChatMessage parseMessageBody(const std::string& body);
+			ChatMessageParser(const std::map<std::string, std::string>& emoticons, HighlightRulesListPtr highlightRules, bool mucMode = false);
+			ChatWindow::ChatMessage parseMessageBody(const std::string& body, bool senderIsSelf = false);
 		private:
+			ChatWindow::ChatMessage emoticonHighlight(const ChatWindow::ChatMessage& parsedMessage);
+			ChatWindow::ChatMessage splitHighlight(const ChatWindow::ChatMessage& parsedMessage);
 			std::map<std::string, std::string> emoticons_;
-
+			HighlightRulesListPtr highlightRules_;
+			bool mucMode_;
 	};
 }
diff --git a/Swift/Controllers/Chat/ChatsManager.cpp b/Swift/Controllers/Chat/ChatsManager.cpp
index 1698b4a..8a077d1 100644
--- a/Swift/Controllers/Chat/ChatsManager.cpp
+++ b/Swift/Controllers/Chat/ChatsManager.cpp
@@ -113,134 +113,133 @@ ChatsManager::ChatsManager(
 		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,
 		ClientBlockListManager* clientBlockListManager,
 		const std::map<std::string, std::string>& emoticons,
 		UserSearchController* inviteUserSearchController,
 		VCardManager* vcardManager) :
 			jid_(jid), 
 			joinMUCWindowFactory_(joinMUCWindowFactory), 
 			useDelayForLatency_(useDelayForLatency), 
 			mucRegistry_(mucRegistry), 
 			entityCapsProvider_(entityCapsProvider), 
 			mucManager(mucManager),
 			ftOverview_(ftOverview),
 			roster_(roster),
 			eagleMode_(eagleMode),
 			settings_(settings),
 			historyController_(historyController),
 			whiteboardManager_(whiteboardManager),
 			highlightManager_(highlightManager),
+			emoticons_(emoticons),
 			clientBlockListManager_(clientBlockListManager),
 			inviteUserSearchController_(inviteUserSearchController),
 			vcardManager_(vcardManager) {
 	timerFactory_ = timerFactory;
 	eventController_ = eventController;
 	stanzaChannel_ = stanzaChannel;
 	iqRouter_ = iqRouter;
 	chatWindowFactory_ = chatWindowFactory;
 	nickResolver_ = nickResolver;
 	presenceOracle_ = presenceOracle;
 	avatarManager_ = NULL;
 	serverDiscoInfo_ = boost::make_shared<DiscoInfo>();
 	presenceSender_ = presenceSender;
 	uiEventStream_ = uiEventStream;
 	mucBookmarkManager_ = NULL;
 	profileSettings_ = profileSettings;
-	chatMessageParser_ = new ChatMessageParser(emoticons);
 	presenceOracle_->onPresenceChange.connect(boost::bind(&ChatsManager::handlePresenceChange, this, _1));
 	uiEventConnection_ = uiEventStream_->onUIEvent.connect(boost::bind(&ChatsManager::handleUIEvent, this, _1));
 
 	chatListWindow_ = chatListWindowFactory->createChatListWindow(uiEventStream_);
 	chatListWindow_->onMUCBookmarkActivated.connect(boost::bind(&ChatsManager::handleMUCBookmarkActivated, this, _1));
 	chatListWindow_->onRecentActivated.connect(boost::bind(&ChatsManager::handleRecentActivated, this, _1));
 	chatListWindow_->onClearRecentsRequested.connect(boost::bind(&ChatsManager::handleClearRecentsRequested, this));
 
 	joinMUCWindow_ = NULL;
 	mucSearchController_ = new MUCSearchController(jid_, mucSearchWindowFactory, iqRouter, profileSettings_);
 	mucSearchController_->onMUCSelected.connect(boost::bind(&ChatsManager::handleMUCSelectedAfterSearch, this, _1));
 	ftOverview_->onNewFileTransferController.connect(boost::bind(&ChatsManager::handleNewFileTransferController, this, _1));
 	whiteboardManager_->onSessionRequest.connect(boost::bind(&ChatsManager::handleWhiteboardSessionRequest, this, _1, _2));
 	whiteboardManager_->onRequestAccepted.connect(boost::bind(&ChatsManager::handleWhiteboardStateChange, this, _1, ChatWindow::WhiteboardAccepted));
 	whiteboardManager_->onSessionTerminate.connect(boost::bind(&ChatsManager::handleWhiteboardStateChange, this, _1, ChatWindow::WhiteboardTerminated));
 	whiteboardManager_->onRequestRejected.connect(boost::bind(&ChatsManager::handleWhiteboardStateChange, this, _1, ChatWindow::WhiteboardRejected));
 	roster_->onJIDAdded.connect(boost::bind(&ChatsManager::handleJIDAddedToRoster, this, _1));
 	roster_->onJIDRemoved.connect(boost::bind(&ChatsManager::handleJIDRemovedFromRoster, this, _1));
 	roster_->onJIDUpdated.connect(boost::bind(&ChatsManager::handleJIDUpdatedInRoster, this, _1));
 	roster_->onRosterCleared.connect(boost::bind(&ChatsManager::handleRosterCleared, this));
 
 	settings_->onSettingChanged.connect(boost::bind(&ChatsManager::handleSettingChanged, this, _1));
 
 	userWantsReceipts_ = settings_->getSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS);
 
 	setupBookmarks();
 	loadRecents();
 
 	autoAcceptMUCInviteDecider_ = new AutoAcceptMUCInviteDecider(jid.getDomain(), roster_, settings_);
 }
 
 ChatsManager::~ChatsManager() {
 	settings_->onSettingChanged.disconnect(boost::bind(&ChatsManager::handleSettingChanged, this, _1));
 	roster_->onJIDAdded.disconnect(boost::bind(&ChatsManager::handleJIDAddedToRoster, this, _1));
 	roster_->onJIDRemoved.disconnect(boost::bind(&ChatsManager::handleJIDRemovedFromRoster, this, _1));
 	roster_->onJIDUpdated.disconnect(boost::bind(&ChatsManager::handleJIDUpdatedInRoster, this, _1));
 	roster_->onRosterCleared.disconnect(boost::bind(&ChatsManager::handleRosterCleared, this));
 	delete joinMUCWindow_;
 	foreach (JIDChatControllerPair controllerPair, chatControllers_) {
 		delete controllerPair.second;
 	}
 	foreach (JIDMUCControllerPair controllerPair, mucControllers_) {
 		delete controllerPair.second;
 	}
 	delete mucBookmarkManager_;
 	delete mucSearchController_;
-	delete chatMessageParser_;
 	delete autoAcceptMUCInviteDecider_;
 }
 
 void ChatsManager::saveRecents() {
 	std::stringstream serializeStream;
 	boost::archive::text_oarchive oa(serializeStream);
 	std::vector<ChatListWindow::Chat> recentsLimited = std::vector<ChatListWindow::Chat>(recentChats_.begin(), recentChats_.end());
 	if (recentsLimited.size() > 25) {
 		recentsLimited.erase(recentsLimited.begin() + 25, recentsLimited.end());
 	}
 	if (eagleMode_) {
 		foreach(ChatListWindow::Chat& chat, recentsLimited) {
 			chat.activity = "";
 		}
 	}
 
 	oa << recentsLimited;
 	std::string serializedStr = Base64::encode(createByteArray(serializeStream.str()));
 	profileSettings_->storeString(RECENT_CHATS, serializedStr);
 }
 
 void ChatsManager::handleClearRecentsRequested() {
 	recentChats_.clear();
 	saveRecents();
 	handleUnreadCountChanged(NULL);
 }
 
 void ChatsManager::handleJIDAddedToRoster(const JID &jid) {
 	updatePresenceReceivingStateOnChatController(jid);
 }
 
 void ChatsManager::handleJIDRemovedFromRoster(const JID &jid) {
 	updatePresenceReceivingStateOnChatController(jid);
 }
 
@@ -665,71 +664,72 @@ void ChatsManager::setOnline(bool enabled) {
 		delete mucBookmarkManager_;
 		mucBookmarkManager_ = NULL;
 		chatListWindow_->setBookmarksEnabled(false);
 		markAllRecentsOffline();
 	} else {
 		setupBookmarks();
 		localMUCServiceFinderWalker_ = boost::make_shared<DiscoServiceWalker>(jid_.getDomain(), iqRouter_);
 		localMUCServiceFinderWalker_->onServiceFound.connect(boost::bind(&ChatsManager::handleLocalServiceFound, this, _1, _2));
 		localMUCServiceFinderWalker_->onWalkAborted.connect(boost::bind(&ChatsManager::handleLocalServiceWalkFinished, this));
 		localMUCServiceFinderWalker_->onWalkComplete.connect(boost::bind(&ChatsManager::handleLocalServiceWalkFinished, this));
 		localMUCServiceFinderWalker_->beginWalk();
 	}
 
 }
 
 void ChatsManager::handleChatRequest(const std::string &contact) {
 	ChatController* controller = getChatControllerOrFindAnother(JID(contact));
 	controller->activateChatWindow();
 }
 
 ChatController* ChatsManager::getChatControllerOrFindAnother(const JID &contact) {
 	ChatController* controller = getChatControllerIfExists(contact);
 	if (!controller && !mucRegistry_->isMUC(contact.toBare())) {
 		foreach (JIDChatControllerPair pair, chatControllers_) {
 			if (pair.first.toBare() == contact.toBare()) {
 				controller = pair.second;
 				break;
 			}
 		}
 	}
 	return controller ? controller : createNewChatController(contact);
 }
 
 ChatController* ChatsManager::createNewChatController(const JID& contact) {
 	assert(chatControllers_.find(contact) == chatControllers_.end());
-	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(), 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_);
 	chatControllers_[contact] = controller;
 	controller->setAvailableServerFeatures(serverDiscoInfo_);
 	controller->onActivity.connect(boost::bind(&ChatsManager::handleChatActivity, this, contact, _1, false));
 	controller->onUnreadCountChanged.connect(boost::bind(&ChatsManager::handleUnreadCountChanged, this, controller));
 	controller->onConvertToMUC.connect(boost::bind(&ChatsManager::handleTransformChatToMUC, this, controller, _1, _2, _3));
 	updatePresenceReceivingStateOnChatController(contact);
 	controller->setCanStartImpromptuChats(!localMUCServiceJID_.toString().empty());
 	return controller;
 }
 
 ChatController* ChatsManager::getChatControllerOrCreate(const JID &contact) {
 	ChatController* controller = getChatControllerIfExists(contact);
 	return controller ? controller : createNewChatController(contact);
 }
 
 ChatController* ChatsManager::getChatControllerIfExists(const JID &contact, bool rebindIfNeeded) {
 	if (chatControllers_.find(contact) == chatControllers_.end()) {
 		if (mucRegistry_->isMUC(contact.toBare())) {
 			return NULL;
 		}
 		//Need to look for an unbound window to bind first
 		JID bare(contact.toBare());
 		if (chatControllers_.find(bare) != chatControllers_.end()) {
 			rebindControllerJID(bare, contact);
 		} else {
 			foreach (JIDChatControllerPair pair, chatControllers_) {
 				if (pair.first.toBare() == contact.toBare()) {
 					if (rebindIfNeeded) {
 						rebindControllerJID(pair.first, contact);
 						return chatControllers_[contact];
 					} else {
 						return pair.second;
 					}
 				}
 			}
@@ -749,71 +749,72 @@ MUC::ref ChatsManager::handleJoinMUCRequest(const JID &mucJID, const boost::opti
 	MUC::ref muc;
 	if (!stanzaChannel_->isAvailable()) {
 		/* This is potentially not the optimal solution, but it will avoid consistency issues.*/
 		return muc;
 	}
 	if (addAutoJoin) {
 		MUCBookmark bookmark(mucJID, mucJID.getNode());
 		bookmark.setAutojoin(true);
 		if (nickMaybe) {
 			bookmark.setNick(*nickMaybe);
 		}
 		if (password) {
 			bookmark.setPassword(*password);
 		}
 		mucBookmarkManager_->addBookmark(bookmark);
 	}
 
 	std::map<JID, MUCController*>::iterator it = mucControllers_.find(mucJID);
 	if (it != mucControllers_.end()) {
 		it->second->rejoin();
 	} else {
 		std::string nick = (nickMaybe && !(*nickMaybe).empty()) ? nickMaybe.get() : nickResolver_->jidToNick(jid_);
 		muc = mucManager->createMUC(mucJID);
 		if (createAsReservedIfNew) {
 			muc->setCreateAsReservedIfNew();
 		}
 		if (isImpromptu) {
 			muc->setCreateAsReservedIfNew();
 		}
 
 		MUCController* controller = NULL;
 		SingleChatWindowFactoryAdapter* chatWindowFactoryAdapter = NULL;
 		if (reuseChatwindow) {
 			chatWindowFactoryAdapter = new SingleChatWindowFactoryAdapter(reuseChatwindow);
 		}
-		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_);
+		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_);
 		if (chatWindowFactoryAdapter) {
 			/* The adapters are only passed to chat windows, which are deleted in their
 			 * controllers' dtor, which are deleted in ChatManager's dtor. The adapters
 			 * are also deleted there.*/
 			chatWindowFactoryAdapters_[controller] = chatWindowFactoryAdapter;
 		}
 
 		mucControllers_[mucJID] = controller;
 		controller->setAvailableServerFeatures(serverDiscoInfo_);
 		controller->onUserLeft.connect(boost::bind(&ChatsManager::handleUserLeftMUC, this, controller));
 		controller->onUserJoined.connect(boost::bind(&ChatsManager::handleChatActivity, this, mucJID.toBare(), "", true));
 		controller->onActivity.connect(boost::bind(&ChatsManager::handleChatActivity, this, mucJID.toBare(), _1, true));
 		controller->onUnreadCountChanged.connect(boost::bind(&ChatsManager::handleUnreadCountChanged, this, controller));
 		handleChatActivity(mucJID.toBare(), "", true);
 	}
 
 	mucControllers_[mucJID]->showChatWindow();
 	return muc;
 }
 
 void ChatsManager::handleSearchMUCRequest() {
 	mucSearchController_->openSearchWindow();
 }
 
 void ChatsManager::handleIncomingMessage(boost::shared_ptr<Message> message) {
 	JID jid = message->getFrom();
 	boost::shared_ptr<MessageEvent> event(new MessageEvent(message));
 	bool isInvite = !!message->getPayload<MUCInvitationPayload>();
 	bool isMediatedInvite = (message->getPayload<MUCUserPayload>() && message->getPayload<MUCUserPayload>()->getInvite());
 	if (isMediatedInvite) {
 		jid = (*message->getPayload<MUCUserPayload>()->getInvite()).from;
 	}
 	if (!event->isReadable() && !message->getPayload<ChatState>() && !message->getPayload<DeliveryReceipt>() && !message->getPayload<DeliveryReceiptRequest>() && !isInvite && !isMediatedInvite && !message->hasSubject()) {
 		return;
 	}
diff --git a/Swift/Controllers/Chat/ChatsManager.h b/Swift/Controllers/Chat/ChatsManager.h
index 88a0986..41435d9 100644
--- a/Swift/Controllers/Chat/ChatsManager.h
+++ b/Swift/Controllers/Chat/ChatsManager.h
@@ -142,45 +142,45 @@ namespace Swift {
 			std::map<JID, MUCController*> mucControllers_;
 			std::map<JID, ChatController*> chatControllers_;
 			std::map<ChatControllerBase*, SingleChatWindowFactoryAdapter*> chatWindowFactoryAdapters_;
 			EventController* eventController_;
 			JID jid_;
 			StanzaChannel* stanzaChannel_;
 			IQRouter* iqRouter_;
 			ChatWindowFactory* chatWindowFactory_;
 			JoinMUCWindowFactory* joinMUCWindowFactory_;
 			NickResolver* nickResolver_;
 			PresenceOracle* presenceOracle_;
 			AvatarManager* avatarManager_;
 			PresenceSender* presenceSender_;
 			UIEventStream* uiEventStream_;
 			MUCBookmarkManager* mucBookmarkManager_;
 			boost::shared_ptr<DiscoInfo> serverDiscoInfo_;
 			ChatListWindow* chatListWindow_;
 			JoinMUCWindow* joinMUCWindow_;
 			boost::bsignals::scoped_connection uiEventConnection_;
 			bool useDelayForLatency_;
 			TimerFactory* timerFactory_;
 			MUCRegistry* mucRegistry_;
 			EntityCapsProvider* entityCapsProvider_;
 			MUCManager* mucManager;
 			MUCSearchController* mucSearchController_;
 			std::list<ChatListWindow::Chat> recentChats_;
 			ProfileSettingsProvider* profileSettings_;
 			FileTransferOverview* ftOverview_;
 			XMPPRoster* roster_;
 			bool eagleMode_;
 			bool userWantsReceipts_;
 			SettingsProvider* settings_;
 			HistoryController* historyController_;
 			WhiteboardManager* whiteboardManager_;
 			HighlightManager* highlightManager_;
+			std::map<std::string, std::string> emoticons_;
 			ClientBlockListManager* clientBlockListManager_;
-			ChatMessageParser* chatMessageParser_;
 			JID localMUCServiceJID_;
 			boost::shared_ptr<DiscoServiceWalker> localMUCServiceFinderWalker_;
 			AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider_;
 			UserSearchController* inviteUserSearchController_;
 			IDGenerator idGenerator_;
 			VCardManager* vcardManager_;
 	};
 }
diff --git a/Swift/Controllers/Chat/MUCController.cpp b/Swift/Controllers/Chat/MUCController.cpp
index d09bc3d..b467227 100644
--- a/Swift/Controllers/Chat/MUCController.cpp
+++ b/Swift/Controllers/Chat/MUCController.cpp
@@ -39,71 +39,71 @@
 #include <Swift/Controllers/UIEvents/RequestAddUserDialogUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestChatUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestInviteToMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/ShowProfileForRosterItemUIEvent.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>
 
 #define MUC_JOIN_WARNING_TIMEOUT_MILLISECONDS 60000
 
 namespace Swift {
 	
 /**
  * The controller does not gain ownership of the stanzaChannel, nor the factory.
  */
 MUCController::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* uiEventStream,
 		bool useDelayForLatency,
 		TimerFactory* timerFactory,
 		EventController* eventController,
 		EntityCapsProvider* entityCapsProvider,
 		XMPPRoster* roster,
 		HistoryController* historyController,
 		MUCRegistry* mucRegistry,
 		HighlightManager* highlightManager,
-		ChatMessageParser* chatMessageParser,
+		boost::shared_ptr<ChatMessageParser> chatMessageParser,
 		bool isImpromptu,
 		AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider,
 		VCardManager* vcardManager) :
 	ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, timerFactory, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider), muc_(muc), nick_(nick), desiredNick_(nick), password_(password), renameCounter_(0), isImpromptu_(isImpromptu), isImpromptuAlreadyConfigured_(false) {
 	parting_ = true;
 	joined_ = false;
 	lastWasPresence_ = false;
 	shouldJoinOnReconnect_ = true;
 	doneGettingHistory_ = false;
 	events_ = uiEventStream;
 	xmppRoster_ = roster;
 	
 	roster_ = new Roster(false, true);
 	rosterVCardProvider_ = new RosterVCardProvider(roster_, vcardManager, JID::WithResource);
 	completer_ = new TabComplete();
 	chatWindow_->setRosterModel(roster_);
 	chatWindow_->setTabComplete(completer_);
 	chatWindow_->onClosed.connect(boost::bind(&MUCController::handleWindowClosed, this));
 	chatWindow_->onOccupantSelectionChanged.connect(boost::bind(&MUCController::handleWindowOccupantSelectionChanged, this, _1));
 	chatWindow_->onOccupantActionSelected.connect(boost::bind(&MUCController::handleActionRequestedOnOccupant, this, _1, _2));
 	chatWindow_->onChangeSubjectRequest.connect(boost::bind(&MUCController::handleChangeSubjectRequest, this, _1));
 	chatWindow_->onBookmarkRequest.connect(boost::bind(&MUCController::handleBookmarkRequest, this));
 	chatWindow_->onConfigureRequest.connect(boost::bind(&MUCController::handleConfigureRequest, this, _1));
 	chatWindow_->onConfigurationFormCancelled.connect(boost::bind(&MUCController::handleConfigurationCancelled, this));
 	chatWindow_->onDestroyRequest.connect(boost::bind(&MUCController::handleDestroyRoomRequest, this));
 	chatWindow_->onInviteToChat.connect(boost::bind(&MUCController::handleInvitePersonToThisMUCRequest, this, _1));
 	chatWindow_->onGetAffiliationsRequest.connect(boost::bind(&MUCController::handleGetAffiliationsRequest, this));
 	chatWindow_->onChangeAffiliationsRequest.connect(boost::bind(&MUCController::handleChangeAffiliationsRequest, this, _1));
 	muc_->onJoinComplete.connect(boost::bind(&MUCController::handleJoinComplete, this, _1));
 	muc_->onJoinFailed.connect(boost::bind(&MUCController::handleJoinFailed, this, _1));
 	muc_->onOccupantJoined.connect(boost::bind(&MUCController::handleOccupantJoined, this, _1));
 	muc_->onOccupantPresenceChange.connect(boost::bind(&MUCController::handleOccupantPresenceChange, this, _1));
 	muc_->onOccupantLeft.connect(boost::bind(&MUCController::handleOccupantLeft, this, _1, _2, _3));
 	muc_->onRoleChangeFailed.connect(boost::bind(&MUCController::handleOccupantRoleChangeFailed, this, _1, _2, _3));
 	muc_->onAffiliationListReceived.connect(boost::bind(&MUCController::handleAffiliationListReceived, this, _1, _2));
diff --git a/Swift/Controllers/Chat/MUCController.h b/Swift/Controllers/Chat/MUCController.h
index feffaba..b5b5837 100644
--- a/Swift/Controllers/Chat/MUCController.h
+++ b/Swift/Controllers/Chat/MUCController.h
@@ -18,71 +18,71 @@
 #include <Swiften/Elements/Message.h>
 #include <Swiften/Elements/DiscoInfo.h>
 #include <Swiften/JID/JID.h>
 #include <Swiften/MUC/MUC.h>
 #include <Swiften/Elements/MUCOccupant.h>
 
 #include <Swift/Controllers/Chat/ChatControllerBase.h>
 #include <Swift/Controllers/Roster/RosterItem.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 
 namespace Swift {
 	class StanzaChannel;
 	class IQRouter;
 	class ChatWindowFactory;
 	class Roster;
 	class AvatarManager;
 	class UIEventStream;
 	class TimerFactory;
 	class TabComplete;
 	class XMPPRoster;
 	class HighlightManager;
 	class UIEvent;
 	class VCardManager;
 	class RosterVCardProvider;
 
 	enum JoinPart {Join, Part, JoinThenPart, PartThenJoin};
 
 	struct NickJoinPart {
 			NickJoinPart(const std::string& nick, JoinPart type) : nick(nick), type(type) {}
 			std::string nick;
 			JoinPart type;
 	};
 
 	class MUCController : public ChatControllerBase {
 		public:
-			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, ChatMessageParser* chatMessageParser, bool isImpromptu, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, VCardManager* vcardManager);
+			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);
 			virtual ~MUCController();
 			boost::signal<void ()> onUserLeft;
 			boost::signal<void ()> onUserJoined;
 			boost::signal<void ()> onImpromptuConfigCompleted;
 			virtual void setOnline(bool online);
 			void rejoin();
 			static void appendToJoinParts(std::vector<NickJoinPart>& joinParts, const NickJoinPart& newEvent);
 			static std::string generateJoinPartString(const std::vector<NickJoinPart>& joinParts, bool isImpromptu);
 			static std::string concatenateListOfNames(const std::vector<NickJoinPart>& joinParts);
 			bool isJoined();
 			const std::string& getNick();
 			const boost::optional<std::string> getPassword() const;
 			bool isImpromptu() const;
 			std::map<std::string, JID> getParticipantJIDs() const;
 			void sendInvites(const std::vector<JID>& jids, const std::string& reason) const;
 		
 		protected:
 			void preSendMessageRequest(boost::shared_ptr<Message> message);
 			bool isIncomingMessageFromMe(boost::shared_ptr<Message> message);
 			std::string senderDisplayNameFromMessage(const JID& from);
 			boost::optional<boost::posix_time::ptime> getMessageTimestamp(boost::shared_ptr<Message> message) const;
 			void preHandleIncomingMessage(boost::shared_ptr<MessageEvent>);
 			void postHandleIncomingMessage(boost::shared_ptr<MessageEvent>, const HighlightAction&);
 			void cancelReplaces();
 			void logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming);
 
 		private:
 			void setAvailableRoomActions(const MUCOccupant::Affiliation& affiliation, const MUCOccupant::Role& role);
 			void clearPresenceQueue();
 			void addPresenceMessage(const std::string& message);
 			void handleWindowOccupantSelectionChanged(ContactRosterItem* item);
 			void handleActionRequestedOnOccupant(ChatWindow::OccupantAction, ContactRosterItem* item);
 			void handleWindowClosed();
 			void handleAvatarChanged(const JID& jid);
 			void handleOccupantJoined(const MUCOccupant& occupant);
diff --git a/Swift/Controllers/Chat/UnitTest/ChatMessageParserTest.cpp b/Swift/Controllers/Chat/UnitTest/ChatMessageParserTest.cpp
index 0a14303..5dca63a 100644
--- a/Swift/Controllers/Chat/UnitTest/ChatMessageParserTest.cpp
+++ b/Swift/Controllers/Chat/UnitTest/ChatMessageParserTest.cpp
@@ -16,110 +16,216 @@ class ChatMessageParserTest : public CppUnit::TestFixture {
 	CPPUNIT_TEST_SUITE(ChatMessageParserTest);
 	CPPUNIT_TEST(testFullBody);
 	CPPUNIT_TEST(testOneEmoticon);
 	CPPUNIT_TEST(testBareEmoticon);
 	CPPUNIT_TEST(testHiddenEmoticon);
 	CPPUNIT_TEST(testEndlineEmoticon);
 	CPPUNIT_TEST(testBoundedEmoticons);
 	CPPUNIT_TEST_SUITE_END();
 	
 public:
 	void setUp() {
 		smile1_ = ":)";
 		smile1Path_ = "/blah/smile1.png";
 		smile2_ = ":(";
 		smile2Path_ = "/blah/smile2.jpg";
 		emoticons_[smile1_] = smile1Path_;
 		emoticons_[smile2_] = smile2Path_;
 	}
 	
 	void tearDown() {
 		emoticons_.clear();
 	}
 
 	void assertText(const ChatWindow::ChatMessage& result, size_t index, const std::string& text) {
 		boost::shared_ptr<ChatWindow::ChatTextMessagePart> part = boost::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(result.getParts()[index]);
 		CPPUNIT_ASSERT_EQUAL(text, part->text);
 	}
 
 	void assertEmoticon(const ChatWindow::ChatMessage& result, size_t index, const std::string& text, const std::string& path) {
 		boost::shared_ptr<ChatWindow::ChatEmoticonMessagePart> part = boost::dynamic_pointer_cast<ChatWindow::ChatEmoticonMessagePart>(result.getParts()[index]);
 		CPPUNIT_ASSERT(!!part);
 		CPPUNIT_ASSERT_EQUAL(text, part->alternativeText);
 		CPPUNIT_ASSERT_EQUAL(path, part->imagePath);
 	}
 
+	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);
+	}
+
 	void assertURL(const ChatWindow::ChatMessage& result, size_t index, const std::string& text) {
 		boost::shared_ptr<ChatWindow::ChatURIMessagePart> part = boost::dynamic_pointer_cast<ChatWindow::ChatURIMessagePart>(result.getParts()[index]);
 		CPPUNIT_ASSERT_EQUAL(text, part->target);
 	}
 
+	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;
+	}
+
 	void testFullBody() {
-		ChatMessageParser testling(emoticons_);
-		ChatWindow::ChatMessage result = testling.parseMessageBody(":) shiny :( :) http://wonderland.lit/blah http://denmark.lit boom boom");
+		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");
 		assertEmoticon(result, 0, smile1_, smile1Path_);
 		assertText(result, 1, " shiny ");
 		assertEmoticon(result, 2, smile2_, smile2Path_);
 		assertText(result, 3, " ");
-		assertEmoticon(result, 4, smile1_, smile1Path_);
+		assertHighlight(result, 4, "trigger");
 		assertText(result, 5, " ");
-		assertURL(result, 6, "http://wonderland.lit/blah");
+		assertEmoticon(result, 6, smile1_, smile1Path_);
 		assertText(result, 7, " ");
-		assertURL(result, 8, "http://denmark.lit");
-		assertText(result, 9, " boom boom");
+		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");
 	}
 
 	void testOneEmoticon() {
-		ChatMessageParser testling(emoticons_);
+		ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());
 		ChatWindow::ChatMessage result = testling.parseMessageBody(" :) ");
 		assertText(result, 0, " ");
 		assertEmoticon(result, 1, smile1_, smile1Path_);
 		assertText(result, 2, " ");
 	}
 
 
 	void testBareEmoticon() {
-		ChatMessageParser testling(emoticons_);
+		ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());
 		ChatWindow::ChatMessage result = testling.parseMessageBody(":)");
 		assertEmoticon(result, 0, smile1_, smile1Path_);
 	}
 
 	void testHiddenEmoticon() {
-		ChatMessageParser testling(emoticons_);
+		ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());
 		ChatWindow::ChatMessage result = testling.parseMessageBody("b:)a");
 		assertText(result, 0, "b:)a");
 	}
 
 	void testEndlineEmoticon() {
-		ChatMessageParser testling(emoticons_);
+		ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());
 		ChatWindow::ChatMessage result = testling.parseMessageBody("Lazy:)");
 		assertText(result, 0, "Lazy");
 		assertEmoticon(result, 1, smile1_, smile1Path_);
 	}
 
 	void testBoundedEmoticons() {
-		ChatMessageParser testling(emoticons_);
+		ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());
 		ChatWindow::ChatMessage result = testling.parseMessageBody(":)Lazy:(");
 		assertEmoticon(result, 0, smile1_, smile1Path_);
 		assertText(result, 1, "Lazy");
 		assertEmoticon(result, 2, smile2_, smile2Path_);
 	}
 
 	void testEmoticonParenthesis() {
-		ChatMessageParser testling(emoticons_);
+		ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());
 		ChatWindow::ChatMessage result = testling.parseMessageBody("(Like this :))");
 		assertText(result, 0, "(Like this ");
 		assertEmoticon(result, 1, smile1_, smile1Path_);
 		assertText(result, 2, ")");
 	}
 
-
 private:
 	std::map<std::string, std::string> emoticons_;
 	std::string smile1_;
 	std::string smile1Path_;
 	std::string smile2_;
 	std::string smile2Path_;
 };
 
 CPPUNIT_TEST_SUITE_REGISTRATION(ChatMessageParserTest);
-
diff --git a/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp b/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp
index 7268878..bb22e43 100644
--- a/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp
+++ b/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp
@@ -1,37 +1,37 @@
 /*
- * Copyright (c) 2010-2013 Kevin Smith
+ * Copyright (c) 2010-2014 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 #include <boost/algorithm/string.hpp>
 #include <hippomocks.h>
 
 #include "Swiften/Base/foreach.h"
 #include "Swift/Controllers/XMPPEvents/EventController.h"
 #include "Swiften/Presence/DirectedPresenceSender.h"
 #include "Swiften/Presence/StanzaChannelPresenceSender.h"
 #include "Swiften/Avatars/NullAvatarManager.h"
 #include "Swift/Controllers/Chat/MUCController.h"
 #include "Swift/Controllers/UIInterfaces/ChatWindow.h"
 #include "Swift/Controllers/UIInterfaces/ChatWindowFactory.h"
 #include "Swiften/Client/NickResolver.h"
 #include "Swiften/Roster/XMPPRoster.h"
 #include "Swift/Controllers/UIEvents/UIEventStream.h"
 #include "Swift/Controllers/UnitTest/MockChatWindow.h"
 #include "Swiften/MUC/UnitTest/MockMUC.h"
 #include "Swiften/Client/DummyStanzaChannel.h"
 #include "Swiften/Queries/DummyIQChannel.h"
 #include "Swiften/Presence/PresenceOracle.h"
 #include "Swiften/Network/TimerFactory.h"
 #include "Swiften/Elements/MUCUserPayload.h"
 #include "Swiften/Disco/DummyEntityCapsProvider.h"
 #include <Swiften/VCards/VCardMemoryStorage.h>
 #include <Swiften/Crypto/PlatformCryptoProvider.h>
 #include <Swiften/VCards/VCardManager.h>
 #include <Swift/Controllers/Settings/DummySettingsProvider.h>
 #include <Swift/Controllers/Chat/ChatMessageParser.h>
 #include <Swift/Controllers/Chat/UserSearchController.h>
 #include <Swift/Controllers/UIInterfaces/UserSearchWindowFactory.h>
@@ -49,95 +49,94 @@ class MUCControllerTest : public CppUnit::TestFixture {
 	CPPUNIT_TEST(testAddressedToSelf);
 	CPPUNIT_TEST(testNotAddressedToSelf);
 	CPPUNIT_TEST(testAddressedToSelfBySelf);
 	CPPUNIT_TEST(testMessageWithEmptyLabelItem);
 	CPPUNIT_TEST(testMessageWithLabelItem);
 	CPPUNIT_TEST(testCorrectMessageWithLabelItem);
 	CPPUNIT_TEST(testRoleAffiliationStates);
 	CPPUNIT_TEST_SUITE_END();
 
 public:
 	void setUp() {
 		crypto_ = boost::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());
 		self_ = JID("girl@wonderland.lit/rabbithole");
 		nick_ = "aLiCe";
 		mucJID_ = JID("teaparty@rooms.wonderland.lit");
 		mocks_ = new MockRepository();
 		stanzaChannel_ = new DummyStanzaChannel();
 		iqChannel_ = new DummyIQChannel();
 		iqRouter_ = new IQRouter(iqChannel_);
 		eventController_ = new EventController();
 		chatWindowFactory_ = mocks_->InterfaceMock<ChatWindowFactory>();
 		userSearchWindowFactory_ = mocks_->InterfaceMock<UserSearchWindowFactory>();
 		presenceOracle_ = new PresenceOracle(stanzaChannel_);
 		presenceSender_ = new StanzaChannelPresenceSender(stanzaChannel_);
 		directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);
 		uiEventStream_ = new UIEventStream();
 		avatarManager_ = new NullAvatarManager();
 		TimerFactory* timerFactory = NULL;
 		window_ = new MockChatWindow();
 		mucRegistry_ = new MUCRegistry();
 		entityCapsProvider_ = new DummyEntityCapsProvider();
 		settings_ = new DummySettingsProvider();
 		highlightManager_ = new HighlightManager(settings_);
 		muc_ = boost::make_shared<MockMUC>(mucJID_);
 		mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(muc_->getJID(), uiEventStream_).Return(window_);
-		chatMessageParser_ = new ChatMessageParser(std::map<std::string, std::string>());
+		chatMessageParser_ = boost::make_shared<ChatMessageParser>(std::map<std::string, std::string>(), highlightManager_->getRules(), true);
 		vcardStorage_ = new VCardMemoryStorage(crypto_.get());
 		vcardManager_ = new VCardManager(self_, iqRouter_, vcardStorage_);
 		controller_ = new MUCController (self_, muc_, boost::optional<std::string>(), nick_, stanzaChannel_, iqRouter_, chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory, eventController_, entityCapsProvider_, NULL, NULL, mucRegistry_, highlightManager_, chatMessageParser_, false, NULL, vcardManager_);
 	}
 
 	void tearDown() {
 		delete controller_;
 		delete vcardManager_;
 		delete vcardStorage_;
 		delete highlightManager_;
 		delete settings_;
 		delete entityCapsProvider_;
 		delete eventController_;
 		delete presenceOracle_;
 		delete mocks_;
 		delete uiEventStream_;
 		delete stanzaChannel_;
 		delete presenceSender_;
 		delete directedPresenceSender_;
 		delete iqRouter_;
 		delete iqChannel_;
 		delete mucRegistry_;
 		delete avatarManager_;
-		delete chatMessageParser_;
 	}
 
 	void finishJoin() {
 		Presence::ref presence(new Presence());
 		presence->setFrom(JID(muc_->getJID().toString() + "/" + nick_));
 		MUCUserPayload::ref status(new MUCUserPayload());
 		MUCUserPayload::StatusCode code;
 		code.code = 110;
 		status->addStatusCode(code);
 		presence->addPayload(status);
 		stanzaChannel_->onPresenceReceived(presence);
 	}
 
 	void testAddressedToSelf() {
 		finishJoin();
 		Message::ref message(new Message());
 
 		message = Message::ref(new Message());
 		message->setFrom(JID(muc_->getJID().toString() + "/otherperson"));
 		message->setBody("basic " + nick_ + " test.");
 		message->setType(Message::Groupchat);
 		controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));
 		CPPUNIT_ASSERT_EQUAL((size_t)1, eventController_->getEvents().size());
 
 		message = Message::ref(new Message());
 		message->setFrom(JID(muc_->getJID().toString() + "/otherperson"));
 		message->setBody(nick_ + ": hi there");
 		message->setType(Message::Groupchat);
 		controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));
 		CPPUNIT_ASSERT_EQUAL((size_t)2, eventController_->getEvents().size());
 
 		message->setFrom(JID(muc_->getJID().toString() + "/other"));
 		message->setBody("Hi there " + nick_);
 		message->setType(Message::Groupchat);
 		controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));
@@ -397,43 +396,43 @@ public:
 			foreach(RosterItem* childItem, child->getChildren()) {
 				ContactRosterItem* item = dynamic_cast<ContactRosterItem*>(childItem);
 				CPPUNIT_ASSERT(item);
 				std::map<std::string, MUCOccupant>::const_iterator occupant = occupants.find(item->getJID().getResource());
 				CPPUNIT_ASSERT(occupant != occupants.end());
 				CPPUNIT_ASSERT(item->getMUCRole() == occupant->second.getRole());
 				CPPUNIT_ASSERT(item->getMUCAffiliation() == occupant->second.getAffiliation());
 			}
 		}
 	}
 
 private:
 	JID self_;
 	JID mucJID_;
 	MockMUC::ref muc_;
 	std::string nick_;
 	DummyStanzaChannel* stanzaChannel_;
 	DummyIQChannel* iqChannel_;
 	IQRouter* iqRouter_;
 	EventController* eventController_;
 	ChatWindowFactory* chatWindowFactory_;
 	UserSearchWindowFactory* userSearchWindowFactory_;
 	MUCController* controller_;
 //	NickResolver* nickResolver_;
 	PresenceOracle* presenceOracle_;
 	AvatarManager* avatarManager_;
 	StanzaChannelPresenceSender* presenceSender_;
 	DirectedPresenceSender* directedPresenceSender_;
 	MockRepository* mocks_;
 	UIEventStream* uiEventStream_;
 	MockChatWindow* window_;
 	MUCRegistry* mucRegistry_;
 	DummyEntityCapsProvider* entityCapsProvider_;
 	DummySettingsProvider* settings_;
 	HighlightManager* highlightManager_;
-	ChatMessageParser* chatMessageParser_;
+	boost::shared_ptr<ChatMessageParser> chatMessageParser_;
 	boost::shared_ptr<CryptoProvider> crypto_;
 	VCardManager* vcardManager_;
 	VCardMemoryStorage* vcardStorage_;
 };
 
 CPPUNIT_TEST_SUITE_REGISTRATION(MUCControllerTest);