1 files changed, 5 insertions, 4 deletions
diff --git a/Swift/Controllers/Chat/MUCController.cpp b/Swift/Controllers/Chat/MUCController.cpp
index e6c16b7..409fe1f 100644
--- a/Swift/Controllers/Chat/MUCController.cpp
+++ b/Swift/Controllers/Chat/MUCController.cpp
@@ -1,54 +1,55 @@
 /*
- * Copyright (c) 2010-2015 Isode Limited.
+ * Copyright (c) 2010-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swift/Controllers/Chat/MUCController.h>
 
 #include <algorithm>
 
 #include <boost/bind.hpp>
 #include <boost/regex.hpp>
 #include <boost/algorithm/string.hpp>
 
 #include <Swiften/Avatars/AvatarManager.h>
 #include <Swiften/Base/Log.h>
 #include <Swiften/Base/foreach.h>
 #include <Swiften/Base/format.h>
 #include <Swiften/Base/Tristate.h>
 #include <Swiften/Client/BlockList.h>
 #include <Swiften/Client/ClientBlockListManager.h>
 #include <Swiften/Client/StanzaChannel.h>
 #include <Swiften/Disco/EntityCapsProvider.h>
 #include <Swiften/Elements/Delay.h>
+#include <Swiften/Elements/Thread.h>
 #include <Swiften/MUC/MUC.h>
 #include <Swiften/MUC/MUCBookmark.h>
 #include <Swiften/MUC/MUCBookmarkManager.h>
 #include <Swiften/Network/Timer.h>
 #include <Swiften/Network/TimerFactory.h>
 #include <Swiften/Roster/XMPPRoster.h>
 
 #include <SwifTools/TabComplete.h>
 
 #include <Swift/Controllers/Chat/ChatMessageParser.h>
 #include <Swift/Controllers/Highlighter.h>
 #include <Swift/Controllers/Intl.h>
 #include <Swift/Controllers/Roster/ContactRosterItem.h>
 #include <Swift/Controllers/Roster/GroupRosterItem.h>
 #include <Swift/Controllers/Roster/ItemOperations/SetAvatar.h>
 #include <Swift/Controllers/Roster/ItemOperations/SetMUC.h>
 #include <Swift/Controllers/Roster/ItemOperations/SetPresence.h>
 #include <Swift/Controllers/Roster/Roster.h>
 #include <Swift/Controllers/Roster/RosterVCardProvider.h>
 #include <Swift/Controllers/UIEvents/InviteToMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestAddUserDialogUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestChangeBlockStateUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestChatUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestInviteToMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/ShowProfileForRosterItemUIEvent.h>
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindowFactory.h>
 #include <Swift/Controllers/XMPPEvents/EventController.h>
 
@@ -504,89 +505,89 @@ void MUCController::clearPresenceQueue() {
 
 std::string MUCController::roleToFriendlyName(MUCOccupant::Role role) {
 	switch (role) {
 	case MUCOccupant::Moderator: return QT_TRANSLATE_NOOP("", "moderator");
 	case MUCOccupant::Participant: return QT_TRANSLATE_NOOP("", "participant");
 	case MUCOccupant::Visitor: return QT_TRANSLATE_NOOP("", "visitor");
 	case MUCOccupant::NoRole: return "";
 	}
 	assert(false);
 	return "";
 }
 
 std::string MUCController::roleToSortName(MUCOccupant::Role role) {
 	switch (role) {
 	case MUCOccupant::Moderator: return "1";
 	case MUCOccupant::Participant: return "2";
 	case MUCOccupant::Visitor: return "3";
 	case MUCOccupant::NoRole: return "4";
 	}
 	assert(false);
 	return "5";
 }
 
 JID MUCController::nickToJID(const std::string& nick) {
 	return muc_->getJID().withResource(nick);
 }
 
 bool MUCController::messageTargetsMe(boost::shared_ptr<Message> message) {
 	std::string stringRegexp(".*\\b" + boost::to_lower_copy(nick_) + "\\b.*");
 	boost::regex myRegexp(stringRegexp);
-	return boost::regex_match(boost::to_lower_copy(message->getBody()), myRegexp);
+	return boost::regex_match(boost::to_lower_copy(message->getBody().get_value_or("")), myRegexp);
 }
 
 void MUCController::preHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent) {
 	if (messageEvent->getStanza()->getType() == Message::Groupchat) {
 		lastActivity_ = boost::posix_time::microsec_clock::universal_time();
 	}
 	clearPresenceQueue();
 	boost::shared_ptr<Message> message = messageEvent->getStanza();
 	if (joined_ && messageEvent->getStanza()->getFrom().getResource() != nick_ && messageTargetsMe(message) && !message->getPayload<Delay>() && messageEvent->isReadable()) {
 		chatWindow_->flash();
 	}
 	else {
 		messageEvent->setTargetsMe(false);
 	}
 	if (messageEvent->isReadable() && isImpromptu_) {
 		chatWindow_->flash(); /* behave like a regular char*/
 	}
 	if (joined_) {
 		std::string nick = message->getFrom().getResource();
 		if (nick != nick_ && currentOccupants_.find(nick) != currentOccupants_.end()) {
 			completer_->addWord(nick);
 		}
 	}
 	/*Buggy implementations never send the status code, so use an incoming message as a hint that joining's done (e.g. the old ejabberd on psi-im.org).*/
 	receivedActivity();
 	joined_ = true;
 
