16 files changed, 365 insertions, 92 deletions
diff --git a/Swift/Controllers/Chat/ChatController.cpp b/Swift/Controllers/Chat/ChatController.cpp
index fe8e870..7fb9c59 100644
--- a/Swift/Controllers/Chat/ChatController.cpp
+++ b/Swift/Controllers/Chat/ChatController.cpp
@@ -1,86 +1,86 @@
 /*
- * Copyright (c) 2010-2017 Isode Limited.
+ * Copyright (c) 2010-2018 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swift/Controllers/Chat/ChatController.h>
 
 #include <memory>
 
 #include <boost/bind.hpp>
 
 #include <Swiften/Avatars/AvatarManager.h>
 #include <Swiften/Base/Algorithm.h>
 #include <Swiften/Base/Log.h>
 #include <Swiften/Base/Path.h>
 #include <Swiften/Base/format.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/Disco/FeatureOracle.h>
 #include <Swiften/Elements/DeliveryReceipt.h>
 #include <Swiften/Elements/DeliveryReceiptRequest.h>
 #include <Swiften/Elements/Idle.h>
 #include <Swiften/FileTransfer/FileTransferManager.h>
 #include <Swiften/Network/TimerFactory.h>
 
 #include <Swift/Controllers/Chat/ChatMessageParser.h>
 #include <Swift/Controllers/FileTransfer/FileTransferController.h>
 #include <Swift/Controllers/Highlighting/Highlighter.h>
 #include <Swift/Controllers/Intl.h>
 #include <Swift/Controllers/SettingConstants.h>
 #include <Swift/Controllers/StatusUtil.h>
 #include <Swift/Controllers/Translator.h>
 #include <Swift/Controllers/UIEvents/AcceptWhiteboardSessionUIEvent.h>
 #include <Swift/Controllers/UIEvents/CancelWhiteboardSessionUIEvent.h>
 #include <Swift/Controllers/UIEvents/InviteToMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestChangeBlockStateUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestInviteToMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/SendFileUIEvent.h>
 #include <Swift/Controllers/UIEvents/ShowWhiteboardUIEvent.h>
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindowFactory.h>
 #include <Swift/Controllers/XMPPEvents/EventController.h>
 #include <Swift/Controllers/XMPPEvents/IncomingFileTransferEvent.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, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, SettingsProvider* settings, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider)
-    : ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, nickResolver, presenceOracle, avatarManager, useDelayForLatency, eventStream, eventController, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider), userWantsReceipts_(userWantsReceipts), settings_(settings), clientBlockListManager_(clientBlockListManager) {
+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, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings)
+    : ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, nickResolver, presenceOracle, avatarManager, useDelayForLatency, eventStream, eventController, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider, settings), userWantsReceipts_(userWantsReceipts), clientBlockListManager_(clientBlockListManager) {
     isInMUC_ = isInMUC;
     lastWasPresence_ = false;
     chatStateNotifier_ = new ChatStateNotifier(stanzaChannel, contact, entityCapsProvider, timerFactory, 20000);
     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->getAccountPresence(contact) : presenceOracle->getLastPresence(contact);
     }
     Idle::ref idle;
     if (theirPresence && (idle = theirPresence->getPayload<Idle>())) {
         startMessage += str(format(QT_TRANSLATE_NOOP("", ", who has been idle since %1%")) % Swift::Translator::getInstance()->ptimeToHumanReadableString(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);
diff --git a/Swift/Controllers/Chat/ChatController.h b/Swift/Controllers/Chat/ChatController.h
index d290d05..c65eb9c 100644
--- a/Swift/Controllers/Chat/ChatController.h
+++ b/Swift/Controllers/Chat/ChatController.h
@@ -1,63 +1,63 @@
 /*
- * Copyright (c) 2010-2017 Isode Limited.
+ * Copyright (c) 2010-2018 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #pragma once
 
 #include <map>
 #include <string>
 
 #include <Swiften/Base/Tristate.h>
 
 #include <Swift/Controllers/Chat/ChatControllerBase.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 
 namespace Swift {
     class AvatarManager;
     class ChatStateNotifier;
     class ChatStateTracker;
     class ClientBlockListManager;
     class EntityCapsProvider;
     class FileTransferController;
     class HighlightManager;
     class HistoryController;
     class NickResolver;
     class SettingsProvider;
     class TimerFactory;
     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, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, SettingsProvider* settings, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<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, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings);
             virtual ~ChatController() override;
             virtual void setToJID(const JID& jid) override;
             virtual void setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info) override;
             virtual void setOnline(bool online) override;
             virtual void handleNewFileTransferController(FileTransferController* ftc);
             virtual void handleWhiteboardSessionRequest(bool senderIsSelf);
             virtual void handleWhiteboardStateChange(const ChatWindow::WhiteboardSessionState state);
             virtual void setContactIsReceivingPresence(bool /*isReceivingPresence*/) override;
             virtual ChatWindow* detachChatWindow() override;
             virtual void handleIncomingOwnMessage(std::shared_ptr<Message> message) override;
 
         protected:
             virtual void cancelReplaces() override;
             virtual JID getBaseJID() override;
             virtual void logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming) override;
             virtual bool shouldIgnoreMessage(std::shared_ptr<Message> message) override;
             virtual JID messageCorrectionJID(const JID& fromJID) override;
 
         private:
             void handlePresenceChange(std::shared_ptr<Presence> newPresence);
             std::string getStatusChangeString(std::shared_ptr<Presence> presence);
             virtual bool isIncomingMessageFromMe(std::shared_ptr<Message> message) override;
             virtual void postSendMessage(const std::string &body, std::shared_ptr<Stanza> sentStanza) override;
             virtual void preHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent) override;
             virtual void addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) override;
             virtual void handleIncomingReplaceMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, const std::string& idToReplace, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) override;
             virtual void postHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent, const ChatWindow::ChatMessage& chatMessage) override;
             virtual void preSendMessageRequest(std::shared_ptr<Message>) override;
             virtual std::string senderHighlightNameFromMessage(const JID& from) override;
             virtual std::string senderDisplayNameFromMessage(const JID& from) override;
@@ -77,44 +77,43 @@ namespace Swift {
             void handleWhiteboardWindowShow();
 
             void handleSettingChanged(const std::string& settingPath);
             void checkForDisplayingDisplayReceiptsAlert();
 
             void handleBlockingStateChanged();
             void handleBlockUserRequest();
             void handleUnblockUserRequest();
 
             void handleInviteToChat(const std::vector<JID>& droppedJIDs);
 
             void handleWindowClosed();
 
             void handleUIEvent(std::shared_ptr<UIEvent> event);
 
         private:
             NickResolver* nickResolver_;
             ChatStateNotifier* chatStateNotifier_;
             ChatStateTracker* chatStateTracker_;
             std::string myLastMessageUIID_;
             bool isInMUC_;
             std::string lastStatusChangeString_;
             std::map<std::shared_ptr<Stanza>, std::string> unackedStanzas_;
             std::map<std::string, std::string> requestedReceipts_;
             StatusShow::Type lastShownStatus_;
 
             Tristate contactSupportsReceipts_;
             bool receivingPresenceFromUs_ = false;
             bool userWantsReceipts_;
             std::map<std::string, FileTransferController*> ftControllers;
-            SettingsProvider* settings_;
             std::string lastWbID_;
             std::string lastHandledMessageID_;
 
             ClientBlockListManager* clientBlockListManager_;
             boost::signals2::scoped_connection blockingOnStateChangedConnection_;
             boost::signals2::scoped_connection blockingOnItemAddedConnection_;
             boost::signals2::scoped_connection blockingOnItemRemovedConnection_;
 
             boost::optional<ChatWindow::AlertID> deliveryReceiptAlert_;
             boost::optional<ChatWindow::AlertID> blockedContactAlert_;
     };
 }
 
diff --git a/Swift/Controllers/Chat/ChatControllerBase.cpp b/Swift/Controllers/Chat/ChatControllerBase.cpp
index 0fc735a..2ef91fa 100644
--- a/Swift/Controllers/Chat/ChatControllerBase.cpp
+++ b/Swift/Controllers/Chat/ChatControllerBase.cpp
@@ -1,71 +1,71 @@
 /*
- * Copyright (c) 2010-2017 Isode Limited.
+ * Copyright (c) 2010-2018 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/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, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, 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), 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, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), entityCapsProvider_(entityCapsProvider), historyController_(historyController), mucRegistry_(mucRegistry), chatMessageParser_(chatMessageParser), autoAcceptMUCInviteDecider_(autoAcceptMUCInviteDecider), eventStream_(eventStream), roomSecurityMarking_(""), previousMessageSecurityMarking_(""), settings_(settings) {
     chatWindow_ = chatWindowFactory_->createChatWindow(toJID, eventStream);
     chatWindow_->onAllMessagesRead.connect(boost::bind(&ChatControllerBase::handleAllMessagesRead, this));
     chatWindow_->onSendMessageRequest.connect(boost::bind(&ChatControllerBase::handleSendMessageRequest, this, _1, _2));
     chatWindow_->onContinuationsBroken.connect(boost::bind(&ChatControllerBase::handleContinuationsBroken, this));
     entityCapsProvider_->onCapsChanged.connect(boost::bind(&ChatControllerBase::handleCapsChanged, this, _1));
     highlighter_ = highlightManager->createHighlighter(nickResolver);
     ChatControllerBase::setOnline(stanzaChannel->isAvailable() && iqRouter->isAvailable());
 }
 
 ChatControllerBase::~ChatControllerBase() {
     delete highlighter_;
     delete chatWindow_;
 }
 
 void ChatControllerBase::handleContinuationsBroken() {
     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);
     }
 }
 
@@ -163,65 +163,87 @@ void ChatControllerBase::handleSecurityLabelsCatalogResponse(std::shared_ptr<Sec
     } 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, const std::string& senderName, bool senderIsSelf) {
     ChatWindow::ChatMessage chatMessage;
     chatMessage = chatMessageParser_->parseMessageBody(message, senderName, senderIsSelf);
     return chatMessage;
 }
 
 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) {
+    auto displayedLabel = label;
+
+    if (settings_->getSetting(SettingConstants::MUC_MARKING_ELISION)) {
+        if (roomSecurityMarking_ != "") {
+
+            if (label && label->getDisplayMarking() == roomSecurityMarking_) {
+                if (label->getDisplayMarking() == previousMessageSecurityMarking_) {
+                    displayedLabel = std::make_shared<SecurityLabel>();
+                }
+                previousMessageSecurityMarking_ = label->getDisplayMarking();
+            }
+            else if (!label || label->getDisplayMarking().empty()) {
+                displayedLabel = std::make_shared<SecurityLabel>();
+                displayedLabel->setDisplayMarking("Unmarked");
+                previousMessageSecurityMarking_ = "Unmarked";
+            }
+            else {
+                previousMessageSecurityMarking_ = displayedLabel->getDisplayMarking();
+            }
+        }
+    }
+
     if (chatMessage.isMeCommand()) {
-        return chatWindow_->addAction(chatMessage, senderName, senderIsSelf, label, pathToString(avatarPath), time);
+        return chatWindow_->addAction(chatMessage, senderName, senderIsSelf, displayedLabel, pathToString(avatarPath), time);
     }
     else {
-        return chatWindow_->addMessage(chatMessage, senderName, senderIsSelf, label, pathToString(avatarPath), time);
+        return chatWindow_->addMessage(chatMessage, senderName, senderIsSelf, displayedLabel, 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) {
     std::shared_ptr<Message> message = messageEvent->getStanza();
     if (shouldIgnoreMessage(message)) {
         return;
     }
 
     preHandleIncomingMessage(messageEvent);
     if (messageEvent->isReadable() && !messageEvent->getConcluded()) {
         unreadMessages_.push_back(messageEvent);
         if (messageEvent->targetsMe()) {
             targetedUnreadMessages_.push_back(messageEvent);
         }
     }
 
diff --git a/Swift/Controllers/Chat/ChatControllerBase.h b/Swift/Controllers/Chat/ChatControllerBase.h
index 88cb95c..f635a46 100644
--- a/Swift/Controllers/Chat/ChatControllerBase.h
+++ b/Swift/Controllers/Chat/ChatControllerBase.h
@@ -1,112 +1,113 @@
 /*
- * Copyright (c) 2010-2017 Isode Limited.
+ * Copyright (c) 2010-2018 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #pragma once
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include <boost/date_time/posix_time/posix_time.hpp>
 #include <boost/filesystem/path.hpp>
 #include <boost/optional.hpp>
 #include <boost/signals2.hpp>
 
 #include <Swiften/Base/IDGenerator.h>
 #include <Swiften/Elements/DiscoInfo.h>
 #include <Swiften/Elements/ErrorPayload.h>
 #include <Swiften/Elements/SecurityLabelsCatalog.h>
 #include <Swiften/Elements/Stanza.h>
 #include <Swiften/JID/JID.h>
 #include <Swiften/MUC/MUCRegistry.h>
 #include <Swiften/Presence/PresenceOracle.h>
 #include <Swiften/Queries/IQRouter.h>
 
 #include <Swift/Controllers/Highlighting/HighlightManager.h>
 #include <Swift/Controllers/HistoryController.h>
+#include <Swift/Controllers/Settings/SettingsProvider.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 #include <Swift/Controllers/XMPPEvents/MUCInviteEvent.h>
 #include <Swift/Controllers/XMPPEvents/MessageEvent.h>
 
 namespace Swift {
     class AutoAcceptMUCInviteDecider;
     class AvatarManager;
     class ChatMessageParser;
     class ChatWindowFactory;
     class EntityCapsProvider;
     class EventController;
     class HighlightManager;
     class Highlighter;
     class IQRouter;
     class NickResolver;
     class StanzaChannel;
     class UIEventStream;
 
     class ChatControllerBase : public boost::signals2::trackable {
         public:
             class StreamWindowMessageIDPair {
                 public:
                     std::string idInStream;
                     std::string idInWindow;
             };
 
         public:
             virtual ~ChatControllerBase();
             void showChatWindow();
             void activateChatWindow();
             bool hasOpenWindow() const;
             virtual void setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info);
             virtual void handleIncomingOwnMessage(std::shared_ptr<Message> /*message*/) {}
             void handleIncomingMessage(std::shared_ptr<MessageEvent> message);
             std::string addMessage(const ChatWindow::ChatMessage& chatMessage, const std::string& senderName, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::filesystem::path& avatarPath, const boost::posix_time::ptime& time);
             void replaceMessage(const ChatWindow::ChatMessage& chatMessage, const std::string& id, const boost::posix_time::ptime& time);
             virtual void setOnline(bool online);
             void setEnabled(bool enabled);
             virtual void setToJID(const JID& jid) {toJID_ = jid;}
             /** Used for determining when something is recent.*/
             boost::signals2::signal<void (const std::string& /*activity*/)> onActivity;
             boost::signals2::signal<void ()> onUnreadCountChanged;
             boost::signals2::signal<void ()> onWindowClosed;
             int getUnreadCount();
             const JID& getToJID() {return toJID_;}
             void handleCapsChanged(const JID& jid);
             void setCanStartImpromptuChats(bool supportsImpromptu);
             virtual ChatWindow* detachChatWindow();
             boost::signals2::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, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider);
