+3.0-beta1

+---------

+- Allow toggling of a more compact roster display.

+- Remember status settings and provide quick access to them with searching of recent selections in the status setter.

+

+2.1

+---

+- Fixed potential crash when using proxies on Mac OS X.

+

+2.0-beta2

+---------

+- Enable auto-completion of nicknames that don't start with a letter.

+- Generate crash dumps on Windows.

+- Connection timeouts are now on each connection separately, instead of on the complete connection process.

+- Don't allow pressing `<Enter>` in the roster to trigger logins.

+- Don't lose security labels when correcting a message.

+- Don't crash when completing user search without selection.

+- Always auto join MUC with a consistent nickname.

+- Renamed `swift` binary to `swift-im` on Linux.

+- Avoid woosh down and woosh up on Mac when opening chat windows.

+- Improved MUC invitation dialog.

+- Fixed problem with displaying group names containing '&' in the 'Edit' dialog.

+- Show stream encryption status in header.

+- Show extended certificate dialog when encryption errors occur.

+- Don't allow server command results to get interpreted as HTML.

+- Additional connection settings (such as manual host setting, proxy configuration and BOSH) can now be specified through a new dialog on the login window.

+

+Thanks to Tobias Markmann.

+

+

+2.0-beta1

+---------

+- Windows packages are now built in Microsoft Installer's ".msi" format. Please

+ uninstall any older NSIS-based Swift packages before upgrading to this release.

+- Suitable names will now be suggested from the contact's vcard when adding/editing their roster entry.

+- It is now possible for sysadmins to deploy files with policies for configuration options, such as

+ making it impossible for users to save passwords or to force sound notifications off, or to set defaults.

+- Swift will now use appropriate algorithms when run on a Windows platform locked down in FIPS-140-2 mode.

+- Our TLS provider has been changed to the platform-provided one (Schannel) on Windows,

+ allowing us to use certificates (both file and card-based) from the system store (CAPI).

+- Added support for message receipts in one-to-one conversations (XEP-0184).

+- Added support for several MUC operations (kicking, banning, invites, topic changes, room destruction,

+ changing participant affiliations, ...).

+- It is now possible to resize the font in the chat window conversations.

+- Added support for message correction. Use 'up' to edit the previous message.

+- A list of recent chats is now kept in the 'Chats' tab of the main window.

+- Added support for server commands.

+- Chat tabs with unread messages from several chats will now be a little more descriptive.

+- Use a bar for showing where the last read messages in a chat are.

+- Added support for SOCKS5 and HTTPConnect proxies. These settings are taken from the platform preferences.

+- Retrieve incremental contact list on login on servers that support it (XEP-0237: Roster Versioning).

+- Lots of bugfixes, performance fixes, and other changes.

+

+Thanks to Tobias Markmann, Jan Kaluza, Thilo Cestonaro, Arnt Gulbrandsen, Vlad Voicu, Vitaly Takmazov,

+Yoann Blein, Catalin Badea, Pavol Babincak, Mateusz Piekos, Alexey Melnikov and Soren Dreijer.

+

+

+1.0

+---

+- Initial release.

