+/*

+ * Copyright (c) 2014-2016 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

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

+

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

+ 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-2019 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+#include <Swift/Controllers/XMPPEvents/IncomingFileTransferEvent.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, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings, Chattables& chattables)

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

+ isInMUC_ = isInMUC;

+ lastWasPresence_ = false;

+ chatStateNotifier_ = new ChatStateNotifier(stanzaChannel, contact, entityCapsProvider, timerFactory, 20000);

+ chatStateTracker_ = new ChatStateTracker();

+ nickResolver_ = nickResolver;

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

+ chatStateTracker_->onChatStateChange.connect(boost::bind(&ChatWindow::setContactChatState, chatWindow_, _1));

+ stanzaChannel_->onStanzaAcked.connect(boost::bind(&ChatController::handleStanzaAcked, this, _1));

+ nickResolver_->onNickChanged.connect(boost::bind(&ChatController::handleContactNickChanged, this, _1, _2));

+ std::string nick = nickResolver_->jidToNick(toJID_);

+ chatWindow_->setName(nick);

+ std::string startMessage;

+ Presence::ref theirPresence;

+ if (isInMUC) {

+ startMessage = str(format(QT_TRANSLATE_NOOP("", "Starting chat with %1% in chatroom %2%")) % nick % contact.toBare().toString());

+ theirPresence = presenceOracle->getLastPresence(contact);

+ } else {

+ startMessage = str(format(QT_TRANSLATE_NOOP("", "Starting chat with %1% - %2%")) % nick % contact.toBare().toString());

+ theirPresence = contact.isBare() ? presenceOracle->getAccountPresence(contact) : presenceOracle->getLastPresence(contact);

+ }

+ Idle::ref idle;

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

+ startMessage += str(format(QT_TRANSLATE_NOOP("", ", who has been idle since %1%")) % Swift::Translator::getInstance()->ptimeToHumanReadableString(idle->getSince()));

+ }

+ startMessage += ": " + statusShowTypeToFriendlyName(theirPresence ? theirPresence->getShow() : StatusShow::None);

+ if (theirPresence && !theirPresence->getStatus().empty()) {

+ startMessage += " (" + theirPresence->getStatus() + ")";

+ }

+ lastShownStatus_ = theirPresence ? theirPresence->getShow() : StatusShow::None;

+ chatStateNotifier_->setContactIsOnline(theirPresence && theirPresence->getType() == Presence::Available);

+ startMessage += ".";

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

+ continuationsBrokenConnection_ = chatWindow_->onContinuationsBroken.connect([this, startMessage]() { chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(startMessage), ChatWindow::DefaultDirection); });

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

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

+ chatWindow_->onFileTransferStart.connect(boost::bind(&ChatController::handleFileTransferStart, this, _1, _2));

+ chatWindow_->onFileTransferAccept.connect(boost::bind(&ChatController::handleFileTransferAccept, this, _1, _2));

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

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

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

+ ChatController::handleBareJIDCapsChanged(toJID_);

+

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

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

+ if (jid.toBare() == toJID_.toBare()) {

+ chatWindow_->setName(nickResolver_->jidToNick(toJID_));

+ }

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

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

+ nickResolver_->onNickChanged.disconnect(boost::bind(&ChatController::handleContactNickChanged, this, _1, _2));

+ delete chatStateNotifier_;

+ delete chatStateTracker_;

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

+ lastWasPresence_ = false;

+ FeatureOracle featureOracle(entityCapsProvider_, presenceOracle_);

+

+ chatWindow_->setCorrectionEnabled(featureOracle.isMessageCorrectionSupported(toJID_));

+ chatWindow_->setFileTransferEnabled(isInMUC_ ? No : featureOracle.isFileTransferSupported(toJID_));

+ contactSupportsReceipts_ = featureOracle.isMessageReceiptsSupported(toJID_);

+

+ checkForDisplayingDisplayReceiptsAlert();

+ chatStateNotifier_->setContact(jid);

+ ChatControllerBase::setToJID(jid);

+ Presence::ref presence;

+ if (isInMUC_) {

+ presence = presenceOracle_->getLastPresence(jid);

+ } else {

+ presence = jid.isBare() ? presenceOracle_->getAccountPresence(jid.toBare()) : presenceOracle_->getLastPresence(jid);

+ }

+ chatStateNotifier_->setContactIsOnline(presence && presence->getType() == Presence::Available);

+ handleBareJIDCapsChanged(toJID_);

+}

+

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

+ ChatControllerBase::setAvailableServerFeatures(info);

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

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

+ }

+}

+

+bool ChatController::isIncomingMessageFromMe(std::shared_ptr<Message>) {

+ return false;

+}

+

+void ChatController::preHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent) {

+ if (messageEvent->isReadable()) {

+ chatWindow_->flash();

+ lastWasPresence_ = false;

+ }

+ std::shared_ptr<Message> message = messageEvent->getStanza();

+ JID from = message->getFrom();

+ if (!from.equals(toJID_, JID::WithResource)) {

+ if (toJID_.equals(from, JID::WithoutResource) && toJID_.isBare()){

+ // Bind controller to a full JID if message contains body text or is a typing chat state.

+ ChatState::ref chatState = message->getPayload<ChatState>();

+ if (!message->getBody().get_value_or("").empty() || (chatState && chatState->getChatState() == ChatState::Composing)) {

+ setToJID(from);

+ }

+ }

+ }

+ chatStateTracker_->handleMessageReceived(message);

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

+

+ // handle XEP-0184 Message Receipts

+ // incomming receipts

+ if (std::shared_ptr<DeliveryReceipt> receipt = message->getPayload<DeliveryReceipt>()) {

+ SWIFT_LOG(debug) << "received receipt for id: " << receipt->getReceivedID();

+ if (requestedReceipts_.find(receipt->getReceivedID()) != requestedReceipts_.end()) {

+ chatWindow_->setMessageReceiptState(requestedReceipts_[receipt->getReceivedID()], ChatWindow::ReceiptReceived);

+ requestedReceipts_.erase(receipt->getReceivedID());

+ }

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

+ } else if (message->getPayload<DeliveryReceiptRequest>()) {

+ if (receivingPresenceFromUs_) {

+ std::shared_ptr<Message> receiptMessage = std::make_shared<Message>();

+ receiptMessage->setTo(toJID_);

+ receiptMessage->addPayload(std::make_shared<DeliveryReceipt>(message->getID()));

+ stanzaChannel_->sendMessage(receiptMessage);

+ }

+ }

+}

+

+void ChatController::postHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent, const ChatWindow::ChatMessage& chatMessage) {

+ highlighter_->handleSystemNotifications(chatMessage, messageEvent);

+ eventController_->handleIncomingEvent(messageEvent);

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

+ highlighter_->handleSoundNotifications(chatMessage);

+ }

+}

+

+

+void ChatController::preSendMessageRequest(std::shared_ptr<Message> message) {

+ chatStateNotifier_->addChatStateRequest(message);

+ if (userWantsReceipts_ && (contactSupportsReceipts_ != No) && message) {

+ message->addPayload(std::make_shared<DeliveryReceiptRequest>());

+ }

+ receivingPresenceFromUs_ = isReceivingPresence;

+ if (settingPath == SettingConstants::REQUEST_DELIVERYRECEIPTS.getKey()) {

+ userWantsReceipts_ = settings_->getSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS);

+ checkForDisplayingDisplayReceiptsAlert();

+ }

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

+ if (userWantsReceipts_ && (contactSupportsReceipts_ == No)) {

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

+ } else if (userWantsReceipts_ && (contactSupportsReceipts_ == Maybe)) {

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

+ } else {

+ if (deliveryReceiptAlert_) {

+ chatWindow_->removeAlert(*deliveryReceiptAlert_);

+ deliveryReceiptAlert_.reset();

+ }

+ }

+ if (newDeliverReceiptAlert) {

+ if (deliveryReceiptAlert_) {

+ chatWindow_->removeAlert(*deliveryReceiptAlert_);

+ }

+ deliveryReceiptAlert_ = newDeliverReceiptAlert;

+ }

+ std::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_->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_->setBlockingState(ChatWindow::IsUnblocked);

+

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

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

+ }

+ }

+ if (isInMUC_) {

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

+ } else {

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

+ }

+ if (isInMUC_) {

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

+ } else {

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

+ }

+ std::shared_ptr<UIEvent> event(new RequestInviteToMUCUIEvent(getToJID(), droppedJIDs, RequestInviteToMUCUIEvent::Impromptu));

+ eventStream_->send(event);

+void ChatController::handleWindowClosed() {

+ onWindowClosed();

+void ChatController::handleUIEvent(std::shared_ptr<UIEvent> event) {

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

+ if (inviteEvent && inviteEvent->getOriginator() == getToJID()) {

+ onConvertToMUC(detachChatWindow(), inviteEvent->getInvites(), inviteEvent->getReason());

+ }

+}

+void ChatController::handleIncomingOwnMessage(std::shared_ptr<Message> message) {

+ if (!message->getBody().get_value_or("").empty()) {

+ postSendMessage(message->getBody().get_value_or(""), message);

+ handleStanzaAcked(message);

+ onActivity(message->getBody().get_value_or(""));

+ }

+}

+void ChatController::postSendMessage(const std::string& body, std::shared_ptr<Stanza> sentStanza) {

+ std::shared_ptr<Replace> replace = sentStanza->getPayload<Replace>();

+ if (replace) {

+ eraseIf(unackedStanzas_, PairSecondEquals<std::shared_ptr<Stanza>, std::string>(myLastMessageUIID_));

+ replaceMessage(chatMessageParser_->parseMessageBody(body, "", true), myLastMessageUIID_, boost::posix_time::microsec_clock::universal_time());

+ } else {

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

+ }

+ if (stanzaChannel_->getStreamManagementEnabled() && !myLastMessageUIID_.empty() ) {

+ chatWindow_->setAckState(myLastMessageUIID_, ChatWindow::Pending);

+ unackedStanzas_[sentStanza] = myLastMessageUIID_;

+ }

+ if (sentStanza->getPayload<DeliveryReceiptRequest>()) {

+ requestedReceipts_[sentStanza->getID()] = myLastMessageUIID_;

+ chatWindow_->setMessageReceiptState(myLastMessageUIID_, ChatWindow::ReceiptRequested);

+ }

+

+ lastWasPresence_ = false;

+ chatStateNotifier_->userSentMessage();

+void ChatController::handleStanzaAcked(std::shared_ptr<Stanza> stanza) {

+ std::map<std::shared_ptr<Stanza>, std::string>::iterator unackedStanza = unackedStanzas_.find(stanza);

+ if (unackedStanza != unackedStanzas_.end()) {

+ chatWindow_->setAckState(unackedStanza->second, ChatWindow::Received);

+ unackedStanzas_.erase(unackedStanza);

+ }

+ if (!online) {

+ for (auto& stanzaIdPair : unackedStanzas_) {

+ chatWindow_->setAckState(stanzaIdPair.second, ChatWindow::Failed);

+ failedStanzas_[stanzaIdPair.second] = stanzaIdPair.first;

+ }

+ unackedStanzas_.clear();

+ Presence::ref fakeOffline(new Presence());

+ fakeOffline->setFrom(toJID_);

+ fakeOffline->setType(Presence::Unavailable);

+ chatStateTracker_->handlePresenceChange(fakeOffline);

+ }

+ ChatControllerBase::setOnline(online);

+ std::string nick = senderDisplayNameFromMessage(ftc->getOtherParty());

+ std::string avatarPath;

+ if (ftc->isIncoming()) {

+ avatarPath = pathToString(avatarManager_->getAvatarPath(ftc->getOtherParty()));

+ }

+ else {

+ avatarPath = pathToString(avatarManager_->getAvatarPath(selfJID_));

+ }

+

+ std::string ftID = ftc->setChatWindow(chatWindow_, nick, avatarPath);

+ ftControllers[ftID] = ftc;

+ lastWasPresence_ = false;

+

+ if (ftc->isIncoming()) {

+ auto incomingFileTransferEvent = std::make_shared<IncomingFileTransferEvent>(ftc->getOtherParty());

+ if (hasOpenWindow()) {

+ incomingFileTransferEvent->conclude();

+ }

+ else {

+ unreadMessages_.push_back(incomingFileTransferEvent);

+ updateMessageCount();

+ }

+ eventController_->handleIncomingEvent(incomingFileTransferEvent);

+ }

+ lastWbID_ = chatWindow_->addWhiteboardRequest(senderIsSelf);

+ chatWindow_->setWhiteboardSessionStatus(lastWbID_, state);

+ SWIFT_LOG(debug) << "handleFileTransferCancel(" << id << ")";

+ if (ftControllers.find(id) != ftControllers.end()) {

+ ftControllers[id]->cancel();

+ } else {

+ std::cerr << "unknown file transfer UI id" << std::endl;

+ }

+ SWIFT_LOG(debug) << "handleFileTransferStart(" << id << ", " << description << ")";

+ if (ftControllers.find(id) != ftControllers.end()) {

+ ftControllers[id]->start(description);

+ } else {

+ std::cerr << "unknown file transfer UI id" << std::endl;

+ }

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

+ if (ftControllers.find(id) != ftControllers.end()) {

+ ftControllers[id]->accept(filename);

+ } else {

+ std::cerr << "unknown file transfer UI id" << std::endl;

+ }

+ SWIFT_LOG(debug) << "ChatController::handleSendFileRequest(" << filename << ")";

+ eventStream_->send(std::make_shared<SendFileUIEvent>(getToJID(), filename));

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

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

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

+}

+

+std::string ChatController::senderHighlightNameFromMessage(const JID& from) {

+ if (isInMUC_) {

+ return nickResolver_->jidToNick(from);

+ }

+ else {

+ return from.toBare().toString();

+ }

+ return nickResolver_->jidToNick(from);

+}

+

+std::string ChatController::getStatusChangeString(std::shared_ptr<Presence> presence) {

+ std::string nick = senderDisplayNameFromMessage(presence->getFrom());

+ std::string response;

+ if (!presence || presence->getType() == Presence::Unavailable || presence->getType() == Presence::Error) {

+ response = QT_TRANSLATE_NOOP("", "%1% has gone offline");

+ } else if (presence->getType() == Presence::Available) {

+ StatusShow::Type show = presence->getShow();

+ if (show == StatusShow::Online || show == StatusShow::FFC) {

+ response = QT_TRANSLATE_NOOP("", "%1% has become available");

+ } else if (show == StatusShow::Away || show == StatusShow::XA) {

+ response = QT_TRANSLATE_NOOP("", "%1% has gone away");

+ } else if (show == StatusShow::DND) {

+ response = QT_TRANSLATE_NOOP("", "%1% is now busy");

+ }

+ }

+ Idle::ref idle;

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

+ response += str(format(QT_TRANSLATE_NOOP("", " and has been idle since %1%")) % Swift::Translator::getInstance()->ptimeToHumanReadableString(idle->getSince()));

+ }

+

+ if (!response.empty()) {

+ response = str(format(response) % nick);

+ }

+

+ if (!presence->getStatus().empty()) {

+ response += " (" + presence->getStatus() + ")";

+ }

+ return response + ".";

+}

+

+void ChatController::handlePresenceChange(std::shared_ptr<Presence> newPresence) {

+ bool relevantPresence = false;

+

+ if (isInMUC_) {

+ // For MUC participants we only have a single presence to choose one and

+ // even for multi-session nicknames multiple resources are not distinguishable

+ // to other participants.

+ if (toJID_.equals(newPresence->getFrom(), JID::WithResource)) {

+ relevantPresence = true;

+ }

+ }

+ else {

+ // For standard chats we retrieve the account presence from the PresenceOracle,

+ // as there can be multiple presences to choose from.

+ if (toJID_.equals(newPresence->getFrom(), JID::WithoutResource)) {

+ // Presence matches ChatController JID.

+ newPresence = presenceOracle_->getAccountPresence(toJID_);

+ relevantPresence = true;

+ }

+ }

+

+ if (!relevantPresence) {

+ return;

+ }

+

+ if (!newPresence) {

+ newPresence = std::make_shared<Presence>();

+ newPresence->setType(Presence::Unavailable);

+ }

+ lastShownStatus_ = newPresence->getShow();

+

+ chatStateTracker_->handlePresenceChange(newPresence);

+ chatStateNotifier_->setContactIsOnline(newPresence->getType() == Presence::Available);

+ std::string newStatusChangeString = getStatusChangeString(newPresence);

+ if (newStatusChangeString != lastStatusChangeString_) {

+ if (lastWasPresence_) {

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

+ } else {

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

+ }

+ lastStatusChangeString_ = newStatusChangeString;

+ lastWasPresence_ = true;

+ }

+}

+

+boost::optional<boost::posix_time::ptime> ChatController::getMessageTimestamp(std::shared_ptr<Message> message) const {

+ return message->getTimestamp();

+}

+

+void ChatController::addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) {

+ lastMessagesIDs_[from.toBare()] = {messageID, addMessage(message, senderDisplayNameFromMessage(from), senderIsSelf, label, avatarManager_->getAvatarPath(from), timeStamp)};

+}

+

+void ChatController::handleIncomingReplaceMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, const std::string& idToReplace, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) {

+ auto lastMessage = lastMessagesIDs_.find(from.toBare());

+ if ((lastMessage != lastMessagesIDs_.end()) && (lastMessage->second.idInStream == idToReplace)) {

+ replaceMessage(message, lastMessage->second.idInWindow, timeStamp);

+ }

+ else {

+ addMessageHandleIncomingMessage(from, message, messageID, senderIsSelf, label, timeStamp);

+ }

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

+ }

+}

+

+bool ChatController::shouldIgnoreMessage(std::shared_ptr<Message> message) {

+ if (!message->getID().empty()) {

+ if (message->getID() == lastHandledMessageID_) {

+ return true;

+ }

+ else {

+ lastHandledMessageID_ = message->getID();

+ }

+ }

+ return false;

+}

+JID ChatController::messageCorrectionJID(const JID& fromJID) {

+ return fromJID.toBare();

+ continuationsBrokenConnection_.disconnect();

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

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

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

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

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

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

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

+ chatWindow_->onSendFileRequest.disconnect(boost::bind(&ChatController::handleSendFileRequest, this, _1));

+ chatWindow_->onFileTransferCancel.disconnect(boost::bind(&ChatController::handleFileTransferCancel, this, _1));

+ chatWindow_->onFileTransferAccept.disconnect(boost::bind(&ChatController::handleFileTransferAccept, this, _1, _2));

+ chatWindow_->onFileTransferStart.disconnect(boost::bind(&ChatController::handleFileTransferStart, this, _1, _2));

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

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

+ return ChatControllerBase::detachChatWindow();

+ * Copyright (c) 2010-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

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

+

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

+ class AvatarManager;

+ class ChatStateNotifier;

+ class ChatStateTracker;

+ class ClientBlockListManager;

+ class EntityCapsProvider;

+ class FileTransferController;

+ class HighlightManager;

+ class HistoryController;

+ class NickResolver;

+ class SettingsProvider;

+ class TimerFactory;

+ class UIEvent;

+

+ class ChatController : public ChatControllerBase {

+ public:

+ 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, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings, Chattables& chattables);

+ virtual ~ChatController() override;

+ virtual void setToJID(const JID& jid) override;

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

+ virtual void setOnline(bool online) override;

+ virtual void handleNewFileTransferController(FileTransferController* ftc);

+ virtual void handleWhiteboardSessionRequest(bool senderIsSelf);

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

+ virtual void setContactIsReceivingPresence(bool /*isReceivingPresence*/) override;

