1 files changed, 10 insertions, 2 deletions
diff --git a/Swift/Controllers/Chat/ChatsManager.cpp b/Swift/Controllers/Chat/ChatsManager.cpp
index 48cdb29..1a69982 100644
--- a/Swift/Controllers/Chat/ChatsManager.cpp
+++ b/Swift/Controllers/Chat/ChatsManager.cpp
@@ -1,32 +1,32 @@
 /*
- * 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/ChatsManager.h>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/archive/text_iarchive.hpp>
 #include <boost/archive/text_oarchive.hpp>
 #include <boost/bind.hpp>
 #include <boost/serialization/map.hpp>
 #include <boost/serialization/optional.hpp>
 #include <boost/serialization/split_free.hpp>
 #include <boost/serialization/string.hpp>
 #include <boost/serialization/vector.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 
 #include <Swiften/Avatars/AvatarManager.h>
 #include <Swiften/Base/Log.h>
 #include <Swiften/Base/foreach.h>
 #include <Swiften/Client/ClientBlockListManager.h>
 #include <Swiften/Client/NickResolver.h>
 #include <Swiften/Client/StanzaChannel.h>
 #include <Swiften/Disco/DiscoServiceWalker.h>
 #include <Swiften/Elements/ChatState.h>
 #include <Swiften/Elements/DeliveryReceipt.h>
 #include <Swiften/Elements/DeliveryReceiptRequest.h>
 #include <Swiften/Elements/MUCInvitationPayload.h>
 #include <Swiften/Elements/MUCUserPayload.h>
 #include <Swiften/MUC/MUCBookmarkManager.h>
@@ -663,60 +663,61 @@ void ChatsManager::handleAvatarChanged(const JID& jid) {
 	}
 }
 
 void ChatsManager::setServerDiscoInfo(boost::shared_ptr<DiscoInfo> info) {
 	serverDiscoInfo_ = info;
 	foreach (JIDChatControllerPair pair, chatControllers_) {
 		pair.second->setAvailableServerFeatures(info);
 	}
 	foreach (JIDMUCControllerPair pair, mucControllers_) {
 		pair.second->setAvailableServerFeatures(info);
 	}
 }
 
 /**
  * This is to be called on connect/disconnect.
  */ 
 void ChatsManager::setOnline(bool enabled) {
 	foreach (JIDChatControllerPair controllerPair, chatControllers_) {
 		controllerPair.second->setOnline(enabled);
 	}
 	foreach (JIDMUCControllerPair controllerPair, mucControllers_) {
 		controllerPair.second->setOnline(enabled);
 		if (enabled) {
 			controllerPair.second->rejoin();
 		}
 	}
 	if (!enabled) {
 		markAllRecentsOffline();
 	} else {
 		setupBookmarks();
+		localMUCServiceJID_ = JID();
 		localMUCServiceFinderWalker_ = boost::make_shared<DiscoServiceWalker>(jid_.getDomain(), iqRouter_);
 		localMUCServiceFinderWalker_->onServiceFound.connect(boost::bind(&ChatsManager::handleLocalServiceFound, this, _1, _2));
 		localMUCServiceFinderWalker_->onWalkAborted.connect(boost::bind(&ChatsManager::handleLocalServiceWalkFinished, this));
 		localMUCServiceFinderWalker_->onWalkComplete.connect(boost::bind(&ChatsManager::handleLocalServiceWalkFinished, this));
 		localMUCServiceFinderWalker_->beginWalk();
 	}
 
 	if (chatListWindow_) {
 		chatListWindow_->setBookmarksEnabled(enabled);
 	}
 }
 
 void ChatsManager::handleChatRequest(const std::string &contact) {
 	ChatController* controller = getChatControllerOrFindAnother(JID(contact));
 	controller->activateChatWindow();
 }
 
 ChatController* ChatsManager::getChatControllerOrFindAnother(const JID &contact) {
 	ChatController* controller = getChatControllerIfExists(contact);
 	if (!controller && !mucRegistry_->isMUC(contact.toBare())) {
 		foreach (JIDChatControllerPair pair, chatControllers_) {
 			if (pair.first.toBare() == contact.toBare()) {
 				controller = pair.second;
 				break;
 			}
 		}
 	}
 	return controller ? controller : createNewChatController(contact);
 }
 
