+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+/*

+ * Copyright (c) 2014 Kevin Smith and Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.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()) {

+ return false; /* always ask the user for normal MUC invites */

+ }

+

+ if (invite->getIsContinuation()) {

+ return true;

+ }

+

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

+ return false;

+ }

+ }

+

+ private:

+ JID domain_;

+ XMPPRoster* roster_;

+ SettingsProvider* settings_;

+ };

+}

+ * Copyright (c) 2010-2014 Kevin Smith

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

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

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

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

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

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

+#include <Swiften/Client/ClientBlockListManager.h>

+#include <Swiften/Client/NickResolver.h>

+#include <Swiften/Disco/EntityCapsProvider.h>

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

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

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

+#include <Swiften/FileTransfer/FileTransferManager.h>

+

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

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

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

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

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

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

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

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

+#include <Swift/Controllers/Chat/ChatMessageParser.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, boost::shared_ptr<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) {

+ Idle::ref idle;

+ if (theirPresence && (idle = theirPresence->getPayload<Idle>())) {

+ startMessage += str(format(QT_TRANSLATE_NOOP("", ", who has been idle since %1%")) % dateTimeToLocalString(idle->getSince()));

+ }

+ chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(startMessage), ChatWindow::DefaultDirection);

+ chatWindow_->onWhiteboardSessionAccept.connect(boost::bind(&ChatController::handleWhiteboardSessionAccept, this));

+ chatWindow_->onWhiteboardSessionCancel.connect(boost::bind(&ChatController::handleWhiteboardSessionCancel, this));

+ chatWindow_->onWhiteboardWindowShow.connect(boost::bind(&ChatController::handleWhiteboardWindowShow, this));

+ chatWindow_->onBlockUserRequest.connect(boost::bind(&ChatController::handleBlockUserRequest, this));

+ chatWindow_->onUnblockUserRequest.connect(boost::bind(&ChatController::handleUnblockUserRequest, this));

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

+ chatWindow_->onClosed.connect(boost::bind(&ChatController::handleWindowClosed, this));

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

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

+JID ChatController::getBaseJID() {

+ return isInMUC_ ? toJID_ : ChatControllerBase::getBaseJID();

+}

+

+ if (FileTransferManager::isSupportedBy(disco)) {

+ chatWindow_->setFileTransferEnabled(ChatWindow::Yes);

+ } else {

+ chatWindow_->setFileTransferEnabled(ChatWindow::No);

+ }

+void ChatController::setAvailableServerFeatures(boost::shared_ptr<DiscoInfo> info) {

+ ChatControllerBase::setAvailableServerFeatures(info);

+ if (iqRouter_->isAvailable() && info->hasFeature(DiscoInfo::BlockingCommandFeature)) {

+ boost::shared_ptr<BlockList> blockList = clientBlockListManager_->getBlockList();

+

+ blockingOnStateChangedConnection_ = blockList->onStateChanged.connect(boost::bind(&ChatController::handleBlockingStateChanged, this));

+ blockingOnItemAddedConnection_ = blockList->onItemAdded.connect(boost::bind(&ChatController::handleBlockingStateChanged, this));

+ blockingOnItemRemovedConnection_ = blockList->onItemRemoved.connect(boost::bind(&ChatController::handleBlockingStateChanged, this));

+

+ handleBlockingStateChanged();

+ }

+}

+

+ chatStateNotifier_->receivedMessageFromContact(!!message->getPayload<ChatState>());

+ // handle XEP-0184 Message Receipts

+ // incomming receipts

+ // incomming errors in response to send out receipts

+ } else if (message->getPayload<DeliveryReceiptRequest>() && (message->getType() == Message::Error)) {

+ if (requestedReceipts_.find(message->getID()) != requestedReceipts_.end()) {

+ chatWindow_->setMessageReceiptState(requestedReceipts_[message->getID()], ChatWindow::ReceiptFailed);

+ requestedReceipts_.erase(message->getID());

+ }

+ // incoming receipt requests

+void ChatController::postHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent, const HighlightAction& highlight) {

+ if (!messageEvent->getConcluded()) {

+ highlighter_->handleHighlightAction(highlight);

+ }

+ boost::optional<ChatWindow::AlertID> newDeliverReceiptAlert;

+ newDeliverReceiptAlert = chatWindow_->addAlert(QT_TRANSLATE_NOOP("", "This chat doesn't support delivery receipts."));

+ newDeliverReceiptAlert = chatWindow_->addAlert(QT_TRANSLATE_NOOP("", "This chat may not support delivery receipts. You might not receive delivery receipts for the messages you sent."));

+ } else {

+ if (deliveryReceiptAlert_) {

+ chatWindow_->removeAlert(*deliveryReceiptAlert_);

+ deliveryReceiptAlert_.reset();

+ }

+ }

+ if (newDeliverReceiptAlert) {

+ if (deliveryReceiptAlert_) {

+ chatWindow_->removeAlert(*deliveryReceiptAlert_);

+ }

+ deliveryReceiptAlert_ = newDeliverReceiptAlert;

+ }

+}

+

+void ChatController::handleBlockingStateChanged() {

+ boost::shared_ptr<BlockList> blockList = clientBlockListManager_->getBlockList();

+ if (blockList->getState() == BlockList::Available) {

+ if (isInMUC_ ? blockList->isBlocked(toJID_) : blockList->isBlocked(toJID_.toBare())) {

+ if (!blockedContactAlert_) {

+ blockedContactAlert_ = chatWindow_->addAlert(QT_TRANSLATE_NOOP("", "You've currently blocked this contact. To continue your conversation you have to unblock the contact first."));

+ }

+ chatWindow_->setInputEnabled(false);

+ chatWindow_->setBlockingState(ChatWindow::IsBlocked);

+

+ // disconnect typing events to prevent chat state notifciations to blocked contacts

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

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

+ } else {

+ if (blockedContactAlert_) {

+ chatWindow_->removeAlert(*blockedContactAlert_);

+ blockedContactAlert_.reset();

+ }

+ chatWindow_->setInputEnabled(true);

+ chatWindow_->setBlockingState(ChatWindow::IsUnblocked);

+

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

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

+ }

+ }

+}

+

+void ChatController::handleBlockUserRequest() {

+ if (isInMUC_) {

+ eventStream_->send(boost::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Blocked, toJID_));

+ eventStream_->send(boost::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Blocked, toJID_.toBare()));

+ }

+}

+

+void ChatController::handleUnblockUserRequest() {

+ if (isInMUC_) {

+ eventStream_->send(boost::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Unblocked, toJID_));

+ } else {

+ eventStream_->send(boost::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Unblocked, toJID_.toBare()));

+ }

+}

+

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

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

+ eventStream_->send(event);

+}

+

+void ChatController::handleWindowClosed() {

+ onWindowClosed();

+}

+

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

+

+ replaceMessage(body, myLastMessageUIID_, true, boost::posix_time::microsec_clock::universal_time(), HighlightAction());

+ myLastMessageUIID_ = addMessage(body, QT_TRANSLATE_NOOP("", "me"), true, labelsEnabled_ ? chatWindow_->getSelectedSecurityLabel().getLabel() : boost::shared_ptr<SecurityLabel>(), avatarManager_->getAvatarPath(selfJID_), boost::posix_time::microsec_clock::universal_time(), HighlightAction());

+void ChatController::handleWhiteboardSessionRequest(bool senderIsSelf) {

+ lastWbID_ = chatWindow_->addWhiteboardRequest(senderIsSelf);

+}

+

+void ChatController::handleWhiteboardStateChange(const ChatWindow::WhiteboardSessionState state) {

+ chatWindow_->setWhiteboardSessionStatus(lastWbID_, state);

+}

+

+ SWIFT_LOG(debug) << "handleFileTransferAccept(" << id << ", " << filename << ")" << std::endl;

+void ChatController::handleWhiteboardSessionAccept() {

+ eventStream_->send(boost::make_shared<AcceptWhiteboardSessionUIEvent>(toJID_));

+}

+

+void ChatController::handleWhiteboardSessionCancel() {

+ eventStream_->send(boost::make_shared<CancelWhiteboardSessionUIEvent>(toJID_));

+}

+

+void ChatController::handleWhiteboardWindowShow() {

+ eventStream_->send(boost::make_shared<ShowWhiteboardUIEvent>(toJID_));

+}

+

+ Idle::ref idle;

+ if ((idle = presence->getPayload<Idle>())) {

+ response += str(format(QT_TRANSLATE_NOOP("", " and has been idle since %1%")) % dateTimeToLocalString(idle->getSince()));

+ }

+

+ chatWindow_->replaceLastMessage(chatMessageParser_->parseMessageBody(newStatusChangeString), ChatWindow::UpdateTimestamp);

+ chatWindow_->addPresenceMessage(chatMessageParser_->parseMessageBody(newStatusChangeString), ChatWindow::DefaultDirection);

+void ChatController::logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool /* isIncoming */) {

+ HistoryMessage::Type type;

+ if (mucRegistry_->isMUC(fromJID.toBare()) || mucRegistry_->isMUC(toJID.toBare())) {

+ type = HistoryMessage::PrivateMessage;

+ }

+ else {

+ type = HistoryMessage::Chat;

+ }

+

+ if (historyController_) {

+ historyController_->addMessage(message, fromJID, toJID, type, timeStamp);

+ }

+}

+

+ChatWindow* ChatController::detachChatWindow() {

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

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

+ return ChatControllerBase::detachChatWindow();

+}

+

+ * Copyright (c) 2010-2014 Kevin Smith

+ class HistoryController;

+ class HighlightManager;

+ class ClientBlockListManager;

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

+ virtual void setAvailableServerFeatures(boost::shared_ptr<DiscoInfo> info);

+ virtual void handleWhiteboardSessionRequest(bool senderIsSelf);

+ virtual void handleWhiteboardStateChange(const ChatWindow::WhiteboardSessionState state);

+ virtual ChatWindow* detachChatWindow();

+ JID getBaseJID();

+ void logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming);

+ void postHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent, const HighlightAction&);

+ void handleWhiteboardSessionAccept();