+ virtual ChatWindow* detachChatWindow() override;

+ virtual void handleIncomingOwnMessage(std::shared_ptr<Message> message) override;

+

+ protected:

+ virtual void cancelReplaces() override;

+ virtual JID getBaseJID() override;

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

+ virtual bool shouldIgnoreMessage(std::shared_ptr<Message> message) override;

+ virtual JID messageCorrectionJID(const JID& fromJID) override;

+

+ private:

+ void handlePresenceChange(std::shared_ptr<Presence> newPresence);

+ std::string getStatusChangeString(std::shared_ptr<Presence> presence);

+ virtual bool isIncomingMessageFromMe(std::shared_ptr<Message> message) override;

+ virtual void postSendMessage(const std::string &body, std::shared_ptr<Stanza> sentStanza) override;

+ virtual void preHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent) override;

+ virtual void addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) override;

+ virtual void handleIncomingReplaceMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, const std::string& idToReplace, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) override;

+ virtual void postHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent, const ChatWindow::ChatMessage& chatMessage) override;

+ virtual void preSendMessageRequest(std::shared_ptr<Message>) override;

+ virtual std::string senderHighlightNameFromMessage(const JID& from) override;

+ virtual std::string senderDisplayNameFromMessage(const JID& from) override;

+ virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(std::shared_ptr<Message>) const override;

+ void handleStanzaAcked(std::shared_ptr<Stanza> stanza);

+ virtual void dayTicked() override { lastWasPresence_ = false; }

+ void handleContactNickChanged(const JID& jid, const std::string& /*oldNick*/);

+ virtual void handleBareJIDCapsChanged(const JID& jid) override;

+

+ void handleFileTransferCancel(std::string /* id */);

+ void handleFileTransferStart(std::string /* id */, std::string /* description */);

+ void handleFileTransferAccept(std::string /* id */, std::string /* filename */);

+ void handleSendFileRequest(std::string filename);

+

+ void handleWhiteboardSessionAccept();

+ void handleWhiteboardSessionCancel();

+ void handleWhiteboardWindowShow();

+

+ void handleSettingChanged(const std::string& settingPath);

+ void checkForDisplayingDisplayReceiptsAlert();

+

+ void handleBlockingStateChanged();

+ void handleBlockUserRequest();

+ void handleUnblockUserRequest();

+

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

+

+ void handleWindowClosed();

+

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

+

+ private:

+ NickResolver* nickResolver_;

+ ChatStateNotifier* chatStateNotifier_;

+ ChatStateTracker* chatStateTracker_;

+ std::string myLastMessageUIID_;

+ bool isInMUC_;

+ std::string lastStatusChangeString_;

+ StatusShow::Type lastShownStatus_;

+

+ Tristate contactSupportsReceipts_;

+ bool receivingPresenceFromUs_ = false;

+ bool userWantsReceipts_;

+ std::map<std::string, FileTransferController*> ftControllers;

+ std::string lastWbID_;

+ std::string lastHandledMessageID_;

+

+ ClientBlockListManager* clientBlockListManager_;

+ boost::signals2::scoped_connection blockingOnStateChangedConnection_;

+ boost::signals2::scoped_connection blockingOnItemAddedConnection_;

+ boost::signals2::scoped_connection blockingOnItemRemovedConnection_;

+ boost::signals2::scoped_connection continuationsBrokenConnection_;

+

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

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

+ };

+ * Copyright (c) 2010-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+#include <sstream>

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

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

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

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

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

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

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

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

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

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

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

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

