6 files changed, 59 insertions, 16 deletions
diff --git a/Swift/Controllers/Chat/ChatController.cpp b/Swift/Controllers/Chat/ChatController.cpp
index 9df7708..9b65c9f 100644
--- a/Swift/Controllers/Chat/ChatController.cpp
+++ b/Swift/Controllers/Chat/ChatController.cpp
@@ -89,18 +89,19 @@ ChatController::ChatController(const JID& self, StanzaChannel* stanzaChannel, IQ
 	chatWindow_->onFileTransferAccept.connect(boost::bind(&ChatController::handleFileTransferAccept, this, _1, _2));
 	chatWindow_->onFileTransferCancel.connect(boost::bind(&ChatController::handleFileTransferCancel, this, _1));
 	chatWindow_->onSendFileRequest.connect(boost::bind(&ChatController::handleSendFileRequest, this, _1));
 	chatWindow_->onWhiteboardSessionAccept.connect(boost::bind(&ChatController::handleWhiteboardSessionAccept, this));
 	chatWindow_->onWhiteboardSessionCancel.connect(boost::bind(&ChatController::handleWhiteboardSessionCancel, this));
 	chatWindow_->onWhiteboardWindowShow.connect(boost::bind(&ChatController::handleWhiteboardWindowShow, this));
 	chatWindow_->onBlockUserRequest.connect(boost::bind(&ChatController::handleBlockUserRequest, this));
 	chatWindow_->onUnblockUserRequest.connect(boost::bind(&ChatController::handleUnblockUserRequest, this));
 	chatWindow_->onInviteToChat.connect(boost::bind(&ChatController::handleInviteToChat, this, _1));
+	chatWindow_->onClosed.connect(boost::bind(&ChatController::handleWindowClosed, this));
 	handleBareJIDCapsChanged(toJID_);
 
 	settings_->onSettingChanged.connect(boost::bind(&ChatController::handleSettingChanged, this, _1));
 	eventStream_->onUIEvent.connect(boost::bind(&ChatController::handleUIEvent, this, _1));
 }
 
 void ChatController::handleContactNickChanged(const JID& jid, const std::string& /*oldNick*/) {
 	if (jid.toBare() == toJID_.toBare()) {
 		chatWindow_->setName(nickResolver_->jidToNick(jid));
@@ -300,18 +301,22 @@ void ChatController::handleUnblockUserRequest() {
 		eventStream_->send(boost::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Unblocked, toJID_.toBare()));
 	}
 }
 
 void ChatController::handleInviteToChat(const std::vector<JID>& droppedJIDs) {
 	boost::shared_ptr<UIEvent> event(new RequestInviteToMUCUIEvent(toJID_.toBare(), droppedJIDs, RequestInviteToMUCUIEvent::Impromptu));
 	eventStream_->send(event);
 }
 