+ void handleWhiteboardSessionCancel();

+ void handleWhiteboardWindowShow();

+

+ void handleBlockingStateChanged();

+ void handleBlockUserRequest();

+ void handleUnblockUserRequest();

+

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

+

+ void handleWindowClosed();

+

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

+

+ std::string lastWbID_;

+

+ ClientBlockListManager* clientBlockListManager_;

+ boost::bsignals::scoped_connection blockingOnStateChangedConnection_;

+ boost::bsignals::scoped_connection blockingOnItemAddedConnection_;

+ boost::bsignals::scoped_connection blockingOnItemRemovedConnection_;

+

+ boost::optional<ChatWindow::AlertID> deliveryReceiptAlert_;

+ boost::optional<ChatWindow::AlertID> blockedContactAlert_;

+ * Copyright (c) 2010-2014 Kevin Smith

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

+#include <boost/numeric/conversion/cast.hpp>

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

+

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

+#include <Swift/Controllers/XMPPEvents/EventController.h>

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

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

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

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

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

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

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

+#include <Swift/Controllers/Chat/ChatMessageParser.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, boost::shared_ptr<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) {

+ highlighter_ = highlightManager->createHighlighter();

+ delete highlighter_;

+ChatWindow* ChatControllerBase::detachChatWindow() {

+ ChatWindow* chatWindow = chatWindow_;

+ chatWindow_ = NULL;

+ return chatWindow;

+}

+

+void ChatControllerBase::setCanStartImpromptuChats(bool supportsImpromptu) {

+ if (chatWindow_) {

+ chatWindow_->setCanInitiateImpromptuChats(supportsImpromptu);

+ }

+}

+

+ int millisecondsUntilMidnight = boost::numeric_cast<int>((midnight - now).total_milliseconds());

+ chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "The day is now %1%")) % std::string(boost::posix_time::to_iso_extended_string(now)).substr(0,10))), ChatWindow::DefaultDirection);

+JID ChatControllerBase::getBaseJID() {

+ return JID(toJID_.toBare());

+}

+

+ GetSecurityLabelsCatalogRequest::ref request = GetSecurityLabelsCatalogRequest::create(getBaseJID(), iqRouter_);

+ return boost::numeric_cast<int>(targetedUnreadMessages_.size());

+ if (!isCorrectionMessage) {

+ lastLabel_ = chatWindow_->getSelectedSecurityLabel();

+ }

+ SecurityLabelsCatalog::Item labelItem = lastLabel_;

+

+ if (useDelayForLatency_) {

+

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

+ logMessage(body, selfJID_, toJID_, now, false);

+#endif

+ if (catalog && !error) {

+bool ChatControllerBase::hasOpenWindow() const {

+ return chatWindow_ && chatWindow_->isVisible();

+}

+

+std::string ChatControllerBase::addMessage(const std::string& message, const std::string& senderName, bool senderIsSelf, const boost::shared_ptr<SecurityLabel> label, const boost::filesystem::path& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) {

+ return chatWindow_->addAction(chatMessageParser_->parseMessageBody(String::getSplittedAtFirst(message, ' ').second), senderName, senderIsSelf, label, pathToString(avatarPath), time, highlight);

+ return chatWindow_->addMessage(chatMessageParser_->parseMessageBody(message,highlighter_->getNick(),senderIsSelf), senderName, senderIsSelf, label, pathToString(avatarPath), time, highlight);

+void ChatControllerBase::replaceMessage(const std::string& message, const std::string& id, bool senderIsSelf, const boost::posix_time::ptime& time, const HighlightAction& highlight) {

+ chatWindow_->replaceWithAction(chatMessageParser_->parseMessageBody(String::getSplittedAtFirst(message, ' ').second), id, time, highlight);

+ chatWindow_->replaceMessage(chatMessageParser_->parseMessageBody(message,highlighter_->getNick(),senderIsSelf), id, time, highlight);

+ HighlightAction highlight;

+ if (!message->getTo().getResource().empty()) {

+ chatWindow_->addErrorMessage(chatMessageParser_->parseMessageBody(errorMessage));

+ }

+ chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(std::string(s.str())), ChatWindow::DefaultDirection);

+ // Highlight

+ if (!isIncomingMessageFromMe(message)) {

+ highlight = highlighter_->findAction(body, senderDisplayNameFromMessage(from));

+ }

+

+ replaceMessage(body, lastMessagesUIID_[from], isIncomingMessageFromMe(message), timeStamp, highlight);

+ lastMessagesUIID_[from] = addMessage(body, senderDisplayNameFromMessage(from), isIncomingMessageFromMe(message), label, avatarManager_->getAvatarPath(from), timeStamp, highlight);

+

+ logMessage(body, from, selfJID_, timeStamp, true);

+ chatWindow_->setUnreadMessageCount(boost::numeric_cast<int>(unreadMessages_.size()));

+ postHandleIncomingMessage(messageEvent, highlight);

+ case ErrorPayload::BadRequest: return QT_TRANSLATE_NOOP("", "Bad request");

+ case ErrorPayload::Conflict: return QT_TRANSLATE_NOOP("", "Conflict");

+ case ErrorPayload::FeatureNotImplemented: return QT_TRANSLATE_NOOP("", "This feature is not implemented");

+ case ErrorPayload::Forbidden: return QT_TRANSLATE_NOOP("", "Forbidden");

+ case ErrorPayload::Gone: return QT_TRANSLATE_NOOP("", "Recipient can no longer be contacted");

+ case ErrorPayload::InternalServerError: return QT_TRANSLATE_NOOP("", "Internal server error");

+ case ErrorPayload::ItemNotFound: return QT_TRANSLATE_NOOP("", "Item not found");

+ case ErrorPayload::JIDMalformed: return QT_TRANSLATE_NOOP("", "JID Malformed");

+ case ErrorPayload::NotAcceptable: return QT_TRANSLATE_NOOP("", "Message was rejected");

+ case ErrorPayload::NotAllowed: return QT_TRANSLATE_NOOP("", "Not allowed");

+ case ErrorPayload::NotAuthorized: return QT_TRANSLATE_NOOP("", "Not authorized");

+ case ErrorPayload::PaymentRequired: return QT_TRANSLATE_NOOP("", "Payment is required");

+ case ErrorPayload::RecipientUnavailable: return QT_TRANSLATE_NOOP("", "Recipient is unavailable");

+ case ErrorPayload::Redirect: return QT_TRANSLATE_NOOP("", "Redirect");

+ case ErrorPayload::RegistrationRequired: return QT_TRANSLATE_NOOP("", "Registration required");

+ case ErrorPayload::RemoteServerNotFound: return QT_TRANSLATE_NOOP("", "Recipient's server not found");

+ case ErrorPayload::RemoteServerTimeout: return QT_TRANSLATE_NOOP("", "Remote server timeout");

+ case ErrorPayload::ResourceConstraint: return QT_TRANSLATE_NOOP("", "The server is low on resources");

+ case ErrorPayload::ServiceUnavailable: return QT_TRANSLATE_NOOP("", "The service is unavailable");

+ case ErrorPayload::SubscriptionRequired: return QT_TRANSLATE_NOOP("", "A subscription is required");

+ case ErrorPayload::UndefinedCondition: return QT_TRANSLATE_NOOP("", "Undefined condition");

+ case ErrorPayload::UnexpectedRequest: return QT_TRANSLATE_NOOP("", "Unexpected request");

+ }

+ }

+ assert(false);

+ chatWindow_->setUnreadMessageCount(boost::numeric_cast<int>(unreadMessages_.size()));

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

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

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

+ } else {

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

+}

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

+ * Copyright (c) 2010-2014 Kevin Smith

+#include <string>

+

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

+#include <Swiften/Network/Timer.h>

+#include <Swiften/Network/TimerFactory.h>

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

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

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

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

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

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

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

+#include <Swiften/Queries/IQRouter.h>

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

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

+

+#include <Swift/Controllers/XMPPEvents/MessageEvent.h>

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

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

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

+ class HighlightManager;

+ class Highlighter;

+ class ChatMessageParser;

+ class AutoAcceptMUCInviteDecider;

+ bool hasOpenWindow() const;

+ virtual void setAvailableServerFeatures(boost::shared_ptr<DiscoInfo> info);

+ std::string addMessage(const std::string& message, const std::string& senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const boost::filesystem::path& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight);

+ void replaceMessage(const std::string& message, const std::string& id, bool senderIsSelf, const boost::posix_time::ptime& time, const HighlightAction& highlight);

+ virtual void setToJID(const JID& jid) {toJID_ = jid;}

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

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

+ virtual void postSendMessage(const std::string&, boost::shared_ptr<Stanza>) {}

+ virtual void preHandleIncomingMessage(boost::shared_ptr<MessageEvent>) {}

+ virtual void postHandleIncomingMessage(boost::shared_ptr<MessageEvent>, const HighlightAction&) {}

+ virtual void preSendMessageRequest(boost::shared_ptr<Message>) {}

+ virtual void dayTicked() {}

+ /** JID any iq for account should go to - bare except for PMs */

+ virtual JID getBaseJID();

+ virtual void logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming) = 0;

+ SecurityLabelsCatalog::Item lastLabel_;

+ HistoryController* historyController_;

+ MUCRegistry* mucRegistry_;

+ Highlighter* highlighter_;

+ boost::shared_ptr<ChatMessageParser> chatMessageParser_;

+ AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider_;

+ UIEventStream* eventStream_;

+/*

+ * Copyright (c) 2013-2014 Kevin Smith

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

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

+

+#include <vector>

+#include <utility>

+

+#include <boost/smart_ptr/make_shared.hpp>

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

+

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

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

+

+#include <SwifTools/Linkify.h>

+

+

+namespace Swift {

+

+ ChatMessageParser::ChatMessageParser(const std::map<std::string, std::string>& emoticons, HighlightRulesListPtr highlightRules, bool mucMode)

+ : emoticons_(emoticons), highlightRules_(highlightRules), mucMode_(mucMode) {

+ }

+

+ typedef std::pair<std::string, std::string> StringPair;

+

+ ChatWindow::ChatMessage ChatMessageParser::parseMessageBody(const std::string& body, const std::string& nick, bool senderIsSelf) {

+ ChatWindow::ChatMessage parsedMessage;

+ std::string remaining = body;

+ /* Parse one, URLs */