+ChatControllerBase::ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings, Chattables& chattables) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), entityCapsProvider_(entityCapsProvider), historyController_(historyController), mucRegistry_(mucRegistry), chatMessageParser_(chatMessageParser), autoAcceptMUCInviteDecider_(autoAcceptMUCInviteDecider), eventStream_(eventStream), roomSecurityMarking_(""), previousMessageSecurityMarking_(""), settings_(settings), chattables_(chattables) {

+ chatWindow_ = chatWindowFactory_->createChatWindow(toJID, eventStream);

+ chatWindow_->onAllMessagesRead.connect(boost::bind(&ChatControllerBase::handleAllMessagesRead, this));

+ chatWindow_->onSendMessageRequest.connect(boost::bind(&ChatControllerBase::handleSendMessageRequest, this, _1, _2));

+ chatWindow_->onContinuationsBroken.connect(boost::bind(&ChatControllerBase::handleContinuationsBroken, this));

+ scopedConnectionResendMessage_ = chatWindow_->onResendMessageRequest.connect(boost::bind(&ChatControllerBase::handleResendMessageRequest, this, _1));

+ entityCapsProvider_->onCapsChanged.connect(boost::bind(&ChatControllerBase::handleCapsChanged, this, _1));

+ highlighter_ = highlightManager->createHighlighter(nickResolver);

+ ChatControllerBase::setOnline(stanzaChannel->isAvailable() && iqRouter->isAvailable());

+ delete highlighter_;

+ delete chatWindow_;

+void ChatControllerBase::handleContinuationsBroken() {

+ cancelReplaces();

+ chatWindow_->onContinuationsBroken.disconnect(boost::bind(&ChatControllerBase::handleContinuationsBroken, this));

+ chatWindow_->onSendMessageRequest.disconnect(boost::bind(&ChatControllerBase::handleSendMessageRequest, this, _1, _2));

+ chatWindow_->onAllMessagesRead.disconnect(boost::bind(&ChatControllerBase::handleAllMessagesRead, this));

+ scopedConnectionResendMessage_.disconnect();

+ ChatWindow* chatWindow = chatWindow_;

+ chatWindow_ = nullptr;

+ return chatWindow;

+ if (jid.compare(toJID_, JID::WithoutResource) == 0) {

+ handleBareJIDCapsChanged(jid);

+ }

+ if (chatWindow_) {

+ chatWindow_->setCanInitiateImpromptuChats(supportsImpromptu);

+ }

+ chatWindow_->setOnline(enabled);

+ chatWindow_->setCanInitiateImpromptuChats(false);

+ setEnabled(online);

+ return JID(toJID_.toBare());

+void ChatControllerBase::setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info) {

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

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

+ request->onResponse.connect(boost::bind(&ChatControllerBase::handleSecurityLabelsCatalogResponse, this, _1, _2));

+ request->send();

+ } else {

+ chatWindow_->setSecurityLabelsEnabled(false);

+ labelsEnabled_ = false;

+ }

+ if (!unreadMessages_.empty()) {

+ targetedUnreadMessages_.clear();

+ for (std::shared_ptr<StanzaEvent> stanzaEvent : unreadMessages_) {

+ stanzaEvent->conclude();

+ }

+ unreadMessages_.clear();

+ updateMessageCount();

+ }

+size_t ChatControllerBase::getUnreadCount() {

+ return targetedUnreadMessages_.size();

+ if (!stanzaChannel_->isAvailable() || body.empty()) {

+ return;

+ }

+ std::shared_ptr<Message> message(new Message());

+ message->setTo(toJID_);

+ message->setType(Swift::Message::Chat);

+ message->setBody(body);

+ if (labelsEnabled_) {

+ if (!isCorrectionMessage) {

+ lastLabel_ = chatWindow_->getSelectedSecurityLabel();

+ }

+ SecurityLabelsCatalog::Item labelItem = lastLabel_;

+ if (labelItem.getLabel()) {

+ message->addPayload(labelItem.getLabel());

+ }

+ }

+ preSendMessageRequest(message);

+

+ boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();

+ if (useDelayForLatency_) {

+ message->addPayload(std::make_shared<Delay>(now, selfJID_));

+ }

+ if (isCorrectionMessage) {

+ message->addPayload(std::shared_ptr<Replace> (new Replace(lastSentMessageStanzaID_)));

+ }

+ message->setID(lastSentMessageStanzaID_ = idGenerator_.generateID());

+ stanzaChannel_->sendMessage(message);

+ postSendMessage(message->getBody().get(), std::dynamic_pointer_cast<Stanza>(message));

+ onActivity(message->getBody().get());

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

+void ChatControllerBase::handleSecurityLabelsCatalogResponse(std::shared_ptr<SecurityLabelsCatalog> catalog, ErrorPayload::ref error) {

+ if (catalog && !error) {

+ if (catalog->getItems().size() == 0) {

+ chatWindow_->setSecurityLabelsEnabled(false);

+ labelsEnabled_ = false;

+ } else {

+ labelsEnabled_ = true;

+ chatWindow_->setAvailableSecurityLabels(catalog->getItems());

+ chatWindow_->setSecurityLabelsEnabled(true);

+ }

+ } else {

+ labelsEnabled_ = false;

+ chatWindow_->setSecurityLabelsError();

+ }

+ chatWindow_->show();

+ chatWindow_->activate();

+}

+

+bool ChatControllerBase::hasOpenWindow() const {

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

+}

+

+ChatWindow::ChatMessage ChatControllerBase::buildChatWindowChatMessage(const std::string& message, const std::string& senderName, bool senderIsSelf) {

+ ChatWindow::ChatMessage chatMessage;

+ chatMessage = chatMessageParser_->parseMessageBody(message, senderName, senderIsSelf);

+ return chatMessage;

+void ChatControllerBase::updateMessageCount() {

+ auto baseJID = getBaseJID();

+ auto state = chattables_.getState(baseJID);

+ state.unreadCount = unreadMessages_.size();

+ chatWindow_->setUnreadMessageCount(state.unreadCount);

+ chattables_.setState(baseJID, state);

+#ifndef NOT_YET

+ onUnreadCountChanged();

+#endif

+}

+

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

+ auto displayedLabel = label;

+

+ if (settings_->getSetting(SettingConstants::MUC_MARKING_ELISION)) {

+ if (roomSecurityMarking_ != "") {

+

+ if (label && label->getDisplayMarking() == roomSecurityMarking_) {

+ if (label->getDisplayMarking() == previousMessageSecurityMarking_) {

+ displayedLabel = std::make_shared<SecurityLabel>();

+ }

+ previousMessageSecurityMarking_ = label->getDisplayMarking();

+ }

+ else if (!label || label->getDisplayMarking().empty()) {

+ displayedLabel = std::make_shared<SecurityLabel>();

+ displayedLabel->setDisplayMarking("Unmarked");

+ previousMessageSecurityMarking_ = "Unmarked";

+ }

+ else {

+ previousMessageSecurityMarking_ = displayedLabel->getDisplayMarking();

+ }

+ }

+ }

+

+ if (chatMessage.isMeCommand()) {

+ return chatWindow_->addAction(chatMessage, senderName, senderIsSelf, displayedLabel, pathToString(avatarPath), time);

+ }

+ else {

+ return chatWindow_->addMessage(chatMessage, senderName, senderIsSelf, displayedLabel, pathToString(avatarPath), time);

+ }

+void ChatControllerBase::replaceMessage(const ChatWindow::ChatMessage& chatMessage, const std::string& id, const boost::posix_time::ptime& time) {

+ if (chatMessage.isMeCommand()) {

+ chatWindow_->replaceWithAction(chatMessage, id, time);

+ }

+ else {

+ chatWindow_->replaceMessage(chatMessage, id, time);

+ }

+ return from.toBare() == toJID_.toBare();

+void ChatControllerBase::handleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent) {

+ std::shared_ptr<Message> message = messageEvent->getStanza();

+ if (shouldIgnoreMessage(message)) {

+ return;

+ }

+

+ preHandleIncomingMessage(messageEvent);

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

+ unreadMessages_.push_back(messageEvent);

+ if (messageEvent->targetsMe()) {

+ targetedUnreadMessages_.push_back(messageEvent);

+ }

+ }

+

+ ChatWindow::ChatMessage chatMessage;

+ boost::optional<std::string> optionalBody = message->getBody();

+ std::string body = optionalBody.get_value_or("");

+ if (message->isError()) {

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

+ std::string errorMessage;

+ if (message->getPayload<Swift::ErrorPayload>()->getCondition() == ErrorPayload::ItemNotFound) {

+ errorMessage = QT_TRANSLATE_NOOP("", "This user could not be found in the room.");

+ }

+ else {

+ errorMessage = str(format(QT_TRANSLATE_NOOP("", "Couldn't send message: %1%")) % getErrorMessage(message->getPayload<ErrorPayload>()));

+ }

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

+ }

+ }

+ else if (messageEvent->getStanza()->getPayload<MUCInvitationPayload>()) {

+ handleMUCInvitation(messageEvent->getStanza());

+ return;

+ }

+ else if (messageEvent->getStanza()->getPayload<MUCUserPayload>() && messageEvent->getStanza()->getPayload<MUCUserPayload>()->getInvite()) {

+ handleMediatedMUCInvitation(messageEvent->getStanza());

+ return;

+ }

+ else {

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

+ return;

+ }

+ showChatWindow();

+ JID from = message->getFrom();

+ std::vector<std::shared_ptr<Delay> > delayPayloads = message->getPayloads<Delay>();

+ for (size_t i = 0; useDelayForLatency_ && i < delayPayloads.size(); i++) {

+ if (!delayPayloads[i]->getFrom()) {

+ continue;

+ }

+ boost::posix_time::ptime now = boost::posix_time::microsec_clock::universal_time();

+ std::ostringstream s;

+ s << "The following message took " << (now - delayPayloads[i]->getStamp()).total_milliseconds() / 1000.0 << " seconds to be delivered from " << delayPayloads[i]->getFrom()->toString() << ".";

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

+ }

+ std::shared_ptr<SecurityLabel> label = message->getPayload<SecurityLabel>();

+

+ // Determine the timestamp

+ boost::posix_time::ptime timeStamp = boost::posix_time::microsec_clock::universal_time();

+ boost::optional<boost::posix_time::ptime> messageTimeStamp = getMessageTimestamp(message);

+ if (messageTimeStamp) {

+ timeStamp = *messageTimeStamp;

+ }

+ onActivity(body);

+

+ std::shared_ptr<Replace> replace = message->getPayload<Replace>();

+ bool senderIsSelf = isIncomingMessageFromMe(message);

+ chatMessage = buildChatWindowChatMessage(body, senderHighlightNameFromMessage(from), senderIsSelf);

+ if (replace) {

+ handleIncomingReplaceMessage(from, chatMessage, message->getID(), replace->getID(), senderIsSelf, label, timeStamp);

+ }

+ else {

+ addMessageHandleIncomingMessage(from, chatMessage, message->getID(), senderIsSelf, label, timeStamp);

+ }

+

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

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

+#endif

+ }

+ chatWindow_->show();

+ updateMessageCount();

+ postHandleIncomingMessage(messageEvent, chatMessage);

+std::string ChatControllerBase::getErrorMessage(std::shared_ptr<ErrorPayload> error) {

+ std::string defaultMessage = QT_TRANSLATE_NOOP("", "Error sending message");

+ if (!error->getText().empty()) {

+ return error->getText();

+ }

+ else {

+ switch (error->getCondition()) {

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

+ return defaultMessage;

+ unreadMessages_.push_back(event);

+ chatWindow_->show();

+ updateMessageCount();

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

+ eventController_->handleIncomingEvent(event);

+ lastWasPresence_ = false;

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

+

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

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

+ } else {

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

+ handleGeneralMUCInvitation(inviteEvent);

+ }

+ MUCUserPayload::Invite invite = *message->getPayload<MUCUserPayload>()->getInvite();

+ JID from = message->getFrom();

+ std::string reason;

+ if (!invite.reason.empty()) {

+ reason = invite.reason;

+ }

+ std::string password;

+ if (message->getPayload<MUCUserPayload>()->getPassword()) {

+ password = *message->getPayload<MUCUserPayload>()->getPassword();

+ }

+

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

+ handleGeneralMUCInvitation(inviteEvent);

+}

+

+void ChatControllerBase::handleResendMessageRequest(const std::string& id) {

+ if (failedStanzas_.find(id) != failedStanzas_.end()) {

+ if (auto resendMsg = std::dynamic_pointer_cast<Message>(failedStanzas_[id])) {

+ stanzaChannel_->sendMessage(resendMsg);

+ if (stanzaChannel_->getStreamManagementEnabled()) {

+ chatWindow_->setAckState(id, ChatWindow::Pending);

+ unackedStanzas_[failedStanzas_[id]] = id;

+ }

+ if (resendMsg->getPayload<DeliveryReceiptRequest>()) {

+ requestedReceipts_[resendMsg->getID()] = id;

+ chatWindow_->setMessageReceiptState(id, ChatWindow::ReceiptRequested);

+ }

+ lastWasPresence_ = false;

+ failedStanzas_.erase(id);

+ }

+ }

+ * Copyright (c) 2010-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+#include <vector>

+#include <boost/date_time/posix_time/posix_time.hpp>

+#include <boost/signals2.hpp>

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

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

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

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

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

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

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

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

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

+ class AutoAcceptMUCInviteDecider;

+ class AvatarManager;

+ class ChatMessageParser;

+ class Chattables;

+ class ChatWindowFactory;

+ class EntityCapsProvider;

+ class EventController;

+ class Highlighter;

+ class HighlightManager;

+ class IQRouter;

+ class NickResolver;

+ class StanzaChannel;

+ class UIEventStream;

+

+ class ChatControllerBase : public boost::signals2::trackable {

+ public:

+ class StreamWindowMessageIDPair {

+ public:

+ std::string idInStream;

+ std::string idInWindow;

+ };

+

+ public:

+ virtual ~ChatControllerBase();

+ void showChatWindow();

+ void activateChatWindow();

+ bool hasOpenWindow() const;

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

+ virtual void handleIncomingOwnMessage(std::shared_ptr<Message> /*message*/) {}

+ void handleIncomingMessage(std::shared_ptr<MessageEvent> message);

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

+ void replaceMessage(const ChatWindow::ChatMessage& chatMessage, const std::string& id, const boost::posix_time::ptime& time);

+ virtual void setOnline(bool online);

+ void setEnabled(bool enabled);

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

+ /** Used for determining when something is recent.*/

+ boost::signals2::signal<void (const std::string& /*activity*/)> onActivity;

+ boost::signals2::signal<void ()> onUnreadCountChanged;

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

+ size_t getUnreadCount();

+ const JID& getToJID() {return toJID_;}

+ void handleCapsChanged(const JID& jid);

+ void setCanStartImpromptuChats(bool supportsImpromptu);

+ virtual ChatWindow* detachChatWindow();

+ boost::signals2::signal<void(ChatWindow* /*window to reuse*/, const std::vector<JID>& /*invite people*/, const std::string& /*reason*/)> onConvertToMUC;

+

+ protected:

+ ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, SettingsProvider* settings, Chattables& chattables);

+ /**

+ * Pass the Message appended, and the stanza used to send it.

+ */

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

+ virtual std::string senderDisplayNameFromMessage(const JID& from) = 0;

+ virtual std::string senderHighlightNameFromMessage(const JID& from) = 0;

+ virtual bool isIncomingMessageFromMe(std::shared_ptr<Message>) = 0;

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

+ virtual void addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& time) = 0;

+ virtual void handleIncomingReplaceMessage(const JID& from, const ChatWindow::ChatMessage& chatMessage, const std::string& messageID, const std::string& idToReplace, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) = 0;

+ virtual void postHandleIncomingMessage(std::shared_ptr<MessageEvent>, const ChatWindow::ChatMessage&) {}

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

+ virtual bool isFromContact(const JID& from);

+ virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(std::shared_ptr<Message>) const = 0;

+ virtual void dayTicked() {}

+ virtual void handleBareJIDCapsChanged(const JID& jid) = 0;

+ std::string getErrorMessage(std::shared_ptr<ErrorPayload>);

+ virtual void setContactIsReceivingPresence(bool /* isReceivingPresence */) {}

+ virtual void cancelReplaces() = 0;

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

+ ChatWindow::ChatMessage buildChatWindowChatMessage(const std::string& message, const std::string& senderName, bool senderIsSelf);

+ void updateMessageCount();

+ virtual bool shouldIgnoreMessage(std::shared_ptr<Message> /* message */) {

+ return false;

+ }

+ /**

+ * What JID should be used for last message correction (XEP-0308) tracking.

+ */

+ virtual JID messageCorrectionJID(const JID& fromJID) = 0;

+ virtual void handleResendMessageRequest(const std::string& id);

+ private:

+ IDGenerator idGenerator_;

+ std::string lastSentMessageStanzaID_;

+ void handleSendMessageRequest(const std::string &body, bool isCorrectionMessage);

+ void handleAllMessagesRead();

+ void handleSecurityLabelsCatalogResponse(std::shared_ptr<SecurityLabelsCatalog>, ErrorPayload::ref error);

+ void handleMUCInvitation(Message::ref message);

+ void handleMediatedMUCInvitation(Message::ref message);

+ void handleGeneralMUCInvitation(MUCInviteEvent::ref event);

+ void handleContinuationsBroken();

+ protected:

+ JID selfJID_;

+ std::vector<std::shared_ptr<StanzaEvent> > unreadMessages_;

+ std::vector<std::shared_ptr<StanzaEvent> > targetedUnreadMessages_;

+ StanzaChannel* stanzaChannel_;

+ IQRouter* iqRouter_;

+ ChatWindowFactory* chatWindowFactory_;

+ ChatWindow* chatWindow_;

+ JID toJID_;

+ bool labelsEnabled_;

+ std::map<JID, StreamWindowMessageIDPair> lastMessagesIDs_;

+ PresenceOracle* presenceOracle_;

+ AvatarManager* avatarManager_;

+ bool useDelayForLatency_;

+ EventController* eventController_;

+ EntityCapsProvider* entityCapsProvider_;

+ SecurityLabelsCatalog::Item lastLabel_;

+ HistoryController* historyController_;

+ MUCRegistry* mucRegistry_;

+ Highlighter* highlighter_;

+ std::shared_ptr<ChatMessageParser> chatMessageParser_;

+ AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider_;

+ UIEventStream* eventStream_;

+ bool lastWasPresence_ = false;

+ std::string roomSecurityMarking_;

+ std::string previousMessageSecurityMarking_;

+ SettingsProvider* settings_;

+ boost::signals2::scoped_connection scopedConnectionResendMessage_;

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

+ std::map<std::shared_ptr<Stanza>, std::string> unackedStanzas_;

+ std::map<std::string, std::shared_ptr<Stanza>> failedStanzas_;

+ Chattables& chattables_;

+ };

+/*

+ * Copyright (c) 2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <memory>

+

+#include <boost/version.hpp>

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

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

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

+#include <boost/bind.hpp>

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

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

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

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

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

+

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

+

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

+namespace Swift {

+ const boost::archive::library_version_type BoostArchiveSkipVersion(15);

+}

+

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

+ auto archiveLibraryVersion = boost::archive::BOOST_ARCHIVE_VERSION();

+ int archiveVersion = 0;

+ archive::text_oarchive* outputStream = dynamic_cast<archive::text_oarchive*>(&ar);

+ if (outputStream) {

+ archiveVersion = outputStream->get_library_version();

+ }

+ archive::text_iarchive* inputStream = dynamic_cast<archive::text_iarchive*>(&ar);

+ if (inputStream) {

+ archiveVersion = inputStream->get_library_version();

+ //Due to https://svn.boost.org/trac10/ticket/13050 the password field may fail to load and crash the client. Therefore we skip loading the values from previous versions.

+ if (archiveLibraryVersion == Swift::BoostArchiveSkipVersion && archiveLibraryVersion > archiveVersion) {

+ return;

+ }

+ }

+ ar & chat.jid;

+ ar & chat.chatName;

+ ar & chat.activity;

+ ar & chat.isMUC;

+ ar & chat.nick;

+ ar & chat.impromptuJIDs;

+ if (version > 0) {

+ if (outputStream && archiveLibraryVersion == Swift::BoostArchiveSkipVersion) {

+ //The bug does not affect the case boost::optional doesn't have a value. Therefore we store always that value, to avoid problem on future launches of the client.

+ boost::optional<std::string> empty;

+ ar & empty;

+ }

+ else {

+ ar & chat.password;

+ }

+ }

+ if (version > 1) {

+ ar & chat.inviteesNames;

+ }

+ }

+ }

+}

+ * Copyright (c) 2013-2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <algorithm>

+#include <memory>

+#include <vector>

+#include <boost/regex.hpp>

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

+ ChatMessageParser::ChatMessageParser(const std::map<std::string, std::string>& emoticons, std::shared_ptr<HighlightConfiguration> highlightConfiguration, Mode mode) : emoticons_(emoticons), highlightConfiguration_(highlightConfiguration), mode_(mode) {

+ }

+

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

+

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

+ ChatWindow::ChatMessage parsedMessage;

+

+ std::string remaining = body;

+ if (boost::starts_with(body, "/me ")) {

+ remaining = String::getSplittedAtFirst(body, ' ').second;

+ parsedMessage.setIsMeCommand(true);

+ }

+

+ /* 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(std::make_shared<ChatWindow::ChatURIMessagePart>(part));

+ }

+ else {

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

+ }

+ }

+ }

+ }

+

+ /* do emoticon substitution */

+ parsedMessage = emoticonHighlight(parsedMessage);

+

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

+ // Highlight keywords and own mentions.

+ parsedMessage = splitHighlight(parsedMessage);

+

+ // Highlight full message events like, specific sender, general

+ // incoming group message, or general incoming direct message.

+ parsedMessage = fullMessageHighlight(parsedMessage, senderNickname);

+ }

+

+ return parsedMessage;

+ }

+

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

+ ChatWindow::ChatMessage parsedMessage = message;

+

+ std::string regexString;

+ /* Parse two, emoticons */

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

+ for (const auto& part : parsedMessage.getParts()) {

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

+ if ((textPart = std::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(std::make_shared<ChatWindow::ChatTextMessagePart>(std::string(start, matchStart)));

+ }

+ std::shared_ptr<ChatWindow::ChatEmoticonMessagePart> emoticonPart = std::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(std::make_shared<ChatWindow::ChatTextMessagePart>(std::string(start, text.end())));

+ }

+

+ }

+ catch (const 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.setParts(newMessage.getParts());

+ }

+

+ return parsedMessage;

+ }

+

+ ChatWindow::ChatMessage ChatMessageParser::splitHighlight(const ChatWindow::ChatMessage& message) {

+ auto keywordToRegEx = [](const std::string& keyword, bool matchCaseSensitive) {

+ std::string escaped = Regex::escape(keyword);

+ boost::regex::flag_type flags = boost::regex::normal;

+ if (!matchCaseSensitive) {

+ flags |= boost::regex::icase;

+ }

+ return boost::regex("\\b" + escaped + "\\b", flags);

+ };

+

+ auto highlightKeywordInChatMessage = [&](const ChatWindow::ChatMessage& message, const std::string& keyword, bool matchCaseSensitive, const HighlightAction& action) {

+ ChatWindow::ChatMessage resultMessage;

+

+ for (const auto& part : message.getParts()) {

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

+ if ((textPart = std::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, keywordToRegEx(keyword, matchCaseSensitive))) {

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

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

+ }

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

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

+ highlightPart->action = action;

+ resultMessage.append(highlightPart);

+ start = matchEnd;

+ }

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

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

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

+ }

+ }

+ catch (const std::runtime_error&) {

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

+ resultMessage.append(part);

+ }

+ } else {

+ resultMessage.append(part);

+ }

+ }

+ return resultMessage;

+ };

+

+ ChatWindow::ChatMessage parsedMessage = message;

+

+ // detect mentions of own nickname

+ HighlightAction ownMentionKeywordAction = highlightConfiguration_->ownMentionAction;

+ ownMentionKeywordAction.setSoundFilePath(boost::optional<std::string>());

+ ownMentionKeywordAction.setSystemNotificationEnabled(false);

+ if (!getNick().empty() && !highlightConfiguration_->ownMentionAction.isEmpty()) {

+ auto nicknameHighlightedMessage = highlightKeywordInChatMessage(parsedMessage, nick_, false, ownMentionKeywordAction);

+ auto highlightedParts = nicknameHighlightedMessage.getParts();

+ auto ownNicknamePart = std::find_if(highlightedParts.begin(), highlightedParts.end(), [&](std::shared_ptr<ChatWindow::ChatMessagePart>& part){

+ auto highlightPart = std::dynamic_pointer_cast<ChatWindow::ChatHighlightingMessagePart>(part);

+ if (highlightPart && highlightPart->text == nick_) {

+ return true;

+ }

+ return false;

+ });

+ if (ownNicknamePart != highlightedParts.end()) {

+ parsedMessage.setHighlightActionOwnMention(highlightConfiguration_->ownMentionAction);

+ }

+ parsedMessage.setParts(nicknameHighlightedMessage.getParts());

+ }

+

+ // detect keywords

+ for (const auto& keywordHighlight : highlightConfiguration_->keywordHighlights) {

+ if (keywordHighlight.keyword.empty() || keywordHighlight.action.isEmpty()) {

+ continue;

+ }

+ auto newMessage = highlightKeywordInChatMessage(parsedMessage, keywordHighlight.keyword, keywordHighlight.matchCaseSensitive, keywordHighlight.action);

+ parsedMessage.setParts(newMessage.getParts());

+ }

+

+ return parsedMessage;

+ }

+