+/*

+ * Copyright (c) 2010-2014 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#include <boost/bind.hpp>

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

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

+

+namespace Swift {

+

+AdHocController::AdHocController(AdHocCommandWindowFactory* factory, boost::shared_ptr<OutgoingAdHocCommandSession> command) {

+ window_ = factory->createAdHocCommandWindow(command);

+ window_->onClosing.connect(boost::bind(&AdHocController::handleWindowClosed, this));

+}

+

+AdHocController::~AdHocController() {

+ window_->onClosing.disconnect(boost::bind(&AdHocController::handleWindowClosed, this));

+ delete window_;

+}

+

+void AdHocController::setOnline(bool online) {

+ window_->setOnline(online);

+}

+

+void AdHocController::handleWindowClosed() {

+ onDeleting();

+}

+

+}

+/*

+ * Copyright (c) 2010-2014 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+#include <Swiften/AdHoc/OutgoingAdHocCommandSession.h>

+

+namespace Swift {

+

+class AdHocCommandWindowFactory;

+class AdHocCommandWindow;

+

+class AdHocController {

+public:

+ AdHocController(AdHocCommandWindowFactory* factory, boost::shared_ptr<OutgoingAdHocCommandSession> command);

+ ~AdHocController();

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

+ void setOnline(bool online);

+private:

+ void handleWindowClosed();

+ AdHocCommandWindow* window_;

+};

+

+}

+ * Copyright (c) 2010-2014 Kevin Smith

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

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

+ controllers_[i]->onDeleting.disconnect(boost::bind(&AdHocManager::removeController, this, controllers_[i]));

+ }

+}

+

+void AdHocManager::removeController(boost::shared_ptr<AdHocController> controller) {

+ controller->onDeleting.disconnect(boost::bind(&AdHocManager::removeController, this, controller));

+ controllers_.erase(std::find(controllers_.begin(), controllers_.end(), controller));

+}

+void AdHocManager::setOnline(bool online) {

+ foreach (boost::shared_ptr<AdHocController> controller, controllers_) {

+ controller->setOnline(online);

+ }

+ boost::shared_ptr<OutgoingAdHocCommandSession> command = boost::make_shared<OutgoingAdHocCommandSession>(adHocEvent->getCommand().getJID(), adHocEvent->getCommand().getNode(), iqRouter_);

+ boost::shared_ptr<AdHocController> controller = boost::make_shared<AdHocController>(factory_, command);

+ controller->onDeleting.connect(boost::bind(&AdHocManager::removeController, this, controller));

+ controllers_.push_back(controller);

+ }

+ boost::shared_ptr<RequestAdHocWithJIDUIEvent> adHocJIDEvent = boost::dynamic_pointer_cast<RequestAdHocWithJIDUIEvent>(event);

+ if (!!adHocJIDEvent) {

+ boost::shared_ptr<OutgoingAdHocCommandSession> command = boost::make_shared<OutgoingAdHocCommandSession>(adHocJIDEvent->getJID(), adHocJIDEvent->getNode(), iqRouter_);

+ boost::shared_ptr<AdHocController> controller = boost::make_shared<AdHocController>(factory_, command);

+ controller->onDeleting.connect(boost::bind(&AdHocManager::removeController, this, controller));

+ controllers_.push_back(controller);

+ * Copyright (c) 2010-2014 Kevin Smith

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

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

+ void removeController(boost::shared_ptr<AdHocController> contoller);

+ void setOnline(bool online);

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

+ boost::signal<void (const AdHocController&)> onControllerComplete;

+ std::vector<boost::shared_ptr<AdHocController> > controllers_;

+

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+/*

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

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+#include <boost/bind.hpp>

+

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

+

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

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

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

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

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

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

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

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

+

+namespace Swift {

+

+BlockListController::BlockListController(ClientBlockListManager* blockListManager, UIEventStream* uiEventStream, BlockListEditorWidgetFactory* blockListEditorWidgetFactory, EventController* eventController) : blockListManager_(blockListManager), blockListEditorWidgetFactory_(blockListEditorWidgetFactory), blockListEditorWidget_(0), eventController_(eventController), remainingRequests_(0), uiEventStream_(uiEventStream) {

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

+ blockListManager_->getBlockList()->onItemAdded.connect(boost::bind(&BlockListController::handleBlockListChanged, this));

+ blockListManager_->getBlockList()->onItemRemoved.connect(boost::bind(&BlockListController::handleBlockListChanged, this));

+}

+

+BlockListController::~BlockListController() {

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

+ blockListManager_->getBlockList()->onItemAdded.disconnect(boost::bind(&BlockListController::handleBlockListChanged, this));

+ blockListManager_->getBlockList()->onItemRemoved.disconnect(boost::bind(&BlockListController::handleBlockListChanged, this));

+}

+

+void BlockListController::blockListDifferences(const std::vector<JID> &newBlockList, std::vector<JID> &jidsToUnblock, std::vector<JID> &jidsToBlock) const {

+ foreach (const JID& jid, blockListBeforeEdit) {

+ if (std::find(newBlockList.begin(), newBlockList.end(), jid) == newBlockList.end()) {

+ jidsToUnblock.push_back(jid);

+ }

+ }

+

+ foreach (const JID& jid, newBlockList) {

+ if (std::find(blockListBeforeEdit.begin(), blockListBeforeEdit.end(), jid) == blockListBeforeEdit.end()) {

+ jidsToBlock.push_back(jid);

+ }

+ }

+}

+

+void BlockListController::handleUIEvent(boost::shared_ptr<UIEvent> rawEvent) {

+ // handle UI dialog

+ boost::shared_ptr<RequestBlockListDialogUIEvent> requestDialogEvent = boost::dynamic_pointer_cast<RequestBlockListDialogUIEvent>(rawEvent);

+ if (requestDialogEvent != NULL) {

+ if (blockListEditorWidget_ == NULL) {

+ blockListEditorWidget_ = blockListEditorWidgetFactory_->createBlockListEditorWidget();

+ blockListEditorWidget_->onSetNewBlockList.connect(boost::bind(&BlockListController::handleSetNewBlockList, this, _1));

+ }

+ blockListBeforeEdit = blockListManager_->getBlockList()->getItems();

+ blockListEditorWidget_->setCurrentBlockList(blockListBeforeEdit);

+ blockListEditorWidget_->setError("");

+ blockListEditorWidget_->show();

+ return;

+ }

+

+ // handle block state change

+ boost::shared_ptr<RequestChangeBlockStateUIEvent> changeStateEvent = boost::dynamic_pointer_cast<RequestChangeBlockStateUIEvent>(rawEvent);

+ if (changeStateEvent != NULL) {

+ if (changeStateEvent->getBlockState() == RequestChangeBlockStateUIEvent::Blocked) {

+ GenericRequest<BlockPayload>::ref blockRequest = blockListManager_->createBlockJIDRequest(changeStateEvent->getContact());

+ blockRequest->onResponse.connect(boost::bind(&BlockListController::handleBlockResponse, this, blockRequest, _1, _2, std::vector<JID>(1, changeStateEvent->getContact()), false));

+ blockRequest->send();

+ } else if (changeStateEvent->getBlockState() == RequestChangeBlockStateUIEvent::Unblocked) {

+ GenericRequest<UnblockPayload>::ref unblockRequest = blockListManager_->createUnblockJIDRequest(changeStateEvent->getContact());

+ unblockRequest->onResponse.connect(boost::bind(&BlockListController::handleUnblockResponse, this, unblockRequest, _1, _2, std::vector<JID>(1, changeStateEvent->getContact()), false));

+ unblockRequest->send();

+ }

+ return;

+ }

+}

+

+void BlockListController::handleBlockResponse(GenericRequest<BlockPayload>::ref request, boost::shared_ptr<BlockPayload>, ErrorPayload::ref error, const std::vector<JID>& jids, bool originEditor) {

+ if (error) {

+ std::string errorMessage;

+ // FIXME: Handle reporting of list of JIDs in a translatable way.

+ errorMessage = str(format(QT_TRANSLATE_NOOP("", "Failed to block %1%.")) % jids.at(0).toString());

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

+ errorMessage = str(format(QT_TRANSLATE_NOOP("", "%1%: %2%.")) % errorMessage % error->getText());

+ }

+ if (blockListEditorWidget_ && originEditor) {

+ blockListEditorWidget_->setError(errorMessage);

+ blockListEditorWidget_->setBusy(false);

+ }

+ else {

+ eventController_->handleIncomingEvent(boost::make_shared<ErrorEvent>(request->getReceiver(), errorMessage));

+ }

+ }

+ if (originEditor) {

+ remainingRequests_--;

+ if (blockListEditorWidget_ && (remainingRequests_ == 0) && !error) {

+ blockListEditorWidget_->setBusy(false);

+ blockListEditorWidget_->hide();

+ }

+ }

+}

+

+void BlockListController::handleUnblockResponse(GenericRequest<UnblockPayload>::ref request, boost::shared_ptr<UnblockPayload>, ErrorPayload::ref error, const std::vector<JID>& jids, bool originEditor) {

+ if (error) {

+ std::string errorMessage;

+ // FIXME: Handle reporting of list of JIDs in a translatable way.

+ errorMessage = str(format(QT_TRANSLATE_NOOP("", "Failed to unblock %1%.")) % jids.at(0).toString());

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

+ errorMessage = str(format(QT_TRANSLATE_NOOP("", "%1%: %2%.")) % errorMessage % error->getText());

+ }

+ if (blockListEditorWidget_ && originEditor) {

+ blockListEditorWidget_->setError(errorMessage);

+ blockListEditorWidget_->setBusy(false);

+ }

+ else {

+ eventController_->handleIncomingEvent(boost::make_shared<ErrorEvent>(request->getReceiver(), errorMessage));

+ }

+ }

+ if (originEditor) {

+ remainingRequests_--;

+ if (blockListEditorWidget_ && (remainingRequests_ == 0) && !error) {

+ blockListEditorWidget_->setBusy(false);

+ blockListEditorWidget_->hide();

+ }

+ }

+}

+

+void BlockListController::handleSetNewBlockList(const std::vector<JID> &newBlockList) {

+ std::vector<JID> jidsToBlock;

+ std::vector<JID> jidsToUnblock;

+

+ blockListDifferences(newBlockList, jidsToUnblock, jidsToBlock);

+

+ if (!jidsToBlock.empty()) {

+ remainingRequests_++;

+ GenericRequest<BlockPayload>::ref blockRequest = blockListManager_->createBlockJIDsRequest(jidsToBlock);

+ blockRequest->onResponse.connect(boost::bind(&BlockListController::handleBlockResponse, this, blockRequest, _1, _2, jidsToBlock, true));

+ blockRequest->send();

+ }

+ if (!jidsToUnblock.empty()) {

+ remainingRequests_++;

+ GenericRequest<UnblockPayload>::ref unblockRequest = blockListManager_->createUnblockJIDsRequest(jidsToUnblock);

+ unblockRequest->onResponse.connect(boost::bind(&BlockListController::handleUnblockResponse, this, unblockRequest, _1, _2, jidsToUnblock, true));

+ unblockRequest->send();

+ }

+ if (!jidsToBlock.empty() || !jidsToUnblock.empty()) {

+ assert(blockListEditorWidget_);

+ blockListEditorWidget_->setBusy(true);

+ blockListEditorWidget_->setError("");

+ } else {

+ blockListEditorWidget_->hide();

+ }

+}

+

+void BlockListController::handleBlockListChanged() {

+ if (blockListEditorWidget_) {

+ std::vector<JID> jidsToBlock;

+ std::vector<JID> jidsToUnblock;

+

+ blockListDifferences(blockListEditorWidget_->getCurrentBlockList(), jidsToUnblock, jidsToBlock);

+ blockListBeforeEdit = blockListManager_->getBlockList()->getItems();

+

+ foreach (const JID& jid, jidsToBlock) {

+ if (std::find(blockListBeforeEdit.begin(), blockListBeforeEdit.end(), jid) == blockListBeforeEdit.end()) {

+ blockListBeforeEdit.push_back(jid);

+ }

+ }

+

+ foreach (const JID& jid, jidsToUnblock) {

+ blockListBeforeEdit.erase(std::remove(blockListBeforeEdit.begin(), blockListBeforeEdit.end(), jid), blockListBeforeEdit.end());

+ }

+

+ blockListEditorWidget_->setCurrentBlockList(blockListBeforeEdit);

+ }

+}

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+#pragma once

+

+#include <boost/shared_ptr.hpp>

+

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

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

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

+

+namespace Swift {

+

+class BlockPayload;

+class UnblockPayload;

+class ClientBlockListManager;

+class EventController;

+

+class BlockListController {

+public:

+ BlockListController(ClientBlockListManager* blockListManager, UIEventStream* uiEventStream, BlockListEditorWidgetFactory* blockListEditorWidgetFactory, EventController* eventController);

+ ~BlockListController();

+

+private:

+ void blockListDifferences(const std::vector<JID> &newBlockList, std::vector<JID>& jidsToUnblock, std::vector<JID>& jidsToBlock) const;

+

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

+

+ void handleBlockResponse(GenericRequest<BlockPayload>::ref, boost::shared_ptr<BlockPayload>, ErrorPayload::ref error, const std::vector<JID>& jids, bool originEditor);

+ void handleUnblockResponse(GenericRequest<UnblockPayload>::ref, boost::shared_ptr<UnblockPayload>, ErrorPayload::ref error, const std::vector<JID>& jids, bool originEditor);

+

+ void handleSetNewBlockList(const std::vector<JID>& newBlockList);

+

+ void handleBlockListChanged();

+

+private:

+ ClientBlockListManager* blockListManager_;

+ BlockListEditorWidgetFactory* blockListEditorWidgetFactory_;

+ BlockListEditorWidget* blockListEditorWidget_;

+ EventController* eventController_;

+ std::vector<JID> blockListBeforeEdit;

+ int remainingRequests_;

+ UIEventStream* uiEventStream_;

+};

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+/*

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

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

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

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

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

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

+

+namespace Swift {

+ class AutoAcceptMUCInviteDecider {

+ public:

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

+ }

+

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

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

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

+ }

+

+ if (invite->getIsContinuation()) {

+ return true;

+ }

+

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

+ if (auto_accept_mode == "no") {

+ return false;

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

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

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

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

+ } else {

+ assert(false);

+ return false;

+ }

+ }

+

+ private:

+ JID domain_;

+ XMPPRoster* roster_;

+ SettingsProvider* settings_;

+ };

+}

+ * Copyright (c) 2010-2014 Kevin Smith

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

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

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

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

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

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

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

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

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

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

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

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

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

+

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

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

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

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

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

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

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

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

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

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

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

+ Idle::ref idle;

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

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

+ }

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

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

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

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

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

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

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

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

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

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

+JID ChatController::getBaseJID() {

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

+}

+

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

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

+ } else {

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

+ }

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

+ ChatControllerBase::setAvailableServerFeatures(info);

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

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

+

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

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

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

+

+ handleBlockingStateChanged();

+ }

+}

+

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

+ // handle XEP-0184 Message Receipts

+ // incomming receipts

+ // incomming errors in response to send out receipts

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

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

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

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

+ }

+ // incoming receipt requests

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

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

+ highlighter_->handleHighlightAction(highlight);

+ }

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

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

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

+ } else {

+ if (deliveryReceiptAlert_) {

+ chatWindow_->removeAlert(*deliveryReceiptAlert_);

+ deliveryReceiptAlert_.reset();

+ }

+ }

+ if (newDeliverReceiptAlert) {

+ if (deliveryReceiptAlert_) {

+ chatWindow_->removeAlert(*deliveryReceiptAlert_);

+ }

+ deliveryReceiptAlert_ = newDeliverReceiptAlert;

+ }

+}

+

+void ChatController::handleBlockingStateChanged() {

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

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

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

+ if (!blockedContactAlert_) {

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

+ }

+ chatWindow_->setInputEnabled(false);

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

+

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

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

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

+ } else {

+ if (blockedContactAlert_) {

+ chatWindow_->removeAlert(*blockedContactAlert_);

+ blockedContactAlert_.reset();

+ }

+ chatWindow_->setInputEnabled(true);

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

+

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

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

+ }

+ }

+}

+

+void ChatController::handleBlockUserRequest() {

+ if (isInMUC_) {

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

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

+ }

+}

+

+void ChatController::handleUnblockUserRequest() {

+ if (isInMUC_) {

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

+ } else {

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

+ }

+}

+

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

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

+ eventStream_->send(event);

+}

+

+void ChatController::handleWindowClosed() {

+ onWindowClosed();

+}

+

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

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

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

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

+

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

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

+void ChatController::handleWhiteboardSessionRequest(bool senderIsSelf) {

+ lastWbID_ = chatWindow_->addWhiteboardRequest(senderIsSelf);

+}

+

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

+ chatWindow_->setWhiteboardSessionStatus(lastWbID_, state);

+}

+

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

+void ChatController::handleWhiteboardSessionAccept() {

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

+}

+

+void ChatController::handleWhiteboardSessionCancel() {

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

+}

+

+void ChatController::handleWhiteboardWindowShow() {

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

+}

+

+ Idle::ref idle;

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

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

+ }

+

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

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

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

+ HistoryMessage::Type type;

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

+ type = HistoryMessage::PrivateMessage;

+ }

+ else {

+ type = HistoryMessage::Chat;

+ }

+

+ if (historyController_) {

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

+ }

+}

+

+ChatWindow* ChatController::detachChatWindow() {

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

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

+ return ChatControllerBase::detachChatWindow();

+}

+

+ * Copyright (c) 2010-2014 Kevin Smith

+ class HistoryController;

+ class HighlightManager;

+ class ClientBlockListManager;

+ class UIEvent;

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

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

+ virtual void handleWhiteboardSessionRequest(bool senderIsSelf);

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

+ virtual ChatWindow* detachChatWindow();

+ JID getBaseJID();

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

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

+ void handleWhiteboardSessionAccept();

+ void handleWhiteboardSessionCancel();

+ void handleWhiteboardWindowShow();

+

+ void handleBlockingStateChanged();

+ void handleBlockUserRequest();

+ void handleUnblockUserRequest();

+

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

+

+ void handleWindowClosed();

+

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

+

+ std::string lastWbID_;

+

+ ClientBlockListManager* clientBlockListManager_;

+ boost::bsignals::scoped_connection blockingOnStateChangedConnection_;

+ boost::bsignals::scoped_connection blockingOnItemAddedConnection_;

+ boost::bsignals::scoped_connection blockingOnItemRemovedConnection_;

+

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

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

+ * Copyright (c) 2010-2014 Kevin Smith

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

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

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

+

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

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

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

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

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

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

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

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

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

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

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

+ highlighter_ = highlightManager->createHighlighter();

+ delete highlighter_;

+ChatWindow* ChatControllerBase::detachChatWindow() {

+ ChatWindow* chatWindow = chatWindow_;

+ chatWindow_ = NULL;

+ return chatWindow;

+}

+

+void ChatControllerBase::setCanStartImpromptuChats(bool supportsImpromptu) {

+ if (chatWindow_) {

+ chatWindow_->setCanInitiateImpromptuChats(supportsImpromptu);

+ }

+}

+

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

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

+JID ChatControllerBase::getBaseJID() {

+ return JID(toJID_.toBare());

+}

+

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

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

+ if (!isCorrectionMessage) {

+ lastLabel_ = chatWindow_->getSelectedSecurityLabel();

+ }

+ SecurityLabelsCatalog::Item labelItem = lastLabel_;

+

+ if (useDelayForLatency_) {

+

+#ifdef SWIFT_EXPERIMENTAL_HISTORY

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

+#endif

+ if (catalog && !error) {

+bool ChatControllerBase::hasOpenWindow() const {

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

+}

+

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

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

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

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

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

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

+ HighlightAction highlight;

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

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

+ }

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

+ // Highlight

+ if (!isIncomingMessageFromMe(message)) {

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

+ }

+

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

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

+

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

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

+ postHandleIncomingMessage(messageEvent, highlight);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ }

+ }

+ assert(false);

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

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

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

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

+ } else {

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

+}

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

+ * Copyright (c) 2010-2014 Kevin Smith

+#include <string>

+

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

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

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

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

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

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

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

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

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

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

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

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

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

+

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

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

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

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

+ class HighlightManager;

+ class Highlighter;

+ class ChatMessageParser;

+ class AutoAcceptMUCInviteDecider;

+ bool hasOpenWindow() const;

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

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

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

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

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

+ void setCanStartImpromptuChats(bool supportsImpromptu);

+ virtual ChatWindow* detachChatWindow();

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

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

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

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

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

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

+ virtual void dayTicked() {}

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

+ virtual JID getBaseJID();

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

+ SecurityLabelsCatalog::Item lastLabel_;

+ HistoryController* historyController_;

+ MUCRegistry* mucRegistry_;

+ Highlighter* highlighter_;

+ boost::shared_ptr<ChatMessageParser> chatMessageParser_;

+ AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider_;

+ UIEventStream* eventStream_;

+/*

+ * Copyright (c) 2013-2014 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

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

+

+#include <vector>

+#include <utility>

+

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

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

+

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

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

+

+#include <SwifTools/Linkify.h>

+

+

+namespace Swift {

+

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

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

+ }

+

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

+

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

+ ChatWindow::ChatMessage parsedMessage;

+ std::string remaining = body;

+ /* Parse one, URLs */

