1 files changed, 43 insertions, 13 deletions
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
@@ -192,70 +192,79 @@ ChatsManager::ChatsManager(
 
 	autoAcceptMUCInviteDecider_ = new AutoAcceptMUCInviteDecider(jid.getDomain(), roster_, settings_);
 }
 
 ChatsManager::~ChatsManager() {
 	settings_->onSettingChanged.disconnect(boost::bind(&ChatsManager::handleSettingChanged, this, _1));
 	roster_->onJIDAdded.disconnect(boost::bind(&ChatsManager::handleJIDAddedToRoster, this, _1));
 	roster_->onJIDRemoved.disconnect(boost::bind(&ChatsManager::handleJIDRemovedFromRoster, this, _1));
 	roster_->onJIDUpdated.disconnect(boost::bind(&ChatsManager::handleJIDUpdatedInRoster, this, _1));
 	roster_->onRosterCleared.disconnect(boost::bind(&ChatsManager::handleRosterCleared, this));
 	delete joinMUCWindow_;
 	foreach (JIDChatControllerPair controllerPair, chatControllers_) {
 		delete controllerPair.second;
 	}
 	foreach (JIDMUCControllerPair controllerPair, mucControllers_) {
 		delete controllerPair.second;
 	}
 	delete mucBookmarkManager_;
 	delete mucSearchController_;
 	delete autoAcceptMUCInviteDecider_;
 }
 
 void ChatsManager::saveRecents() {
 	std::stringstream serializeStream;
 	boost::archive::text_oarchive oa(serializeStream);
 	std::vector<ChatListWindow::Chat> recentsLimited = std::vector<ChatListWindow::Chat>(recentChats_.begin(), recentChats_.end());
 	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);
 }
 
 void ChatsManager::handleJIDAddedToRoster(const JID &jid) {
 	updatePresenceReceivingStateOnChatController(jid);
 }
 
 void ChatsManager::handleJIDRemovedFromRoster(const JID &jid) {
 	updatePresenceReceivingStateOnChatController(jid);
 }
 
 void ChatsManager::handleJIDUpdatedInRoster(const JID &jid) {
 	updatePresenceReceivingStateOnChatController(jid);
 }
 
 void ChatsManager::handleRosterCleared() {
 	/*	Setting that all chat controllers aren't receiving presence anymore;
 		including MUC 1-to-1 chats due to the assumtion that this handler
 		is only called on log out. */
 	foreach(JIDChatControllerPair pair, chatControllers_) {
 		pair.second->setContactIsReceivingPresence(false);
 	}
 }
 
 void ChatsManager::updatePresenceReceivingStateOnChatController(const JID &jid) {
 	ChatController* controller = getChatControllerIfExists(jid);
 	if (controller) {
@@ -278,248 +287,268 @@ ChatListWindow::Chat ChatsManager::updateChatStatusAndAvatarHelper(const ChatLis
 		if (avatarManager_) {
 			fixedChat.avatarPath = avatarManager_->getAvatarPath(fixedChat.jid);
 		}
 		Presence::ref presence = presenceOracle_->getHighestPriorityPresence(fixedChat.jid.toBare());
 		fixedChat.statusType = presence ? presence->getShow() : StatusShow::None;
 	}
 	return fixedChat;
 }
 
 void ChatsManager::loadRecents() {
 	std::string recentsString(profileSettings_->getStringSetting(RECENT_CHATS));
 	if (recentsString.find("\t") != std::string::npos) {
 		// old format
 		std::vector<std::string> recents;
 		boost::split(recents, recentsString, boost::is_any_of("\n"));
 		int i = 0;
 		foreach (std::string recentString, recents) {
 			if (i++ > 30) {
 				break;
 			}
 			std::vector<std::string> recent;
 			boost::split(recent, recentString, boost::is_any_of("\t"));
 			if (recent.size() < 4) {
 				continue;
 			}
 			JID jid(recent[0]);
 			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 {
 			boost::archive::text_iarchive ia(deserializeStream);
 			ia >> recentChats;
 		} catch (const boost::archive::archive_exception& e) {
 			SWIFT_LOG(debug) << "Failed to load recents: " << e.what() << std::endl;
 			return;
 		}
 
 		foreach(ChatListWindow::Chat chat, recentChats) {
 			chat.statusType = StatusShow::None;
 			chat = updateChatStatusAndAvatarHelper(chat);
 			prependRecent(chat);
 		}
 	}
 	handleUnreadCountChanged(NULL);
 }
 
 void ChatsManager::setupBookmarks() {
 	if (!mucBookmarkManager_) {
 		mucBookmarkManager_ = new MUCBookmarkManager(iqRouter_);
 		mucBookmarkManager_->onBookmarksReady.connect(boost::bind(&ChatsManager::handleBookmarksReady, this));
 		mucBookmarkManager_->onBookmarkAdded.connect(boost::bind(&ChatsManager::handleMUCBookmarkAdded, this, _1));
 		mucBookmarkManager_->onBookmarkRemoved.connect(boost::bind(&ChatsManager::handleMUCBookmarkRemoved, this, _1));
 
 		if (chatListWindow_) {
 			chatListWindow_->setBookmarksEnabled(false);
 			chatListWindow_->clearBookmarks();
 		}
 	}
 }
 
 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()) {
 		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();
 			/* 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);
 }
 
 boost::optional<ChatListWindow::Chat> ChatsManager::removeExistingChat(const ChatListWindow::Chat& chat) {
 	std::list<ChatListWindow::Chat>::iterator result = std::find(recentChats_.begin(), recentChats_.end(), chat);
 	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);
 }
 
 void ChatsManager::prependRecent(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_back(mergedChat);
 }
 
 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;
 	}
 }
 
 void ChatsManager::finalizeImpromptuJoin(MUC::ref muc, const std::vector<JID>& jidsToInvite, const std::string& reason, const boost::optional<JID>& reuseChatJID) {
 	// send impromptu invites for the new MUC
 	std::vector<JID> missingJIDsToInvite = jidsToInvite;
 
 	typedef std::pair<std::string, MUCOccupant> StringMUCOccupantPair;
 	std::map<std::string, MUCOccupant> occupants = muc->getOccupants();
 	foreach(StringMUCOccupantPair occupant, occupants) {
 		boost::optional<JID> realJID = occupant.second.getRealJID();
 		if (realJID) {
 			missingJIDsToInvite.erase(std::remove(missingJIDsToInvite.begin(), missingJIDsToInvite.end(), realJID->toBare()), missingJIDsToInvite.end());
 		}
 	}
 
 	if (reuseChatJID) {
 		muc->invitePerson(reuseChatJID.get(), reason, true, true);
 	}
 	foreach(const JID& jid, missingJIDsToInvite) {
 		muc->invitePerson(jid, reason, true);
 	}
 }
 
 void ChatsManager::handleUIEvent(boost::shared_ptr<UIEvent> event) {
 	boost::shared_ptr<RequestChatUIEvent> chatEvent = boost::dynamic_pointer_cast<RequestChatUIEvent>(event);
 	if (chatEvent) {
 		handleChatRequest(chatEvent->getContact());
 		return;
@@ -669,70 +698,71 @@ void ChatsManager::setOnline(bool enabled) {
 		setupBookmarks();
 		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();
 	}
 
 }
 
 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);
 }
 
 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);
 	return controller ? controller : createNewChatController(contact);
 }
 
 ChatController* ChatsManager::getChatControllerIfExists(const JID &contact, bool rebindIfNeeded) {
 	if (chatControllers_.find(contact) == chatControllers_.end()) {
 		if (mucRegistry_->isMUC(contact.toBare())) {
 			return NULL;
 		}
 		//Need to look for an unbound window to bind first
 		JID bare(contact.toBare());
 		if (chatControllers_.find(bare) != chatControllers_.end()) {
 			rebindControllerJID(bare, contact);
 		} else {
 			foreach (JIDChatControllerPair pair, chatControllers_) {
 				if (pair.first.toBare() == contact.toBare()) {
 					if (rebindIfNeeded) {
 						rebindControllerJID(pair.first, contact);
 						return chatControllers_[contact];
 					} else {
 						return pair.second;
 					}
 				}
 			}
 			return NULL;
 		}
 	}