2 files changed, 23 insertions, 5 deletions
diff --git a/Swift/Controllers/Chat/ChatController.cpp b/Swift/Controllers/Chat/ChatController.cpp
index 50d85a3..0b34681 100644
--- a/Swift/Controllers/Chat/ChatController.cpp
+++ b/Swift/Controllers/Chat/ChatController.cpp
@@ -215,87 +215,96 @@ void ChatController::preHandleIncomingMessage(boost::shared_ptr<MessageEvent> me
 			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) {
 	chatStateNotifier_->addChatStateRequest(message);
 	if (userWantsReceipts_ && (contactSupportsReceipts_ != ChatWindow::No) && message) {
 		message->addPayload(boost::make_shared<DeliveryReceiptRequest>());
 	}
 }
 
 void ChatController::setContactIsReceivingPresence(bool isReceivingPresence) {
 	receivingPresenceFromUs_ = isReceivingPresence;
 }
 
 void ChatController::handleSettingChanged(const std::string& settingPath) {
 	if (settingPath == SettingConstants::REQUEST_DELIVERYRECEIPTS.getKey()) {
 		userWantsReceipts_ = settings_->getSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS);
 		checkForDisplayingDisplayReceiptsAlert();
 	}
 }
 
 void ChatController::checkForDisplayingDisplayReceiptsAlert() {
+	boost::optional<ChatWindow::AlertID> newDeliverReceiptAlert;
 	if (userWantsReceipts_ && (contactSupportsReceipts_ == ChatWindow::No)) {
-		deliveryReceiptAlert_ = chatWindow_->addAlert(QT_TRANSLATE_NOOP("", "This chat doesn't support delivery receipts."));
+		newDeliverReceiptAlert = chatWindow_->addAlert(QT_TRANSLATE_NOOP("", "This chat doesn't support delivery receipts."));
 	} else if (userWantsReceipts_ && (contactSupportsReceipts_ == ChatWindow::Maybe)) {
-		deliveryReceiptAlert_ = chatWindow_->addAlert(QT_TRANSLATE_NOOP("", "This chat may not support delivery receipts. You might not receive delivery receipts for the messages you sent."));
+		newDeliverReceiptAlert = chatWindow_->addAlert(QT_TRANSLATE_NOOP("", "This chat may not support delivery receipts. You might not receive delivery receipts for the messages you sent."));
 	} else {
 		if (deliveryReceiptAlert_) {
 			chatWindow_->removeAlert(*deliveryReceiptAlert_);
 			deliveryReceiptAlert_.reset();
 		}
 	}
+	if (newDeliverReceiptAlert) {
+		if (deliveryReceiptAlert_) {
+			chatWindow_->removeAlert(*deliveryReceiptAlert_);
+		}
+		deliveryReceiptAlert_ = newDeliverReceiptAlert;
+	}
 }
 
 void ChatController::handleBlockingStateChanged() {
 	boost::shared_ptr<BlockList> blockList = clientBlockListManager_->getBlockList();
 	if (blockList->getState() == BlockList::Available) {
 		if (isInMUC_ ? blockList->isBlocked(toJID_) : blockList->isBlocked(toJID_.toBare())) {
-			blockedContactAlert_ = chatWindow_->addAlert(QT_TRANSLATE_NOOP("", "You've currently blocked this contact. To continue your conversation you have to unblock the contact first."));
+			if (!blockedContactAlert_) {
+				blockedContactAlert_ = chatWindow_->addAlert(QT_TRANSLATE_NOOP("", "You've currently blocked this contact. To continue your conversation you have to unblock the contact first."));
+			}
 			chatWindow_->setInputEnabled(false);
 			chatWindow_->setBlockingState(ChatWindow::IsBlocked);
 
 			// disconnect typing events to prevent chat state notifciations to blocked contacts
 			chatWindow_->onUserTyping.disconnect(boost::bind(&ChatStateNotifier::setUserIsTyping, chatStateNotifier_));
 			chatWindow_->onUserCancelsTyping.disconnect(boost::bind(&ChatStateNotifier::userCancelledNewMessage, chatStateNotifier_));
 		} else {
 			if (blockedContactAlert_) {
 				chatWindow_->removeAlert(*blockedContactAlert_);
 				blockedContactAlert_.reset();
 			}
 			chatWindow_->setInputEnabled(true);
 			chatWindow_->setBlockingState(ChatWindow::IsUnblocked);
 
 			chatWindow_->onUserTyping.connect(boost::bind(&ChatStateNotifier::setUserIsTyping, chatStateNotifier_));
 			chatWindow_->onUserCancelsTyping.connect(boost::bind(&ChatStateNotifier::userCancelledNewMessage, chatStateNotifier_));
 		}
 	}
 }
 
 void ChatController::handleBlockUserRequest() {
 	if (isInMUC_) {
 		eventStream_->send(boost::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Blocked, toJID_));
 	} else {
 		eventStream_->send(boost::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Blocked, toJID_.toBare()));
 	}
 }
 
 void ChatController::handleUnblockUserRequest() {
 	if (isInMUC_) {
 		eventStream_->send(boost::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Unblocked, toJID_));
 	} else {
 		eventStream_->send(boost::make_shared<RequestChangeBlockStateUIEvent>(RequestChangeBlockStateUIEvent::Unblocked, toJID_.toBare()));
 	}
 }
