- * Copyright (c) 2014 Isode Limited.

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

- };

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

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

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

-

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

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

- isInMUC_ = isInMUC;

- lastWasPresence_ = false;

- chatStateNotifier_ = new ChatStateNotifier(stanzaChannel, contact, entityCapsProvider);

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

- 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(boost::shared_ptr<DiscoInfo> info) {

- ChatControllerBase::setAvailableServerFeatures(info);

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

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

-

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

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

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

-

- handleBlockingStateChanged();

- }

-}

-

-bool ChatController::isIncomingMessageFromMe(boost::shared_ptr<Message>) {

- return false;

-}

-

-void ChatController::preHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent) {

- if (messageEvent->isReadable()) {

- chatWindow_->flash();

- lastWasPresence_ = false;

- }

- boost::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 (boost::shared_ptr<DeliveryReceipt> receipt = message->getPayload<DeliveryReceipt>()) {

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

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

- boost::shared_ptr<Message> receiptMessage = boost::make_shared<Message>();

- receiptMessage->setTo(toJID_);

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

- stanzaChannel_->sendMessage(receiptMessage);

- }

- }

-}

-

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

- eventController_->handleIncomingEvent(messageEvent);

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

- highlighter_->handleHighlightAction(highlight);

- }

-}

-

-

-void ChatController::preSendMessageRequest(boost::shared_ptr<Message> message) {

- chatStateNotifier_->addChatStateRequest(message);

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

- message->addPayload(boost::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;

- }

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

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

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

- if (!blockedContactAlert_) {

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

- }

- chatWindow_->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(boost::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Blocked, toJID_));

- } else {

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

- }

- if (isInMUC_) {

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

- } else {

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

- }

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

- eventStream_->send(event);

- onWindowClosed();

-void ChatController::handleUIEvent(boost::shared_ptr<UIEvent> event) {

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

- if (inviteEvent && inviteEvent->getRoom() == toJID_.toBare()) {

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

- }

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

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

- if (replace) {

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

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

- } else {

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

- }

- 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(boost::shared_ptr<Stanza> stanza) {

- std::map<boost::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) {

- std::map<boost::shared_ptr<Stanza>, std::string>::iterator it = unackedStanzas_.begin();

- for ( ; it != unackedStanzas_.end(); ++it) {

- chatWindow_->setAckState(it->second, ChatWindow::Failed);

- }

- 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 ftID = ftc->setChatWindow(chatWindow_, nick);

- ftControllers[ftID] = ftc;

- lastWasPresence_ = false;

- lastWbID_ = chatWindow_->addWhiteboardRequest(senderIsSelf);

- chatWindow_->setWhiteboardSessionStatus(lastWbID_, state);

- SWIFT_LOG(debug) << "handleFileTransferCancel(" << id << ")" << std::endl;

- 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 << ")" << std::endl;

- 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 << ")" << std::endl;

- 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 << ")" << std::endl;

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

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

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

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

- if (isInMUC_) {

- return nickResolver_->jidToNick(from);

- }

- else {

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

- }

- return nickResolver_->jidToNick(from);

-}

-

-std::string ChatController::getStatusChangeString(boost::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%")) % dateTimeToLocalString(idle->getSince()));

- }

-

- if (!response.empty()) {

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

- }

-

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

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

- }

- return response + ".";

-}

-

-void ChatController::handlePresenceChange(boost::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 = boost::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(boost::shared_ptr<Message> message) const {

- return message->getTimestamp();

- HistoryMessage::Type type;

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

- type = HistoryMessage::PrivateMessage;

- }

- else {

- type = HistoryMessage::Chat;

- }

- if (historyController_) {

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

- }

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

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

- return ChatControllerBase::detachChatWindow();

- * Copyright (c) 2010-2015 Isode Limited.

- class AvatarManager;

- class ChatStateNotifier;

- class ChatStateTracker;

- class NickResolver;

- class EntityCapsProvider;

- class FileTransferController;

- class SettingsProvider;

- class HistoryController;

- class HighlightManager;

- class ClientBlockListManager;

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

- virtual ~ChatController();

- virtual void setToJID(const JID& jid) SWIFTEN_OVERRIDE;

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

- virtual void setOnline(bool online) SWIFTEN_OVERRIDE;

- virtual void handleNewFileTransferController(FileTransferController* ftc);

- virtual void handleWhiteboardSessionRequest(bool senderIsSelf);

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

- virtual void setContactIsReceivingPresence(bool /*isReceivingPresence*/) SWIFTEN_OVERRIDE;

- virtual ChatWindow* detachChatWindow() SWIFTEN_OVERRIDE;

-

- protected:

- virtual void cancelReplaces() SWIFTEN_OVERRIDE;

- virtual JID getBaseJID() SWIFTEN_OVERRIDE;

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

-

- private:

- void handlePresenceChange(boost::shared_ptr<Presence> newPresence);

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

- virtual bool isIncomingMessageFromMe(boost::shared_ptr<Message> message) SWIFTEN_OVERRIDE;

- virtual void postSendMessage(const std::string &body, boost::shared_ptr<Stanza> sentStanza) SWIFTEN_OVERRIDE;

- virtual void preHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent) SWIFTEN_OVERRIDE;

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

- virtual void preSendMessageRequest(boost::shared_ptr<Message>) SWIFTEN_OVERRIDE;

- virtual std::string senderHighlightNameFromMessage(const JID& from) SWIFTEN_OVERRIDE;

- virtual std::string senderDisplayNameFromMessage(const JID& from) SWIFTEN_OVERRIDE;

- virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(boost::shared_ptr<Message>) const SWIFTEN_OVERRIDE;

- void handleStanzaAcked(boost::shared_ptr<Stanza> stanza);

- virtual void dayTicked() SWIFTEN_OVERRIDE { lastWasPresence_ = false; }

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

- virtual void handleBareJIDCapsChanged(const JID& jid) SWIFTEN_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(boost::shared_ptr<UIEvent> event);

-

- private:

- NickResolver* nickResolver_;

- ChatStateNotifier* chatStateNotifier_;

- ChatStateTracker* chatStateTracker_;

- std::string myLastMessageUIID_;

- bool isInMUC_;

- bool lastWasPresence_;

- std::string lastStatusChangeString_;

- std::map<boost::shared_ptr<Stanza>, std::string> unackedStanzas_;

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

- StatusShow::Type lastShownStatus_;

- UIEventStream* eventStream_;

-

- Tristate contactSupportsReceipts_;

- bool receivingPresenceFromUs_;

- bool userWantsReceipts_;

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

- SettingsProvider* settings_;

- std::string lastWbID_;

-

- ClientBlockListManager* clientBlockListManager_;

- boost::bsignals::scoped_connection blockingOnStateChangedConnection_;

- boost::bsignals::scoped_connection blockingOnItemAddedConnection_;

- boost::bsignals::scoped_connection blockingOnItemRemovedConnection_;

-

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

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

- };

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

-#include <boost/shared_ptr.hpp>

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

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

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