+            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, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings);
 
             /**
              * Pass the Message appended, and the stanza used to send it.
              */
             virtual void postSendMessage(const std::string&, std::shared_ptr<Stanza>) {}
             virtual std::string senderDisplayNameFromMessage(const JID& from) = 0;
             virtual std::string senderHighlightNameFromMessage(const JID& from) = 0;
             virtual bool isIncomingMessageFromMe(std::shared_ptr<Message>) = 0;
             virtual void preHandleIncomingMessage(std::shared_ptr<MessageEvent>) {}
             virtual void addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& time) = 0;
             virtual void handleIncomingReplaceMessage(const JID& from, const ChatWindow::ChatMessage& chatMessage, const std::string& messageID, const std::string& idToReplace, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) = 0;
             virtual void postHandleIncomingMessage(std::shared_ptr<MessageEvent>, const ChatWindow::ChatMessage&) {}
             virtual void preSendMessageRequest(std::shared_ptr<Message>) {}
             virtual bool isFromContact(const JID& from);
             virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(std::shared_ptr<Message>) const = 0;
             virtual void dayTicked() {}
             virtual void handleBareJIDCapsChanged(const JID& jid) = 0;
             std::string getErrorMessage(std::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;
             ChatWindow::ChatMessage buildChatWindowChatMessage(const std::string& message, const std::string& senderName, bool senderIsSelf);
             void updateMessageCount();
             virtual bool shouldIgnoreMessage(std::shared_ptr<Message> /* message */) {
                 return false;
             }
 
             /**
@@ -123,32 +124,35 @@ namespace Swift {
             void handleSecurityLabelsCatalogResponse(std::shared_ptr<SecurityLabelsCatalog>, ErrorPayload::ref error);
             void handleMUCInvitation(Message::ref message);
             void handleMediatedMUCInvitation(Message::ref message);
             void handleGeneralMUCInvitation(MUCInviteEvent::ref event);
             void handleContinuationsBroken();
 
         protected:
             JID selfJID_;
             std::vector<std::shared_ptr<StanzaEvent> > unreadMessages_;
             std::vector<std::shared_ptr<StanzaEvent> > targetedUnreadMessages_;
             StanzaChannel* stanzaChannel_;
             IQRouter* iqRouter_;
             ChatWindowFactory* chatWindowFactory_;
             ChatWindow* chatWindow_;
             JID toJID_;
             bool labelsEnabled_;
             std::map<JID, StreamWindowMessageIDPair> lastMessagesIDs_;
             PresenceOracle* presenceOracle_;
             AvatarManager* avatarManager_;
             bool useDelayForLatency_;
             EventController* eventController_;
             EntityCapsProvider* entityCapsProvider_;
             SecurityLabelsCatalog::Item lastLabel_;
             HistoryController* historyController_;
             MUCRegistry* mucRegistry_;
             Highlighter* highlighter_;
             std::shared_ptr<ChatMessageParser> chatMessageParser_;
             AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider_;
             UIEventStream* eventStream_;
             bool lastWasPresence_ = false;
+            std::string roomSecurityMarking_;
+            std::string previousMessageSecurityMarking_;
+            SettingsProvider* settings_;
     };
 }
diff --git a/Swift/Controllers/Chat/ChatsManager.cpp b/Swift/Controllers/Chat/ChatsManager.cpp
index b7087fd..dd74f6a 100644
--- a/Swift/Controllers/Chat/ChatsManager.cpp
+++ b/Swift/Controllers/Chat/ChatsManager.cpp
@@ -1,32 +1,32 @@
 /*
- * Copyright (c) 2010-2017 Isode Limited.
+ * Copyright (c) 2010-2018 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swift/Controllers/Chat/ChatsManager.h>
 
 #include <memory>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/archive/text_iarchive.hpp>
 #include <boost/archive/text_oarchive.hpp>
 #include <boost/bind.hpp>
 #include <boost/serialization/map.hpp>
 #include <boost/serialization/optional.hpp>
 #include <boost/serialization/split_free.hpp>
 #include <boost/serialization/string.hpp>
 #include <boost/serialization/vector.hpp>
 
 #include <Swiften/Avatars/AvatarManager.h>
 #include <Swiften/Base/Log.h>
 #include <Swiften/Client/ClientBlockListManager.h>
 #include <Swiften/Client/NickResolver.h>
 #include <Swiften/Client/StanzaChannel.h>
 #include <Swiften/Disco/DiscoServiceWalker.h>
 #include <Swiften/Disco/FeatureOracle.h>
 #include <Swiften/Elements/CarbonsReceived.h>
 #include <Swiften/Elements/CarbonsSent.h>
 #include <Swiften/Elements/ChatState.h>
 #include <Swiften/Elements/DeliveryReceipt.h>
 #include <Swiften/Elements/DeliveryReceiptRequest.h>
@@ -744,61 +744,61 @@ void ChatsManager::setOnline(bool enabled) {
         localMUCServiceFinderWalker_->onWalkComplete.connect(boost::bind(&ChatsManager::handleLocalServiceWalkFinished, this));
         localMUCServiceFinderWalker_->beginWalk();
     }
 
     if (chatListWindow_) {
         chatListWindow_->setBookmarksEnabled(enabled);
     }
 }
 
 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())) {
         for (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());
     std::shared_ptr<ChatMessageParser> chatMessageParser = std::make_shared<ChatMessageParser>(emoticons_, highlightManager_->getConfiguration(), ChatMessageParser::Mode::Chat); /* 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_, timerFactory_, eventController_, entityCapsProvider_, userWantsReceipts_, settings_, historyController_, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser, autoAcceptMUCInviteDecider_);
+    auto controller = new ChatController(jid_, stanzaChannel_, iqRouter_, chatWindowFactory_, contact, nickResolver_, presenceOracle_, avatarManager_, mucRegistry_->isMUC(contact.toBare()), useDelayForLatency_, uiEventStream_, timerFactory_, eventController_, entityCapsProvider_, userWantsReceipts_, historyController_, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser, autoAcceptMUCInviteDecider_, settings_);
     chatControllers_[contact] = controller;
     controller->setAvailableServerFeatures(serverDiscoInfo_);
     controller->onActivity.connect(boost::bind(&ChatsManager::handleChatActivity, this, contact, _1, false));
     controller->onWindowClosed.connect(boost::bind(&ChatsManager::handleChatClosed, this, contact));
     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 nullptr;
         }
         //Need to look for an unbound window to bind first
         JID bare(contact.toBare());
         if (chatControllers_.find(bare) != chatControllers_.end()) {
             if (rebindIfNeeded) {
                 rebindControllerJID(bare, contact);
             }
             else {
                 return chatControllers_[bare];
             }
@@ -833,61 +833,61 @@ MUC::ref ChatsManager::handleJoinMUCRequest(const JID &mucJID, const boost::opti
         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()) {
         if (stanzaChannel_->isAvailable()) {
             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 = nullptr;
         SingleChatWindowFactoryAdapter* chatWindowFactoryAdapter = nullptr;
         if (reuseChatwindow) {
             chatWindowFactoryAdapter = new SingleChatWindowFactoryAdapter(reuseChatwindow);
         }
         std::shared_ptr<ChatMessageParser> chatMessageParser = std::make_shared<ChatMessageParser>(emoticons_, highlightManager_->getConfiguration(), ChatMessageParser::Mode::GroupChat); /* 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_, nickResolver_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_, roster_, historyController_, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser, isImpromptu, autoAcceptMUCInviteDecider_, vcardManager_, mucBookmarkManager_);
+        controller = new MUCController(jid_, muc, password, nick, stanzaChannel_, iqRouter_, reuseChatwindow ? chatWindowFactoryAdapter : chatWindowFactory_, nickResolver_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_, roster_, historyController_, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser, isImpromptu, autoAcceptMUCInviteDecider_, vcardManager_, mucBookmarkManager_, settings_);
         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->onUserNicknameChanged.connect(boost::bind(&ChatsManager::handleUserNicknameChanged, this, controller, _1, _2));
         controller->onActivity.connect(boost::bind(&ChatsManager::handleChatActivity, this, mucJID.toBare(), _1, true));
         controller->onUnreadCountChanged.connect(boost::bind(&ChatsManager::handleUnreadCountChanged, this, controller));
         if (!stanzaChannel_->isAvailable()) {
             /* When online, the MUC is added to the registry in MUCImpl::internalJoin. This method is not
              * called when Swift is offline, so we add it here as only MUCs in the registry are rejoined
              * when going back online.
              */
             mucRegistry_->addMUC(mucJID.toBare());
         }
         handleChatActivity(mucJID.toBare(), "", true);
     }
 
     auto chatListWindowIter = std::find_if(recentChats_.begin(), recentChats_.end(), [&](const ChatListWindow::Chat& chatListWindow) { return mucJID == (chatListWindow.jid); });
     if (chatListWindowIter != recentChats_.end() && (mucControllers_[mucJID]->isImpromptu() || !chatListWindowIter->impromptuJIDs.empty())) {
         mucControllers_[mucJID]->setChatWindowTitle(chatListWindowIter->getTitle());
     }
 
     mucControllers_[mucJID]->showChatWindow();
