break;

case ErrorPayload::Forbidden:

errorMessage += ": ";

errorMessage += QT_TRANSLATE_NOOP("", "You are banned from the room");

break;

case ErrorPayload::ServiceUnavailable:

errorMessage += ": ";

errorMessage += QT_TRANSLATE_NOOP("", "The room is full");

break;

case ErrorPayload::ItemNotFound:

errorMessage += ": ";

errorMessage += QT_TRANSLATE_NOOP("", "The room does not exist");

break;

default: break;

}

}

errorMessage = str(format(QT_TRANSLATE_NOOP("", "Couldn't 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_) {

} else {

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

}

setNick(nick);

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

parting_ = true;

shouldJoinOnReconnect_ = false;

muc_->part();

onUserLeft();

}

setAvailableRoomActions(occupant.getAffiliation(), occupant.getRole());

}

}

void MUCController::handleOccupantAffiliationChanged(const std::string& nick, const MUCOccupant::Affiliation& affiliation, const MUCOccupant::Affiliation& /*oldAffiliation*/)

{

if (nick == nick_) {

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

}

JID jid(nickToJID(nick));

MUCOccupant occupant = muc_->getOccupant(nick);

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

}

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

if (isImpromptu_) {

} else {

chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "Trying to enter room %1%")) % toJID_.toString())), ChatWindow::DefaultDirection);

}

if (loginCheckTimer_) {

loginCheckTimer_->start();

}

setNick(desiredNick_);

rejoin();

}

}

}

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

std::string partMessage;

bool clearAfter = false;

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

std::string partType;

switch (type) {

case MUC::LeaveKick: clearPresenceQueue(); clearAfter = true; partType = " (kicked)"; break;

case MUC::LeaveBan: clearPresenceQueue(); clearAfter = true; partType = " (banned)"; break;

case MUC::LeaveNotMember: clearPresenceQueue(); clearAfter = true; partType = " (no longer a member)"; break;

case MUC::LeaveDestroy:

case MUC::Disconnect:

case MUC::LeavePart: break;

}

}

else {

switch (type) {

case MUC::LeaveKick: clearPresenceQueue(); clearAfter = true; partMessage = QT_TRANSLATE_NOOP("", "You have been kicked out of the room"); break;

case MUC::LeaveBan: clearPresenceQueue(); clearAfter = true; partMessage = QT_TRANSLATE_NOOP("", "You have been banned from the room"); break;

case MUC::LeaveNotMember: clearPresenceQueue(); clearAfter = true; partMessage = QT_TRANSLATE_NOOP("", "You are no longer a member of the room and have been removed"); break;

case MUC::LeaveDestroy: clearPresenceQueue(); clearAfter = true; partMessage = QT_TRANSLATE_NOOP("", "The room has been destroyed"); break;

case MUC::Disconnect:

case MUC::LeavePart: partMessage = QT_TRANSLATE_NOOP("", "You have left the room");

}

}

if (!reason.empty()) {

partMessage += " (" + reason + ")";

}

partMessage += ".";

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

if (shouldUpdateJoinParts()) {

updateJoinParts();

} else {

addPresenceMessage(partMessage);

}

roster_->removeContact(JID(toJID_.getNode(), toJID_.getDomain(), occupant.getNick()));

} else {

addPresenceMessage(partMessage);

parting_ = true;

processUserPart();

}

if (clearAfter) {

clearPresenceQueue();

}

if (isImpromptu_) {

setImpromptuWindowTitle();

}