+ ChatWindow::ChatMessage ChatMessageParser::fullMessageHighlight(const ChatWindow::ChatMessage& parsedMessage, const std::string& sender) {

+ auto fullHighlightedMessage = parsedMessage;

+

+ // contact highlighting

+ for (const auto& contactHighlight : highlightConfiguration_->contactHighlights) {

+ if (sender == contactHighlight.name) {

+ fullHighlightedMessage.setHighlightActionSender(contactHighlight.action);

+ break;

+ }

+ }

+

+ // general incoming messages

+ HighlightAction groupAction;

+ HighlightAction chatAction;

+

+ switch (mode_) {

+ case Mode::GroupChat:

+ groupAction.setSoundFilePath(highlightConfiguration_->playSoundOnIncomingGroupchatMessages ? boost::optional<std::string>("") : boost::optional<std::string>());

+ groupAction.setSystemNotificationEnabled(highlightConfiguration_->showNotificationOnIncomingGroupchatMessages);

+ fullHighlightedMessage.setHighlightActionGroupMessage(groupAction);

+ break;

+

+ case Mode::Chat:

+ chatAction.setSoundFilePath(highlightConfiguration_->playSoundOnIncomingDirectMessages ? boost::optional<std::string>("") : boost::optional<std::string>());

+ chatAction.setSystemNotificationEnabled(highlightConfiguration_->showNotificationOnIncomingDirectMessages);

+ fullHighlightedMessage.setHighlightActonDirectMessage(chatAction);

+ break;

+ }

+

+ return fullHighlightedMessage;

+ }

+ * Copyright (c) 2013-2017 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+#include <Swift/Controllers/Highlighting/HighlightConfiguration.h>

+ /**

+ * @brief The ChatMessageParser class takes an emoticon map, a \ref HighlightConfiguration, and a boolean that indicates if the message context is in a MUC or not.

+ * The class handles parsing a message string and identifies emoticons, URLs, and various highlights.

+ */

+ class ChatMessageParser {

+ public:

+ enum class Mode { Chat, GroupChat };

+ public:

+ ChatMessageParser(const std::map<std::string, std::string>& emoticons, std::shared_ptr<HighlightConfiguration> highlightConfiguration, Mode mode = Mode::Chat);

+

+ void setNick(const std::string& nick) { nick_ = nick; }

+ std::string getNick() const { return nick_; }

+

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

+

+ private:

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

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

+ ChatWindow::ChatMessage fullMessageHighlight(const ChatWindow::ChatMessage& parsedMessage, const std::string& sender);

+

+ private:

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

+ std::shared_ptr<HighlightConfiguration> highlightConfiguration_;

+ Mode mode_;

+ std::string nick_;

+ };

+ * Copyright (c) 2010-2019 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+

+#include <boost/bind.hpp>

+

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+#ifndef NOT_YET

+#endif

+ JID jid, StanzaChannel* stanzaChannel,

+ IQRouter* iqRouter,

+ EventController* eventController,

+ ChatWindowFactory* chatWindowFactory,

+ JoinMUCWindowFactory* joinMUCWindowFactory,

+ NickResolver* nickResolver,

+ PresenceOracle* presenceOracle,

+ PresenceSender* presenceSender,

+ UIEventStream* uiEventStream,

+#ifndef NOT_YET

+ ChatListWindowFactory* chatListWindowFactory,

+#endif

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

+ VCardManager* vcardManager,

+ Chattables& chattables) :

+ jid_(jid),

+ joinMUCWindowFactory_(joinMUCWindowFactory),

+ useDelayForLatency_(useDelayForLatency),

+ mucRegistry_(mucRegistry),

+ entityCapsProvider_(entityCapsProvider),

+ mucManager(mucManager),

+ ftOverview_(ftOverview),

+ roster_(roster),

+ eagleMode_(eagleMode),

+ settings_(settings),

+ historyController_(historyController),

+ whiteboardManager_(whiteboardManager),

+ highlightManager_(highlightManager),

+ emoticons_(emoticons),

+ clientBlockListManager_(clientBlockListManager),

+ vcardManager_(vcardManager),

+ chattables_(chattables) {

+ timerFactory_ = timerFactory;

+ eventController_ = eventController;

+ stanzaChannel_ = stanzaChannel;

+ iqRouter_ = iqRouter;

+ chatWindowFactory_ = chatWindowFactory;

+ nickResolver_ = nickResolver;

+ presenceOracle_ = presenceOracle;

+ avatarManager_ = nullptr;

+ serverDiscoInfo_ = std::make_shared<DiscoInfo>();

+ presenceSender_ = presenceSender;

+ uiEventStream_ = uiEventStream;

+ mucBookmarkManager_ = nullptr;

+ profileSettings_ = profileSettings;

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

+ uiEventConnection_ = uiEventStream_->onUIEvent.connect(boost::bind(&ChatsManager::handleUIEvent, this, _1));

+#ifndef NOT_YET

+ chatListWindow_ = chatListWindowFactory->createChatListWindow(uiEventStream_);

+ chatListWindow_->onMUCBookmarkActivated.connect(boost::bind(&ChatsManager::handleMUCBookmarkActivated, this, _1));

+ chatListWindow_->onRecentActivated.connect(boost::bind(&ChatsManager::handleRecentActivated, this, _1));

+ chatListWindow_->onClearRecentsRequested.connect(boost::bind(&ChatsManager::handleClearRecentsRequested, this));

+#endif

+ joinMUCWindow_ = nullptr;

+ mucSearchController_ = new MUCSearchController(jid_, mucSearchWindowFactory, iqRouter, profileSettings_);

+ mucSearchController_->onMUCSelected.connect(boost::bind(&ChatsManager::handleMUCSelectedAfterSearch, this, _1));

+ ftOverview_->onNewFileTransferController.connect(boost::bind(&ChatsManager::handleNewFileTransferController, this, _1));

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

+ roster_->onJIDAdded.connect(boost::bind(&ChatsManager::handleJIDAddedToRoster, this, _1));

+ roster_->onJIDRemoved.connect(boost::bind(&ChatsManager::handleJIDRemovedFromRoster, this, _1));

+ roster_->onJIDUpdated.connect(boost::bind(&ChatsManager::handleJIDUpdatedInRoster, this, _1));

+ roster_->onRosterCleared.connect(boost::bind(&ChatsManager::handleRosterCleared, this));

+

+ chattables_.onActivated.connect(boost::bind(&ChatsManager::handleChattableActivated, this, _1));

+

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

+

+ userWantsReceipts_ = settings_->getSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS);

+

+ setupBookmarks();

+#ifndef NOT_YET

+ loadRecents();

+#endif

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

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

+ chattables_.onActivated.disconnect(boost::bind(&ChatsManager::handleChattableActivated, this, _1));

+ roster_->onJIDAdded.disconnect(boost::bind(&ChatsManager::handleJIDAddedToRoster, this, _1));

+ roster_->onJIDRemoved.disconnect(boost::bind(&ChatsManager::handleJIDRemovedFromRoster, this, _1));

+ roster_->onJIDUpdated.disconnect(boost::bind(&ChatsManager::handleJIDUpdatedInRoster, this, _1));

+ roster_->onRosterCleared.disconnect(boost::bind(&ChatsManager::handleRosterCleared, this));

+ ftOverview_->onNewFileTransferController.disconnect(boost::bind(&ChatsManager::handleNewFileTransferController, this, _1));

+ delete joinMUCWindow_;

+ SWIFT_LOG(debug) << "Destroying ChatsManager, containing " << chatControllers_.size() << " chats and " << mucControllers_.size() << " MUCs";

+ for (JIDChatControllerPair controllerPair : chatControllers_) {

+ delete controllerPair.second;

+ }

+ for (JIDMUCControllerPair controllerPair : mucControllers_) {

+ delete controllerPair.second;

+ }

+ delete mucBookmarkManager_;

+ delete mucSearchController_;

+ delete autoAcceptMUCInviteDecider_;

+#ifndef NOT_YET

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

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

+ recentChats_.clear();

+ saveRecents();

+ handleUnreadCountChanged(nullptr);

+#endif

+ updatePresenceReceivingStateOnChatController(jid);

+ updatePresenceReceivingStateOnChatController(jid);

+ updatePresenceReceivingStateOnChatController(jid);

+ /* Setting that all chat controllers aren't receiving presence anymore;

+ including MUC 1-to-1 chats due to the assumtion that this handler

+ is only called on log out. */

+ for (JIDChatControllerPair pair : chatControllers_) {

+ pair.second->setContactIsReceivingPresence(false);

+ }

+ ChatController* controller = getChatControllerIfExists(jid);

+ if (controller) {

+ if (!mucRegistry_->isMUC(jid.toBare())) {

+ RosterItemPayload::Subscription subscription = roster_->getSubscriptionStateForJID(jid);

+ controller->setContactIsReceivingPresence(subscription == RosterItemPayload::From || subscription == RosterItemPayload::Both);

+ } else {

+ controller->setContactIsReceivingPresence(true);

+ }

+ }

+#ifndef NOT_YET

+ 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_->getAccountPresence(fixedChat.jid.toBare());

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

+ }

+ return fixedChat;

+ std::string recentsString(profileSettings_->getStringSetting(RECENT_CHATS));

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

+ // old format

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

+ boost::split(recents, recentsString, boost::is_any_of("\n"));

+ int i = 0;

+ for (std::string recentString : recents) {

+ if (i++ > 30) {

+ break;

+ }

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

+ boost::split(recent, recentString, boost::is_any_of("\t"));

+ if (recent.size() < 4) {

+ continue;

+ }

+ JID jid(recent[0]);

+ if (!jid.isValid()) {

+ continue;

+ }

+ std::string activity(recent[1]);

+ bool isMUC = recent[2] == "true";

+ std::string nick(recent[3]);

+ StatusShow::Type type = StatusShow::None;

+ boost::filesystem::path path;

+

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

+ return;

+ }

+ recentChats.erase(std::remove(recentChats.begin(), recentChats.end(), ChatListWindow::Chat()), recentChats.end());

+ for (auto chat : recentChats) {

+ chat.statusType = StatusShow::None;

+ chat = updateChatStatusAndAvatarHelper(chat);

+ prependRecent(chat);

+ }

+ }

+ handleUnreadCountChanged(nullptr);

+#endif

+ if (!mucBookmarkManager_) {

+ mucBookmarkManager_ = new MUCBookmarkManager(iqRouter_);

+ mucBookmarkManager_->onBookmarksReady.connect(boost::bind(&ChatsManager::handleBookmarksReady, this));

+ mucBookmarkManager_->onBookmarkAdded.connect(boost::bind(&ChatsManager::handleMUCBookmarkAdded, this, _1));

+ mucBookmarkManager_->onBookmarkRemoved.connect(boost::bind(&ChatsManager::handleMUCBookmarkRemoved, this, _1));

+

+#ifndef NOT_YET

+ if (chatListWindow_) {

+ chatListWindow_->setBookmarksEnabled(false);

+ chatListWindow_->clearBookmarks();

+ }

+#endif

+ }

+#ifndef NOT_YET

+ if (chatListWindow_) {

+ chatListWindow_->setBookmarksEnabled(true);

+ }

+#endif

+ if (bookmark.getRoom().isBare() && !bookmark.getRoom().getNode().empty()) {

+ std::map<JID, MUCController*>::iterator it = mucControllers_.find(bookmark.getRoom());

+ if (it == mucControllers_.end() && bookmark.getAutojoin()) {

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

+ }

+#ifndef NOT_YET

+ //Only one entry of the bookmark should exist

+ chatListWindow_->removeMUCBookmark(bookmark);

+ chatListWindow_->addMUCBookmark(bookmark);

+#endif

+ chattables_.addJID(bookmark.getRoom(), Chattables::State::Type::Room);

+ }

+#ifndef NOT_YET

+ chatListWindow_->removeMUCBookmark(bookmark);

+#endif

+#ifndef NOT_YET

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

+ size_t unreadCount = 0;

+ if (mucRegistry_->isMUC(jid)) {

+ MUCController* controller = mucControllers_[jid.toBare()];

+ StatusShow::Type type = StatusShow::None;

+ std::string nick = "";

+ std::string password = "";

+ if (controller) {

+ unreadCount = controller->getUnreadCount();

+ if (controller->isJoined()) {

+ type = StatusShow::Online;

+ }

+ nick = controller->getNick();

+

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

+

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

+ for (auto& i : invitees_[jid]) {

+ participantsNames.emplace(i, roster_->getNameForJID(i));

+ }

+ chat.inviteesNames = participantsNames;

+ return chat;

+ }

+ }

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

+ } else {

+ ChatController* controller = getChatControllerIfExists(jid, false);

+ if (controller) {

+ unreadCount = controller->getUnreadCount();

+ }

+ JID bareishJID = mucRegistry_->isMUC(jid.toBare()) ? jid : jid.toBare();

+ Presence::ref presence = presenceOracle_->getAccountPresence(bareishJID);

+ StatusShow::Type type = presence ? presence->getShow() : StatusShow::None;

+ boost::filesystem::path avatarPath = avatarManager_ ? avatarManager_->getAvatarPath(bareishJID) : boost::filesystem::path();

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

+ }

+}

+#endif

+

+#ifndef NOT_YET

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

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

+ /* FIXME: handle nick changes */

+ appendRecent(chat);

+ handleUnreadCountChanged(nullptr);

+ saveRecents();

+

+ // Look up potential MUC controller and update title accordingly as people

+ // join impromptu chats.

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

+ auto chatListWindowIter = std::find_if(recentChats_.begin(), recentChats_.end(), [&](const ChatListWindow::Chat& chatListWindow) { return jid == (chatListWindow.jid); });

+ if (chatListWindowIter != recentChats_.end() && (mucControllers_[jid]->isImpromptu() || !chatListWindowIter->impromptuJIDs.empty())) {

+ mucControllers_[jid]->setChatWindowTitle(chatListWindowIter->getTitle());

+ }

+ }

+#endif

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

+ cleanupPrivateMessageRecents();

+#ifndef NOT_YET

+ chatListWindow_->setRecents(recentChats_);

+#endif

+}

+

+#ifndef NOT_YET

+

+ size_t unreadTotal = 0;

+ bool controllerIsMUC = dynamic_cast<MUCController*>(controller);

+ bool isPM = controller && !controllerIsMUC && mucRegistry_->isMUC(controller->getToJID().toBare());

+ for (ChatListWindow::Chat& chatItem : recentChats_) {

+ bool match = false;

+ if (controller) {

+ /* Matching MUC item */

+ match |= chatItem.isMUC == controllerIsMUC && chatItem.jid.toBare() == controller->getToJID().toBare();

+ /* Matching PM */

+ match |= isPM && chatItem.jid == controller->getToJID();

+ /* Matching non-PM */

+ match |= !isPM && !controllerIsMUC && chatItem.jid.toBare() == controller->getToJID().toBare();

+ }

+ if (match) {

+ chatItem.setUnreadCount(controller->getUnreadCount());

+ }

+ unreadTotal += chatItem.unreadCount;

+ }

+ chatListWindow_->setRecents(recentChats_);

+ chatListWindow_->setUnreadCount(unreadTotal);

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

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

+ ChatListWindow::Chat existingChat = *result;

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

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

+ } else {

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

+ }

+}

+#endif

+

+#ifndef NOT_YET

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

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

+ }

+ }

+ }

+ }

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

+ ChatListWindow::Chat mergedChat = chat;

+ if (oldChat) {

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

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

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

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

+ }

+ recentChats_.push_back(mergedChat);

+#endif

+ std::map<JID, MUCController*>::iterator it;

+ for (it = mucControllers_.begin(); it != mucControllers_.end(); ++it) {

+ if ((*it).second == mucController) {

+#ifndef NOT_YET

+ for (ChatListWindow::Chat& chat : recentChats_) {

+ if (chat.isMUC && chat.jid == (*it).first) {

+ chat.statusType = StatusShow::None;

+ }

+ }

+#endif

+ const auto& jid = it->first;

+ auto state = chattables_.getState(jid);

+ state.status = StatusShow::None;

+ chattables_.setState(jid, state);

+ //If user deletes bookmark from chatListWindow_ and then decides to leave the room, or if the server doesn't support bookmarks, the bookmark will not exist.

+ if (auto bookmarkFound = mucBookmarkManager_->lookupBookmark(jid)) {

+ MUCBookmark newBookmark(bookmarkFound.get());

+ newBookmark.setAutojoin(false);

+ mucBookmarkManager_->replaceBookmark(bookmarkFound.get(), newBookmark);

+ }

+ mucControllers_.erase(it);

+ delete mucController;

+ break;

+ }

+ }

+ cleanupPrivateMessageRecents();

+#ifndef NOT_YET

+ chatListWindow_->setRecents(recentChats_);

+#endif

+ if (settingPath == SettingConstants::REQUEST_DELIVERYRECEIPTS.getKey()) {

+ userWantsReceipts_ = settings_->getSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS);