diff --git a/Swift/Controllers/Chat/MUCController.cpp b/Swift/Controllers/Chat/MUCController.cpp
index 9e12a66..4c3f524 100644
--- a/Swift/Controllers/Chat/MUCController.cpp
+++ b/Swift/Controllers/Chat/MUCController.cpp
@@ -72,62 +72,63 @@ class MUCBookmarkPredicate {
 };
 
 /**
  * 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,
         NickResolver* nickResolver,
         PresenceOracle* presenceOracle,
         AvatarManager* avatarManager,
         UIEventStream* uiEventStream,
         bool useDelayForLatency,
         TimerFactory* timerFactory,
         EventController* eventController,
         EntityCapsProvider* entityCapsProvider,
         XMPPRoster* xmppRoster,
         HistoryController* historyController,
         MUCRegistry* mucRegistry,
         HighlightManager* highlightManager,
         ClientBlockListManager* clientBlockListManager,
         std::shared_ptr<ChatMessageParser> chatMessageParser,
         bool isImpromptu,
         AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider,
         VCardManager* vcardManager,
-        MUCBookmarkManager* mucBookmarkManager) :
-    ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), nickResolver, presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider), muc_(muc), nick_(nick), desiredNick_(nick), password_(password), renameCounter_(0), isImpromptu_(isImpromptu), isImpromptuAlreadyConfigured_(false), clientBlockListManager_(clientBlockListManager), mucBookmarkManager_(mucBookmarkManager) {
+        MUCBookmarkManager* mucBookmarkManager,
+        SettingsProvider* settings) :
+    ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), nickResolver, presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider, settings), muc_(muc), nick_(nick), desiredNick_(nick), password_(password), renameCounter_(0), isImpromptu_(isImpromptu), isImpromptuAlreadyConfigured_(false), clientBlockListManager_(clientBlockListManager), mucBookmarkManager_(mucBookmarkManager) {
     assert(avatarManager_);
 
     parting_ = true;
     joined_ = false;
     lastWasPresence_ = false;
     shouldJoinOnReconnect_ = true;
     doneGettingHistory_ = false;
     xmppRoster_ = xmppRoster;
     subject_ = "";
     isInitialJoin_ = true;
     chatWindowTitle_ = "";
 
     roster_ = std::make_unique<Roster>(false, true);
     rosterVCardProvider_ = new RosterVCardProvider(roster_.get(), vcardManager, JID::WithResource);
     completer_ = new TabComplete();
     chatWindow_->setRosterModel(roster_.get());
     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));
     chatWindow_->onUnblockUserRequest.connect(boost::bind(&MUCController::handleUnblockUserRequest, this));
     chatWindow_->onContinuationsBroken.connect(boost::bind(&MUCController::addChatSystemMessage, this));
@@ -1250,50 +1251,60 @@ void MUCController::setChatWindowTitle(const std::string& title) {
 void MUCController::requestSecurityMarking() {
     auto discoInfoRequest = GetDiscoInfoRequest::create(muc_->getJID(), iqRouter_);
     discoInfoRequest->onResponse.connect(
         [this](std::shared_ptr<DiscoInfo> discoInfoRef, ErrorPayload::ref errorPayloadRef) {
             if (!discoInfoRef || errorPayloadRef) {
                 return;
             }
             const std::vector<Form::ref>& extensionsList = discoInfoRef->getExtensions();
             if (extensionsList.empty()) {
                 return;
             }
             // Get the correct form if it exists
             Form::ref roomInfoForm;
             for (const auto& form : extensionsList) {
                 if (form->getFormType() == "http://jabber.org/protocol/muc#roominfo") {
                     roomInfoForm = form;
                     break;
                 }
             }
             if (!roomInfoForm) {
                 return;
             }
             // It exists, now examine the security marking data
             auto marking = roomInfoForm->getField("x-isode#roominfo_marking");
             if (!marking) {
                 return;
             }
             // Now we know the marking is valid
             auto markingValue = marking->getTextSingleValue();
             if (markingValue == "") {
-                chatWindow_->removeChatSecurityMarking();
+                setMUCSecurityMarkingDefault();
                 return;
             }
             auto markingForegroundColor = roomInfoForm->getField("x-isode#roominfo_marking_fg_color");
             auto markingBackgroundColor = roomInfoForm->getField("x-isode#roominfo_marking_bg_color");
             std::string markingForegroundColorValue = "Black";
             std::string markingBackgroundColorValue = "White";
             if (markingForegroundColor) {
                 markingForegroundColorValue = markingForegroundColor->getTextSingleValue();
             }
             if (markingBackgroundColor) {
                 markingBackgroundColorValue = markingBackgroundColor->getTextSingleValue();
             }
-            chatWindow_->setChatSecurityMarking(markingValue, markingForegroundColorValue, markingBackgroundColorValue);
+            setMUCSecurityMarking(markingValue, markingForegroundColorValue, markingBackgroundColorValue);
         }
     );
     discoInfoRequest->send();
 }
 
+void MUCController::setMUCSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue) {
+    roomSecurityMarking_ = markingValue;
+    chatWindow_->setChatSecurityMarking(markingValue, markingForegroundColorValue, markingBackgroundColorValue);
+}
+
+void MUCController::setMUCSecurityMarkingDefault() {
+    roomSecurityMarking_ = "";
+    chatWindow_->removeChatSecurityMarking();
+}
+
 }
diff --git a/Swift/Controllers/Chat/MUCController.h b/Swift/Controllers/Chat/MUCController.h
index 949f530..afc524f 100644
--- a/Swift/Controllers/Chat/MUCController.h
+++ b/Swift/Controllers/Chat/MUCController.h
@@ -26,61 +26,61 @@
 #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;
     class ClientBlockListManager;
     class MUCBookmarkManager;
     class MUCBookmark;
 
     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, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, XMPPRoster* xmppRoster, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, bool isImpromptu, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, VCardManager* vcardManager, MUCBookmarkManager* mucBookmarkManager);
+            MUCController(const JID& self, MUC::ref muc, const boost::optional<std::string>& password, const std::string &nick, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, XMPPRoster* xmppRoster, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, bool isImpromptu, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, VCardManager* vcardManager, MUCBookmarkManager* mucBookmarkManager, SettingsProvider* settings);
             virtual ~MUCController() override;
             boost::signals2::signal<void ()> onUserLeft;
             boost::signals2::signal<void ()> onUserJoined;
             boost::signals2::signal<void ()> onImpromptuConfigCompleted;
             boost::signals2::signal<void (const std::string&, const std::string& )> onUserNicknameChanged;
             virtual void setOnline(bool online) override;
             virtual void setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info) override;
             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);
             static std::string generateNicknameChangeString(const std::string& oldNickname, const std::string& newNickname);
             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;
             void setChatWindowTitle(const std::string& title);
 
         protected:
             virtual void preSendMessageRequest(std::shared_ptr<Message> message) override;
             virtual bool isIncomingMessageFromMe(std::shared_ptr<Message> message) override;
             virtual std::string senderHighlightNameFromMessage(const JID& from) override;
             virtual std::string senderDisplayNameFromMessage(const JID& from) override;
             virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(std::shared_ptr<Message> message) const override;
             virtual void preHandleIncomingMessage(std::shared_ptr<MessageEvent>) override;
             virtual void addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& time) override;
             virtual void handleIncomingReplaceMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, const std::string& idToReplace, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) override;
             virtual void postHandleIncomingMessage(std::shared_ptr<MessageEvent>, const ChatWindow::ChatMessage& chatMessage) override;
@@ -122,73 +122,74 @@ namespace Swift {
             void handleConfigurationFailed(ErrorPayload::ref);
             void handleConfigurationFormReceived(Form::ref);
             void handleDestroyRoomRequest();
             void handleInvitePersonToThisMUCRequest(const std::vector<JID>& jidsToInvite);
             void handleConfigurationCancelled();
             void handleOccupantRoleChangeFailed(ErrorPayload::ref, const JID&, MUCOccupant::Role);
             void handleGetAffiliationsRequest();
             void handleAffiliationListReceived(MUCOccupant::Affiliation affiliation, const std::vector<JID>& jids);
             void handleChangeAffiliationsRequest(const std::vector<std::pair<MUCOccupant::Affiliation, JID> >& changes);
             void handleInviteToMUCWindowDismissed();
             void handleInviteToMUCWindowCompleted();
             void handleUIEvent(std::shared_ptr<UIEvent> event);
             void addRecentLogs();
             void checkDuplicates(std::shared_ptr<Message> newMessage);
             void setNick(const std::string& nick);
             void handleRoomUnlocked();
             void configureAsImpromptuRoom(Form::ref form);
             Form::ref buildImpromptuRoomConfiguration(Form::ref roomConfigurationForm);
 
             void handleUnblockUserRequest();
             void handleBlockingStateChanged();
 
             void handleMUCBookmarkAdded(const MUCBookmark& bookmark);
             void handleMUCBookmarkRemoved(const MUCBookmark& bookmark);
             void updateChatWindowBookmarkStatus(const boost::optional<MUCBookmark>& bookmark);
 
             void displaySubjectIfChanged(const std::string& sucject);
             void addChatSystemMessage();
 
             void requestSecurityMarking();
+            void setMUCSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue);
+            void setMUCSecurityMarkingDefault();
 
         private:
             MUC::ref muc_;
             std::string nick_;
             std::string desiredNick_;
             TabComplete* completer_;
             bool parting_;
             bool joined_;
             bool shouldJoinOnReconnect_;
             bool doneGettingHistory_;
             boost::signals2::scoped_connection avatarChangedConnection_;
             std::shared_ptr<Timer> loginCheckTimer_;
             std::set<std::string> currentOccupants_;
             std::vector<NickJoinPart> joinParts_;
             boost::posix_time::ptime lastActivity_;
             boost::optional<std::string> password_;
             XMPPRoster* xmppRoster_;
             std::unique_ptr<Roster> roster_;
             std::vector<HistoryMessage> joinContext_;
             size_t renameCounter_;
             bool isImpromptu_;
             bool isImpromptuAlreadyConfigured_;
             RosterVCardProvider* rosterVCardProvider_;
             std::string lastJoinMessageUID_;
             std::string lastStartMessage_;
 
             ClientBlockListManager* clientBlockListManager_;
             boost::signals2::scoped_connection blockingOnStateChangedConnection_;
             boost::signals2::scoped_connection blockingOnItemAddedConnection_;
             boost::signals2::scoped_connection blockingOnItemRemovedConnection_;
 
             boost::optional<ChatWindow::AlertID> blockedContactAlert_;
 
             MUCBookmarkManager* mucBookmarkManager_;
             boost::signals2::scoped_connection mucBookmarkManagerBookmarkAddedConnection_;
             boost::signals2::scoped_connection mucBookmarkManagerBookmarkRemovedConnection_;
 
             std::string subject_;
             bool isInitialJoin_;
             std::string chatWindowTitle_;
     };
 }
-
diff --git a/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp b/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp
index 06486d3..9b45794 100644
--- a/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp
+++ b/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp
@@ -9,195 +9,245 @@
 #include <cppunit/extensions/HelperMacros.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 #include <hippomocks.h>
 
 #include <Swiften/Avatars/NullAvatarManager.h>
 #include <Swiften/Client/ClientBlockListManager.h>
 #include <Swiften/Client/DummyStanzaChannel.h>
 #include <Swiften/Client/NickResolver.h>
 #include <Swiften/Crypto/CryptoProvider.h>
 #include <Swiften/Crypto/PlatformCryptoProvider.h>
 #include <Swiften/Disco/DummyEntityCapsProvider.h>
 #include <Swiften/Elements/MUCUserPayload.h>
 #include <Swiften/Elements/Thread.h>
 #include <Swiften/MUC/MUCBookmarkManager.h>
 #include <Swiften/MUC/UnitTest/MockMUC.h>
 #include <Swiften/Network/TimerFactory.h>
 #include <Swiften/Presence/DirectedPresenceSender.h>
 #include <Swiften/Presence/PresenceOracle.h>
 #include <Swiften/Presence/StanzaChannelPresenceSender.h>
 #include <Swiften/Queries/DummyIQChannel.h>
 #include <Swiften/Roster/XMPPRoster.h>
 #include <Swiften/Roster/XMPPRosterImpl.h>
 #include <Swiften/VCards/VCardManager.h>
 #include <Swiften/VCards/VCardMemoryStorage.h>
 
 #include <Swift/Controllers/Chat/ChatMessageParser.h>
 #include <Swift/Controllers/Chat/MUCController.h>
 #include <Swift/Controllers/Chat/UserSearchController.h>
 #include <Swift/Controllers/Roster/GroupRosterItem.h>
 #include <Swift/Controllers/Roster/Roster.h>
+#include <Swift/Controllers/SettingConstants.h>
 #include <Swift/Controllers/Settings/DummySettingsProvider.h>
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindowFactory.h>
 #include <Swift/Controllers/UIInterfaces/UserSearchWindowFactory.h>
 #include <Swift/Controllers/UnitTest/MockChatWindow.h>
 #include <Swift/Controllers/XMPPEvents/EventController.h>
 
 using namespace Swift;
 
 class MUCControllerTest : public CppUnit::TestFixture {
     CPPUNIT_TEST_SUITE(MUCControllerTest);
     CPPUNIT_TEST(testJoinPartStringContructionSimple);
     CPPUNIT_TEST(testJoinPartStringContructionMixed);
     CPPUNIT_TEST(testAppendToJoinParts);
     CPPUNIT_TEST(testAddressedToSelf);
     CPPUNIT_TEST(testNotAddressedToSelf);
     CPPUNIT_TEST(testAddressedToSelfBySelf);
     CPPUNIT_TEST(testMessageWithEmptyLabelItem);
     CPPUNIT_TEST(testMessageWithLabelItem);
     CPPUNIT_TEST(testCorrectMessageWithLabelItem);
     CPPUNIT_TEST(testRoleAffiliationStates);
     CPPUNIT_TEST(testSubjectChangeCorrect);
     CPPUNIT_TEST(testSubjectChangeIncorrectA);
     CPPUNIT_TEST(testSubjectChangeIncorrectB);
     CPPUNIT_TEST(testSubjectChangeIncorrectC);
     CPPUNIT_TEST(testHandleOccupantNicknameChanged);
     CPPUNIT_TEST(testHandleOccupantNicknameChangedRoster);
     CPPUNIT_TEST(testHandleChangeSubjectRequest);
 
     CPPUNIT_TEST(testNonImpromptuMUCWindowTitle);
 
     CPPUNIT_TEST(testSecurityMarkingRequestCompleteMarking);
     CPPUNIT_TEST(testSecurityMarkingRequestCompleteMarkingWithExtraForm);
     CPPUNIT_TEST(testSecurityMarkingRequestEmptyMarking);
     CPPUNIT_TEST(testSecurityMarkingRequestWithMarkingNoFormType);
     CPPUNIT_TEST(testSecurityMarkingRequestNoMarking);
     CPPUNIT_TEST(testSecurityMarkingRequestNoForm);
     CPPUNIT_TEST(testSecurityMarkingRequestError);
 
+    CPPUNIT_TEST(testSecurityMarkingAddedToMessage_Elision_NoRoomMarkingA);
+    CPPUNIT_TEST(testSecurityMarkingAddedToMessage_Elision_NoRoomMarkingB);
+    CPPUNIT_TEST(testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingA);
+    CPPUNIT_TEST(testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingB);
+    CPPUNIT_TEST(testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingC);
+
+    CPPUNIT_TEST(testSecurityMarkingAddedToMessage_NoElision_NoRoomMarkingA);
+    CPPUNIT_TEST(testSecurityMarkingAddedToMessage_NoElision_NoRoomMarkingB);
+    CPPUNIT_TEST(testSecurityMarkingAddedToMessage_NoElision_WithRoomMarkingA);
+    CPPUNIT_TEST(testSecurityMarkingAddedToMessage_NoElision_WithRoomMarkingB);
+
     CPPUNIT_TEST_SUITE_END();
 
 public:
     void setUp() {
         crypto_ = std::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>();
         xmppRoster_ = new XMPPRosterImpl();
         presenceOracle_ = new PresenceOracle(stanzaChannel_, xmppRoster_);
         presenceSender_ = new StanzaChannelPresenceSender(stanzaChannel_);
         directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);
         uiEventStream_ = new UIEventStream();
         avatarManager_ = new NullAvatarManager();
         TimerFactory* timerFactory = nullptr;
         window_ = new MockChatWindow();
         mucRegistry_ = new MUCRegistry();
         entityCapsProvider_ = new DummyEntityCapsProvider();
         settings_ = new DummySettingsProvider();
         highlightManager_ = new HighlightManager(settings_);
         highlightManager_->resetToDefaultConfiguration();
         muc_ = std::make_shared<MockMUC>(mucJID_);
         mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(muc_->getJID(), uiEventStream_).Return(window_);
         chatMessageParser_ = std::make_shared<ChatMessageParser>(std::map<std::string, std::string>(), highlightManager_->getConfiguration(), ChatMessageParser::Mode::GroupChat);
         vcardStorage_ = new VCardMemoryStorage(crypto_.get());
         vcardManager_ = new VCardManager(self_, iqRouter_, vcardStorage_);
         nickResolver_ = new NickResolver(self_, xmppRoster_, vcardManager_, mucRegistry_);
         clientBlockListManager_ = new ClientBlockListManager(iqRouter_);
         mucBookmarkManager_ = new MUCBookmarkManager(iqRouter_);
-        controller_ = new MUCController (self_, muc_, boost::optional<std::string>(), nick_, stanzaChannel_, iqRouter_, chatWindowFactory_, nickResolver_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory, eventController_, entityCapsProvider_, nullptr, nullptr, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser_, false, nullptr, vcardManager_, mucBookmarkManager_);
+        controller_ = new MUCController (self_, muc_, boost::optional<std::string>(), nick_, stanzaChannel_, iqRouter_, chatWindowFactory_, nickResolver_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory, eventController_, entityCapsProvider_, nullptr, nullptr, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser_, false, nullptr, vcardManager_, mucBookmarkManager_, settings_);
     }
 
     void tearDown() {
         delete controller_;
         delete mucBookmarkManager_;
         delete clientBlockListManager_;
         delete nickResolver_;
         delete vcardManager_;
         delete vcardStorage_;
         delete highlightManager_;
         delete settings_;
         delete entityCapsProvider_;
         delete eventController_;
         delete presenceOracle_;
         delete xmppRoster_;
         delete mocks_;
         delete uiEventStream_;
         delete stanzaChannel_;
         delete presenceSender_;
         delete directedPresenceSender_;
         delete iqRouter_;
         delete iqChannel_;
         delete mucRegistry_;
         delete avatarManager_;
     }
 
     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 joinCompleted() {
         std::string messageBody("test message");
         window_->onSendMessageRequest(messageBody, false);
         std::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];
         Message::ref message = std::dynamic_pointer_cast<Message>(rawStanza);
         CPPUNIT_ASSERT(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */
         CPPUNIT_ASSERT(message);
         CPPUNIT_ASSERT_EQUAL(messageBody, message->getBody().get_value_or(""));
 
         {
             Message::ref message = std::make_shared<Message>();
             message->setType(Message::Groupchat);
             message->setTo(self_);
             message->setFrom(mucJID_.withResource("SomeNickname"));
             message->setID(iqChannel_->getNewIQID());
             message->setSubject("Initial");
 
             controller_->handleIncomingMessage(std::make_shared<MessageEvent>(message));
         }
     }
 
