+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <Swiften/Roster/XMPPRoster.h>

+#include <Swiften/Elements/MUCInvitationPayload.h>

+#include <Swift/Controllers/Settings/SettingsProvider.h>

+#include <Swift/Controllers/SettingConstants.h>

+

+namespace Swift {

+ class AutoAcceptMUCInviteDecider {

+ public:

+ AutoAcceptMUCInviteDecider(const JID& domain, XMPPRoster* roster, SettingsProvider* settings) : domain_(domain), roster_(roster), settings_(settings) {

+ }

+

+ bool isAutoAcceptedInvite(const JID& from, MUCInvitationPayload::ref invite) {

+ if (!invite->getIsImpromptu() && !invite->getIsContinuation()) {

+ return false;

+ }

+

+ std::string auto_accept_mode = settings_->getSetting(SettingConstants::INVITE_AUTO_ACCEPT_MODE);

+ if (auto_accept_mode == "no") {

+ return false;

+ } else if (auto_accept_mode == "presence") {

+ return roster_->getSubscriptionStateForJID(from) == RosterItemPayload::From || roster_->getSubscriptionStateForJID(from) == RosterItemPayload::Both;

+ } else if (auto_accept_mode == "domain") {

+ return roster_->getSubscriptionStateForJID(from) == RosterItemPayload::From || roster_->getSubscriptionStateForJID(from) == RosterItemPayload::Both || from.getDomain() == domain_;

+ } else {

+ assert(false);

+ }

+ }

+

+ private:

+ JID domain_;

+ XMPPRoster* roster_;

+ SettingsProvider* settings_;

+ };

+}

+#include <Swift/Controllers/UIEvents/InviteToMUCUIEvent.h>

+#include <Swift/Controllers/UIEvents/RequestInviteToMUCUIEvent.h>

+ChatController::ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, SettingsProvider* settings, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, ChatMessageParser* chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider)

+ : ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, presenceOracle, avatarManager, useDelayForLatency, eventStream, eventController, timerFactory, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider), eventStream_(eventStream), userWantsReceipts_(userWantsReceipts), settings_(settings), clientBlockListManager_(clientBlockListManager) {

+ chatWindow_->onInviteToChat.connect(boost::bind(&ChatController::handleInviteToChat, this, _1));

+ eventStream_->onUIEvent.connect(boost::bind(&ChatController::handleUIEvent, this, _1));

+ eventStream_->onUIEvent.disconnect(boost::bind(&ChatController::handleUIEvent, this, _1));

+void ChatController::handleInviteToChat(const std::vector<JID>& droppedJIDs) {

+ boost::shared_ptr<UIEvent> event(new RequestInviteToMUCUIEvent(toJID_.toBare(), droppedJIDs));

+ eventStream_->send(event);

+}

+

+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());

+ }

+}

+

+

+ChatWindow* ChatController::detachChatWindow() {

+ chatWindow_->onUserTyping.disconnect(boost::bind(&ChatStateNotifier::setUserIsTyping, chatStateNotifier_));

+ chatWindow_->onUserCancelsTyping.disconnect(boost::bind(&ChatStateNotifier::userCancelledNewMessage, chatStateNotifier_));

+ return ChatControllerBase::detachChatWindow();

+}

+

+ class UIEvent;

+ ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, SettingsProvider* settings, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, ChatMessageParser* chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider);

+ virtual ChatWindow* detachChatWindow();

+ void handleInviteToChat(const std::vector<JID>& droppedJIDs);

+ void handleInviteToMUCWindowDismissed();

+ void handleInviteToMUCWindowCompleted();

+

+ void handleUIEvent(boost::shared_ptr<UIEvent> event);

+

+#include <Swift/Controllers/UIEvents/JoinMUCUIEvent.h>

+#include <Swift/Controllers/UIEvents/UIEventStream.h>

+#include <Swift/Controllers/Chat/AutoAcceptMUCInviteDecider.h>

+ChatControllerBase::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, ChatMessageParser* chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), timerFactory_(timerFactory), entityCapsProvider_(entityCapsProvider), historyController_(historyController), mucRegistry_(mucRegistry), chatMessageParser_(chatMessageParser), autoAcceptMUCInviteDecider_(autoAcceptMUCInviteDecider), eventStream_(eventStream) {

+ChatWindow* ChatControllerBase::detachChatWindow() {

+ ChatWindow* chatWindow = chatWindow_;

+ chatWindow_ = NULL;

+ return chatWindow;

+}

+

+void ChatControllerBase::setCanStartImpromptuChats(bool supportsImpromptu) {

+ if (chatWindow_) {

+ chatWindow_->setCanInitiateImpromptuChats(supportsImpromptu);

+ }

+}

+

+ chatWindow_->addMUCInvitation(senderDisplayNameFromMessage(event->getInviter()), event->getRoomJID(), event->getReason(), event->getPassword(), event->getDirect(), event->getImpromptu());

+ if (autoAcceptMUCInviteDecider_->isAutoAcceptedInvite(message->getFrom(), invite)) {

+ eventStream_->send(boost::make_shared<JoinMUCUIEvent>(invite->getJID(), boost::optional<std::string>(), boost::optional<std::string>(), false, false, true));

+ } else {

+ MUCInviteEvent::ref inviteEvent = boost::make_shared<MUCInviteEvent>(toJID_, invite->getJID(), invite->getReason(), invite->getPassword(), true, invite->getIsImpromptu());

+}

+ MUCInviteEvent::ref inviteEvent = boost::make_shared<MUCInviteEvent>(invite.from, from, reason, password, false, false);

+ class AutoAcceptMUCInviteDecider;

+ 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;

+ 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, ChatMessageParser* chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider);

+ AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider_;

+ UIEventStream* eventStream_;

+#include <boost/archive/text_oarchive.hpp>

+#include <boost/archive/text_iarchive.hpp>

+#include <boost/serialization/vector.hpp>

+#include <boost/serialization/map.hpp>

+#include <boost/serialization/string.hpp>

+#include <boost/serialization/split_free.hpp>

+#include <Swift/Controllers/Chat/AutoAcceptMUCInviteDecider.h>

+#include <Swift/Controllers/UIEvents/CreateImpromptuMUCUIEvent.h>

+#include <Swift/Controllers/UIEvents/InviteToMUCUIEvent.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>

+

+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*/) {

+ ar & chat.jid;

+ ar & chat.chatName;

+ ar & chat.activity;

+ ar & chat.isMUC;

+ ar & chat.nick;

+ ar & chat.impromptuJIDs;

+ }

+}

+}

+ const std::map<std::string, std::string>& emoticons,

+ UserSearchController* inviteUserSearchController) :

+ clientBlockListManager_(clientBlockListManager),