+ while (!remaining.empty()) {

+ bool found = false;

+ std::pair<std::vector<std::string>, size_t> links = Linkify::splitLink(remaining);

+ remaining = "";

+ for (size_t i = 0; i < links.first.size(); i++) {

+ const std::string& part = links.first[i];

+ if (found) {

+ // Must be on the last part, then

+ remaining = part;

+ }

+ else {

+ if (i == links.second) {

+ found = true;

+ parsedMessage.append(boost::make_shared<ChatWindow::ChatURIMessagePart>(part));

+ }

+ else {

+ parsedMessage.append(boost::make_shared<ChatWindow::ChatTextMessagePart>(part));

+ }

+ }

+ }

+ }

+

+ /* do emoticon substitution */

+ parsedMessage = emoticonHighlight(parsedMessage);

+

+ if (!senderIsSelf) { /* do not highlight our own messsages */

+ /* do word-based color highlighting */

+ parsedMessage = splitHighlight(parsedMessage, nick);

+ }

+

+ return parsedMessage;

+ }

+

+ ChatWindow::ChatMessage ChatMessageParser::emoticonHighlight(const ChatWindow::ChatMessage& message)

+ {

+ ChatWindow::ChatMessage parsedMessage = message;

+

+ std::string regexString;

+ /* Parse two, emoticons */

+ foreach (StringPair emoticon, emoticons_) {

+ /* Construct a regexp that finds an instance of any of the emoticons inside a group

+ * at the start or end of the line, or beside whitespace.

+ */

+ regexString += regexString.empty() ? "" : "|";

+ std::string escaped = "(" + Regex::escape(emoticon.first) + ")";

+ regexString += "^" + escaped + "|";

+ regexString += escaped + "$|";

+ regexString += "\\s" + escaped + "|";

+ regexString += escaped + "\\s";

+

+ }

+ if (!regexString.empty()) {

+ regexString += "";

+ boost::regex emoticonRegex(regexString);

+

+ ChatWindow::ChatMessage newMessage;

+ foreach (boost::shared_ptr<ChatWindow::ChatMessagePart> part, parsedMessage.getParts()) {

+ boost::shared_ptr<ChatWindow::ChatTextMessagePart> textPart;

+ if ((textPart = boost::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(part))) {

+ try {

+ boost::match_results<std::string::const_iterator> match;

+ const std::string& text = textPart->text;

+ std::string::const_iterator start = text.begin();

+ while (regex_search(start, text.end(), match, emoticonRegex)) {

+ int matchIndex = 0;

+ for (matchIndex = 1; matchIndex < static_cast<int>(match.size()); matchIndex++) {

+ if (match[matchIndex].length() > 0) {

+ //This is the matching subgroup

+ break;

+ }

+ }

+ std::string::const_iterator matchStart = match[matchIndex].first;

+ std::string::const_iterator matchEnd = match[matchIndex].second;

+ if (start != matchStart) {

+ /* If we're skipping over plain text since the previous emoticon, record it as plain text */

+ newMessage.append(boost::make_shared<ChatWindow::ChatTextMessagePart>(std::string(start, matchStart)));

+ }

+ boost::shared_ptr<ChatWindow::ChatEmoticonMessagePart> emoticonPart = boost::make_shared<ChatWindow::ChatEmoticonMessagePart>();

+ std::string matchString = match[matchIndex].str();

+ std::map<std::string, std::string>::const_iterator emoticonIterator = emoticons_.find(matchString);

+ assert (emoticonIterator != emoticons_.end());

+ const StringPair& emoticon = *emoticonIterator;

+ emoticonPart->imagePath = emoticon.second;

+ emoticonPart->alternativeText = emoticon.first;

+ newMessage.append(emoticonPart);

+ start = matchEnd;

+ }

+ if (start != text.end()) {

+ /* If there's plain text after the last emoticon, record it */

+ newMessage.append(boost::make_shared<ChatWindow::ChatTextMessagePart>(std::string(start, text.end())));

+ }

+

+ }

+ catch (std::runtime_error) {

+ /* Basically too expensive to compute the regex results and it gave up, so pass through as text */

+ newMessage.append(part);

+ }

+ }

+ else {

+ newMessage.append(part);

+ }

+ }

+ parsedMessage = newMessage;

+

+ }

+ return parsedMessage;

+ }

+

+ ChatWindow::ChatMessage ChatMessageParser::splitHighlight(const ChatWindow::ChatMessage& message, const std::string& nick)

+ {

+ ChatWindow::ChatMessage parsedMessage = message;

+

+ for (size_t i = 0; i < highlightRules_->getSize(); ++i) {

+ const HighlightRule& rule = highlightRules_->getRule(i);

+ if (rule.getMatchMUC() && !mucMode_) {

+ continue; /* this rule only applies to MUC's, and this is a CHAT */

+ } else if (rule.getMatchChat() && mucMode_) {

+ continue; /* this rule only applies to CHAT's, and this is a MUC */

+ }

+ const std::vector<boost::regex> keywordRegex = rule.getKeywordRegex(nick);

+ foreach(const boost::regex& regex, keywordRegex) {

+ ChatWindow::ChatMessage newMessage;

+ foreach (boost::shared_ptr<ChatWindow::ChatMessagePart> part, parsedMessage.getParts()) {

+ boost::shared_ptr<ChatWindow::ChatTextMessagePart> textPart;

+ if ((textPart = boost::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(part))) {

+ try {

+ boost::match_results<std::string::const_iterator> match;

+ const std::string& text = textPart->text;

+ std::string::const_iterator start = text.begin();

+ while (regex_search(start, text.end(), match, regex)) {

+ std::string::const_iterator matchStart = match[0].first;

+ std::string::const_iterator matchEnd = match[0].second;

+ if (start != matchStart) {

+ /* If we're skipping over plain text since the previous emoticon, record it as plain text */

+ newMessage.append(boost::make_shared<ChatWindow::ChatTextMessagePart>(std::string(start, matchStart)));

+ }

+ boost::shared_ptr<ChatWindow::ChatHighlightingMessagePart> highlightPart = boost::make_shared<ChatWindow::ChatHighlightingMessagePart>();

+ highlightPart->text = match.str();

+ highlightPart->foregroundColor = rule.getAction().getTextColor();

+ highlightPart->backgroundColor = rule.getAction().getTextBackground();

+ newMessage.append(highlightPart);

+ start = matchEnd;

+ }

+ if (start != text.end()) {

+ /* If there's plain text after the last emoticon, record it */

+ newMessage.append(boost::make_shared<ChatWindow::ChatTextMessagePart>(std::string(start, text.end())));

+ }

+ }

+ catch (std::runtime_error) {

+ /* Basically too expensive to compute the regex results and it gave up, so pass through as text */

+ newMessage.append(part);

+ }

+ } else {

+ newMessage.append(part);

+ }

+ }

+ parsedMessage = newMessage;

+ }

+ }

+

+ return parsedMessage;

+ }

+}

+/*

+ * Copyright (c) 2013-2014 Kevin Smith

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <string>

+

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

+

+namespace Swift {

+

+ class ChatMessageParser {

+ public:

+ ChatMessageParser(const std::map<std::string, std::string>& emoticons, HighlightRulesListPtr highlightRules, bool mucMode = false);

+ ChatWindow::ChatMessage parseMessageBody(const std::string& body, const std::string& nick = "", bool senderIsSelf = false);

+ private:

+ ChatWindow::ChatMessage emoticonHighlight(const ChatWindow::ChatMessage& parsedMessage);

+ ChatWindow::ChatMessage splitHighlight(const ChatWindow::ChatMessage& parsedMessage, const std::string& nick);

+ std::map<std::string, std::string> emoticons_;

+ HighlightRulesListPtr highlightRules_;

+ bool mucMode_;

+ };

+}

+ * Copyright (c) 2010-2014 Kevin Smith

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

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

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

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

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

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

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

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

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

+#include <Swiften/Client/NickResolver.h>

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

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

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

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

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

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

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

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

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

+#include <Swiften/Client/ClientBlockListManager.h>

+#include <Swiften/Client/StanzaChannel.h>

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

+

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

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

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

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

+#include <Swift/Controllers/Chat/ChatMessageParser.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>

+

+BOOST_CLASS_VERSION(Swift::ChatListWindow::Chat, 1)

+

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

+ if (version > 0) {

+ ar & chat.password;

+ }

+ }

+}

+}

+ SettingsProvider* settings,

+ HistoryController* historyController,

+ WhiteboardManager* whiteboardManager,

+ HighlightManager* highlightManager,

+ ClientBlockListManager* clientBlockListManager,

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

+ UserSearchController* inviteUserSearchController,

+ VCardManager* vcardManager) :

+ settings_(settings),

+ historyController_(historyController),

+ whiteboardManager_(whiteboardManager),

+ highlightManager_(highlightManager),

+ emoticons_(emoticons),

+ clientBlockListManager_(clientBlockListManager),

+ inviteUserSearchController_(inviteUserSearchController),

+ vcardManager_(vcardManager) {

+ whiteboardManager_->onSessionRequest.connect(boost::bind(&ChatsManager::handleWhiteboardSessionRequest, this, _1, _2));

+ whiteboardManager_->onRequestAccepted.connect(boost::bind(&ChatsManager::handleWhiteboardStateChange, this, _1, ChatWindow::WhiteboardAccepted));

+ whiteboardManager_->onSessionTerminate.connect(boost::bind(&ChatsManager::handleWhiteboardStateChange, this, _1, ChatWindow::WhiteboardTerminated));

+ whiteboardManager_->onRequestRejected.connect(boost::bind(&ChatsManager::handleWhiteboardStateChange, this, _1, ChatWindow::WhiteboardRejected));

+

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

+ }

+

+ class RemoveRecent {

+ public:

+ static bool ifPrivateMessage(const ChatListWindow::Chat& chat) {

+ return chat.isPrivateMessage;

+ }

+ };

+

+ recentsLimited.erase(std::remove_if(recentsLimited.begin(), recentsLimited.end(), RemoveRecent::ifPrivateMessage), recentsLimited.end());

+

+ oa << recentsLimited;

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

+ profileSettings_->storeString(RECENT_CHATS, serializedStr);

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

+ ChatListWindow::Chat fixedChat = chat;

+ if (fixedChat.isMUC) {

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

+ fixedChat.statusType = StatusShow::Online;

+ }

+ } else {

+ if (avatarManager_) {

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

+ }

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

+ fixedChat.statusType = presence ? presence->getShow() : StatusShow::None;

+ }

+ return fixedChat;

+}

+

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

+ // old format

+

+ ChatListWindow::Chat chat(jid, nickResolver_->jidToNick(jid), activity, 0, type, path, isMUC, false, nick);

+ chat = updateChatStatusAndAvatarHelper(chat);

+ prependRecent(chat);

+ } else if (!recentsString.empty()){

+ // boost searilaize based format

+ ByteArray debase64 = Base64::decode(recentsString);

+ std::vector<ChatListWindow::Chat> recentChats;

+ std::stringstream deserializeStream(std::string(reinterpret_cast<const char*>(vecptr(debase64)), debase64.size()));

+ try {

+ boost::archive::text_iarchive ia(deserializeStream);

+ ia >> recentChats;

+ } catch (const boost::archive::archive_exception& e) {

+ SWIFT_LOG(debug) << "Failed to load recents: " << e.what() << std::endl;

+ return;

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

+ chat.statusType = StatusShow::None;

+ chat = updateChatStatusAndAvatarHelper(chat);

+ }

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

+ChatListWindow::Chat ChatsManager::createChatListChatItem(const JID& jid, const std::string& activity, bool privateMessage) {

+ std::string password = "";

+

+ if (controller->getPassword()) {

+ password = *controller->getPassword();

+ if (controller->isImpromptu()) {

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

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

+ chat.impromptuJIDs = participants;

+ return chat;

+ }

+ }

+ return ChatListWindow::Chat(jid, jid.toString(), activity, unreadCount, type, boost::filesystem::path(), true, privateMessage, nick, password);

+ return ChatListWindow::Chat(bareishJID, nickResolver_->jidToNick(bareishJID), activity, unreadCount, type, avatarPath, false, privateMessage);

+ const bool privateMessage = mucRegistry_->isMUC(jid.toBare()) && !isMUC;

+ ChatListWindow::Chat chat = createChatListChatItem(jid, activity, privateMessage);

+void ChatsManager::handleChatClosed(const JID& /*jid*/) {

+ cleanupPrivateMessageRecents();

+ chatListWindow_->setRecents(recentChats_);

+}

