+boostLibs = [("signals", None), ("thread", None), ("regex", None), ("program_options", None), ("filesystem", None), ("serialization", "archive/text_oarchive.hpp"), ("system", "system/system_error.hpp"), ("date_time", "date_time/date.hpp")]

+/*

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

+ handleGeneralMUCInvitation(inviteEvent);

+ }

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

+}

+

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

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

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

+ recentChats_.erase(std::remove(recentChats_.begin(), recentChats_.end(), chat), recentChats_.end());

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

+ } else {

+ return boost::optional<ChatListWindow::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_->convertToMUC();

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

+ chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "Trying to enter room %1%")) % toJID_.toString())), ChatWindow::DefaultDirection);

+ }

+

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

+ chatWindow_->showRoomConfigurationForm(form);

+ }

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

+ handle = true;

+ }

+ break;

+ case StartChat:

+ if (boost::dynamic_pointer_cast<RequestChatWithUserDialogUIEvent>(event)) {

+ handle = true;

+ }

+ break;

+ case InviteToChat:

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

+ handle = true;

+ }

+ break;

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

+ case Qt::DisplayRole: return chat_.impromptuJIDs.empty() ? P2QSTRING(chat_.chatName) : P2QSTRING(chat_.getImpromptuTitle());

+ settings_ = settings;

+ QRegExp hasTrailingGarbage("^(.[-\\w\\s,&]+)([^\\s\\,w].*)$");

+QtChatWindow::QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventStream* eventStream, SettingsProvider* settings) : QtTabbable(), contact_(contact), previousMessageWasSelf_(false), previousMessageKind_(PreviosuMessageWasNone), eventStream_(eventStream), blockingState_(BlockingUnsupported), isMUC_(false), supportsImpromptuChat_(false) {

+ connect(jsBridge, SIGNAL(buttonClicked(QString,QString,QString,QString,QString,QString)), this, SLOT(handleHTMLButtonClicked(QString,QString,QString,QString,QString,QString)));

+void QtChatWindow::convertToMUC(bool impromptuMUC) {

+ impromptu_ = impromptuMUC;

+ isMUC_ = true;

+ subject_->setVisible(!impromptu_);

+QString QtChatWindow::buildChatWindowButton(const QString& name, const QString& id, const QString& arg1, const QString& arg2, const QString& arg3, const QString& arg4, const QString& arg5) {

+ QString html = QString("<input id='%2' type='submit' value='%1' onclick='chatwindow.buttonClicked(\"%2\", \"%3\", \"%4\", \"%5\", \"%6\", \"%7\");' />").arg(name).arg(id).arg(encodeButtonArgument(arg1)).arg(encodeButtonArgument(arg2)).arg(encodeButtonArgument(arg3)).arg(encodeButtonArgument(arg4)).arg(encodeButtonArgument(arg5));

+void QtChatWindow::handleHTMLButtonClicked(QString id, QString encodedArgument1, QString encodedArgument2, QString encodedArgument3, QString encodedArgument4, QString encodedArgument5) {

+ QString arg4 = decodeButtonArgument(encodedArgument4);

+ QString arg5 = decodeButtonArgument(encodedArgument5);

+ QString isImpromptu = arg4;

+ QString isContinuation = arg5;

+ eventStream_->send(boost::make_shared<JoinMUCUIEvent>(Q2PSTRING(roomJID), Q2PSTRING(password), boost::optional<std::string>(), false, false, isImpromptu.contains("true"), isContinuation.contains("true")));

+ if (!isMUC_) {

+ event->acceptProposedAction();

+ }

+ } else if (event->mimeData()->hasFormat("application/vnd.swift.contact-jid")) {

+ if (isMUC_ || supportsImpromptuChat_) {

+ event->acceptProposedAction();

+ }

+ if (event->mimeData()->hasUrls()) {

+ if (event->mimeData()->urls().size() == 1) {

+ onSendFileRequest(Q2PSTRING(event->mimeData()->urls().at(0).toLocalFile()));

+ } else {

+ std::string messageText(Q2PSTRING(tr("Sending of multiple files at once isn't supported at this time.")));

+ ChatMessage message;

+ message.append(boost::make_shared<ChatTextMessagePart>(messageText));

+ addSystemMessage(message, DefaultDirection);

+ }

+ } else if (event->mimeData()->hasFormat("application/vnd.swift.contact-jid")) {

+ QByteArray dataBytes = event->mimeData()->data("application/vnd.swift.contact-jid");

+ QDataStream dataStream(&dataBytes, QIODevice::ReadOnly);

+ QString jidString;

+ dataStream >> jidString;

+ onInviteToChat(std::vector<JID>(1, JID(Q2PSTRING(jidString))));

+

+ if (supportsImpromptuChat_) {

+ invite = contextMenu.addAction(tr("Invite person to this chat…"));

+ }

+

+ if (impromptu_) {

+ // hide options we don't need in impromptu chats

+ if (availableAction == ChatWindow::ChangeSubject ||

+ availableAction == ChatWindow::Configure ||

+ availableAction == ChatWindow::Affiliations ||

+ availableAction == ChatWindow::Destroy) {

+ continue;

+ }

+ }

+ onInviteToChat(std::vector<JID>());

+void QtChatWindow::setCanInitiateImpromptuChats(bool supportsImpromptu) {

+ supportsImpromptuChat_ = supportsImpromptu;

+}

+

+void QtChatWindow::addMUCInvitation(const std::string& senderName, const JID& jid, const std::string& reason, const std::string& password, bool direct, bool isImpromptu, bool isContinuation) {

+ QString message;

+ if (isImpromptu) {

+ message = QObject::tr("You've been invited to join a chat.") + "\n";

+ } else {

+ message = QObject::tr("You've been invited to enter the %1 room.").arg(P2QSTRING(jid.toString())) + "\n";

+ }

+ buildChatWindowButton(chatMessageToHTML(ChatMessage(Q2PSTRING((tr("Accept Invite"))))), ButtonMUCInvite, QtUtilities::htmlEscape(P2QSTRING(jid.toString())), QtUtilities::htmlEscape(P2QSTRING(password)), id, QtUtilities::htmlEscape(isImpromptu ? "true" : "false"), QtUtilities::htmlEscape(isContinuation ? "true" : "false")) +

+ void convertToMUC(bool impromptuMUC = false);

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

+ virtual void setCanInitiateImpromptuChats(bool supportsImpromptu);

+ static QString buildChatWindowButton(const QString& name, const QString& id, const QString& arg1 = QString(), const QString& arg2 = QString(), const QString& arg3 = QString(), const QString& arg4 = QString(), const QString& arg5 = QString());

+ void handleHTMLButtonClicked(QString id, QString arg1, QString arg2, QString arg3, QString arg4, QString arg5);

+ bool impromptu_;

+ bool isMUC_;

+ bool supportsImpromptuChat_;

+ void buttonClicked(QString id, QString arg1, QString arg2, QString arg3, QString arg4, QString arg5);

+ addUserAction_->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_D));

+ chatUserAction_->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_N));

+ return new QtUserSearchWindow(eventStream, type, groups, qtOnlySettings);

+void QtRemovableItemDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const {

+ drawBackground(painter, option, index);

+ setDragEnabled(true);

+ QTreeView::dragMoveEvent(event);

+#include <QMimeData>

+}

+Qt::ItemFlags RosterModel::flags(const QModelIndex& index) const {

+ Qt::ItemFlags flags = QAbstractItemModel::flags(index);

+ if (dynamic_cast<GroupRosterItem*>(getItem(index)) == NULL) {

+ flags |= Qt::ItemIsDragEnabled;

+ }

+ return flags;

+}

+

+QMimeData* RosterModel::mimeData(const QModelIndexList& indexes) const {

+ QMimeData* data = QAbstractItemModel::mimeData(indexes);

+

+ ContactRosterItem *item = dynamic_cast<ContactRosterItem*>(getItem(indexes.first()));

+ if (item == NULL) {

+ return data;

+ }

+

+ QByteArray itemData;

+ QDataStream dataStream(&itemData, QIODevice::WriteOnly);

+

+ // jid, chatName, activity, statusType, avatarPath

+ dataStream << P2QSTRING(item->getJID().toString());

+ dataStream << P2QSTRING(item->getDisplayName());

+ dataStream << P2QSTRING(item->getStatusText());

+ dataStream << item->getSimplifiedStatusShow();

+ dataStream << P2QSTRING(item->getAvatarPath().string());

+ data->setData("application/vnd.swift.contact-jid", itemData);

+ return data;

+}

+

+ Qt::ItemFlags flags(const QModelIndex& index) const;

+ QMimeData* mimeData(const QModelIndexList& indexes) const;

+

+ "UserSearch/ContactListDelegate.cpp",

+ "UserSearch/ContactListModel.cpp",

+ "UserSearch/QtContactListWidget.cpp",

+ "UserSearch/QtSuggestingJIDInput.cpp",

+ "UserSearch/QtUserSearchFirstMultiJIDPage.cpp",

+myenv.Uic4("UserSearch/QtUserSearchFirstMultiJIDPage.ui")

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <Swift/QtUI/UserSearch/ContactListDelegate.h>

+#include <Swift/QtUI/UserSearch/ContactListModel.h>

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

+#include <Swift/QtUI/QtSwiftUtil.h>

+

+namespace Swift {

+

+ContactListDelegate::ContactListDelegate(bool compact) : compact_(compact) {

+}

+

+ContactListDelegate::~ContactListDelegate() {

+}

+

+void ContactListDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const {

+ if (!index.isValid()) {

+ return;

+ }

+ const Contact* contact = static_cast<Contact*>(index.internalPointer());

+ QColor nameColor = index.data(Qt::TextColorRole).value<QColor>();

+ QString avatarPath = index.data(ContactListModel::AvatarRole).value<QString>();

+ QIcon presenceIcon =index.data(ChatListRecentItem::PresenceIconRole).isValid() && !index.data(ChatListRecentItem::PresenceIconRole).value<QIcon>().isNull()

+ ? index.data(ChatListRecentItem::PresenceIconRole).value<QIcon>()

+ : QIcon(":/icons/offline.png");

+ QString name = P2QSTRING(contact->name);

+ QString statusText = P2QSTRING(contact->jid.toString());

+ common_.paintContact(painter, option, nameColor, avatarPath, presenceIcon, name, statusText, false, 0, compact_);

+}

+

+QSize ContactListDelegate::sizeHint(const QStyleOptionViewItem& /*option*/, const QModelIndex& /*index*/ ) const {

+ QFontMetrics nameMetrics(common_.nameFont);

+ QFontMetrics statusMetrics(common_.detailFont);

+ int sizeByText = 2 * common_.verticalMargin + nameMetrics.height() + statusMetrics.height();

+ return QSize(150, sizeByText);

+}