+ inviteUserSearchController_(inviteUserSearchController) {

+

+ autoAcceptMUCInviteDecider_ = new AutoAcceptMUCInviteDecider(jid.getDomain(), roster_, settings_);

+ delete autoAcceptMUCInviteDecider_;

+ 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 = "";

+

+ oa << recentsLimited;

+ std::string serializedStr = Base64::encode(createByteArray(serializeStream.str()));

+ profileSettings_->storeString(RECENT_CHATS, serializedStr);

+ChatListWindow::Chat ChatsManager::updateChatStatusAndAvatarHelper(const ChatListWindow::Chat& chat) const {

+ ChatListWindow::Chat fixedChat = chat;

+ if (fixedChat.isMUC) {

+ if (mucControllers_.find(fixedChat.jid.toBare()) != mucControllers_.end()) {

+ fixedChat.statusType = StatusShow::Online;

+ }

+ } else {

+ 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;

+}

+

+ if (recentsString.find("\t") != std::string::npos) {

+ // old format

+

+ ChatListWindow::Chat chat(jid, nickResolver_->jidToNick(jid), activity, 0, type, path, isMUC, 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((const char*)debase64.data(), 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);

+ }

+ handleJoinMUCRequest(bookmark.getRoom(), bookmark.getPassword(), bookmark.getNick(), false, false, false );

+

+ if (controller->isImpromptu()) {

+ ChatListWindow::Chat chat = ChatListWindow::Chat(jid, jid.toString(), activity, unreadCount, type, boost::filesystem::path(), true, nick);

+ typedef std::pair<std::string, JID> StringJIDPair;

+ std::map<std::string, JID> participants = controller->getParticipantJIDs();

+ chat.impromptuJIDs = participants;

+ return chat;

+ }

+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;

+ return boost::optional<ChatListWindow::Chat>(existingChat);

+ } else {

+ return boost::optional<ChatListWindow::Chat>();

+ }

+}

+

+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);

+ 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::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);

+ }

+}

+

+ boost::shared_ptr<CreateImpromptuMUCUIEvent> createImpromptuMUCEvent = boost::dynamic_pointer_cast<CreateImpromptuMUCUIEvent>(event);

+ if (createImpromptuMUCEvent) {

+ assert(!localMUCServiceJID_.toString().empty());

+ // create new muc

+ JID roomJID = createImpromptuMUCEvent->getRoomJID().toString().empty() ? JID(idGenerator_.generateID(), localMUCServiceJID_) : createImpromptuMUCEvent->getRoomJID();

+

+ // join muc

+ MUC::ref muc = handleJoinMUCRequest(roomJID, boost::optional<std::string>(), nickResolver_->jidToNick(jid_), false, true, true);

+ mucControllers_[roomJID]->onImpromptuConfigCompleted.connect(boost::bind(&ChatsManager::finalizeImpromptuJoin, this, muc, createImpromptuMUCEvent->getJIDs(), createImpromptuMUCEvent->getReason(), boost::optional<JID>()));

+ mucControllers_[roomJID]->activateChatWindow();

+ }

+ handleJoinMUCRequest(joinEvent->getJID(), joinEvent->getPassword(), joinEvent->getNick(), joinEvent->getShouldJoinAutomatically(), joinEvent->getCreateAsReservedRoomIfNew(), joinEvent->isImpromptu());

+void ChatsManager::handleTransformChatToMUC(ChatController* chatController, ChatWindow* chatWindow, const std::vector<JID>& jidsToInvite, const std::string& reason) {

+ JID reuseChatInvite = chatController->getToJID();

+ chatControllers_.erase(chatController->getToJID());

+ delete chatController;

+

+ // join new impromptu muc

+ assert(!localMUCServiceJID_.toString().empty());

+

+ // create new muc

+ JID roomJID = JID(idGenerator_.generateID(), localMUCServiceJID_);

+

+ // join muc

+ MUC::ref muc = handleJoinMUCRequest(roomJID, boost::optional<std::string>(), nickResolver_->jidToNick(jid_), false, true, true, chatWindow);

+ mucControllers_[roomJID]->onImpromptuConfigCompleted.connect(boost::bind(&ChatsManager::finalizeImpromptuJoin, this, muc, jidsToInvite, reason, boost::optional<JID>(reuseChatInvite)));

+}

+

+ 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();

+ 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_);

+ controller->onConvertToMUC.connect(boost::bind(&ChatsManager::handleTransformChatToMUC, this, controller, _1, _2, _3));

+ controller->setCanStartImpromptuChats(!localMUCServiceJID_.toString().empty());