+    void setMUCSecurityMarking(const std::string& markingValue, const std::string   & markingForegroundColorValue, const std::string& markingBackgroundColorValue, const bool includeFormTypeField = true) {
+        auto form = std::make_shared<Form>(Form::Type::ResultType);
+
+        if (includeFormTypeField) {
+            std::shared_ptr<FormField> formTypeField = std::make_shared<FormField>(FormField::Type::HiddenType, "http://jabber.org/protocol/muc#roominfo");
+            formTypeField->setName("FORM_TYPE");
+            form->addField(formTypeField);
+        }
+
+        auto markingField = std::make_shared<FormField>(FormField::Type::TextSingleType, markingValue);
+        auto markingForegroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, markingForegroundColorValue);
+        auto markingBackgroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, markingBackgroundColorValue);
+
+        markingField->setName("x-isode#roominfo_marking");
+        markingForegroundColorField->setName("x-isode#roominfo_marking_fg_color");
+        markingBackgroundColorField->setName("x-isode#roominfo_marking_bg_color");
+
+        form->addField(markingField);
+        form->addField(markingForegroundColorField);
+        form->addField(markingBackgroundColorField);
+
+        auto discoInfoRef = std::make_shared<DiscoInfo>();
+        discoInfoRef->addExtension(form);
+
+        auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);
+        iqChannel_->onIQReceived(infoResponse);
+    }
+
+    Message::ref createTestMessageWithoutSecurityLabel() {
+        auto message = std::make_shared<Message>();
+        message->setType(Message::Type::Groupchat);
+        message->setID("test-id");
+        message->setTo(self_);
+        message->setFrom(mucJID_.withResource("TestNickname"));
+        message->setBody("Do Not Read This Message");
+        return message;
+    }
+
     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)));
         CPPUNIT_ASSERT_EQUAL((size_t)3, eventController_->getEvents().size());
 
         message = Message::ref(new Message());
         message->setFrom(JID(muc_->getJID().toString() + "/other2"));
         message->setBody("Hi " + boost::to_lower_copy(nick_) + ".");
         message->setType(Message::Groupchat);
         controller_->handleIncomingMessage(MessageEvent::ref(new MessageEvent(message)));
 
@@ -575,221 +625,376 @@ public:
 
     void testRoleAffiliationStatesVerify(const std::map<std::string, MUCOccupant> &occupants) {
         /* verify that the roster is in sync */
         GroupRosterItem* group = window_->getRosterModel()->getRoot();
         for (auto rosterItem : group->getChildren()) {
             GroupRosterItem* child = dynamic_cast<GroupRosterItem*>(rosterItem);
             CPPUNIT_ASSERT(child);
             for (auto 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());
             }
         }
     }
 
     void testHandleChangeSubjectRequest() {
         std::string testStr("New Subject");
         CPPUNIT_ASSERT_EQUAL(std::string(""), muc_->newSubjectSet_);
         window_->onChangeSubjectRequest(testStr);
         CPPUNIT_ASSERT_EQUAL(testStr, muc_->newSubjectSet_);
     }
 
     void testNonImpromptuMUCWindowTitle() {
         CPPUNIT_ASSERT_EQUAL(muc_->getJID().getNode(), window_->name_);
     }
 
     void testSecurityMarkingRequestCompleteMarking() {
-        auto formTypeField = std::make_shared<FormField>(FormField::Type::HiddenType, "http://jabber.org/protocol/muc#roominfo");
-        auto markingField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Test | Highest Possible Security");
-        auto markingForegroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Black");
-        auto markingBackgroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Red");
-        formTypeField->setName("FORM_TYPE");
-        markingField->setName("x-isode#roominfo_marking");
-        markingForegroundColorField->setName("x-isode#roominfo_marking_fg_color");
-        markingBackgroundColorField->setName("x-isode#roominfo_marking_bg_color");
-
-        auto form = std::make_shared<Form>(Form::Type::ResultType);
-        form->addField(formTypeField);
-        form->addField(markingField);
-        form->addField(markingForegroundColorField);
-        form->addField(markingBackgroundColorField);
+        setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red", true);
 
-        auto discoInfoRef = std::make_shared<DiscoInfo>();
-        discoInfoRef->addExtension(form);
-
-        auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);
-        iqChannel_->onIQReceived(infoResponse);
-        CPPUNIT_ASSERT_EQUAL(std::string("Test | Highest Possible Security"), window_->markingValue_);
+        CPPUNIT_ASSERT_EQUAL(std::string("Test|Highest Possible Security"), window_->markingValue_);
         CPPUNIT_ASSERT_EQUAL(std::string("Black"), window_->markingForegroundColorValue_);
         CPPUNIT_ASSERT_EQUAL(std::string("Red"), window_->markingBackgroundColorValue_);
     }
 
     void testSecurityMarkingRequestCompleteMarkingWithExtraForm() {
         auto formTypeField = std::make_shared<FormField>(FormField::Type::HiddenType, "http://jabber.org/protocol/muc#roominfo");
-        auto markingField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Test | Highest Possible Security");
+        auto markingField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Test|Highest Possible Security");
         auto markingForegroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Black");
         auto markingBackgroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Red");
         formTypeField->setName("FORM_TYPE");
         markingField->setName("x-isode#roominfo_marking");
         markingForegroundColorField->setName("x-isode#roominfo_marking_fg_color");
         markingBackgroundColorField->setName("x-isode#roominfo_marking_bg_color");
 
         auto extraForm = std::make_shared<Form>(Form::Type::ResultType);
         auto form = std::make_shared<Form>(Form::Type::ResultType);
         form->addField(formTypeField);
         form->addField(markingField);
         form->addField(markingForegroundColorField);
         form->addField(markingBackgroundColorField);
 
         auto discoInfoRef = std::make_shared<DiscoInfo>();
         discoInfoRef->addExtension(extraForm);
         discoInfoRef->addExtension(form);
 
         auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);
         iqChannel_->onIQReceived(infoResponse);
-        CPPUNIT_ASSERT_EQUAL(std::string("Test | Highest Possible Security"), window_->markingValue_);
+        CPPUNIT_ASSERT_EQUAL(std::string("Test|Highest Possible Security"), window_->markingValue_);
         CPPUNIT_ASSERT_EQUAL(std::string("Black"), window_->markingForegroundColorValue_);
         CPPUNIT_ASSERT_EQUAL(std::string("Red"), window_->markingBackgroundColorValue_);
     }
 
     void testSecurityMarkingRequestNoColorsInMarking() {
         auto formTypeField = std::make_shared<FormField>(FormField::Type::HiddenType, "http://jabber.org/protocol/muc#roominfo");
-        auto markingField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Test | Highest Possible Security");
+        auto markingField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Test|Highest Possible Security");
         auto markingForegroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "");
         auto markingBackgroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "");
         formTypeField->setName("FORM_TYPE");
         markingField->setName("x-isode#roominfo_marking");
         markingForegroundColorField->setName("x-isode#roominfo_marking_fg_color");
         markingBackgroundColorField->setName("x-isode#roominfo_marking_bg_color");
 
         auto form = std::make_shared<Form>(Form::Type::ResultType);
         form->addField(formTypeField);
         form->addField(markingField);
         form->addField(markingForegroundColorField);
         form->addField(markingBackgroundColorField);
 
         auto discoInfoRef = std::make_shared<DiscoInfo>();
         discoInfoRef->addExtension(form);
 
         auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);
         iqChannel_->onIQReceived(infoResponse);
-        CPPUNIT_ASSERT_EQUAL(std::string("Test | Highest Possible Security"), window_->markingValue_);
+        CPPUNIT_ASSERT_EQUAL(std::string("Test|Highest Possible Security"), window_->markingValue_);
         CPPUNIT_ASSERT_EQUAL(std::string("Black"), window_->markingForegroundColorValue_);
         CPPUNIT_ASSERT_EQUAL(std::string("White"), window_->markingBackgroundColorValue_);
     }
 
     void testSecurityMarkingRequestEmptyMarking() {
-        auto formTypeField = std::make_shared<FormField>(FormField::Type::HiddenType, "http://jabber.org/protocol/muc#roominfo");
-        auto markingField = std::make_shared<FormField>(FormField::Type::TextSingleType, "");
-        auto markingForegroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "");
-        auto markingBackgroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "");
-        formTypeField->setName("FORM_TYPE");
-        markingField->setName("x-isode#roominfo_marking");
-        markingForegroundColorField->setName("x-isode#roominfo_marking_fg_color");
-        markingBackgroundColorField->setName("x-isode#roominfo_marking_bg_color");
+        setMUCSecurityMarking("", "", "", true);
 
