path = avatarManager_->getAvatarPath(jid);

}

Presence::ref presence = presenceOracle_->getHighestPriorityPresence(jid.toBare());

type = presence ? presence->getShow() : StatusShow::None;

}

ChatListWindow::Chat chat(jid, nickResolver_->jidToNick(jid), activity, 0, type, path, isMUC, nick);

prependRecent(chat);

}

handleUnreadCountChanged(NULL);

}

void ChatsManager::setupBookmarks() {

if (!mucBookmarkManager_) {

mucBookmarkManager_ = new MUCBookmarkManager(iqRouter_);

mucBookmarkManager_->onBookmarksReady.connect(boost::bind(&ChatsManager::handleBookmarksReady, this));

mucBookmarkManager_->onBookmarkAdded.connect(boost::bind(&ChatsManager::handleMUCBookmarkAdded, this, _1));

mucBookmarkManager_->onBookmarkRemoved.connect(boost::bind(&ChatsManager::handleMUCBookmarkRemoved, this, _1));

if (chatListWindow_) {

chatListWindow_->setBookmarksEnabled(false);

chatListWindow_->clearBookmarks();

}

}

}

void ChatsManager::handleBookmarksReady() {

if (chatListWindow_) {

chatListWindow_->setBookmarksEnabled(true);

}

}

void ChatsManager::handleMUCBookmarkAdded(const MUCBookmark& bookmark) {

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

if (it == mucControllers_.end() && bookmark.getAutojoin()) {

handleJoinMUCRequest(bookmark.getRoom(), bookmark.getPassword(), bookmark.getNick(), false, false);

}

chatListWindow_->addMUCBookmark(bookmark);

}

void ChatsManager::handleMUCBookmarkRemoved(const MUCBookmark& bookmark) {

chatListWindow_->removeMUCBookmark(bookmark);

}

ChatListWindow::Chat ChatsManager::createChatListChatItem(const JID& jid, const std::string& activity) {

int unreadCount = 0;

if (mucRegistry_->isMUC(jid)) {

MUCController* controller = mucControllers_[jid.toBare()];

StatusShow::Type type = StatusShow::None;

std::string nick = "";

if (controller) {

unreadCount = controller->getUnreadCount();

if (controller->isJoined()) {

type = StatusShow::Online;

}

nick = controller->getNick();

}

return ChatListWindow::Chat(jid, jid.toString(), activity, unreadCount, type, boost::filesystem::path(), true, nick);

} else {

ChatController* controller = getChatControllerIfExists(jid, false);

if (controller) {

unreadCount = controller->getUnreadCount();

}

JID bareishJID = mucRegistry_->isMUC(jid.toBare()) ? jid : jid.toBare();

Presence::ref presence = presenceOracle_->getHighestPriorityPresence(bareishJID);

StatusShow::Type type = presence ? presence->getShow() : StatusShow::None;

boost::filesystem::path avatarPath = avatarManager_ ? avatarManager_->getAvatarPath(bareishJID) : boost::filesystem::path();

return ChatListWindow::Chat(bareishJID, nickResolver_->jidToNick(bareishJID), activity, unreadCount, type, avatarPath, false);

}

if (rebindIfNeeded) {

rebindControllerJID(pair.first, contact);

return chatControllers_[contact];

} else {

return pair.second;

}

}

}

return NULL;

}

}

return chatControllers_[contact];

}

void ChatsManager::rebindControllerJID(const JID& from, const JID& to) {

chatControllers_[to] = chatControllers_[from];

chatControllers_.erase(from);

chatControllers_[to]->setToJID(to);

}

void ChatsManager::handleJoinMUCRequest(const JID &mucJID, const boost::optional<std::string>& password, const boost::optional<std::string>& nickMaybe, bool addAutoJoin, bool createAsReservedIfNew) {

if (addAutoJoin) {

MUCBookmark bookmark(mucJID, mucJID.getNode());

bookmark.setAutojoin(true);

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 {

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

bool isInvite = message->getPayload<MUCInvitationPayload>();

if (!event->isReadable() && !message->getPayload<ChatState>() && !isInvite && !message->hasSubject()) {

return;

}

// Try to deliver it to a MUC

if (message->getType() == Message::Groupchat || message->getType() == Message::Error || (isInvite && message->getType() == Message::Normal)) {

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

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

i->second->handleIncomingMessage(event);

return;