+ while (!remaining.empty()) {

+ bool found = false;

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

+ remaining = "";

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

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

+ if (found) {

+ // Must be on the last part, then

+ remaining = part;

+ }

+ else {

+ if (i == links.second) {

+ found = true;

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

+ }

+ else {

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

+ }

+ }

+ }

+ }

+

+ /* do emoticon substitution */

+ parsedMessage = emoticonHighlight(parsedMessage);

+

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

+ /* do word-based color highlighting */

+ parsedMessage = splitHighlight(parsedMessage, nick);

+ }

+

+ return parsedMessage;

+ }

+

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

+ {

+ ChatWindow::ChatMessage parsedMessage = message;

+

+ std::string regexString;

+ /* Parse two, emoticons */

+ foreach (StringPair emoticon, emoticons_) {

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

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

+ */

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

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

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

+ regexString += escaped + "$|";

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

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

+

+ }

+ if (!regexString.empty()) {

+ regexString += "";

+ boost::regex emoticonRegex(regexString);

+

+ ChatWindow::ChatMessage newMessage;

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

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

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

+ try {

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

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

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

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

+ int matchIndex = 0;

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

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

+ //This is the matching subgroup

+ break;

+ }

+ }

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

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

+ if (start != matchStart) {

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

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

+ }

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

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

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

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

+ const StringPair& emoticon = *emoticonIterator;

+ emoticonPart->imagePath = emoticon.second;

+ emoticonPart->alternativeText = emoticon.first;

+ newMessage.append(emoticonPart);

+ start = matchEnd;

+ }

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

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

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