-	if (message->hasSubject() && message->getBody().empty()) {
+	if (message->hasSubject() && !message->getPayload<Body>() && !message->getPayload<Thread>()) {
 		chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "The room subject is now: %1%")) % message->getSubject())), ChatWindow::DefaultDirection);
 		chatWindow_->setSubject(message->getSubject());
 		doneGettingHistory_ = true;
 	}
 
 	if (!doneGettingHistory_ && !message->getPayload<Delay>()) {
 		doneGettingHistory_ = true;
 	}
 
 	if (!doneGettingHistory_) {
 		checkDuplicates(message);
 		messageEvent->conclude();
 	}
 }
 
 void MUCController::addMessageHandleIncomingMessage(const JID& from, const std::string& message, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& time, const HighlightAction& highlight) {
 	if (from.isBare()) {
 		chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "%1%")) % message)), ChatWindow::DefaultDirection);
 	}
 	else {
 		ChatControllerBase::addMessageHandleIncomingMessage(from, message, senderIsSelf, label, time, highlight);
 	}
 }
 
 void MUCController::postHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent, const HighlightAction& highlight) {
 	boost::shared_ptr<Message> message = messageEvent->getStanza();
 	if (joined_ && messageEvent->getStanza()->getFrom().getResource() != nick_ && !message->getPayload<Delay>()) {
 		if (messageTargetsMe(message) || isImpromptu_) {
 			eventController_->handleIncomingEvent(messageEvent);
 		}
@@ -1051,61 +1052,61 @@ void MUCController::handleBlockingStateChanged() {
 	}
 }
 
 void MUCController::handleAffiliationListReceived(MUCOccupant::Affiliation affiliation, const std::vector<JID>& jids) {
 	chatWindow_->setAffiliations(affiliation, jids);
 }
 
 void MUCController::logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming) {
 	// log only incoming messages
 	if (isIncoming && historyController_) {
 		historyController_->addMessage(message, fromJID, toJID, HistoryMessage::Groupchat, timeStamp);
 	}
 }
 
 void MUCController::addRecentLogs() {
 	if (!historyController_) {
 		return;
 	}
 
 	joinContext_ = historyController_->getMUCContext(selfJID_, toJID_, lastActivity_);
 
 	foreach (const HistoryMessage& message, joinContext_) {
 		bool senderIsSelf = nick_ == message.getFromJID().getResource();
 
 		// the chatWindow uses utc timestamps
 		addMessage(message.getMessage(), senderDisplayNameFromMessage(message.getFromJID()), senderIsSelf, boost::shared_ptr<SecurityLabel>(new SecurityLabel()), avatarManager_->getAvatarPath(message.getFromJID()), message.getTime() - boost::posix_time::hours(message.getOffset()), HighlightAction());
 	}
 }
 
 void MUCController::checkDuplicates(boost::shared_ptr<Message> newMessage) {
-	std::string body = newMessage->getBody();
+	std::string body = newMessage->getBody().get_value_or("");
 	JID jid = newMessage->getFrom();
 	boost::optional<boost::posix_time::ptime> time = newMessage->getTimestamp();
 
 	reverse_foreach (const HistoryMessage& message, joinContext_) {
 		boost::posix_time::ptime messageTime = message.getTime() - boost::posix_time::hours(message.getOffset());
 		if (time && time < messageTime) {
 			break;
 		}
 		if (time && time != messageTime) {
 			continue;
 		}
 		if (message.getFromJID() != jid) {
 			continue;
 		}
 		if (message.getMessage() != body) {
 			continue;
 		}
 
 		// Mark the message as unreadable
 		newMessage->setBody("");
 	}
 }
 
 void MUCController::setNick(const std::string& nick) {
 	nick_ = nick;
 	highlighter_->setNick(nick_);
 }
 
 Form::ref MUCController::buildImpromptuRoomConfiguration(Form::ref roomConfigurationForm) {
 	Form::ref result = boost::make_shared<Form>(Form::SubmitType);