+ return;

+ }

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

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

+ }

+ for (const JID& jid : missingJIDsToInvite) {

+ muc->invitePerson(jid, reason, true);

+ }

+}

+

+void ChatsManager::handleUIEvent(std::shared_ptr<UIEvent> event) {

+ std::shared_ptr<RequestChatUIEvent> chatEvent = std::dynamic_pointer_cast<RequestChatUIEvent>(event);

+ if (chatEvent) {

+ handleChatRequest(chatEvent->getContact());

+ return;

+ }

+ std::shared_ptr<RemoveMUCBookmarkUIEvent> removeMUCBookmarkEvent = std::dynamic_pointer_cast<RemoveMUCBookmarkUIEvent>(event);

+ if (removeMUCBookmarkEvent) {

+ mucBookmarkManager_->removeBookmark(removeMUCBookmarkEvent->getBookmark());

+ return;

+ }

+ std::shared_ptr<AddMUCBookmarkUIEvent> addMUCBookmarkEvent = std::dynamic_pointer_cast<AddMUCBookmarkUIEvent>(event);

+ if (addMUCBookmarkEvent) {

+ mucBookmarkManager_->addBookmark(addMUCBookmarkEvent->getBookmark());

+ return;

+ }

+ std::shared_ptr<SendFileUIEvent> sendFileEvent = std::dynamic_pointer_cast<SendFileUIEvent>(event);

+ if (sendFileEvent) {

+ JID fileReceiver = sendFileEvent->getJID();

+ if (fileReceiver.isBare()) {

+ // See if there is a chat controller for a conversation with a bound

+ // full JID. Check if this JID supports file transfer and use it instead

+ // of the bare JID.

+ ChatController* controller = getChatControllerIfExists(fileReceiver, false);

+ if (controller) {

+ JID controllerJID = controller->getToJID();

+ if (!controllerJID.isBare() && (FeatureOracle(entityCapsProvider_, presenceOracle_).isFileTransferSupported(controllerJID) == Yes)) {

+ fileReceiver = controllerJID;

+ }

+ }

+ }

+ ftOverview_->sendFile(fileReceiver, sendFileEvent->getFilename());

+ return;

+ }

+

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

+ if (createImpromptuMUCEvent) {

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

+ // The room JID is random for new impromptu rooms, or a predefined JID for impromptu rooms resumed from the 'Recent chats' list.

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

+

+ std::vector<JID> missingJIDsToInvite = createImpromptuMUCEvent->getJIDs();

+ for (const JID& jid : missingJIDsToInvite) {

+ invitees_[roomJID].insert(jid);

+ }

+ // join muc

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

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

+ mucControllers_[roomJID]->activateChatWindow();

+ }

+

+ std::shared_ptr<EditMUCBookmarkUIEvent> editMUCBookmarkEvent = std::dynamic_pointer_cast<EditMUCBookmarkUIEvent>(event);

+ if (editMUCBookmarkEvent) {

+ mucBookmarkManager_->replaceBookmark(editMUCBookmarkEvent->getOldBookmark(), editMUCBookmarkEvent->getNewBookmark());

+ }

+ else if (JoinMUCUIEvent::ref joinEvent = std::dynamic_pointer_cast<JoinMUCUIEvent>(event)) {

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

+ mucControllers_[joinEvent->getJID()]->activateChatWindow();

+ }

+ else if (std::shared_ptr<RequestJoinMUCUIEvent> joinEvent = std::dynamic_pointer_cast<RequestJoinMUCUIEvent>(event)) {

+ if (!joinMUCWindow_) {

+ joinMUCWindow_ = joinMUCWindowFactory_->createJoinMUCWindow(uiEventStream_);

+ joinMUCWindow_->onSearchMUC.connect(boost::bind(&ChatsManager::handleSearchMUCRequest, this));

+ }

+ joinMUCWindow_->setMUC(joinEvent->getRoom());

+ joinMUCWindow_->setNick(nickResolver_->jidToNick(jid_));

+ joinMUCWindow_->show();

+ }

+#ifndef NOT_YET

+ for (ChatListWindow::Chat& chat : recentChats_) {

+ chat.setStatusType(StatusShow::None);

+ }

+ chatListWindow_->setRecents(recentChats_);

+#endif

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

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

+void ChatsManager::handlePresenceChange(std::shared_ptr<Presence> newPresence) {

+ if (mucRegistry_->isMUC(newPresence->getFrom().toBare())) return;

+#ifndef NOT_YET

+ for (ChatListWindow::Chat& chat : recentChats_) {

+ if (newPresence->getFrom().toBare() == chat.jid.toBare() && !chat.isMUC) {

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

+ chat.setStatusType(presence ? presence->getShow() : StatusShow::None);

+ chatListWindow_->setRecents(recentChats_);

+ break;

+ }

+ }

+#endif

+ //if (newPresence->getType() != Presence::Unavailable) return;

+

+ JID fullJID(newPresence->getFrom());

+ std::map<JID, ChatController*>::iterator it = chatControllers_.find(fullJID);

+ if (it == chatControllers_.end()) return;

+ JID bareJID(fullJID.toBare());

+ //It doesn't make sense to have two unbound dialogs.

+ if (chatControllers_.find(bareJID) != chatControllers_.end()) return;

+ rebindControllerJID(fullJID, bareJID);

+ if (avatarManager_) {

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

+ }

+ avatarManager_ = avatarManager;

+#ifndef NOT_YET

+ for (ChatListWindow::Chat& chat : recentChats_) {

+ if (!chat.isMUC) {

+ chat.setAvatarPath(avatarManager_->getAvatarPath(chat.jid));

+ }

+ }

+#endif

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

+#ifndef NOT_YET

+ for (ChatListWindow::Chat& chat : recentChats_) {

+ if (!chat.isMUC && jid.toBare() == chat.jid.toBare()) {

+ chat.setAvatarPath(avatarManager_->getAvatarPath(jid));

+ break;

+ }

+ }

+#endif

+void ChatsManager::setServerDiscoInfo(std::shared_ptr<DiscoInfo> info) {

+ serverDiscoInfo_ = info;

+ for (JIDChatControllerPair pair : chatControllers_) {

+ pair.second->setAvailableServerFeatures(info);

+ }

+ for (JIDMUCControllerPair pair : mucControllers_) {

+ pair.second->setAvailableServerFeatures(info);

+ }

+ */

+ for (JIDChatControllerPair controllerPair : chatControllers_) {

+ controllerPair.second->setOnline(enabled);

+ }

+ for (JIDMUCControllerPair controllerPair : mucControllers_) {

+ controllerPair.second->setOnline(enabled);

+ if (enabled) {

+ controllerPair.second->rejoin();

+ }

+ }

+ if (!enabled) {

+ markAllRecentsOffline();

+ } else {

+ setupBookmarks();

+ localMUCServiceJID_ = JID();

+ localMUCServiceFinderWalker_ = std::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();

+ }

+#ifndef NOT_YET

+ if (chatListWindow_) {

+ chatListWindow_->setBookmarksEnabled(enabled);

+ }

+#endif

+ ChatController* controller = getChatControllerOrFindAnother(JID(contact));

+ controller->activateChatWindow();

+ ChatController* controller = getChatControllerIfExists(contact);

+ if (!controller && !mucRegistry_->isMUC(contact.toBare())) {

+ for (JIDChatControllerPair pair : chatControllers_) {

+ if (pair.first.toBare() == contact.toBare()) {

+ controller = pair.second;

+ break;

+ }

+ }

+ }

+ return controller ? controller : createNewChatController(contact);

+ assert(chatControllers_.find(contact) == chatControllers_.end());

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

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

+ chatControllers_[contact] = controller;

+ controller->setAvailableServerFeatures(serverDiscoInfo_);

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

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

+#ifndef NOT_YET

+ controller->onUnreadCountChanged.connect(boost::bind(&ChatsManager::handleUnreadCountChanged, this, controller));

+#endif

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

+ updatePresenceReceivingStateOnChatController(contact);

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

+ return controller;

+ ChatController* controller = getChatControllerIfExists(contact);

+ return controller ? controller : createNewChatController(contact);

+ if (chatControllers_.find(contact) == chatControllers_.end()) {

+ if (mucRegistry_->isMUC(contact.toBare())) {

+ return nullptr;

+ }

+ //Need to look for an unbound window to bind first

+ JID bare(contact.toBare());

+ if (chatControllers_.find(bare) != chatControllers_.end()) {

+ if (rebindIfNeeded) {

+ rebindControllerJID(bare, contact);

+ }

+ else {

+ return chatControllers_[bare];

+ }

+ } else {

+ for (JIDChatControllerPair pair : chatControllers_) {

+ if (pair.first.toBare() == contact.toBare()) {

+ if (rebindIfNeeded) {

+ rebindControllerJID(pair.first, contact);

+ return chatControllers_[contact];

+ } else {

+ return pair.second;

+ }

+ }

+ }

+ return nullptr;

+ }

+ }

+ return chatControllers_[contact];

+ chatControllers_[to] = chatControllers_[from];

+ chatControllers_.erase(from);

+ chatControllers_[to]->setToJID(to);

+}

+

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

+ MUC::ref muc;

+ std::map<JID, MUCController*>::iterator it = mucControllers_.find(mucJID);

+ if (it != mucControllers_.end()) {

+ if (stanzaChannel_->isAvailable()) {

+ it->second->rejoin();

+ }

+ } else {

+ std::string nick = (nickMaybe && !(*nickMaybe).empty()) ? nickMaybe.get() : nickResolver_->jidToNick(jid_);

+ muc = mucManager->createMUC(mucJID);

+ if (createAsReservedIfNew) {

+ muc->setCreateAsReservedIfNew();

+ }

+ if (isImpromptu) {

+ muc->setCreateAsReservedIfNew();

+ }

+

+ MUCController* controller = nullptr;

+ SingleChatWindowFactoryAdapter* chatWindowFactoryAdapter = nullptr;

+ if (reuseChatwindow) {

+ chatWindowFactoryAdapter = new SingleChatWindowFactoryAdapter(reuseChatwindow);

+ }

+ std::shared_ptr<ChatMessageParser> chatMessageParser = std::make_shared<ChatMessageParser>(emoticons_, highlightManager_->getConfiguration(), ChatMessageParser::Mode::GroupChat); /* 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_, nickResolver_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_, roster_, historyController_, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser, isImpromptu, autoAcceptMUCInviteDecider_, vcardManager_, mucBookmarkManager_, settings_, chattables_);

+ chattables_.addJID(muc->getJID(), Chattables::State::Type::Room);

+ auto state = chattables_.getState(muc->getJID());

+ state.status = StatusShow::Online;

+ chattables_.setState(muc->getJID(), state);

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

+ }

+

+ mucControllers_[mucJID] = controller;

+ controller->setAvailableServerFeatures(serverDiscoInfo_);

+ controller->onUserLeft.connect(boost::bind(&ChatsManager::handleUserLeftMUC, this, controller));

+ controller->onUserJoined.connect(boost::bind(&ChatsManager::handleChatActivity, this, mucJID.toBare(), "", true));

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

+ controller->onActivity.connect(boost::bind(&ChatsManager::handleChatActivity, this, mucJID.toBare(), _1, true));

+#ifndef NOT_YET

+ controller->onUnreadCountChanged.connect(boost::bind(&ChatsManager::handleUnreadCountChanged, this, controller));

+#endif

+ if (!stanzaChannel_->isAvailable()) {

+ /* When online, the MUC is added to the registry in MUCImpl::internalJoin. This method is not

+ * called when Swift is offline, so we add it here as only MUCs in the registry are rejoined

+ * when going back online.

+ */

+ mucRegistry_->addMUC(mucJID.toBare());

+ }

+ handleChatActivity(mucJID.toBare(), "", true);

+ }

+#ifndef NOT_YET

+ auto chatListWindowIter = std::find_if(recentChats_.begin(), recentChats_.end(), [&](const ChatListWindow::Chat& chatListWindow) { return mucJID == (chatListWindow.jid); });

+ if (chatListWindowIter != recentChats_.end() && (mucControllers_[mucJID]->isImpromptu() || !chatListWindowIter->impromptuJIDs.empty())) {

+ mucControllers_[mucJID]->setChatWindowTitle(chatListWindowIter->getTitle());

+ }

+#endif

+ if (auto existingBookmark = mucBookmarkManager_->lookupBookmark(mucJID)) {

+ if (!existingBookmark->getAutojoin()) {

+ MUCBookmark newbookmark(existingBookmark.get());

+ newbookmark.setAutojoin(true);

+ mucBookmarkManager_->replaceBookmark(*existingBookmark, newbookmark);

+ }

+ }

+ else {

+ MUCBookmark bookmark(mucJID, mucJID.getNode());

+ bookmark.setAutojoin(true);

+ if (nickMaybe) {

+ bookmark.setNick(*nickMaybe);

+ }

+ if (password) {

+ bookmark.setPassword(*password);

+ }

+ mucBookmarkManager_->addBookmark(bookmark);

+ }

+ mucControllers_[mucJID]->showChatWindow();

+ return muc;

+ mucSearchController_->openSearchWindow();

+}

+

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

+

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

+ }

+}

+

+bool ChatsManager::messageCausesSessionBinding(std::shared_ptr<Message> message) {

+ bool causesRebind = false;

+ ChatState::ref chatState = message->getPayload<ChatState>();

+ if (!message->getBody().get_value_or("").empty() || (chatState && chatState->getChatState() == ChatState::Composing)) {

+ causesRebind = true;

+ }

+ return causesRebind;

+}

+

+void ChatsManager::handleIncomingMessage(std::shared_ptr<Message> incomingMessage) {

+ std::shared_ptr<Message> message = incomingMessage;

+ if (message->getFrom().toBare() == jid_.toBare()) {

+ CarbonsReceived::ref carbonsReceived;

+ CarbonsSent::ref carbonsSent;

+ Forwarded::ref forwarded;

+ Message::ref forwardedMessage;

+ if ((carbonsReceived = incomingMessage->getPayload<CarbonsReceived>()) &&

+ (forwarded = carbonsReceived->getForwarded()) &&

+ (forwardedMessage = std::dynamic_pointer_cast<Message>(forwarded->getStanza()))) {

+ message = forwardedMessage;

+ }

+ else if ((carbonsSent = incomingMessage->getPayload<CarbonsSent>()) &&

+ (forwarded = carbonsSent->getForwarded()) &&

+ (forwardedMessage = std::dynamic_pointer_cast<Message>(forwarded->getStanza()))) {

+ JID toJID = forwardedMessage->getTo();

+

+ ChatController* controller = getChatControllerOrCreate(toJID);

+ if (controller) {

+ controller->handleIncomingOwnMessage(forwardedMessage);

+ }

+ else {

+ SWIFT_LOG(error) << "Carbons message ignored.";

+ }

+ return;

+ }

+ }

+ JID fromJID = message->getFrom();

+

+ std::shared_ptr<MessageEvent> event(new MessageEvent(message));

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

+ bool isMediatedInvite = (message->getPayload<MUCUserPayload>() && message->getPayload<MUCUserPayload>()->getInvite());

+ if (isMediatedInvite) {

+ fromJID = (*message->getPayload<MUCUserPayload>()->getInvite()).from;

+ }

+ if (!event->isReadable() && !message->getPayload<ChatState>() && !message->getPayload<DeliveryReceipt>() && !message->getPayload<DeliveryReceiptRequest>() && !isInvite && !isMediatedInvite && !message->hasSubject()) {

+ return;

+ }

+

+ // Try to deliver MUC errors to a MUC PM window if a suitable window is open.

+ if (message->getType() == Message::Error) {

+ auto controller = getChatControllerIfExists(fromJID, messageCausesSessionBinding(message));

+ if (controller) {

+ controller->handleIncomingMessage(event);

+ return;

+ }

+ }

+

+ // Try to deliver it to a MUC.

+ if (message->getType() == Message::Groupchat || message->getType() == Message::Error) {

+ // Try to deliver it to a MUC room.

+ std::map<JID, MUCController*>::iterator i = mucControllers_.find(fromJID.toBare());

+ if (i != mucControllers_.end()) {

+ i->second->handleIncomingMessage(event);

+ return;

+ }

+ else if (message->getType() == Message::Groupchat) {

+ //FIXME: Error handling - groupchat messages from an unknown muc.

+ return;

+ }

+ }

+

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

+ if (controller) {

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

+ chatControllers_.erase(fromJID);

+ delete controller;

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

+ return;

+ }

+ } else {

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

+ return;

+ }