-ChatControllerBase::ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, boost::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), timerFactory_(timerFactory), entityCapsProvider_(entityCapsProvider), historyController_(historyController), mucRegistry_(mucRegistry), chatMessageParser_(chatMessageParser), autoAcceptMUCInviteDecider_(autoAcceptMUCInviteDecider), eventStream_(eventStream) {

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

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

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

- chatWindow_->onLogCleared.connect(boost::bind(&ChatControllerBase::handleLogCleared, this));

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

- highlighter_ = highlightManager->createHighlighter();

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

- createDayChangeTimer();

- if (dateChangeTimer_) {

- dateChangeTimer_->onTick.disconnect(boost::bind(&ChatControllerBase::handleDayChangeTick, this));

- dateChangeTimer_->stop();

- }

- delete highlighter_;

- delete chatWindow_;

- cancelReplaces();

- ChatWindow* chatWindow = chatWindow_;

- chatWindow_ = NULL;

- return chatWindow;

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

- handleBareJIDCapsChanged(jid);

- }

- if (chatWindow_) {

- chatWindow_->setCanInitiateImpromptuChats(supportsImpromptu);

- }

- if (timerFactory_) {

- boost::posix_time::ptime now = boost::posix_time::second_clock::local_time();

- boost::posix_time::ptime midnight(now.date() + boost::gregorian::days(1));

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

- dateChangeTimer_ = timerFactory_->createTimer(millisecondsUntilMidnight);

- dateChangeTimer_->onTick.connect(boost::bind(&ChatControllerBase::handleDayChangeTick, this));

- dateChangeTimer_->start();

- }

- dateChangeTimer_->stop();

- boost::posix_time::ptime now = boost::posix_time::second_clock::local_time();

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

- dayTicked();

- createDayChangeTimer();

- chatWindow_->setOnline(enabled);

- chatWindow_->setCanInitiateImpromptuChats(false);

- setEnabled(online);

- return JID(toJID_.toBare());

-void ChatControllerBase::setAvailableServerFeatures(boost::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();

- foreach (boost::shared_ptr<StanzaEvent> stanzaEvent, unreadMessages_) {

- stanzaEvent->conclude();

- }

- unreadMessages_.clear();

- chatWindow_->setUnreadMessageCount(0);

- onUnreadCountChanged();

- }

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

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

- return;

- }

- boost::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(boost::make_shared<Delay>(now, selfJID_));

- }

- if (isCorrectionMessage) {

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

- }

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

- stanzaChannel_->sendMessage(message);

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

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

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

-void ChatControllerBase::handleSecurityLabelsCatalogResponse(boost::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();

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

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

- if (boost::starts_with(message, "/me ")) {

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

- } else {

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

- }

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

- if (boost::starts_with(message, "/me ")) {

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

- } else {

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

- }

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

-}

-

-void ChatControllerBase::handleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent) {

- preHandleIncomingMessage(messageEvent);

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

- unreadMessages_.push_back(messageEvent);

- if (messageEvent->targetsMe()) {

- targetedUnreadMessages_.push_back(messageEvent);

- }

- }

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

- std::string body = message->getBody().get_value_or("");

- HighlightAction highlight;

- if (message->isError()) {

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

- std::string 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<boost::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);

- }

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

-

- // Highlight

- if (!isIncomingMessageFromMe(message)) {

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

- }

-

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

- if (replace) {

- std::string body = message->getBody().get_value_or("");

- // Should check if the user has a previous message

- std::map<JID, std::string>::iterator lastMessage;

- lastMessage = lastMessagesUIID_.find(from);

- if (lastMessage != lastMessagesUIID_.end()) {

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

- }

- }

- else {

- addMessageHandleIncomingMessage(from, body, isIncomingMessageFromMe(message), label, timeStamp, highlight);

- }

-

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

- }

- chatWindow_->show();

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

- onUnreadCountChanged();

- postHandleIncomingMessage(messageEvent, highlight);

-}

-

-void ChatControllerBase::addMessageHandleIncomingMessage(const JID& from, const std::string& message, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& timeStamp, const HighlightAction& highlight) {

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

-}

-

-std::string ChatControllerBase::getErrorMessage(boost::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();

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

- onUnreadCountChanged();

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

- eventController_->handleIncomingEvent(event);

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

-

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

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

- } else {

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

- handleGeneralMUCInvitation(inviteEvent);

- }

- 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 = boost::make_shared<MUCInviteEvent>(invite.from, from, reason, password, false, false);

- handleGeneralMUCInvitation(inviteEvent);

- * Copyright (c) 2010-2015 Isode Limited.

-#include <boost/shared_ptr.hpp>

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

- class IQRouter;

- class StanzaChannel;

- class ChatWindowFactory;

- class AvatarManager;

- class UIEventStream;

- class EventController;

- class EntityCapsProvider;

- class HighlightManager;

- class Highlighter;

- class ChatMessageParser;

- class AutoAcceptMUCInviteDecider;

- class ChatControllerBase : public boost::bsignals::trackable {

- public:

- virtual ~ChatControllerBase();

- void showChatWindow();

- void activateChatWindow();

- bool hasOpenWindow() const;

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

- void handleIncomingMessage(boost::shared_ptr<MessageEvent> message);

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

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

- virtual void setOnline(bool online);

- void setEnabled(bool enabled);

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

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

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

- boost::signal<void ()> onUnreadCountChanged;

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

- int getUnreadCount();

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

- void handleCapsChanged(const JID& jid);

- void setCanStartImpromptuChats(bool supportsImpromptu);

- virtual ChatWindow* detachChatWindow();

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

- protected:

- ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, boost::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider);

- /**

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

- */

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

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

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

- virtual bool isIncomingMessageFromMe(boost::shared_ptr<Message>) = 0;

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

- virtual void addMessageHandleIncomingMessage(const JID& from, const std::string& message, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& time, const HighlightAction& highlight);

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

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

- virtual bool isFromContact(const JID& from);

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

- virtual void dayTicked() {}

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

- std::string getErrorMessage(boost::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;

- private:

- IDGenerator idGenerator_;

- std::string lastSentMessageStanzaID_;

- void createDayChangeTimer();

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

- void handleAllMessagesRead();

- void handleSecurityLabelsCatalogResponse(boost::shared_ptr<SecurityLabelsCatalog>, ErrorPayload::ref error);

- void handleDayChangeTick();

- void handleMUCInvitation(Message::ref message);

- void handleMediatedMUCInvitation(Message::ref message);

- void handleGeneralMUCInvitation(MUCInviteEvent::ref event);

- void handleLogCleared();

- protected:

- JID selfJID_;

- std::vector<boost::shared_ptr<StanzaEvent> > unreadMessages_;

- std::vector<boost::shared_ptr<StanzaEvent> > targetedUnreadMessages_;

- StanzaChannel* stanzaChannel_;

- IQRouter* iqRouter_;

- ChatWindowFactory* chatWindowFactory_;

- ChatWindow* chatWindow_;

- JID toJID_;

- bool labelsEnabled_;

- std::map<JID, std::string> lastMessagesUIID_;

- PresenceOracle* presenceOracle_;

- AvatarManager* avatarManager_;

- bool useDelayForLatency_;

- EventController* eventController_;

- boost::shared_ptr<Timer> dateChangeTimer_;

- TimerFactory* timerFactory_;

- EntityCapsProvider* entityCapsProvider_;

- SecurityLabelsCatalog::Item lastLabel_;

- HistoryController* historyController_;

- MUCRegistry* mucRegistry_;

- Highlighter* highlighter_;

- boost::shared_ptr<ChatMessageParser> chatMessageParser_;

- AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider_;

- UIEventStream* eventStream_;

- };

- * Copyright (c) 2013-2015 Isode Limited.

-#include <vector>

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

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

-

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

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

- }

-

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

-

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