+

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

+ std::list<ChatListWindow::Chat>::iterator result = std::find(recentChats_.begin(), recentChats_.end(), chat);

+ if (result != recentChats_.end()) {

+ ChatListWindow::Chat existingChat = *result;

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

+ } else {

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

+ }

+}

+

+void ChatsManager::cleanupPrivateMessageRecents() {

+ /* if we leave a MUC and close a PM, remove it's recent chat entry */

+ const std::list<ChatListWindow::Chat> chats = recentChats_;

+ foreach (const ChatListWindow::Chat& chat, chats) {

+ if (chat.isPrivateMessage) {

+ typedef std::map<JID, MUCController*> ControllerMap;

+ ControllerMap::iterator muc = mucControllers_.find(chat.jid.toBare());

+ if (muc == mucControllers_.end() || !muc->second->isJoined()) {

+ ChatController* chatController = getChatControllerIfExists(chat.jid);

+ if (!chatController || !chatController->hasOpenWindow()) {

+ removeExistingChat(chat);

+ break;

+ }

+ }

+ }

+ }

+}

+

+void ChatsManager::appendRecent(const ChatListWindow::Chat& chat) {

+ boost::optional<ChatListWindow::Chat> oldChat = removeExistingChat(chat);

+ ChatListWindow::Chat mergedChat = chat;

+ if (oldChat && !oldChat->impromptuJIDs.empty()) {

+ mergedChat.impromptuJIDs.insert(oldChat->impromptuJIDs.begin(), oldChat->impromptuJIDs.end());

+ }

+ recentChats_.push_front(mergedChat);

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

+ break;

+ cleanupPrivateMessageRecents();

+ chatListWindow_->setRecents(recentChats_);

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

+ boost::shared_ptr<ChatMessageParser> chatMessageParser = boost::make_shared<ChatMessageParser>(emoticons_, highlightManager_->getRules(), false); /* a message parser that knows this is a chat (not a room/MUC) */

+ ChatController* controller = new ChatController(jid_, stanzaChannel_, iqRouter_, chatWindowFactory_, contact, nickResolver_, presenceOracle_, avatarManager_, mucRegistry_->isMUC(contact.toBare()), useDelayForLatency_, uiEventStream_, eventController_, timerFactory_, entityCapsProvider_, userWantsReceipts_, settings_, historyController_, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser, autoAcceptMUCInviteDecider_);

+ controller->onWindowClosed.connect(boost::bind(&ChatsManager::handleChatClosed, this, contact));

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

+ }

+ boost::shared_ptr<ChatMessageParser> chatMessageParser = boost::make_shared<ChatMessageParser>(emoticons_, highlightManager_->getRules(), true); /* a message parser that knows this is a room/MUC (not a chat) */

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

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

+ }

+

+ controller->onUserNicknameChanged.connect(boost::bind(&ChatsManager::handleUserNicknameChanged, this, controller, _1, _2));

+ return muc;

+void ChatsManager::handleUserNicknameChanged(MUCController* mucController, const std::string& oldNickname, const std::string& newNickname) {

+ JID oldMUCChatJID = mucController->getToJID().withResource(oldNickname);

+ JID newMUCChatJID = mucController->getToJID().withResource(newNickname);

+

+ SWIFT_LOG(debug) << "nickname change in " << mucController->getToJID().toString() << " from " << oldNickname << " to " << newNickname << std::endl;

+

+ // get current chat controller

+ ChatController *chatController = getChatControllerIfExists(oldMUCChatJID);

+ if (chatController) {

+ // adjust chat controller

+ chatController->setToJID(newMUCChatJID);

+ nickResolver_->onNickChanged(newMUCChatJID, oldNickname);

+ chatControllers_.erase(oldMUCChatJID);

+ chatControllers_[newMUCChatJID] = chatController;

+

+ chatController->onActivity.disconnect(boost::bind(&ChatsManager::handleChatActivity, this, oldMUCChatJID, _1, false));

+ chatController->onActivity.connect(boost::bind(&ChatsManager::handleChatActivity, this, newMUCChatJID, _1, false));

+ /*for (std::list<ChatListWindow::Chat>::iterator i = recentChats_.begin(); i != recentChats_.end(); i++) {

+ if (i->jid ==

+ }*/

+ }

+}

+

+ bool isInvite = !!message->getPayload<MUCInvitationPayload>();

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

+ return;

+ }

+ } else {

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

+ return;

+ }

+ }

+

+ if (!event->isReadable() && !isInvite && !isMediatedInvite) {

+ /* Only route such messages if a window exists, don't open new windows for them.*/

+ ChatController* controller = getChatControllerIfExists(jid);

+ if (controller) {

+ controller->handleIncomingMessage(event);

+ }

+ } else {

+}

+void ChatsManager::handleWhiteboardSessionRequest(const JID& contact, bool senderIsSelf) {

+ ChatController* chatController = getChatControllerOrCreate(contact);

+ chatController->handleWhiteboardSessionRequest(senderIsSelf);

+ chatController->activateChatWindow();

+}

+

+void ChatsManager::handleWhiteboardStateChange(const JID& contact, const ChatWindow::WhiteboardSessionState state) {

+ ChatController* chatController = getChatControllerOrCreate(contact);

+ chatController->handleWhiteboardStateChange(state);

+ chatController->activateChatWindow();

+ if (state == ChatWindow::WhiteboardAccepted) {

+ boost::filesystem::path path;

+ JID bareJID = contact.toBare();

+ if (avatarManager_) {

+ path = avatarManager_->getAvatarPath(bareJID);

+ }

+ ChatListWindow::Chat chat(bareJID, nickResolver_->jidToNick(bareJID), "", 0, StatusShow::None, path, false);

+ chatListWindow_->addWhiteboardSession(chat);

+ } else {

+ chatListWindow_->removeWhiteboardSession(contact.toBare());

+ }

+}

+

+ 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::ref> Swift::ChatsManager::getContacts(bool withMUCNicks) {

+ std::vector<Contact::ref> result;

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

+ if (!chat.isMUC) {

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

+ }

+ }

+ if (withMUCNicks) {

+ /* collect MUC nicks */

+ typedef std::map<JID, MUCController*>::value_type Item;

+ foreach (const Item& item, mucControllers_) {

+ JID mucJID = item.second->getToJID();

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

+ typedef std::map<std::string, JID>::value_type ParticipantType;

+ foreach (const ParticipantType& participant, participants) {

+ const JID nickJID = JID(mucJID.getNode(), mucJID.getDomain(), participant.first);

+ Presence::ref presence = presenceOracle_->getLastPresence(nickJID);

+ const boost::filesystem::path avatar = avatarManager_->getAvatarPath(nickJID);

+ result.push_back(boost::make_shared<Contact>(participant.first, JID(), presence->getShow(), avatar));

+ }

+ }

+ }

+ return result;

+}

+

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

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

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

+ return chatWindow_;

+}

+

+ * Copyright (c) 2010-2014 Kevin Smith

+#include <string>

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

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

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

+

+

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

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

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

+

+ class WhiteboardManager;

+ class HistoryController;

+ class HighlightManager;

+ class ClientBlockListManager;

+ class ChatMessageParser;

+ class DiscoServiceWalker;

+ class AutoAcceptMUCInviteDecider;

+ class UserSearchController;

+ class VCardManager;

+ 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, VCardManager* vcardManager);

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

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

+

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