+ }

+

+ //if not a mucroom

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

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

+

+ // Do not bind a controller to a full JID, for delivery receipts or chat state notifications.

+ ChatController* controller = getChatControllerIfExists(fromJID, messageCausesSessionBinding(message));

+ if (controller) {

+ controller->handleIncomingMessage(event);

+ }

+ } else {

+ getChatControllerOrCreate(fromJID)->handleIncomingMessage(event);

+ }

+ if (joinMUCWindow_) {

+ joinMUCWindow_->setMUC(muc.toString());

+ }

+ uiEventStream_->send(std::make_shared<JoinMUCUIEvent>(mucBookmark.getRoom(), mucBookmark.getPassword(), mucBookmark.getNick()));

+ ChatController* chatController = getChatControllerOrCreate(ftc->getOtherParty());

+ chatController->handleNewFileTransferController(ftc);

+ if (!ftc->isIncoming()) {

+ chatController->activateChatWindow();

+ }

+ ChatController* chatController = getChatControllerOrCreate(contact);

+ chatController->handleWhiteboardSessionRequest(senderIsSelf);

+ chatController->activateChatWindow();

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

+ }

+#ifndef NOT_YET

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

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

+ std::vector<JID> inviteJIDs;

+ for (StringJIDPair pair : chat.impromptuJIDs) {

+ inviteJIDs.push_back(pair.second);

+ }

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

+ }

+ else if (chat.isMUC) {

+ bool isImpromptu = (!chat.inviteesNames.empty() || !chat.impromptuJIDs.empty());

+ /* FIXME: This means that recents requiring passwords will just flat-out not work */

+ uiEventStream_->send(std::make_shared<JoinMUCUIEvent>(chat.jid, boost::optional<std::string>(), chat.nick, false, isImpromptu));

+ }

+ else {

+ uiEventStream_->send(std::make_shared<RequestChatUIEvent>(chat.jid));

+ }

+}

+

+#endif

+

+void ChatsManager::handleChattableActivated(const JID& jid) {

+ auto state = chattables_.getState(jid);

+ if (state.type == Chattables::State::Type::Person) {

+ uiEventStream_->send(std::make_shared<RequestChatUIEvent>(jid));

+ }

+ else if (state.type == Chattables::State::Type::Room) {

+ if (auto foundBookmark = mucBookmarkManager_->lookupBookmark(jid)) {

+ handleMUCBookmarkActivated(foundBookmark.get());

+ }

+ else {

+ uiEventStream_->send(std::make_shared<JoinMUCUIEvent>(jid, boost::optional<std::string>(), boost::optional<std::string>())); // Just a quick hack to reuse already open MUCs

+ }

+ }

+}

+

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

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

+ break;

+ }

+ }

+ bool impromptuMUCSupported = !localMUCServiceJID_.toString().empty();

+ for (JIDChatControllerPair controllerPair : chatControllers_) {

+ controllerPair.second->setCanStartImpromptuChats(impromptuMUCSupported);

+ }

+ for (JIDMUCControllerPair controllerPair : mucControllers_) {

+ controllerPair.second->setCanStartImpromptuChats(impromptuMUCSupported);

+ }

+ onImpromptuMUCServiceDiscovered(impromptuMUCSupported);

+#ifndef NOT_YET

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

+#endif

+

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

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

+#ifndef NOT_YET

+ for (ChatListWindow::Chat chat : recentChats_) {

+ if (!chat.isMUC) {

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

+ }

+ }

+#endif

+ if (withMUCNicks) {

+ /* collect MUC nicks */

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

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

+ for (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(std::make_shared<Contact>(participant.first, JID(), presence->getShow(), avatar));

+ }

+ }

+ }

+ return result;

+ return chatWindow_;

+ * Copyright (c) 2010-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <memory>

+#include <set>

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

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

+ class AutoAcceptMUCInviteDecider;

+ class AvatarManager;

+ class ChatController;

+ class ChatControllerBase;

+ class ChatListWindowFactory;

+ class ChatMessageParser;

+ class Chattables;

+ class ClientBlockListManager;

+ class DirectedPresenceSender;

+ class DiscoServiceWalker;

+ class EntityCapsProvider;

+ class EventController;

+ class FileTransferController;

+ class FileTransferOverview;

+ class HighlightManager;

+ class HistoryController;

+ class IQRouter;

+ class JoinMUCWindow;

+ class JoinMUCWindowFactory;

+ class MUCBookmarkManager;

+ class MUCController;

+ class MUCManager;

+ class MUCSearchController;

+ class MUCSearchWindowFactory;

+ class NickResolver;

+ class PresenceOracle;

+ class PresenceSender;

+ class ProfileSettingsProvider;

+ class SettingsProvider;

+ class StanzaChannel;

+ class TimerFactory;

+ class VCardManager;

+ class WhiteboardManager;

+ class XMPPRoster;

+

+ class ChatsManager : public ContactProvider {

+ public:

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

+ virtual ~ChatsManager();

+ void setAvatarManager(AvatarManager* avatarManager);

+ void setOnline(bool enabled);

+ void setServerDiscoInfo(std::shared_ptr<DiscoInfo> info);

+ void handleIncomingMessage(std::shared_ptr<Message> incomingMessage);

+#ifndef NOT_YET

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

+#endif

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

+

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

+

+ private:

+ class SingleChatWindowFactoryAdapter : public ChatWindowFactory {

+ public:

+ SingleChatWindowFactoryAdapter(ChatWindow* chatWindow);

+ virtual ~SingleChatWindowFactoryAdapter();

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

+

+ private:

+ ChatWindow* chatWindow_;

+ };

+

+ private:

+#ifndef NOT_YET

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

+#endif

+ void handleChatRequest(const std::string& contact);

+ 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 createAsReservedIfNew, bool isImpromptu, ChatWindow* reuseChatwindow = nullptr);

+ void handleSearchMUCRequest();

+ void handleMUCSelectedAfterSearch(const JID&);

+ void rebindControllerJID(const JID& from, const JID& to);

+ void handlePresenceChange(std::shared_ptr<Presence> newPresence);

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

+ void handleMUCBookmarkAdded(const MUCBookmark& bookmark);

+ void handleMUCBookmarkRemoved(const MUCBookmark& bookmark);

+ void handleUserLeftMUC(MUCController* mucController);

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

+ void handleBookmarksReady();

+ void handleChatActivity(const JID& jid, const std::string& activity, bool isMUC);

+ void handleChatClosed(const JID& jid);

+ void handleNewFileTransferController(FileTransferController*);

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

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

+#ifndef NOT_YET

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

+#endif

+ bool messageCausesSessionBinding(std::shared_ptr<Message> message);

+ void cleanupPrivateMessageRecents();

+#ifndef NOT_YET

+ void appendRecent(const ChatListWindow::Chat& chat);

+ void prependRecent(const ChatListWindow::Chat& chat);

+#endif

+ void setupBookmarks();

+#ifndef NOT_YET

+ void loadRecents();

+ void saveRecents();

+ void handleChatMadeRecent();

+ void handleMUCBookmarkActivated(const MUCBookmark&);

+ void handleRecentActivated(const ChatListWindow::Chat&);

+ void handleUnreadCountChanged(ChatControllerBase* controller);

+#endif

+ void handleChattableActivated(const JID& jid);

+ void handleAvatarChanged(const JID& jid);

+ void handleClearRecentsRequested();

+ void handleJIDAddedToRoster(const JID&);

+ void handleJIDRemovedFromRoster(const JID&);

+ void handleJIDUpdatedInRoster(const JID&);

+ void handleRosterCleared();

+ void handleSettingChanged(const std::string& settingPath);

+ void markAllRecentsOffline();

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

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

+ void handleLocalServiceWalkFinished();

+ void updatePresenceReceivingStateOnChatController(const JID&);

+#ifndef NOT_YET

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

+#endif

+

+

+

+ ChatController* getChatControllerOrFindAnother(const JID &contact);

+ ChatController* createNewChatController(const JID &contact);

+ ChatController* getChatControllerOrCreate(const JID &contact);

+ ChatController* getChatControllerIfExists(const JID &contact, bool rebindIfNeeded = true);

+

+ protected:

+ MUCBookmarkManager* mucBookmarkManager_;

+

+ private:

+ std::map<JID, MUCController*> mucControllers_;

+ std::map<JID, ChatController*> chatControllers_;

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

+ EventController* eventController_;

+ JID jid_;

+ StanzaChannel* stanzaChannel_;

+ IQRouter* iqRouter_;

+ ChatWindowFactory* chatWindowFactory_;

+ JoinMUCWindowFactory* joinMUCWindowFactory_;

+ NickResolver* nickResolver_;

+ PresenceOracle* presenceOracle_;

+ AvatarManager* avatarManager_;

+ PresenceSender* presenceSender_;

+ UIEventStream* uiEventStream_;

+ std::shared_ptr<DiscoInfo> serverDiscoInfo_;

+#ifndef NOT_YET

+ ChatListWindow* chatListWindow_;

+#endif

+ JoinMUCWindow* joinMUCWindow_;

+ boost::signals2::scoped_connection uiEventConnection_;

+ bool useDelayForLatency_;

+ TimerFactory* timerFactory_;

+ MUCRegistry* mucRegistry_;

+ EntityCapsProvider* entityCapsProvider_;

+ MUCManager* mucManager;

+ MUCSearchController* mucSearchController_;

+#ifndef NOT_YET

+ std::list<ChatListWindow::Chat> recentChats_;

+#endif

+ ProfileSettingsProvider* profileSettings_;

+ FileTransferOverview* ftOverview_;

+ XMPPRoster* roster_;

+ bool eagleMode_;

+ bool userWantsReceipts_;

+ SettingsProvider* settings_;

+ HistoryController* historyController_;

+ WhiteboardManager* whiteboardManager_;

+ HighlightManager* highlightManager_;

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

+ ClientBlockListManager* clientBlockListManager_;

+ JID localMUCServiceJID_;

+ std::shared_ptr<DiscoServiceWalker> localMUCServiceFinderWalker_;

+ AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider_;

+ IDGenerator idGenerator_;

+ VCardManager* vcardManager_;

+ Chattables& chattables_;

+

+ std::map<JID, std::set<JID>> invitees_;

+ };

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

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

+

+namespace Swift {

+

+const std::vector<JID>& Chattables::get() const {

+ return list_;

+}

+

+const Chattables::State& Chattables::getState(const JID& jid) const {

+ auto it = states_.find(jid);

+ return it != states_.end() ? it->second : unknown_;

+}

+

+void Chattables::addJID(const JID& jid, State::Type type) {

+ if (states_.find(jid) != states_.end()) {

+ return;

+ }

+ State state;

+ state.type = type;

+ state.jid = jid;

+ onBeginAdd(static_cast<int>(list_.size()));

+ list_.push_back(jid);

+ states_[jid] = state;

+ onAdded();

+}

+

+void Chattables::setState(const JID& jid, State state) {

+ auto stateIter = states_.find(jid);

+ if (stateIter == states_.end()) {

+ return;

+ }

+ stateIter->second = state;

+ auto listPos = static_cast<int>(std::distance(list_.begin(), std::find(list_.begin(), list_.end(), jid)));

+ onChanged(jid, listPos);

+}

+

+}

+/*

+ * Copyright (c) 2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+ */

+

+#pragma once

+

+#include <map>

+#include <vector>

+

+#include <boost/signals2.hpp>

+

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

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

+

+namespace Swift {

+class Chattables {

+ public:

+ struct State {

+ enum class Type {Room, Person};

+ JID jid;

+ /// Empty for no name

+ std::string name;

+ size_t unreadCount = 0;

+ Type type;

+ StatusShow::Type status = StatusShow::None;

+ //avatar

+ //status

+ };

+ const std::vector<JID>& get() const;

+ const State& getState(const JID& jid) const;

+

+ void addJID(const JID& jid, State::Type type);

+ void setState(const JID& jid, State state);

+

+ boost::signals2::signal<void (int)> onBeginAdd;

+ boost::signals2::signal<void ()> onAdded;

+ boost::signals2::signal<void (const JID&, int)> onChanged;

+ /// The UI has activated a chattable item (e.g. clicked in the roster)

+ boost::signals2::signal<void (const JID&)> onActivated;

+ private:

+ std::vector<JID> list_;

+ std::map<JID, State> states_;

+ State unknown_;

+};

+}

+ * Copyright (c) 2010-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <algorithm>

+#include <cassert>

+#include <memory>

+

+#include <boost/range/adaptor/reversed.hpp>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+

+

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

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

+#include <Swift/Controllers/Highlighting/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/SetMUC.h>

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

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

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

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

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

+

+ const JID& self,

+ MUC::ref muc,

+ const boost::optional<std::string>& password,

+ const std::string &nick,

+ StanzaChannel* stanzaChannel,

+ IQRouter* iqRouter,

+ ChatWindowFactory* chatWindowFactory,

+ NickResolver* nickResolver,

+ PresenceOracle* presenceOracle,

+ AvatarManager* avatarManager,

+ UIEventStream* uiEventStream,

+ bool useDelayForLatency,

+ TimerFactory* timerFactory,

+ EventController* eventController,

+ EntityCapsProvider* entityCapsProvider,

+ XMPPRoster* xmppRoster,

+ HistoryController* historyController,

+ MUCRegistry* mucRegistry,

+ HighlightManager* highlightManager,

+ ClientBlockListManager* clientBlockListManager,

+ std::shared_ptr<ChatMessageParser> chatMessageParser,

+ bool isImpromptu,

+ AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider,

+ VCardManager* vcardManager,

+ MUCBookmarkManager* mucBookmarkManager,

+ SettingsProvider* settings,

+ Chattables& chattables) :

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

+ assert(avatarManager_);

+

+ parting_ = true;

+ joined_ = false;

+ lastWasPresence_ = false;

+ shouldJoinOnReconnect_ = true;

+ doneGettingHistory_ = false;

+ xmppRoster_ = xmppRoster;

+ subject_ = "";

+ isInitialJoin_ = true;

+ chatWindowTitle_ = "";

+

+ roster_ = std::make_unique<Roster>(false, true);

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

+ completer_ = new TabComplete();

+ chatWindow_->setRosterModel(roster_.get());

+ chatWindow_->setTabComplete(completer_);

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

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

+ chatWindow_->onOccupantActionSelected.connect(boost::bind(&MUCController::handleActionRequestedOnOccupant, this, _1, _2));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ chatMessageParser_->setNick(nick_);

+ if (timerFactory && stanzaChannel_->isAvailable()) {

+ loginCheckTimer_ = std::shared_ptr<Timer>(timerFactory->createTimer(MUC_JOIN_WARNING_TIMEOUT_MILLISECONDS));

+ loginCheckTimer_->onTick.connect(boost::bind(&MUCController::handleJoinTimeoutTick, this));

+ loginCheckTimer_->start();

+ }

+ else {

+ chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(QT_TRANSLATE_NOOP("", "You are currently offline. You will enter this room when you are connected.")), ChatWindow::DefaultDirection);

+ }

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

+ }

+ if (stanzaChannel->isAvailable()) {

+ MUCController::setOnline(true);

+ }

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

+

+ MUCController::handleBareJIDCapsChanged(muc->getJID());

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

+

+

+ // setup handling of MUC bookmark changes

+ mucBookmarkManagerBookmarkAddedConnection_ = (mucBookmarkManager_->onBookmarkAdded.connect(boost::bind(&MUCController::handleMUCBookmarkAdded, this, _1)));

+ mucBookmarkManagerBookmarkRemovedConnection_ = (mucBookmarkManager_->onBookmarkRemoved.connect(boost::bind(&MUCController::handleMUCBookmarkRemoved, this, _1)));

+

+ updateChatWindowBookmarkStatus(mucBookmarkManager_->lookupBookmark(muc->getJID()));

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

+ chatWindow_->setRosterModel(nullptr);

+ delete rosterVCardProvider_;

+ if (loginCheckTimer_) {

+ loginCheckTimer_->stop();

+ }

+ chatWindow_->setTabComplete(nullptr);

+ delete completer_;

+ lastWasPresence_ = false;

+ std::vector<ChatWindow::OccupantAction> actions;

+