- ChatWindow::ChatMessage parsedMessage;

- std::string remaining = body;

- /* Parse one, URLs */

- while (!remaining.empty()) {

- bool found = false;

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

- remaining = "";

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

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

- if (found) {

- // Must be on the last part, then

- remaining = part;

- }

- else {

- if (i == links.second) {

- found = true;

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

- }

- else {

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

- }

- }

- }

- }

-

- /* do emoticon substitution */

- parsedMessage = emoticonHighlight(parsedMessage);

-

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

- /* do word-based color highlighting */

- parsedMessage = splitHighlight(parsedMessage, nick);

- }

-

- return parsedMessage;

- }

-

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

- {

- ChatWindow::ChatMessage parsedMessage = message;

-

- std::string regexString;

- /* Parse two, emoticons */

- foreach (StringPair emoticon, emoticons_) {

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

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

- */

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

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

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

- regexString += escaped + "$|";

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

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

-

- }

- if (!regexString.empty()) {

- regexString += "";

- boost::regex emoticonRegex(regexString);

-

- ChatWindow::ChatMessage newMessage;

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

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

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

- try {

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

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

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

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

- int matchIndex = 0;

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

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

- //This is the matching subgroup

- break;

- }

- }

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

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

- if (start != matchStart) {

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

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

- }

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

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

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

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

- const StringPair& emoticon = *emoticonIterator;

- emoticonPart->imagePath = emoticon.second;

- emoticonPart->alternativeText = emoticon.first;

- newMessage.append(emoticonPart);

- start = matchEnd;

- }

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

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

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

- }

-

- }

- catch (std::runtime_error) {

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

- newMessage.append(part);

- }

- }

- else {

- newMessage.append(part);

- }

- }

- parsedMessage = newMessage;

-

- }

- return parsedMessage;

- }

-

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

- {

- ChatWindow::ChatMessage parsedMessage = message;

-

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

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

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

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

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

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

- } else if (rule.getAction().getTextBackground().empty() && rule.getAction().getTextColor().empty()) {

- continue; /* do not try to highlight text, if no highlight color is specified */

- }

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

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

- ChatWindow::ChatMessage newMessage;

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

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

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

- try {

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

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

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

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

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

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

- if (start != matchStart) {

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

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

- }

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

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

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

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

- newMessage.append(highlightPart);

- start = matchEnd;

- }

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

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

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

- }

- }

- catch (std::runtime_error) {

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

- newMessage.append(part);

- }

- } else {

- newMessage.append(part);

- }

- }

- parsedMessage = newMessage;

- }

- }

-

- return parsedMessage;

- }

- class ChatMessageParser {

- public:

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

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

- private:

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

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

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

- HighlightRulesListPtr highlightRules_;

- bool mucMode_;

- };

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

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

-#include <Swift/Controllers/XMPPEvents/IncomingFileTransferEvent.h>

- template<class Archive> void save(Archive& ar, const Swift::JID& jid, const unsigned int /*version*/) {

- std::string jidStr = jid.toString();

- ar << jidStr;

- }

-

- template<class Archive> void load(Archive& ar, Swift::JID& jid, const unsigned int /*version*/) {

- std::string stringJID;

- ar >> stringJID;

- jid = Swift::JID(stringJID);

- }

-

- template<class Archive> inline void serialize(Archive& ar, Swift::JID& t, const unsigned int file_version){

- split_free(ar, t, file_version);

- }

-

- template<class Archive> void serialize(Archive& ar, Swift::ChatListWindow::Chat& chat, const unsigned int version) {

- ar & chat.jid;

- ar & chat.chatName;

- ar & chat.activity;

- ar & chat.isMUC;

- ar & chat.nick;

- ar & chat.impromptuJIDs;

- if (version > 0) {

- ar & chat.password;

- }

- }

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

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

- timerFactory_ = timerFactory;

- eventController_ = eventController;

- stanzaChannel_ = stanzaChannel;

- iqRouter_ = iqRouter;

- chatWindowFactory_ = chatWindowFactory;

- nickResolver_ = nickResolver;

- presenceOracle_ = presenceOracle;

- avatarManager_ = NULL;

- serverDiscoInfo_ = boost::make_shared<DiscoInfo>();

- presenceSender_ = presenceSender;

- uiEventStream_ = uiEventStream;

- mucBookmarkManager_ = NULL;

- profileSettings_ = profileSettings;

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

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

-

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

-

- joinMUCWindow_ = NULL;

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

-

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

-

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

-

- setupBookmarks();

- loadRecents();

-

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

- settings_->onSettingChanged.disconnect(boost::bind(&ChatsManager::handleSettingChanged, 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));

- delete joinMUCWindow_;

- foreach (JIDChatControllerPair controllerPair, chatControllers_) {

- delete controllerPair.second;

- }

- foreach (JIDMUCControllerPair controllerPair, mucControllers_) {

- delete controllerPair.second;

- }

- delete mucBookmarkManager_;

- delete mucSearchController_;

- delete autoAcceptMUCInviteDecider_;

- std::stringstream serializeStream;

- boost::archive::text_oarchive oa(serializeStream);

- std::vector<ChatListWindow::Chat> recentsLimited = std::vector<ChatListWindow::Chat>(recentChats_.begin(), recentChats_.end());

- if (recentsLimited.size() > 25) {

- recentsLimited.erase(recentsLimited.begin() + 25, recentsLimited.end());

- }

- if (eagleMode_) {

- foreach(ChatListWindow::Chat& chat, recentsLimited) {

- chat.activity = "";

- }

- }

-

- class RemoveRecent {

- public:

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

- return chat.isPrivateMessage;

- }

- };

-

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

-

- oa << recentsLimited;

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

- profileSettings_->storeString(RECENT_CHATS, serializedStr);

- recentChats_.clear();

- saveRecents();

- handleUnreadCountChanged(NULL);

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

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

- }

- }

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

- foreach (std::string recentString, recents) {

- if (i++ > 30) {

- break;

- }

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

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

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

- continue;

- }

- JID jid(recent[0]);

- if (!jid.isValid()) {

- continue;

- }

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

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

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

- StatusShow::Type type = StatusShow::None;

- boost::filesystem::path path;

-

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

- chat = updateChatStatusAndAvatarHelper(chat);

- prependRecent(chat);

- }

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

- // boost searilaize based format

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

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

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

- try {

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

- ia >> recentChats;

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

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

- return;

- }

-

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

- chat.statusType = StatusShow::None;

- chat = updateChatStatusAndAvatarHelper(chat);

- prependRecent(chat);

- }

- }

- handleUnreadCountChanged(NULL);

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

-

- if (chatListWindow_) {

- chatListWindow_->setBookmarksEnabled(false);

- chatListWindow_->clearBookmarks();

- }

- }

- if (chatListWindow_) {

- chatListWindow_->setBookmarksEnabled(true);

- }

- 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, false );

- }

- chatListWindow_->addMUCBookmark(bookmark);

- chatListWindow_->removeMUCBookmark(bookmark);

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

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

- }

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

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

- /* FIXME: handle nick changes */

- appendRecent(chat);

- handleUnreadCountChanged(NULL);

- saveRecents();

- cleanupPrivateMessageRecents();

- chatListWindow_->setRecents(recentChats_);

- int unreadTotal = 0;

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

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

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

- }

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

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

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

- if (chat.isPrivateMessage) {

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

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

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

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

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

- removeExistingChat(chat);

- break;

- }

- }

