1 files changed, 16 insertions, 8 deletions
diff --git a/Swift/Controllers/Chat/MUCController.cpp b/Swift/Controllers/Chat/MUCController.cpp
index a142ee0..73cf748 100644
--- a/Swift/Controllers/Chat/MUCController.cpp
+++ b/Swift/Controllers/Chat/MUCController.cpp
@@ -101,60 +101,61 @@ MUCController::MUCController (
         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) {
     assert(avatarManager_);
 
     parting_ = true;
     joined_ = false;
     lastWasPresence_ = false;
     shouldJoinOnReconnect_ = true;
     doneGettingHistory_ = false;
     xmppRoster_ = xmppRoster;
     subject_ = "";
     isInitialJoin_ = true;
 
     roster_ = std::unique_ptr<Roster>(new 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));
     muc_->onJoinComplete.connect(boost::bind(&MUCController::handleJoinComplete, this, _1));
     muc_->onJoinFailed.connect(boost::bind(&MUCController::handleJoinFailed, this, _1));
     muc_->onOccupantJoined.connect(boost::bind(&MUCController::handleOccupantJoined, this, _1));
     muc_->onOccupantNicknameChanged.connect(boost::bind(&MUCController::handleOccupantNicknameChanged, this, _1, _2));
     muc_->onOccupantPresenceChange.connect(boost::bind(&MUCController::handleOccupantPresenceChange, this, _1));
     muc_->onOccupantLeft.connect(boost::bind(&MUCController::handleOccupantLeft, this, _1, _2, _3));
     muc_->onRoleChangeFailed.connect(boost::bind(&MUCController::handleOccupantRoleChangeFailed, this, _1, _2, _3));
     muc_->onAffiliationListReceived.connect(boost::bind(&MUCController::handleAffiliationListReceived, this, _1, _2));
     muc_->onConfigurationFailed.connect(boost::bind(&MUCController::handleConfigurationFailed, this, _1));
     muc_->onConfigurationFormReceived.connect(boost::bind(&MUCController::handleConfigurationFormReceived, this, _1));
     chatMessageParser_->setNick(nick_);
     if (timerFactory && stanzaChannel_->isAvailable()) {
         loginCheckTimer_ = std::shared_ptr<Timer>(timerFactory->createTimer(MUC_JOIN_WARNING_TIMEOUT_MILLISECONDS));
         loginCheckTimer_->onTick.connect(boost::bind(&MUCController::handleJoinTimeoutTick, this));
         loginCheckTimer_->start();
     }
     else {
         chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(QT_TRANSLATE_NOOP("", "You are currently offline. You will enter this room when you are connected.")), ChatWindow::DefaultDirection);
     }
     if (isImpromptu) {
         muc_->onUnlocked.connect(boost::bind(&MUCController::handleRoomUnlocked, this));
         chatWindow_->convertToMUC(ChatWindow::ImpromptuMUC);
     } else {
         muc_->onOccupantRoleChanged.connect(boost::bind(&MUCController::handleOccupantRoleChanged, this, _1, _2, _3));
         muc_->onOccupantAffiliationChanged.connect(boost::bind(&MUCController::handleOccupantAffiliationChanged, this, _1, _2, _3));
         chatWindow_->convertToMUC(ChatWindow::StandardMUC);
         chatWindow_->setName(muc->getJID().getNode());
     }
     if (stanzaChannel->isAvailable()) {
         MUCController::setOnline(true);
@@ -354,68 +355,68 @@ void MUCController::handleJoinFailed(std::shared_ptr<ErrorPayload> error) {
             errorMessage += QT_TRANSLATE_NOOP("", "You are banned from the room");
             break;
         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 enter 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);
+        lastStartMessage_ = str(format(QT_TRANSLATE_NOOP("", "You have joined the chat as %1%.")) % nick);
+    }
+    else {
+        lastStartMessage_ = str(format(QT_TRANSLATE_NOOP("", "You have entered room %1% as %2%.")) % toJID_.toString() % nick);
     }
     setNick(nick);
-    chatWindow_->replaceSystemMessage(chatMessageParser_->parseMessageBody(joinMessage, "", true), lastJoinMessageUID_, ChatWindow::UpdateTimestamp);
+    chatWindow_->replaceSystemMessage(chatMessageParser_->parseMessageBody(lastStartMessage_, "", true), lastJoinMessageUID_, ChatWindow::UpdateTimestamp);
     lastJoinMessageUID_ = "";
 
 #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() {
