6 files changed, 24 insertions, 16 deletions
diff --git a/Swift/Controllers/Chat/ChatsManager.cpp b/Swift/Controllers/Chat/ChatsManager.cpp
index d3060b8..e6441e1 100644
--- a/Swift/Controllers/Chat/ChatsManager.cpp
+++ b/Swift/Controllers/Chat/ChatsManager.cpp
@@ -193,19 +193,19 @@ void ChatsManager::handleBookmarksReady() {
 	if (chatListWindow_) {
 		chatListWindow_->setBookmarksEnabled(true);
 	}
 }
 
 void ChatsManager::handleMUCBookmarkAdded(const MUCBookmark& bookmark) {
 	std::map<JID, MUCController*>::iterator it = mucControllers_.find(bookmark.getRoom());
 	if (it == mucControllers_.end() && bookmark.getAutojoin()) {
 		//FIXME: need vcard stuff here to get a nick
-		handleJoinMUCRequest(bookmark.getRoom(), bookmark.getNick(), false, false);
+		handleJoinMUCRequest(bookmark.getRoom(), bookmark.getPassword(), bookmark.getNick(), false, false);
 	}
 	chatListWindow_->addMUCBookmark(bookmark);
 }
 
 void ChatsManager::handleMUCBookmarkRemoved(const MUCBookmark& bookmark) {
 	chatListWindow_->removeMUCBookmark(bookmark);
 }
 
 ChatListWindow::Chat ChatsManager::createChatListChatItem(const JID& jid, const std::string& activity) {
@@ -315,19 +315,19 @@ void ChatsManager::handleUIEvent(boost::shared_ptr<UIEvent> event) {
 		mucBookmarkManager_->addBookmark(addMUCBookmarkEvent->getBookmark());
 		return;
 	}
 
 	boost::shared_ptr<EditMUCBookmarkUIEvent> editMUCBookmarkEvent = boost::dynamic_pointer_cast<EditMUCBookmarkUIEvent>(event);
 	if (editMUCBookmarkEvent) {
 		mucBookmarkManager_->replaceBookmark(editMUCBookmarkEvent->getOldBookmark(), editMUCBookmarkEvent->getNewBookmark());
 	}
 	else if (JoinMUCUIEvent::ref joinEvent = boost::dynamic_pointer_cast<JoinMUCUIEvent>(event)) {
-		handleJoinMUCRequest(joinEvent->getJID(), joinEvent->getNick(), joinEvent->getShouldJoinAutomatically(), joinEvent->getCreateAsReservedRoomIfNew());
+		handleJoinMUCRequest(joinEvent->getJID(), joinEvent->getPassword(), joinEvent->getNick(), joinEvent->getShouldJoinAutomatically(), joinEvent->getCreateAsReservedRoomIfNew());
 		mucControllers_[joinEvent->getJID()]->activateChatWindow();
 	}
 	else if (boost::shared_ptr<RequestJoinMUCUIEvent> joinEvent = boost::dynamic_pointer_cast<RequestJoinMUCUIEvent>(event)) {
 		if (!joinMUCWindow_) {
 			joinMUCWindow_ = joinMUCWindowFactory_->createJoinMUCWindow(uiEventStream_);
 			joinMUCWindow_->onSearchMUC.connect(boost::bind(&ChatsManager::handleSearchMUCRequest, this));
 		}
 		joinMUCWindow_->setMUC(joinEvent->getRoom());
 		joinMUCWindow_->setNick(nickResolver_->jidToNick(jid_));
@@ -475,38 +475,38 @@ ChatController* ChatsManager::getChatControllerIfExists(const JID &contact, bool
 	return chatControllers_[contact];
 }
 
 void ChatsManager::rebindControllerJID(const JID& from, const JID& to) {
 	chatControllers_[to] = chatControllers_[from];
 	chatControllers_.erase(from);
 	chatControllers_[to]->setToJID(to);
 }
 
-void ChatsManager::handleJoinMUCRequest(const JID &mucJID, const boost::optional<std::string>& nickMaybe, bool addAutoJoin, bool createAsReservedIfNew) {
+void ChatsManager::handleJoinMUCRequest(const JID &mucJID, const boost::optional<std::string>& password, const boost::optional<std::string>& nickMaybe, bool addAutoJoin, bool createAsReservedIfNew) {
 	if (addAutoJoin) {
 		MUCBookmark bookmark(mucJID, mucJID.getNode());
 		bookmark.setAutojoin(true);
 		if (nickMaybe) {
 			bookmark.setNick(*nickMaybe);
 		}
 		mucBookmarkManager_->addBookmark(bookmark);
 	}
 
 	std::map<JID, MUCController*>::iterator it = mucControllers_.find(mucJID);
 	if (it != mucControllers_.end()) {
 		it->second->rejoin();
 	} else {
 		std::string nick = nickMaybe ? nickMaybe.get() : jid_.getNode();
 		MUC::ref muc = mucManager->createMUC(mucJID);
 		if (createAsReservedIfNew) {
 			muc->setCreateAsReservedIfNew();
 		}
-		MUCController* controller = new MUCController(jid_, muc, nick, stanzaChannel_, iqRouter_, chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_);
+		MUCController* controller = new MUCController(jid_, muc, password, nick, stanzaChannel_, iqRouter_, chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_);
 		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->onActivity.connect(boost::bind(&ChatsManager::handleChatActivity, this, mucJID.toBare(), _1, true));
 		controller->onUnreadCountChanged.connect(boost::bind(&ChatsManager::handleUnreadCountChanged, this, controller));
 		handleChatActivity(mucJID.toBare(), "", true);
 	}
 
@@ -543,28 +543,29 @@ void ChatsManager::handleIncomingMessage(boost::shared_ptr<Message> message) {
 }
 
 void ChatsManager::handleMUCSelectedAfterSearch(const JID& muc) {
 	if (joinMUCWindow_) {
 		joinMUCWindow_->setMUC(muc.toString());
 	}
 }
 
 void ChatsManager::handleMUCBookmarkActivated(const MUCBookmark& mucBookmark) {
-	uiEventStream_->send(boost::make_shared<JoinMUCUIEvent>(mucBookmark.getRoom(), mucBookmark.getNick()));
+	uiEventStream_->send(boost::make_shared<JoinMUCUIEvent>(mucBookmark.getRoom(), mucBookmark.getPassword(), mucBookmark.getNick()));
 }
 
 void ChatsManager::handleNewFileTransferController(FileTransferController* ftc) {
 	ChatController* chatController = getChatControllerOrCreate(ftc->getOtherParty());
 	chatController->handleNewFileTransferController(ftc);
 	chatController->activateChatWindow();
 }
 
 void ChatsManager::handleRecentActivated(const ChatListWindow::Chat& chat) {
 	if (chat.isMUC) {
-		uiEventStream_->send(boost::make_shared<JoinMUCUIEvent>(chat.jid, chat.nick));
+		/* 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));
 	}
 }
 
 }
diff --git a/Swift/Controllers/Chat/ChatsManager.h b/Swift/Controllers/Chat/ChatsManager.h
index a82492c..8e94d9a 100644
--- a/Swift/Controllers/Chat/ChatsManager.h
+++ b/Swift/Controllers/Chat/ChatsManager.h
@@ -52,19 +52,19 @@ namespace Swift {
 			virtual ~ChatsManager();
 			void setAvatarManager(AvatarManager* avatarManager);
 			void setOnline(bool enabled);
 			void setServerDiscoInfo(boost::shared_ptr<DiscoInfo> info);
 			void handleIncomingMessage(boost::shared_ptr<Message> message);
 
 		private:
 			ChatListWindow::Chat createChatListChatItem(const JID& jid, const std::string& activity);
 			void handleChatRequest(const std::string& contact);
-			void handleJoinMUCRequest(const JID& muc, const boost::optional<std::string>& nick, bool addAutoJoin, bool createAsReservedIfNew);
+			void handleJoinMUCRequest(const JID& muc, const boost::optional<std::string>& password, const boost::optional<std::string>& nick, bool addAutoJoin, bool createAsReservedIfNew);
 			void handleSearchMUCRequest();
 			void handleMUCSelectedAfterSearch(const JID&);
 			void rebindControllerJID(const JID& from, const JID& to);
 			void handlePresenceChange(boost::shared_ptr<Presence> newPresence);
 			void handleUIEvent(boost::shared_ptr<UIEvent> event);
 			void handleMUCBookmarkAdded(const MUCBookmark& bookmark);
 			void handleMUCBookmarkRemoved(const MUCBookmark& bookmark);
 			void handleUserLeftMUC(MUCController* mucController);
 			void handleBookmarksReady();
diff --git a/Swift/Controllers/Chat/MUCController.cpp b/Swift/Controllers/Chat/MUCController.cpp
index d72c0f7..2b8a8b7 100644
--- a/Swift/Controllers/Chat/MUCController.cpp
+++ b/Swift/Controllers/Chat/MUCController.cpp
@@ -38,30 +38,31 @@
 
 namespace Swift {
 	
 /**
  * The controller does not gain ownership of the stanzaChannel, nor the factory.
  */
 MUCController::MUCController (
 		const JID& self,
 		MUC::ref muc,
+		const boost::optional<std::string>& password,
 		const std::string &nick, 
 		StanzaChannel* stanzaChannel, 
 		IQRouter* iqRouter, 
 		ChatWindowFactory* chatWindowFactory, 
 		PresenceOracle* presenceOracle,
 		AvatarManager* avatarManager,
 		UIEventStream* uiEventStream,
 		bool useDelayForLatency,
 		TimerFactory* timerFactory,
 		EventController* eventController,
 		EntityCapsProvider* entityCapsProvider) :
-			ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, timerFactory, entityCapsProvider), muc_(muc), nick_(nick), desiredNick_(nick) {
+			ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, timerFactory, entityCapsProvider), muc_(muc), nick_(nick), desiredNick_(nick), password_(password) {
 	parting_ = true;
 	joined_ = false;
 	lastWasPresence_ = false;
 	shouldJoinOnReconnect_ = true;
 	doneGettingHistory_ = false;
 	events_ = uiEventStream;
 	
 	roster_ = new Roster(false, true);
 	completer_ = new TabComplete();
@@ -140,18 +141,21 @@ void MUCController::handleBareJIDCapsChanged(const JID& /*jid*/) {
 }
 
 /**
  * Join the MUC if not already in it.
  */
 void MUCController::rejoin() {
 	if (parting_) {
 		joined_ = false;
 		parting_ = false;
+		if (password_) {
+			muc_->setPassword(*password_);
+		}
 		//FIXME: check for received activity
 		if (lastActivity_ == boost::posix_time::not_a_date_time) {
 			muc_->joinAs(nick_);
 		} else {
 			muc_->joinWithContextSince(nick_, lastActivity_);
 		}
 	}
 }
 
diff --git a/Swift/Controllers/Chat/MUCController.h b/Swift/Controllers/Chat/MUCController.h
index 17dbba4..d22d2ca 100644
--- a/Swift/Controllers/Chat/MUCController.h
+++ b/Swift/Controllers/Chat/MUCController.h
@@ -36,19 +36,19 @@ namespace Swift {
 
 	struct NickJoinPart {
 			NickJoinPart(const std::string& nick, JoinPart type) : nick(nick), type(type) {};
 			std::string nick;
 			JoinPart type;
 	};
 
 	class MUCController : public ChatControllerBase {
 		public:
-			MUCController(const JID& self, MUC::ref muc, const std::string &nick, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider);
+			MUCController(const JID& self, MUC::ref muc, const boost::optional<std::string>& password, const std::string &nick, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider);
 			~MUCController();
 			boost::signal<void ()> onUserLeft;
 			boost::signal<void ()> onUserJoined;
 			virtual void setOnline(bool online);
 			void rejoin();
 			static void appendToJoinParts(std::vector<NickJoinPart>& joinParts, const NickJoinPart& newEvent);
 			static std::string generateJoinPartString(const std::vector<NickJoinPart>& joinParts);
 			static std::string concatenateListOfNames(const std::vector<NickJoinPart>& joinParts);
 			bool isJoined();
@@ -106,12 +106,13 @@ namespace Swift {
 			bool joined_;
 			bool lastWasPresence_;
 			bool shouldJoinOnReconnect_;
 			bool doneGettingHistory_;
 			boost::bsignals::scoped_connection avatarChangedConnection_;
 			boost::shared_ptr<Timer> loginCheckTimer_;
 			std::set<std::string> currentOccupants_;
 			std::vector<NickJoinPart> joinParts_;
 			boost::posix_time::ptime lastActivity_;
+			boost::optional<std::string> password_;
 	};
 }
 
diff --git a/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp b/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp
index ad5ceac..16ad999 100644
--- a/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp
+++ b/Swift/Controllers/Chat/UnitTest/MUCControllerTest.cpp
@@ -54,19 +54,19 @@ public:
 		directedPresenceSender_ = new DirectedPresenceSender(presenceSender_);
 		uiEventStream_ = new UIEventStream();
 		avatarManager_ = new NullAvatarManager();
 		TimerFactory* timerFactory = NULL;
 		window_ = new MockChatWindow();//mocks_->InterfaceMock<ChatWindow>();
 		mucRegistry_ = new MUCRegistry();
 		entityCapsProvider_ = new DummyEntityCapsProvider();
 		muc_ = MUC::ref(new MUC(stanzaChannel_, iqRouter_, directedPresenceSender_, JID("teaparty@rooms.wonderland.lit"), mucRegistry_));
 		mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(muc_->getJID(), uiEventStream_).Return(window_);
-		controller_ = new MUCController (self_, muc_, nick_, stanzaChannel_, iqRouter_, chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory, eventController_, entityCapsProvider_);
+		controller_ = new MUCController (self_, muc_, boost::optional<std::string>(), nick_, stanzaChannel_, iqRouter_, chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory, eventController_, entityCapsProvider_);
 	};
 
 	void tearDown() {
 		delete entityCapsProvider_;
 		delete controller_;
 		delete eventController_;
 		delete presenceOracle_;
 		delete mocks_;
 		delete uiEventStream_;
diff --git a/Swift/Controllers/UIEvents/JoinMUCUIEvent.h b/Swift/Controllers/UIEvents/JoinMUCUIEvent.h
index e1d65ad..b3ff8c7 100644
--- a/Swift/Controllers/UIEvents/JoinMUCUIEvent.h
+++ b/Swift/Controllers/UIEvents/JoinMUCUIEvent.h
@@ -6,27 +6,29 @@
 
 #pragma once
 
 #include <boost/optional.hpp>
 #include <boost/shared_ptr.hpp>
 #include <string>
 
 #include <Swiften/JID/JID.h>
 
-#include "Swift/Controllers/UIEvents/UIEvent.h"
+#include <Swift/Controllers/UIEvents/UIEvent.h>
 
 namespace Swift {
 	class JoinMUCUIEvent : public UIEvent {
 		public:
 			typedef boost::shared_ptr<JoinMUCUIEvent> ref;
-			JoinMUCUIEvent(const JID& jid, const boost::optional<std::string>& nick = boost::optional<std::string>(), bool joinAutomaticallyInFuture = false, bool createAsReservedRoomIfNew = false) : jid_(jid), nick_(nick), joinAutomatically_(joinAutomaticallyInFuture), createAsReservedRoomIfNew_(createAsReservedRoomIfNew) {};
-			boost::optional<std::string> getNick() {return nick_;};
-			JID getJID() {return jid_;};
-			bool getShouldJoinAutomatically() {return joinAutomatically_;}
-			bool getCreateAsReservedRoomIfNew() {return createAsReservedRoomIfNew_;}
+			JoinMUCUIEvent(const JID& jid, const boost::optional<std::string>& password = boost::optional<std::string>(), const boost::optional<std::string>& nick = boost::optional<std::string>(), bool joinAutomaticallyInFuture = false, bool createAsReservedRoomIfNew = false) : jid_(jid), nick_(nick), joinAutomatically_(joinAutomaticallyInFuture), createAsReservedRoomIfNew_(createAsReservedRoomIfNew), password_(password) {};
+			const boost::optional<std::string>& getNick() const {return nick_;}
+			const JID& getJID() const {return jid_;}
+			bool getShouldJoinAutomatically() const {return joinAutomatically_;}
+			bool getCreateAsReservedRoomIfNew() const {return createAsReservedRoomIfNew_;}
+			const boost::optional<std::string>& getPassword() const {return password_;}
 		private:
 			JID jid_;
 			boost::optional<std::string> nick_;
 			bool joinAutomatically_;
 			bool createAsReservedRoomIfNew_;
+			boost::optional<std::string> password_;
 	};
 }