2 files changed, 3 insertions, 3 deletions
diff --git a/Swift/Controllers/Chat/ChatController.cpp b/Swift/Controllers/Chat/ChatController.cpp
index 65d65a6..2367761 100644
--- a/Swift/Controllers/Chat/ChatController.cpp
+++ b/Swift/Controllers/Chat/ChatController.cpp
@@ -446,69 +446,69 @@ std::string ChatController::getStatusChangeString(boost::shared_ptr<Presence> pr
 
 	if (!response.empty()) {
 		response = str(format(response) % nick);
 	}
 
 	if (!presence->getStatus().empty()) {
 		response += " (" + presence->getStatus() + ")";
 	}
 	return response + ".";
 }
 
 void ChatController::handlePresenceChange(boost::shared_ptr<Presence> newPresence) {
 	bool me = false;
 	if (toJID_.isBare()) {
 		newPresence = presenceOracle_->getHighestPriorityPresence(toJID_);
 		if ((newPresence ? newPresence->getShow() : StatusShow::None) != lastShownStatus_) {
 			me = true;
 		}
 	} else if (toJID_.equals(newPresence->getFrom(), JID::WithResource)) {
 		me = true;
 	}
 	if (!me) {
 		return;
 	}
 	if (!newPresence) {
 		newPresence = boost::make_shared<Presence>();
 		newPresence->setType(Presence::Unavailable);
 	}
 	lastShownStatus_ = newPresence->getShow();
 
 	chatStateTracker_->handlePresenceChange(newPresence);
 	chatStateNotifier_->setContactIsOnline(newPresence->getType() == Presence::Available);
 	std::string newStatusChangeString = getStatusChangeString(newPresence);
 	if (newStatusChangeString != lastStatusChangeString_) {
 		if (lastWasPresence_) {
-			chatWindow_->replaceLastMessage(chatMessageParser_->parseMessageBody(newStatusChangeString));
+			chatWindow_->replaceLastMessage(chatMessageParser_->parseMessageBody(newStatusChangeString), ChatWindow::UpdateTimestamp);
 		} else {
 			chatWindow_->addPresenceMessage(chatMessageParser_->parseMessageBody(newStatusChangeString), ChatWindow::DefaultDirection);
 		}
 		lastStatusChangeString_ = newStatusChangeString;
 		lastWasPresence_ = true;
 	}
 }
 
 boost::optional<boost::posix_time::ptime> ChatController::getMessageTimestamp(boost::shared_ptr<Message> message) const {
 	return message->getTimestamp();
 }
 
 void ChatController::logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool /* isIncoming */) {
 	HistoryMessage::Type type;
 	if (mucRegistry_->isMUC(fromJID.toBare()) || mucRegistry_->isMUC(toJID.toBare())) {
 		type = HistoryMessage::PrivateMessage;
 	}
 	else {
 		type = HistoryMessage::Chat;
 	}
 
 	if (historyController_) {
 		historyController_->addMessage(message, fromJID, toJID, type, timeStamp);
 	}
 }
 
 ChatWindow* ChatController::detachChatWindow() {
 	chatWindow_->onUserTyping.disconnect(boost::bind(&ChatStateNotifier::setUserIsTyping, chatStateNotifier_));
 	chatWindow_->onUserCancelsTyping.disconnect(boost::bind(&ChatStateNotifier::userCancelledNewMessage, chatStateNotifier_));
 	return ChatControllerBase::detachChatWindow();
 }
 
 }
