MUCRegistry* mucRegistry,

HighlightManager* highlightManager,

ChatMessageParser* chatMessageParser,

bool isImpromptu,

AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider,

VCardManager* vcardManager) :

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

parting_ = true;

joined_ = false;

lastWasPresence_ = false;

shouldJoinOnReconnect_ = true;

doneGettingHistory_ = false;

events_ = uiEventStream;

xmppRoster_ = roster;

roster_ = new Roster(false, true);

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

completer_ = new TabComplete();

chatWindow_->setRosterModel(roster_);

chatWindow_->setTabComplete(completer_);

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

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

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

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

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

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_->onOccupantPresenceChange.connect(boost::bind(&MUCController::handleOccupantPresenceChange, this, _1));

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

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

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

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

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

highlighter_->setMode(Highlighter::MUCMode);

highlighter_->setNick(nick_);

if (timerFactory) {

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

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

loginCheckTimer_->start();

}

if (isImpromptu) {

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

} else {

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

}

setOnline(true);

if (avatarManager_ != NULL) {

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

}

handleBareJIDCapsChanged(muc->getJID());

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

}

MUCController::~MUCController() {

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

chatWindow_->setRosterModel(NULL);

delete rosterVCardProvider_;

delete roster_;

if (loginCheckTimer_) {

loginCheckTimer_->stop();

}

chatWindow_->setTabComplete(NULL);

delete completer_;

}

void MUCController::cancelReplaces() {

lastWasPresence_ = false;

}

void MUCController::handleWindowOccupantSelectionChanged(ContactRosterItem* item) {

std::vector<ChatWindow::OccupantAction> actions;

if (item) {

MUCOccupant::Affiliation affiliation = muc_->getOccupant(getNick()).getAffiliation();

MUCOccupant::Role role = muc_->getOccupant(getNick()).getRole();

{

if (affiliation == MUCOccupant::Admin || affiliation == MUCOccupant::Owner) {

actions.push_back(ChatWindow::Ban);

}

actions.push_back(ChatWindow::Kick);

actions.push_back(ChatWindow::MakeModerator);

actions.push_back(ChatWindow::MakeParticipant);

actions.push_back(ChatWindow::MakeVisitor);

}

// Add contact is available only if the real JID is also available

if (muc_->getOccupant(item->getJID().getResource()).getRealJID()) {

actions.push_back(ChatWindow::AddContact);

}

actions.push_back(ChatWindow::ShowProfile);

}

chatWindow_->setAvailableOccupantActions(actions);

}

void MUCController::handleActionRequestedOnOccupant(ChatWindow::OccupantAction action, ContactRosterItem* item) {

JID mucJID = item->getJID();

MUCOccupant occupant = muc_->getOccupant(mucJID.getResource());

JID realJID;

if (occupant.getRealJID()) {

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

}

switch (action) {

case ChatWindow::Kick: muc_->kickOccupant(mucJID);break;

case ChatWindow::Ban: muc_->changeAffiliation(realJID, MUCOccupant::Outcast);break;

case ChatWindow::MakeModerator: muc_->changeOccupantRole(mucJID, MUCOccupant::Moderator);break;

case ChatWindow::MakeParticipant: muc_->changeOccupantRole(mucJID, MUCOccupant::Participant);break;

case ChatWindow::MakeVisitor: muc_->changeOccupantRole(mucJID, MUCOccupant::Visitor);break;

case ChatWindow::AddContact: if (occupant.getRealJID()) events_->send(boost::make_shared<RequestAddUserDialogUIEvent>(realJID, occupant.getNick()));break;

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

}

default: break;

}

}

errorMessage = str(format(QT_TRANSLATE_NOOP("", "Couldn't join 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;

std::string joinMessage;

if (isImpromptu_) {

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

} else {

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

}

setNick(nick);

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

#ifdef SWIFT_EXPERIMENTAL_HISTORY

addRecentLogs();

#endif

clearPresenceQueue();

shouldJoinOnReconnect_ = true;

setEnabled(true);

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

parting_ = true;

shouldJoinOnReconnect_ = false;

muc_->part();

onUserLeft();

}

void MUCController::handleOccupantJoined(const MUCOccupant& occupant) {

if (nick_ != occupant.getNick()) {

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

}

receivedActivity();

JID jid(nickToJID(occupant.getNick()));

JID realJID;

if (occupant.getRealJID()) {

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

}

currentOccupants_.insert(occupant.getNick());

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

appendToJoinParts(joinParts_, event);

roster_->addContact(jid, realJID, occupant.getNick(), groupName, avatarManager_->getAvatarPath(jid));

if (joined_) {

std::string joinString;

if (role != MUCOccupant::NoRole && role != MUCOccupant::Participant) {

joinString = str(format(QT_TRANSLATE_NOOP("", "%1% has entered the %3% as a %2%.")) % occupant.getNick() % roleToFriendlyName(role) % (isImpromptu_ ? QT_TRANSLATE_NOOP("", "chat") : QT_TRANSLATE_NOOP("", "room")));

}

else {

joinString = str(format(QT_TRANSLATE_NOOP("", "%1% has entered the %2%.")) % occupant.getNick() % (isImpromptu_ ? QT_TRANSLATE_NOOP("", "chat") : QT_TRANSLATE_NOOP("", "room")));

}

if (shouldUpdateJoinParts()) {

updateJoinParts();

} else {

addPresenceMessage(joinString);

}

if (isImpromptu_) {

setImpromptuWindowTitle();

onActivity("");

}

}

if (avatarManager_ != NULL) {

handleAvatarChanged(jid);

}

}

void MUCController::addPresenceMessage(const std::string& message) {

lastWasPresence_ = true;

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

}

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

{

std::vector<ChatWindow::RoomAction> actions;

if (role <= MUCOccupant::Participant) {

actions.push_back(ChatWindow::ChangeSubject);

}