switch (error->getCondition()) {

case ErrorPayload::BadRequest: return QT_TRANSLATE_NOOP("", "Bad request"); break;

case ErrorPayload::Conflict: return QT_TRANSLATE_NOOP("", "Conflict"); break;

case ErrorPayload::FeatureNotImplemented: return QT_TRANSLATE_NOOP("", "This feature is not implemented"); break;

case ErrorPayload::Forbidden: return QT_TRANSLATE_NOOP("", "Forbidden"); break;

case ErrorPayload::Gone: return QT_TRANSLATE_NOOP("", "Recipient can no longer be contacted"); break;

case ErrorPayload::InternalServerError: return QT_TRANSLATE_NOOP("", "Internal server error"); break;

case ErrorPayload::ItemNotFound: return QT_TRANSLATE_NOOP("", "Item not found"); break;

case ErrorPayload::JIDMalformed: return QT_TRANSLATE_NOOP("", "JID Malformed"); break;

case ErrorPayload::NotAcceptable: return QT_TRANSLATE_NOOP("", "Message was rejected"); break;

case ErrorPayload::NotAllowed: return QT_TRANSLATE_NOOP("", "Not allowed"); break;

case ErrorPayload::NotAuthorized: return QT_TRANSLATE_NOOP("", "Not authorized"); break;

case ErrorPayload::PaymentRequired: return QT_TRANSLATE_NOOP("", "Payment is required"); break;

case ErrorPayload::RecipientUnavailable: return QT_TRANSLATE_NOOP("", "Recipient is unavailable"); break;

case ErrorPayload::Redirect: return QT_TRANSLATE_NOOP("", "Redirect"); break;

case ErrorPayload::RegistrationRequired: return QT_TRANSLATE_NOOP("", "Registration required"); break;

case ErrorPayload::RemoteServerNotFound: return QT_TRANSLATE_NOOP("", "Recipient's server not found"); break;

case ErrorPayload::RemoteServerTimeout: return QT_TRANSLATE_NOOP("", "Remote server timeout"); break;

case ErrorPayload::ResourceConstraint: return QT_TRANSLATE_NOOP("", "The server is low on resources"); break;

case ErrorPayload::ServiceUnavailable: return QT_TRANSLATE_NOOP("", "The service is unavailable"); break;

case ErrorPayload::SubscriptionRequired: return QT_TRANSLATE_NOOP("", "A subscription is required"); break;

case ErrorPayload::UndefinedCondition: return QT_TRANSLATE_NOOP("", "Undefined condition"); break;

case ErrorPayload::UnexpectedRequest: return QT_TRANSLATE_NOOP("", "Unexpected request"); break;

}

}

return defaultMessage;

}

void ChatControllerBase::handleMUCInvitation(Message::ref message) {

MUCInvitationPayload::ref invite = message->getPayload<MUCInvitationPayload>();

chatWindow_->addMUCInvitation(invite->getJID(), invite->getReason(), invite->getPassword());

}

void ChatControllerBase::handleMediatedMUCInvitation(Message::ref message) {

MUCUserPayload::Invite invite = *message->getPayload<MUCUserPayload>()->getInvite();

std::string reason;

if (!invite.reason.empty()) {

reason = invite.reason;

}

std::string password;

if (message->getPayload<MUCUserPayload>()->getPassword()) {

password = *message->getPayload<MUCUserPayload>()->getPassword();

}

chatWindow_->addMUCInvitation(from, reason, password, false);

}

}

if (nickMaybe) {

bookmark.setNick(*nickMaybe);

}

mucBookmarkManager_->addBookmark(bookmark);

}

std::map<JID, MUCController*>::iterator it = mucControllers_.find(mucJID);

if (it != mucControllers_.end()) {

it->second->rejoin();

} else {

std::string nick = (nickMaybe && !(*nickMaybe).empty()) ? nickMaybe.get() : nickResolver_->jidToNick(jid_);

MUC::ref muc = mucManager->createMUC(mucJID);

if (createAsReservedIfNew) {

muc->setCreateAsReservedIfNew();

}

MUCController* controller = new MUCController(jid_, muc, password, nick, stanzaChannel_, iqRouter_, chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_);

mucControllers_[mucJID] = controller;

controller->setAvailableServerFeatures(serverDiscoInfo_);

controller->onUserLeft.connect(boost::bind(&ChatsManager::handleUserLeftMUC, this, controller));

controller->onUserJoined.connect(boost::bind(&ChatsManager::handleChatActivity, this, mucJID.toBare(), "", true));

controller->onActivity.connect(boost::bind(&ChatsManager::handleChatActivity, this, mucJID.toBare(), _1, true));

controller->onUnreadCountChanged.connect(boost::bind(&ChatsManager::handleUnreadCountChanged, this, controller));

handleChatActivity(mucJID.toBare(), "", true);

}

mucControllers_[mucJID]->showChatWindow();

}

void ChatsManager::handleSearchMUCRequest() {

mucSearchController_->openSearchWindow();

}

void ChatsManager::handleIncomingMessage(boost::shared_ptr<Message> message) {

JID jid = message->getFrom();

boost::shared_ptr<MessageEvent> event(new MessageEvent(message));

return;

}

// Try to deliver it to a MUC

std::map<JID, MUCController*>::iterator i = mucControllers_.find(jid.toBare());

if (i != mucControllers_.end()) {

i->second->handleIncomingMessage(event);

return;

}

else if (message->getType() == Message::Groupchat) {

//FIXME: Error handling - groupchat messages from an unknown muc.

return;

}

}

//if not a mucroom

getChatControllerOrCreate(jid)->handleIncomingMessage(event);

}

void ChatsManager::handleMUCSelectedAfterSearch(const JID& muc) {

if (joinMUCWindow_) {

joinMUCWindow_->setMUC(muc.toString());

}

}

void ChatsManager::handleMUCBookmarkActivated(const MUCBookmark& mucBookmark) {

uiEventStream_->send(boost::make_shared<JoinMUCUIEvent>(mucBookmark.getRoom(), mucBookmark.getPassword(), mucBookmark.getNick()));

}

void ChatsManager::handleNewFileTransferController(FileTransferController* ftc) {

ChatController* chatController = getChatControllerOrCreate(ftc->getOtherParty());

chatController->handleNewFileTransferController(ftc);

chatController->activateChatWindow();

}

void ChatsManager::handleRecentActivated(const ChatListWindow::Chat& chat) {

if (chat.isMUC) {

/* FIXME: This means that recents requiring passwords will just flat-out not work */

uiEventStream_->send(boost::make_shared<JoinMUCUIEvent>(chat.jid, boost::optional<std::string>(), chat.nick));