@@ -633,67 +634,70 @@ void MUCController::handleOccupantAffiliationChanged(const std::string& nick, co
         setAvailableRoomActions(affiliation, muc_->getOccupant(nick_).getRole());
     }
     JID jid(nickToJID(nick));
     MUCOccupant occupant = muc_->getOccupant(nick);
     roster_->applyOnItems(SetMUC(jid, occupant.getRole(), affiliation));
 }
 
 std::string MUCController::roleToGroupName(MUCOccupant::Role role) {
     std::string result;
     switch (role) {
     case MUCOccupant::Moderator: result = QT_TRANSLATE_NOOP("", "Moderators"); break;
     case MUCOccupant::Participant: result = QT_TRANSLATE_NOOP("", "Participants"); break;
     case MUCOccupant::Visitor: result = QT_TRANSLATE_NOOP("", "Visitors"); break;
     case MUCOccupant::NoRole: result = QT_TRANSLATE_NOOP("", "Occupants"); break;
     }
     return result;
 }
 
 void MUCController::setOnline(bool online) {
     ChatControllerBase::setOnline(online);
     if (!online) {
         muc_->part();
         parting_ = true;
         processUserPart();
     } else {
         if (shouldJoinOnReconnect_) {
             renameCounter_ = 0;
             std::shared_ptr<BlockList> blockList = clientBlockListManager_->getBlockList();
             if (blockList && blockList->isBlocked(muc_->getJID())) {
                 handleBlockingStateChanged();
-                lastJoinMessageUID_ = chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(QT_TRANSLATE_NOOP("", "You've blocked this room. To enter the room, first unblock it using the cog menu and try again")), ChatWindow::DefaultDirection);
+                lastStartMessage_ = QT_TRANSLATE_NOOP("", "You've blocked this room. To enter the room, first unblock it using the cog menu and try again");
+                lastJoinMessageUID_ = chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(lastStartMessage_ ), ChatWindow::DefaultDirection);
             }
             else {
                 if (isImpromptu_) {
-                    lastJoinMessageUID_ = chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(QT_TRANSLATE_NOOP("", "Trying to join chat")), ChatWindow::DefaultDirection);
+                    lastStartMessage_ = QT_TRANSLATE_NOOP("", "Trying to join chat");
+                    lastJoinMessageUID_ = chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(lastStartMessage_), ChatWindow::DefaultDirection);
                 } else {
-                    lastJoinMessageUID_ = chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "Trying to enter room %1%")) % toJID_.toString())), ChatWindow::DefaultDirection);
+                    lastStartMessage_ = str(format(QT_TRANSLATE_NOOP("", "Trying to enter room %1%")) % toJID_.toString());
+                    lastJoinMessageUID_ = chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(lastStartMessage_), ChatWindow::DefaultDirection);
                 }
                 if (loginCheckTimer_) {
                     loginCheckTimer_->start();
                 }
                 setNick(desiredNick_);
                 rejoin();
             }
         }
     }
 }
 
 void MUCController::processUserPart() {
     roster_->removeAll();
     /* handleUserLeft won't throw a part back up unless this is called
        when it doesn't yet know we've left - which only happens on
        disconnect, so call with disconnect here so if the signal does
        bubble back up, it'll be with the right type.*/
     muc_->handleUserLeft(MUC::Disconnect);
     setEnabled(false);
 }
 
 bool MUCController::shouldUpdateJoinParts() {
     return lastWasPresence_;
 }
 
 void MUCController::handleOccupantLeft(const MUCOccupant& occupant, MUC::LeavingType type, const std::string& reason) {
     NickJoinPart event(occupant.getNick(), Part);
     appendToJoinParts(joinParts_, event);
     currentOccupants_.erase(occupant.getNick());
     completer_->removeWord(occupant.getNick());
@@ -1212,31 +1216,35 @@ void MUCController::handleMUCBookmarkRemoved(const MUCBookmark& bookmark) {
     }
 }
 
 void MUCController::updateChatWindowBookmarkStatus(const boost::optional<MUCBookmark>& bookmark) {
     assert(chatWindow_);
     if (bookmark) {
         if (bookmark->getAutojoin()) {
             chatWindow_->setBookmarkState(ChatWindow::RoomAutoJoined);
         }
         else {
             chatWindow_->setBookmarkState(ChatWindow::RoomBookmarked);
         }
     }
     else {
         chatWindow_->setBookmarkState(ChatWindow::RoomNotBookmarked);
     }
 }
 
 void MUCController::displaySubjectIfChanged(const std::string& subject) {
     if (subject_ != subject) {
         if (!subject.empty()) {
             chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "The room subject is now: %1%")) % subject)), ChatWindow::DefaultDirection);
         }
         else {
             chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "The room subject has been removed")))), ChatWindow::DefaultDirection);
         }
         subject_ = subject;
     }
 }
 
+void MUCController::addChatSystemMessage() {
+    lastJoinMessageUID_ = chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(lastStartMessage_), ChatWindow::DefaultDirection);
+}
+
 }