+ class SingleChatWindowFactoryAdapter : public ChatWindowFactory {

+ public:

+ SingleChatWindowFactoryAdapter(ChatWindow* chatWindow);

+ virtual ~SingleChatWindowFactoryAdapter();

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

+

+ private:

+ ChatWindow* chatWindow_;

+ };

+

+ private:

+ ChatListWindow::Chat createChatListChatItem(const JID& jid, const std::string& activity, bool privateMessage);

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

+ void handleUserNicknameChanged(MUCController* mucController, const std::string& oldNickname, const std::string& newNickname);

+ void handleChatClosed(const JID& jid);

+ void handleWhiteboardSessionRequest(const JID& contact, bool senderIsSelf);

+ void handleWhiteboardStateChange(const JID& contact, const ChatWindow::WhiteboardSessionState state);

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

+ void cleanupPrivateMessageRecents();

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

+ HistoryController* historyController_;

+ WhiteboardManager* whiteboardManager_;

+ HighlightManager* highlightManager_;

+ std::map<std::string, std::string> emoticons_;

+ ClientBlockListManager* clientBlockListManager_;

+ JID localMUCServiceJID_;

+ boost::shared_ptr<DiscoServiceWalker> localMUCServiceFinderWalker_;

+ AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider_;

+ UserSearchController* inviteUserSearchController_;

+ IDGenerator idGenerator_;

+ VCardManager* vcardManager_;

+ * Copyright (c) 2010-2014 Kevin Smith

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

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

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

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

+#include <Swiften/Client/StanzaChannel.h>

+#include <Swiften/Disco/EntityCapsProvider.h>

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

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

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

+

+

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

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

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

+#include <Swift/Controllers/Roster/GroupRosterItem.h>

+#include <Swift/Controllers/Roster/ItemOperations/SetAvatar.h>

+#include <Swift/Controllers/Roster/ItemOperations/SetPresence.h>

+#include <Swift/Controllers/Roster/ItemOperations/SetMUC.h>

+#include <Swift/Controllers/Roster/RosterVCardProvider.h>

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

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

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

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

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

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

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

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

+#include <Swift/Controllers/XMPPEvents/EventController.h>

+ EntityCapsProvider* entityCapsProvider,

+ XMPPRoster* roster,

+ HistoryController* historyController,

+ MUCRegistry* mucRegistry,

+ HighlightManager* highlightManager,

+ boost::shared_ptr<ChatMessageParser> chatMessageParser,

+ bool isImpromptu,

+ AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider,

+ VCardManager* vcardManager) :

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

+ xmppRoster_ = roster;

+ rosterVCardProvider_ = new RosterVCardProvider(roster_, vcardManager, JID::WithResource);

+ chatWindow_->onBookmarkRequest.connect(boost::bind(&MUCController::handleBookmarkRequest, this));

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

+ muc_->onOccupantNicknameChanged.connect(boost::bind(&MUCController::handleOccupantNicknameChanged, this, _1, _2));

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

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

+ highlighter_->setMode(isImpromptu_ ? Highlighter::ChatMode : Highlighter::MUCMode);

+ highlighter_->setNick(nick_);

+ if (isImpromptu) {

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

+ chatWindow_->convertToMUC(ChatWindow::ImpromptuMUC);

+ } else {

+ muc_->onOccupantRoleChanged.connect(boost::bind(&MUCController::handleOccupantRoleChanged, this, _1, _2, _3));

+ muc_->onOccupantAffiliationChanged.connect(boost::bind(&MUCController::handleOccupantAffiliationChanged, this, _1, _2, _3));

+ chatWindow_->convertToMUC(ChatWindow::StandardMUC);

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

+ }

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

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

+ delete rosterVCardProvider_;

+ if (role == MUCOccupant::Moderator && !isImpromptu_)

+ actions.push_back(ChatWindow::ShowProfile);

+ case ChatWindow::ShowProfile: events_->send(boost::make_shared<ShowProfileForRosterItemUIEvent>(mucJID));break;

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

+ if (lastActivity_ == boost::posix_time::not_a_date_time && historyController_) {

+ lastActivity_ = historyController_->getLastTimeStampFromMUC(selfJID_, toJID_);

+ }

+#endif

+ }

+ else {

+const boost::optional<std::string> MUCController::getPassword() const {

+ return password_;

+}

+

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

+ }

+}

+

+ chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "Room %1% is not responding. This operation may never complete.")) % toJID_.toString())), ChatWindow::DefaultDirection);

+#pragma clang diagnostic push

+#pragma clang diagnostic ignored "-Wswitch-enum"

+

+ chatWindow_->addErrorMessage(chatMessageParser_->parseMessageBody(errorMessage));

+ if (!rejoinNick.empty() && renameCounter_ < 10) {

+ renameCounter_++;

+ setNick(rejoinNick);

+#pragma clang diagnostic pop

+

+ renameCounter_ = 0;

+ std::string joinMessage;

+ if (isImpromptu_) {

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

+ } else {

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

+ }

+ setNick(nick);

+ chatWindow_->replaceLastMessage(chatMessageParser_->parseMessageBody(joinMessage), ChatWindow::UpdateTimestamp);

+

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

+ addRecentLogs();

+#endif

+

+ if (isImpromptu_) {

+ setAvailableRoomActions(MUCOccupant::NoAffiliation, MUCOccupant::Participant);

+ } else {

+ }

+

+ if (isImpromptu_) {

+ setImpromptuWindowTitle();

+ }

+ roster_->applyOnItems(SetAvatar(jid, avatarManager_->getAvatarPath(jid), JID::WithResource));

+ MUCOccupant::Role role = MUCOccupant::Participant;

+ MUCOccupant::Affiliation affiliation = MUCOccupant::NoAffiliation;

+ if (!isImpromptu_) {

+ role = occupant.getRole();

+ affiliation = occupant.getAffiliation();

+ }

+ std::string groupName(roleToGroupName(role));

+ roster_->addContact(jid, realJID, occupant.getNick(), groupName, avatarManager_->getAvatarPath(jid));

+ roster_->applyOnItems(SetMUC(jid, role, affiliation));

+ roster_->getGroup(groupName)->setManualSort(roleToSortName(role));

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

+ chatWindow_->addPresenceMessage(chatMessageParser_->parseMessageBody(message), ChatWindow::DefaultDirection);

+ assert(false);

+ assert(false);

+ return muc_->getJID().withResource(nick);

+ if (joined_ && messageEvent->getStanza()->getFrom().getResource() != nick_ && messageTargetsMe(message) && !message->getPayload<Delay>() && messageEvent->isReadable()) {

+ if (messageEvent->isReadable() && isImpromptu_) {

+ chatWindow_->flash(); /* behave like a regular char*/

+ }

+ chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "The room subject is now: %1%")) % message->getSubject())), ChatWindow::DefaultDirection);;

+ checkDuplicates(message);

+void MUCController::postHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent, const HighlightAction& highlight) {

+ if (joined_ && messageEvent->getStanza()->getFrom().getResource() != nick_ && !message->getPayload<Delay>()) {

+ if (messageTargetsMe(message) || isImpromptu_) {

+ if (!messageEvent->getConcluded()) {

+ highlighter_->handleHighlightAction(highlight);

+ }

+ }

+ roster_->addContact(jid, realJID, nick, group, avatarManager_->getAvatarPath(jid));

+ roster_->applyOnItems(SetMUC(jid, occupant.getRole(), occupant.getAffiliation()));

+ chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "%1% is now a %2%")) % nick % roleToFriendlyName(occupant.getRole()))), ChatWindow::DefaultDirection);

+ JID jid(nickToJID(nick));

+ MUCOccupant occupant = muc_->getOccupant(nick);

+ roster_->applyOnItems(SetMUC(jid, occupant.getRole(), affiliation));

+ renameCounter_ = 0;

+ if (isImpromptu_) {

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

+ } else {

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

+ }

+ setNick(desiredNick_);

+ if (isImpromptu_) {

+ partMessage = str(format(QT_TRANSLATE_NOOP("", "%1% has left the chat%2%")) % occupant.getNick() % partType);

+ } else {

+ }

+ else if (isImpromptu_) {

+ switch (type) {

+ case MUC::LeaveKick:

+ case MUC::LeaveBan: clearPresenceQueue(); clearAfter = true; partMessage = QT_TRANSLATE_NOOP("", "You have been removed from this chat"); break;

+ case MUC::LeaveNotMember: clearPresenceQueue(); clearAfter = true; partMessage = QT_TRANSLATE_NOOP("", "You have been removed from this chat"); break;

+ case MUC::LeaveDestroy: clearPresenceQueue(); clearAfter = true; partMessage = QT_TRANSLATE_NOOP("", "This chat has ended"); break;

+ case MUC::Disconnect:

+ case MUC::LeavePart: partMessage = QT_TRANSLATE_NOOP("", "You have left the chat");

+ }

+ }

+

+ if (isImpromptu_) {

+ setImpromptuWindowTitle();

+ }

+}

+