+

+void ContactListDelegate::setCompact(bool compact) {

+ compact_ = compact;

+}

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <QStyledItemDelegate>

+

+#include <Swift/QtUI/Roster/DelegateCommons.h>

+

+namespace Swift {

+

+class ContactListDelegate : public QStyledItemDelegate {

+ public:

+ ContactListDelegate(bool compact);

+ virtual ~ContactListDelegate();

+

+ QSize sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const;

+ void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const;

+

+ public slots:

+ void setCompact(bool compact);

+

+ private:

+ bool compact_;

+ DelegateCommons common_;

+};

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <Swift/QtUI/UserSearch/ContactListModel.h>

+

+#include <Swift/QtUI/QtSwiftUtil.h>

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

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

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

+

+#include <QMimeData>

+

+namespace Swift {

+

+QDataStream& operator >>(QDataStream& in, StatusShow::Type& e){

+ quint32 buffer;

+ in >> buffer;

+ switch(buffer) {

+ case StatusShow::Online:

+ e = StatusShow::Online;

+ break;

+ case StatusShow::Away:

+ e = StatusShow::Away;

+ break;

+ case StatusShow::FFC:

+ e = StatusShow::FFC;

+ break;

+ case StatusShow::XA:

+ e = StatusShow::XA;

+ break;

+ case StatusShow::DND:

+ e = StatusShow::DND;

+ break;

+ default:

+ e = StatusShow::None;

+ break;

+ }

+ return in;

+}

+

+ContactListModel::ContactListModel(bool editable) : QAbstractItemModel(), editable_(editable) {

+}

+

+void ContactListModel::setList(const std::vector<Contact>& list) {

+ emit layoutAboutToBeChanged();

+ contacts_ = list;

+ emit layoutChanged();

+}

+

+const std::vector<Contact>& ContactListModel::getList() const {

+ return contacts_;

+}

+

+Qt::ItemFlags ContactListModel::flags(const QModelIndex& index) const {

+ Qt::ItemFlags flags = QAbstractItemModel::flags(index);

+ if (index.isValid()) {

+ flags = flags & ~Qt::ItemIsDropEnabled;

+ } else {

+ flags = Qt::ItemIsDropEnabled | flags;

+ }

+ return flags;

+}

+

+int ContactListModel::columnCount(const QModelIndex&) const {

+ return editable_ ? 2 : 1;

+}

+

+QVariant ContactListModel::data(const QModelIndex& index, int role) const {

+ if (boost::numeric_cast<size_t>(index.row()) < contacts_.size()) {

+ const Contact& contact = contacts_[index.row()];

+ if (role == Qt::EditRole) {

+ return P2QSTRING(contact.jid.toString());

+ }

+ return dataForContact(contact, role);

+ } else {

+ return QVariant();

+ }

+}

+

+bool ContactListModel::dropMimeData(const QMimeData* data, Qt::DropAction /*action*/, int /*row*/, int /*column*/, const QModelIndex& /*parent*/) {

+ if (!data->hasFormat("application/vnd.swift.contact-jid")) {

+ return false;

+ }

+

+ QByteArray dataBytes = data->data("application/vnd.swift.contact-jid");

+ QDataStream dataStream(&dataBytes, QIODevice::ReadOnly);

+ QString jidString;

+ QString displayName;

+ QString statusText;

+ StatusShow::Type statusType;

+ QString avatarPath;

+

+ dataStream >> jidString;

+ dataStream >> displayName;

+ dataStream >> statusText;

+ dataStream >> statusType;

+ dataStream >> avatarPath;

+

+ JID jid = JID(Q2PSTRING(jidString));

+

+ foreach(const Contact& contact, contacts_) {

+ if (contact.jid == jid) {

+ return false;

+ }

+ }

+

+ emit layoutAboutToBeChanged();

+ contacts_.push_back(Contact(Q2PSTRING(displayName), jid, statusType, Q2PSTRING(avatarPath)));

+ emit layoutChanged();

+

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

+ onListChanged(getList());

+

+ return true;

+}

+

+QModelIndex ContactListModel::index(int row, int column, const QModelIndex& parent) const {

+ if (!hasIndex(row, column, parent)) {

+ return QModelIndex();

+ }

+

+ return boost::numeric_cast<size_t>(row) < contacts_.size() ? createIndex(row, column, (void*)&(contacts_[row])) : QModelIndex();

+}

+

+QModelIndex ContactListModel::parent(const QModelIndex& index) const {

+ if (!index.isValid()) {

+ return QModelIndex();

+ }

+ return QModelIndex();

+}

+

+int ContactListModel::rowCount(const QModelIndex& /*parent*/) const {

+ return contacts_.size();

+}

+

+bool ContactListModel::removeRows(int row, int /*count*/, const QModelIndex& /*parent*/) {

+ if (boost::numeric_cast<size_t>(row) < contacts_.size()) {

+ emit layoutAboutToBeChanged();

+ contacts_.erase(contacts_.begin() + row);

+ emit layoutChanged();

+ onListChanged(getList());

+ return true;

+ }

+ return false;

+}

+

+QVariant ContactListModel::dataForContact(const Contact& contact, int role) const {

+ switch (role) {

+ case Qt::DisplayRole: return P2QSTRING(contact.name);

+ case DetailTextRole: return P2QSTRING(contact.jid.toString());

+ case AvatarRole: return QVariant(P2QSTRING(pathToString(contact.avatarPath)));

+ case PresenceIconRole: return getPresenceIconForContact(contact);

+ default: return QVariant();

+ }

+}

+

+QIcon ContactListModel::getPresenceIconForContact(const Contact& contact) const {

+ QString iconString;

+ switch (contact.statusType) {

+ case StatusShow::Online: iconString = "online";break;

+ case StatusShow::Away: iconString = "away";break;

+ case StatusShow::XA: iconString = "away";break;

+ case StatusShow::FFC: iconString = "online";break;

+ case StatusShow::DND: iconString = "dnd";break;

+ case StatusShow::None: iconString = "offline";break;

+ }

+ return QIcon(":/icons/" + iconString + ".png");

+}

+

+}

+/*

+ * 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 <boost/bind.hpp>

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

+

+#include <QAbstractItemModel>

+

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

+#include <Swift/QtUI/ChatList/ChatListItem.h>

+#include <Swift/QtUI/ChatList/ChatListGroupItem.h>

+#include <Swift/QtUI/ChatList/ChatListRecentItem.h>

+

+namespace Swift {

+ class ContactListModel : public QAbstractItemModel {

+ Q_OBJECT

+ public:

+ enum ContactRoles {

+ DetailTextRole = Qt::UserRole,

+ AvatarRole = Qt::UserRole + 1,

+ PresenceIconRole = Qt::UserRole + 2

+ };

+

+ public:

+ ContactListModel(bool editable);

+

+ void setList(const std::vector<Contact>& list);

+ const std::vector<Contact>& getList() const;

+

+ Qt::ItemFlags flags(const QModelIndex& index) const;

+ int columnCount(const QModelIndex& parent = QModelIndex()) const;

+ QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const;

+ bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent);

+ QModelIndex index(int row, int column, const QModelIndex & parent = QModelIndex()) const;

+ QModelIndex parent(const QModelIndex& index) const;

+ int rowCount(const QModelIndex& parent = QModelIndex()) const;

+ bool removeRows(int row, int count, const QModelIndex& parent = QModelIndex());

+

+ private:

+ QVariant dataForContact(const Contact& contact, int role) const;

+ QIcon getPresenceIconForContact(const Contact& contact) const;

+

+ signals:

+ void onListChanged(std::vector<Contact> list);

+ void onJIDsDropped(const std::vector<JID>& contact);

+

+ private:

+ bool editable_;

+ std::vector<Contact> contacts_;

+ };

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <Swift/QtUI/UserSearch/QtContactListWidget.h>

+

+#include <Swift/QtUI/UserSearch/ContactListModel.h>

+#include <Swift/QtUI/UserSearch/ContactListDelegate.h>

+#include <Swift/QtUI/QtUISettingConstants.h>

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

+#include <Swift/QtUI/QtVCardWidget/QtRemovableItemDelegate.h>

+

+#include <QHeaderView>

+

+namespace Swift {

+

+QtContactListWidget::QtContactListWidget(QWidget* parent, SettingsProvider* settings) : QTreeView(parent), settings_(settings), limited_(false) {

+ contactListModel_ = new ContactListModel(true);

+ setModel(contactListModel_);

+

+ connect(contactListModel_, SIGNAL(onListChanged(std::vector<Contact>)), this, SLOT(handleListChanged(std::vector<Contact>)));

+ connect(contactListModel_, SIGNAL(onListChanged(std::vector<Contact>)), this, SIGNAL(onListChanged(std::vector<Contact>)));

+ connect(contactListModel_, SIGNAL(onJIDsDropped(std::vector<JID>)), this, SIGNAL(onJIDsAdded(std::vector<JID>)));

+

+ setSelectionMode(QAbstractItemView::SingleSelection);

+ setSelectionBehavior(QAbstractItemView::SelectRows);

+ setDragEnabled(true);

+ setAcceptDrops(true);

+ setDropIndicatorShown(true);

+ setUniformRowHeights(true);

+

+ setAlternatingRowColors(true);

+ setIndentation(0);

+ setHeaderHidden(true);

+ setExpandsOnDoubleClick(false);

+ setItemsExpandable(false);

+ setEditTriggers(QAbstractItemView::DoubleClicked);

+

+ contactListDelegate_ = new ContactListDelegate(settings->getSetting(QtUISettingConstants::COMPACT_ROSTER));

+ removableItemDelegate_ = new QtRemovableItemDelegate(style());

+

+ setItemDelegateForColumn(0, contactListDelegate_);

+ setItemDelegateForColumn(1, removableItemDelegate_);

+

+ int closeIconWidth = fontMetrics().height();

+ header()->resizeSection(1, closeIconWidth);

+

+ header()->setStretchLastSection(false);

+#if QT_VERSION >= 0x050000

+ header()->setSectionResizeMode(0, QHeaderView::Stretch);

+#else

+ header()->setResizeMode(0, QHeaderView::Stretch);

+#endif

+}

+

+QtContactListWidget::~QtContactListWidget() {

+ delete contactListDelegate_;

+ delete removableItemDelegate_;

+}

+

+void QtContactListWidget::setList(const std::vector<Contact>& list) {

+ contactListModel_->setList(list);

+}

+

+std::vector<Contact> QtContactListWidget::getList() const {

+ return contactListModel_->getList();

+}

+

+void QtContactListWidget::setMaximumNoOfContactsToOne(bool limited) {

+ limited_ = limited;

+ if (limited) {

+ handleListChanged(getList());

+ } else {

+ setAcceptDrops(true);

+ setDropIndicatorShown(true);

+ }

+}

+

+void QtContactListWidget::updateContacts(const std::vector<Contact>& contactUpdates) {

+ std::vector<Contact> contacts = contactListModel_->getList();

+ foreach(const Contact& contactUpdate, contactUpdates) {

+ for(size_t n = 0; n < contacts.size(); n++) {

+ if (contactUpdate.jid == contacts[n].jid) {

+ contacts[n] = contactUpdate;

+ break;

+ }

+ }

+ }

+ contactListModel_->setList(contacts);

+}

+

+void QtContactListWidget::handleListChanged(std::vector<Contact> list) {

+ if (limited_) {

+ setAcceptDrops(list.size() <= 1);

+ setDropIndicatorShown(list.size() <= 1);

+ }

+}

+

+void QtContactListWidget::handleSettingsChanged(const std::string&) {

+ contactListDelegate_->setCompact(settings_->getSetting(QtUISettingConstants::COMPACT_ROSTER));

+}

+

+}

+/*

+ * 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 <QTreeView>

+

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

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

+

+#include <QDragEnterEvent>

+#include <QDragMoveEvent>

+#include <QDropEvent>

+

+namespace Swift {

+

+class ContactListDelegate;

+class ContactListModel;

+class SettingsProvider;

+class QtRemovableItemDelegate;

+

+class QtContactListWidget : public QTreeView {

+ Q_OBJECT

+public:

+ QtContactListWidget(QWidget* parent, SettingsProvider* settings);

+ virtual ~QtContactListWidget();

+

+ void setList(const std::vector<Contact>& list);

+ std::vector<Contact> getList() const;

+ void setMaximumNoOfContactsToOne(bool limited);

+

+public slots:

+ void updateContacts(const std::vector<Contact>& contactUpdates);

+

+signals:

+ void onListChanged(std::vector<Contact> list);

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

+

+private slots:

+ void handleListChanged(std::vector<Contact> list);

+

+private:

+ void handleSettingsChanged(const std::string&);

+

+private:

+ SettingsProvider* settings_;

+ ContactListModel* contactListModel_;

+ ContactListDelegate* contactListDelegate_;

+ QtRemovableItemDelegate* removableItemDelegate_;

+ bool limited_;

+};

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include <Swift/QtUI/UserSearch/QtSuggestingJIDInput.h>

+#include <Swift/QtUI/UserSearch/ContactListDelegate.h>

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

+#include <Swift/QtUI/QtUISettingConstants.h>

+#include <Swift/QtUI/UserSearch/ContactListModel.h>

+

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

+#include <boost/bind.hpp>

+

+#include <Swift/QtUI/QtSwiftUtil.h>

+

+#include <QAbstractItemView>

+#include <QApplication>

+#include <QDesktopWidget>

+#include <QKeyEvent>

+

+

+namespace Swift {

+

+QtSuggestingJIDInput::QtSuggestingJIDInput(QWidget* parent, SettingsProvider* settings) : QLineEdit(parent), settings_(settings), currentContact_(NULL) {

+ treeViewPopup_ = new QTreeView();

+ treeViewPopup_->setWindowFlags(Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint | Qt::X11BypassWindowManagerHint);

+ //treeViewPopup_->setAttribute(Qt::WA_ShowWithoutActivating);

+ treeViewPopup_->setAlternatingRowColors(true);

+ treeViewPopup_->setIndentation(0);

+ treeViewPopup_->setHeaderHidden(true);

+ treeViewPopup_->setExpandsOnDoubleClick(false);

+ treeViewPopup_->setItemsExpandable(false);

+ treeViewPopup_->setSelectionMode(QAbstractItemView::SingleSelection);

+ treeViewPopup_->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);

+ treeViewPopup_->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

+ QSizePolicy policy(treeViewPopup_->sizePolicy());

+ policy.setVerticalPolicy(QSizePolicy::Expanding);

+ treeViewPopup_->setSizePolicy(policy);

+ treeViewPopup_->hide();

+ treeViewPopup_->setFocusProxy(this);

+ connect(treeViewPopup_, SIGNAL(clicked(QModelIndex)), this, SLOT(handleClicked(QModelIndex)));

+ connect(treeViewPopup_, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(handleClicked(QModelIndex)));

+

+ contactListModel_ = new ContactListModel(false);

+ treeViewPopup_->setModel(contactListModel_);

+

+ contactListDelegate_ = new ContactListDelegate(settings->getSetting(QtUISettingConstants::COMPACT_ROSTER));

+ treeViewPopup_->setItemDelegate(contactListDelegate_);

+

+ settings_->onSettingChanged.connect(boost::bind(&QtSuggestingJIDInput::handleSettingsChanged, this, _1));

+}

+

+QtSuggestingJIDInput::~QtSuggestingJIDInput() {

+ settings_->onSettingChanged.disconnect(boost::bind(&QtSuggestingJIDInput::handleSettingsChanged, this, _1));

+ delete treeViewPopup_;

+}

+

+const Contact* QtSuggestingJIDInput::getContact() {

+ if (currentContact_ != NULL) {

+ return currentContact_;

+ } else {

+ if (!text().isEmpty()) {

+ JID jid(Q2PSTRING(text()));

+ if (jid.isValid()) {

+ manualContact_.name = jid.toString();

+ manualContact_.jid = jid;

+ return &manualContact_;

+ }

+ }

+ return NULL;

+ }

+}

+

+void QtSuggestingJIDInput::setSuggestions(const std::vector<Contact>& suggestions) {

+ contactListModel_->setList(suggestions);

+ positionPopup();

+ if (!suggestions.empty()) {

+ treeViewPopup_->setCurrentIndex(contactListModel_->index(0, 0));

+ showPopup();

+ } else {

+ currentContact_ = NULL;

+ }

+}

+

+void QtSuggestingJIDInput::keyPressEvent(QKeyEvent* event) {

+ if (event->key() == Qt::Key_Up) {

+ if (contactListModel_->rowCount() > 0) {

+ int row = treeViewPopup_->currentIndex().row();

+ row = (row + contactListModel_->rowCount() - 1) % contactListModel_->rowCount();

+ treeViewPopup_->setCurrentIndex(contactListModel_->index(row, 0));

+ }

+ } else if (event->key() == Qt::Key_Down) {

+ if (contactListModel_->rowCount() > 0) {

+ int row = treeViewPopup_->currentIndex().row();

+ row = (row + contactListModel_->rowCount() + 1) % contactListModel_->rowCount();

+ treeViewPopup_->setCurrentIndex(contactListModel_->index(row, 0));

+ }

+ } else if (event->key() == Qt::Key_Return && treeViewPopup_->isVisible()) {

+ QModelIndex index = treeViewPopup_->currentIndex();

+ if (!contactListModel_->getList().empty() && index.isValid()) {

+ currentContact_ = &contactListModel_->getList()[index.row()];

+ setText(P2QSTRING(currentContact_->jid.toString()));

+ hidePopup();

+ clearFocus();

+ } else {

+ currentContact_ = NULL;

+ }

+ editingDone();

+ } else {

+ QLineEdit::keyPressEvent(event);

+ }

+}

+

+void QtSuggestingJIDInput::handleApplicationFocusChanged(QWidget* /*old*/, QWidget* /*now*/) {

+ /* Using the now argument gives use the wrong widget. This is part of the code needed

+ to prevent stealing of focus when opening a the suggestion window. */

+ QWidget* now = qApp->focusWidget();

+ if (!now || (now != treeViewPopup_ && now != this && !now->isAncestorOf(this) && !now->isAncestorOf(treeViewPopup_) && !this->isAncestorOf(now) && !treeViewPopup_->isAncestorOf(now))) {

+ hidePopup();

+ }

+}