- }

- }

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

- ChatListWindow::Chat mergedChat = chat;

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

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

- }

- recentChats_.push_front(mergedChat);

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

- ChatListWindow::Chat mergedChat = chat;

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

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

- }

- recentChats_.push_back(mergedChat);

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

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

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

- foreach (ChatListWindow::Chat& chat, recentChats_) {

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

- chat.statusType = StatusShow::None;

- }

- }

- mucControllers_.erase(it);

- delete mucController;

- break;

- }

- }

- cleanupPrivateMessageRecents();

- chatListWindow_->setRecents(recentChats_);

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

- foreach(StringMUCOccupantPair occupant, occupants) {

- boost::optional<JID> realJID = occupant.second.getRealJID();

- if (realJID) {

- missingJIDsToInvite.erase(std::remove(missingJIDsToInvite.begin(), missingJIDsToInvite.end(), realJID->toBare()), missingJIDsToInvite.end());

- }

- }

-

- if (reuseChatJID) {

- muc->invitePerson(reuseChatJID.get(), reason, true, true);

- }

- foreach(const JID& jid, missingJIDsToInvite) {

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

- }

-void ChatsManager::handleUIEvent(boost::shared_ptr<UIEvent> event) {

- boost::shared_ptr<RequestChatUIEvent> chatEvent = boost::dynamic_pointer_cast<RequestChatUIEvent>(event);

- if (chatEvent) {

- handleChatRequest(chatEvent->getContact());

- return;

- }

- boost::shared_ptr<RemoveMUCBookmarkUIEvent> removeMUCBookmarkEvent = boost::dynamic_pointer_cast<RemoveMUCBookmarkUIEvent>(event);

- if (removeMUCBookmarkEvent) {

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

- return;

- }

- boost::shared_ptr<AddMUCBookmarkUIEvent> addMUCBookmarkEvent = boost::dynamic_pointer_cast<AddMUCBookmarkUIEvent>(event);

- if (addMUCBookmarkEvent) {

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

- return;

- }

-

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

- if (createImpromptuMUCEvent) {

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

- // create new muc

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

-

- // join muc

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

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

- mucControllers_[roomJID]->activateChatWindow();

- }

-

- boost::shared_ptr<EditMUCBookmarkUIEvent> editMUCBookmarkEvent = boost::dynamic_pointer_cast<EditMUCBookmarkUIEvent>(event);

- if (editMUCBookmarkEvent) {

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

- }

- else if (JoinMUCUIEvent::ref joinEvent = boost::dynamic_pointer_cast<JoinMUCUIEvent>(event)) {

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

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

- }

- else if (boost::shared_ptr<RequestJoinMUCUIEvent> joinEvent = boost::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();

- }

- foreach (ChatListWindow::Chat& chat, recentChats_) {

- chat.setStatusType(StatusShow::None);

- }

- chatListWindow_->setRecents(recentChats_);

- JID reuseChatInvite = chatController->getToJID();

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

- delete chatController;

- // join new impromptu muc

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

- // create new muc

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

- // join muc

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

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

-void ChatsManager::handlePresenceChange(boost::shared_ptr<Presence> newPresence) {

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

-

- foreach (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;

- }

- }

-

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

- foreach (ChatListWindow::Chat& chat, recentChats_) {

- if (!chat.isMUC) {

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

- }

- }

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

- foreach (ChatListWindow::Chat& chat, recentChats_) {

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

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

- break;

- }

- }

-void ChatsManager::setServerDiscoInfo(boost::shared_ptr<DiscoInfo> info) {

- serverDiscoInfo_ = info;

- foreach (JIDChatControllerPair pair, chatControllers_) {

- pair.second->setAvailableServerFeatures(info);

- }

- foreach (JIDMUCControllerPair pair, mucControllers_) {

- pair.second->setAvailableServerFeatures(info);

- }

- */

- foreach (JIDChatControllerPair controllerPair, chatControllers_) {

- controllerPair.second->setOnline(enabled);

- }

- foreach (JIDMUCControllerPair controllerPair, mucControllers_) {

- controllerPair.second->setOnline(enabled);

- if (enabled) {

- controllerPair.second->rejoin();

- }

- }

- if (!enabled) {

- markAllRecentsOffline();

- } else {

- setupBookmarks();

- localMUCServiceJID_ = JID();

- localMUCServiceFinderWalker_ = boost::make_shared<DiscoServiceWalker>(jid_.getDomain(), iqRouter_);

- localMUCServiceFinderWalker_->onServiceFound.connect(boost::bind(&ChatsManager::handleLocalServiceFound, this, _1, _2));

- localMUCServiceFinderWalker_->onWalkAborted.connect(boost::bind(&ChatsManager::handleLocalServiceWalkFinished, this));

- localMUCServiceFinderWalker_->onWalkComplete.connect(boost::bind(&ChatsManager::handleLocalServiceWalkFinished, this));

- localMUCServiceFinderWalker_->beginWalk();

- }

-

- if (chatListWindow_) {

- chatListWindow_->setBookmarksEnabled(enabled);

- }

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

- controller->activateChatWindow();

- ChatController* controller = getChatControllerIfExists(contact);

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

- foreach (JIDChatControllerPair pair, chatControllers_) {

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

- controller = pair.second;

- break;

- }

- }

- }

- return controller ? controller : createNewChatController(contact);

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

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

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

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

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

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

- }

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

- foreach (JIDChatControllerPair pair, chatControllers_) {

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

- if (rebindIfNeeded) {

- rebindControllerJID(pair.first, contact);

- return chatControllers_[contact];

- } else {

- return pair.second;

- }

- }

- }

- return NULL;

- }

- }

- return chatControllers_[contact];

- chatControllers_[to] = chatControllers_[from];

- chatControllers_.erase(from);

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

- MUC::ref muc;

- if (addAutoJoin) {

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

- bookmark.setAutojoin(true);

- if (nickMaybe) {

- bookmark.setNick(*nickMaybe);

- }

- if (password) {

- bookmark.setPassword(*password);

- }

- mucBookmarkManager_->addBookmark(bookmark);

- }

-

- 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 = NULL;

- SingleChatWindowFactoryAdapter* chatWindowFactoryAdapter = NULL;

- if (reuseChatwindow) {

- chatWindowFactoryAdapter = new SingleChatWindowFactoryAdapter(reuseChatwindow);

- }

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

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

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

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

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

- }

-

- mucControllers_[mucJID]->showChatWindow();

- return muc;

- mucSearchController_->openSearchWindow();

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

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

-

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

-

- // get current chat controller

- ChatController *chatController = getChatControllerIfExists(oldMUCChatJID);

- if (chatController) {

- // adjust chat controller

- chatController->setToJID(newMUCChatJID);

- nickResolver_->onNickChanged(newMUCChatJID, oldNickname);

- chatControllers_.erase(oldMUCChatJID);

- chatControllers_[newMUCChatJID] = chatController;

-

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

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

- }