+void MUCController::handleOccupantNicknameChanged(const std::string& oldNickname, const std::string& newNickname) {

+ addPresenceMessage(generateNicknameChangeString(oldNickname, newNickname));

+ JID oldJID = muc_->getJID().withResource(oldNickname);

+ JID newJID = muc_->getJID().withResource(newNickname);

+

+ // adjust occupants

+ currentOccupants_.erase(oldNickname);

+ currentOccupants_.insert(newNickname);

+

+ // adjust completer

+ completer_->removeWord(oldNickname);

+ completer_->addWord(newNickname);

+

+ // update contact

+ roster_->removeContact(oldJID);

+ MUCOccupant occupant = muc_->getOccupant(newNickname);

+

+ JID realJID;

+ if (occupant.getRealJID()) {

+ realJID = occupant.getRealJID().get();

+ }

+ MUCOccupant::Role role = MUCOccupant::Participant;

+ MUCOccupant::Affiliation affiliation = MUCOccupant::NoAffiliation;

+ if (!isImpromptu_) {

+ role = occupant.getRole();

+ affiliation = occupant.getAffiliation();

+ }

+ std::string groupName(roleToGroupName(role));

+ roster_->addContact(newJID, realJID, newNickname, groupName, avatarManager_->getAvatarPath(newJID));

+ roster_->applyOnItems(SetMUC(newJID, role, affiliation));

+ if (avatarManager_ != NULL) {

+ handleAvatarChanged(newJID);

+ }

+

+ clearPresenceQueue();

+ onUserNicknameChanged(oldNickname, newNickname);

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

+ case PartThenJoin: break;

+ case JoinThenPart: break;

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

+std::string MUCController::generateNicknameChangeString(const std::string& oldNickname, const std::string& newNickname) {

+ return str(boost::format(QT_TRANSLATE_NOOP("", "%1% is now known as %2%.")) % oldNickname % newNickname);

+}

+

+void MUCController::handleBookmarkRequest() {

+ const JID jid = muc_->getJID();

+ MUCBookmark bookmark(jid, jid.toBare().toString());

+ bookmark.setPassword(password_);

+ bookmark.setNick(nick_);

+ chatWindow_->showBookmarkWindow(bookmark);

+}

+

+ chatWindow_->addErrorMessage(chatMessageParser_->parseMessageBody(errorMessage));

+ chatWindow_->addErrorMessage(chatMessageParser_->parseMessageBody(errorMessage));

+}

+

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

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

+ isImpromptuAlreadyConfigured_ = true;

+ onImpromptuConfigCompleted();

+ if (isImpromptu_) {

+ if (!isImpromptuAlreadyConfigured_) {

+ configureAsImpromptuRoom(form);

+ }

+ } else {

+}

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

+ RequestInviteToMUCUIEvent::ImpromptuMode mode = isImpromptu_ ? RequestInviteToMUCUIEvent::Impromptu : RequestInviteToMUCUIEvent::NotImpromptu;

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

+ 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::logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming) {

+ // log only incoming messages

+ if (isIncoming && historyController_) {

+ historyController_->addMessage(message, fromJID, toJID, HistoryMessage::Groupchat, timeStamp);

+ }

+}

+

+void MUCController::addRecentLogs() {

+ if (!historyController_) {

+ return;

+ }

+

+ joinContext_ = historyController_->getMUCContext(selfJID_, toJID_, lastActivity_);

+

+ foreach (const HistoryMessage& message, joinContext_) {

+ bool senderIsSelf = nick_ == message.getFromJID().getResource();

+

+ // the chatWindow uses utc timestamps

+ addMessage(message.getMessage(), senderDisplayNameFromMessage(message.getFromJID()), senderIsSelf, boost::shared_ptr<SecurityLabel>(new SecurityLabel()), avatarManager_->getAvatarPath(message.getFromJID()), message.getTime() - boost::posix_time::hours(message.getOffset()), HighlightAction());

+ }

+}

+

+void MUCController::checkDuplicates(boost::shared_ptr<Message> newMessage) {

+ std::string body = newMessage->getBody();

+ JID jid = newMessage->getFrom();

+ boost::optional<boost::posix_time::ptime> time = newMessage->getTimestamp();

+

+ reverse_foreach (const HistoryMessage& message, joinContext_) {

+ boost::posix_time::ptime messageTime = message.getTime() - boost::posix_time::hours(message.getOffset());

+ if (time && time < messageTime) {

+ break;

+ }

+ if (time && time != messageTime) {

+ continue;

+ }

+ if (message.getFromJID() != jid) {

+ continue;

+ }

+ if (message.getMessage() != body) {

+ continue;

+ }

+

+ // Mark the message as unreadable

+ newMessage->setBody("");

+ }

+}

+

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

+ nick_ = nick;

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

+ }

+ }

+}

+

+ * Copyright (c) 2010-2014 Kevin Smith

+#include <set>

+#include <string>

+#include <map>

+

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

+

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

+ class XMPPRoster;

+ class HighlightManager;

+ class UIEvent;

+ class VCardManager;

+ class RosterVCardProvider;

+ NickJoinPart(const std::string& nick, JoinPart type) : nick(nick), type(type) {}

+ 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, boost::shared_ptr<ChatMessageParser> chatMessageParser, bool isImpromptu, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, VCardManager* vcardManager);

+ virtual ~MUCController();

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

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

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

+ static std::string generateNicknameChangeString(const std::string& oldNickname, const std::string& newNickname);

+ const boost::optional<std::string> getPassword() const;

+ bool isImpromptu() const;

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

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

+ void postHandleIncomingMessage(boost::shared_ptr<MessageEvent>, const HighlightAction&);

+ void logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming);

+ void handleOccupantNicknameChanged(const std::string& oldNickname, const std::string& newNickname);

+ void handleBookmarkRequest();

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

+ void handleInviteToMUCWindowDismissed();

+ void handleInviteToMUCWindowCompleted();

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

+ void addRecentLogs();

+ void checkDuplicates(boost::shared_ptr<Message> newMessage);

+ void setNick(const std::string& nick);

+ void setImpromptuWindowTitle();

+ void handleRoomUnlocked();

+ void configureAsImpromptuRoom(Form::ref form);

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

+ XMPPRoster* xmppRoster_;

+ std::vector<HistoryMessage> joinContext_;

+ size_t renameCounter_;

+ bool isImpromptu_;

+ bool isImpromptuAlreadyConfigured_;

+ RosterVCardProvider* rosterVCardProvider_;