+MUC::ref ChatsManager::handleJoinMUCRequest(const JID &mucJID, const boost::optional<std::string>& password, const boost::optional<std::string>& nickMaybe, bool addAutoJoin, bool createAsReservedIfNew, bool isImpromptu, ChatWindow* reuseChatwindow) {

+ MUC::ref muc;

+ return muc;

+ muc = mucManager->createMUC(mucJID);

+ if (isImpromptu) {

+ muc->setCreateAsReservedIfNew();

+ }

+

+ MUCController* controller = NULL;

+ SingleChatWindowFactoryAdapter* chatWindowFactoryAdapter = NULL;

+ if (reuseChatwindow) {

+ chatWindowFactoryAdapter = new SingleChatWindowFactoryAdapter(reuseChatwindow);

+ }

+ controller = new MUCController(jid_, muc, password, nick, stanzaChannel_, iqRouter_, reuseChatwindow ? chatWindowFactoryAdapter : chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_, roster_, historyController_, mucRegistry_, highlightManager_, chatMessageParser_, isImpromptu, autoAcceptMUCInviteDecider_);

+ if (chatWindowFactoryAdapter) {

+ /* The adapters are only passed to chat windows, which are deleted in their

+ * controllers' dtor, which are deleted in ChatManager's dtor. The adapters

+ * are also deleted there.*/

+ chatWindowFactoryAdapters_[controller] = chatWindowFactoryAdapter;

+ }

+

+ return muc;

+ // check for impromptu invite to potentially auto-accept

+ MUCInvitationPayload::ref invite = message->getPayload<MUCInvitationPayload>();

+ if (invite && autoAcceptMUCInviteDecider_->isAutoAcceptedInvite(message->getFrom(), invite)) {

+ if (invite->getIsContinuation()) {

+ // check for existing chat controller for the from JID

+ ChatController* controller = getChatControllerIfExists(jid);

+ if (controller) {

+ ChatWindow* window = controller->detachChatWindow();

+ chatControllers_.erase(jid);

+ delete controller;

+ handleJoinMUCRequest(invite->getJID(), boost::optional<std::string>(), boost::optional<std::string>(), false, false, true, window);

+ }

+ } else {

+ handleJoinMUCRequest(invite->getJID(), boost::optional<std::string>(), boost::optional<std::string>(), false, false, true);

+ return;

+ }

+ }

+

+ if (chat.isMUC && !chat.impromptuJIDs.empty()) {

+ typedef std::pair<std::string, JID> StringJIDPair;

+ std::vector<JID> inviteJIDs;

+ foreach(StringJIDPair pair, chat.impromptuJIDs) {

+ inviteJIDs.push_back(pair.second);

+ }

+ uiEventStream_->send(boost::make_shared<CreateImpromptuMUCUIEvent>(inviteJIDs, chat.jid, ""));

+ }

+ else if (chat.isMUC) {

+void ChatsManager::handleLocalServiceFound(const JID& service, boost::shared_ptr<DiscoInfo> info) {

+ foreach (DiscoInfo::Identity identity, info->getIdentities()) {

+ if ((identity.getCategory() == "directory"

+ && identity.getType() == "chatroom")

+ || (identity.getCategory() == "conference"

+ && identity.getType() == "text")) {

+ localMUCServiceJID_ = service;

+ localMUCServiceFinderWalker_->endWalk();

+ SWIFT_LOG(debug) << "Use following MUC service for impromptu chats: " << localMUCServiceJID_ << std::endl;

+ break;

+ }

+ }

+}

+

+void ChatsManager::handleLocalServiceWalkFinished() {

+ onImpromptuMUCServiceDiscovered(!localMUCServiceJID_.toString().empty());

+}

+

+std::vector<ChatListWindow::Chat> ChatsManager::getRecentChats() const {

+ return std::vector<ChatListWindow::Chat>(recentChats_.begin(), recentChats_.end());

+}

+

+std::vector<Contact> Swift::ChatsManager::getContacts() {

+ std::vector<Contact> result;

+ foreach (ChatListWindow::Chat chat, recentChats_) {

+ if (!chat.isMUC) {

+ result.push_back(Contact(chat.chatName.empty() ? chat.jid.toString() : chat.chatName, chat.jid, chat.statusType, chat.avatarPath));

+ }

+ }

+ return result;

+}

+

+ChatsManager::SingleChatWindowFactoryAdapter::SingleChatWindowFactoryAdapter(ChatWindow* chatWindow) : chatWindow_(chatWindow) {}

+ChatsManager::SingleChatWindowFactoryAdapter::~SingleChatWindowFactoryAdapter() {}

+ChatWindow* ChatsManager::SingleChatWindowFactoryAdapter::createChatWindow(const JID &, UIEventStream*) {

+ return chatWindow_;

+}

+

+#include <Swiften/Base/IDGenerator.h>

+#include <Swiften/MUC/MUC.h>

+

+#include <Swift/Controllers/ContactProvider.h>

+#include <Swift/Controllers/UIInterfaces/ChatWindowFactory.h>

+ class DiscoServiceWalker;

+ class AutoAcceptMUCInviteDecider;

+ class UserSearchController;

+ class ChatsManager : public ContactProvider {

+ ChatsManager(JID jid, StanzaChannel* stanzaChannel, IQRouter* iqRouter, EventController* eventController, ChatWindowFactory* chatWindowFactory, JoinMUCWindowFactory* joinMUCWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, PresenceSender* presenceSender, UIEventStream* uiEventStream, ChatListWindowFactory* chatListWindowFactory, bool useDelayForLatency, TimerFactory* timerFactory, MUCRegistry* mucRegistry, EntityCapsProvider* entityCapsProvider, MUCManager* mucManager, MUCSearchWindowFactory* mucSearchWindowFactory, ProfileSettingsProvider* profileSettings, FileTransferOverview* ftOverview, XMPPRoster* roster, bool eagleMode, SettingsProvider* settings, HistoryController* historyController_, WhiteboardManager* whiteboardManager, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, const std::map<std::string, std::string>& emoticons, UserSearchController* inviteUserSearchController);

+ std::vector<ChatListWindow::Chat> getRecentChats() const;

+ virtual std::vector<Contact> getContacts();

+

+ boost::signal<void (bool supportsImpromptu)> onImpromptuMUCServiceDiscovered;

+

+ private:

+ class SingleChatWindowFactoryAdapter : public ChatWindowFactory {

+ public:

+ SingleChatWindowFactoryAdapter(ChatWindow* chatWindow);

+ virtual ~SingleChatWindowFactoryAdapter();

+ virtual ChatWindow* createChatWindow(const JID &, UIEventStream*);

+

+ private:

+ ChatWindow* chatWindow_;

+ };

+ 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);

+ boost::optional<ChatListWindow::Chat> removeExistingChat(const ChatListWindow::Chat& chat);

+ void handleTransformChatToMUC(ChatController* chatController, ChatWindow* chatWindow, const std::vector<JID>& jidsToInvite, const std::string& reason);

+

+ void handleLocalServiceFound(const JID& service, boost::shared_ptr<DiscoInfo> info);

+ void handleLocalServiceWalkFinished();

+ ChatListWindow::Chat updateChatStatusAndAvatarHelper(const ChatListWindow::Chat& chat) const;

+

+ std::map<ChatControllerBase*, SingleChatWindowFactoryAdapter*> chatWindowFactoryAdapters_;

+ JID localMUCServiceJID_;

+ boost::shared_ptr<DiscoServiceWalker> localMUCServiceFinderWalker_;

+ AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider_;

+ UserSearchController* inviteUserSearchController_;

+ IDGenerator idGenerator_;

+#include <Swift/Controllers/UIEvents/RequestInviteToMUCUIEvent.h>

+#include <Swift/Controllers/UIEvents/InviteToMUCUIEvent.h>

+#include <Swiften/Base/Log.h>

+ ChatMessageParser* chatMessageParser,

+ bool isImpromptu,

+ AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider) :

+ ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, timerFactory, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider), muc_(muc), nick_(nick), desiredNick_(nick), password_(password), renameCounter_(0), isImpromptu_(isImpromptu), isImpromptuAlreadyConfigured_(false) {

+ chatWindow_->onInviteToChat.connect(boost::bind(&MUCController::handleInvitePersonToThisMUCRequest, this, _1));

+ muc_->onConfigurationFailed.connect(boost::bind(&MUCController::handleConfigurationFailed, this, _1));

+ muc_->onConfigurationFormReceived.connect(boost::bind(&MUCController::handleConfigurationFormReceived, this, _1));

+ if (isImpromptu) {

+ muc_->onUnlocked.connect(boost::bind(&MUCController::handleRoomUnlocked, this));

+ chatWindow_->convertToMUC(true);

+ } else {

+ chatWindow_->setName(muc->getJID().getNode());

+ }

+ eventStream_->onUIEvent.connect(boost::bind(&MUCController::handleUIEvent, this, _1));

+ eventStream_->onUIEvent.disconnect(boost::bind(&MUCController::handleUIEvent, this, _1));

+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) {

+ if (occupant.first != nick_) {

+ participants[occupant.first] = occupant.second.getRealJID().is_initialized() ? occupant.second.getRealJID().get().toBare() : JID();

+ }

+ }

+ return participants;

+}

+

+void MUCController::sendInvites(const std::vector<JID>& jids, const std::string& reason) const {

+ foreach (const JID& jid, jids) {

+ muc_->invitePerson(jid, reason, isImpromptu_);

+ }

+}

+

+ std::string joinMessage;

+ if (isImpromptu_) {

+ joinMessage = str(format(QT_TRANSLATE_NOOP("", "You have entered chat as %1%.")) % nick);

+ } else {

+ joinMessage = str(format(QT_TRANSLATE_NOOP("", "You have entered room %1% as %2%.")) % toJID_.toString() % nick);

+ }

+

+ if (isImpromptu_) {

+ setImpromptuWindowTitle();

+ }

+ joinString = str(format(QT_TRANSLATE_NOOP("", "%1% has entered the %3% as a %2%.")) % occupant.getNick() % roleToFriendlyName(role) % (isImpromptu_ ? QT_TRANSLATE_NOOP("", "chat") : QT_TRANSLATE_NOOP("", "room")));