-        auto form = std::make_shared<Form>(Form::Type::ResultType);
-        form->addField(formTypeField);
-        form->addField(markingField);
-        form->addField(markingForegroundColorField);
-        form->addField(markingBackgroundColorField);
-
-        auto discoInfoRef = std::make_shared<DiscoInfo>();
-        discoInfoRef->addExtension(form);
-
-        auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);
-        iqChannel_->onIQReceived(infoResponse);
         CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingValue_);
         CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingForegroundColorValue_);
         CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingBackgroundColorValue_);
     }
 
     void testSecurityMarkingRequestWithMarkingNoFormType() {
-        auto markingField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Test | Highest Possible Security");
-        auto markingForegroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Black");
-        auto markingBackgroundColorField = std::make_shared<FormField>(FormField::Type::TextSingleType, "Red");
-        markingField->setName("x-isode#roominfo_marking");
-        markingForegroundColorField->setName("x-isode#roominfo_marking_fg_color");
-        markingBackgroundColorField->setName("x-isode#roominfo_marking_bg_color");
+        setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red", false);
 
-        auto form = std::make_shared<Form>(Form::Type::ResultType);
-        form->addField(markingField);
-        form->addField(markingForegroundColorField);
-        form->addField(markingBackgroundColorField);
-
-        auto discoInfoRef = std::make_shared<DiscoInfo>();
-        discoInfoRef->addExtension(form);
-
-        auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);
-        iqChannel_->onIQReceived(infoResponse);
         CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingValue_);
         CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingForegroundColorValue_);
         CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingBackgroundColorValue_);
     }
 
     void testSecurityMarkingRequestNoMarking() {
         auto form = std::make_shared<Form>(Form::Type::ResultType);
 
         auto discoInfoRef = std::make_shared<DiscoInfo>();
         discoInfoRef->addExtension(form);
 
         auto infoResponse = IQ::createResult(self_, mucJID_, "test-id", discoInfoRef);
         iqChannel_->onIQReceived(infoResponse);
         CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingValue_);
         CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingForegroundColorValue_);
         CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingBackgroundColorValue_);
     }
 
     void testSecurityMarkingRequestNoForm() {
         auto discoInfoRef = std::make_shared<DiscoInfo>();
 
         auto infoResponse = IQ::createResult( self_, mucJID_, "test-id", discoInfoRef);
         iqChannel_->onIQReceived(infoResponse);
         CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingValue_);
         CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingForegroundColorValue_);
         CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingBackgroundColorValue_);
     }
 
     void testSecurityMarkingRequestError() {
         auto errorPayload = std::make_shared<ErrorPayload>(ErrorPayload::Condition::NotAuthorized, ErrorPayload::Type::Auth);
 
         auto infoResponse = IQ::createResult( self_, mucJID_, "test-id", errorPayload);
         iqChannel_->onIQReceived(infoResponse);
         CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingValue_);
         CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingForegroundColorValue_);
         CPPUNIT_ASSERT_EQUAL(std::string(""), window_->markingBackgroundColorValue_);
     }
 
+    void testSecurityMarkingAddedToMessage_Elision_NoRoomMarkingA() {
+        settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);
+        setMUCSecurityMarking("", "Black", "Red");
+
+        auto messageLabel = std::make_shared<SecurityLabel>();
+        messageLabel->setDisplayMarking("Test|Highest Possible Security");
+
+        auto sentMessage = createTestMessageWithoutSecurityLabel();
+        sentMessage->addPayload(messageLabel);
+
+        auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);
+        controller_->handleIncomingMessage(sentMessageEvent);
+
+        auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;
+
+        CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel == nullptr);
+        // This is the potentially altered security label that is displayed on the screen
+        CPPUNIT_ASSERT_EQUAL(std::string("Test|Highest Possible Security"), storedSecurityLabel->getDisplayMarking());
+    }
+
+    void testSecurityMarkingAddedToMessage_Elision_NoRoomMarkingB() {
+        settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);
+        setMUCSecurityMarking("", "Black", "Red");
+
+        auto messageLabel = std::make_shared<SecurityLabel>();
+        messageLabel->setDisplayMarking("");
+
+        auto sentMessage = createTestMessageWithoutSecurityLabel();
+        sentMessage->addPayload(messageLabel);
+
+        auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);
+        controller_->handleIncomingMessage(sentMessageEvent);
+
+        auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;
+
+        CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel == nullptr);
+        // This is the potentially altered security label that is displayed on the screen
+        CPPUNIT_ASSERT_EQUAL(std::string(""), storedSecurityLabel->getDisplayMarking());
+    }
+
+    void testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingA() {
+        settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);
+        setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red");
+
+        auto messageLabel = std::make_shared<SecurityLabel>();
+        messageLabel->setDisplayMarking("Test|Highest Possible Security");
+
+        auto sentMessage = createTestMessageWithoutSecurityLabel();
+        sentMessage->addPayload(messageLabel);
+
+        // Test the first message matching MUC marking. This message SHOULD have a marking
+
+        auto sentMessageEvent1 = std::make_shared<MessageEvent>(sentMessage);
+        controller_->handleIncomingMessage(sentMessageEvent1);
+
+        auto storedSecurityLabel1 = window_->lastAddedMessageSecurityLabel_;
+
+        CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel1 == nullptr);
+        // This is the potentially altered security label that is displayed on the screen
+        CPPUNIT_ASSERT_EQUAL(std::string("Test|Highest Possible Security"), storedSecurityLabel1->getDisplayMarking());
+
+        // Test a consecutive message matching MUC marking. This message SHOULD NOT have a marking
+
+        auto sentMessageEvent2 = std::make_shared<MessageEvent>(sentMessage);
+        controller_->handleIncomingMessage(sentMessageEvent2);
+
+        auto storedSecurityLabel2 = window_->lastAddedMessageSecurityLabel_;
+
+        CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel2 == nullptr);
+        // This is the potentially altered security label that is displayed on the screen
+        CPPUNIT_ASSERT_EQUAL(std::string(""), storedSecurityLabel2->getDisplayMarking());
+    }
+
+    void testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingB() {
+        settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);
+        setMUCSecurityMarking("Test|Lower Security Marking", "Black", "Red");
+
+        auto messageLabel = std::make_shared<SecurityLabel>();
+        messageLabel->setDisplayMarking("Test|Highest Possible Security");
+
+        auto sentMessage = createTestMessageWithoutSecurityLabel();
+        sentMessage->addPayload(messageLabel);
+
+        auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);
+        controller_->handleIncomingMessage(sentMessageEvent);
+
+        auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;
+
+        CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel == nullptr);
+        // This is the potentially altered security label that is displayed on the screen
+        CPPUNIT_ASSERT_EQUAL(std::string("Test|Highest Possible Security"), storedSecurityLabel->getDisplayMarking());
+    }
+
+    void testSecurityMarkingAddedToMessage_Elision_WithRoomMarkingC() {
+        settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, true);
+        setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red");
+
+        auto messageLabel = std::make_shared<SecurityLabel>();
+        messageLabel->setDisplayMarking("");
+
+        auto sentMessage = createTestMessageWithoutSecurityLabel();
+        sentMessage->addPayload(messageLabel);
+
+        auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);
+        controller_->handleIncomingMessage(sentMessageEvent);
+
+        auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;
+
+        CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel == nullptr);
+        // This is the potentially altered security label that is displayed on the screen
+        CPPUNIT_ASSERT_EQUAL(std::string("Unmarked"), storedSecurityLabel->getDisplayMarking());
+    }
+
+    void testSecurityMarkingAddedToMessage_NoElision_NoRoomMarkingA() {
+        settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, false);
+        setMUCSecurityMarking("", "Black", "Red");
+
+        auto messageLabel = std::make_shared<SecurityLabel>();
+        messageLabel->setDisplayMarking("Test|Highest Possible Security");
+
+        auto sentMessage = createTestMessageWithoutSecurityLabel();
+        sentMessage->addPayload(messageLabel);
+
+        auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);
+        controller_->handleIncomingMessage(sentMessageEvent);
+
+        auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;
+
+        CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel == nullptr);
+        // This is the potentially altered security label that is displayed on the screen
+        CPPUNIT_ASSERT_EQUAL(std::string("Test|Highest Possible Security"), storedSecurityLabel->getDisplayMarking());
+    }
+
+    void testSecurityMarkingAddedToMessage_NoElision_NoRoomMarkingB() {
+        settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, false);
+        setMUCSecurityMarking("", "Black", "Red");
+
+        auto messageLabel = std::make_shared<SecurityLabel>();
+        messageLabel->setDisplayMarking("");
+
+        auto sentMessage = createTestMessageWithoutSecurityLabel();
+        sentMessage->addPayload(messageLabel);
+
+        auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);
+        controller_->handleIncomingMessage(sentMessageEvent);
+
+        auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;
+
+        CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel == nullptr);
+        // This is the potentially altered security label that is displayed on the screen
+        CPPUNIT_ASSERT_EQUAL(std::string(""), storedSecurityLabel->getDisplayMarking());
+    }
+
+    void testSecurityMarkingAddedToMessage_NoElision_WithRoomMarkingA() {
+        settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, false);
+        setMUCSecurityMarking("Test|Highest Possible Security", "Black", "Red");
+
+        auto messageLabel = std::make_shared<SecurityLabel>();
+        messageLabel->setDisplayMarking("Test|Highest Possible Security");
+
+        auto sentMessage = createTestMessageWithoutSecurityLabel();
+        sentMessage->addPayload(messageLabel);
+
+        // Test the first message matching MUC marking. This message SHOULD have a marking
+
+        auto sentMessageEvent1 = std::make_shared<MessageEvent>(sentMessage);
+        controller_->handleIncomingMessage(sentMessageEvent1);
+
+        auto storedSecurityLabel1 = window_->lastAddedMessageSecurityLabel_;
+
+        CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel1 == nullptr);
+        // This is the potentially altered security label that is displayed on the screen
+        CPPUNIT_ASSERT_EQUAL(std::string("Test|Highest Possible Security"), storedSecurityLabel1->getDisplayMarking());
+
+        // Test a consecutive message matching MUC marking. This message SHOULD ALSO have a marking
+
+        auto sentMessageEvent2 = std::make_shared<MessageEvent>(sentMessage);
+        controller_->handleIncomingMessage(sentMessageEvent2);
+
+        auto storedSecurityLabel2 = window_->lastAddedMessageSecurityLabel_;
+
+        CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel2 == nullptr);
+        // This is the potentially altered security label that is displayed on the screen
+        CPPUNIT_ASSERT_EQUAL(std::string("Test|Highest Possible Security"), storedSecurityLabel2->getDisplayMarking());
+    }
+
+    void testSecurityMarkingAddedToMessage_NoElision_WithRoomMarkingB() {
+        settings_->storeSetting(SettingConstants::MUC_MARKING_ELISION, false);
+        setMUCSecurityMarking("", "Black", "Red");
+
+        auto messageLabel = std::make_shared<SecurityLabel>();
+        messageLabel->setDisplayMarking("");
+
+        auto sentMessage = createTestMessageWithoutSecurityLabel();
+        sentMessage->addPayload(messageLabel);
+
+        auto sentMessageEvent = std::make_shared<MessageEvent>(sentMessage);
+        controller_->handleIncomingMessage(sentMessageEvent);
+
+        auto storedSecurityLabel = window_->lastAddedMessageSecurityLabel_;
+
+        CPPUNIT_ASSERT_EQUAL(false, storedSecurityLabel == nullptr);
+        // This is the potentially altered security label that is displayed on the screen
+        CPPUNIT_ASSERT_EQUAL(std::string(""), storedSecurityLabel->getDisplayMarking());
+    }
+
 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_;
     std::shared_ptr<ChatMessageParser> chatMessageParser_;
     std::shared_ptr<CryptoProvider> crypto_;
     VCardManager* vcardManager_;
     VCardMemoryStorage* vcardStorage_;
     ClientBlockListManager* clientBlockListManager_;
     MUCBookmarkManager* mucBookmarkManager_;