-void ChatsManager::handleIncomingMessage(boost::shared_ptr<Message> message) {

- JID jid = message->getFrom();

- boost::shared_ptr<MessageEvent> event(new MessageEvent(message));

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

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

- if (isMediatedInvite) {

- jid = (*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 it to a MUC

- if (message->getType() == Message::Groupchat || message->getType() == Message::Error /*|| (isInvite && message->getType() == Message::Normal)*/) {

- std::map<JID, MUCController*>::iterator i = mucControllers_.find(jid.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(jid);

- if (controller) {

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

- chatControllers_.erase(jid);

- delete controller;

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

- return;

- }

- } else {

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

- return;

- }

- }

-

- //if 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.

- bool bindControllerToJID = false;

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

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

- bindControllerToJID = true;

- }

-

- ChatController* controller = getChatControllerIfExists(jid, bindControllerToJID);

- if (controller) {

- controller->handleIncomingMessage(event);

- }

- } else {

- getChatControllerOrCreate(jid)->handleIncomingMessage(event);

- }

- if (joinMUCWindow_) {

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

- }

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

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

- chatController->handleNewFileTransferController(ftc);

- chatController->activateChatWindow();

- if (ftc->isIncoming()) {

- eventController_->handleIncomingEvent(boost::make_shared<IncomingFileTransferEvent>(ftc->getOtherParty()));

- }

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

- }

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

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

- std::vector<JID> inviteJIDs;

- foreach(StringJIDPair pair, chat.impromptuJIDs) {

- inviteJIDs.push_back(pair.second);

- }

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

- }

- else if (chat.isMUC) {

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

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

- }

- else {

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

- }

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

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

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

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

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

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

- localMUCServiceJID_ = service;

- localMUCServiceFinderWalker_->endWalk();

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

- break;

- }

- }

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

- foreach (JIDChatControllerPair controllerPair, chatControllers_) {

- controllerPair.second->setCanStartImpromptuChats(impromptuMUCSupported);

- }

- foreach (JIDMUCControllerPair controllerPair, mucControllers_) {

- controllerPair.second->setCanStartImpromptuChats(impromptuMUCSupported);

- }

- onImpromptuMUCServiceDiscovered(impromptuMUCSupported);

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

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

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

- if (!chat.isMUC) {

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

- }

- }

- if (withMUCNicks) {

- /* collect MUC nicks */

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

- foreach (const Item& item, mucControllers_) {

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

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

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

- foreach (const ParticipantType& participant, participants) {

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

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

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

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

- }

- }

- }

- return result;

- return chatWindow_;

- * Copyright (c) 2010-2015 Isode Limited.

-#include <boost/shared_ptr.hpp>

-

- class EventController;

- class ChatController;

- class ChatControllerBase;

- class MUCController;

- class MUCManager;

- class JoinMUCWindow;

- class JoinMUCWindowFactory;

- class NickResolver;

- class PresenceOracle;

- class AvatarManager;

- class StanzaChannel;

- class IQRouter;

- class PresenceSender;

- class MUCBookmarkManager;

- class ChatListWindowFactory;

- class TimerFactory;

- class EntityCapsProvider;

- class DirectedPresenceSender;

- class MUCSearchWindowFactory;

- class ProfileSettingsProvider;

- class MUCSearchController;

- class FileTransferOverview;

- class FileTransferController;

- class XMPPRoster;

- class SettingsProvider;

- class WhiteboardManager;

- class HistoryController;

- class HighlightManager;

- class ClientBlockListManager;

- class ChatMessageParser;

- class DiscoServiceWalker;

- class AutoAcceptMUCInviteDecider;

- class VCardManager;

-

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

- virtual ~ChatsManager();

- void setAvatarManager(AvatarManager* avatarManager);

- void setOnline(bool enabled);

- void setServerDiscoInfo(boost::shared_ptr<DiscoInfo> info);

- void handleIncomingMessage(boost::shared_ptr<Message> message);

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

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

-

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

-

- private:

- class SingleChatWindowFactoryAdapter : public ChatWindowFactory {

- public:

- SingleChatWindowFactoryAdapter(ChatWindow* chatWindow);

- virtual ~SingleChatWindowFactoryAdapter();

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

-

- private:

- ChatWindow* chatWindow_;

- };

-

- private:

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

- 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 addAutoJoin, bool createAsReservedIfNew, bool isImpromptu, ChatWindow* reuseChatwindow = 0);

- void handleSearchMUCRequest();

- void handleMUCSelectedAfterSearch(const JID&);

- void rebindControllerJID(const JID& from, const JID& to);

- void handlePresenceChange(boost::shared_ptr<Presence> newPresence);

- void handleUIEvent(boost::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);

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

- void cleanupPrivateMessageRecents();

- void appendRecent(const ChatListWindow::Chat& chat);

- void prependRecent(const ChatListWindow::Chat& chat);

- void setupBookmarks();

- void loadRecents();

- void saveRecents();

- void handleChatMadeRecent();

- void handleMUCBookmarkActivated(const MUCBookmark&);

- void handleRecentActivated(const ChatListWindow::Chat&);

- void handleUnreadCountChanged(ChatControllerBase* controller);

- 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, boost::shared_ptr<DiscoInfo> info);

- void handleLocalServiceWalkFinished();

-

- void updatePresenceReceivingStateOnChatController(const JID&);

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

-

-

- ChatController* getChatControllerOrFindAnother(const JID &contact);

- ChatController* createNewChatController(const JID &contact);

- ChatController* getChatControllerOrCreate(const JID &contact);

- ChatController* getChatControllerIfExists(const JID &contact, bool rebindIfNeeded = true);

-

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

- MUCBookmarkManager* mucBookmarkManager_;

- boost::shared_ptr<DiscoInfo> serverDiscoInfo_;

- ChatListWindow* chatListWindow_;

- JoinMUCWindow* joinMUCWindow_;

- boost::bsignals::scoped_connection uiEventConnection_;

- bool useDelayForLatency_;

- TimerFactory* timerFactory_;

- MUCRegistry* mucRegistry_;

- EntityCapsProvider* entityCapsProvider_;

- MUCManager* mucManager;

- MUCSearchController* mucSearchController_;

- std::list<ChatListWindow::Chat> recentChats_;

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

- boost::shared_ptr<DiscoServiceWalker> localMUCServiceFinderWalker_;

- AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider_;

- IDGenerator idGenerator_;

- VCardManager* vcardManager_;

- };

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

- public:

- MUCBookmarkPredicate(const JID& mucJID) : roomJID_(mucJID) { }

- bool operator()(const MUCBookmark& operand) {

- return operand.getRoom() == roomJID_;

- }

-

- private:

- JID roomJID_;

- const JID& self,

- MUC::ref muc,

- const boost::optional<std::string>& password,

- const std::string &nick,

- StanzaChannel* stanzaChannel,

- IQRouter* iqRouter,

- ChatWindowFactory* chatWindowFactory,

- PresenceOracle* presenceOracle,

- AvatarManager* avatarManager,

- UIEventStream* uiEventStream,

- bool useDelayForLatency,

- TimerFactory* timerFactory,

- EventController* eventController,

- EntityCapsProvider* entityCapsProvider,

- XMPPRoster* roster,

- HistoryController* historyController,

- MUCRegistry* mucRegistry,

- HighlightManager* highlightManager,

- ClientBlockListManager* clientBlockListManager,

- boost::shared_ptr<ChatMessageParser> chatMessageParser,

- bool isImpromptu,

- AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider,

- VCardManager* vcardManager,

- MUCBookmarkManager* mucBookmarkManager) :

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

- parting_ = true;

- joined_ = false;

- lastWasPresence_ = false;

- shouldJoinOnReconnect_ = true;

- doneGettingHistory_ = false;

- events_ = uiEventStream;

- xmppRoster_ = roster;

-

- roster_ = new Roster(false, true);

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

- completer_ = new TabComplete();

