1 files changed, 4 insertions, 4 deletions
diff --git a/Swift/Controllers/Chat/ChatControllerBase.cpp b/Swift/Controllers/Chat/ChatControllerBase.cpp
index 4a84a6e..fef3e7a 100644
--- a/Swift/Controllers/Chat/ChatControllerBase.cpp
+++ b/Swift/Controllers/Chat/ChatControllerBase.cpp
@@ -145,62 +145,62 @@ int ChatControllerBase::getUnreadCount() {
 }
 
 void ChatControllerBase::handleSendMessageRequest(const std::string &body, bool isCorrectionMessage) {
 	if (!stanzaChannel_->isAvailable() || body.empty()) {
 		return;
 	}
 	boost::shared_ptr<Message> message(new Message());
 	message->setTo(toJID_);
 	message->setType(Swift::Message::Chat);
 	message->setBody(body);
 	if (labelsEnabled_) {
 		if (!isCorrectionMessage) {
 			lastLabel_ = chatWindow_->getSelectedSecurityLabel();
 		}
 		SecurityLabelsCatalog::Item labelItem = lastLabel_;
 		if (labelItem.getLabel()) {
 			message->addPayload(labelItem.getLabel());
 		}
 	}
 	preSendMessageRequest(message);
 
 	boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();
 	if (useDelayForLatency_) {
 		message->addPayload(boost::make_shared<Delay>(now, selfJID_));
 	}
 	if (isCorrectionMessage) {
 		message->addPayload(boost::shared_ptr<Replace> (new Replace(lastSentMessageStanzaID_)));
 	}
 	message->setID(lastSentMessageStanzaID_ = idGenerator_.generateID());
 	stanzaChannel_->sendMessage(message);
-	postSendMessage(message->getBody(), boost::dynamic_pointer_cast<Stanza>(message));
-	onActivity(message->getBody());
+	postSendMessage(message->getBody().get(), boost::dynamic_pointer_cast<Stanza>(message));
+	onActivity(message->getBody().get());
 
 #ifdef SWIFT_EXPERIMENTAL_HISTORY
 	logMessage(body, selfJID_, toJID_, now, false);
 #endif
 }
 
 void ChatControllerBase::handleSecurityLabelsCatalogResponse(boost::shared_ptr<SecurityLabelsCatalog> catalog, ErrorPayload::ref error) {
 	if (catalog && !error) {
 		if (catalog->getItems().size() == 0) {
 			chatWindow_->setSecurityLabelsEnabled(false);
 			labelsEnabled_ = false;
 		} else {
 			labelsEnabled_ = true;
 			chatWindow_->setAvailableSecurityLabels(catalog->getItems());
 			chatWindow_->setSecurityLabelsEnabled(true);
 		}
 	} else {
 		labelsEnabled_ = false;
 		chatWindow_->setSecurityLabelsError();
 	}
 }
 
 void ChatControllerBase::showChatWindow() {
 	chatWindow_->show();
 }
 
 void ChatControllerBase::activateChatWindow() {
 	chatWindow_->activate();
 }
 
