2 files changed, 2 insertions, 0 deletions
diff --git a/Swift/Controllers/ChatControllerBase.h b/Swift/Controllers/ChatControllerBase.h
index 91b72a8..c780789 100644
--- a/Swift/Controllers/ChatControllerBase.h
+++ b/Swift/Controllers/ChatControllerBase.h
@@ -1,64 +1,65 @@
 #ifndef SWIFTEN_ChatControllerBase_H
 #define SWIFTEN_ChatControllerBase_H
 
 #include <map>
 #include <vector>
 #include <boost/shared_ptr.hpp>
 #include <boost/signals.hpp>
 #include <boost/filesystem.hpp>
 
 #include "Swiften/Base/String.h"
 #include "Swiften/Elements/DiscoInfo.h"
 #include "Swiften/Events/MessageEvent.h"
 #include "Swiften/JID/JID.h"
 #include "Swiften/Elements/SecurityLabelsCatalog.h"
 #include "Swiften/Elements/ErrorPayload.h"
 #include "Swiften/Presence/PresenceOracle.h"
 #include "Swiften/Queries/IQRouter.h"
 
 namespace Swift {
 	class IQRouter;
 	class StanzaChannel;
 	class ChatWindow;
 	class ChatWindowFactory;
 	class AvatarManager;
 
 	class ChatControllerBase  {
 		public:
 			virtual ~ChatControllerBase();
 			void showChatWindow();
 			void activateChatWindow();
 			void setAvailableServerFeatures(boost::shared_ptr<DiscoInfo> info);
 			void handleIncomingMessage(boost::shared_ptr<MessageEvent> message);
 			void setEnabled(bool enabled);
+			void setToJID(const JID& jid) {toJID_ = jid;};
 		protected:
 			ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, PresenceOracle* presenceOracle, AvatarManager* avatarManager);
 
 			virtual void postSendMessage(const String&) {};
 			virtual String senderDisplayNameFromMessage(const JID& from) = 0;
 			virtual bool isIncomingMessageFromMe(boost::shared_ptr<Message>) = 0;
 			virtual void preHandleIncomingMessage(boost::shared_ptr<Message>) {};
 			virtual void preSendMessageRequest(boost::shared_ptr<Message>) {};
 
 
 		private:
 			void handleSendMessageRequest(const String &body);
 			void handleAllMessagesRead();
 			void handleSecurityLabelsCatalogResponse(boost::shared_ptr<SecurityLabelsCatalog>, const boost::optional<ErrorPayload>& error);
 			String getErrorMessage(boost::shared_ptr<ErrorPayload>);
 
 		protected:
 			JID selfJID_;
 			std::vector<boost::shared_ptr<MessageEvent> > unreadMessages_;
 			StanzaChannel* stanzaChannel_;
 			IQRouter* iqRouter_;
 			ChatWindowFactory* chatWindowFactory_;
 			ChatWindow* chatWindow_;
 			JID toJID_;
 			bool labelsEnabled_;
 			PresenceOracle* presenceOracle_;
 			AvatarManager* avatarManager_;
 	};
 }
 
 #endif
diff --git a/Swift/Controllers/ChatsManager.cpp b/Swift/Controllers/ChatsManager.cpp
index 2863a14..e64967c 100644
--- a/Swift/Controllers/ChatsManager.cpp
+++ b/Swift/Controllers/ChatsManager.cpp
@@ -71,87 +71,88 @@ void ChatsManager::setAvatarManager(AvatarManager* avatarManager) {
 // 		}
 // 	}
 // }
 
 
 void ChatsManager::setServerDiscoInfo(boost::shared_ptr<DiscoInfo> info) {
 	foreach (JIDChatControllerPair pair, chatControllers_) {
 		pair.second->setAvailableServerFeatures(info);
 	}
 	foreach (JIDMUCControllerPair pair, mucControllers_) {
 		pair.second->setAvailableServerFeatures(info);
 	}
 }
 
 void ChatsManager::setEnabled(bool enabled) {
 	foreach (JIDChatControllerPair controllerPair, chatControllers_) {
 		//printf("Setting enabled on %d to %d\n", controllerPair.second, enabled);
 		controllerPair.second->setEnabled(enabled);
 	}
 	foreach (JIDMUCControllerPair controllerPair, mucControllers_) {
 		controllerPair.second->setEnabled(enabled);
 	}
 
 }
 
 void ChatsManager::handleChatRequest(const String &contact) {
 	ChatController* controller = getChatController(JID(contact));
 	controller->showChatWindow();
 	controller->activateChatWindow();
 }
 
 ChatController* ChatsManager::getChatController(const JID &contact) {
 	if (chatControllers_.find(contact) == chatControllers_.end()) {
 		//Need to look for an unboud window to bind first
 		JID bare(contact.toBare());
 		if (chatControllers_.find(bare) != chatControllers_.end()) {
 			rebindControllerJID(bare, contact);
 		} else {
 			chatControllers_[contact] = new ChatController(jid_, stanzaChannel_, iqRouter_, chatWindowFactory_, contact, nickResolver_, presenceOracle_, avatarManager_);
 			chatControllers_[contact]->setAvailableServerFeatures(serverDiscoInfo_);
 		}
 	}
 	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 &muc, const String &nick) {
 	mucControllers_[muc] = new MUCController(jid_, muc, nick, stanzaChannel_, presenceSender_, iqRouter_, chatWindowFactory_, treeWidgetFactory_, presenceOracle_, avatarManager_);
 	mucControllers_[muc]->setAvailableServerFeatures(serverDiscoInfo_);
 }
 
 void ChatsManager::handleIncomingMessage(boost::shared_ptr<Message> message) {
 	JID jid = message->getFrom();
 	boost::shared_ptr<MessageEvent> event(new MessageEvent(message));
 	if (!event->isReadable()) {
 		return;
 	}
 
 	// Try to deliver it to a MUC
 	if (message->getType() == Message::Groupchat || message->getType() == Message::Error) {
 		std::map<JID, MUCController*>::iterator i = mucControllers_.find(jid.toBare());
 		if (i != mucControllers_.end()) {
 			i->second->handleIncomingMessage(event);
 			return;
 		}
 		else if (message->getType() == Message::Groupchat) {
 			//FIXME: Error handling - groupchat messages from an unknown muc.
 			return;
 		}
 	}
 	
 	//if not a mucroom
 	eventController_->handleIncomingEvent(event);
 	getChatController(jid)->handleIncomingMessage(event);
 }
 
 bool ChatsManager::isMUC(const JID& jid) const {
 	return mucControllers_.find(jid.toBare()) != mucControllers_.end();
 }
 
 
 
 }