+

+void QtSuggestingJIDInput::handleSettingsChanged(const std::string& setting) {

+ if (setting == QtUISettingConstants::COMPACT_ROSTER.getKey()) {

+ contactListDelegate_->setCompact(settings_->getSetting(QtUISettingConstants::COMPACT_ROSTER));

+ }

+}

+

+void QtSuggestingJIDInput::handleClicked(const QModelIndex& index) {

+ if (index.isValid()) {

+ currentContact_ = &contactListModel_->getList()[index.row()];

+ setText(P2QSTRING(currentContact_->jid.toString()));

+ hidePopup();

+ }

+}

+

+void QtSuggestingJIDInput::positionPopup() {

+ QDesktopWidget* desktop = QApplication::desktop();

+ int screen = desktop->screenNumber(this);

+ QPoint point = mapToGlobal(QPoint(0, height()));

+ QRect geometry = desktop->availableGeometry(screen);

+ int x = point.x();

+ int y = point.y();

+ int width = this->width();

+ int height = 80;

+

+ int screenWidth = geometry.x() + geometry.width();

+ if (x + width > screenWidth) {

+ x = screenWidth - width;

+ }

+

+ height = treeViewPopup_->sizeHintForRow(0) * contactListModel_->rowCount();

+ height = height > 200 ? 200 : height;

+

+ int marginLeft;

+ int marginTop;

+ int marginRight;

+ int marginBottom;

+ treeViewPopup_->getContentsMargins(&marginLeft, &marginTop, &marginRight, &marginBottom);

+ height += marginTop + marginBottom;

+ width += marginLeft + marginRight;

+

+ treeViewPopup_->setGeometry(x, y, width, height);

+ treeViewPopup_->move(x, y);

+ treeViewPopup_->setMaximumWidth(width);

+}