- chatWindow_->setRosterModel(roster_);

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

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

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

- highlighter_->setNick(nick_);

- if (timerFactory && stanzaChannel_->isAvailable()) {

- loginCheckTimer_ = boost::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);

- }

- if (avatarManager_ != NULL) {

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

-

- std::vector<MUCBookmark> mucBookmarks = mucBookmarkManager_->getBookmarks();

- std::vector<MUCBookmark>::iterator bookmarkIterator = std::find_if(mucBookmarks.begin(), mucBookmarks.end(), MUCBookmarkPredicate(muc->getJID()));

- if (bookmarkIterator != mucBookmarks.end()) {

- updateChatWindowBookmarkStatus(*bookmarkIterator);

- }

- else {

- updateChatWindowBookmarkStatus(boost::optional<MUCBookmark>());

- }

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

- chatWindow_->setRosterModel(NULL);

- delete rosterVCardProvider_;

- delete roster_;

- if (loginCheckTimer_) {

- loginCheckTimer_->stop();

- }

- chatWindow_->setTabComplete(NULL);

- 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()) events_->send(boost::make_shared<RequestAddUserDialogUIEvent>(realJID, occupant.getNick()));break;

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

- }

- Tristate support = Yes;

- bool any = false;

- foreach (const std::string& nick, currentOccupants_) {

- DiscoInfo::ref disco = entityCapsProvider_->getCaps(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_);

- }

- if (lastActivity_ == boost::posix_time::not_a_date_time) {

- muc_->joinAs(nick_);

- }

- else {

- muc_->joinWithContextSince(nick_, lastActivity_);

- }

- }

- return joined_;

- return nick_;

- return password_;

- return isImpromptu_;

- std::map<std::string, JID> participants;

- typedef std::pair<std::string, MUCOccupant> MUCOccupantPair;

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

- foreach(const MUCOccupantPair& occupant, occupants) {

- if (occupant.first != nick_) {

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

- }

- }

- return participants;

- foreach (const JID& 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(boost::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;

- std::string joinMessage;

- if (isImpromptu_) {

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

- } else {

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

- }

- setNick(nick);

- chatWindow_->replaceSystemMessage(chatMessageParser_->parseMessageBody(joinMessage), 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 (isImpromptu_) {

- setImpromptuWindowTitle();

- }

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

- setImpromptuWindowTitle();

- onActivity("");

- }

- }

- if (avatarManager_ != NULL) {

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

- }

- 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(boost::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(boost::shared_ptr<MessageEvent> messageEvent) {

- if (messageEvent->getStanza()->getType() == Message::Groupchat) {

- lastActivity_ = boost::posix_time::microsec_clock::universal_time();

- }

- clearPresenceQueue();

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

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

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

- chatWindow_->setSubject(message->getSubject());

- doneGettingHistory_ = true;

- }

-

- if (!doneGettingHistory_ && !message->getPayload<Delay>()) {

- doneGettingHistory_ = true;

- }

-

- if (!doneGettingHistory_) {

- checkDuplicates(message);

- messageEvent->conclude();

- }

-}

-

-void MUCController::addMessageHandleIncomingMessage(const JID& from, const std::string& message, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& time, const HighlightAction& highlight) {

- if (from.isBare()) {

- chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "%1%")) % message)), ChatWindow::DefaultDirection);

- }

- else {

- ChatControllerBase::addMessageHandleIncomingMessage(from, message, senderIsSelf, label, time, highlight);

- }

-}

-

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

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

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

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

- eventController_->handleIncomingEvent(messageEvent);

- }

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

- highlighter_->handleHighlightAction(highlight);

- }

- }

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

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

- if (blockList && blockList->isBlocked(muc_->getJID())) {

- handleBlockingStateChanged();

- lastJoinMessageUID_ = chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(QT_TRANSLATE_NOOP("", "You've blocked this room. To enter the room, first unblock it using the cog menu and try again")), ChatWindow::DefaultDirection);

- }

- else {

- if (isImpromptu_) {

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

- } else {

- lastJoinMessageUID_ = chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "Trying to enter room %1%")) % toJID_.toString())), 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();

- }

-

- if (isImpromptu_) {

- setImpromptuWindowTitle();

- }

- addPresenceMessage(generateNicknameChangeString(oldNickname, newNickname));

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

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

- // adjust occupants

- currentOccupants_.erase(oldNickname);

- currentOccupants_.insert(newNickname);

- // adjust completer

- completer_->removeWord(oldNickname);

- completer_->addWord(newNickname);

- // update contact

- roster_->removeContact(oldJID);

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

- JID realJID;

- if (occupant.getRealJID()) {

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

- }

- MUCOccupant::Role role = MUCOccupant::Participant;

- MUCOccupant::Affiliation affiliation = MUCOccupant::NoAffiliation;

- if (!isImpromptu_) {

- role = occupant.getRole();

- affiliation = occupant.getAffiliation();

- }

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

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

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

- if (avatarManager_ != NULL) {

- handleAvatarChanged(newJID);

- }

- clearPresenceQueue();

- onUserNicknameChanged(oldNickname, newNickname);

-void MUCController::handleOccupantPresenceChange(boost::shared_ptr<Presence> presence) {

- receivedActivity();

- roster_->applyOnItems(SetPresence(presence, JID::WithResource));

-bool MUCController::isIncomingMessageFromMe(boost::shared_ptr<Message> message) {

- JID from = message->getFrom();

- return nick_ == from.getResource();

- return from.getResource();

- return from.getResource();

-void MUCController::preSendMessageRequest(boost::shared_ptr<Message> message) {

- message->setType(Swift::Message::Groupchat);

-boost::optional<boost::posix_time::ptime> MUCController::getMessageTimestamp(boost::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];

- foreach (NickJoinPart 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;

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

- muc_->changeSubject(subject);

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

- foreach (const MUCBookmark& 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;

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

- eventStream_->send(event);

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

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

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

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

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

- }

- }

- muc_->requestAffiliationList(MUCOccupant::Owner);

- muc_->requestAffiliationList(MUCOccupant::Admin);

- muc_->requestAffiliationList(MUCOccupant::Member);

- muc_->requestAffiliationList(MUCOccupant::Outcast);

-typedef std::pair<MUCOccupant::Affiliation, JID> AffiliationChangePair;

-

- std::set<JID> addedJIDs;

- foreach (const AffiliationChangePair& change, changes) {

- if (change.first != MUCOccupant::NoAffiliation) {

- addedJIDs.insert(change.second);

- }

- }

- foreach (const AffiliationChangePair& change, changes) {

- if (change.first != MUCOccupant::NoAffiliation || addedJIDs.find(change.second) == addedJIDs.end()) {

- muc_->changeAffiliation(change.second, change.first);

- }

- }

- eventStream_->send(boost::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Unblocked, muc_->getJID()));

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

- }

- if (!historyController_) {

- return;

- }

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

- foreach (const HistoryMessage& message, joinContext_) {

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

- // the chatWindow uses utc timestamps

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

- }

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

- std::string body = newMessage->getBody().get_value_or("");

- JID jid = newMessage->getFrom();

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

- reverse_foreach (const HistoryMessage& message, joinContext_) {

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

- if (time && time < messageTime) {

- break;

- }

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

- continue;

- }

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

- continue;

- }

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

- continue;

- }

- // Mark the message as unreadable

- newMessage->setBody("");

- }

- nick_ = nick;