@@ -977,61 +978,68 @@ void ChatsManager::handleRecentActivated(const ChatListWindow::Chat& chat) {
 		std::vector<JID> inviteJIDs;
 		foreach(StringJIDPair pair, chat.impromptuJIDs) {
 			inviteJIDs.push_back(pair.second);
 		}
 		uiEventStream_->send(boost::make_shared<CreateImpromptuMUCUIEvent>(inviteJIDs, chat.jid, ""));
 	}
 	else if (chat.isMUC) {
 		/* FIXME: This means that recents requiring passwords will just flat-out not work */
 		uiEventStream_->send(boost::make_shared<JoinMUCUIEvent>(chat.jid, boost::optional<std::string>(), chat.nick));
 	}
 	else {
 		uiEventStream_->send(boost::make_shared<RequestChatUIEvent>(chat.jid));
 	}
 }
 
 void ChatsManager::handleLocalServiceFound(const JID& service, boost::shared_ptr<DiscoInfo> info) {
 	foreach (DiscoInfo::Identity identity, info->getIdentities()) {
 			if ((identity.getCategory() == "directory"
 				&& identity.getType() == "chatroom")
 				|| (identity.getCategory() == "conference"
 				&& identity.getType() == "text")) {
 				localMUCServiceJID_ = service;
 				localMUCServiceFinderWalker_->endWalk();
 				SWIFT_LOG(debug) << "Use following MUC service for impromptu chats: " << localMUCServiceJID_ << std::endl;
 				break;
 			}
 	}
 }
 
 void ChatsManager::handleLocalServiceWalkFinished() {
-	onImpromptuMUCServiceDiscovered(!localMUCServiceJID_.toString().empty());
+	bool impromptuMUCSupported = !localMUCServiceJID_.toString().empty();
+	foreach (JIDChatControllerPair controllerPair, chatControllers_) {
+		controllerPair.second->setCanStartImpromptuChats(impromptuMUCSupported);
+	}
+	foreach (JIDMUCControllerPair controllerPair, mucControllers_) {
+		controllerPair.second->setCanStartImpromptuChats(impromptuMUCSupported);
+	}
+	onImpromptuMUCServiceDiscovered(impromptuMUCSupported);
 }
 
 std::vector<ChatListWindow::Chat> ChatsManager::getRecentChats() const {
 	return std::vector<ChatListWindow::Chat>(recentChats_.begin(), recentChats_.end());
 }
 
 std::vector<Contact::ref> Swift::ChatsManager::getContacts(bool withMUCNicks) {
 	std::vector<Contact::ref> result;
 	foreach (ChatListWindow::Chat chat, recentChats_) {
 		if (!chat.isMUC) {
 			result.push_back(boost::make_shared<Contact>(chat.chatName.empty() ? chat.jid.toString() : chat.chatName, chat.jid, chat.statusType, chat.avatarPath));
 		}
 	}
 	if (withMUCNicks) {
 		/* collect MUC nicks */
 		typedef std::map<JID, MUCController*>::value_type Item;
 		foreach (const Item& item, mucControllers_) {
 			JID mucJID = item.second->getToJID();
 			std::map<std::string, JID> participants = item.second->getParticipantJIDs();
 			typedef std::map<std::string, JID>::value_type ParticipantType;
 			foreach (const ParticipantType& participant, participants) {
 				const JID nickJID = JID(mucJID.getNode(), mucJID.getDomain(), participant.first);
 				Presence::ref presence = presenceOracle_->getLastPresence(nickJID);
 				const boost::filesystem::path avatar = avatarManager_->getAvatarPath(nickJID);
 				result.push_back(boost::make_shared<Contact>(participant.first, JID(), presence->getShow(), avatar));
 			}
 		}
 	}
 	return result;
 }