+

+void QtSuggestingJIDInput::showPopup() {

+ treeViewPopup_->show();

+ activateWindow();

+ connect(qApp, SIGNAL(focusChanged(QWidget*, QWidget*)), this, SLOT(handleApplicationFocusChanged(QWidget*, QWidget*)), Qt::QueuedConnection);

+ setFocus();

+}

+

+void QtSuggestingJIDInput::hidePopup() {

+ disconnect(qApp, SIGNAL(focusChanged(QWidget*, QWidget*)), this, SLOT(handleApplicationFocusChanged(QWidget*, QWidget*)));

+ treeViewPopup_->hide();

+}

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <QLineEdit>

+#include <QTreeView>

+

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

+

+namespace Swift {

+

+class ContactListDelegate;

+class SettingsProvider;

+class ContactListModel;

+

+class QtSuggestingJIDInput : public QLineEdit {

+ Q_OBJECT

+ public:

+ QtSuggestingJIDInput(QWidget* parent, SettingsProvider* settings);

+ virtual ~QtSuggestingJIDInput();

+

+ const Contact* getContact();

+

+ void setSuggestions(const std::vector<Contact>& suggestions);

+

+ signals:

+ void editingDone();

+

+ protected:

+ virtual void keyPressEvent(QKeyEvent* event);

+

+ private:

+ void handleSettingsChanged(const std::string& setting);

+

+ private slots:

+ void handleClicked(const QModelIndex& index);

+ void handleApplicationFocusChanged(QWidget* old, QWidget* now);

+

+ private:

+ void positionPopup();

+ void showPopup();

+ void hidePopup();

+

+ private:

+ SettingsProvider* settings_;

+ ContactListModel* contactListModel_;

+ QTreeView* treeViewPopup_;

+ ContactListDelegate* contactListDelegate_;

+ Contact manualContact_;

+ const Contact* currentContact_;

+};

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#include "Swift/QtUI/UserSearch/QtUserSearchFirstMultiJIDPage.h"

+

+#include "Swift/QtUI/QtSwiftUtil.h"

+#include <Swift/QtUI/UserSearch/QtContactListWidget.h>

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

+#include <Swift/QtUI/UserSearch/QtSuggestingJIDInput.h>

+

+namespace Swift {

+

+QtUserSearchFirstMultiJIDPage::QtUserSearchFirstMultiJIDPage(UserSearchWindow::Type type, const QString& title, SettingsProvider* settings) {

+ setupUi(this);

+ setTitle(title);

+ QString introText = "";

+ switch (type) {

+ case UserSearchWindow::AddContact:

+ introText = tr("Add another user to your contact list");

+ break;

+ case UserSearchWindow::ChatToContact:

+ introText = tr("Chat to another user");

+ break;

+ case UserSearchWindow::InviteToChat:

+ introText = tr("Invite contact to chat");

+ break;

+ }

+

+ setSubTitle(QString(tr("%1. If you know their address you can enter it directly, or you can search for them.")).arg(introText));

+

+ contactList_ = new QtContactListWidget(this, settings);

+ horizontalLayout_5->addWidget(contactList_);

+

+ jid_ = new QtSuggestingJIDInput(this, settings);

+ horizontalLayout_6->insertWidget(0, jid_);

+

+ connect(contactList_, SIGNAL(onListChanged(std::vector<Contact>)), this, SLOT(emitCompletenessCheck()));

+ connect(jid_, SIGNAL(editingDone()), this, SLOT(handleEditingDone()));

+}

+

+bool QtUserSearchFirstMultiJIDPage::isComplete() const {

+ return !contactList_->getList().empty();

+}

+

+void QtUserSearchFirstMultiJIDPage::emitCompletenessCheck() {

+ emit completeChanged();

+}

+

+void QtUserSearchFirstMultiJIDPage::handleEditingDone() {

+ addContactButton_->setFocus();

+}

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <QWizardPage>

+

+#include <Swift/QtUI/UserSearch/ui_QtUserSearchFirstMultiJIDPage.h>

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

+

+namespace Swift {

+ class UserSearchModel;

+ class UserSearchDelegate;

+ class UserSearchResult;

+ class UIEventStream;

+ class QtContactListWidget;

+ class ContactSuggester;

+ class AvatarManager;

+ class VCardManager;

+ class SettingsProvider;

+ class QtSuggestingJIDInput;

+

+ class QtUserSearchFirstMultiJIDPage : public QWizardPage, public Ui::QtUserSearchFirstMultiJIDPage {

+ Q_OBJECT

+ public:

+ QtUserSearchFirstMultiJIDPage(UserSearchWindow::Type type, const QString& title, SettingsProvider* settings);

+ virtual bool isComplete() const;

+

+ public slots:

+ void emitCompletenessCheck();

+ void handleEditingDone();

+

+ public:

+ QtContactListWidget* contactList_;

+ QtSuggestingJIDInput* jid_;

+ };

+}

+<?xml version="1.0" encoding="UTF-8"?>

+<ui version="4.0">

+ <class>QtUserSearchFirstMultiJIDPage</class>

+ <widget class="QWizardPage" name="QtUserSearchFirstMultiJIDPage">

+ <property name="geometry">

+ <rect>

+ <x>0</x>

+ <y>0</y>

+ <width>477</width>

+ <height>500</height>

+ </rect>

+ </property>

+ <property name="windowTitle">

+ <string/>

+ </property>

+ <property name="title">

+ <string>Add a user</string>

+ </property>

+ <property name="subTitle">

+ <string>Add another user to your contact list. If you know their address you can add them directly, or you can search for them.</string>

+ </property>

+ <layout class="QVBoxLayout" name="verticalLayout">

+ <item>

+ <widget class="QLabel" name="howLabel_">

+ <property name="text">

+ <string/>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <layout class="QHBoxLayout" name="horizontalLayout_5"/>

+ </item>

+ <item>

+ <widget class="QGroupBox" name="groupBox">

+ <property name="minimumSize">

+ <size>

+ <width>0</width>

+ <height>0</height>

+ </size>

+ </property>

+ <property name="title">

+ <string>Choose another contact</string>

+ </property>

+ <property name="flat">

+ <bool>false</bool>

+ </property>

+ <property name="checkable">

+ <bool>false</bool>

+ </property>

+ <layout class="QVBoxLayout" name="verticalLayout_3">

+ <property name="spacing">

+ <number>-1</number>

+ </property>

+ <property name="margin">

+ <number>6</number>

+ </property>

+ <item>

+ <layout class="QHBoxLayout" name="horizontalLayout_6" stretch="0">

+ <property name="spacing">

+ <number>-1</number>

+ </property>

+ <item>

+ <widget class="QPushButton" name="addContactButton_">

+ <property name="autoFillBackground">

+ <bool>false</bool>

+ </property>

+ <property name="text">

+ <string>Add Contact</string>

+ </property>

+ <property name="default">

+ <bool>false</bool>

+ </property>

+ <property name="flat">

+ <bool>false</bool>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ <item>

+ <widget class="Line" name="line">

+ <property name="orientation">

+ <enum>Qt::Horizontal</enum>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <layout class="QHBoxLayout" name="horizontalLayout_3">

+ <item>

+ <widget class="QRadioButton" name="byLocalSearch_">

+ <property name="text">

+ <string>I'd like to search my server</string>

+ </property>

+ <property name="autoExclusive">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <spacer name="horizontalSpacer">

+ <property name="orientation">

+ <enum>Qt::Horizontal</enum>

+ </property>

+ <property name="sizeHint" stdset="0">

+ <size>

+ <width>40</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ </layout>

+ </item>

+ <item>

+ <layout class="QHBoxLayout" name="horizontalLayout">

+ <item>

+ <widget class="QRadioButton" name="byRemoteSearch_">

+ <property name="text">

+ <string>I'd like to search another server:</string>

+ </property>

+ <property name="autoExclusive">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QComboBox" name="service_">

+ <property name="sizePolicy">

+ <sizepolicy hsizetype="Expanding" vsizetype="Fixed">

+ <horstretch>0</horstretch>

+ <verstretch>0</verstretch>

+ </sizepolicy>

+ </property>

+ <property name="editable">

+ <bool>true</bool>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ <item>

+ <layout class="QHBoxLayout" name="horizontalLayout_2">

+ <item>

+ <spacer name="horizontalSpacer_2">

+ <property name="orientation">

+ <enum>Qt::Horizontal</enum>

+ </property>

+ <property name="sizeHint" stdset="0">

+ <size>

+ <width>40</width>

+ <height>20</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ <item>

+ <widget class="QPushButton" name="addViaSearchButton_">

+ <property name="text">

+ <string>Add via Search</string>

+ </property>

+ </widget>

+ </item>

+ </layout>

+ </item>

+ </layout>

+ </widget>

+ </item>

+ <item>

+ <layout class="QHBoxLayout" name="horizontalLayout_4">

+ <item>

+ <widget class="QLabel" name="label">

+ <property name="text">

+ <string>Reason:</string>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <widget class="QLineEdit" name="reason_"/>

+ </item>

+ </layout>

+ </item>

+ <item>

+ <spacer name="verticalSpacer_2">

+ <property name="orientation">

+ <enum>Qt::Vertical</enum>

+ </property>

+ <property name="sizeHint" stdset="0">

+ <size>

+ <width>20</width>

+ <height>77</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ <item>

+ <widget class="QLabel" name="errorLabel_">

+ <property name="text">

+ <string/>

+ </property>

+ <property name="alignment">

+ <set>Qt::AlignCenter</set>

+ </property>

+ </widget>

+ </item>

+ <item>

+ <spacer name="verticalSpacer">

+ <property name="orientation">

+ <enum>Qt::Vertical</enum>

+ </property>

+ <property name="sizeHint" stdset="0">

+ <size>

+ <width>20</width>

+ <height>40</height>

+ </size>

+ </property>

+ </spacer>

+ </item>

+ </layout>

+ </widget>

+ <resources/>

+ <connections/>

+</ui>

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

+

+QtUserSearchFirstPage::QtUserSearchFirstPage(UserSearchWindow::Type type, const QString& title, SettingsProvider* settings) {

+ jid_ = new QtSuggestingJIDInput(this, settings);

+ horizontalLayout_2->addWidget(jid_);

+ setTabOrder(byJID_, jid_);

+ setTabOrder(jid_, byLocalSearch_);

+ setTabOrder(byLocalSearch_, byRemoteSearch_);

+#include <Swift/QtUI/UserSearch/QtSuggestingJIDInput.h>

+

+ QtUserSearchFirstPage(UserSearchWindow::Type type, const QString& title, SettingsProvider* settings);

+ public:

+ QtSuggestingJIDInput* jid_;

+ <property name="autoExclusive">

+ <bool>true</bool>

+ </property>

+ <property name="autoExclusive">

+ <bool>true</bool>

+ </property>

+ <property name="autoExclusive">

+ <bool>true</bool>

+ </property>

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

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

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

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

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

+#include <Swift/QtUI/UserSearch/UserSearchModel.h>

+#include <Swift/QtUI/UserSearch/UserSearchDelegate.h>

+#include <Swift/QtUI/QtSwiftUtil.h>

+#include <Swift/QtUI/QtFormResultItemModel.h>

+#include <Swift/QtUI/UserSearch/QtUserSearchFirstPage.h>

+#include <Swift/QtUI/UserSearch/QtUserSearchFirstMultiJIDPage.h>

+#include <Swift/QtUI/UserSearch/QtUserSearchFieldsPage.h>

+#include <Swift/QtUI/UserSearch/QtUserSearchResultsPage.h>

+#include <Swift/QtUI/UserSearch/QtUserSearchDetailsPage.h>

+#include <Swift/QtUI/UserSearch/QtContactListWidget.h>

+

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

+QtUserSearchWindow::QtUserSearchWindow(UIEventStream* eventStream, UserSearchWindow::Type type, const std::set<std::string>& groups, SettingsProvider* settingsProvider) : eventStream_(eventStream), type_(type), model_(NULL), settings_(settingsProvider), searchNext_(false), supportsImpromptu_(false) {

+ QString title;

+ switch(type) {

+ case AddContact:

+ title = tr("Add Contact");

+ break;

+ case ChatToContact:

+ title = tr("Chat to Users");

+ break;

+ case InviteToChat:

+ title = tr("Add Users to Chat");

+ break;

+ }

+ setFirstPage(title);

+ setSecondPage();

+ setThirdPage();

+ searchNext_ = false;

+ if (page == 1 && lastPage_ == 3) {

+ addSearchedJIDToList(getContactJID());

+ setSecondPage();

+ }

+ else if (page == 2 && lastPage_ == 1) {

+ setThirdPage();

+ JID server = getServerToSearch();

+

+ if (type_ == AddContact) {

+ bool remote = firstPage_->byRemoteSearch_->isChecked();

+ firstPage_->byRemoteSearch_->setChecked(remote);

+ firstPage_->service_->setEditText(P2QSTRING(server.toString()));

+ } else {

+ bool remote = firstMultiJIDPage_->byRemoteSearch_->isChecked();

+ setFirstPage();

+ firstMultiJIDPage_->byRemoteSearch_->setChecked(remote);

+ firstMultiJIDPage_->service_->setEditText(P2QSTRING(server.toString()));

+ }

+ if (type_ == AddContact) {

+ return firstPage_->byRemoteSearch_->isChecked() ? JID(Q2PSTRING(firstPage_->service_->currentText().trimmed())) : myServer_;

+ } else {

+ return firstMultiJIDPage_->byRemoteSearch_->isChecked() ? JID(Q2PSTRING(firstMultiJIDPage_->service_->currentText().trimmed())) : myServer_;

+ }

+ JID jid;

+ std::vector<JID> jids;

+ switch(type_) {

+ case AddContact:

+ jid = getContactJID();

+ eventStream_->send(boost::make_shared<AddContactUIEvent>(jid, detailsPage_->getName(), detailsPage_->getSelectedGroups()));

+ break;

+ case ChatToContact:

+ if (contactVector_.size() == 1) {

+ boost::shared_ptr<UIEvent> event(new RequestChatUIEvent(contactVector_[0].jid));

+ eventStream_->send(event);

+ break;

+ }

+ foreach(const Contact& contact, contactVector_) {

+ jids.push_back(contact.jid);

+ }

+

+ eventStream_->send(boost::make_shared<CreateImpromptuMUCUIEvent>(jids, JID(), Q2PSTRING(firstMultiJIDPage_->reason_->text())));

+ break;

+ case InviteToChat:

+ foreach(const Contact& contact, contactVector_) {

+ jids.push_back(contact.jid);

+ }

+ eventStream_->send(boost::make_shared<InviteToMUCUIEvent>(roomJID_, jids, Q2PSTRING(firstMultiJIDPage_->reason_->text())));

+ break;

+}

+

+void QtUserSearchWindow::handleContactSuggestionRequested(const QString& text) {

+ std::string stdText = Q2PSTRING(text);

+ onContactSuggestionsRequested(stdText);

+}

+

+void QtUserSearchWindow::addContact() {

+ if (firstMultiJIDPage_->jid_->getContact() != 0) {

+ Contact contact = *(firstMultiJIDPage_->jid_->getContact());

+ contactVector_.push_back(contact);

+ }

+ firstMultiJIDPage_->contactList_->setList(contactVector_);

+ firstMultiJIDPage_->emitCompletenessCheck();

+ if (type_ == ChatToContact) {

+ firstMultiJIDPage_->groupBox->setEnabled(supportsImpromptu_ ? 1 : (contactVector_.size() < 1));

+ if (type_ == AddContact) {

+ switch (currentId()) {

+ case 1: return firstPage_->byJID_->isChecked() ? (type_ == AddContact ? 4 : -1) : 2;

+ case 2: return 3;

+ case 3: return type_ == AddContact ? 4 : -1;

+ case 4: return -1;

+ default: return -1;

+ }

+ } else {

+ switch (currentId()) {

+ case 1: return searchNext_ ? 2 : -1;

+ case 2: return 3;

+ case 3: return 1;

+ case 4: return -1;

+ default: return -1;

+ }

+

+ bool useSearchResult;

+ if (type_ == AddContact) {

+ useSearchResult = !firstPage_->byJID_->isChecked();

+ } else {

+ useSearchResult = true;

+ }

+

+ if (useSearchResult) {

+void QtUserSearchWindow::addSearchedJIDToList(const JID& jid) {

+ Contact contact(jid, jid.toString(), StatusShow::None, "");

+ contactVector_.push_back(contact);

+ firstMultiJIDPage_->contactList_->setList(contactVector_);

+ firstMultiJIDPage_->emitCompletenessCheck();

+ if (type_ == ChatToContact) {

+ firstMultiJIDPage_->groupBox->setEnabled(supportsImpromptu_ ? 1 : (contactVector_.size() < 1));

+ }

+}

+

+ if (type_ == AddContact) {

+ firstPage_->service_->clear();

+ foreach (JID jid, services) {

+ firstPage_->service_->addItem(P2QSTRING(jid.toString()));

+ }

+ firstPage_->service_->clearEditText();

+ } else {

+ firstMultiJIDPage_->service_->clear();

+ foreach (JID jid, services) {

+ firstMultiJIDPage_->service_->addItem(P2QSTRING(jid.toString()));

+ }

+ firstMultiJIDPage_->service_->clearEditText();

+void QtUserSearchWindow::setContactSuggestions(const std::vector<Contact>& suggestions) {

+ if (type_ == AddContact) {

+ firstPage_->jid_->setSuggestions(suggestions);

+ } else {

+ firstMultiJIDPage_->jid_->setSuggestions(suggestions);

+ }

+}

+

+void QtUserSearchWindow::setJIDs(const std::vector<JID> &jids) {

+ foreach(JID jid, jids) {

+ addSearchedJIDToList(jid);

+ }

+ onJIDUpdateRequested(jids);

+}

+

+void QtUserSearchWindow::setRoomJID(const JID& roomJID) {

+ roomJID_ = roomJID;

+}

+

+std::string QtUserSearchWindow::getReason() const {

+ return Q2PSTRING(firstMultiJIDPage_->reason_->text());

+}

+

+std::vector<JID> QtUserSearchWindow::getJIDs() const {

+ std::vector<JID> jids;

+ foreach (const Contact& contact, contactVector_) {

+ jids.push_back(contact.jid);

+ }

+ return jids;

+}

+

+void QtUserSearchWindow::setCanStartImpromptuChats(bool supportsImpromptu) {

+ supportsImpromptu_ = supportsImpromptu;

+ if (type_ == ChatToContact) {

+ firstMultiJIDPage_->contactList_->setMaximumNoOfContactsToOne(!supportsImpromptu_);

+ }

+}

+

+void QtUserSearchWindow::updateContacts(const std::vector<Contact>& contacts) {

+ if (type_ != AddContact) {

+ firstMultiJIDPage_->contactList_->updateContacts(contacts);

+ }

+}

+

+void QtUserSearchWindow::handleAddViaSearch() {

+ searchNext_ = true;

+ next();

+}

+

+void QtUserSearchWindow::handleListChanged(std::vector<Contact> list) {

+ contactVector_ = list;

+ if (type_ == ChatToContact) {

+ firstMultiJIDPage_->groupBox->setEnabled(supportsImpromptu_ ? 1 : (contactVector_.size() < 1));

+ }

+}

+

+void QtUserSearchWindow::handleJIDsAdded(std::vector<JID> jids) {

+ onJIDUpdateRequested(jids);

+}

+

+void QtUserSearchWindow::setFirstPage(QString title) {

+ if (page(1) != 0) {

+ removePage(1);

+ }

+ if (type_ == AddContact) {

+ firstPage_ = new QtUserSearchFirstPage(type_, title.isEmpty() ? firstPage_->title() : title, settings_);

+ connect(firstPage_->jid_, SIGNAL(textEdited(QString)), this, SLOT(handleContactSuggestionRequested(QString)));

+ connect(firstPage_->byJID_, SIGNAL(toggled(bool)), this, SLOT(handleFirstPageRadioChange()));

+ connect(firstPage_->byLocalSearch_, SIGNAL(toggled(bool)), this, SLOT(handleFirstPageRadioChange()));

+ connect(firstPage_->byRemoteSearch_, SIGNAL(toggled(bool)), this, SLOT(handleFirstPageRadioChange()));

+#if QT_VERSION >= 0x040700

+ firstPage_->jid_->setPlaceholderText(tr("alice@wonderland.lit"));

+#endif

+ firstPage_->service_->setEnabled(false);

+ setPage(1, firstPage_);

+ } else {

+ firstMultiJIDPage_ = new QtUserSearchFirstMultiJIDPage(type_, title.isEmpty() ? firstMultiJIDPage_->title() : title, settings_);

+ connect(firstMultiJIDPage_->addContactButton_, SIGNAL(clicked()), this, SLOT(addContact()));

+ connect(firstMultiJIDPage_->jid_, SIGNAL(textEdited(QString)), this, SLOT(handleContactSuggestionRequested(QString)));

+ connect(firstMultiJIDPage_->addViaSearchButton_, SIGNAL(clicked()), this, SLOT(handleAddViaSearch()));

+ connect(firstMultiJIDPage_->contactList_, SIGNAL(onListChanged(std::vector<Contact>)), this, SLOT(handleListChanged(std::vector<Contact>)));

+ connect(firstMultiJIDPage_->contactList_, SIGNAL(onJIDsAdded(std::vector<JID>)), this, SLOT(handleJIDsAdded(std::vector<JID>)));

+ setPage(1, firstMultiJIDPage_);

+ }

+}

+

+void QtUserSearchWindow::setSecondPage() {

+ if (page(2) != 0) {

+ removePage(2);

+ }

+ fieldsPage_ = new QtUserSearchFieldsPage();

+ fieldsPage_->fetchingThrobber_->setMovie(new QMovie(":/icons/throbber.gif", QByteArray(), this));

+ fieldsPage_->fetchingThrobber_->movie()->stop();

+ setPage(2, fieldsPage_);

+}

+

+void QtUserSearchWindow::setThirdPage() {

+ if (page(3) != 0) {

+ removePage(3);

+ }

+ resultsPage_ = new QtUserSearchResultsPage();

+

+#ifdef SWIFT_PLATFORM_MACOSX

+ resultsPage_->results_->setAlternatingRowColors(true);

+#endif

+ if (type_ == AddContact) {

+ connect(resultsPage_, SIGNAL(onUserTriggersContinue()), this, SLOT(next()));

+ }

+ else {

+ connect(resultsPage_, SIGNAL(onUserTriggersContinue()), this, SLOT(next()));

+ }

+ setPage(3, resultsPage_);

+}

+

+ firstPage_->errorLabel_->setVisible(false);

+ firstPage_->howLabel_->setText(howText);

+ firstPage_->byJID_->setChecked(true);

+ handleFirstPageRadioChange();

+ } else {

+ contactVector_.clear();

+ firstMultiJIDPage_->contactList_->setList(contactVector_);

+ firstMultiJIDPage_->errorLabel_->setVisible(false);

+ if (type_ == ChatToContact) {

+ howText = QString(tr("Who would you like to chat to?"));

+ } else if (type_ == InviteToChat) {

+ howText = QString(tr("Who do you want to invite to the chat?"));

+ }

+ firstMultiJIDPage_->howLabel_->setText(howText);

+ if (type_ == AddContact) {

+ firstPage_->errorLabel_->hide();

+ } else {

+ firstMultiJIDPage_->errorLabel_->hide();

+ }

+ if (type_ == AddContact) {

+ firstPage_->errorLabel_->setText(QString("<font color='red'>%1</font>").arg(error));

+ firstPage_->errorLabel_->show();

+ } else {

+ firstMultiJIDPage_->errorLabel_->setText(QString("<font color='red'>%1</font>").arg(error));

+ firstMultiJIDPage_->errorLabel_->show();

+ }

+ class QtUserSearchFirstMultiJIDPage;

+ class SettingsProvider;

+ QtUserSearchWindow(UIEventStream* eventStream, UserSearchWindow::Type type, const std::set<std::string>& groups, SettingsProvider* settingsProvider);

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

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

+ virtual void setRoomJID(const JID &roomJID);

+ virtual std::string getReason() const;

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

+ virtual void setCanStartImpromptuChats(bool supportsImpromptu);

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

+

+ void handleContactSuggestionRequested(const QString& text);

+ void addContact();

+ void handleAddViaSearch();

+ void handleListChanged(std::vector<Contact> list);

+ void handleJIDsAdded(std::vector<JID> jids);

+

+ private:

+ void setFirstPage(QString title = "");

+ void setSecondPage();

+ void setThirdPage();

+

+ void addSearchedJIDToList(const JID& jid);

+ QtUserSearchFirstMultiJIDPage* firstMultiJIDPage_;

+ JID roomJID_;

+ std::vector<Contact> contactVector_;

+ SettingsProvider* settings_;

+ bool searchNext_;

+ bool supportsImpromptu_;

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

+#include <Swiften/StringCodecs/Hexify.h>

+ vcardStorage = new VCardMemoryStorage(crypto.get());

+ avatarStorage->setAvatarForJID(user1, avatar1Hash);

+

+ VCardMemoryStorage* vcardStorage;

+ onWalkAborted();

+ /** Emitted when walking is aborted. */

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

+

+ MUCInvitationPayload() : continuation_(false), impromptu_(false) {

+ void setIsImpromptu(bool b) {

+ impromptu_ = b;

+ }

+

+ bool getIsImpromptu() const {

+ return impromptu_;

+ }

+

+ bool impromptu_;

+MUC::MUC(StanzaChannel* stanzaChannel, IQRouter* iqRouter, DirectedPresenceSender* presenceSender, const JID &muc, MUCRegistry* mucRegistry) : ownMUCJID(muc), stanzaChannel(stanzaChannel), iqRouter_(iqRouter), presenceSender(presenceSender), mucRegistry(mucRegistry), createAsReservedIfNew(false), unlocking(false), isUnlocked_(false) {

+std::map<std::string, MUCOccupant> MUC::getOccupants() const {

+ return occupants;

+}

+

+ isUnlocked_ = false;

+ MUCOccupant occupant = i->second;

+ onOccupantLeft(occupant, type, "");

+ bool isLocked = false;

+ isLocked = true;

+ if (!isLocked && !isUnlocked_ && (presence->getFrom() == ownMUCJID)) {

+ isUnlocked_ = true;

+ onUnlocked();

+ }

+ isUnlocked_ = true;

+ onUnlocked();

+void MUC::invitePerson(const JID& person, const std::string& reason, bool isImpromptu, bool isReuseChat) {

+ invite->setIsImpromptu(isImpromptu);

+ invite->setIsContinuation(isReuseChat);

+ /**

+ * Returns if the room is unlocked and other people can join the room.

+ * @return True if joinable by others; false otherwise.

+ */

+ bool isUnlocked() const {

+ return isUnlocked_;

+ }

+

+ std::map<std::string, MUCOccupant> getOccupants() const;

+ void invitePerson(const JID& person, const std::string& reason = "", bool isImpromptu = false, bool isReuseChat = false);

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

+ bool isUnlocked_;

+ invite->setIsImpromptu(root->getChild("impromptu", "http://swift.im/impromptu") ? true : false);

+ if (payload->getIsImpromptu()) {

+ mucElement.addNode(boost::make_shared<XMLElement>("impromptu", "http://swift.im/impromptu"));

+ }