3 files changed, 19 insertions, 3 deletions
diff --git a/Swift/Controllers/Chat/ChatsManager.cpp b/Swift/Controllers/Chat/ChatsManager.cpp
index 654f735..1698b4a 100644
--- a/Swift/Controllers/Chat/ChatsManager.cpp
+++ b/Swift/Controllers/Chat/ChatsManager.cpp
@@ -5,18 +5,19 @@
  */
 
 #include <Swift/Controllers/Chat/ChatsManager.h>
 
 #include <boost/bind.hpp>
 #include <boost/algorithm/string.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 #include <boost/archive/text_oarchive.hpp>
 #include <boost/archive/text_iarchive.hpp>
+#include <boost/serialization/optional.hpp>
 #include <boost/serialization/vector.hpp>
 #include <boost/serialization/map.hpp>
 #include <boost/serialization/string.hpp>
 #include <boost/serialization/split_free.hpp>
 
 #include <Swiften/Base/foreach.h>
 #include <Swiften/Presence/PresenceSender.h>
 #include <Swiften/Client/NickResolver.h>
 #include <Swiften/MUC/MUCManager.h>
@@ -56,42 +57,47 @@
 #include <Swift/Controllers/SettingConstants.h>
 #include <Swift/Controllers/WhiteboardManager.h>
 #include <Swift/Controllers/Chat/ChatMessageParser.h>
 #include <Swift/Controllers/Chat/UserSearchController.h>
 #include <Swiften/Disco/DiscoServiceWalker.h>
 #include <Swiften/Client/ClientBlockListManager.h>
 #include <Swiften/StringCodecs/Base64.h>
 #include <Swiften/Base/Log.h>
 
+BOOST_CLASS_VERSION(Swift::ChatListWindow::Chat, 1)
+
 namespace boost {
 namespace serialization {
 	template<class Archive> void save(Archive& ar, const Swift::JID& jid, const unsigned int /*version*/) {
 		std::string jidStr = jid.toString();
 		ar << jidStr;
 	}
 
 	template<class Archive> void load(Archive& ar, Swift::JID& jid, const unsigned int /*version*/) {
 		std::string stringJID;
 		ar >> stringJID;
 		jid = Swift::JID(stringJID);
 	}
 
 	template<class Archive> inline void serialize(Archive& ar, Swift::JID& t, const unsigned int file_version){
 		split_free(ar, t, file_version);
 	}
 
-	template<class Archive> void serialize(Archive& ar, Swift::ChatListWindow::Chat& chat, const unsigned int /*version*/) {
+	template<class Archive> void serialize(Archive& ar, Swift::ChatListWindow::Chat& chat, const unsigned int version) {
 		ar & chat.jid;
 		ar & chat.chatName;
 		ar & chat.activity;
 		ar & chat.isMUC;
 		ar & chat.nick;
 		ar & chat.impromptuJIDs;
+		if (version > 0) {
+			ar & chat.password;
+		}
 	}
 }
 }
 
 namespace Swift {
 
 typedef std::pair<JID, ChatController*> JIDChatControllerPair;
 typedef std::pair<JID, MUCController*> JIDMUCControllerPair;
 
@@ -363,34 +369,39 @@ void ChatsManager::handleMUCBookmarkRemoved(const MUCBookmark& bookmark) {
 	chatListWindow_->removeMUCBookmark(bookmark);
 }
 
 ChatListWindow::Chat ChatsManager::createChatListChatItem(const JID& jid, const std::string& activity) {
 	int unreadCount = 0;
 	if (mucRegistry_->isMUC(jid)) {
 		MUCController* controller = mucControllers_[jid.toBare()];
 		StatusShow::Type type = StatusShow::None;
 		std::string nick = "";
+		std::string password = "";
 		if (controller) {
 			unreadCount = controller->getUnreadCount();
 			if (controller->isJoined()) {
 				type = StatusShow::Online;
 			}
 			nick = controller->getNick();
 
+			if (controller->getPassword()) {
+				password = *controller->getPassword();
+			}
+
 			if (controller->isImpromptu()) {
-				ChatListWindow::Chat chat = ChatListWindow::Chat(jid, jid.toString(), activity, unreadCount, type, boost::filesystem::path(), true, nick);
+				ChatListWindow::Chat chat = ChatListWindow::Chat(jid, jid.toString(), activity, unreadCount, type, boost::filesystem::path(), true, nick, password);
 				typedef std::pair<std::string, JID> StringJIDPair;
 				std::map<std::string, JID> participants = controller->getParticipantJIDs();
 				chat.impromptuJIDs = participants;
 				return chat;
 			}
 		}
-		return ChatListWindow::Chat(jid, jid.toString(), activity, unreadCount, type, boost::filesystem::path(), true, nick);
+		return ChatListWindow::Chat(jid, jid.toString(), activity, unreadCount, type, boost::filesystem::path(), true, 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_->getHighestPriorityPresence(bareishJID);
 		StatusShow::Type type = presence ? presence->getShow() : StatusShow::None;
 		boost::filesystem::path avatarPath = avatarManager_ ? avatarManager_->getAvatarPath(bareishJID) : boost::filesystem::path();
diff --git a/Swift/Controllers/Chat/MUCController.cpp b/Swift/Controllers/Chat/MUCController.cpp
index 4860fc8..6bc7067 100644
--- a/Swift/Controllers/Chat/MUCController.cpp
+++ b/Swift/Controllers/Chat/MUCController.cpp
@@ -237,18 +237,22 @@ void MUCController::rejoin() {
 
 bool MUCController::isJoined() {
 	return joined_;
 }
 
 const std::string& MUCController::getNick() {
 	return nick_;
 }
 
+const boost::optional<std::string> MUCController::getPassword() const {
+	return password_;
+}
+
 bool MUCController::isImpromptu() const {
 	return isImpromptu_;
 }
 
 std::map<std::string, JID> MUCController::getParticipantJIDs() const {
 	std::map<std::string, JID> participants;
 	typedef std::pair<std::string, MUCOccupant> MUCOccupantPair;
 	std::map<std::string, MUCOccupant> occupants = muc_->getOccupants();
 	foreach(const MUCOccupantPair& occupant, occupants) {
diff --git a/Swift/Controllers/Chat/MUCController.h b/Swift/Controllers/Chat/MUCController.h
index e78ff77..feffaba 100644
--- a/Swift/Controllers/Chat/MUCController.h
+++ b/Swift/Controllers/Chat/MUCController.h
@@ -56,18 +56,19 @@ namespace Swift {
 			boost::signal<void ()> onUserJoined;
 			boost::signal<void ()> onImpromptuConfigCompleted;
 			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, bool isImpromptu);
 			static std::string concatenateListOfNames(const std::vector<NickJoinPart>& joinParts);
 			bool isJoined();
 			const std::string& getNick();
+			const boost::optional<std::string> getPassword() const;
 			bool isImpromptu() const;
 			std::map<std::string, JID> getParticipantJIDs() const;
 			void sendInvites(const std::vector<JID>& jids, const std::string& reason) const;
 		
 		protected:
 			void preSendMessageRequest(boost::shared_ptr<Message> message);
 			bool isIncomingMessageFromMe(boost::shared_ptr<Message> message);
 			std::string senderDisplayNameFromMessage(const JID& from);
 			boost::optional<boost::posix_time::ptime> getMessageTimestamp(boost::shared_ptr<Message> message) const;