diff --git a/Swift/Controllers/SettingConstants.cpp b/Swift/Controllers/SettingConstants.cpp
index f0064ba..5347d4e 100644
--- a/Swift/Controllers/SettingConstants.cpp
+++ b/Swift/Controllers/SettingConstants.cpp
@@ -1,28 +1,29 @@
 /*
- * Copyright (c) 2012-2017 Isode Limited.
+ * Copyright (c) 2012-2018 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swift/Controllers/SettingConstants.h>
 
 namespace Swift {
 
 const SettingsProvider::Setting<bool> SettingConstants::IDLE_GOES_OFFLINE = SettingsProvider::Setting<bool>("idleGoesOffline", false);
 const SettingsProvider::Setting<int> SettingConstants::IDLE_TIMEOUT = SettingsProvider::Setting<int>("idleTimeout", 600);
 const SettingsProvider::Setting<bool> SettingConstants::SHOW_NOTIFICATIONS = SettingsProvider::Setting<bool>("showNotifications", true);
 const SettingsProvider::Setting<bool> SettingConstants::REQUEST_DELIVERYRECEIPTS = SettingsProvider::Setting<bool>("requestDeliveryReceipts", false);
 const SettingsProvider::Setting<bool> SettingConstants::FORGET_PASSWORDS = SettingsProvider::Setting<bool>("forgetPasswords", false);
 const SettingsProvider::Setting<bool> SettingConstants::REMEMBER_RECENT_CHATS = SettingsProvider::Setting<bool>("rememberRecentChats", true);
 const SettingsProvider::Setting<std::string> SettingConstants::LAST_LOGIN_JID = SettingsProvider::Setting<std::string>("lastLoginJID", "");
 const SettingsProvider::Setting<bool> SettingConstants::LOGIN_AUTOMATICALLY = SettingsProvider::Setting<bool>("loginAutomatically", false);
 const SettingsProvider::Setting<bool> SettingConstants::SHOW_OFFLINE("showOffline", false);
 const SettingsProvider::Setting<std::string> SettingConstants::EXPANDED_ROSTER_GROUPS("GroupExpandiness", "");
 const SettingsProvider::Setting<bool> SettingConstants::PLAY_SOUNDS("playSounds", true);
 const SettingsProvider::Setting<std::string> SettingConstants::HIGHLIGHT_RULES("highlightRules", "@");
 const SettingsProvider::Setting<std::string> SettingConstants::HIGHLIGHT_RULES_V2("highlightRulesV2", "@");
 const SettingsProvider::Setting<std::string> SettingConstants::INVITE_AUTO_ACCEPT_MODE("inviteAutoAcceptMode", "presence");
 const SettingsProvider::Setting<bool> SettingConstants::DISCONNECT_ON_CARD_REMOVAL("disconnectOnCardRemoval", true);
 const SettingsProvider::Setting<bool> SettingConstants::SINGLE_SIGN_ON("singleSignOn", false);
+const SettingsProvider::Setting<bool> SettingConstants::MUC_MARKING_ELISION("mucMarkingElision", true);
 
 }
diff --git a/Swift/Controllers/SettingConstants.h b/Swift/Controllers/SettingConstants.h
index fec2d27..61781e0 100644
--- a/Swift/Controllers/SettingConstants.h
+++ b/Swift/Controllers/SettingConstants.h
@@ -1,32 +1,32 @@
 /*
- * Copyright (c) 2012-2017 Isode Limited.
+ * Copyright (c) 2012-2018 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #pragma once
 
 #include <Swift/Controllers/Settings/SettingsProvider.h>
 
 namespace Swift {
     /**
      *  This class contains the major setting keys for Swift.
      */
     class SettingConstants {
         public:
             /**
              * The #IDLE_GOES_OFFLINE setting specifies whether to close the XMPP connection when
              * the user went idle.
              *
              * True for automatic close of the XMPP connection and false for only changing the presence on idle.
              */
             static const SettingsProvider::Setting<bool> IDLE_GOES_OFFLINE;
             /**
              * The #IDLE_TIMEOUT setting specifieds the seconds the user has to be inactive at the
              * desktop so the user is regarded as idle.
              */
             static const SettingsProvider::Setting<int> IDLE_TIMEOUT;
             static const SettingsProvider::Setting<bool> SHOW_NOTIFICATIONS;
             /**
              * The #REQUEST_DELIVERYRECEIPTS settings specifies whether to request delivery receipts
              * for messages to contacts that support message receipts.
@@ -66,32 +66,43 @@ namespace Swift {
             static const SettingsProvider::Setting<std::string> HIGHLIGHT_RULES_V2;
             /**
              * The #INVITE_AUTO_ACCEPT_MODE setting specifies how to handle invites to chat rooms.
              *
              * Supported values are:
              * - "no" : It is up to the user whether to accept the invitation and enter a room or not.
              * - "presence" : The invitation is automatically accepted if it is from a contact that is
              *   already allowed to see the user's presence status.
              * - "domain" : The invitation is automatically accepted if it is from a contact that is
              *   already allowed to see the user's presence status or from a contact of user's domain.
              */
             static const SettingsProvider::Setting<std::string> INVITE_AUTO_ACCEPT_MODE;
             /**
              * The #DISCONNECT_ON_CARD_REMOVAL setting
              * specifies whether or not to sign out the user when
              * the smartcard is removed.
              *
              * If set true Swift will sign out the user when the
              * smart card is removed; else not.
              */
             static const SettingsProvider::Setting<bool> DISCONNECT_ON_CARD_REMOVAL;
             /**
              * The #SINGLE_SIGN_ON setting
              * specifies whether to log in using Single Sign On.
              * This is currently supported on Windows.
              *
              * If set true Swift will use GSSAPI authentication to
              * log in the user; else not.
              */
             static const SettingsProvider::Setting<bool> SINGLE_SIGN_ON;
+            /**
+             * The #MUC_MARKING_ELISION setting
+             * specifies whether or not messages with the default muc
+             * marking display their marking, and whether unmarked messages
+             * are marked as such.
+             *
+             * If set true, unmarked messages will be marked with the marking
+             * "unmarked", and messages with the room default marking will
+             * have their markings stripped.
+             */
+            static const SettingsProvider::Setting<bool> MUC_MARKING_ELISION;
     };
 }
diff --git a/Swift/Controllers/UnitTest/MockChatWindow.h b/Swift/Controllers/UnitTest/MockChatWindow.h
index 56f118d..389d787 100644
--- a/Swift/Controllers/UnitTest/MockChatWindow.h
+++ b/Swift/Controllers/UnitTest/MockChatWindow.h
@@ -1,53 +1,54 @@
 /*
  * Copyright (c) 2010-2017 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #pragma once
 
 #include <memory>
 #include <string>
 
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 
 namespace Swift {
     class MockChatWindow : public ChatWindow {
         public:
             MockChatWindow() {}
             virtual ~MockChatWindow();
 
-            virtual std::string addMessage(const ChatMessage& message, const std::string& senderName, bool senderIsSelf, std::shared_ptr<SecurityLabel> /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime& /*time*/) {
+            virtual std::string addMessage(const ChatMessage& message, const std::string& senderName, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const std::string& /*avatarPath*/, const boost::posix_time::ptime& /*time*/) {
                 lastAddedMessage_ = message;
                 lastAddedMessageSenderName_ = senderName;
                 lastAddedMessageSenderIsSelf_ = senderIsSelf;
+                lastAddedMessageSecurityLabel_ = label;
                 return "id";
             }
 
             virtual std::string addAction(const ChatMessage& message, const std::string& senderName, bool senderIsSelf, std::shared_ptr<SecurityLabel> /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime& /*time*/) {
                 lastAddedAction_ = message;
                 lastAddedActionSenderName_ = senderName;
                 lastAddedActionSenderIsSelf_ = senderIsSelf;
                 return "id";
             }
 
             virtual std::string addSystemMessage(const ChatMessage& message, Direction /*direction*/) {
                 lastAddedSystemMessage_ = message;
                 return "id";
             }
 
             virtual void addPresenceMessage(const ChatMessage& message, Direction /*direction*/) {
                 lastAddedPresence_ = message;
             }
 
             virtual void addErrorMessage(const ChatMessage& message) {
                 lastAddedErrorMessage_ = message;
             }
 
             virtual void replaceMessage(const ChatMessage& message, const std::string& /*id*/, const boost::posix_time::ptime& /*time*/) {
                 lastReplacedMessage_ = message;
             }
 
             virtual void replaceWithAction(const ChatMessage& /*message*/, const std::string& /*id*/, const boost::posix_time::ptime& /*time*/) {}
             virtual void replaceLastMessage(const ChatMessage& message, const TimestampBehaviour /*timestampBehaviour*/) {
                 lastReplacedLastMessage_ = message;
@@ -118,53 +119,54 @@ namespace Swift {
                 std::shared_ptr<ChatHighlightingMessagePart> highlight;
                 for (auto &&part : message.getParts()) {
                     if ((text = std::dynamic_pointer_cast<ChatTextMessagePart>(part))) {
                         body += text->text;
                     }
                     else if ((highlight = std::dynamic_pointer_cast<ChatHighlightingMessagePart>(part))) {
                         body += highlight->text;
                     }
                 }
                 return body;
             }
 
             void resetLastMessages() {
                 lastAddedMessage_ = lastAddedAction_ = lastAddedPresence_ = lastReplacedLastMessage_ = lastAddedSystemMessage_ = lastReplacedSystemMessage_ = ChatMessage();
                 lastAddedMessageSenderName_ = lastAddedActionSenderName_ = "";
                 lastAddedMessageSenderIsSelf_ = lastAddedActionSenderIsSelf_ = false;
             }
 
             void setChatSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue) {
                 markingValue_ = markingValue;
                 markingForegroundColorValue_ = markingForegroundColorValue;
                 markingBackgroundColorValue_ = markingBackgroundColorValue;
             }
 
             void removeChatSecurityMarking() {}
 
             std::string name_;
             ChatMessage lastAddedMessage_;
             std::string lastAddedMessageSenderName_;
             bool lastAddedMessageSenderIsSelf_ = false;
+            std::shared_ptr<SecurityLabel> lastAddedMessageSecurityLabel_ = nullptr;
             ChatMessage lastAddedAction_;
             std::string lastAddedActionSenderName_;
             bool lastAddedActionSenderIsSelf_ = false;
             ChatMessage lastAddedPresence_;
             ChatMessage lastReplacedMessage_;
             ChatMessage lastReplacedLastMessage_;
             ChatMessage lastAddedSystemMessage_;
             ChatMessage lastReplacedSystemMessage_;
             ChatMessage lastAddedErrorMessage_;
             JID lastMUCInvitationJID_;
             std::vector<SecurityLabelsCatalog::Item> labels_;
             bool labelsEnabled_ = false;
             bool impromptuMUCSupported_ = false;
             SecurityLabelsCatalog::Item label_;
             Roster* roster_ = nullptr;
             std::vector<std::pair<std::string, ReceiptState>> receiptChanges_;
             boost::optional<MUCType> mucType_;
             std::string markingValue_;
             std::string markingForegroundColorValue_;
             std::string markingBackgroundColorValue_;
     };
 }
 
