1 files changed, 11 insertions, 1 deletions
diff --git a/Swift/Controllers/Chat/ChatsManager.cpp b/Swift/Controllers/Chat/ChatsManager.cpp
index 190ca8b..b7087fd 100644
--- a/Swift/Controllers/Chat/ChatsManager.cpp
+++ b/Swift/Controllers/Chat/ChatsManager.cpp
@@ -408,60 +408,69 @@ ChatListWindow::Chat ChatsManager::createChatListChatItem(const JID& jid, const
 
                 std::map<JID, std::string> participantsNames;
                 for (auto& i : invitees_[jid]) {
                     participantsNames.emplace(i, roster_->getNameForJID(i));
                 }
                 chat.inviteesNames = participantsNames;
                 return chat;
             }
         }
         return ChatListWindow::Chat(jid, jid.toString(), activity, unreadCount, type, boost::filesystem::path(), true, privateMessage, nick, password);
     } else {
         ChatController* controller = getChatControllerIfExists(jid, false);
         if (controller) {
             unreadCount = controller->getUnreadCount();
         }
         JID bareishJID = mucRegistry_->isMUC(jid.toBare()) ? jid : jid.toBare();
         Presence::ref presence = presenceOracle_->getAccountPresence(bareishJID);
         StatusShow::Type type = presence ? presence->getShow() : StatusShow::None;
         boost::filesystem::path avatarPath = avatarManager_ ? avatarManager_->getAvatarPath(bareishJID) : boost::filesystem::path();
         return ChatListWindow::Chat(bareishJID, nickResolver_->jidToNick(bareishJID), activity, unreadCount, type, avatarPath, false, privateMessage);
     }
 }
 
 void ChatsManager::handleChatActivity(const JID& jid, const std::string& activity, bool isMUC) {
     const bool privateMessage = mucRegistry_->isMUC(jid.toBare()) && !isMUC;
     ChatListWindow::Chat chat = createChatListChatItem(jid, activity, privateMessage);
     /* FIXME: handle nick changes */
     appendRecent(chat);
     handleUnreadCountChanged(nullptr);
     saveRecents();
+
+    // Look up potential MUC controller and update title accordingly as people
+    // join impromptu chats.
+    if (mucControllers_.find(jid) != mucControllers_.end()) {
+        auto chatListWindowIter = std::find_if(recentChats_.begin(), recentChats_.end(), [&](const ChatListWindow::Chat& chatListWindow) { return jid == (chatListWindow.jid); });
+        if (chatListWindowIter != recentChats_.end() && (mucControllers_[jid]->isImpromptu() || !chatListWindowIter->impromptuJIDs.empty())) {
+            mucControllers_[jid]->setChatWindowTitle(chatListWindowIter->getTitle());
+        }
+    }
 }
 
 void ChatsManager::handleChatClosed(const JID& /*jid*/) {
     cleanupPrivateMessageRecents();
     chatListWindow_->setRecents(recentChats_);
 }
 
 void ChatsManager::handleUnreadCountChanged(ChatControllerBase* controller) {
     int unreadTotal = 0;
     bool controllerIsMUC = dynamic_cast<MUCController*>(controller);
     bool isPM = controller && !controllerIsMUC && mucRegistry_->isMUC(controller->getToJID().toBare());
     for (ChatListWindow::Chat& chatItem : recentChats_) {
         bool match = false;
         if (controller) {
             /* Matching MUC item */
             match |= chatItem.isMUC == controllerIsMUC && chatItem.jid.toBare() == controller->getToJID().toBare();
             /* Matching PM */
             match |= isPM &&  chatItem.jid == controller->getToJID();
             /* Matching non-PM */
             match |= !isPM && !controllerIsMUC && chatItem.jid.toBare() == controller->getToJID().toBare();
         }
         if (match) {
             chatItem.setUnreadCount(controller->getUnreadCount());
         }
         unreadTotal += chatItem.unreadCount;
     }
     chatListWindow_->setRecents(recentChats_);
     chatListWindow_->setUnreadCount(unreadTotal);
 }
 
@@ -848,62 +857,63 @@ MUC::ref ChatsManager::handleJoinMUCRequest(const JID &mucJID, const boost::opti
         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_);
         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()) {
+    if (chatListWindowIter != recentChats_.end() && (mucControllers_[mucJID]->isImpromptu() || !chatListWindowIter->impromptuJIDs.empty())) {
         mucControllers_[mucJID]->setChatWindowTitle(chatListWindowIter->getTitle());
     }
 
     mucControllers_[mucJID]->showChatWindow();
     return muc;
 }
 
 void ChatsManager::handleSearchMUCRequest() {
     mucSearchController_->openSearchWindow();
 }
 
 void ChatsManager::handleUserNicknameChanged(MUCController* mucController, const std::string& oldNickname, const std::string& newNickname) {
     JID oldMUCChatJID = mucController->getToJID().withResource(oldNickname);
     JID newMUCChatJID = mucController->getToJID().withResource(newNickname);
 
     SWIFT_LOG(debug) << "nickname change in " << mucController->getToJID().toString() << " from " << oldNickname << " to " << newNickname << std::endl;
 
     // get current chat controller
     ChatController *chatController = getChatControllerIfExists(oldMUCChatJID);
     if (chatController) {
         // adjust chat controller
         chatController->setToJID(newMUCChatJID);
         nickResolver_->onNickChanged(newMUCChatJID, oldNickname);
         chatControllers_.erase(oldMUCChatJID);
         chatControllers_[newMUCChatJID] = chatController;
 
         chatController->onActivity.disconnect(boost::bind(&ChatsManager::handleChatActivity, this, oldMUCChatJID, _1, false));
         chatController->onActivity.connect(boost::bind(&ChatsManager::handleChatActivity, this, newMUCChatJID, _1, false));
     }
 }