+ if (item) {

+ MUCOccupant::Affiliation affiliation = muc_->getOccupant(getNick()).getAffiliation();

+ MUCOccupant::Role role = muc_->getOccupant(getNick()).getRole();

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

+ {

+ if (affiliation == MUCOccupant::Admin || affiliation == MUCOccupant::Owner) {

+ actions.push_back(ChatWindow::Ban);

+ }

+

+ actions.push_back(ChatWindow::Kick);

+ actions.push_back(ChatWindow::MakeModerator);

+ actions.push_back(ChatWindow::MakeParticipant);

+ actions.push_back(ChatWindow::MakeVisitor);

+ }

+ // Add contact is available only if the real JID is also available

+ if (muc_->getOccupant(item->getJID().getResource()).getRealJID()) {

+ actions.push_back(ChatWindow::AddContact);

+ }

+ actions.push_back(ChatWindow::ShowProfile);

+ }

+ chatWindow_->setAvailableOccupantActions(actions);

+ JID mucJID = item->getJID();

+ MUCOccupant occupant = muc_->getOccupant(mucJID.getResource());

+ JID realJID;

+ if (occupant.getRealJID()) {

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

+ }

+ switch (action) {

+ case ChatWindow::Kick: muc_->kickOccupant(mucJID);break;

+ case ChatWindow::Ban: muc_->changeAffiliation(realJID, MUCOccupant::Outcast);break;

+ case ChatWindow::MakeModerator: muc_->changeOccupantRole(mucJID, MUCOccupant::Moderator);break;

+ case ChatWindow::MakeParticipant: muc_->changeOccupantRole(mucJID, MUCOccupant::Participant);break;

+ case ChatWindow::MakeVisitor: muc_->changeOccupantRole(mucJID, MUCOccupant::Visitor);break;

+ case ChatWindow::AddContact: if (occupant.getRealJID()) eventStream_->send(std::make_shared<RequestAddUserDialogUIEvent>(realJID, occupant.getNick()));break;

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

+ }

+ Tristate support = Yes;

+ bool any = false;

+ for (const auto& nick : currentOccupants_) {

+ DiscoInfo::ref disco = entityCapsProvider_->getCapsCached(toJID_.toBare().toString() + "/" + nick);

+ if (disco && disco->hasFeature(DiscoInfo::MessageCorrectionFeature)) {

+ any = true;

+ } else {

+ support = Maybe;

+ }

+ }

+ if (!any) {

+ support = No;

+ }

+ chatWindow_->setCorrectionEnabled(support);

+ if (parting_) {

+ joined_ = false;

+ parting_ = false;

+ if (password_) {

+ muc_->setPassword(*password_);

+ }

+ //FIXME: check for received activity

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

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

+ }

+

+ requestSecurityMarking();

+

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

+ muc_->joinAs(nick_);

+ }

+ else {

+ muc_->joinWithContextSince(nick_, lastActivity_);

+ }

+ }

+ return joined_;

+ return nick_;

+}

+

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

+ return password_;

+ return isImpromptu_;

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

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

+ for (const auto& occupant : occupants) {

+ if (occupant.first != nick_) {

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

+ }

+ }

+ return participants;

+ for (const auto& jid : jids) {

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

+ }

+ receivedActivity();

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

+ if (loginCheckTimer_) {

+ loginCheckTimer_->stop();

+ }

+void MUCController::handleJoinFailed(std::shared_ptr<ErrorPayload> error) {

+ receivedActivity();

+ std::string errorMessage = QT_TRANSLATE_NOOP("", "Unable to enter this room");

+ std::string rejoinNick;

+ if (error) {

+ switch (error->getCondition()) {

+ case ErrorPayload::Conflict:

+ rejoinNick = nick_ + "_";

+ errorMessage = str(format(QT_TRANSLATE_NOOP("", "Unable to enter this room as %1%, retrying as %2%")) % nick_ % rejoinNick);

+ break;

+ case ErrorPayload::JIDMalformed:

+ errorMessage += ": ";

+ errorMessage += QT_TRANSLATE_NOOP("", "No nickname specified");

+ break;

+ case ErrorPayload::NotAuthorized:

+ errorMessage += ": ";

+ errorMessage += QT_TRANSLATE_NOOP("", "The correct room password is needed");

+ break;

+ case ErrorPayload::RegistrationRequired:

+ errorMessage += ": ";

+ errorMessage += QT_TRANSLATE_NOOP("", "Only members may enter");

+ break;

+ case ErrorPayload::Forbidden:

+ errorMessage += ": ";

+ errorMessage += QT_TRANSLATE_NOOP("", "You are banned from the room");

+ break;

+ case ErrorPayload::ServiceUnavailable:

+ errorMessage += ": ";

+ errorMessage += QT_TRANSLATE_NOOP("", "The room is full");

+ break;

+ case ErrorPayload::ItemNotFound:

+ errorMessage += ": ";

+ errorMessage += QT_TRANSLATE_NOOP("", "The room does not exist");

+ break;

+

+ default: break;

+ }

+ }

+ errorMessage = str(format(QT_TRANSLATE_NOOP("", "Couldn't enter room: %1%.")) % errorMessage);

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

+ parting_ = true;

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

+ renameCounter_++;

+ setNick(rejoinNick);

+ rejoin();

+ }

+ receivedActivity();

+ renameCounter_ = 0;

+ joined_ = true;

+ if (isImpromptu_) {

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

+ }

+ else {

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

+ }

+ setNick(nick);

+ chatWindow_->replaceSystemMessage(chatMessageParser_->parseMessageBody(lastStartMessage_, "", true), lastJoinMessageUID_, ChatWindow::UpdateTimestamp);

+ lastJoinMessageUID_ = "";

+ addRecentLogs();

+ clearPresenceQueue();

+ shouldJoinOnReconnect_ = true;

+ setEnabled(true);

+ if (isImpromptu_) {

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

+ } else {

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

+ setAvailableRoomActions(occupant.getAffiliation(), occupant.getRole());

+ }

+ onUserJoined();

+ if (parting_ || !jid.equals(toJID_, JID::WithoutResource)) {

+ return;

+ }

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

+ parting_ = true;

+ shouldJoinOnReconnect_ = false;

+ muc_->part();

+ onUserLeft();

+ if (nick_ != occupant.getNick()) {

+ completer_->addWord(occupant.getNick());

+ }

+ receivedActivity();

+ JID jid(nickToJID(occupant.getNick()));

+ JID realJID;

+ if (occupant.getRealJID()) {

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

+ }

+ currentOccupants_.insert(occupant.getNick());

+ NickJoinPart event(occupant.getNick(), Join);

+ appendToJoinParts(joinParts_, event);

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

+ if (joined_) {

+ std::string joinString;

+ if (role != MUCOccupant::NoRole && role != MUCOccupant::Participant) {

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

+ }

+ else {

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

+ }

+ if (shouldUpdateJoinParts()) {

+ updateJoinParts();

+ } else {

+ addPresenceMessage(joinString);

+ }

+

+ if (isImpromptu_) {

+ onActivity("");

+ }

+ }

+ handleAvatarChanged(jid);

+ lastWasPresence_ = true;

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

+ std::vector<ChatWindow::RoomAction> actions;

+

+ if (role <= MUCOccupant::Participant) {

+ actions.push_back(ChatWindow::ChangeSubject);

+ }

+ if (affiliation == MUCOccupant::Owner) {

+ actions.push_back(ChatWindow::Configure);

+ }

+ if (affiliation <= MUCOccupant::Admin) {

+ actions.push_back(ChatWindow::Affiliations);

+ }

+ if (affiliation == MUCOccupant::Owner) {

+ actions.push_back(ChatWindow::Destroy);

+ }

+ if (role <= MUCOccupant::Visitor) {

+ actions.push_back(ChatWindow::Invite);

+ }

+ actions.push_back(ChatWindow::Leave);

+ chatWindow_->setAvailableRoomActions(actions);

+ lastWasPresence_ = false;

+ joinParts_.clear();

+ switch (role) {

+ case MUCOccupant::Moderator: return QT_TRANSLATE_NOOP("", "moderator");

+ case MUCOccupant::Participant: return QT_TRANSLATE_NOOP("", "participant");

+ case MUCOccupant::Visitor: return QT_TRANSLATE_NOOP("", "visitor");

+ case MUCOccupant::NoRole: return "";

+ }

+ assert(false);

+ return "";

+ switch (role) {

+ case MUCOccupant::Moderator: return "1";

+ case MUCOccupant::Participant: return "2";

+ case MUCOccupant::Visitor: return "3";

+ case MUCOccupant::NoRole: return "4";

+ }

+ assert(false);

+ return "5";

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

+}

+

+bool MUCController::messageTargetsMe(std::shared_ptr<Message> message) {

+ std::string stringRegexp(".*\\b" + boost::to_lower_copy(nick_) + "\\b.*");

+ boost::regex myRegexp(stringRegexp);

+ return boost::regex_match(boost::to_lower_copy(message->getBody().get_value_or("")), myRegexp);

+}

+

+void MUCController::preHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent) {

+ if (messageEvent->getStanza()->getType() == Message::Groupchat) {

+ lastActivity_ = boost::posix_time::microsec_clock::universal_time();

+ }

+ std::shared_ptr<Message> message = messageEvent->getStanza();

+

+ // This avoids clearing join/leave queue for chat state notification messages

+ // which are not readable (e.g. have no body content).

+ if (!(!messageEvent->isReadable() && message->getPayload<ChatState>())) {

+ clearPresenceQueue();

+ }

+

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

+ chatWindow_->flash();

+ }

+ else {

+ messageEvent->setTargetsMe(false);

+ }

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

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

+ }

+ if (joined_) {

+ std::string nick = message->getFrom().getResource();

+ if (nick != nick_ && currentOccupants_.find(nick) != currentOccupants_.end()) {

+ completer_->addWord(nick);

+ }

+ }

+ /*Buggy implementations never send the status code, so use an incoming message as a hint that joining's done (e.g. the old ejabberd on psi-im.org).*/

+ receivedActivity();

+ joined_ = true;

+

+ if (message->hasSubject() && !message->getPayload<Body>() && !message->getPayload<Thread>()) {

+ if (!isInitialJoin_) {

+ displaySubjectIfChanged(message->getSubject());

+ }

+ isInitialJoin_ = false;

+ chatWindow_->setSubject(message->getSubject());

+ doneGettingHistory_ = true;

+ subject_ = message->getSubject();

+ }

+

+ if (!doneGettingHistory_ && !message->getPayload<Delay>()) {

+ doneGettingHistory_ = true;

+ }

+

+ if (!doneGettingHistory_) {

+ checkDuplicates(message);

+ messageEvent->conclude();

+ }

+}

+

+void MUCController::addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& time) {

+ if (from.isBare()) {

+ chatWindow_->addSystemMessage(message, ChatWindow::DefaultDirection);

+ }

+ else {

+ lastMessagesIDs_[from] = {messageID, addMessage(message, senderDisplayNameFromMessage(from), senderIsSelf, label, avatarManager_->getAvatarPath(from), time)};

+ }

+}

+

+void MUCController::handleIncomingReplaceMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, const std::string& /*idToReplace*/, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) {

+ auto lastMessage = lastMessagesIDs_.find(from);

+ if (lastMessage != lastMessagesIDs_.end()) {

+ replaceMessage(message, lastMessage->second.idInWindow, timeStamp);

+ }

+ else {

+ addMessageHandleIncomingMessage(from, message, messageID, senderIsSelf, label, timeStamp);

+ }

+}

+

+void MUCController::postHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent, const ChatWindow::ChatMessage& chatMessage) {

+ std::shared_ptr<Message> message = messageEvent->getStanza();

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

+ highlighter_->handleSystemNotifications(chatMessage, messageEvent);

+ if (!messageEvent->getNotifications().empty()) {

+ eventController_->handleIncomingEvent(messageEvent);

+ }

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

+ highlighter_->handleSoundNotifications(chatMessage);

+ }

+ }

+ clearPresenceQueue();

+ receivedActivity();

+ JID jid(nickToJID(nick));

+ roster_->removeContactFromGroup(jid, roleToGroupName(oldRole));

+ JID realJID;

+ if (occupant.getRealJID()) {

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

+ }

+ std::string group(roleToGroupName(occupant.getRole()));

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

+ roster_->getGroup(group)->setManualSort(roleToSortName(occupant.getRole()));

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

+ if (nick == nick_) {

+ setAvailableRoomActions(occupant.getAffiliation(), occupant.getRole());

+ }

+ if (nick == nick_) {

+ setAvailableRoomActions(affiliation, muc_->getOccupant(nick_).getRole());

+ }

+ JID jid(nickToJID(nick));

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

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

+ std::string result;

+ switch (role) {

+ case MUCOccupant::Moderator: result = QT_TRANSLATE_NOOP("", "Moderators"); break;

+ case MUCOccupant::Participant: result = QT_TRANSLATE_NOOP("", "Participants"); break;

+ case MUCOccupant::Visitor: result = QT_TRANSLATE_NOOP("", "Visitors"); break;

+ case MUCOccupant::NoRole: result = QT_TRANSLATE_NOOP("", "Occupants"); break;

+ }

+ return result;

+ ChatControllerBase::setOnline(online);

+ if (!online) {

+ muc_->part();

+ parting_ = true;

+ processUserPart();

+ } else {

+ if (shouldJoinOnReconnect_) {

+ renameCounter_ = 0;

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

+ if (blockList && blockList->isBlocked(muc_->getJID())) {

+ handleBlockingStateChanged();

+ lastStartMessage_ = QT_TRANSLATE_NOOP("", "You've blocked this room. To enter the room, first unblock it using the cog menu and try again");

+ lastJoinMessageUID_ = chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(lastStartMessage_ ), ChatWindow::DefaultDirection);

+ }

+ else {

+ if (isImpromptu_) {

+ lastStartMessage_ = QT_TRANSLATE_NOOP("", "Trying to join chat");

+ lastJoinMessageUID_ = chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(lastStartMessage_), ChatWindow::DefaultDirection);

+ } else {

+ lastStartMessage_ = str(format(QT_TRANSLATE_NOOP("", "Trying to enter room %1%")) % toJID_.toString());

+ lastJoinMessageUID_ = chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(lastStartMessage_), ChatWindow::DefaultDirection);

+ }

+ if (loginCheckTimer_) {

+ loginCheckTimer_->start();

+ }

+ setNick(desiredNick_);

+ rejoin();

+ }

+ }

+ }

+ roster_->removeAll();

+ /* handleUserLeft won't throw a part back up unless this is called

+ when it doesn't yet know we've left - which only happens on

+ disconnect, so call with disconnect here so if the signal does

+ bubble back up, it'll be with the right type.*/

+ muc_->handleUserLeft(MUC::Disconnect);

+ setEnabled(false);

+ return lastWasPresence_;

+ NickJoinPart event(occupant.getNick(), Part);

+ appendToJoinParts(joinParts_, event);

+ currentOccupants_.erase(occupant.getNick());

+ completer_->removeWord(occupant.getNick());

+ std::string partMessage;

+ bool clearAfter = false;

+ if (occupant.getNick() != nick_) {

+ std::string partType;

+ switch (type) {

+ case MUC::LeaveKick: clearPresenceQueue(); clearAfter = true; partType = " (kicked)"; break;

+ case MUC::LeaveBan: clearPresenceQueue(); clearAfter = true; partType = " (banned)"; break;

+ case MUC::LeaveNotMember: clearPresenceQueue(); clearAfter = true; partType = " (no longer a member)"; break;

+ case MUC::LeaveDestroy:

+ case MUC::Disconnect:

+ case MUC::LeavePart: break;

+ }

+ if (isImpromptu_) {

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

+ } else {

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

+ }

+ }

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

+ }

+ }

+ else {

+ switch (type) {

+ case MUC::LeaveKick: clearPresenceQueue(); clearAfter = true; partMessage = QT_TRANSLATE_NOOP("", "You have been kicked out of the room"); break;

+ case MUC::LeaveBan: clearPresenceQueue(); clearAfter = true; partMessage = QT_TRANSLATE_NOOP("", "You have been banned from the room"); break;

+ case MUC::LeaveNotMember: clearPresenceQueue(); clearAfter = true; partMessage = QT_TRANSLATE_NOOP("", "You are no longer a member of the room and have been removed"); break;

+ case MUC::LeaveDestroy: clearPresenceQueue(); clearAfter = true; partMessage = QT_TRANSLATE_NOOP("", "The room has been destroyed"); break;

+ case MUC::Disconnect:

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

+ }

+ }

+ if (!reason.empty()) {

+ partMessage += " (" + reason + ")";

+ }

