2 files changed, 2 insertions, 2 deletions
diff --git a/Swift/Controllers/Chat/ChatController.cpp b/Swift/Controllers/Chat/ChatController.cpp
index fd6da94..fb69366 100644
--- a/Swift/Controllers/Chat/ChatController.cpp
+++ b/Swift/Controllers/Chat/ChatController.cpp
@@ -154,71 +154,71 @@ void ChatController::setToJID(const JID& jid) {
 	}
 	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);
-	chatStateNotifier_->receivedMessageFromContact(message->getPayload<ChatState>());
+	chatStateNotifier_->receivedMessageFromContact(!!message->getPayload<ChatState>());
 
 	// 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) {
diff --git a/Swift/Controllers/Chat/ChatsManager.cpp b/Swift/Controllers/Chat/ChatsManager.cpp
index fef9039..919a3d6 100644
--- a/Swift/Controllers/Chat/ChatsManager.cpp
+++ b/Swift/Controllers/Chat/ChatsManager.cpp
@@ -766,71 +766,71 @@ MUC::ref ChatsManager::handleJoinMUCRequest(const JID &mucJID, const boost::opti
 		}
 
 		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 isInvite = message->getPayload<MUCInvitationPayload>();
+	bool isInvite = !!message->getPayload<MUCInvitationPayload>();
 	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);