+void ChatController::handleWindowClosed() {
+	onWindowClosed();
+}
+
 void ChatController::handleUIEvent(boost::shared_ptr<UIEvent> event) {
 	boost::shared_ptr<InviteToMUCUIEvent> inviteEvent = boost::dynamic_pointer_cast<InviteToMUCUIEvent>(event);
 	if (inviteEvent && inviteEvent->getRoom() == toJID_.toBare()) {
 		onConvertToMUC(detachChatWindow(), inviteEvent->getInvites(), inviteEvent->getReason());
 	}
 }
 
 
 void ChatController::postSendMessage(const std::string& body, boost::shared_ptr<Stanza> sentStanza) {
diff --git a/Swift/Controllers/Chat/ChatController.h b/Swift/Controllers/Chat/ChatController.h
index 8b1bb9a..2e92be7 100644
--- a/Swift/Controllers/Chat/ChatController.h
+++ b/Swift/Controllers/Chat/ChatController.h
@@ -73,20 +73,20 @@ namespace Swift {
 
 			void handleBlockingStateChanged();
 			void handleBlockingItemAdded(const JID&);
 			void handleBlockingItemRemoved(const JID&);
 
 			void handleBlockUserRequest();
 			void handleUnblockUserRequest();
 
 			void handleInviteToChat(const std::vector<JID>& droppedJIDs);
-			void handleInviteToMUCWindowDismissed();
-			void handleInviteToMUCWindowCompleted();
+
+			void handleWindowClosed();
 
 			void handleUIEvent(boost::shared_ptr<UIEvent> event);
 
 		private:
 			NickResolver* nickResolver_;
 			ChatStateNotifier* chatStateNotifier_;
 			ChatStateTracker* chatStateTracker_;
 			std::string myLastMessageUIID_;
 			bool isInMUC_;
diff --git a/Swift/Controllers/Chat/ChatControllerBase.cpp b/Swift/Controllers/Chat/ChatControllerBase.cpp
index 5363e0c..24341e6 100644
--- a/Swift/Controllers/Chat/ChatControllerBase.cpp
+++ b/Swift/Controllers/Chat/ChatControllerBase.cpp
@@ -191,18 +191,22 @@ void ChatControllerBase::handleSecurityLabelsCatalogResponse(boost::shared_ptr<S
 
 void ChatControllerBase::showChatWindow() {
 	chatWindow_->show();
 }
 
 void ChatControllerBase::activateChatWindow() {
 	chatWindow_->activate();
 }
 
+bool ChatControllerBase::hasOpenWindow() const {
+	return chatWindow_ && chatWindow_->isVisible();
+}
+
 std::string ChatControllerBase::addMessage(const std::string& message, const std::string& senderName, bool senderIsSelf, const boost::shared_ptr<SecurityLabel> label, const boost::filesystem::path& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) {
 	if (boost::starts_with(message, "/me ")) {
 		return chatWindow_->addAction(chatMessageParser_->parseMessageBody(String::getSplittedAtFirst(message, ' ').second), senderName, senderIsSelf, label, pathToString(avatarPath), time, highlight);
 	} else {
 		return chatWindow_->addMessage(chatMessageParser_->parseMessageBody(message,senderIsSelf), senderName, senderIsSelf, label, pathToString(avatarPath), time, highlight);
 	}
 }
 
 void ChatControllerBase::replaceMessage(const std::string& message, const std::string& id, bool senderIsSelf, const boost::posix_time::ptime& time, const HighlightAction& highlight) {
diff --git a/Swift/Controllers/Chat/ChatControllerBase.h b/Swift/Controllers/Chat/ChatControllerBase.h
index cf0a4d2..a0b848b 100644
--- a/Swift/Controllers/Chat/ChatControllerBase.h
+++ b/Swift/Controllers/Chat/ChatControllerBase.h
@@ -46,28 +46,30 @@ namespace Swift {
 	class Highlighter;
 	class ChatMessageParser;
 	class AutoAcceptMUCInviteDecider;
 
 	class ChatControllerBase : public boost::bsignals::trackable {
 		public:
 			virtual ~ChatControllerBase();
 			void showChatWindow();
 			void activateChatWindow();
+			bool hasOpenWindow() const;
 			virtual void setAvailableServerFeatures(boost::shared_ptr<DiscoInfo> info);
 			void handleIncomingMessage(boost::shared_ptr<MessageEvent> message);
 			std::string addMessage(const std::string& message, const std::string& senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const boost::filesystem::path& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight);
 			void replaceMessage(const std::string& message, const std::string& id, bool senderIsSelf, const boost::posix_time::ptime& time, const HighlightAction& highlight);
 			virtual void setOnline(bool online);
 			virtual void setEnabled(bool enabled);
 			virtual void setToJID(const JID& jid) {toJID_ = jid;}
 			/** Used for determining when something is recent.*/
 			boost::signal<void (const std::string& /*activity*/)> onActivity;
 			boost::signal<void ()> onUnreadCountChanged;
+			boost::signal<void ()> onWindowClosed;
 			int getUnreadCount();
 			const JID& getToJID() {return toJID_;}
 			void handleCapsChanged(const JID& jid);
 			void setCanStartImpromptuChats(bool supportsImpromptu);
 			virtual ChatWindow* detachChatWindow();
 			boost::signal<void(ChatWindow* /*window to reuse*/, const std::vector<JID>& /*invite people*/, const std::string& /*reason*/)> onConvertToMUC;
 
 		protected:
 			ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, boost::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider);
diff --git a/Swift/Controllers/Chat/ChatsManager.cpp b/Swift/Controllers/Chat/ChatsManager.cpp
index 8a077d1..3db1327 100644
--- a/Swift/Controllers/Chat/ChatsManager.cpp
+++ b/Swift/Controllers/Chat/ChatsManager.cpp
@@ -218,18 +218,27 @@ void ChatsManager::saveRecents() {
 	if (recentsLimited.size() > 25) {
 		recentsLimited.erase(recentsLimited.begin() + 25, recentsLimited.end());
 	}
 	if (eagleMode_) {
 		foreach(ChatListWindow::Chat& chat, recentsLimited) {
 			chat.activity = "";
 		}
 	}
 
+	class RemoveRecent {
+	public:
+		static bool ifPrivateMessage(const ChatListWindow::Chat& chat) {
+			return chat.isPrivateMessage;
+		}
+	};
+
+	recentsLimited.erase(std::remove_if(recentsLimited.begin(), recentsLimited.end(), RemoveRecent::ifPrivateMessage), recentsLimited.end());
+
 	oa << recentsLimited;
 	std::string serializedStr = Base64::encode(createByteArray(serializeStream.str()));
 	profileSettings_->storeString(RECENT_CHATS, serializedStr);
 }
 
 void ChatsManager::handleClearRecentsRequested() {
 	recentChats_.clear();
 	saveRecents();
 	handleUnreadCountChanged(NULL);
@@ -304,19 +313,19 @@ void ChatsManager::loadRecents() {
 			if (!jid.isValid()) {
 				continue;
 			}
 			std::string activity(recent[1]);
 			bool isMUC = recent[2] == "true";
 			std::string nick(recent[3]);
 			StatusShow::Type type = StatusShow::None;
 			boost::filesystem::path path;
 
-			ChatListWindow::Chat chat(jid, nickResolver_->jidToNick(jid), activity, 0, type, path, isMUC, nick);
+			ChatListWindow::Chat chat(jid, nickResolver_->jidToNick(jid), activity, 0, type, path, isMUC, false, nick);
 			chat = updateChatStatusAndAvatarHelper(chat);
 			prependRecent(chat);
 		}
 	} else if (!recentsString.empty()){
 		// boost searilaize based format
 		ByteArray debase64 = Base64::decode(recentsString);
 		std::vector<ChatListWindow::Chat> recentChats;
 		std::stringstream deserializeStream(std::string(reinterpret_cast<const char*>(vecptr(debase64)), debase64.size()));
 		try {
@@ -362,70 +371,72 @@ void ChatsManager::handleMUCBookmarkAdded(const MUCBookmark& bookmark) {
 		handleJoinMUCRequest(bookmark.getRoom(), bookmark.getPassword(), bookmark.getNick(), false, 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) {
+ChatListWindow::Chat ChatsManager::createChatListChatItem(const JID& jid, const std::string& activity, bool privateMessage) {
 	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, password);
+				ChatListWindow::Chat chat = ChatListWindow::Chat(jid, jid.toString(), activity, unreadCount, type, boost::filesystem::path(), true, privateMessage, 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, password);
+		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_->getHighestPriorityPresence(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);
+		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) {
-	if (mucRegistry_->isMUC(jid.toBare()) && !isMUC) {
-		/* Don't include PMs in MUC rooms.*/
-		return;
-	}
-	ChatListWindow::Chat chat = createChatListChatItem(jid, activity);
+	const bool privateMessage = mucRegistry_->isMUC(jid.toBare()) && !isMUC;
+	ChatListWindow::Chat chat = createChatListChatItem(jid, activity, privateMessage);
 	/* FIXME: handle nick changes */
 	appendRecent(chat);
 	handleUnreadCountChanged(NULL);
 	saveRecents();
 }
 
+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());
 	foreach (ChatListWindow::Chat& chatItem, recentChats_) {
 		bool match = false;
 		if (controller) {
 			/* Matching MUC item */
 			match |= chatItem.isMUC == controllerIsMUC && chatItem.jid.toBare() == controller->getToJID().toBare();
@@ -448,18 +459,36 @@ boost::optional<ChatListWindow::Chat> ChatsManager::removeExistingChat(const Cha
 	if (result != recentChats_.end()) {
 		ChatListWindow::Chat existingChat = *result;
 		recentChats_.erase(std::remove(recentChats_.begin(), recentChats_.end(), chat), recentChats_.end());
 		return boost::optional<ChatListWindow::Chat>(existingChat);
 	} else {
 		return boost::optional<ChatListWindow::Chat>();
 	}
 }
 
+void ChatsManager::cleanupPrivateMessageRecents() {
+	/* if we leave a MUC and close a PM, remove it's recent chat entry */
+	const std::list<ChatListWindow::Chat> chats = recentChats_;
+	foreach (const ChatListWindow::Chat& chat, chats) {
+		if (chat.isPrivateMessage) {
+			typedef std::map<JID, MUCController*> ControllerMap;
+			ControllerMap::iterator muc = mucControllers_.find(chat.jid.toBare());
+			if (muc == mucControllers_.end() || !muc->second->isJoined()) {
+				ChatController* chatController = getChatControllerIfExists(chat.jid);
+				if (!chatController || !chatController->hasOpenWindow()) {
+					removeExistingChat(chat);
+					break;
+				}
+			}
+		}
+	}
+}
+
 void ChatsManager::appendRecent(const ChatListWindow::Chat& chat) {
 	boost::optional<ChatListWindow::Chat> oldChat = removeExistingChat(chat);
 	ChatListWindow::Chat mergedChat = chat;
 	if (oldChat && !oldChat->impromptuJIDs.empty()) {
 		mergedChat.impromptuJIDs.insert(oldChat->impromptuJIDs.begin(), oldChat->impromptuJIDs.end());
 	}
 	recentChats_.push_front(mergedChat);
 }
 
@@ -473,27 +502,27 @@ void ChatsManager::prependRecent(const ChatListWindow::Chat& chat) {
 }
 
 void ChatsManager::handleUserLeftMUC(MUCController* mucController) {
 	std::map<JID, MUCController*>::iterator it;
 	for (it = mucControllers_.begin(); it != mucControllers_.end(); ++it) {
 		if ((*it).second == mucController) {
 			foreach (ChatListWindow::Chat& chat, recentChats_) {
 				if (chat.isMUC && chat.jid == (*it).first) {
 					chat.statusType = StatusShow::None;
-					chatListWindow_->setRecents(recentChats_);
-					break;
 				}
 			}
 			mucControllers_.erase(it);
 			delete mucController;
-			return;
+			break;
 		}
 	}
+	cleanupPrivateMessageRecents();
+	chatListWindow_->setRecents(recentChats_);
 }
 
 void ChatsManager::handleSettingChanged(const std::string& settingPath) {
 	if (settingPath == SettingConstants::REQUEST_DELIVERYRECEIPTS.getKey()) {
 		userWantsReceipts_ = settings_->getSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS);
 		return;
 	}
 }
 
@@ -695,18 +724,19 @@ ChatController* ChatsManager::getChatControllerOrFindAnother(const JID &contact)
 }
 
 ChatController* ChatsManager::createNewChatController(const JID& contact) {
 	assert(chatControllers_.find(contact) == chatControllers_.end());
 	boost::shared_ptr<ChatMessageParser> chatMessageParser = boost::make_shared<ChatMessageParser>(emoticons_, highlightManager_->getRules(), false); /* a message parser that knows this is a chat (not a room/MUC) */
 	ChatController* controller = new ChatController(jid_, stanzaChannel_, iqRouter_, chatWindowFactory_, contact, nickResolver_, presenceOracle_, avatarManager_, mucRegistry_->isMUC(contact.toBare()), useDelayForLatency_, uiEventStream_, eventController_, timerFactory_, entityCapsProvider_, userWantsReceipts_, settings_, historyController_, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser, autoAcceptMUCInviteDecider_);
 	chatControllers_[contact] = controller;
 	controller->setAvailableServerFeatures(serverDiscoInfo_);
 	controller->onActivity.connect(boost::bind(&ChatsManager::handleChatActivity, this, contact, _1, false));
+	controller->onWindowClosed.connect(boost::bind(&ChatsManager::handleChatClosed, this, contact));
 	controller->onUnreadCountChanged.connect(boost::bind(&ChatsManager::handleUnreadCountChanged, this, controller));
 	controller->onConvertToMUC.connect(boost::bind(&ChatsManager::handleTransformChatToMUC, this, controller, _1, _2, _3));
 	updatePresenceReceivingStateOnChatController(contact);
 	controller->setCanStartImpromptuChats(!localMUCServiceJID_.toString().empty());
 	return controller;
 }
 
 ChatController* ChatsManager::getChatControllerOrCreate(const JID &contact) {
 	ChatController* controller = getChatControllerIfExists(contact);
diff --git a/Swift/Controllers/Chat/ChatsManager.h b/Swift/Controllers/Chat/ChatsManager.h
index 41435d9..179f536 100644
--- a/Swift/Controllers/Chat/ChatsManager.h
+++ b/Swift/Controllers/Chat/ChatsManager.h
@@ -83,36 +83,38 @@ namespace Swift {
 					SingleChatWindowFactoryAdapter(ChatWindow* chatWindow);
 					virtual ~SingleChatWindowFactoryAdapter();
 					virtual ChatWindow* createChatWindow(const JID &, UIEventStream*);
 
 				private:
 					ChatWindow* chatWindow_;
 			};
 
 		private:
-			ChatListWindow::Chat createChatListChatItem(const JID& jid, const std::string& activity);
+			ChatListWindow::Chat createChatListChatItem(const JID& jid, const std::string& activity, bool privateMessage);
 			void handleChatRequest(const std::string& contact);
 			void finalizeImpromptuJoin(MUC::ref muc, const std::vector<JID>& jidsToInvite, const std::string& reason, const boost::optional<JID>& reuseChatJID = boost::optional<JID>());
 			MUC::ref handleJoinMUCRequest(const JID& muc, const boost::optional<std::string>& password, const boost::optional<std::string>& nick, bool addAutoJoin, bool createAsReservedIfNew, bool isImpromptu, ChatWindow* reuseChatwindow = 0);
 			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();
 			void handleChatActivity(const JID& jid, const std::string& activity, bool isMUC);
+			void handleChatClosed(const JID& jid);
 			void handleNewFileTransferController(FileTransferController*);
 			void handleWhiteboardSessionRequest(const JID& contact, bool senderIsSelf);
 			void handleWhiteboardStateChange(const JID& contact, const ChatWindow::WhiteboardSessionState state);
 			boost::optional<ChatListWindow::Chat> removeExistingChat(const ChatListWindow::Chat& chat);
+			void cleanupPrivateMessageRecents();
 			void appendRecent(const ChatListWindow::Chat& chat);
 			void prependRecent(const ChatListWindow::Chat& chat);
 			void setupBookmarks();
 			void loadRecents();
 			void saveRecents();
 			void handleChatMadeRecent();
 			void handleMUCBookmarkActivated(const MUCBookmark&);
 			void handleRecentActivated(const ChatListWindow::Chat&);
 			void handleUnreadCountChanged(ChatControllerBase* controller);