+/*

+ * Copyright (c) 2013-2014 Kevin Smith

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+#include <hippomocks.h>

+

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

+

+using namespace Swift;

+

+class ChatMessageParserTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(ChatMessageParserTest);

+ CPPUNIT_TEST(testFullBody);

+ CPPUNIT_TEST(testOneEmoticon);

+ CPPUNIT_TEST(testBareEmoticon);

+ CPPUNIT_TEST(testHiddenEmoticon);

+ CPPUNIT_TEST(testEndlineEmoticon);

+ CPPUNIT_TEST(testBoundedEmoticons);

+ CPPUNIT_TEST_SUITE_END();

+

+public:

+ void setUp() {

+ smile1_ = ":)";

+ smile1Path_ = "/blah/smile1.png";

+ smile2_ = ":(";

+ smile2Path_ = "/blah/smile2.jpg";

+ emoticons_[smile1_] = smile1Path_;

+ emoticons_[smile2_] = smile2Path_;

+ }

+

+ void tearDown() {

+ emoticons_.clear();

+ }

+

+ void assertText(const ChatWindow::ChatMessage& result, size_t index, const std::string& text) {

+ boost::shared_ptr<ChatWindow::ChatTextMessagePart> part = boost::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(result.getParts()[index]);

+ CPPUNIT_ASSERT_EQUAL(text, part->text);

+ }

+

+ void assertEmoticon(const ChatWindow::ChatMessage& result, size_t index, const std::string& text, const std::string& path) {

+ boost::shared_ptr<ChatWindow::ChatEmoticonMessagePart> part = boost::dynamic_pointer_cast<ChatWindow::ChatEmoticonMessagePart>(result.getParts()[index]);

+ CPPUNIT_ASSERT(!!part);

+ CPPUNIT_ASSERT_EQUAL(text, part->alternativeText);

+ CPPUNIT_ASSERT_EQUAL(path, part->imagePath);

+ }

+

+ void assertHighlight(const ChatWindow::ChatMessage& result, size_t index, const std::string& text) {

+ boost::shared_ptr<ChatWindow::ChatHighlightingMessagePart> part = boost::dynamic_pointer_cast<ChatWindow::ChatHighlightingMessagePart>(result.getParts()[index]);

+ CPPUNIT_ASSERT_EQUAL(text, part->text);

+ }

+

+ void assertURL(const ChatWindow::ChatMessage& result, size_t index, const std::string& text) {

+ boost::shared_ptr<ChatWindow::ChatURIMessagePart> part = boost::dynamic_pointer_cast<ChatWindow::ChatURIMessagePart>(result.getParts()[index]);

+ CPPUNIT_ASSERT_EQUAL(text, part->target);

+ }

+

+ static HighlightRule ruleFromKeyword(const std::string& keyword, bool matchCase, bool matchWholeWord)

+ {

+ HighlightRule rule;

+ std::vector<std::string> keywords;

+ keywords.push_back(keyword);

+ rule.setKeywords(keywords);

+ rule.setMatchCase(matchCase);

+ rule.setMatchWholeWords(matchWholeWord);

+ rule.setMatchChat(true);

+ return rule;

+ }

+

+ static const HighlightRulesListPtr ruleListFromKeyword(const std::string& keyword, bool matchCase, bool matchWholeWord)

+ {

+ boost::shared_ptr<HighlightManager::HighlightRulesList> list = boost::make_shared<HighlightManager::HighlightRulesList>();

+ list->addRule(ruleFromKeyword(keyword, matchCase, matchWholeWord));

+ return list;

+ }

+

+ static const HighlightRulesListPtr ruleListFromKeywords(const HighlightRule &rule1, const HighlightRule &rule2)

+ {

+ boost::shared_ptr<HighlightManager::HighlightRulesList> list = boost::make_shared<HighlightManager::HighlightRulesList>();

+ list->addRule(rule1);

+ list->addRule(rule2);

+ return list;

+ }

+

+ static HighlightRulesListPtr ruleListWithNickHighlight()

+ {

+ HighlightRule rule;

+ rule.setMatchChat(true);

+ rule.setNickIsKeyword(true);

+ rule.setMatchCase(true);

+ rule.setMatchWholeWords(true);

+ boost::shared_ptr<HighlightManager::HighlightRulesList> list = boost::make_shared<HighlightManager::HighlightRulesList>();

+ list->addRule(rule);

+ return list;

+ }

+

+ void testFullBody() {

+ const std::string no_special_message = "a message with no special content";

+ ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

+ ChatWindow::ChatMessage result = testling.parseMessageBody(no_special_message);

+ assertText(result, 0, no_special_message);

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeyword("trigger", false, false));

+ result = testling.parseMessageBody(":) shiny :( trigger :) http://wonderland.lit/blah http://denmark.lit boom boom");

+ assertEmoticon(result, 0, smile1_, smile1Path_);

+ assertText(result, 1, " shiny ");

+ assertEmoticon(result, 2, smile2_, smile2Path_);

+ assertText(result, 3, " ");

+ assertHighlight(result, 4, "trigger");

+ assertText(result, 5, " ");

+ assertEmoticon(result, 6, smile1_, smile1Path_);

+ assertText(result, 7, " ");

+ assertURL(result, 8, "http://wonderland.lit/blah");

+ assertText(result, 9, " ");

+ assertURL(result, 10, "http://denmark.lit");

+ assertText(result, 11, " boom boom");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeyword("trigger", false, false));

+ result = testling.parseMessageBody("testtriggermessage");

+ assertText(result, 0, "test");

+ assertHighlight(result, 1, "trigger");

+ assertText(result, 2, "message");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeyword("trigger", false, true));

+ result = testling.parseMessageBody("testtriggermessage");

+ assertText(result, 0, "testtriggermessage");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeyword("trigger", true, false));

+ result = testling.parseMessageBody("TrIgGeR");

+ assertText(result, 0, "TrIgGeR");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeyword("trigger", false, false));

+ result = testling.parseMessageBody("TrIgGeR");

+ assertHighlight(result, 0, "TrIgGeR");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeyword("trigger", false, false));

+ result = testling.parseMessageBody("partialTrIgGeRmatch");

+ assertText(result, 0, "partial");

+ assertHighlight(result, 1, "TrIgGeR");

+ assertText(result, 2, "match");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, false), ruleFromKeyword("three", false, false)));

+ result = testling.parseMessageBody("zero one two three");

+ assertText(result, 0, "zero ");

+ assertHighlight(result, 1, "one");

+ assertText(result, 2, " two ");

+ assertHighlight(result, 3, "three");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, false), ruleFromKeyword("three", false, false)));

+ result = testling.parseMessageBody("zero oNe two tHrEe");

+ assertText(result, 0, "zero ");

+ assertHighlight(result, 1, "oNe");

+ assertText(result, 2, " two ");

+ assertHighlight(result, 3, "tHrEe");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, false), ruleFromKeyword("three", true, false)));

+ result = testling.parseMessageBody("zero oNe two tHrEe");

+ assertText(result, 0, "zero ");

+ assertHighlight(result, 1, "oNe");

+ assertText(result, 2, " two tHrEe");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", true, false), ruleFromKeyword("three", true, false)));

+ result = testling.parseMessageBody("zero oNe two tHrEe");

+ assertText(result, 0, "zero oNe two tHrEe");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, false), ruleFromKeyword("three", false, false)));

+ result = testling.parseMessageBody("zeroonetwothree");

+ assertText(result, 0, "zero");

+ assertHighlight(result, 1, "one");

+ assertText(result, 2, "two");

+ assertHighlight(result, 3, "three");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", true, false), ruleFromKeyword("three", false, false)));

+ result = testling.parseMessageBody("zeroOnEtwoThReE");

+ assertText(result, 0, "zeroOnEtwo");

+ assertHighlight(result, 1, "ThReE");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, true), ruleFromKeyword("three", false, false)));

+ result = testling.parseMessageBody("zeroonetwothree");

+ assertText(result, 0, "zeroonetwo");

+ assertHighlight(result, 1, "three");

+

+ testling = ChatMessageParser(emoticons_, ruleListFromKeywords(ruleFromKeyword("one", false, true), ruleFromKeyword("three", false, true)));

+ result = testling.parseMessageBody("zeroonetwothree");

+ assertText(result, 0, "zeroonetwothree");

+

+ testling = ChatMessageParser(emoticons_, ruleListWithNickHighlight());

+ result = testling.parseMessageBody("Alice", "Alice");

+ assertHighlight(result, 0, "Alice");

+

+ testling = ChatMessageParser(emoticons_, ruleListWithNickHighlight());

+ result = testling.parseMessageBody("TextAliceText", "Alice");

+ assertText(result, 0, "TextAliceText");

+

+ testling = ChatMessageParser(emoticons_, ruleListWithNickHighlight());

+ result = testling.parseMessageBody("Text Alice Text", "Alice");

+ assertText(result, 0, "Text ");

+ assertHighlight(result, 1, "Alice");

+ assertText(result, 2, " Text");

+

+ testling = ChatMessageParser(emoticons_, ruleListWithNickHighlight());

+ result = testling.parseMessageBody("Alice Text", "Alice");

+ assertHighlight(result, 0, "Alice");

+ assertText(result, 1, " Text");

+

+ testling = ChatMessageParser(emoticons_, ruleListWithNickHighlight());

+ result = testling.parseMessageBody("Text Alice", "Alice");

+ assertText(result, 0, "Text ");

+ assertHighlight(result, 1, "Alice");

+ }

+

+ void testOneEmoticon() {

+ ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

+ ChatWindow::ChatMessage result = testling.parseMessageBody(" :) ");

+ assertText(result, 0, " ");

+ assertEmoticon(result, 1, smile1_, smile1Path_);

+ assertText(result, 2, " ");

+ }

+

+

+ void testBareEmoticon() {

+ ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

+ ChatWindow::ChatMessage result = testling.parseMessageBody(":)");

+ assertEmoticon(result, 0, smile1_, smile1Path_);

+ }

+

+ void testHiddenEmoticon() {

+ ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

+ ChatWindow::ChatMessage result = testling.parseMessageBody("b:)a");

+ assertText(result, 0, "b:)a");

+ }

+

+ void testEndlineEmoticon() {

+ ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

+ ChatWindow::ChatMessage result = testling.parseMessageBody("Lazy:)");

+ assertText(result, 0, "Lazy");

+ assertEmoticon(result, 1, smile1_, smile1Path_);

+ }

+

+ void testBoundedEmoticons() {

+ ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

+ ChatWindow::ChatMessage result = testling.parseMessageBody(":)Lazy:(");

+ assertEmoticon(result, 0, smile1_, smile1Path_);

+ assertText(result, 1, "Lazy");

+ assertEmoticon(result, 2, smile2_, smile2Path_);

+ }

+

+ void testEmoticonParenthesis() {

+ ChatMessageParser testling(emoticons_, boost::make_shared<HighlightManager::HighlightRulesList>());

+ ChatWindow::ChatMessage result = testling.parseMessageBody("(Like this :))");

+ assertText(result, 0, "(Like this ");

+ assertEmoticon(result, 1, smile1_, smile1Path_);

+ assertText(result, 2, ")");

+ }

+

+private:

+ std::map<std::string, std::string> emoticons_;

+ std::string smile1_;

+ std::string smile1Path_;

+ std::string smile2_;

+ std::string smile2Path_;

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(ChatMessageParserTest);

+

+#include <hippomocks.h>

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

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

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

+#include <Swiften/Client/ClientBlockListManager.h>

+#include <Swiften/Client/DummyStanzaChannel.h>

+#include <Swiften/Client/NickResolver.h>

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

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

+#include <Swiften/Disco/CapsProvider.h>

+#include <Swiften/Disco/EntityCapsManager.h>

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

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

+#include <Swiften/FileTransfer/UnitTest/DummyFileTransferManager.h>

+#include <Swiften/Jingle/JingleSessionManager.h>

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

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

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

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

+#include <Swiften/Queries/DummyIQChannel.h>

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

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

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

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

+#include <Swiften/Whiteboard/WhiteboardSessionManager.h>

+

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

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

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

+#include <Swift/Controllers/Chat/UnitTest/MockChatListWindow.h>

+#include <Swift/Controllers/FileTransfer/FileTransferOverview.h>

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

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

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

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

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

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

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

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

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

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

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

+#include <Swift/Controllers/UnitTest/MockChatWindow.h>

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

+#include <Swift/Controllers/XMPPEvents/EventController.h>

+

+ avatarManager_ = new NullAvatarManager();

+ wbSessionManager_ = new WhiteboardSessionManager(iqRouter_, stanzaChannel_, presenceOracle_, entityCapsManager_);

+ wbManager_ = new WhiteboardManager(whiteboardWindowFactory_, uiEventStream_, nickResolver_, wbSessionManager_);

+ highlightManager_ = new HighlightManager(settings_);

+ crypto_ = PlatformCryptoProvider::create();

+ vcardStorage_ = new VCardMemoryStorage(crypto_);

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

+ clientBlockListManager_ = new ClientBlockListManager(iqRouter_);

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

+ }

+ delete highlightManager_;

+ delete clientBlockListManager_;

+ delete vcardManager_;

+ delete vcardStorage_;

+ delete crypto_;

+ delete wbSessionManager_;

+ delete wbManager_;

+ message->setBody("This will cause the window to open");

+ WhiteboardWindowFactory* whiteboardWindowFactory_;

+ WhiteboardSessionManager* wbSessionManager_;

+ WhiteboardManager* wbManager_;

+ HighlightManager* highlightManager_;

+ ClientBlockListManager* clientBlockListManager_;

+ VCardManager* vcardManager_;

+ CryptoProvider* crypto_;

+ VCardStorage* vcardStorage_;

+ std::map<std::string, std::string> emoticons_;

+ * Copyright (c) 2010-2014 Kevin Smith

+#include <hippomocks.h>

+#include "Swiften/Base/foreach.h"

+#include "Swiften/MUC/UnitTest/MockMUC.h"

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

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

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

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

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

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

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

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

+#include <Swift/Controllers/Roster/GroupRosterItem.h>

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

+ CPPUNIT_TEST(testCorrectMessageWithLabelItem);

+ CPPUNIT_TEST(testRoleAffiliationStates);

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

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

+ settings_ = new DummySettingsProvider();

+ highlightManager_ = new HighlightManager(settings_);

+ muc_ = boost::make_shared<MockMUC>(mucJID_);

+ chatMessageParser_ = boost::make_shared<ChatMessageParser>(std::map<std::string, std::string>(), highlightManager_->getRules(), true);

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

+ }

+ delete vcardManager_;

+ delete vcardStorage_;

+ delete highlightManager_;

+ delete settings_;

+ delete entityCapsProvider_;

+ boost::shared_ptr<SecurityLabel> label = boost::make_shared<SecurityLabel>();

+ void testCorrectMessageWithLabelItem() {

+ boost::shared_ptr<SecurityLabel> label = boost::make_shared<SecurityLabel>();

+ label->setLabel("a");

+ SecurityLabelsCatalog::Item labelItem;

+ labelItem.setSelector("Bob");

+ labelItem.setLabel(label);

+ boost::shared_ptr<SecurityLabel> label2 = boost::make_shared<SecurityLabel>();

+ label->setLabel("b");

+ SecurityLabelsCatalog::Item labelItem2;

+ labelItem2.setSelector("Charlie");

+ labelItem2.setLabel(label2);

+ window_->label_ = labelItem;

+ boost::shared_ptr<DiscoInfo> features = boost::make_shared<DiscoInfo>();

+ features->addFeature(DiscoInfo::SecurityLabelsCatalogFeature);

+ controller_->setAvailableServerFeatures(features);

+ IQ::ref iq = iqChannel_->iqs_[iqChannel_->iqs_.size() - 1];

+ SecurityLabelsCatalog::ref labelPayload = boost::make_shared<SecurityLabelsCatalog>();

+ labelPayload->addItem(labelItem);

+ IQ::ref result = IQ::createResult(self_, iq->getID(), labelPayload);

+ iqChannel_->onIQReceived(result);

+ std::string messageBody("agamemnon");

+ window_->onSendMessageRequest(messageBody, false);

+ boost::shared_ptr<Stanza> rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

+ Message::ref message = boost::dynamic_pointer_cast<Message>(rawStanza);

+ CPPUNIT_ASSERT_EQUAL(iq->getTo(), result->getFrom());

+ CPPUNIT_ASSERT(window_->labelsEnabled_);

+ CPPUNIT_ASSERT(stanzaChannel_->isAvailable()); /* Otherwise will prevent sends. */

