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

chatStateTracker_ = new ChatStateTracker();

nickResolver_ = nickResolver;

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

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

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

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

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

chatWindow_->setName(nick);

std::string startMessage;

Presence::ref theirPresence;

if (isInMUC) {

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

theirPresence = presenceOracle->getLastPresence(contact);

} else {

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

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

}

Idle::ref idle;

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

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

}

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

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

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

}

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

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

startMessage += ".";

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

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

}

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

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

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

}

}

ChatController::~ChatController() {

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

MUCBookmarkManager* mucBookmarkManager) :

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

assert(avatarManager_);

parting_ = true;

joined_ = false;

lastWasPresence_ = false;

shouldJoinOnReconnect_ = true;

doneGettingHistory_ = false;

xmppRoster_ = xmppRoster;

subject_ = "";

isInitialJoin_ = true;

roster_ = std::unique_ptr<Roster>(new Roster(false, true));

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

completer_ = new TabComplete();

chatWindow_->setRosterModel(roster_.get());

chatWindow_->setTabComplete(completer_);

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

chatWindow_->onOccupantSelectionChanged.connect(boost::bind(&MUCController::handleWindowOccupantSelectionChanged, this, _1));

chatWindow_->onOccupantActionSelected.connect(boost::bind(&MUCController::handleActionRequestedOnOccupant, this, _1, _2));

chatWindow_->onChangeSubjectRequest.connect(boost::bind(&MUCController::handleChangeSubjectRequest, this, _1));

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

chatWindow_->onConfigureRequest.connect(boost::bind(&MUCController::handleConfigureRequest, this, _1));

chatWindow_->onConfigurationFormCancelled.connect(boost::bind(&MUCController::handleConfigurationCancelled, this));

chatWindow_->onDestroyRequest.connect(boost::bind(&MUCController::handleDestroyRoomRequest, this));

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

chatWindow_->onGetAffiliationsRequest.connect(boost::bind(&MUCController::handleGetAffiliationsRequest, this));

chatWindow_->onChangeAffiliationsRequest.connect(boost::bind(&MUCController::handleChangeAffiliationsRequest, this, _1));

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

muc_->onJoinComplete.connect(boost::bind(&MUCController::handleJoinComplete, this, _1));

muc_->onJoinFailed.connect(boost::bind(&MUCController::handleJoinFailed, this, _1));

muc_->onOccupantJoined.connect(boost::bind(&MUCController::handleOccupantJoined, this, _1));

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

muc_->onOccupantPresenceChange.connect(boost::bind(&MUCController::handleOccupantPresenceChange, this, _1));

muc_->onOccupantLeft.connect(boost::bind(&MUCController::handleOccupantLeft, this, _1, _2, _3));

muc_->onRoleChangeFailed.connect(boost::bind(&MUCController::handleOccupantRoleChangeFailed, this, _1, _2, _3));

muc_->onAffiliationListReceived.connect(boost::bind(&MUCController::handleAffiliationListReceived, this, _1, _2));

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

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

chatMessageParser_->setNick(nick_);

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

loginCheckTimer_ = std::shared_ptr<Timer>(timerFactory->createTimer(MUC_JOIN_WARNING_TIMEOUT_MILLISECONDS));

loginCheckTimer_->onTick.connect(boost::bind(&MUCController::handleJoinTimeoutTick, this));

loginCheckTimer_->start();

}

else {

chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(QT_TRANSLATE_NOOP("", "You are currently offline. You will enter this room when you are connected.")), ChatWindow::DefaultDirection);

}

if (isImpromptu) {

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

chatWindow_->convertToMUC(ChatWindow::ImpromptuMUC);

} else {

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

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

chatWindow_->convertToMUC(ChatWindow::StandardMUC);

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

}

if (stanzaChannel->isAvailable()) {

MUCController::setOnline(true);

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

}

}

#pragma clang diagnostic pop

void MUCController::handleJoinComplete(const std::string& nick) {

receivedActivity();

renameCounter_ = 0;

joined_ = true;

if (isImpromptu_) {

}

setNick(nick);

lastJoinMessageUID_ = "";

#ifdef SWIFT_EXPERIMENTAL_HISTORY

addRecentLogs();

#endif

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

}

}

void MUCController::handleAvatarChanged(const JID& jid) {

if (parting_ || !jid.equals(toJID_, JID::WithoutResource)) {

return;

}

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

}

void MUCController::handleWindowClosed() {

setAvailableRoomActions(affiliation, muc_->getOccupant(nick_).getRole());

}

JID jid(nickToJID(nick));

MUCOccupant occupant = muc_->getOccupant(nick);

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

}

std::string MUCController::roleToGroupName(MUCOccupant::Role role) {

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;

}

void MUCController::setOnline(bool online) {

ChatControllerBase::setOnline(online);

if (!online) {

muc_->part();

parting_ = true;

processUserPart();

} else {

if (shouldJoinOnReconnect_) {

renameCounter_ = 0;

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

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

handleBlockingStateChanged();

}

else {

if (isImpromptu_) {

} else {

}

if (loginCheckTimer_) {

loginCheckTimer_->start();

}

setNick(desiredNick_);

rejoin();

}

}

}

}

void MUCController::processUserPart() {

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

}

bool MUCController::shouldUpdateJoinParts() {

return lastWasPresence_;

}

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

NickJoinPart event(occupant.getNick(), Part);

appendToJoinParts(joinParts_, event);

currentOccupants_.erase(occupant.getNick());

completer_->removeWord(occupant.getNick());

}

}

void MUCController::updateChatWindowBookmarkStatus(const boost::optional<MUCBookmark>& bookmark) {

assert(chatWindow_);

if (bookmark) {

if (bookmark->getAutojoin()) {

chatWindow_->setBookmarkState(ChatWindow::RoomAutoJoined);

}

else {

chatWindow_->setBookmarkState(ChatWindow::RoomBookmarked);

}

}

else {

chatWindow_->setBookmarkState(ChatWindow::RoomNotBookmarked);

}

}

void MUCController::displaySubjectIfChanged(const std::string& subject) {

if (subject_ != subject) {

if (!subject.empty()) {

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

}

else {

chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "The room subject has been removed")))), ChatWindow::DefaultDirection);

}

subject_ = subject;

}

}

}

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(std::shared_ptr<UIEvent> event);

void addRecentLogs();

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

void displaySubjectIfChanged(const std::string& sucject);

private:

MUC::ref muc_;

std::string nick_;

std::string desiredNick_;

TabComplete* completer_;

bool parting_;

bool joined_;

bool shouldJoinOnReconnect_;

bool doneGettingHistory_;

boost::signals2::scoped_connection avatarChangedConnection_;

std::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::unique_ptr<Roster> roster_;

std::vector<HistoryMessage> joinContext_;

size_t renameCounter_;

bool isImpromptu_;

bool isImpromptuAlreadyConfigured_;

RosterVCardProvider* rosterVCardProvider_;

std::string lastJoinMessageUID_;

ClientBlockListManager* clientBlockListManager_;

boost::signals2::scoped_connection blockingOnStateChangedConnection_;

boost::signals2::scoped_connection blockingOnItemAddedConnection_;

boost::signals2::scoped_connection blockingOnItemRemovedConnection_;

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

MUCBookmarkManager* mucBookmarkManager_;

boost::signals2::scoped_connection mucBookmarkManagerBookmarkAddedConnection_;

boost::signals2::scoped_connection mucBookmarkManagerBookmarkRemovedConnection_;

std::string subject_;

bool isInitialJoin_;

};

}