+ }

+

+ }

+ catch (std::runtime_error) {

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

+ newMessage.append(part);

+ }

+ }

+ else {

+ newMessage.append(part);

+ }

+ }

+ parsedMessage = newMessage;

+

+ }

+ return parsedMessage;

+ }

+

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

+ {

+ ChatWindow::ChatMessage parsedMessage = message;

+

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

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

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

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

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

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

+ }

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

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

+ ChatWindow::ChatMessage newMessage;

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

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

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

+ try {

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

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

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

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

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

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

+ if (start != matchStart) {

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

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

+ }

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

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

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

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

+ newMessage.append(highlightPart);

+ start = matchEnd;

+ }

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

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

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

+ }

+ }

+ catch (std::runtime_error) {

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

+ newMessage.append(part);

+ }

+ } else {

+ newMessage.append(part);

+ }

+ }

+ parsedMessage = newMessage;

+ }

+ }

+

+ return parsedMessage;

+ }

+}

+/*

+ * Copyright (c) 2013-2014 Kevin Smith

+ * Licensed under the GNU General Public License v3.

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

+ */

+

+#pragma once

+

+#include <string>

+

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

+

+namespace Swift {

+

+ class ChatMessageParser {

+ public:

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

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

+ private:

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

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

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

+ HighlightRulesListPtr highlightRules_;

+ bool mucMode_;

+ };

+}