+ CPPUNIT_ASSERT(message);

+ CPPUNIT_ASSERT_EQUAL(messageBody, message->getBody());

+ CPPUNIT_ASSERT_EQUAL(label, message->getPayload<SecurityLabel>());

+ window_->label_ = labelItem2;

+ window_->onSendMessageRequest(messageBody, true);

+ rawStanza = stanzaChannel_->sentStanzas[stanzaChannel_->sentStanzas.size() - 1];

+ message = boost::dynamic_pointer_cast<Message>(rawStanza);

+ CPPUNIT_ASSERT_EQUAL(messageBody, message->getBody());

+ CPPUNIT_ASSERT_EQUAL(label, message->getPayload<SecurityLabel>());

+ }

+

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

+ }

+

+ JID jidFromOccupant(const MUCOccupant& occupant) {

+ return JID(mucJID_.toString()+"/"+occupant.getNick());

+ }

+

+ void testRoleAffiliationStates() {

+

+ typedef std::map<std::string, MUCOccupant> occupant_map;

+ occupant_map occupants;

+ occupants.insert(occupant_map::value_type("Kev", MUCOccupant("Kev", MUCOccupant::Participant, MUCOccupant::Owner)));

+ occupants.insert(occupant_map::value_type("Remko", MUCOccupant("Remko", MUCOccupant::Participant, MUCOccupant::Owner)));

+ occupants.insert(occupant_map::value_type("Bert", MUCOccupant("Bert", MUCOccupant::Participant, MUCOccupant::Owner)));

+ occupants.insert(occupant_map::value_type("Ernie", MUCOccupant("Ernie", MUCOccupant::Participant, MUCOccupant::Owner)));

+

+ /* populate the MUC with fake users */

+ typedef const std::pair<std::string,MUCOccupant> occupantIterator;

+ foreach(occupantIterator &occupant, occupants) {

+ muc_->insertOccupant(occupant.second);

+ }

+

+ std::vector<MUCOccupant> alterations;

+ alterations.push_back(MUCOccupant("Kev", MUCOccupant::Visitor, MUCOccupant::Admin));

+ alterations.push_back(MUCOccupant("Remko", MUCOccupant::Moderator, MUCOccupant::Member));

+ alterations.push_back(MUCOccupant("Bert", MUCOccupant::Visitor, MUCOccupant::Outcast));

+ alterations.push_back(MUCOccupant("Ernie", MUCOccupant::NoRole, MUCOccupant::Member));

+ alterations.push_back(MUCOccupant("Bert", MUCOccupant::Moderator, MUCOccupant::Owner));

+ alterations.push_back(MUCOccupant("Kev", MUCOccupant::Participant, MUCOccupant::Outcast));

+ alterations.push_back(MUCOccupant("Bert", MUCOccupant::Visitor, MUCOccupant::NoAffiliation));

+ alterations.push_back(MUCOccupant("Remko", MUCOccupant::NoRole, MUCOccupant::NoAffiliation));

+ alterations.push_back(MUCOccupant("Ernie", MUCOccupant::Visitor, MUCOccupant::Outcast));

+

+ foreach(const MUCOccupant& alteration, alterations) {

+ /* perform an alteration to a user's role and affiliation */

+ occupant_map::iterator occupant = occupants.find(alteration.getNick());

+ CPPUNIT_ASSERT(occupant != occupants.end());

+ const JID jid = jidFromOccupant(occupant->second);

+ /* change the affiliation, leave the role in place */

+ muc_->changeAffiliation(jid, alteration.getAffiliation());

+ occupant->second = MUCOccupant(occupant->first, occupant->second.getRole(), alteration.getAffiliation());

+ testRoleAffiliationStatesVerify(occupants);

+ /* change the role, leave the affiliation in place */

+ muc_->changeOccupantRole(jid, alteration.getRole());

+ occupant->second = MUCOccupant(occupant->first, alteration.getRole(), occupant->second.getAffiliation());

+ testRoleAffiliationStatesVerify(occupants);

+ }

+ }

+

+ void testRoleAffiliationStatesVerify(const std::map<std::string, MUCOccupant> &occupants) {

+ /* verify that the roster is in sync */

+ GroupRosterItem* group = window_->getRosterModel()->getRoot();

+ foreach(RosterItem* rosterItem, group->getChildren()) {

+ GroupRosterItem* child = dynamic_cast<GroupRosterItem*>(rosterItem);

+ CPPUNIT_ASSERT(child);

+ foreach(RosterItem* childItem, child->getChildren()) {

+ ContactRosterItem* item = dynamic_cast<ContactRosterItem*>(childItem);

+ CPPUNIT_ASSERT(item);

+ std::map<std::string, MUCOccupant>::const_iterator occupant = occupants.find(item->getJID().getResource());

+ CPPUNIT_ASSERT(occupant != occupants.end());

+ CPPUNIT_ASSERT(item->getMUCRole() == occupant->second.getRole());

+ CPPUNIT_ASSERT(item->getMUCAffiliation() == occupant->second.getAffiliation());

+ }

+ }

+ MockMUC::ref muc_;

+ UserSearchWindowFactory* userSearchWindowFactory_;

+ DummySettingsProvider* settings_;

+ HighlightManager* highlightManager_;

+ boost::shared_ptr<ChatMessageParser> chatMessageParser_;

+ boost::shared_ptr<CryptoProvider> crypto_;

+ VCardManager* vcardManager_;

+ VCardMemoryStorage* vcardStorage_;

+ * Copyright (c) 2011-2014 Kevin Smith

+ MockChatListWindow() {}

+ virtual ~MockChatListWindow() {}

+ void addWhiteboardSession(const ChatListWindow::Chat& /*chat*/) {}

+ void removeWhiteboardSession(const JID& /*jid*/) {}

+ void setOnline(bool /*isOnline*/) {}

+ * Copyright (c) 2010-2014 Kevin Smith

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

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

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

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

+UserSearchWindow* UserSearchController::getUserSearchWindow() {

+ initializeUserWindow();

+ assert(window_);

+ return window_;

+}

+

+void UserSearchController::setCanInitiateImpromptuMUC(bool supportsImpromptu) {

+ if (!window_) {

+ initializeUserWindow();

+ }

+ window_->setCanStartImpromptuChats(supportsImpromptu);

+}

+

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

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

+ switch (type_) {

+ case AddContact:

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

+ break;

+ case StartChat:

+ break;

+ case InviteToChat:

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

+ handle = true;

+ break;

+ if (handle) {

+ initializeUserWindow();

+ if (addUserRequest) {

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

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

+ } else if (inviteToMUCRequest) {

+ window_->setCanSupplyDescription(!inviteToMUCRequest->isImpromptu());

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

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

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

+ const std::vector<JID> existingJIDs = window_->getJIDs();

+ std::vector<Contact::ref> suggestions = contactSuggester_->getSuggestions(text, false);

+ /* do not suggest contacts that have already been added to the chat list */

+ std::vector<Contact::ref>::iterator i = suggestions.begin();

+ while (i != suggestions.end()) {

+ bool found = false;

+ foreach (const JID& jid, existingJIDs) {

+ if ((*i)->jid == jid) {

+ found = true;

+ break;

+ }

+ }

+ if (found) {

+ i = suggestions.erase(i);

+ } else {

+ i++;

+ }

+ }

+ window_->setContactSuggestions(suggestions);

+}

+

+ 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::ref> updates;

+ foreach(const JID& jid, jids) {

+ updates.push_back(convertJIDtoContact(jid));

+ }

+ window_->updateContacts(updates);

+ }

+}

+

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

+ std::vector<Contact::ref> contacts;

+ foreach(const JID& jid, jids) {

+ contacts.push_back(convertJIDtoContact(jid));

+ }

+ window_->addContacts(contacts);

+}

+

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

+ Contact::ref contact = boost::make_shared<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_->onJIDAddRequested.connect(boost::bind(&UserSearchController::handleJIDAddRequested, this, _1));

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

+ window_->clear();

+ }

+}

+

+ * Copyright (c) 2010-2014 Kevin Smith

+

+

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

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

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

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

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

+ class ContactSuggester;

+ class AvatarManager;

+ class PresenceOracle;

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

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

+ Contact::ref convertJIDtoContact(const JID& jid);

+ void initializeUserWindow();

+ ContactSuggester* contactSuggester_;

+ AvatarManager* avatarManager_;

+ PresenceOracle* presenceOracle_;