- highlighter_->setNick(nick_);

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

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

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

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

- boost::shared_ptr<FormField> resultField;

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

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

- }

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

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

- }

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

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

- }

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

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

- }

-

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

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

- }

-

- if (resultField) {

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

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

- result->addField(resultField);

- }

- }

-

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

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

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

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

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

- }

- }

-

- return result;

- std::string title;

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

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

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

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

- } else {

- foreach (StringMUCOccupantPair pair, occupants) {

- if (pair.first != nick_) {

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

- }

- }

- }

- chatWindow_->setName(title);

- // 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(boost::shared_ptr<DiscoInfo> info) {

- ChatControllerBase::setAvailableServerFeatures(info);

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

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

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

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

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

- handleBlockingStateChanged();

- }

- if (bookmark.getRoom() == muc_->getJID()) {

- updateChatWindowBookmarkStatus(bookmark);

- }

- if (bookmark.getRoom() == muc_->getJID()) {

- updateChatWindowBookmarkStatus(boost::optional<MUCBookmark>());

- }

- assert(chatWindow_);

- if (bookmark) {

- if (bookmark->getAutojoin()) {

- chatWindow_->setBookmarkState(ChatWindow::RoomAutoJoined);

- }

- else {

- chatWindow_->setBookmarkState(ChatWindow::RoomBookmarked);

- }

- }

- else {

- chatWindow_->setBookmarkState(ChatWindow::RoomNotBookmarked);

- }

- * Copyright (c) 2010-2015 Isode Limited.

-#include <boost/shared_ptr.hpp>

-#include <boost/signals/connection.hpp>

-#include <Swiften/Base/boost_bsignals.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, PresenceOracle* presenceOracle, AvatarManager* avatarManager, UIEventStream* events, bool useDelayForLatency, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, XMPPRoster* roster, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, boost::shared_ptr<ChatMessageParser> chatMessageParser, bool isImpromptu, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider, VCardManager* vcardManager, MUCBookmarkManager* mucBookmarkManager);

- virtual ~MUCController();

- boost::signal<void ()> onUserLeft;

- boost::signal<void ()> onUserJoined;

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

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

- virtual void setOnline(bool online) SWIFTEN_OVERRIDE;

- virtual void setAvailableServerFeatures(boost::shared_ptr<DiscoInfo> info) SWIFTEN_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;

-

- protected:

- virtual void preSendMessageRequest(boost::shared_ptr<Message> message) SWIFTEN_OVERRIDE;

- virtual bool isIncomingMessageFromMe(boost::shared_ptr<Message> message) SWIFTEN_OVERRIDE;

- virtual std::string senderHighlightNameFromMessage(const JID& from) SWIFTEN_OVERRIDE;

- virtual std::string senderDisplayNameFromMessage(const JID& from) SWIFTEN_OVERRIDE;

- virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(boost::shared_ptr<Message> message) const SWIFTEN_OVERRIDE;

- virtual void preHandleIncomingMessage(boost::shared_ptr<MessageEvent>) SWIFTEN_OVERRIDE;

- virtual void addMessageHandleIncomingMessage(const JID& from, const std::string& message, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& time, const HighlightAction& highlight) SWIFTEN_OVERRIDE;

- virtual void postHandleIncomingMessage(boost::shared_ptr<MessageEvent>, const HighlightAction&) SWIFTEN_OVERRIDE;

- virtual void cancelReplaces() SWIFTEN_OVERRIDE;

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

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

- void handleOccupantLeft(const MUCOccupant& occupant, MUC::LeavingType type, const std::string& reason);

- void handleOccupantPresenceChange(boost::shared_ptr<Presence> presence);

- void handleOccupantRoleChanged(const std::string& nick, const MUCOccupant& occupant,const MUCOccupant::Role& oldRole);

- void handleOccupantAffiliationChanged(const std::string& nick, const MUCOccupant::Affiliation& affiliation,const MUCOccupant::Affiliation& oldAffiliation);

- void handleJoinComplete(const std::string& nick);

- void handleJoinFailed(boost::shared_ptr<ErrorPayload> error);

- void handleJoinTimeoutTick();

- void handleChangeSubjectRequest(const std::string&);

- void handleBookmarkRequest();

- std::string roleToGroupName(MUCOccupant::Role role);

- std::string roleToSortName(MUCOccupant::Role role);

- JID nickToJID(const std::string& nick);

- std::string roleToFriendlyName(MUCOccupant::Role role);

- void receivedActivity();

- bool messageTargetsMe(boost::shared_ptr<Message> message);

- void updateJoinParts();

- bool shouldUpdateJoinParts();

- virtual void dayTicked() SWIFTEN_OVERRIDE { clearPresenceQueue(); }

- void processUserPart();

- virtual void handleBareJIDCapsChanged(const JID& jid) SWIFTEN_OVERRIDE;

- void handleConfigureRequest(Form::ref);

- void handleConfigurationFailed(ErrorPayload::ref);

- void handleConfigurationFormReceived(Form::ref);

- void handleDestroyRoomRequest();

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

- void handleConfigurationCancelled();

- void handleOccupantRoleChangeFailed(ErrorPayload::ref, const JID&, MUCOccupant::Role);

- void handleGetAffiliationsRequest();

- void handleAffiliationListReceived(MUCOccupant::Affiliation affiliation, const std::vector<JID>& jids);

- void handleChangeAffiliationsRequest(const std::vector<std::pair<MUCOccupant::Affiliation, JID> >& changes);

- void handleInviteToMUCWindowDismissed();

- void handleInviteToMUCWindowCompleted();

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

- void addRecentLogs();

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

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

- void setImpromptuWindowTitle();

- void handleRoomUnlocked();

- void configureAsImpromptuRoom(Form::ref form);

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

-

- void handleUnblockUserRequest();

- void handleBlockingStateChanged();

-

- void handleMUCBookmarkAdded(const MUCBookmark& bookmark);

- void handleMUCBookmarkRemoved(const MUCBookmark& bookmark);

- void updateChatWindowBookmarkStatus(const boost::optional<MUCBookmark>& bookmark);

-

- private:

- MUC::ref muc_;

- UIEventStream* events_;

- std::string nick_;

- std::string desiredNick_;

- Roster* roster_;

- TabComplete* completer_;

- bool parting_;

- bool joined_;

- bool lastWasPresence_;

- bool shouldJoinOnReconnect_;

- bool doneGettingHistory_;

- boost::bsignals::scoped_connection avatarChangedConnection_;

- boost::shared_ptr<Timer> loginCheckTimer_;

- std::set<std::string> currentOccupants_;

- std::vector<NickJoinPart> joinParts_;

- boost::posix_time::ptime lastActivity_;

- boost::optional<std::string> password_;

- XMPPRoster* xmppRoster_;

- std::vector<HistoryMessage> joinContext_;

- size_t renameCounter_;

- bool isImpromptu_;

- bool isImpromptuAlreadyConfigured_;

- RosterVCardProvider* rosterVCardProvider_;

- std::string lastJoinMessageUID_;

-

- ClientBlockListManager* clientBlockListManager_;

- boost::bsignals::scoped_connection blockingOnStateChangedConnection_;

- boost::bsignals::scoped_connection blockingOnItemAddedConnection_;

- boost::bsignals::scoped_connection blockingOnItemRemovedConnection_;

-

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

-

- MUCBookmarkManager* mucBookmarkManager_;