diff --git a/Swift/Controllers/Chat/MUCController.cpp b/Swift/Controllers/Chat/MUCController.cpp
index 6bc7067..d09bc3d 100644
--- a/Swift/Controllers/Chat/MUCController.cpp
+++ b/Swift/Controllers/Chat/MUCController.cpp
@@ -312,71 +312,71 @@ void MUCController::handleJoinFailed(boost::shared_ptr<ErrorPayload> error) {
 		case ErrorPayload::ServiceUnavailable: 
 			errorMessage += ": ";
 			errorMessage += QT_TRANSLATE_NOOP("", "The room is full");
 			break;
 		case ErrorPayload::ItemNotFound: 
 			errorMessage += ": ";
 			errorMessage += QT_TRANSLATE_NOOP("", "The room does not exist");
 			break;
 			
 		default: break;
 		}
 	}
 	errorMessage = str(format(QT_TRANSLATE_NOOP("", "Couldn't join room: %1%.")) % errorMessage);
 	chatWindow_->addErrorMessage(chatMessageParser_->parseMessageBody(errorMessage));
 	parting_ = true;
 	if (!rejoinNick.empty() && renameCounter_ < 10) {
 		renameCounter_++;
 		setNick(rejoinNick);
 		rejoin();
 	}
 }
 
 #pragma clang diagnostic pop
 
 void MUCController::handleJoinComplete(const std::string& nick) {
 	receivedActivity();
 	renameCounter_ = 0;
 	joined_ = true;
 	std::string joinMessage;
 	if (isImpromptu_) {
 		joinMessage = str(format(QT_TRANSLATE_NOOP("", "You have joined the chat as %1%.")) % nick);
 	} else {
 		joinMessage = str(format(QT_TRANSLATE_NOOP("", "You have entered room %1% as %2%.")) % toJID_.toString() % nick);
 	}
 	setNick(nick);
-	chatWindow_->replaceLastMessage(chatMessageParser_->parseMessageBody(joinMessage));
+	chatWindow_->replaceLastMessage(chatMessageParser_->parseMessageBody(joinMessage), ChatWindow::UpdateTimestamp);
 
 #ifdef SWIFT_EXPERIMENTAL_HISTORY
 	addRecentLogs();
 #endif
 
 	clearPresenceQueue();
 	shouldJoinOnReconnect_ = true;
 	setEnabled(true);
 	if (isImpromptu_) {
 		setAvailableRoomActions(MUCOccupant::NoAffiliation, MUCOccupant::Participant);
 	} else {
 		MUCOccupant occupant = muc_->getOccupant(nick);
 		setAvailableRoomActions(occupant.getAffiliation(), occupant.getRole());
 	}
 	onUserJoined();
 
 	if (isImpromptu_) {
 		setImpromptuWindowTitle();
 	}
 }
 
 void MUCController::handleAvatarChanged(const JID& jid) {
 	if (parting_ || !jid.equals(toJID_, JID::WithoutResource)) {
 		return;
 	}
 	roster_->applyOnItems(SetAvatar(jid, avatarManager_->getAvatarPath(jid), JID::WithResource));
 }
 
 void MUCController::handleWindowClosed() {
 	parting_ = true;
 	shouldJoinOnReconnect_ = false;
 	muc_->part();
 	onUserLeft();
 }
 
@@ -682,71 +682,71 @@ void MUCController::handleOccupantLeft(const MUCOccupant& occupant, MUC::Leaving
 		parting_ = true;
 		processUserPart();
 	}
 	if (clearAfter) {
 		clearPresenceQueue();
 	}
 
 	if (isImpromptu_) {
 		setImpromptuWindowTitle();
 	}
 }
 
 void MUCController::handleOccupantPresenceChange(boost::shared_ptr<Presence> presence) {
 	receivedActivity();
 	roster_->applyOnItems(SetPresence(presence, JID::WithResource));
 }
 
 bool MUCController::isIncomingMessageFromMe(boost::shared_ptr<Message> message) {
 	JID from = message->getFrom();
 	return nick_ == from.getResource();
 }
 
 std::string MUCController::senderDisplayNameFromMessage(const JID& from) {
 	return from.getResource();
 }
 
 void MUCController::preSendMessageRequest(boost::shared_ptr<Message> message) {
 	message->setType(Swift::Message::Groupchat);
 }
 
 boost::optional<boost::posix_time::ptime> MUCController::getMessageTimestamp(boost::shared_ptr<Message> message) const {
 	return message->getTimestampFrom(toJID_);
 }
 
 void MUCController::updateJoinParts() {
-	chatWindow_->replaceLastMessage(chatMessageParser_->parseMessageBody(generateJoinPartString(joinParts_, isImpromptu())));
+	chatWindow_->replaceLastMessage(chatMessageParser_->parseMessageBody(generateJoinPartString(joinParts_, isImpromptu())), ChatWindow::UpdateTimestamp);
 }
 
 void MUCController::appendToJoinParts(std::vector<NickJoinPart>& joinParts, const NickJoinPart& newEvent) {
 	std::vector<NickJoinPart>::iterator it = joinParts.begin();
 	bool matched = false;
 	for (; it != joinParts.end(); ++it) {
 		if ((*it).nick == newEvent.nick) {
 			matched = true;
 			JoinPart type = (*it).type;
 			switch (newEvent.type) {
 				case Join: type = (type == Part) ? PartThenJoin : Join; break;
 				case Part: type = (type == Join) ? JoinThenPart : Part; break;
 				case PartThenJoin: break;
 				case JoinThenPart: break;
 			}
 			(*it).type = type;
 			break;
 		}
 	}
 	if (!matched) {
 		joinParts.push_back(newEvent);
 	}
 }
 
 std::string MUCController::concatenateListOfNames(const std::vector<NickJoinPart>& joinParts) {
 	std::string result;
 	for (size_t i = 0; i < joinParts.size(); i++) {
 		if (i > 0) {
 			if (i < joinParts.size() - 1) {
 				result += ", ";
 			} else {
 				result += QT_TRANSLATE_NOOP("", " and ");
 			}
 		}
 		NickJoinPart event = joinParts[i];