diff --git a/Swift/QtUI/QtChatWindow.cpp b/Swift/QtUI/QtChatWindow.cpp
index 17e3328..96162ba 100644
--- a/Swift/QtUI/QtChatWindow.cpp
+++ b/Swift/QtUI/QtChatWindow.cpp
@@ -84,61 +84,61 @@ QtChatWindow::QtChatWindow(const QString& contact, QtChatTheme* theme, UIEventSt
 
     alertStyleSheet_ = ".QWidget, QTextEdit { background: rgb(255, 255, 153); color: black }";
 
     QBoxLayout *layout = new QBoxLayout(QBoxLayout::TopToBottom, this);
     layout->setContentsMargins(0,0,0,0);
     layout->setSpacing(2);
 
     alertLayout_ = new QVBoxLayout();
     layout->addLayout(alertLayout_);
 
     subjectLayout_ = new QBoxLayout(QBoxLayout::LeftToRight);
     subject_ = new QLineEdit(this);
     subjectLayout_->addWidget(subject_);
     setSubject("");
     subject_->setReadOnly(true);
 
     QPushButton* actionButton_ = new QPushButton(this);
     actionButton_->setIcon(QIcon(":/icons/actions.png"));
     connect(actionButton_, SIGNAL(clicked()), this, SLOT(handleActionButtonClicked()));
     subject_->hide();
 
     layout->addLayout(subjectLayout_);
 
     logRosterSplitter_ = new QSplitter(this);
     logRosterSplitter_->setAutoFillBackground(true);
     layout->addWidget(logRosterSplitter_);
     if (settings_->getSetting(QtUISettingConstants::USE_PLAIN_CHATS) || settings_->getSetting(QtUISettingConstants::USE_SCREENREADER)) {
         messageLog_ = new QtPlainChatView(this, eventStream_);
     }
     else {
-        messageLog_ = new QtWebKitChatView(this, eventStream_, theme, this); // I accept that passing the ChatWindow in so that the view can call the signals is somewhat inelegant, but it saves a lot of boilerplate. This patch is unpleasant enough already. So let's fix this soon (it at least needs fixing by the time history is sorted), but not now.
+        messageLog_ = new QtWebKitChatView(this, eventStream_, theme, this, settings); // I accept that passing the ChatWindow in so that the view can call the signals is somewhat inelegant, but it saves a lot of boilerplate. This patch is unpleasant enough already. So let's fix this soon (it at least needs fixing by the time history is sorted), but not now.
     }
     logRosterSplitter_->addWidget(messageLog_);
 
     treeWidget_ = new QtOccupantListWidget(eventStream_, settings_, QtTreeWidget::MessageDisplayJID, this);
     treeWidget_->hide();
     logRosterSplitter_->addWidget(treeWidget_);
     logRosterSplitter_->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
     connect(logRosterSplitter_, SIGNAL(splitterMoved(int, int)), this, SLOT(handleSplitterMoved(int, int)));
 
     midBar_ = new QWidget(this);
     //layout->addWidget(midBar);
     midBar_->setAutoFillBackground(true);
     QHBoxLayout *midBarLayout = new QHBoxLayout(midBar_);
     midBarLayout->setContentsMargins(0,0,0,0);
     midBarLayout->setSpacing(2);
     //midBarLayout->addStretch();
 
     labelsWidget_ = new QComboBox(this);
     labelsWidget_->setFocusPolicy(Qt::NoFocus);
     labelsWidget_->hide();
     labelsWidget_->setSizeAdjustPolicy(QComboBox::AdjustToContents);
     midBarLayout->addWidget(labelsWidget_,0);
     connect(labelsWidget_, SIGNAL(currentIndexChanged(int)), this, SLOT(handleCurrentLabelChanged(int)));
     defaultLabelsPalette_ = labelsWidget_->palette();
 
     QHBoxLayout* inputBarLayout = new QHBoxLayout();
     inputBarLayout->setContentsMargins(0,0,0,0);
     inputBarLayout->setSpacing(2);
     input_ = new QtTextEdit(settings_, this);
     input_->setAcceptRichText(false);
diff --git a/Swift/QtUI/QtHistoryWindow.cpp b/Swift/QtUI/QtHistoryWindow.cpp
index 77a7f12..983d0e9 100644
--- a/Swift/QtUI/QtHistoryWindow.cpp
+++ b/Swift/QtUI/QtHistoryWindow.cpp
@@ -22,61 +22,61 @@
 #include <QLineEdit>
 #include <QMenu>
 #include <QTextDocument>
 #include <QTime>
 #include <QUrl>
 
 #include <Swiften/History/HistoryMessage.h>
 
 #include <Swift/Controllers/Settings/SettingsProvider.h>
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 
 #include <Swift/QtUI/ChatSnippet.h>
 #include <Swift/QtUI/MessageSnippet.h>
 #include <Swift/QtUI/QtScaledAvatarCache.h>
 #include <Swift/QtUI/QtSwiftUtil.h>
 #include <Swift/QtUI/QtUtilities.h>
 #include <Swift/QtUI/QtWebKitChatView.h>
 #include <Swift/QtUI/Roster/QtTreeWidget.h>
 
 namespace Swift {
 
 QtHistoryWindow::QtHistoryWindow(SettingsProvider* settings, UIEventStream* eventStream) :
         previousTopMessageWasSelf_(false),
         previousBottomMessageWasSelf_(false) {
     ui_.setupUi(this);
 
     theme_ = new QtChatTheme("");
     idCounter_ = 0;
 
     delete ui_.conversation_;
-    conversation_ = new QtWebKitChatView(nullptr, nullptr, theme_, this, true); // Horrible unsafe. Do not do this. FIXME
+    conversation_ = new QtWebKitChatView(nullptr, nullptr, theme_, this, settings, true); // Horrible unsafe. Do not do this. FIXME
     QSizePolicy sizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
     sizePolicy.setHorizontalStretch(80);
     sizePolicy.setVerticalStretch(0);
     conversation_->setSizePolicy(sizePolicy);
 
     ui_.conversation_ = conversation_;
     ui_.bottomLayout_->addWidget(conversation_);
 
     delete ui_.conversationRoster_;
     conversationRoster_ = new QtTreeWidget(eventStream, settings, QtTreeWidget::MessageDefaultJID, this);
     QSizePolicy sizePolicy2(QSizePolicy::Preferred, QSizePolicy::Expanding);
     sizePolicy2.setVerticalStretch(80);
     conversationRoster_->setSizePolicy(sizePolicy2);
     ui_.conversationRoster_ = conversationRoster_;
     ui_.bottomLeftLayout_->setDirection(QBoxLayout::BottomToTop);
     ui_.bottomLeftLayout_->addWidget(conversationRoster_);
 
     setWindowTitle(tr("History"));
 
     conversationRoster_->onSomethingSelectedChanged.connect(boost::bind(&QtHistoryWindow::handleSomethingSelectedChanged, this, _1));
     connect(conversation_, SIGNAL(scrollRequested(int)), this, SLOT(handleScrollRequested(int)));
     connect(conversation_, SIGNAL(scrollReachedTop()), this, SLOT(handleScrollReachedTop()));
     connect(conversation_, SIGNAL(scrollReachedBottom()), this, SLOT(handleScrollReachedBottom()));
     connect(conversation_, SIGNAL(fontResized(int)), this, SLOT(handleFontResized(int)));
     connect(ui_.searchBox_->lineEdit(), SIGNAL(returnPressed()), this, SLOT(handleReturnPressed()));
     connect(ui_.calendarWidget_, SIGNAL(clicked(const QDate&)), this, SLOT(handleCalendarClicked(const QDate&)));
     connect(ui_.calendarWidget_, SIGNAL(activated(const QDate&)), this, SLOT(handleCalendarClicked(const QDate&)));
     connect(ui_.previousButton_, SIGNAL(clicked(bool)), this, SLOT(handlePreviousButtonClicked()));
     connect(ui_.nextButton_, SIGNAL(clicked(bool)), this, SLOT(handleNextButtonClicked()));
 }
diff --git a/Swift/QtUI/QtWebKitChatView.cpp b/Swift/QtUI/QtWebKitChatView.cpp
index ea9a9c6..f3d23e7 100644
--- a/Swift/QtUI/QtWebKitChatView.cpp
+++ b/Swift/QtUI/QtWebKitChatView.cpp
@@ -1,89 +1,91 @@
 /*
  * Copyright (c) 2010-2017 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swift/QtUI/QtWebKitChatView.h>
 
 #include <QApplication>
 #include <QDesktopServices>
 #include <QDesktopWidget>
 #include <QEventLoop>
 #include <QFile>
 #include <QFileDialog>
 #include <QFileInfo>
 #include <QFileDevice>
 #include <QInputDialog>
 #include <QKeyEvent>
 #include <QMessageBox>
 #include <QStackedWidget>
 #include <QTimer>
 #include <QVBoxLayout>
 #include <QWebFrame>
 #include <QWebSettings>
 #include <QtDebug>
 
 #include <Swiften/Base/FileSize.h>
 #include <Swiften/Base/Log.h>
 #include <Swiften/StringCodecs/Base64.h>
 
+#include <Swift/Controllers/SettingConstants.h>
+#include <Swift/Controllers/Settings/SettingsProvider.h>
 #include <Swift/Controllers/UIEvents/JoinMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 
 #include <Swift/QtUI/MessageSnippet.h>
 #include <Swift/QtUI/QtChatWindow.h>
 #include <Swift/QtUI/QtChatWindowJSBridge.h>
 #include <Swift/QtUI/QtScaledAvatarCache.h>
 #include <Swift/QtUI/QtSwiftUtil.h>
 #include <Swift/QtUI/QtUtilities.h>
 #include <Swift/QtUI/QtWebView.h>
 #include <Swift/QtUI/SystemMessageSnippet.h>
 
 namespace Swift {
 
 const QString QtWebKitChatView::ButtonWhiteboardSessionCancel = QString("whiteboard-cancel");
 const QString QtWebKitChatView::ButtonWhiteboardSessionAcceptRequest = QString("whiteboard-acceptrequest");
 const QString QtWebKitChatView::ButtonWhiteboardShowWindow = QString("whiteboard-showwindow");
 const QString QtWebKitChatView::ButtonFileTransferCancel = QString("filetransfer-cancel");
 const QString QtWebKitChatView::ButtonFileTransferSetDescription = QString("filetransfer-setdescription");
 const QString QtWebKitChatView::ButtonFileTransferSendRequest = QString("filetransfer-sendrequest");
 const QString QtWebKitChatView::ButtonFileTransferAcceptRequest = QString("filetransfer-acceptrequest");
 const QString QtWebKitChatView::ButtonFileTransferOpenFile = QString("filetransfer-openfile");
 const QString QtWebKitChatView::ButtonMUCInvite = QString("mucinvite");
 
 namespace {
     const double minimalFontScaling = 0.7;
 }
 
-QtWebKitChatView::QtWebKitChatView(QtChatWindow* window, UIEventStream* eventStream, QtChatTheme* theme, QWidget* parent, bool disableAutoScroll) : QtChatView(parent), window_(window), eventStream_(eventStream), fontSizeSteps_(0), disableAutoScroll_(disableAutoScroll), previousMessageKind_(PreviosuMessageWasNone), previousMessageWasSelf_(false), showEmoticons_(false), insertingLastLine_(false), idCounter_(0) {
+QtWebKitChatView::QtWebKitChatView(QtChatWindow* window, UIEventStream* eventStream, QtChatTheme* theme, QWidget* parent, SettingsProvider* settings, bool disableAutoScroll /*= false*/) : QtChatView(parent), window_(window), eventStream_(eventStream), fontSizeSteps_(0), disableAutoScroll_(disableAutoScroll), previousMessageKind_(PreviosuMessageWasNone), previousMessageWasSelf_(false), showEmoticons_(false), insertingLastLine_(false), idCounter_(0), settings_(settings) {
     theme_ = theme;
 
     QVBoxLayout* mainLayout = new QVBoxLayout(this);
     mainLayout->setSpacing(0);
     mainLayout->setContentsMargins(0,0,0,0);
     webView_ = new QtWebView(this);
     connect(webView_, SIGNAL(linkClicked(const QUrl&)), SLOT(handleLinkClicked(const QUrl&)));
     connect(webView_, SIGNAL(loadFinished(bool)), SLOT(handleViewLoadFinished(bool)));
     connect(webView_, SIGNAL(gotFocus()), SIGNAL(gotFocus()));
     connect(webView_, SIGNAL(clearRequested()), SLOT(handleClearRequested()));
     connect(webView_, SIGNAL(fontGrowRequested()), SLOT(increaseFontSize()));
     connect(webView_, SIGNAL(fontShrinkRequested()), SLOT(decreaseFontSize()));
 #if defined (Q_OS_UNIX) && !defined(Q_OS_MAC)
     /* To give a border on Linux, where it looks bad without */
     QStackedWidget* stack = new QStackedWidget(this);
     stack->addWidget(webView_);
     stack->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
     stack->setLineWidth(2);
     mainLayout->addWidget(stack);
 #else
     mainLayout->addWidget(webView_);
 #endif
 
 #ifdef SWIFT_EXPERIMENTAL_FT
     setAcceptDrops(true);
 #endif
 
     webPage_ = new QWebPage(this);
     webPage_->setLinkDelegationPolicy(QWebPage::DelegateAllLinks);
     if (Log::getLogLevel() == Log::debug) {
@@ -528,83 +530,87 @@ QString QtWebKitChatView::chatMessageToHTML(const ChatWindow::ChatMessage& messa
         }
         if ((emoticonPart = std::dynamic_pointer_cast<ChatWindow::ChatEmoticonMessagePart>(part))) {
             QString textStyle = showEmoticons_ ? "style='display:none'" : "";
             QString imageStyle = showEmoticons_ ? "" : "style='display:none'";
             result += "<span class='swift_emoticon_image' " + imageStyle + "><img src='" + P2QSTRING(emoticonPart->imagePath) + "'/></span><span class='swift_emoticon_text' " + textStyle + ">" + QtUtilities::htmlEscape(P2QSTRING(emoticonPart->alternativeText)) + "</span>";
             continue;
         }
         if ((highlightPart = std::dynamic_pointer_cast<ChatWindow::ChatHighlightingMessagePart>(part))) {
             QString spanStart = getHighlightSpanStart(highlightPart->action.getFrontColor().get_value_or(""), highlightPart->action.getBackColor().get_value_or(""));
             result += spanStart + QtUtilities::htmlEscape(P2QSTRING(highlightPart->text)) + "</span>";
             continue;
         }
 
     }
     return result;
 }
 
 std::string QtWebKitChatView::addMessage(
         const QString& message,
         const std::string& senderName,
         bool senderIsSelf,
         std::shared_ptr<SecurityLabel> label,
         const std::string& avatarPath,
         const QString& style,
         const boost::posix_time::ptime& time,
         const HighlightAction& highlight,
         ChatSnippet::Direction direction) {
 
     QString scaledAvatarPath = QtScaledAvatarCache(32).getScaledAvatarPath(avatarPath.c_str());
 
+    std::string messageMarkingValue = "";
+
     QString htmlString;
     if (label) {
+        messageMarkingValue = label->getDisplayMarking();
         htmlString = QString("<span style=\"border: thin dashed grey; padding-left: .5em; padding-right: .5em; color: %1; background-color: %2; font-size: 90%; margin-right: .5em; \" class='swift_label'>").arg(QtUtilities::htmlEscape(P2QSTRING(label->getForegroundColor()))).arg(QtUtilities::htmlEscape(P2QSTRING(label->getBackgroundColor())));
-        htmlString += QString("%1</span> ").arg(QtUtilities::htmlEscape(P2QSTRING(label->getDisplayMarking())));
+        htmlString += QString("%1</span> ").arg(QtUtilities::htmlEscape(P2QSTRING(messageMarkingValue)));
     }
 
     QString styleSpanStart = style == "" ? "" : "<span style=\"" + style + "\">";
     QString styleSpanEnd = style == "" ? "" : "</span>";
 
     bool highlightWholeMessage = highlight.getFrontColor() || highlight.getBackColor();
     QString highlightSpanStart = highlightWholeMessage ? getHighlightSpanStart(highlight) : "";
     QString highlightSpanEnd = highlightWholeMessage ? "</span>" : "";
     htmlString += "<span class='swift_inner_message'>" + styleSpanStart + highlightSpanStart + message + highlightSpanEnd + styleSpanEnd + "</span>" ;
 
-    bool appendToPrevious = appendToPreviousCheck(PreviousMessageWasMessage, senderName, senderIsSelf);
+    bool appendToPrevious = appendToPreviousCheck(PreviousMessageWasMessage, senderName, senderIsSelf, label);
 
     QString qAvatarPath = scaledAvatarPath.isEmpty() ? "qrc:/icons/avatar.svg" : QUrl::fromLocalFile(scaledAvatarPath).toEncoded();
     std::string id = "id" + boost::lexical_cast<std::string>(idCounter_++);
     addMessageBottom(std::make_shared<MessageSnippet>(htmlString, QtUtilities::htmlEscape(P2QSTRING(senderName)), B2QDATE(time), qAvatarPath, senderIsSelf, appendToPrevious, theme_, P2QSTRING(id), direction));
 
     previousMessageWasSelf_ = senderIsSelf;
     previousSenderName_ = P2QSTRING(senderName);
     previousMessageKind_ = PreviousMessageWasMessage;
+    previousMessageDisplayMarking_ = messageMarkingValue;
     return id;
 }
 
 std::string QtWebKitChatView::addAction(const ChatWindow::ChatMessage& message, const std::string &senderName, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time) {
     return addMessage(" *" + chatMessageToHTML(message) + "*", senderName, senderIsSelf, label, avatarPath, "font-style:italic ", time, message.getHighlightActionSender(), ChatSnippet::getDirection(message));
 }
 
 static QString encodeButtonArgument(const QString& str) {
     return QtUtilities::htmlEscape(P2QSTRING(Base64::encode(createByteArray(Q2PSTRING(str)))));
 }
 
 static QString decodeButtonArgument(const QString& str) {
     return P2QSTRING(byteArrayToString(Base64::decode(Q2PSTRING(str))));
 }
 
 QString QtWebKitChatView::buildChatWindowButton(const QString& name, const QString& id, const QString& arg1, const QString& arg2, const QString& arg3, const QString& arg4, const QString& arg5) {
     QRegExp regex("[A-Za-z][A-Za-z0-9\\-\\_]+");
     Q_ASSERT(regex.exactMatch(id));
     QString html = QString("<input id='%2' type='submit' value='%1' onclick='chatwindow.buttonClicked(\"%2\", \"%3\", \"%4\", \"%5\", \"%6\", \"%7\");' />").arg(name).arg(id).arg(encodeButtonArgument(arg1)).arg(encodeButtonArgument(arg2)).arg(encodeButtonArgument(arg3)).arg(encodeButtonArgument(arg4)).arg(encodeButtonArgument(arg5));
     return html;
 }
 
 void QtWebKitChatView::resizeEvent(QResizeEvent* event) {
     // This code ensures that if the user is scrolled all to the bottom of a chat view,
     // the view stays scrolled to the bottom if the view is resized or if the message
     // input widget becomes multi line.
     if (isAtBottom_) {
         scrollToBottom();
     }
     QWidget::resizeEvent(event);
@@ -951,49 +957,56 @@ void QtWebKitChatView::setAckState(std::string const& id, ChatWindow::AckState s
     QString xml;
     switch (state) {
         case ChatWindow::Pending:
             xml = "<img src='qrc:/icons/throbber.gif' title='" + tr("This message has not been received by your server yet.") + "'/>";
             displayReceiptInfo(P2QSTRING(id), false);
             break;
         case ChatWindow::Received:
             xml = "";
             displayReceiptInfo(P2QSTRING(id), true);
             break;
         case ChatWindow::Failed: xml = "<img src='qrc:/icons/error.png' title='" + tr("This message may not have been transmitted.") + "'/>"; break;
     }
     setAckXML(P2QSTRING(id), xml);
 }
 
 void QtWebKitChatView::setMessageReceiptState(const std::string& id, ChatWindow::ReceiptState state) {
     QString xml;
     switch (state) {
         case ChatWindow::ReceiptReceived:
             xml = "<img src='qrc:/icons/delivery-success.svg' title='" + tr("The receipt for this message has been received.") + "'/>";
             break;
         case ChatWindow::ReceiptRequested:
             xml = "<img src='qrc:/icons/delivery-warning.svg' title='" + tr("The receipt for this message has not yet been received. The recipient(s) might not have received this message.") + "'/>";
             break;
         case ChatWindow::ReceiptFailed:
             xml = "<img src='qrc:/icons/delivery-failure.svg' title='" + tr("Failed to transmit message to the receipient(s).") + "'/>";
     }
     setReceiptXML(P2QSTRING(id), xml);
 }
 
-bool QtWebKitChatView::appendToPreviousCheck(PreviousMessageKind messageKind, const std::string& senderName, bool senderIsSelf) {
+bool QtWebKitChatView::appendToPreviousCheck(PreviousMessageKind messageKind, const std::string& senderName, bool senderIsSelf, const std::shared_ptr<SecurityLabel>& label /*=nullptr*/) {
     bool result = previousMessageKind_ == messageKind && ((senderIsSelf && previousMessageWasSelf_) || (!senderIsSelf && !previousMessageWasSelf_&& previousSenderName_ == P2QSTRING(senderName)));
     if (insertingLastLine_) {
         insertingLastLine_ = false;
         return false;
     }
+    if (settings_->getSetting(SettingConstants::MUC_MARKING_ELISION)) {
+        if (label && label->getDisplayMarking() != previousMessageDisplayMarking_) {
+            if (label->getDisplayMarking() != "") {
+                return false;
+            }
+        }
+    }
     return result;
 }
 
 ChatSnippet::Direction QtWebKitChatView::getActualDirection(const ChatWindow::ChatMessage& message, ChatWindow::Direction direction) {
     if (direction == ChatWindow::DefaultDirection) {
         return QCoreApplication::translate("QApplication", "QT_LAYOUT_DIRECTION") == "RTL" ? ChatSnippet::RTL : ChatSnippet::LTR;
     }
     else {
         return ChatSnippet::getDirection(message);
     }
 }
 
 }
diff --git a/Swift/QtUI/QtWebKitChatView.h b/Swift/QtUI/QtWebKitChatView.h
index f816942..a2eafe6 100644
--- a/Swift/QtUI/QtWebKitChatView.h
+++ b/Swift/QtUI/QtWebKitChatView.h
@@ -1,75 +1,76 @@
 /*
  * Copyright (c) 2010-2017 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #pragma once
 
 #include <memory>
 
 #include <QList>
 #include <QString>
 #include <QWebElement>
 #include <QWidget>
 
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 
 #include <Swift/QtUI/ChatSnippet.h>
 #include <Swift/QtUI/QtChatView.h>
 
 class QWebPage;
 class QUrl;
 class QDate;
 
 namespace Swift {
     class QtWebView;
     class QtChatTheme;
     class QtChatWindowJSBridge;
     class UIEventStream;
     class QtChatWindow;
+    class SettingsProvider;
     class QtWebKitChatView : public QtChatView {
             Q_OBJECT
 
         public:
             static const QString ButtonWhiteboardSessionCancel;
             static const QString ButtonWhiteboardSessionAcceptRequest;
             static const QString ButtonWhiteboardShowWindow;
             static const QString ButtonFileTransferCancel;
             static const QString ButtonFileTransferSetDescription;
             static const QString ButtonFileTransferSendRequest;
             static const QString ButtonFileTransferAcceptRequest;
             static const QString ButtonFileTransferOpenFile;
             static const QString ButtonMUCInvite;
         public:
-            QtWebKitChatView(QtChatWindow* window, UIEventStream* eventStream, QtChatTheme* theme, QWidget* parent, bool disableAutoScroll = false);
+            QtWebKitChatView(QtChatWindow* window, UIEventStream* eventStream, QtChatTheme* theme, QWidget* parent, SettingsProvider* settings, bool disableAutoScroll = false);
             ~QtWebKitChatView() override;
 
             /** Add message to window.
              * @return id of added message (for acks).
              */
             virtual std::string addMessage(const ChatWindow::ChatMessage& message, const std::string& senderName, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time) override;
             /** Adds action to window.
              * @return id of added message (for acks);
              */
             virtual std::string addAction(const ChatWindow::ChatMessage& message, const std::string& senderName, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time) override;
 
             virtual std::string addSystemMessage(const ChatWindow::ChatMessage& message, ChatWindow::Direction direction) override;
             virtual void addPresenceMessage(const ChatWindow::ChatMessage& message, ChatWindow::Direction direction) override;
 
             virtual void addErrorMessage(const ChatWindow::ChatMessage& message) override;
             virtual void replaceMessage(const ChatWindow::ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time) override;
             virtual void replaceSystemMessage(const ChatWindow::ChatMessage& message, const std::string& id, ChatWindow::TimestampBehaviour timestampBehaviour) override;
             virtual void replaceWithAction(const ChatWindow::ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time) override;
             virtual void replaceLastMessage(const ChatWindow::ChatMessage& message, const ChatWindow::TimestampBehaviour timestampBehaviour) override;
             virtual void setAckState(const std::string& id, ChatWindow::AckState state) override;
 
             virtual std::string addFileTransfer(const std::string& senderName, const std::string& avatarPath, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes, const std::string& description) override;
             virtual void setFileTransferProgress(std::string, const int percentageDone) override;
             virtual void setFileTransferStatus(std::string, const ChatWindow::FileTransferState state, const std::string& msg = "") override;
             virtual void addMUCInvitation(const std::string& senderName, const JID& jid, const std::string& reason, const std::string& password, bool direct, bool isImpromptu, bool isContinuation) override;
             virtual std::string addWhiteboardRequest(const QString& contact, bool senderIsSelf) override;
             virtual void setWhiteboardSessionStatus(const std::string& id, const ChatWindow::WhiteboardSessionState state) override;
             virtual void setMessageReceiptState(const std::string& id, ChatWindow::ReceiptState state) override;
 
             virtual void showEmoticons(bool show) override;
@@ -123,71 +124,73 @@ namespace Swift {
             void handleFrameSizeChanged();
             void handleClearRequested();
             void handleHTMLButtonClicked(QString id, QString arg1, QString arg2, QString arg3, QString arg4, QString arg5);
             void handleVerticalScrollBarPositionChanged(double position);
 
         private:
             enum PreviousMessageKind {
                 PreviosuMessageWasNone,
                 PreviousMessageWasMessage,
                 PreviousMessageWasSystem,
                 PreviousMessageWasPresence,
                 PreviousMessageWasFileTransfer,
                 PreviousMessageWasMUCInvite
             };
             std::string addMessage(
                     const QString& message,
                     const std::string& senderName,
                     bool senderIsSelf,
                     std::shared_ptr<SecurityLabel> label,
                     const std::string& avatarPath,
                     const QString& style,
                     const boost::posix_time::ptime& time,
                     const HighlightAction& highlight,
                     ChatSnippet::Direction direction);
             void replaceMessage(
                     const QString& message,
                     const std::string& id,
                     const boost::posix_time::ptime& time,
                     const QString& style,
                     const HighlightAction& highlight);
-            bool appendToPreviousCheck(PreviousMessageKind messageKind, const std::string& senderName, bool senderIsSelf);
+            bool appendToPreviousCheck(PreviousMessageKind messageKind, const std::string& senderName, bool senderIsSelf, const std::shared_ptr<SecurityLabel>& label = nullptr);
             static ChatSnippet::Direction getActualDirection(const ChatWindow::ChatMessage& message, ChatWindow::Direction direction);
             QString getHighlightSpanStart(const std::string& text, const std::string& background);
             QString getHighlightSpanStart(const HighlightAction& highlight);
             QString chatMessageToHTML(const ChatWindow::ChatMessage& message);
             static QString buildChatWindowButton(const QString& name, const QString& id, const QString& arg1 = QString(), const QString& arg2 = QString(), const QString& arg3 = QString(), const QString& arg4 = QString(), const QString& arg5 = QString());
 
         protected:
             void resizeEvent(QResizeEvent* event) override;
 
         private:
             void headerEncode();
             void messageEncode();
             void addToDOM(std::shared_ptr<ChatSnippet> snippet);
 
             QtChatWindow* window_;
             UIEventStream* eventStream_;
             bool viewReady_;
             bool isAtBottom_;
             bool topMessageAdded_;
             int scrollBarMaximum_;
             QtWebView* webView_;
             QWebPage* webPage_;
             int fontSizeSteps_;
             QtChatTheme* theme_;
             QWebElement lineSeparator_;
             QWebElement lastElement_;
             QWebElement firstElement_;
             QWebElement document_;
             bool disableAutoScroll_;
             QtChatWindowJSBridge* jsBridge;
             PreviousMessageKind previousMessageKind_;
             bool previousMessageWasSelf_;
             bool showEmoticons_;
             bool insertingLastLine_;
             int idCounter_;
             QString previousSenderName_;
             std::map<QString, QString> descriptions_;
             std::map<QString, QString> filePaths_;
+            std::string previousMessageDisplayMarking_;
+            SettingsProvider* settings_ = nullptr;
     };
 }
diff --git a/Swiften/Elements/SecurityLabel.h b/Swiften/Elements/SecurityLabel.h
index 0f0311e..fcaa610 100644
--- a/Swiften/Elements/SecurityLabel.h
+++ b/Swiften/Elements/SecurityLabel.h
@@ -1,47 +1,48 @@
 /*
  * Copyright (c) 2010-2017 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #pragma once
 
 #include <string>
 #include <vector>
 
 #include <Swiften/Base/API.h>
 #include <Swiften/Elements/Payload.h>
 
 namespace Swift {
     class SWIFTEN_API SecurityLabel : public Payload {
         public:
+            using ref = std::shared_ptr<SecurityLabel>;
 
             SecurityLabel();
 
             virtual ~SecurityLabel();
 
             const std::vector< std::string >& getEquivalentLabels() const {
                 return equivalentLabels;
             }
 
             void setEquivalentLabels(const std::vector< std::string >& value) {
                 this->equivalentLabels = value ;
             }
 
             void addEquivalentLabel(const std::string& value) {
                 this->equivalentLabels.push_back(value);
             }
 
             const std::string& getForegroundColor() const {
                 return foregroundColor;
             }
 
             void setForegroundColor(const std::string& value) {
                 this->foregroundColor = value ;
             }
 
             const std::string& getDisplayMarking() const {
                 return displayMarking;
             }
 
             void setDisplayMarking(const std::string& value) {