1 files changed, 25 insertions, 5 deletions
diff --git a/Swift/Controllers/Roster/RosterController.cpp b/Swift/Controllers/Roster/RosterController.cpp
index d2d024c..6bb5119 100644
--- a/Swift/Controllers/Roster/RosterController.cpp
+++ b/Swift/Controllers/Roster/RosterController.cpp
@@ -26,103 +26,109 @@
 #include <Swiften/Roster/GetRosterRequest.h>
 #include <Swiften/Roster/SetRosterRequest.h>
 #include <Swiften/Roster/XMPPRoster.h>
 #include <Swiften/Roster/XMPPRosterItem.h>
 
 #include <Swift/Controllers/Intl.h>
 #include <Swift/Controllers/Roster/GroupRosterItem.h>
 #include <Swift/Controllers/Roster/OfflineRosterFilter.h>
 #include <Swift/Controllers/Roster/Roster.h>
 #include <Swift/Controllers/Roster/RosterVCardProvider.h>
 #include <Swift/Controllers/Roster/ItemOperations/AppearOffline.h>
 #include <Swift/Controllers/Roster/ItemOperations/SetAvatar.h>
 #include <Swift/Controllers/Roster/ItemOperations/SetAvailableFeatures.h>
 #include <Swift/Controllers/Roster/ItemOperations/SetBlockingState.h>
 #include <Swift/Controllers/Roster/ItemOperations/SetName.h>
 #include <Swift/Controllers/Roster/ItemOperations/SetPresence.h>
 #include <Swift/Controllers/Roster/ItemOperations/SetVCard.h>
 #include <Swift/Controllers/SettingConstants.h>
 #include <Swift/Controllers/UIEvents/AddContactUIEvent.h>
 #include <Swift/Controllers/UIEvents/RemoveRosterItemUIEvent.h>
 #include <Swift/Controllers/UIEvents/RenameGroupUIEvent.h>
 #include <Swift/Controllers/UIEvents/RenameRosterItemUIEvent.h>
 #include <Swift/Controllers/UIEvents/SendFileUIEvent.h>
 #include <Swift/Controllers/UIInterfaces/MainWindow.h>
 #include <Swift/Controllers/UIInterfaces/MainWindowFactory.h>
 #include <Swift/Controllers/XMPPEvents/ErrorEvent.h>
 #include <Swift/Controllers/XMPPEvents/EventController.h>
 #include <Swift/Controllers/XMPPEvents/SubscriptionRequestEvent.h>
 
 namespace Swift {
 
 /**
  * The controller does not gain ownership of these parameters.
  */
 RosterController::RosterController(const JID& jid, XMPPRoster* xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, NickManager* nickManager, NickResolver* nickResolver, PresenceOracle* presenceOracle, SubscriptionManager* subscriptionManager, EventController* eventController, UIEventStream* uiEventStream, IQRouter* iqRouter, SettingsProvider* settings, EntityCapsProvider* entityCapsManager, FileTransferOverview* fileTransferOverview, ClientBlockListManager* clientBlockListManager, VCardManager* vcardManager)
-	: myJID_(jid), xmppRoster_(xmppRoster), mainWindowFactory_(mainWindowFactory), mainWindow_(mainWindowFactory_->createMainWindow(uiEventStream)), roster_(new Roster()), offlineFilter_(new OfflineRosterFilter()), nickManager_(nickManager), nickResolver_(nickResolver), uiEventStream_(uiEventStream), entityCapsManager_(entityCapsManager), ftOverview_(fileTransferOverview), clientBlockListManager_(clientBlockListManager) {
+	: myJID_(jid), xmppRoster_(xmppRoster), mainWindowFactory_(mainWindowFactory), mainWindow_(mainWindowFactory_->createMainWindow(uiEventStream)), roster_(new Roster()), offlineFilter_(new OfflineRosterFilter()), vcardManager_(vcardManager), avatarManager_(avatarManager), nickManager_(nickManager), nickResolver_(nickResolver), presenceOracle_(presenceOracle), uiEventStream_(uiEventStream), entityCapsManager_(entityCapsManager), ftOverview_(fileTransferOverview), clientBlockListManager_(clientBlockListManager) {
 	assert(fileTransferOverview);
 	iqRouter_ = iqRouter;
-	presenceOracle_ = presenceOracle;
 	subscriptionManager_ = subscriptionManager;
 	eventController_ = eventController;
 	settings_ = settings;
 	expandiness_ = new RosterGroupExpandinessPersister(roster_, settings);
 	mainWindow_->setRosterModel(roster_);
 	rosterVCardProvider_ = new RosterVCardProvider(roster_, vcardManager, JID::WithoutResource);
 	
 	changeStatusConnection_ = mainWindow_->onChangeStatusRequest.connect(boost::bind(&RosterController::handleChangeStatusRequest, this, _1, _2));
 	signOutConnection_ = mainWindow_->onSignOutRequest.connect(boost::bind(boost::ref(onSignOutRequest)));
 	xmppRoster_->onJIDAdded.connect(boost::bind(&RosterController::handleOnJIDAdded, this, _1));
 	xmppRoster_->onJIDUpdated.connect(boost::bind(&RosterController::handleOnJIDUpdated, this, _1, _2, _3));
 	xmppRoster_->onJIDRemoved.connect(boost::bind(&RosterController::handleOnJIDRemoved, this, _1));
 	xmppRoster_->onRosterCleared.connect(boost::bind(&RosterController::handleRosterCleared, this));
 	subscriptionManager_->onPresenceSubscriptionRequest.connect(boost::bind(&RosterController::handleSubscriptionRequest, this, _1, _2));
 	presenceOracle_->onPresenceChange.connect(boost::bind(&RosterController::handleIncomingPresence, this, _1));
 	uiEventConnection_ = uiEventStream->onUIEvent.connect(boost::bind(&RosterController::handleUIEvent, this, _1));
-	avatarManager_ = avatarManager;
+
+	vcardManager_->onOwnVCardChanged.connect(boost::bind(&RosterController::handleOwnVCardChanged, this, _1));
 	avatarManager_->onAvatarChanged.connect(boost::bind(&RosterController::handleAvatarChanged, this, _1));
-	mainWindow_->setMyAvatarPath(pathToString(avatarManager_->getAvatarPath(myJID_)));
+	presenceOracle_->onPresenceChange.connect(boost::bind(&RosterController::handlePresenceChanged, this, _1));
+	mainWindow_->setMyAvatarPath(pathToString(avatarManager_->getAvatarPath(myJID_.toBare())));
 
 	nickManager_->onOwnNickChanged.connect(boost::bind(&MainWindow::setMyNick, mainWindow_, _1));
 	mainWindow_->setMyJID(jid);
 	mainWindow_->setMyNick(nickManager_->getOwnNick());
 	
 	entityCapsManager_->onCapsChanged.connect(boost::bind(&RosterController::handleOnCapsChanged, this, _1));
 
 	settings_->onSettingChanged.connect(boost::bind(&RosterController::handleSettingChanged, this, _1));
 
 	handleShowOfflineToggled(settings_->getSetting(SettingConstants::SHOW_OFFLINE));
+
+	ownContact_ = boost::make_shared<ContactRosterItem>(myJID_.toBare(), myJID_.toBare(), nickManager_->getOwnNick(), (GroupRosterItem*)0);
+	ownContact_->setVCard(vcardManager_->getVCard(myJID_.toBare()));
+	ownContact_->setAvatarPath(pathToString(avatarManager_->getAvatarPath(myJID_.toBare())));
+	mainWindow_->setMyContactRosterItem(ownContact_);
 }
 
 
 RosterController::~RosterController() {	
 	settings_->onSettingChanged.disconnect(boost::bind(&RosterController::handleSettingChanged, this, _1));
 	nickManager_->onOwnNickChanged.disconnect(boost::bind(&MainWindow::setMyNick, mainWindow_, _1));
 	
 	delete offlineFilter_;
 	delete expandiness_;
 
 	mainWindow_->setRosterModel(NULL);
 	if (mainWindow_->canDelete()) {
 		delete mainWindow_;
 	}
 	delete rosterVCardProvider_;
 	delete roster_;	
 }
 
 void RosterController::setEnabled(bool enabled) {
 	if (!enabled) {
 		roster_->applyOnItems(AppearOffline());
 	}
 }
 
 void RosterController::handleShowOfflineToggled(bool state) {
 	if (state) {
 		roster_->removeFilter(offlineFilter_);
 	} else {
 		roster_->addFilter(offlineFilter_);
 	}
 }
 
 void RosterController::handleChangeStatusRequest(StatusShow::Type show, const std::string &statusText) {
 	onChangeStatusRequest(show, statusText);
 }
@@ -304,66 +310,80 @@ void RosterController::handleRosterSetError(ErrorPayload::ref error, boost::shar
 	}
 	boost::shared_ptr<ErrorEvent> errorEvent(new ErrorEvent(JID(myJID_.getDomain()), text));
 	eventController_->handleIncomingEvent(errorEvent);
 }
 
 void RosterController::handleIncomingPresence(Presence::ref newPresence) {
 	if (newPresence->getType() == Presence::Error) {
 		return;
 	}
 	roster_->applyOnItems(SetPresence(newPresence));
 }
 
 void RosterController::handleSubscriptionRequest(const JID& jid, const std::string& message) {
 	if (xmppRoster_->containsJID(jid) && (xmppRoster_->getSubscriptionStateForJID(jid) == RosterItemPayload::To || xmppRoster_->getSubscriptionStateForJID(jid) == RosterItemPayload::Both)) {
 		subscriptionManager_->confirmSubscription(jid);
 		return;
 	}
 	SubscriptionRequestEvent* eventPointer = new SubscriptionRequestEvent(jid, message);
 	eventPointer->onAccept.connect(boost::bind(&RosterController::handleSubscriptionRequestAccepted, this, eventPointer));
 	eventPointer->onDecline.connect(boost::bind(&RosterController::handleSubscriptionRequestDeclined, this, eventPointer));
 	boost::shared_ptr<StanzaEvent> event(eventPointer);
 	eventController_->handleIncomingEvent(event);
 }
 
 void RosterController::handleSubscriptionRequestAccepted(SubscriptionRequestEvent* event) {
 	subscriptionManager_->confirmSubscription(event->getJID());
 	if (!xmppRoster_->containsJID(event->getJID()) || xmppRoster_->getSubscriptionStateForJID(event->getJID()) == RosterItemPayload::None || xmppRoster_->getSubscriptionStateForJID(event->getJID()) == RosterItemPayload::From) {
 		subscriptionManager_->requestSubscription(event->getJID());
 	}
 }
 
 void RosterController::handleSubscriptionRequestDeclined(SubscriptionRequestEvent* event) {
 	subscriptionManager_->cancelSubscription(event->getJID());
 }
 
+void RosterController::handleOwnVCardChanged(VCard::ref vcard) {
+	ownContact_->setVCard(vcard);
+	mainWindow_->setMyContactRosterItem(ownContact_);
+}
+
 void RosterController::handleAvatarChanged(const JID& jid) {
 	boost::filesystem::path path = avatarManager_->getAvatarPath(jid);
 	roster_->applyOnItems(SetAvatar(jid, path));
-	if (jid.equals(myJID_, JID::WithoutResource)) {
+	if (jid.equals(myJID_, JID::WithResource)) {
 		mainWindow_->setMyAvatarPath(pathToString(path));
 	}
+	ownContact_->setAvatarPath(pathToString(path));
+	mainWindow_->setMyContactRosterItem(ownContact_);
+}
+
+void RosterController::handlePresenceChanged(Presence::ref presence) {
+	if (presence->getFrom().equals(myJID_, JID::WithResource)) {
+		ownContact_->applyPresence(std::string(), presence);
+		mainWindow_->setMyContactRosterItem(ownContact_);
+	}
 }
 
 boost::optional<XMPPRosterItem> RosterController::getItem(const JID& jid) const {
 	return xmppRoster_->getItem(jid);
 }
 
 std::set<std::string> RosterController::getGroups() const {
 	return xmppRoster_->getGroups();
 }
 
 void RosterController::handleOnCapsChanged(const JID& jid) {
 	DiscoInfo::ref info = entityCapsManager_->getCaps(jid);
 	if (info) {
 		std::set<ContactRosterItem::Feature> features;
 		if (FileTransferManager::isSupportedBy(info)) {
 			features.insert(ContactRosterItem::FileTransferFeature);
 		}
 		if (info->hasFeature(DiscoInfo::WhiteboardFeature)) {
 			features.insert(ContactRosterItem::WhiteboardFeature);
 		}
 		roster_->applyOnItems(SetAvailableFeatures(jid, features));
 	}
 }
 
 }