+ joinString = str(format(QT_TRANSLATE_NOOP("", "%1% has entered the %2%.")) % occupant.getNick() % (isImpromptu_ ? QT_TRANSLATE_NOOP("", "chat") : QT_TRANSLATE_NOOP("", "room")));

+

+ if (isImpromptu_) {

+ setImpromptuWindowTitle();

+ onActivity("");

+ }

+ if (isImpromptu_) {

+ chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(QT_TRANSLATE_NOOP("", "Trying to enter chat")), ChatWindow::DefaultDirection);

+ } else {

+ }

+

+ if (isImpromptu_) {

+ setImpromptuWindowTitle();

+ }

+ chatWindow_->replaceLastMessage(chatMessageParser_->parseMessageBody(generateJoinPartString(joinParts_, isImpromptu())));

+std::string MUCController::generateJoinPartString(const std::vector<NickJoinPart>& joinParts, bool isImpromptu) {

+ eventString = (isImpromptu ? QT_TRANSLATE_NOOP("", "%1% have joined the chat") : QT_TRANSLATE_NOOP("", "%1% have entered the room"));

+ eventString = (isImpromptu ? QT_TRANSLATE_NOOP("", "%1% has joined the chat") : QT_TRANSLATE_NOOP("", "%1% has entered the room"));

+ eventString = (isImpromptu ? QT_TRANSLATE_NOOP("", "%1% have left the chat") : QT_TRANSLATE_NOOP("", "%1% have left the room"));

+ eventString = (isImpromptu ? QT_TRANSLATE_NOOP("", "%1% have left the chat") : QT_TRANSLATE_NOOP("", "%1% has left the room"));

+ eventString = (isImpromptu ? QT_TRANSLATE_NOOP("", "%1% have joined then left the chat") : QT_TRANSLATE_NOOP("", "%1% have entered then left the room"));

+ eventString = (isImpromptu ? QT_TRANSLATE_NOOP("", "%1% has joined then left the chat") : QT_TRANSLATE_NOOP("", "%1% has entered then left the room"));

+ eventString = (isImpromptu ? QT_TRANSLATE_NOOP("", "%1% have left then returned to the chat") : QT_TRANSLATE_NOOP("", "%1% have left then returned to the room"));

+ eventString = (isImpromptu ? QT_TRANSLATE_NOOP("", "%1% has left then returned to the chat") : QT_TRANSLATE_NOOP("", "%1% has left then returned to the room"));

+void MUCController::configureAsImpromptuRoom(Form::ref form) {

+ muc_->configureRoom(buildImpromptuRoomConfiguration(form));

+ isImpromptuAlreadyConfigured_ = true;

+ onImpromptuConfigCompleted();

+}

+

+ if (isImpromptu_) {

+ if (!isImpromptuAlreadyConfigured_) {

+ configureAsImpromptuRoom(form);

+ }

+ } else {

+}

+void MUCController::handleInvitePersonToThisMUCRequest(const std::vector<JID>& jidsToInvite) {

+ boost::shared_ptr<UIEvent> event(new RequestInviteToMUCUIEvent(muc_->getJID(), jidsToInvite));

+ eventStream_->send(event);

+void MUCController::handleUIEvent(boost::shared_ptr<UIEvent> event) {

+ boost::shared_ptr<InviteToMUCUIEvent> inviteEvent = boost::dynamic_pointer_cast<InviteToMUCUIEvent>(event);

+ if (inviteEvent && inviteEvent->getRoom() == muc_->getJID()) {

+ foreach (const JID& jid, inviteEvent->getInvites()) {

+ muc_->invitePerson(jid, inviteEvent->getReason(), isImpromptu_);

+void MUCController::setNick(const std::string& nick) {

+Form::ref MUCController::buildImpromptuRoomConfiguration(Form::ref roomConfigurationForm) {

+ Form::ref result = boost::make_shared<Form>(Form::SubmitType);

+ std::string impromptuConfigs[] = { "muc#roomconfig_enablelogging", "muc#roomconfig_persistentroom", "muc#roomconfig_publicroom", "muc#roomconfig_whois"};

+ std::set<std::string> impromptuConfigsMissing(impromptuConfigs, impromptuConfigs + 4);

+ foreach (boost::shared_ptr<FormField> field, roomConfigurationForm->getFields()) {

+ boost::shared_ptr<FormField> resultField;

+ if (field->getName() == "muc#roomconfig_enablelogging") {

+ resultField = boost::make_shared<FormField>(FormField::BooleanType, "0");

+ }

+ if (field->getName() == "muc#roomconfig_persistentroom") {

+ resultField = boost::make_shared<FormField>(FormField::BooleanType, "0");

+ }

+ if (field->getName() == "muc#roomconfig_publicroom") {

+ resultField = boost::make_shared<FormField>(FormField::BooleanType, "0");

+ }

+ if (field->getName() == "muc#roomconfig_whois") {

+ resultField = boost::make_shared<FormField>(FormField::ListSingleType, "anyone");

+ }

+

+ if (field->getName() == "FORM_TYPE") {

+ resultField = boost::make_shared<FormField>(FormField::HiddenType, "http://jabber.org/protocol/muc#roomconfig");

+ }

+

+ if (resultField) {

+ impromptuConfigsMissing.erase(field->getName());

+ resultField->setName(field->getName());

+ result->addField(resultField);

+ }

+ }

+

+ foreach (const std::string& config, impromptuConfigsMissing) {

+ if (config == "muc#roomconfig_publicroom") {

+ chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(QT_TRANSLATE_NOOP("", "This server doesn't support hiding your chat from other users.")), ChatWindow::DefaultDirection);

+ } else if (config == "muc#roomconfig_whois") {

+ chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(QT_TRANSLATE_NOOP("", "This server doesn't support sharing people's real identity in this chat.")), ChatWindow::DefaultDirection);

+ }

+ }

+

+ return result;

+}

+

+void MUCController::setImpromptuWindowTitle() {

+ std::string title;

+ typedef std::pair<std::string, MUCOccupant> StringMUCOccupantPair;

+ std::map<std::string, MUCOccupant> occupants = muc_->getOccupants();

+ if (occupants.size() <= 1) {

+ title = QT_TRANSLATE_NOOP("", "Empty Chat");

+ } else {

+ foreach (StringMUCOccupantPair pair, occupants) {

+ if (pair.first != nick_) {

+ title += (title.empty() ? "" : ", ") + pair.first;

+ }

+ }

+ }

+ chatWindow_->setName(title);

+}

+

+void MUCController::handleRoomUnlocked() {

+ // Handle buggy MUC implementations where the joined room already exists and is unlocked.

+ // Configure the room again in this case.

+ if (!isImpromptuAlreadyConfigured_) {

+ if (isImpromptu_ && (muc_->getOccupant(nick_).getAffiliation() == MUCOccupant::Owner)) {

+ muc_->requestConfigurationForm();

+ } else if (isImpromptu_) {

+ onImpromptuConfigCompleted();

+ }

+ }

+}

+

+ class UIEvent;

+ MUCController(const JID& self, MUC::ref muc, const boost::optional<std::string>& password, const std::string &nick, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, XMPPRoster* roster, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ChatMessageParser* chatMessageParser, bool isImpromptu, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider);

+ boost::signal<void ()> onImpromptuConfigCompleted;

+ static std::string generateJoinPartString(const std::vector<NickJoinPart>& joinParts, bool isImpromptu);

+ bool isImpromptu() const;

+ std::map<std::string, JID> getParticipantJIDs() const;

+ void sendInvites(const std::vector<JID>& jids, const std::string& reason) const;

+ void handleInvitePersonToThisMUCRequest(const std::vector<JID>& jidsToInvite);

+ void handleUIEvent(boost::shared_ptr<UIEvent> event);

+ void setImpromptuWindowTitle();

+ void handleRoomUnlocked();

+ void configureAsImpromptuRoom(Form::ref form);

+ Form::ref buildImpromptuRoomConfiguration(Form::ref roomConfigurationForm);

+ bool isImpromptu_;

+ bool isImpromptuAlreadyConfigured_;

+ manager_ = new ChatsManager(jid_, stanzaChannel_, iqRouter_, eventController_, chatWindowFactory_, joinMUCWindowFactory_, nickResolver_, presenceOracle_, directedPresenceSender_, uiEventStream_, chatListWindowFactory_, true, NULL, mucRegistry_, entityCapsManager_, mucManager_, mucSearchWindowFactory_, profileSettings_, ftOverview_, xmppRoster_, false, settings_, NULL, wbManager_, highlightManager_, clientBlockListManager_, emoticons_, NULL);

+#include <Swiften/VCards/VCardMemoryStorage.h>

+#include <Swiften/Crypto/PlatformCryptoProvider.h>

+#include <Swiften/VCards/VCardManager.h>

+#include <Swift/Controllers/Chat/UserSearchController.h>

+#include <Swift/Controllers/UIInterfaces/UserSearchWindowFactory.h>

+#include <Swiften/Crypto/CryptoProvider.h>

+ crypto_ = boost::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

+ userSearchWindowFactory_ = mocks_->InterfaceMock<UserSearchWindowFactory>();

+ vcardStorage_ = new VCardMemoryStorage(crypto_.get());

+ vcardManager_ = new VCardManager(self_, iqRouter_, vcardStorage_);

+ controller_ = new MUCController (self_, muc_, boost::optional<std::string>(), nick_, stanzaChannel_, iqRouter_, chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory, eventController_, entityCapsProvider_, NULL, NULL, mucRegistry_, highlightManager_, chatMessageParser_, false, NULL);

+ delete vcardManager_;

+ delete vcardStorage_;

+ CPPUNIT_ASSERT_EQUAL(std::string("Kev has entered the room"), MUCController::generateJoinPartString(list, false));

+ CPPUNIT_ASSERT_EQUAL(std::string("Kev has entered the room and Remko has left the room"), MUCController::generateJoinPartString(list, false));

+ CPPUNIT_ASSERT_EQUAL(std::string("Kev and Bert have entered the room and Remko has left the room"), MUCController::generateJoinPartString(list, false));

+ CPPUNIT_ASSERT_EQUAL(std::string("Kev, Bert and Ernie have entered the room and Remko has left the room"), MUCController::generateJoinPartString(list, false));

+ CPPUNIT_ASSERT_EQUAL(std::string("Kev has entered then left the room"), MUCController::generateJoinPartString(list, false));

+ CPPUNIT_ASSERT_EQUAL(std::string("Remko has left the room and Kev has entered then left the room"), MUCController::generateJoinPartString(list, false));

+ CPPUNIT_ASSERT_EQUAL(std::string("Remko has left the room, Kev has entered then left the room and Bert has left then returned to the room"), MUCController::generateJoinPartString(list, false));

+ CPPUNIT_ASSERT_EQUAL(std::string("Remko has left the room, Kev and Ernie have entered then left the room and Bert has left then returned to the room"), MUCController::generateJoinPartString(list, false));

+ UserSearchWindowFactory* userSearchWindowFactory_;

+ boost::shared_ptr<CryptoProvider> crypto_;

+ VCardManager* vcardManager_;

+ VCardMemoryStorage* vcardStorage_;

+#include <Swiften/Presence/PresenceOracle.h>

+#include <Swiften/Avatars/AvatarManager.h>

+#include <Swift/Controllers/UIEvents/RequestInviteToMUCUIEvent.h>

+#include <Swift/Controllers/ContactSuggester.h>

+UserSearchController::UserSearchController(Type type, const JID& jid, UIEventStream* uiEventStream, VCardManager* vcardManager, UserSearchWindowFactory* factory, IQRouter* iqRouter, RosterController* rosterController, ContactSuggester* contactSuggester, AvatarManager* avatarManager, PresenceOracle* presenceOracle) : type_(type), jid_(jid), uiEventStream_(uiEventStream), vcardManager_(vcardManager), factory_(factory), iqRouter_(iqRouter), rosterController_(rosterController), contactSuggester_(contactSuggester), avatarManager_(avatarManager), presenceOracle_(presenceOracle) {

+ avatarManager_->onAvatarChanged.connect(boost::bind(&UserSearchController::handleAvatarChanged, this, _1));

+ presenceOracle_->onPresenceChange.connect(boost::bind(&UserSearchController::handlePresenceChanged, this, _1));

+ window_->onJIDUpdateRequested.disconnect(boost::bind(&UserSearchController::handleJIDUpdateRequested, this, _1));

+ presenceOracle_->onPresenceChange.disconnect(boost::bind(&UserSearchController::handlePresenceChanged, this, _1));

+ avatarManager_->onAvatarChanged.disconnect(boost::bind(&UserSearchController::handleAvatarChanged, this, _1));

+UserSearchWindow* UserSearchController::getUserSearchWindow() {

+ initializeUserWindow();

+ assert(window_);

+ return window_;

+}

+

+void UserSearchController::setCanInitiateImpromptuMUC(bool supportsImpromptu) {

+ if (!window_) {

+ initializeUserWindow();

+ }

+ window_->setCanStartImpromptuChats(supportsImpromptu);

+}

+

+ boost::shared_ptr<RequestAddUserDialogUIEvent> addUserRequest = boost::shared_ptr<RequestAddUserDialogUIEvent>();

+ RequestInviteToMUCUIEvent::ref inviteToMUCRequest = RequestInviteToMUCUIEvent::ref();

+ switch (type_) {

+ case AddContact:

+ if ((addUserRequest = boost::dynamic_pointer_cast<RequestAddUserDialogUIEvent>(event))) {

+ break;

+ case StartChat:

+ break;

+ case InviteToChat:

+ if ((inviteToMUCRequest = boost::dynamic_pointer_cast<RequestInviteToMUCUIEvent>(event))) {

+ handle = true;

+ break;

+ if (handle) {

+ initializeUserWindow();

+ if (addUserRequest) {

+ const std::string& name = addUserRequest->getPredefinedName();

+ const JID& jid = addUserRequest->getPredefinedJID();

+ } else if (inviteToMUCRequest) {

+ window_->setJIDs(inviteToMUCRequest->getInvites());

+ window_->setRoomJID(inviteToMUCRequest->getRoom());

+void UserSearchController::handleContactSuggestionsRequested(std::string text) {

+ window_->setContactSuggestions(contactSuggester_->getSuggestions(text));

+}

+

+ handleJIDUpdateRequested(std::vector<JID>(1, jid));

+}

+

+void UserSearchController::handleAvatarChanged(const JID& jid) {

+ handleJIDUpdateRequested(std::vector<JID>(1, jid));

+}

+

+void UserSearchController::handlePresenceChanged(Presence::ref presence) {

+ handleJIDUpdateRequested(std::vector<JID>(1, presence->getFrom().toBare()));

+}

+

+void UserSearchController::handleJIDUpdateRequested(const std::vector<JID>& jids) {

+ if (window_) {

+ std::vector<Contact> updates;

+ foreach(const JID& jid, jids) {

+ updates.push_back(convertJIDtoContact(jid));

+ }

+ window_->updateContacts(updates);

+ }

+}

+

+Contact UserSearchController::convertJIDtoContact(const JID& jid) {

+ Contact contact;

+ contact.jid = jid;

+

+ // name lookup

+ boost::optional<XMPPRosterItem> rosterItem = rosterController_->getItem(jid);

+ if (rosterItem && !rosterItem->getName().empty()) {

+ contact.name = rosterItem->getName();

+ } else {

+ VCard::ref vcard = vcardManager_->getVCard(jid);

+ if (vcard && !vcard->getFullName().empty()) {

+ contact.name = vcard->getFullName();

+ } else {

+ contact.name = jid.toString();

+ }

+ }

+

+ // presence lookup

+ Presence::ref presence = presenceOracle_->getHighestPriorityPresence(jid);

+ if (presence) {

+ contact.statusType = presence->getShow();

+ } else {

+ contact.statusType = StatusShow::None;

+ }

+

+ // avatar lookup

+ contact.avatarPath = avatarManager_->getAvatarPath(jid);

+ return contact;

+void UserSearchController::initializeUserWindow() {

+ if (!window_) {

+ UserSearchWindow::Type windowType = UserSearchWindow::AddContact;

+ switch(type_) {

+ case AddContact:

+ windowType = UserSearchWindow::AddContact;

+ break;

+ case StartChat:

+ windowType = UserSearchWindow::ChatToContact;

+ break;

+ case InviteToChat:

+ windowType = UserSearchWindow::InviteToChat;

+ break;

+ }

+

+ window_ = factory_->createUserSearchWindow(windowType, uiEventStream_, rosterController_->getGroups());

+ window_->onNameSuggestionRequested.connect(boost::bind(&UserSearchController::handleNameSuggestionRequest, this, _1));

+ window_->onFormRequested.connect(boost::bind(&UserSearchController::handleFormRequested, this, _1));

+ window_->onSearchRequested.connect(boost::bind(&UserSearchController::handleSearch, this, _1, _2));

+ window_->onContactSuggestionsRequested.connect(boost::bind(&UserSearchController::handleContactSuggestionsRequested, this, _1));

+ window_->onJIDUpdateRequested.connect(boost::bind(&UserSearchController::handleJIDUpdateRequested, this, _1));

+ window_->setSelectedService(JID(jid_.getDomain()));

+ window_->clear();

+ }

+}

+

+#include <Swiften/Elements/Presence.h>

+ class ContactSuggester;

+ class AvatarManager;

+ class PresenceOracle;

+ class Contact;

+ enum Type {AddContact, StartChat, InviteToChat};

+ UserSearchController(Type type, const JID& jid, UIEventStream* uiEventStream, VCardManager* vcardManager, UserSearchWindowFactory* userSearchWindowFactory, IQRouter* iqRouter, RosterController* rosterController, ContactSuggester* contactSuggester, AvatarManager* avatarManager, PresenceOracle* presenceOracle);

+ UserSearchWindow* getUserSearchWindow();

+ void setCanInitiateImpromptuMUC(bool supportsImpromptu);

+

+ void handleContactSuggestionsRequested(std::string text);

+ void handleAvatarChanged(const JID& jid);

+ void handlePresenceChanged(Presence::ref presence);

+ void handleJIDUpdateRequested(const std::vector<JID>& jids);

+ Contact convertJIDtoContact(const JID& jid);

+ void initializeUserWindow();

+ ContactSuggester* contactSuggester_;

+ AvatarManager* avatarManager_;

+ PresenceOracle* presenceOracle_;

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include <Swift/Controllers/Contact.h>

+

+namespace Swift {

+

+Contact::Contact() {

+}

+

+Contact::Contact(const std::string& name, const JID& jid, StatusShow::Type statusType, const boost::filesystem::path& path) : name(name), jid(jid), statusType(statusType), avatarPath(path) {

+}

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/filesystem/path.hpp>

+

+#include <Swiften/Elements/StatusShow.h>

+#include <Swiften/JID/JID.h>

+

+namespace Swift {

+

+class Contact {

+ public:

+ Contact();

+ Contact(const std::string& name, const JID& jid, StatusShow::Type statusType, const boost::filesystem::path& path);

+

+ public:

+ std::string name;

+ JID jid;

+ StatusShow::Type statusType;

+ boost::filesystem::path avatarPath;

+};

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include <Swift/Controllers/ContactProvider.h>

+

+namespace Swift {

+

+ContactProvider::~ContactProvider() {

+

+}

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <vector>

+

+#include <Swift/Controllers/Contact.h>

+

+namespace Swift {

+

+class ContactProvider {

+ public:

+ virtual ~ContactProvider();

+ virtual std::vector<Contact> getContacts() = 0;

+};

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include <Swift/Controllers/ContactSuggester.h>

+

+#include <boost/algorithm/string/find.hpp>

+#include <boost/lambda/lambda.hpp>

+#include <boost/lambda/bind.hpp>

+

+#include <Swiften/Base/Algorithm.h>

+#include <Swiften/Base/foreach.h>

+#include <Swiften/JID/JID.h>

+

+#include <Swift/Controllers/ContactProvider.h>

+

+#include <algorithm>

+#include <vector>

+#include <set>

+

+namespace lambda = boost::lambda;

+

+namespace Swift {

+

+ContactSuggester::ContactSuggester() {

+}

+

+ContactSuggester::~ContactSuggester() {

+}

+

+void ContactSuggester::addContactProvider(ContactProvider* provider) {

+ contactProviders_.push_back(provider);

+}

+

+bool ContactSuggester::matchContact(const std::string& search, const Contact& c) {

+ return fuzzyMatch(c.name, search) || fuzzyMatch(c.jid.toString(), search);

+}

+

+std::vector<Contact> ContactSuggester::getSuggestions(const std::string& search) const {

+ std::vector<Contact> results;

+

+ foreach(ContactProvider* provider, contactProviders_) {

+ append(results, provider->getContacts());

+ }

+

+ std::sort(results.begin(), results.end(),

+ lambda::bind(&Contact::jid, lambda::_1) < lambda::bind(&Contact::jid, lambda::_2));

+ results.erase(std::unique(results.begin(), results.end(),

+ lambda::bind(&Contact::jid, lambda::_1) == lambda::bind(&Contact::jid, lambda::_2)),

+ results.end());

+ results.erase(std::remove_if(results.begin(), results.end(), !lambda::bind(&ContactSuggester::matchContact, search, lambda::_1)),

+ results.end());

+ std::sort(results.begin(), results.end(), ContactSuggester::chatSortPredicate);

+

+ return results;

+}

+

+bool ContactSuggester::fuzzyMatch(std::string text, std::string match) {

+ for (std::string::iterator currentQueryChar = match.begin(); currentQueryChar != match.end(); currentQueryChar++) {

+ //size_t result = text.find(*currentQueryChar);

+ std::string::iterator result = boost::algorithm::ifind_first(text, std::string(currentQueryChar, currentQueryChar+1)).begin();

+ if (result == text.end()) {

+ return false;

+ }

+ text.erase(result);

+ }

+ return true;

+}

+

+bool ContactSuggester::chatSortPredicate(const Contact& a, const Contact& b) {

+ if (a.statusType == b.statusType) {

+ return a.name.compare(b.name) < 0;

+ } else {

+ return a.statusType < b.statusType;

+ }

+}

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <string>

+#include <vector>

+

+#include <Swift/Controllers/Contact.h>

+

+namespace Swift {

+ class ContactProvider;

+

+ class ContactSuggester {

+ public:

+ ContactSuggester();

+ ~ContactSuggester();

+

+ void addContactProvider(ContactProvider* provider);

+

+ std::vector<Contact> getSuggestions(const std::string& search) const;

+ private:

+ static bool matchContact(const std::string& search, const Contact& c);

+ /**

+ * Performs fuzzy matching on the string text. Matches when each character of match string is present in sequence in text string.

+ */

+ static bool fuzzyMatch(std::string text, std::string match);

+ static bool chatSortPredicate(const Contact& a, const Contact& b);

+

+ private:

+ std::vector<ContactProvider*> contactProviders_;

+ };

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include <Swift/Controllers/ContactsFromXMPPRoster.h>

+

+#include <Swiften/Base/foreach.h>

+

+#include <Swiften/Avatars/AvatarManager.h>

+#include <Swiften/Presence/PresenceOracle.h>

+#include <Swiften/Roster/XMPPRoster.h>

+#include <Swiften/Roster/XMPPRosterItem.h>

+

+namespace Swift {

+

+ContactsFromXMPPRoster::ContactsFromXMPPRoster(XMPPRoster* roster, AvatarManager* avatarManager, PresenceOracle* presenceOracle) : roster_(roster), avatarManager_(avatarManager), presenceOracle_(presenceOracle) {

+}

+

+ContactsFromXMPPRoster::~ContactsFromXMPPRoster() {

+}

+

+std::vector<Contact> ContactsFromXMPPRoster::getContacts() {

+ std::vector<Contact> results;

+ std::vector<XMPPRosterItem> rosterItems = roster_->getItems();

+ foreach(const XMPPRosterItem& rosterItem, rosterItems) {

+ Contact contact(rosterItem.getName().empty() ? rosterItem.getJID().toString() : rosterItem.getName(), rosterItem.getJID(), StatusShow::None,"");

+ contact.statusType = presenceOracle_->getHighestPriorityPresence(contact.jid) ? presenceOracle_->getHighestPriorityPresence(contact.jid)->getShow() : StatusShow::None;

+ contact.avatarPath = avatarManager_->getAvatarPath(contact.jid);

+ results.push_back(contact);

+ }

+ return results;

+}

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <Swift/Controllers/ContactProvider.h>

+

+namespace Swift {

+

+class PresenceOracle;

+class AvatarManager;

+class XMPPRoster;

+

+class ContactsFromXMPPRoster : public ContactProvider {

+ public:

+ ContactsFromXMPPRoster(XMPPRoster* roster, AvatarManager* avatarManager, PresenceOracle* presenceOracle);

+ virtual ~ContactsFromXMPPRoster();

+

+ virtual std::vector<Contact> getContacts();

+ private:

+ XMPPRoster* roster_;

+ AvatarManager* avatarManager_;

+ PresenceOracle* presenceOracle_;

+};

+

+}

+#include <Swiften/Crypto/CryptoProvider.h>

+#include <Swift/Controllers/ContactSuggester.h>

+#include <Swift/Controllers/ContactsFromXMPPRoster.h>

+ userSearchControllerInvite_ = NULL;

+ contactsFromRosterProvider_ = NULL;

+ contactSuggesterWithoutRoster_ = NULL;

+ contactSuggesterWithRoster_ = NULL;

+ delete userSearchControllerInvite_;

+ userSearchControllerInvite_ = NULL;

+ delete contactSuggesterWithoutRoster_;

+ contactSuggesterWithoutRoster_ = NULL;

+ delete contactSuggesterWithRoster_;

+ contactSuggesterWithRoster_ = NULL;

+ delete contactsFromRosterProvider_;

+ contactsFromRosterProvider_ = NULL;

+ contactSuggesterWithoutRoster_ = new ContactSuggester();

+ contactSuggesterWithRoster_ = new ContactSuggester();

+

+ userSearchControllerInvite_ = new UserSearchController(UserSearchController::InviteToChat, jid_, uiEventStream_, client_->getVCardManager(), uiFactory_, client_->getIQRouter(), rosterController_, contactSuggesterWithRoster_, client_->getAvatarManager(), client_->getPresenceOracle());

+ chatsManager_ = new ChatsManager(jid_, client_->getStanzaChannel(), client_->getIQRouter(), eventController_, uiFactory_, uiFactory_, client_->getNickResolver(), client_->getPresenceOracle(), client_->getPresenceSender(), uiEventStream_, uiFactory_, useDelayForLatency_, networkFactories_->getTimerFactory(), client_->getMUCRegistry(), client_->getEntityCapsProvider(), client_->getMUCManager(), uiFactory_, profileSettings_, ftOverview_, client_->getRoster(), !settings_->getSetting(SettingConstants::REMEMBER_RECENT_CHATS), settings_, historyController_, whiteboardManager_, highlightManager_, client_->getClientBlockListManager(), emoticons_, userSearchControllerInvite_);

+ chatsManager_ = new ChatsManager(jid_, client_->getStanzaChannel(), client_->getIQRouter(), eventController_, uiFactory_, uiFactory_, client_->getNickResolver(), client_->getPresenceOracle(), client_->getPresenceSender(), uiEventStream_, uiFactory_, useDelayForLatency_, networkFactories_->getTimerFactory(), client_->getMUCRegistry(), client_->getEntityCapsProvider(), client_->getMUCManager(), uiFactory_, profileSettings_, ftOverview_, client_->getRoster(), !settings_->getSetting(SettingConstants::REMEMBER_RECENT_CHATS), settings_, NULL, whiteboardManager_, highlightManager_, client_->getClientBlockListManager(), &emoticons_, userSearchControllerInvite_);

+ contactsFromRosterProvider_ = new ContactsFromXMPPRoster(client_->getRoster(), client_->getAvatarManager(), client_->getPresenceOracle());

+ contactSuggesterWithoutRoster_->addContactProvider(chatsManager_);

+ contactSuggesterWithRoster_->addContactProvider(chatsManager_);

+ contactSuggesterWithRoster_->addContactProvider(contactsFromRosterProvider_);

+ userSearchControllerChat_ = new UserSearchController(UserSearchController::StartChat, jid_, uiEventStream_, client_->getVCardManager(), uiFactory_, client_->getIQRouter(), rosterController_, contactSuggesterWithRoster_, client_->getAvatarManager(), client_->getPresenceOracle());

+ userSearchControllerAdd_ = new UserSearchController(UserSearchController::AddContact, jid_, uiEventStream_, client_->getVCardManager(), uiFactory_, client_->getIQRouter(), rosterController_, contactSuggesterWithoutRoster_, client_->getAvatarManager(), client_->getPresenceOracle());

+ chatsManager_->onImpromptuMUCServiceDiscovered.connect(boost::bind(&UserSearchController::setCanInitiateImpromptuMUC, userSearchControllerChat_, _1));

+ class ContactSuggester;

+ class ContactsFromXMPPRoster;

+ ContactsFromXMPPRoster* contactsFromRosterProvider_;

+ ContactSuggester* contactSuggesterWithoutRoster_;

+ ContactSuggester* contactSuggesterWithRoster_;

+ UserSearchController* userSearchControllerInvite_;

+ "ContactSuggester.cpp",

+ "Highlighter.cpp",

+ "ContactsFromXMPPRoster.cpp",

+ "ContactProvider.cpp",

+ "Contact.cpp"

+const SettingsProvider::Setting<std::string> SettingConstants::INVITE_AUTO_ACCEPT_MODE("inviteAutoAcceptMode", "presence");

+ static const SettingsProvider::Setting<std::string> INVITE_AUTO_ACCEPT_MODE;

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <Swift/Controllers/UIEvents/UIEvent.h>

+

+namespace Swift {

+

+class CreateImpromptuMUCUIEvent : public UIEvent {

+ public:

+ CreateImpromptuMUCUIEvent(const std::vector<JID>& jids, const JID& roomJID = JID(), const std::string reason = "") : jids_(jids), roomJID_(roomJID), reason_(reason) { }

+

+ std::vector<JID> getJIDs() const { return jids_; }

+ JID getRoomJID() const { return roomJID_; }

+ std::string getReason() const { return reason_; }

+ private:

+ std::vector<JID> jids_;

+ JID roomJID_;

+ std::string reason_;

+};

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+#include <vector>

+

+#include <Swift/Controllers/UIEvents/UIEvent.h>

+#include <Swiften/JID/JID.h>

+

+namespace Swift {

+ class InviteToMUCUIEvent : public UIEvent {

+ public:

+ typedef boost::shared_ptr<InviteToMUCUIEvent> ref;

+

+ InviteToMUCUIEvent(const JID& room, const std::vector<JID>& JIDsToInvite, const std::string& reason) : room_(room), invite_(JIDsToInvite), reason_(reason) {

+ }

+

+ const JID& getRoom() const {

+ return room_;

+ }

+

+ const std::vector<JID> getInvites() const {

+ return invite_;

+ }

+

+ const std::string getReason() const {

+ return reason_;

+ }

+

+ private:

+ JID room_;

+ std::vector<JID> invite_;

+ std::string reason_;

+ };

+}

+ JoinMUCUIEvent(const JID& jid, const boost::optional<std::string>& password = boost::optional<std::string>(), const boost::optional<std::string>& nick = boost::optional<std::string>(), bool joinAutomaticallyInFuture = false, bool createAsReservedRoomIfNew = false, bool isImpromptu = false, bool isContinuation = false) : jid_(jid), nick_(nick), joinAutomatically_(joinAutomaticallyInFuture), createAsReservedRoomIfNew_(createAsReservedRoomIfNew), password_(password), isImpromptuMUC_(isImpromptu), isContinuation_(isContinuation) {}

+ bool isImpromptu() const {return isImpromptuMUC_;}

+ bool isContinuation() const {return isContinuation_;}

+

+ bool isImpromptuMUC_;

+ bool isContinuation_;

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+#include <vector>

+

+#include <Swift/Controllers/UIEvents/UIEvent.h>

+#include <Swiften/JID/JID.h>

+

+namespace Swift {

+ class RequestInviteToMUCUIEvent : public UIEvent {

+ public:

+ typedef boost::shared_ptr<RequestInviteToMUCUIEvent> ref;

+

+ RequestInviteToMUCUIEvent(const JID& room, const std::vector<JID>& JIDsToInvite) : room_(room), invite_(JIDsToInvite) {

+ }

+

+ const JID& getRoom() const {

+ return room_;

+ }

+

+ const std::vector<JID> getInvites() const {

+ return invite_;

+ }

+

+ private:

+ JID room_;

+ std::vector<JID> invite_;

+ };

+}

+#include <set>

+#include <map>

+#include <Swiften/Base/foreach.h>

+ Chat() : statusType(StatusShow::None), isMUC(false), unreadCount(0) {}

+ std::string getImpromptuTitle() const {

+ typedef std::pair<std::string, JID> StringJIDPair;

+ std::string title;

+ foreach(StringJIDPair pair, impromptuJIDs) {

+ if (title.empty()) {

+ title += pair.first;

+ } else {

+ title += ", " + pair.first;

+ }

+ }

+ return title;

+ }

+ std::map<std::string, JID> impromptuJIDs;

+ class UserSearchWindow;

+ virtual void addMUCInvitation(const std::string& senderName, const JID& jid, const std::string& reason, const std::string& password, bool direct = true, bool isImpromptu = false, bool isContinuation = false) = 0;

+ virtual void convertToMUC(bool impromptuMUC = false) = 0;

+ virtual void setCanInitiateImpromptuChats(bool supportsImpromptu) = 0;

+ boost::signal<void (const std::vector<JID>&)> onInviteToChat;

+#include <Swiften/Base/boost_bsignals.h>

+#include <Swiften/JID/JID.h>

+#include <Swift/Controllers/Chat/UserSearchController.h>

+#include <Swift/Controllers/Contact.h>

+ enum Type {AddContact, ChatToContact, InviteToChat};

+ virtual void setContactSuggestions(const std::vector<Contact>& suggestions) = 0;

+ virtual void setJIDs(const std::vector<JID>&) = 0;

+ virtual void setRoomJID(const JID& roomJID) = 0;

+ virtual std::string getReason() const = 0;

+ virtual std::vector<JID> getJIDs() const = 0;

+ virtual void setCanStartImpromptuChats(bool supportsImpromptu) = 0;

+ virtual void updateContacts(const std::vector<Contact>& contacts) = 0;

+

+ boost::signal<void (const std::string&)> onContactSuggestionsRequested;

+ boost::signal<void (const std::vector<JID>&)> onJIDUpdateRequested;

+ virtual void convertToMUC(bool /*impromptuMUC*/) {}

+ virtual void addMUCInvitation(const std::string& /*senderName*/, const JID& /*jid*/, const std::string& /*reason*/, const std::string& /*password*/, bool = true, bool = false, bool = false) {}

+ virtual void setCanInitiateImpromptuChats(bool /*supportsImpromptu*/) {}

+ MUCInviteEvent(const JID& inviter, const JID& roomJID, const std::string& reason, const std::string& password, bool direct, bool impromptu) : inviter_(inviter), roomJID_(roomJID), reason_(reason), password_(password), direct_(direct), impromptu_(impromptu) {}

+ bool getImpromptu() const { return impromptu_; }

+ bool impromptu_;