if (!response.empty()) {

response = str(format(response) % nick);

}

if (!presence->getStatus().empty()) {

response += " (" + presence->getStatus() + ")";

}

return response + ".";

}

void ChatController::handlePresenceChange(boost::shared_ptr<Presence> newPresence) {

bool me = false;

if (toJID_.isBare()) {

newPresence = presenceOracle_->getHighestPriorityPresence(toJID_);

if ((newPresence ? newPresence->getShow() : StatusShow::None) != lastShownStatus_) {

me = true;

}

} else if (toJID_.equals(newPresence->getFrom(), JID::WithResource)) {

me = true;

}

if (!me) {

return;

}

if (!newPresence) {

newPresence = boost::make_shared<Presence>();

newPresence->setType(Presence::Unavailable);

}

lastShownStatus_ = newPresence->getShow();

chatStateTracker_->handlePresenceChange(newPresence);

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

std::string newStatusChangeString = getStatusChangeString(newPresence);

if (newStatusChangeString != lastStatusChangeString_) {

if (lastWasPresence_) {

} else {

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

}

lastStatusChangeString_ = newStatusChangeString;

lastWasPresence_ = true;

}

}

boost::optional<boost::posix_time::ptime> ChatController::getMessageTimestamp(boost::shared_ptr<Message> message) const {

return message->getTimestamp();

}

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

}

}

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

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

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

}

parting_ = true;

processUserPart();

}

if (clearAfter) {

clearPresenceQueue();

}

if (isImpromptu_) {

setImpromptuWindowTitle();

}

}

void MUCController::handleOccupantPresenceChange(boost::shared_ptr<Presence> presence) {

receivedActivity();

roster_->applyOnItems(SetPresence(presence, JID::WithResource));

}

bool MUCController::isIncomingMessageFromMe(boost::shared_ptr<Message> message) {

JID from = message->getFrom();

return nick_ == from.getResource();

}

std::string MUCController::senderDisplayNameFromMessage(const JID& from) {

return from.getResource();

}

void MUCController::preSendMessageRequest(boost::shared_ptr<Message> message) {

message->setType(Swift::Message::Groupchat);

}

boost::optional<boost::posix_time::ptime> MUCController::getMessageTimestamp(boost::shared_ptr<Message> message) const {

return message->getTimestampFrom(toJID_);

}

void MUCController::updateJoinParts() {

}

void MUCController::appendToJoinParts(std::vector<NickJoinPart>& joinParts, const NickJoinPart& newEvent) {

std::vector<NickJoinPart>::iterator it = joinParts.begin();

bool matched = false;

for (; it != joinParts.end(); ++it) {

if ((*it).nick == newEvent.nick) {

matched = true;

JoinPart type = (*it).type;

switch (newEvent.type) {

case Join: type = (type == Part) ? PartThenJoin : Join; break;

case Part: type = (type == Join) ? JoinThenPart : Part; break;

case PartThenJoin: break;

case JoinThenPart: break;

}

(*it).type = type;

break;

}

}

if (!matched) {

joinParts.push_back(newEvent);

}

}

std::string MUCController::concatenateListOfNames(const std::vector<NickJoinPart>& joinParts) {

std::string result;

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

if (i > 0) {

if (i < joinParts.size() - 1) {

result += ", ";

} else {

result += QT_TRANSLATE_NOOP("", " and ");

}

}

NickJoinPart event = joinParts[i];