+ partMessage += ".";

+

+ if (occupant.getNick() != nick_) {

+ if (shouldUpdateJoinParts()) {

+ updateJoinParts();

+ } else {

+ addPresenceMessage(partMessage);

+ }

+ roster_->removeContact(JID(toJID_.getNode(), toJID_.getDomain(), occupant.getNick()));

+ } else {

+ addPresenceMessage(partMessage);

+ parting_ = true;

+ processUserPart();

+ }

+ if (clearAfter) {

+ clearPresenceQueue();

+ }

+}

+

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

+ auto it = currentOccupants_.find(newNickname);

+ if (it != currentOccupants_.end()) {

+ roster_->removeContact(newJID);

+ }

+

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

+ handleAvatarChanged(newJID);

+

+ clearPresenceQueue();

+ onUserNicknameChanged(oldNickname, newNickname);

+}

+

+void MUCController::handleOccupantPresenceChange(std::shared_ptr<Presence> presence) {

+ receivedActivity();

+ roster_->applyOnItems(SetPresence(presence, JID::WithResource));

+}

+

+bool MUCController::isIncomingMessageFromMe(std::shared_ptr<Message> message) {

+ JID from = message->getFrom();

+ return nick_ == from.getResource();

+}

+

+std::string MUCController::senderHighlightNameFromMessage(const JID& from) {

+ return from.getResource();

+ return from.getResource();

+void MUCController::preSendMessageRequest(std::shared_ptr<Message> message) {

+ message->setType(Swift::Message::Groupchat);

+boost::optional<boost::posix_time::ptime> MUCController::getMessageTimestamp(std::shared_ptr<Message> message) const {

+ return message->getTimestampFrom(toJID_);

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

+ std::vector<NickJoinPart>::iterator it = joinParts.begin();

+ bool matched = false;

+ for (; it != joinParts.end(); ++it) {

+ if ((*it).nick == newEvent.nick) {

+ matched = true;

+ JoinPart type = (*it).type;

+ switch (newEvent.type) {

+ case Join: type = (type == Part) ? PartThenJoin : Join; break;

+ case Part: type = (type == Join) ? JoinThenPart : Part; break;

+ case PartThenJoin: break;

+ case JoinThenPart: break;

+ }

+ (*it).type = type;

+ break;

+ }

+ }

+ if (!matched) {

+ joinParts.push_back(newEvent);

+ }

+ std::string result;

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

+ if (i > 0) {

+ if (i < joinParts.size() - 1) {

+ result += ", ";

+ } else {

+ result += QT_TRANSLATE_NOOP("", " and ");

+ }

+ }

+ NickJoinPart event = joinParts[i];

+ result += event.nick;

+ }

+ return result;

+ std::vector<NickJoinPart> sorted[4];

+ std::string eventStrings[4];

+ for (const auto& event : joinParts) {

+ sorted[event.type].push_back(event);

+ }

+ std::string result;

+ std::vector<JoinPart> populatedEvents;

+ for (size_t i = 0; i < 4; i++) {

+ std::string names = concatenateListOfNames(sorted[i]);

+ if (!names.empty()) {

+ std::string eventString;

+ switch (i) {

+ case Join:

+ if (sorted[i].size() > 1) {

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

+ }

+ else {

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

+ }

+ break;

+ case Part:

+ if (sorted[i].size() > 1) {

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

+ }

+ else {

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

+ }

+ break;

+ case JoinThenPart:

+ if (sorted[i].size() > 1) {

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

+ }

+ else {

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

+ }

+ break;

+ case PartThenJoin:

+ if (sorted[i].size() > 1) {

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

+ }

+ else {

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

+ }

+ break;

+ }

+ populatedEvents.push_back(static_cast<JoinPart>(i));

+ eventStrings[i] = str(boost::format(eventString) % names);

+ }

+ }

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

+ if (i > 0) {

+ if (i < populatedEvents.size() - 1) {

+ result += ", ";

+ } else {

+ result += QT_TRANSLATE_NOOP("", " and ");

+ }

+ }

+ result += eventStrings[populatedEvents[i]];

+ }

+ return result;

+}

+

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

+ muc_->changeSubject(subject);

+}

+

+void MUCController::handleBookmarkRequest() {

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

+

+ // Prepare new bookmark for this room.

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

+ roomBookmark.setPassword(password_);

+ roomBookmark.setNick(nick_);

+

+ // Check for existing bookmark for this room and, if it exists, use it instead.

+ std::vector<MUCBookmark> bookmarks = mucBookmarkManager_->getBookmarks();

+ for (const auto& bookmark : bookmarks) {

+ if (bookmark.getRoom() == jid.toBare()) {

+ roomBookmark = bookmark;

+ break;

+ }

+ }

+

+ chatWindow_->showBookmarkWindow(roomBookmark);

+ if (form) {

+ muc_->configureRoom(form);

+ }

+ else {

+ muc_->requestConfigurationForm();

+ }

+ std::string errorMessage = getErrorMessage(error);

+ errorMessage = str(format(QT_TRANSLATE_NOOP("", "Room configuration failed: %1%.")) % errorMessage);

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

+ std::string errorMessage = getErrorMessage(error);

+ errorMessage = str(format(QT_TRANSLATE_NOOP("", "Occupant role change failed: %1%.")) % errorMessage);

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

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

+ isImpromptuAlreadyConfigured_ = true;

+ onImpromptuConfigCompleted();

+ if (isImpromptu_) {

+ if (!isImpromptuAlreadyConfigured_) {

+ configureAsImpromptuRoom(form);

+ }

+ } else {

+ chatWindow_->showRoomConfigurationForm(form);

+ }

+ muc_->cancelConfigureRoom();

+ muc_->destroyRoom();

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

+ eventStream_->send(std::make_shared<RequestInviteToMUCUIEvent>(getToJID(), jidsToInvite, mode));

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

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

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

+ for (const auto& jid : inviteEvent->getInvites()) {

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

+ }

+ }

+ muc_->requestAffiliationList(MUCOccupant::Owner);

+ muc_->requestAffiliationList(MUCOccupant::Admin);

+ muc_->requestAffiliationList(MUCOccupant::Member);

+ muc_->requestAffiliationList(MUCOccupant::Outcast);

+ std::set<JID> addedJIDs;

+ for (const auto& change : changes) {

+ if (change.first != MUCOccupant::NoAffiliation) {

+ addedJIDs.insert(change.second);

+ }

+ }

+ for (const auto& change : changes) {

+ if (change.first != MUCOccupant::NoAffiliation || addedJIDs.find(change.second) == addedJIDs.end()) {

+ muc_->changeAffiliation(change.second, change.first);

+ }

+ }

+}

+

+void MUCController::handleUnblockUserRequest() {

+ eventStream_->send(std::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Unblocked, muc_->getJID()));

+}

+

+void MUCController::handleBlockingStateChanged() {

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

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

+ if (blockList->isBlocked(toJID_)) {

+ if (!blockedContactAlert_) {

+ blockedContactAlert_ = chatWindow_->addAlert(QT_TRANSLATE_NOOP("", "You've blocked this room. To enter the room, first unblock it using the cog menu and try again"));

+ }

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

+ } else {

+ if (blockedContactAlert_) {

+ chatWindow_->removeAlert(*blockedContactAlert_);

+ blockedContactAlert_.reset();

+ }

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

+ }

+ }

+ chatWindow_->setAffiliations(affiliation, jids);

+ // log only incoming messages

+ if (isIncoming && historyController_) {

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

+ }

+}

+

+JID MUCController::messageCorrectionJID(const JID& fromJID) {

+ return fromJID;

+ if (!historyController_) {

+ return;

+ }

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

+ for (const auto& message : joinContext_) {

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

+ // the chatWindow uses utc timestamps

+ addMessage(chatMessageParser_->parseMessageBody(message.getMessage()), senderDisplayNameFromMessage(message.getFromJID()), senderIsSelf, std::make_shared<SecurityLabel>(), avatarManager_->getAvatarPath(message.getFromJID()), message.getTime() - boost::posix_time::hours(message.getOffset()));

+ }

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

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

+ JID jid = newMessage->getFrom();

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

+ for (const auto& message : boost::adaptors::reverse(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("");

+ }

+ nick_ = nick;

+ chatMessageParser_->setNick(nick);

+ Form::ref result = std::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);

+ for (const auto& field : roomConfigurationForm->getFields()) {

+ std::shared_ptr<FormField> resultField;

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

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

+ }

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

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

+ }

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

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

+ }

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

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

+ }

+

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

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

+ }

+

+ if (resultField) {

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

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

+ result->addField(resultField);

+ }

+ }

+

+ for (const auto& 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;

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

+ }

+ }

+}

+

+void MUCController::setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info) {

+ ChatControllerBase::setAvailableServerFeatures(info);

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

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

+

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

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

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

+

+ handleBlockingStateChanged();

+ }

+}

+

+void MUCController::handleMUCBookmarkAdded(const MUCBookmark& bookmark) {

+ if (bookmark.getRoom() == muc_->getJID()) {

+ updateChatWindowBookmarkStatus(bookmark);

+ }

+}

+

+void MUCController::handleMUCBookmarkRemoved(const MUCBookmark& bookmark) {

+ if (bookmark.getRoom() == muc_->getJID()) {

+ updateChatWindowBookmarkStatus(boost::optional<MUCBookmark>());

+ }

+}

+

+void MUCController::updateChatWindowBookmarkStatus(const boost::optional<MUCBookmark>& bookmark) {

+ assert(chatWindow_);

+ if (bookmark) {

+ if (bookmark->getAutojoin()) {

+ chatWindow_->setBookmarkState(ChatWindow::RoomAutoJoined);

+ }

+ else {

+ chatWindow_->setBookmarkState(ChatWindow::RoomBookmarked);

+ }

+ }

+ else {

+ chatWindow_->setBookmarkState(ChatWindow::RoomNotBookmarked);

+ }

+}

+

+void MUCController::displaySubjectIfChanged(const std::string& subject) {

+ if (subject_ != subject) {

+ if (!subject.empty()) {

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

+ }

+ else {

+ chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "The room subject has been removed")))), ChatWindow::DefaultDirection);

+ }

+ subject_ = subject;

+ }

+}

+

+void MUCController::addChatSystemMessage() {

+ lastJoinMessageUID_ = chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(lastStartMessage_), ChatWindow::DefaultDirection);

+}

+

+void MUCController::setChatWindowTitle(const std::string& title) {

+ chatWindowTitle_ = title;

+ chatWindow_->setName(chatWindowTitle_);

+}

+

+void MUCController::requestSecurityMarking() {

+ auto discoInfoRequest = GetDiscoInfoRequest::create(muc_->getJID(), iqRouter_);

+ discoInfoRequest->onResponse.connect(

+ [this](std::shared_ptr<DiscoInfo> discoInfoRef, ErrorPayload::ref errorPayloadRef) {

+ if (!discoInfoRef || errorPayloadRef) {

+ return;

+ }

+ const std::vector<Form::ref>& extensionsList = discoInfoRef->getExtensions();

+ if (extensionsList.empty()) {

+ return;

+ }

+ // Get the correct form if it exists

+ Form::ref roomInfoForm;

+ for (const auto& form : extensionsList) {

+ if (form->getFormType() == "http://jabber.org/protocol/muc#roominfo") {

+ roomInfoForm = form;

+ break;

+ }

+ }

+ if (!roomInfoForm) {

+ return;

+ }

+ // It exists, now examine the security marking data

+ auto marking = roomInfoForm->getField("x-isode#roominfo_marking");

+ if (!marking) {

+ return;

+ }

+ // Now we know the marking is valid

+ auto markingValue = marking->getTextSingleValue();

+ if (markingValue == "") {

+ setMUCSecurityMarkingDefault();

+ return;

+ }

+ auto markingForegroundColor = roomInfoForm->getField("x-isode#roominfo_marking_fg_color");

+ auto markingBackgroundColor = roomInfoForm->getField("x-isode#roominfo_marking_bg_color");

+ std::string markingForegroundColorValue = "Black";

+ std::string markingBackgroundColorValue = "White";

+ if (markingForegroundColor && markingForegroundColor->getTextSingleValue() != "") {

+ markingForegroundColorValue = markingForegroundColor->getTextSingleValue();

+ }

+ if (markingBackgroundColor && markingBackgroundColor->getTextSingleValue() != "") {

+ markingBackgroundColorValue = markingBackgroundColor->getTextSingleValue();

+ }

+ setMUCSecurityMarking(markingValue, markingForegroundColorValue, markingBackgroundColorValue);

+ }

+ );

+ discoInfoRequest->send();

+}

+

+void MUCController::setMUCSecurityMarking(const std::string& markingValue, const std::string& markingForegroundColorValue, const std::string& markingBackgroundColorValue) {

+ roomSecurityMarking_ = markingValue;

+ chatWindow_->setChatSecurityMarking(markingValue, markingForegroundColorValue, markingBackgroundColorValue);

+}

+

+void MUCController::setMUCSecurityMarkingDefault() {

+ roomSecurityMarking_ = "";

+ chatWindow_->removeChatSecurityMarking();

+ * Copyright (c) 2010-2018 Isode Limited.

+ * All rights reserved.

+ * See the COPYING file for more information.

+#include <map>

+#include <memory>

+#include <boost/signals2.hpp>

+#include <boost/signals2/connection.hpp>

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

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

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

+ class StanzaChannel;

+ class IQRouter;

+ class ChatWindowFactory;

+ class Roster;

+ class AvatarManager;

+ class UIEventStream;

+ class TimerFactory;

+ class TabComplete;

+ class XMPPRoster;

+ class HighlightManager;

+ class UIEvent;

+ class VCardManager;

+ class RosterVCardProvider;

+ class ClientBlockListManager;

+ class MUCBookmarkManager;

+ class MUCBookmark;

+

+ enum JoinPart {Join, Part, JoinThenPart, PartThenJoin};

+

+ struct NickJoinPart {

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

+ std::string nick;

+ JoinPart type;

+ };

+

+ class MUCController : public ChatControllerBase {

+ public:

+ MUCController(const JID& self, MUC::ref muc, const boost::optional<std::string>& password, const std::string &nick, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, XMPPRoster* xmppRoster, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, bool isImpromptu, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, VCardManager* vcardManager, MUCBookmarkManager* mucBookmarkManager, SettingsProvider* settings, Chattables& chattables);

+ virtual ~MUCController() override;

+ boost::signals2::signal<void ()> onUserLeft;

+ boost::signals2::signal<void ()> onUserJoined;

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

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

+ virtual void setOnline(bool online) override;

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

+ void rejoin();

+ static void appendToJoinParts(std::vector<NickJoinPart>& joinParts, const NickJoinPart& newEvent);

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

+ static std::string concatenateListOfNames(const std::vector<NickJoinPart>& joinParts);

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

+ bool isJoined();

+ const std::string& getNick();

+ 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 setChatWindowTitle(const std::string& title);

+ protected:

+ virtual void preSendMessageRequest(std::shared_ptr<Message> message) override;

+ virtual bool isIncomingMessageFromMe(std::shared_ptr<Message> message) override;

+ virtual std::string senderHighlightNameFromMessage(const JID& from) override;

+ virtual std::string senderDisplayNameFromMessage(const JID& from) override;

+ virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(std::shared_ptr<Message> message) const override;

+ virtual void preHandleIncomingMessage(std::shared_ptr<MessageEvent>) override;

+ virtual void addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& time) override;

+ virtual void handleIncomingReplaceMessage(const JID& from, const ChatWindow::ChatMessage& message, const std::string& messageID, const std::string& idToReplace, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp) override;

+ virtual void postHandleIncomingMessage(std::shared_ptr<MessageEvent>, const ChatWindow::ChatMessage& chatMessage) override;

+ virtual void cancelReplaces() override;

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

+ virtual JID messageCorrectionJID(const JID& fromJID) override;

+

+ private:

+ void setAvailableRoomActions(const MUCOccupant::Affiliation& affiliation, const MUCOccupant::Role& role);

+ void clearPresenceQueue();

+ void addPresenceMessage(const std::string& message);

+ void handleWindowOccupantSelectionChanged(ContactRosterItem* item);

+ void handleActionRequestedOnOccupant(ChatWindow::OccupantAction, ContactRosterItem* item);

+ void handleWindowClosed();

+ void handleAvatarChanged(const JID& jid);

+ void handleOccupantJoined(const MUCOccupant& occupant);