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

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

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

}

void ChatController::handleContactNickChanged(const JID& jid, const std::string& /*oldNick*/) {

#pragma once

#include <map>

#include <string>

#include <Swiften/Base/Tristate.h>

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

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

namespace Swift {

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 handleNewFileTransferController(FileTransferController* ftc);

virtual void handleWhiteboardSessionRequest(bool senderIsSelf);

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

protected:

private:

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

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

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

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

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

* All rights reserved.

* See the COPYING file for more information.

*/

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

#include <map>

#include <boost/bind.hpp>

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

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

#include <Swiften/Base/Path.h>

#include <Swiften/Base/String.h>

#include <Swiften/Client/StanzaChannel.h>

#include <Swiften/Elements/Delay.h>

#include <Swiften/Elements/MUCInvitationPayload.h>

#include <Swiften/Elements/MUCUserPayload.h>

#include <Swiften/Queries/Requests/GetSecurityLabelsCatalogRequest.h>

#include <Swift/Controllers/Intl.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/XMPPEvents/MUCInviteEvent.h>

namespace Swift {

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

createDayChangeTimer();

}

ChatControllerBase::~ChatControllerBase() {

delete highlighter_;

delete chatWindow_;

* See the COPYING file for more information.

*/

#pragma once

#include <map>

#include <string>

#include <boost/filesystem/path.hpp>

#include <boost/optional.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/ErrorPayload.h>

#include <Swiften/Presence/PresenceOracle.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swift/Controllers/HighlightManager.h>

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

namespace Swift {

class IQRouter;

class StanzaChannel;

class ChatWindowFactory;

class AvatarManager;

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

}

if (avatarManager_ != NULL) {

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

}

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

#include <set>

#include <string>

#include <boost/shared_ptr.hpp>

#include <boost/signals/connection.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Elements/MUCOccupant.h>

#include <Swiften/Elements/Message.h>

#include <Swiften/JID/JID.h>

#include <Swiften/MUC/MUC.h>

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;

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

private:

void setAvailableRoomActions(const MUCOccupant::Affiliation& affiliation, const MUCOccupant::Role& role);

void clearPresenceQueue();

void addPresenceMessage(const std::string& message);

void handleWindowOccupantSelectionChanged(ContactRosterItem* item);

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

void processUserPart();

void handleConfigureRequest(Form::ref);

void handleConfigurationFailed(ErrorPayload::ref);

void handleConfigurationFormReceived(Form::ref);

void handleDestroyRoomRequest();

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

void handleConfigurationCancelled();

/*

* Copyright (c) 2012 Tobias Markmann

* Licensed under the simplified BSD license.

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

*/

#pragma once

namespace Swift {

class MUCInviteEvent : public StanzaEvent {

public:

typedef boost::shared_ptr<MUCInviteEvent> ref;