diff --git a/Swift/QtUI/QtChatWindow.cpp b/Swift/QtUI/QtChatWindow.cpp
index 6500ba4..ed79dcc 100644
--- a/Swift/QtUI/QtChatWindow.cpp
+++ b/Swift/QtUI/QtChatWindow.cpp
@@ -239,75 +239,84 @@ QtChatWindow::AlertID QtChatWindow::addAlert(const std::string& alertText) {
 void QtChatWindow::removeAlert(const AlertID id) {
 	std::map<AlertID, QWidget*>::iterator i = alertWidgets_.find(id);
 	if (i != alertWidgets_.end()) {
 		alertLayout_->removeWidget(i->second);
 		delete i->second;
 		alertWidgets_.erase(i);
 	}
 }
 
 void QtChatWindow::setTabComplete(TabComplete* completer) {
 	completer_ = completer;
 }
 
 void QtChatWindow::handleKeyPressEvent(QKeyEvent* event) {
 	event->ignore();
 	if (event->isAccepted()) {
 		return;
 	}
 	event->accept();
 
 	int key = event->key();
 	if (key == Qt::Key_Tab) {
 		tabComplete();
 	} else if ((key == Qt::Key_Up) && input_->toPlainText().isEmpty() && !(lastSentMessage_.isEmpty())) {
 		beginCorrection();
 	} else if (key == Qt::Key_Down && isCorrection_ && input_->textCursor().atBlockEnd()) {
 		cancelCorrection();
 	} else if (key == Qt::Key_Down || key == Qt::Key_Up) {
 		/* Drop */
 	} else {
 		messageLog_->handleKeyPressEvent(event);
 	}
 }
 
 void QtChatWindow::beginCorrection() {
+	boost::optional<AlertID> newCorrectingAlert;
 	if (correctionEnabled_ == ChatWindow::Maybe) {
-		correctingAlert_ = addAlert(Q2PSTRING(tr("This chat may not support message correction. If you send a correction anyway, it may appear as a duplicate message")));
+		newCorrectingAlert = addAlert(Q2PSTRING(tr("This chat may not support message correction. If you send a correction anyway, it may appear as a duplicate message")));
 	} else if (correctionEnabled_ == ChatWindow::No) {
-		correctingAlert_ = addAlert(Q2PSTRING(tr("This chat does not support message correction.  If you send a correction anyway, it will appear as a duplicate message")));
+		newCorrectingAlert = addAlert(Q2PSTRING(tr("This chat does not support message correction.  If you send a correction anyway, it will appear as a duplicate message")));
 	}
+
+	if (newCorrectingAlert) {
+		if (correctingAlert_) {
+			removeAlert(*correctingAlert_);
+		}
+		correctingAlert_ = newCorrectingAlert;
+	}
+
 	QTextCursor cursor = input_->textCursor();
 	cursor.select(QTextCursor::Document);
 	cursor.beginEditBlock();
 	cursor.insertText(QString(lastSentMessage_));
 	cursor.endEditBlock();
 	isCorrection_ = true;
 	correctingLabel_->show();
 	input_->setStyleSheet(alertStyleSheet_);
 	labelsWidget_->setEnabled(false);
 }
 
 void QtChatWindow::cancelCorrection() {
 	if (correctingAlert_) {
 		removeAlert(*correctingAlert_);
 		correctingAlert_.reset();
 	}
 	QTextCursor cursor = input_->textCursor();
 	cursor.select(QTextCursor::Document);
 	cursor.removeSelectedText();
 	isCorrection_ = false;
 	correctingLabel_->hide();
 	input_->setStyleSheet(qApp->styleSheet());
 	labelsWidget_->setEnabled(true);
 }
 
 QByteArray QtChatWindow::getSplitterState() {
 	return logRosterSplitter_->saveState();
 }
 
 void QtChatWindow::handleChangeSplitterState(QByteArray state) {
 	logRosterSplitter_->restoreState(state);
 }
 
 void QtChatWindow::handleSplitterMoved(int, int) {
 	emit splitterMoved();