@@ -210,110 +210,110 @@ bool ChatControllerBase::hasOpenWindow() const {
 
 std::string ChatControllerBase::addMessage(const std::string& message, const std::string& senderName, bool senderIsSelf, const boost::shared_ptr<SecurityLabel> label, const boost::filesystem::path& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) {
 	if (boost::starts_with(message, "/me ")) {
 		return chatWindow_->addAction(chatMessageParser_->parseMessageBody(String::getSplittedAtFirst(message, ' ').second), senderName, senderIsSelf, label, pathToString(avatarPath), time, highlight);
 	} else {
 		return chatWindow_->addMessage(chatMessageParser_->parseMessageBody(message,highlighter_->getNick(),senderIsSelf), senderName, senderIsSelf, label, pathToString(avatarPath), time, highlight);
 	}
 }
 
 void ChatControllerBase::replaceMessage(const std::string& message, const std::string& id, bool senderIsSelf, const boost::posix_time::ptime& time, const HighlightAction& highlight) {
 	if (boost::starts_with(message, "/me ")) {
 		chatWindow_->replaceWithAction(chatMessageParser_->parseMessageBody(String::getSplittedAtFirst(message, ' ').second), id, time, highlight);
 	} else {
 		chatWindow_->replaceMessage(chatMessageParser_->parseMessageBody(message,highlighter_->getNick(),senderIsSelf), id, time, highlight);
 	}
 }
 
 bool ChatControllerBase::isFromContact(const JID& from) {
 	return from.toBare() == toJID_.toBare();
 }
 
 void ChatControllerBase::handleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent) {
 	preHandleIncomingMessage(messageEvent);
 	if (messageEvent->isReadable() && !messageEvent->getConcluded()) {
 		unreadMessages_.push_back(messageEvent);
 		if (messageEvent->targetsMe()) {
 			targetedUnreadMessages_.push_back(messageEvent);
 		}
 	}
 	boost::shared_ptr<Message> message = messageEvent->getStanza();
-	std::string body = message->getBody();
+	std::string body = message->getBody().get_value_or("");
 	HighlightAction highlight;
 	if (message->isError()) {
 		if (!message->getTo().getResource().empty()) {
 			std::string errorMessage = str(format(QT_TRANSLATE_NOOP("", "Couldn't send message: %1%")) % getErrorMessage(message->getPayload<ErrorPayload>()));
 			chatWindow_->addErrorMessage(chatMessageParser_->parseMessageBody(errorMessage));
 		}
 	}
 	else if (messageEvent->getStanza()->getPayload<MUCInvitationPayload>()) {
 		handleMUCInvitation(messageEvent->getStanza());
 		return;
 	}
 	else if (messageEvent->getStanza()->getPayload<MUCUserPayload>() && messageEvent->getStanza()->getPayload<MUCUserPayload>()->getInvite()) {
 		handleMediatedMUCInvitation(messageEvent->getStanza());
 		return;
 	}
 	else {
 		if (!messageEvent->isReadable()) {
 			return;
 		}
 		showChatWindow();
 		JID from = message->getFrom();
 		std::vector<boost::shared_ptr<Delay> > delayPayloads = message->getPayloads<Delay>();
 		for (size_t i = 0; useDelayForLatency_ && i < delayPayloads.size(); i++) {
 			if (!delayPayloads[i]->getFrom()) {
 				continue;
 			}
 			boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();
 			std::ostringstream s;
 			s << "The following message took " << (now - delayPayloads[i]->getStamp()).total_milliseconds() / 1000.0 <<  " seconds to be delivered from " << delayPayloads[i]->getFrom()->toString() << ".";
 			chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(std::string(s.str())), ChatWindow::DefaultDirection);
 		}
 		boost::shared_ptr<SecurityLabel> label = message->getPayload<SecurityLabel>();
 
 		// Determine the timestamp
 		boost::posix_time::ptime timeStamp = boost::posix_time::microsec_clock::universal_time();
 		boost::optional<boost::posix_time::ptime> messageTimeStamp = getMessageTimestamp(message);
 		if (messageTimeStamp) {
 			timeStamp = *messageTimeStamp;
 		}
 		onActivity(body);
 
 		// Highlight
 		if (!isIncomingMessageFromMe(message)) {
 			highlight = highlighter_->findAction(body, senderHighlightNameFromMessage(from));
 		}
 
 		boost::shared_ptr<Replace> replace = message->getPayload<Replace>();
 		if (replace) {
-			std::string body = message->getBody();
+			std::string body = message->getBody().get_value_or("");
 			// Should check if the user has a previous message
 			std::map<JID, std::string>::iterator lastMessage;
 			lastMessage = lastMessagesUIID_.find(from);
 			if (lastMessage != lastMessagesUIID_.end()) {
 				replaceMessage(body, lastMessagesUIID_[from], isIncomingMessageFromMe(message), timeStamp, highlight);
 			}
 		}
 		else {
 			addMessageHandleIncomingMessage(from, body, isIncomingMessageFromMe(message), label, timeStamp, highlight);
 		}
 
 		logMessage(body, from, selfJID_, timeStamp, true);
 	}
 	chatWindow_->show();
 	chatWindow_->setUnreadMessageCount(boost::numeric_cast<int>(unreadMessages_.size()));
 	onUnreadCountChanged();
 	postHandleIncomingMessage(messageEvent, highlight);
 }
 
 void ChatControllerBase::addMessageHandleIncomingMessage(const JID& from, const std::string& message, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp, const HighlightAction& highlight) {
 	lastMessagesUIID_[from] = addMessage(message, senderDisplayNameFromMessage(from), senderIsSelf, label, avatarManager_->getAvatarPath(from), timeStamp, highlight);
 }
 
 std::string ChatControllerBase::getErrorMessage(boost::shared_ptr<ErrorPayload> error) {
 	std::string defaultMessage = QT_TRANSLATE_NOOP("", "Error sending message");
 	if (!error->getText().empty()) {
 		return error->getText();
 	}
 	else {
 		switch (error->getCondition()) {