+ * Copyright (c) 2010-2014 Kevin Smith

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+

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

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

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

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

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

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

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

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

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

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

+

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

+

+namespace boost {

+namespace serialization {

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

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

+ ar << jidStr;

+ }

+

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

+ std::string stringJID;

+ ar >> stringJID;

+ jid = Swift::JID(stringJID);

+ }

+

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

+ split_free(ar, t, file_version);

+ }

+

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

+ ar & chat.jid;

+ ar & chat.chatName;

+ ar & chat.activity;

+ ar & chat.isMUC;

+ ar & chat.nick;

+ ar & chat.impromptuJIDs;

+ if (version > 0) {

+ ar & chat.password;

+ }

+ }

+}

+}

+ SettingsProvider* settings,

+ HistoryController* historyController,

+ WhiteboardManager* whiteboardManager,

+ HighlightManager* highlightManager,

+ ClientBlockListManager* clientBlockListManager,

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

+ UserSearchController* inviteUserSearchController,

+ VCardManager* vcardManager) :

+ settings_(settings),

+ historyController_(historyController),

+ whiteboardManager_(whiteboardManager),

+ highlightManager_(highlightManager),

+ emoticons_(emoticons),

+ clientBlockListManager_(clientBlockListManager),

+ inviteUserSearchController_(inviteUserSearchController),

