}

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

handleBareJIDCapsChanged(toJID_);

}

void ChatController::setAvailableServerFeatures(boost::shared_ptr<DiscoInfo> info) {

ChatControllerBase::setAvailableServerFeatures(info);

if (iqRouter_->isAvailable() && info->hasFeature(DiscoInfo::BlockingCommandFeature)) {

boost::shared_ptr<BlockList> blockList = clientBlockListManager_->getBlockList();

blockingOnStateChangedConnection_ = blockList->onStateChanged.connect(boost::bind(&ChatController::handleBlockingStateChanged, this));

blockingOnItemAddedConnection_ = blockList->onItemAdded.connect(boost::bind(&ChatController::handleBlockingItemAdded, this, _1));

blockingOnItemRemovedConnection_ = blockList->onItemRemoved.connect(boost::bind(&ChatController::handleBlockingItemRemoved, this, _1));

handleBlockingStateChanged();

}

}

bool ChatController::isIncomingMessageFromMe(boost::shared_ptr<Message>) {

return false;

}

void ChatController::preHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent) {

if (messageEvent->isReadable()) {

chatWindow_->flash();

lastWasPresence_ = false;

}

boost::shared_ptr<Message> message = messageEvent->getStanza();

JID from = message->getFrom();

if (!from.equals(toJID_, JID::WithResource)) {

if (toJID_.equals(from, JID::WithoutResource) && toJID_.isBare()){

setToJID(from);

}

}

chatStateTracker_->handleMessageReceived(message);

// handle XEP-0184 Message Receipts

// incomming receipts

if (boost::shared_ptr<DeliveryReceipt> receipt = message->getPayload<DeliveryReceipt>()) {

SWIFT_LOG(debug) << "received receipt for id: " << receipt->getReceivedID() << std::endl;

if (requestedReceipts_.find(receipt->getReceivedID()) != requestedReceipts_.end()) {

chatWindow_->setMessageReceiptState(requestedReceipts_[receipt->getReceivedID()], ChatWindow::ReceiptReceived);

requestedReceipts_.erase(receipt->getReceivedID());

}

// incomming errors in response to send out receipts

} else if (message->getPayload<DeliveryReceiptRequest>() && (message->getType() == Message::Error)) {

if (requestedReceipts_.find(message->getID()) != requestedReceipts_.end()) {

chatWindow_->setMessageReceiptState(requestedReceipts_[message->getID()], ChatWindow::ReceiptFailed);

requestedReceipts_.erase(message->getID());

}

// incoming receipt requests

} else if (message->getPayload<DeliveryReceiptRequest>()) {

if (receivingPresenceFromUs_) {

boost::shared_ptr<Message> receiptMessage = boost::make_shared<Message>();

receiptMessage->setTo(toJID_);

receiptMessage->addPayload(boost::make_shared<DeliveryReceipt>(message->getID()));

stanzaChannel_->sendMessage(receiptMessage);

}

}

}

void ChatController::postHandleIncomingMessage(boost::shared_ptr<MessageEvent> messageEvent, const HighlightAction& highlight) {

eventController_->handleIncomingEvent(messageEvent);

if (!messageEvent->getConcluded()) {

highlighter_->handleHighlightAction(highlight);

}

}

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

}

MUCController* controller = NULL;

SingleChatWindowFactoryAdapter* chatWindowFactoryAdapter = NULL;

if (reuseChatwindow) {

chatWindowFactoryAdapter = new SingleChatWindowFactoryAdapter(reuseChatwindow);

}

controller = new MUCController(jid_, muc, password, nick, stanzaChannel_, iqRouter_, reuseChatwindow ? chatWindowFactoryAdapter : chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory_, eventController_, entityCapsProvider_, roster_, historyController_, mucRegistry_, highlightManager_, chatMessageParser_, isImpromptu, autoAcceptMUCInviteDecider_, vcardManager_);

if (chatWindowFactoryAdapter) {

/* The adapters are only passed to chat windows, which are deleted in their

* controllers' dtor, which are deleted in ChatManager's dtor. The adapters

* are also deleted there.*/

chatWindowFactoryAdapters_[controller] = chatWindowFactoryAdapter;

}

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

return muc;

}

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 isMediatedInvite = (message->getPayload<MUCUserPayload>() && message->getPayload<MUCUserPayload>()->getInvite());

if (isMediatedInvite) {

jid = (*message->getPayload<MUCUserPayload>()->getInvite()).from;

}

if (!event->isReadable() && !message->getPayload<ChatState>() && !message->getPayload<DeliveryReceipt>() && !message->getPayload<DeliveryReceiptRequest>() && !isInvite && !isMediatedInvite && !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;

}

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

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

return;

}

}

// check for impromptu invite to potentially auto-accept

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

if (invite && autoAcceptMUCInviteDecider_->isAutoAcceptedInvite(message->getFrom(), invite)) {

if (invite->getIsContinuation()) {

// check for existing chat controller for the from JID

ChatController* controller = getChatControllerIfExists(jid);

if (controller) {

ChatWindow* window = controller->detachChatWindow();

chatControllers_.erase(jid);

delete controller;

handleJoinMUCRequest(invite->getJID(), boost::optional<std::string>(), boost::optional<std::string>(), false, false, true, window);

}

} else {

handleJoinMUCRequest(invite->getJID(), boost::optional<std::string>(), boost::optional<std::string>(), false, false, true);