- boost::bsignals::scoped_connection mucBookmarkManagerBookmarkAddedConnection_;

- boost::bsignals::scoped_connection mucBookmarkManagerBookmarkRemovedConnection_;

- };

- * Copyright (c) 2010-2011 Isode Limited.

-#include "Swift/Controllers/Chat/MUCSearchController.h"

-#include <boost/shared_ptr.hpp>

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

-#include <Swiften/Disco/GetDiscoItemsRequest.h>

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

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

-MUCSearchController::MUCSearchController(const JID& jid, MUCSearchWindowFactory* factory, IQRouter* iqRouter, ProfileSettingsProvider* settings) : jid_(jid), factory_(factory), iqRouter_(iqRouter), settings_(settings), window_(NULL), walker_(NULL) {

- itemsInProgress_ = 0;

- loadSavedServices();

- delete walker_;

- delete window_;

- if (!window_) {

- window_ = factory_->createMUCSearchWindow();

- window_->onSearchService.connect(boost::bind(&MUCSearchController::handleSearchService, this, _1));

- window_->onFinished.connect(boost::bind(&MUCSearchController::handleMUCSearchFinished, this, _1));

- window_->addSavedServices(savedServices_);

- }

- handleSearchService(JID(jid_.getDomain()));

- window_->show();

- savedServices_.clear();

- foreach (std::string stringItem, String::split(settings_->getStringSetting(SEARCHED_SERVICES), '\n')) {

- savedServices_.push_back(JID(stringItem));

- }

- savedServices_.erase(std::remove(savedServices_.begin(), savedServices_.end(), jid), savedServices_.end());

- savedServices_.push_front(jid);

-

- std::string collapsed;

- int i = 0;

- foreach (JID jidItem, savedServices_) {

- if (i >= 15) {

- break;

- }

- if (!collapsed.empty()) {

- collapsed += "\n";

- }

- collapsed += jidItem.toString();

- ++i;

- }

- settings_->storeString(SEARCHED_SERVICES, collapsed);

- window_->addSavedServices(savedServices_);

- if (!jid.isValid()) {

- //Set Window to say error this isn't valid

- return;

- }

- addToSavedServices(jid);

-

- services_.clear();

- serviceDetails_.clear();

-

- window_->setSearchInProgress(true);

- refreshView();

-

- if (walker_) {

- walker_->endWalk();

- walker_->onServiceFound.disconnect(boost::bind(&MUCSearchController::handleDiscoServiceFound, this, _1, _2));

- walker_->onWalkComplete.disconnect(boost::bind(&MUCSearchController::handleDiscoWalkFinished, this));

- delete walker_;

- }

-

- SWIFT_LOG(debug) << "Starting walking MUC services" << std::endl;

- itemsInProgress_ = 0;

- walker_ = new DiscoServiceWalker(jid, iqRouter_);

- walker_->onServiceFound.connect(boost::bind(&MUCSearchController::handleDiscoServiceFound, this, _1, _2));

- walker_->onWalkComplete.connect(boost::bind(&MUCSearchController::handleDiscoWalkFinished, this));

- walker_->beginWalk();

-void MUCSearchController::handleDiscoServiceFound(const JID& jid, boost::shared_ptr<DiscoInfo> info) {

- bool isMUC = false;

- std::string name;

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

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

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

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

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

- isMUC = true;

- name = identity.getName();

- }

- }

- if (isMUC) {

- SWIFT_LOG(debug) << "MUC Service found: " << jid << std::endl;

- services_.erase(std::remove(services_.begin(), services_.end(), jid), services_.end());

- services_.push_back(jid);

- serviceDetails_[jid].setName(name);

- serviceDetails_[jid].setJID(jid);

- serviceDetails_[jid].setComplete(false);

- itemsInProgress_++;

- SWIFT_LOG(debug) << "Requesting items of " << jid << " (" << itemsInProgress_ << " item requests in progress)" << std::endl;

- GetDiscoItemsRequest::ref discoItemsRequest = GetDiscoItemsRequest::create(jid, iqRouter_);

- discoItemsRequest->onResponse.connect(boost::bind(&MUCSearchController::handleRoomsItemsResponse, this, _1, _2, jid));

- discoItemsRequest->send();

- }

- else {

- removeService(jid);

- }

- refreshView();

- SWIFT_LOG(debug) << "MUC Walk finished" << std::endl;

- updateInProgressness();

- serviceDetails_.erase(jid);

- services_.erase(std::remove(services_.begin(), services_.end(), jid), services_.end());

- refreshView();

-void MUCSearchController::handleRoomsItemsResponse(boost::shared_ptr<DiscoItems> items, ErrorPayload::ref error, const JID& jid) {

- itemsInProgress_--;

- SWIFT_LOG(debug) << "Items received for " << jid << " (" << itemsInProgress_ << " item requests in progress)" << std::endl;

- updateInProgressness();

- if (error) {

- handleDiscoError(jid, error);

- return;

- }

- serviceDetails_[jid].clearRooms();

- foreach (DiscoItems::Item item, items->getItems()) {

- serviceDetails_[jid].addRoom(MUCService::MUCRoom(item.getJID().getNode(), item.getName(), -1));

- }

- serviceDetails_[jid].setComplete(true);

- refreshView();

- serviceDetails_[jid].setComplete(true);

- serviceDetails_[jid].setError(error->getText());

- window_->clearList();

- foreach (JID jid, services_) {

- window_->addService(serviceDetails_[jid]);

- }

- window_->setSearchInProgress((walker_ && walker_->isActive()) || itemsInProgress_ > 0);

- if (result) {

- onMUCSelected(*result);

- }

- * Copyright (c) 2010-2011 Isode Limited.

-#include <vector>

-#include <boost/shared_ptr.hpp>

-#include "Swiften/Base/boost_bsignals.h"

-#include <string>

-#include "Swiften/JID/JID.h"

-#include "Swift/Controllers/UIEvents/UIEvent.h"

-#include "Swift/Controllers/ProfileSettingsProvider.h"

-#include "Swiften/Elements/DiscoInfo.h"

-#include "Swiften/Elements/DiscoItems.h"

-#include "Swiften/Elements/ErrorPayload.h"

- class UIEventStream;

- class MUCSearchWindow;

- class MUCSearchWindowFactory;

- class IQRouter;

- class DiscoServiceWalker;

- class NickResolver;

-

- class MUCService {

- public:

- class MUCRoom {

- public:

- MUCRoom(const std::string& node, const std::string& name, int occupants) : node_(node), name_(name), occupants_(occupants) {}

- std::string getNode() {return node_;}

- std::string getName() {return name_;}

- int getOccupantCount() {return occupants_;}

- private:

- std::string node_;

- std::string name_;

- int occupants_;

- };

-

- MUCService() {error_ = false; complete_ = false;}

-

- void setComplete(bool complete) {

- complete_ = complete;

- }

-

- void setName(const std::string& name) {

- name_ = name;

- }

-

- void setJID(const JID& jid) {

- jid_ = jid;

- }

-

- bool getComplete() const {

- return complete_;

- }

-

- JID getJID() const {

- return jid_;

- }

-

- std::string getName() const {

- return name_;

- }

-

- void setError(const std::string& errorText) {error_ = true; errorText_ = errorText;}

-

- void clearRooms() {rooms_.clear();}

-

- void addRoom(const MUCRoom& room) {rooms_.push_back(room);}

-

- std::vector<MUCRoom> getRooms() const {return rooms_;}