+ vcardManager_(vcardManager) {

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

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

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

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

+

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

+ delete autoAcceptMUCInviteDecider_;

+ std::stringstream serializeStream;

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

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

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

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

+ if (eagleMode_) {

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

+ chat.activity = "";

+ }

+

+ class RemoveRecent {

+ public:

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

+ return chat.isPrivateMessage;

+ }

+ };

+

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

+

+ oa << recentsLimited;

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

+ profileSettings_->storeString(RECENT_CHATS, serializedStr);

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

+ ChatListWindow::Chat fixedChat = chat;

+ if (fixedChat.isMUC) {

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

+ fixedChat.statusType = StatusShow::Online;

+ }

+ } else {

+ if (avatarManager_) {

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

+ }

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

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

+ }

+ return fixedChat;

+}

+

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

+ // old format

+

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

+ chat = updateChatStatusAndAvatarHelper(chat);

+ prependRecent(chat);

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

+ // boost searilaize based format

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

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

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

+ try {

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

+ ia >> recentChats;

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

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

+ return;

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

+ chat.statusType = StatusShow::None;

+ chat = updateChatStatusAndAvatarHelper(chat);

+ }

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

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

+ std::string password = "";

+

+ if (controller->getPassword()) {

+ password = *controller->getPassword();

+ if (controller->isImpromptu()) {

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

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

+ chat.impromptuJIDs = participants;

+ return chat;

+ }

+ }

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

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

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

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

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

+ cleanupPrivateMessageRecents();

+ chatListWindow_->setRecents(recentChats_);

+}

+

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

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

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

+ ChatListWindow::Chat existingChat = *result;

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

+ } else {

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

+ }

+}

+

+void ChatsManager::cleanupPrivateMessageRecents() {

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

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

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

+ if (chat.isPrivateMessage) {

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

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

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

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

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

+ removeExistingChat(chat);

+ break;

+ }

+ }

+ }

+ }

+}

+

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

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

+ ChatListWindow::Chat mergedChat = chat;

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

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

+ }

+ recentChats_.push_front(mergedChat);

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

+ ChatListWindow::Chat mergedChat = chat;

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

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

+ }

+ recentChats_.push_back(mergedChat);

+ break;

+ cleanupPrivateMessageRecents();

+ chatListWindow_->setRecents(recentChats_);

+void ChatsManager::finalizeImpromptuJoin(MUC::ref muc, const std::vector<JID>& jidsToInvite, const std::string& reason, const boost::optional<JID>& reuseChatJID) {

+ // send impromptu invites for the new MUC

+ std::vector<JID> missingJIDsToInvite = jidsToInvite;

+

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

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

+ foreach(StringMUCOccupantPair occupant, occupants) {

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

+ if (realJID) {

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

+ }

+ }

+

+ if (reuseChatJID) {

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

+ }

+ foreach(const JID& jid, missingJIDsToInvite) {

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

+ }

+}

+

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

+ if (createImpromptuMUCEvent) {

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

+ // create new muc

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

+

+ // join muc

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

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

+ mucControllers_[roomJID]->activateChatWindow();

+ }

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

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

+ JID reuseChatInvite = chatController->getToJID();

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

+ delete chatController;

+

+ // join new impromptu muc

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

+

+ // create new muc

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

+

+ // join muc

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

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

+}

+

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

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

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

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

+ localMUCServiceFinderWalker_->beginWalk();

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

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

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

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

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

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

+ MUC::ref muc;