6 files changed, 70 insertions, 57 deletions
diff --git a/Swift/Controllers/Chat/ChatController.cpp b/Swift/Controllers/Chat/ChatController.cpp
index 9b65c9f..786b4e9 100644
--- a/Swift/Controllers/Chat/ChatController.cpp
+++ b/Swift/Controllers/Chat/ChatController.cpp
@@ -163,20 +163,20 @@ void ChatController::setToJID(const JID& jid) {
 	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));
+		blockingOnItemAddedConnection_ = blockList->onItemAdded.connect(boost::bind(&ChatController::handleBlockingStateChanged, this));
+		blockingOnItemRemovedConnection_ = blockList->onItemRemoved.connect(boost::bind(&ChatController::handleBlockingStateChanged, this));
 
 		handleBlockingStateChanged();
 	}
 }
 
 bool ChatController::isIncomingMessageFromMe(boost::shared_ptr<Message>) {
 	return false;
 }
 
@@ -242,56 +242,47 @@ void ChatController::setContactIsReceivingPresence(bool isReceivingPresence) {
 void ChatController::handleSettingChanged(const std::string& settingPath) {
 	if (settingPath == SettingConstants::REQUEST_DELIVERYRECEIPTS.getKey()) {
 		userWantsReceipts_ = settings_->getSetting(SettingConstants::REQUEST_DELIVERYRECEIPTS);
 		checkForDisplayingDisplayReceiptsAlert();
 	}
 }
 
 void ChatController::checkForDisplayingDisplayReceiptsAlert() {
 	if (userWantsReceipts_ && (contactSupportsReceipts_ == ChatWindow::No)) {
-		chatWindow_->setAlert(QT_TRANSLATE_NOOP("", "This chat doesn't support delivery receipts."));
+		deliveryReceiptAlert_ = chatWindow_->addAlert(QT_TRANSLATE_NOOP("", "This chat doesn't support delivery receipts."));
 	} else if (userWantsReceipts_ && (contactSupportsReceipts_ == ChatWindow::Maybe)) {
-		chatWindow_->setAlert(QT_TRANSLATE_NOOP("", "This chat may not support delivery receipts. You might not receive delivery receipts for the messages you sent."));
+		deliveryReceiptAlert_ = chatWindow_->addAlert(QT_TRANSLATE_NOOP("", "This chat may not support delivery receipts. You might not receive delivery receipts for the messages you sent."));
 	} else {
-		chatWindow_->cancelAlert();
+		if (deliveryReceiptAlert_) {
+			chatWindow_->removeAlert(*deliveryReceiptAlert_);
+			deliveryReceiptAlert_.reset();
+		}
 	}
 }
 
 void ChatController::handleBlockingStateChanged() {
 	boost::shared_ptr<BlockList> blockList = clientBlockListManager_->getBlockList();
 	if (blockList->getState() == BlockList::Available) {
 		if (isInMUC_ ? blockList->isBlocked(toJID_) : blockList->isBlocked(toJID_.toBare())) {
-			chatWindow_->setAlert(QT_TRANSLATE_NOOP("", "You've currently blocked this contact. To continue your conversation you have to unblock the contact first."));
+			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);
 		} else {
+			if (blockedContactAlert_) {
+				chatWindow_->removeAlert(*blockedContactAlert_);
+				blockedContactAlert_.reset();
+			}
+			chatWindow_->setInputEnabled(true);
 			chatWindow_->setBlockingState(ChatWindow::IsUnblocked);
 		}
 	}
 }
 
-void ChatController::handleBlockingItemAdded(const JID& jid) {
-	if (toJID_ == (isInMUC_ ? jid: jid.toBare())) {
-		chatWindow_->setAlert(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);
-	}
-}
-
-void ChatController::handleBlockingItemRemoved(const JID& jid) {
-	if (toJID_ == (isInMUC_ ? jid: jid.toBare())) {
-		// FIXME: Support for different types of alerts.
-		chatWindow_->cancelAlert();
-		chatWindow_->setInputEnabled(true);
-		chatWindow_->setBlockingState(ChatWindow::IsUnblocked);
-	}
-}
-
 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() {
diff --git a/Swift/Controllers/Chat/ChatController.h b/Swift/Controllers/Chat/ChatController.h
index 2e92be7..998b437 100644
--- a/Swift/Controllers/Chat/ChatController.h
+++ b/Swift/Controllers/Chat/ChatController.h
@@ -66,21 +66,18 @@ namespace Swift {
 
 			void handleWhiteboardSessionAccept();
 			void handleWhiteboardSessionCancel();
 			void handleWhiteboardWindowShow();
 
 			void handleSettingChanged(const std::string& settingPath);
 			void checkForDisplayingDisplayReceiptsAlert();
 
 			void handleBlockingStateChanged();
-			void handleBlockingItemAdded(const JID&);
-			void handleBlockingItemRemoved(const JID&);
-
 			void handleBlockUserRequest();
 			void handleUnblockUserRequest();
 
 			void handleInviteToChat(const std::vector<JID>& droppedJIDs);
 
 			void handleWindowClosed();
 
 			void handleUIEvent(boost::shared_ptr<UIEvent> event);
 
@@ -102,12 +99,15 @@ namespace Swift {
 			bool userWantsReceipts_;
 			std::map<std::string, FileTransferController*> ftControllers;
 			SettingsProvider* settings_;
 			std::string lastWbID_;
 
 			ClientBlockListManager* clientBlockListManager_;
 			boost::bsignals::scoped_connection blockingOnStateChangedConnection_;
 			boost::bsignals::scoped_connection blockingOnItemAddedConnection_;
 			boost::bsignals::scoped_connection blockingOnItemRemovedConnection_;
+
+			boost::optional<ChatWindow::AlertID> deliveryReceiptAlert_;
+			boost::optional<ChatWindow::AlertID> blockedContactAlert_;
 	};
 }
 
diff --git a/Swift/Controllers/UIInterfaces/ChatWindow.h b/Swift/Controllers/UIInterfaces/ChatWindow.h
index 81d26c8..f2f5f76 100644
--- a/Swift/Controllers/UIInterfaces/ChatWindow.h
+++ b/Swift/Controllers/UIInterfaces/ChatWindow.h
@@ -147,28 +147,35 @@ namespace Swift {
 			virtual void replaceLastMessage(const ChatMessage& message, const TimestampBehaviour timestampBehaviour) = 0;
 			virtual void setAckState(const std::string& id, AckState state) = 0;
 			virtual void flash() = 0;
 			virtual void setSubject(const std::string& subject) = 0;
 			virtual void setAffiliations(MUCOccupant::Affiliation, const std::vector<JID>&) = 0;
 			virtual void setAvailableRoomActions(const std::vector<RoomAction> &actions) = 0;
 			virtual void setBlockingState(BlockingState state) = 0;
 			virtual void setCanInitiateImpromptuChats(bool supportsImpromptu) = 0;
 			virtual void showBookmarkWindow(const MUCBookmark& bookmark) = 0;
+
+			/**
+			 * A handle that uniquely identities an alert message.
+			 */
+			typedef int AlertID;
 			/**
 			 * Set an alert on the window.
 			 * @param alertText Description of alert (required).
 			 * @param buttonText Button text to use (optional, no button is shown if empty).
+			 * @return A handle to the alert message.
 			 */
-			virtual void setAlert(const std::string& alertText, const std::string& buttonText = "") = 0;
+			virtual AlertID addAlert(const std::string& alertText, const std::string& buttonText = "") = 0;
 			/**
 			 * Removes an alert.
+			 * @param id An alert ID previously returned from setAlert
 			 */
-			virtual void cancelAlert() = 0;
+			virtual void removeAlert(const AlertID id) = 0;
 
 			/**
 			 * Actions that can be performed on the selected occupant.
 			 */
 			virtual void setAvailableOccupantActions(const std::vector<OccupantAction>& actions) = 0;
 
 			/**
 			 * A room configuration has been requested, show the form.
 			 * If the form is cancelled, must emit onConfigurationFormCancelled().
diff --git a/Swift/Controllers/UnitTest/MockChatWindow.h b/Swift/Controllers/UnitTest/MockChatWindow.h
index 5e6606b..ef7216b 100644
--- a/Swift/Controllers/UnitTest/MockChatWindow.h
+++ b/Swift/Controllers/UnitTest/MockChatWindow.h
@@ -50,20 +50,20 @@ namespace Swift {
 			virtual void setSecurityLabelsError() {}
 			virtual SecurityLabelsCatalog::Item getSelectedSecurityLabel() {return label_;}
 			virtual void setInputEnabled(bool /*enabled*/) {}
 			virtual void setRosterModel(Roster* roster) { roster_ = roster; }
 			Roster* getRosterModel() { return roster_; }
 			virtual void setTabComplete(TabComplete*) {}
 
 			void setAckState(const std::string& /*id*/, AckState /*state*/) {}
 			virtual void flash() {}
-			virtual void setAlert(const std::string& /*alertText*/, const std::string& /*buttonText*/) {}
-			virtual void cancelAlert() {}
+			virtual AlertID addAlert(const std::string& /*alertText*/, const std::string& /*buttonText*/) { return 0; }
+			virtual void removeAlert(const AlertID /*id*/) {}
 			virtual void setCorrectionEnabled(Tristate /*enabled*/) {}
 			virtual void setFileTransferEnabled(Tristate /*enabled*/) {}
 			void setAvailableOccupantActions(const std::vector<OccupantAction>&/* actions*/) {}
 			void setSubject(const std::string& /*subject*/) {}
 			virtual void showRoomConfigurationForm(Form::ref) {}
 			virtual void addMUCInvitation(const std::string& /*senderName*/, const JID& /*jid*/, const std::string& /*reason*/, const std::string& /*password*/, bool = true, bool = false, bool = false) {}
 
 			virtual std::string addWhiteboardRequest(bool) {return "";}
 			virtual void setWhiteboardSessionStatus(std::string, const ChatWindow::WhiteboardSessionState){}
diff --git a/Swift/QtUI/QtChatWindow.cpp b/Swift/QtUI/QtChatWindow.cpp
index 47eeac0..574a0a2 100644
--- a/Swift/QtUI/QtChatWindow.cpp
+++ b/Swift/QtUI/QtChatWindow.cpp
@@ -51,19 +51,19 @@
 #include <Swift/QtUI/QtSettingsProvider.h>
 #include <Swift/QtUI/QtScaledAvatarCache.h>
 #include <Swift/QtUI/QtTextEdit.h>
 #include <Swift/QtUI/QtUISettingConstants.h>
 #include <Swift/QtUI/QtUtilities.h>
 #include <Swift/QtUI/QtWebKitChatView.h>
 
 namespace Swift {
 
-QtChatWindow::QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventStream* eventStream, SettingsProvider* settings) : QtTabbable(), contact_(contact), eventStream_(eventStream), blockingState_(BlockingUnsupported), isMUC_(false), supportsImpromptuChat_(false) {
+QtChatWindow::QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventStream* eventStream, SettingsProvider* settings) : QtTabbable(), contact_(contact), nextAlertId_(0), eventStream_(eventStream), blockingState_(BlockingUnsupported), isMUC_(false), supportsImpromptuChat_(false) {
 	settings_ = settings;
 	unreadCount_ = 0;
 	inputEnabled_ = true;
 	completer_ = NULL;
 	affiliationEditor_ = NULL;
 	theme_ = theme;
 	isCorrection_ = false;
 	labelModel_ = NULL;
 	correctionEnabled_ = Maybe;
@@ -74,32 +74,20 @@ QtChatWindow::QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventSt
 	setAcceptDrops(true);
 #endif
 
 	alertStyleSheet_ = "background: rgb(255, 255, 153); color: black";
 
 	QBoxLayout *layout = new QBoxLayout(QBoxLayout::TopToBottom, this);
 	layout->setContentsMargins(0,0,0,0);
 	layout->setSpacing(2);
 
-	alertWidget_ = new QWidget(this);
-	QHBoxLayout* alertLayout = new QHBoxLayout(alertWidget_);
-	layout->addWidget(alertWidget_);
-	alertLabel_ = new QLabel(this);
-	alertLayout->addWidget(alertLabel_);
-	alertButton_ = new QPushButton(this);
-	connect (alertButton_, SIGNAL(clicked()), this, SLOT(handleAlertButtonClicked()));
-	alertLayout->addWidget(alertButton_);
-	QPalette palette = alertWidget_->palette();
-	palette.setColor(QPalette::Window, QColor(Qt::yellow));
-	palette.setColor(QPalette::WindowText, QColor(Qt::black));
-	alertWidget_->setStyleSheet(alertStyleSheet_);
-	alertLabel_->setStyleSheet(alertStyleSheet_);
-	alertWidget_->hide();
+	alertLayout_ = new QVBoxLayout(this);
+	layout->addLayout(alertLayout_);
 
 	subjectLayout_ = new QBoxLayout(QBoxLayout::LeftToRight);
 	subject_ = new QLineEdit(this);
 	subjectLayout_->addWidget(subject_);
 	setSubject("");
 	subject_->setReadOnly(true);
 
 	QPushButton* actionButton_ = new QPushButton(this);
 	actionButton_->setIcon(QIcon(":/icons/actions.png"));
@@ -208,31 +196,53 @@ void QtChatWindow::handleOccupantSelectionChanged(RosterItem* item) {
 
 void QtChatWindow::handleFontResized(int fontSizeSteps) {
 	messageLog_->resizeFont(fontSizeSteps);
 }
 
 void QtChatWindow::handleAlertButtonClicked() {
 	onAlertButtonClicked();
 }
 
-void QtChatWindow::setAlert(const std::string& alertText, const std::string& buttonText) {
-	alertLabel_->setText(alertText.c_str());
+QtChatWindow::AlertID QtChatWindow::addAlert(const std::string& alertText, const std::string& buttonText) {
+	QWidget* alertWidget = new QWidget(this);
+	QHBoxLayout* alertLayout = new QHBoxLayout(alertWidget);
+	alertLayout_->addWidget(alertWidget);
+	QLabel* alertLabel = new QLabel(this);
+	alertLayout->addWidget(alertLabel);
+	alertButton_ = new QPushButton(this);
+	connect (alertButton_, SIGNAL(clicked()), this, SLOT(handleAlertButtonClicked()));
+	alertLayout->addWidget(alertButton_);
+	QPalette palette = alertWidget->palette();
+	palette.setColor(QPalette::Window, QColor(Qt::yellow));
+	palette.setColor(QPalette::WindowText, QColor(Qt::black));
+	alertWidget->setStyleSheet(alertStyleSheet_);
+	alertLabel->setStyleSheet(alertStyleSheet_);
+
+	alertLabel->setText(alertText.c_str());
 	if (buttonText.empty()) {
 		alertButton_->hide();
 	} else {
 		alertButton_->setText(buttonText.c_str());
 		alertButton_->show();
 	}
-	alertWidget_->show();
+
+	AlertID id = nextAlertId_++;
+	alertWidgets_[id] = alertWidget;
+	return id;
 }
 
-void QtChatWindow::cancelAlert() {
-	alertWidget_->hide();
+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()) {
@@ -250,35 +260,38 @@ void QtChatWindow::handleKeyPressEvent(QKeyEvent* event) {
 	} else if (key == Qt::Key_Down || key == Qt::Key_Up) {
 		/* Drop */
 	} else {
 		messageLog_->handleKeyPressEvent(event);
 	}
 }
 
 void QtChatWindow::beginCorrection() {
 	if (correctionEnabled_ == ChatWindow::Maybe) {
-		setAlert(Q2PSTRING(tr("This chat may not support message correction. If you send a correction anyway, it may appear as a duplicate message")));
+		correctingAlert_ = 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) {
-		setAlert(Q2PSTRING(tr("This chat does not support message correction.  If you send a correction anyway, it will appear as a duplicate message")));
+		correctingAlert_ = addAlert(Q2PSTRING(tr("This chat does not support message correction.  If you send a correction anyway, it will appear as a duplicate message")));
 	}
 	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() {
-	cancelAlert();
+	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);
 }
 
diff --git a/Swift/QtUI/QtChatWindow.h b/Swift/QtUI/QtChatWindow.h
index b3a3f5e..45eaa6f 100644
--- a/Swift/QtUI/QtChatWindow.h
+++ b/Swift/QtUI/QtChatWindow.h
@@ -128,20 +128,20 @@ namespace Swift {
 			void setAffiliations(MUCOccupant::Affiliation, const std::vector<JID>&);
 			void setAvailableRoomActions(const std::vector<RoomAction>& actions);
 			void setBlockingState(BlockingState state);
 			virtual void setCanInitiateImpromptuChats(bool supportsImpromptu);
 			virtual void showBookmarkWindow(const MUCBookmark& bookmark);
 
 		public slots:
 			void handleChangeSplitterState(QByteArray state);
 			void handleFontResized(int fontSizeSteps);
-			void setAlert(const std::string& alertText, const std::string& buttonText = "");
-			void cancelAlert();
+			AlertID addAlert(const std::string& alertText, const std::string& buttonText = "");
+			void removeAlert(const AlertID id);
 			void setCorrectionEnabled(Tristate enabled);
 			void setFileTransferEnabled(Tristate enabled);
 
 		signals:
 			void geometryChanged();
 			void splitterMoved();
 			void fontResized(int);
 
 		protected slots:
@@ -187,20 +187,22 @@ namespace Swift {
 			QTextCursor tabCompleteCursor_;
 			QtChatView* messageLog_;
 			QtChatTheme* theme_;
 			QtTextEdit* input_;
 			QWidget* midBar_; 
 			QBoxLayout* subjectLayout_;
 			QComboBox* labelsWidget_;
 			QtOccupantListWidget* treeWidget_;
 			QLabel* correctingLabel_;
-			QLabel* alertLabel_;
-			QWidget* alertWidget_;
+			boost::optional<AlertID> correctingAlert_;
+			QVBoxLayout* alertLayout_;
+			std::map<AlertID, QWidget*> alertWidgets_;
+			AlertID nextAlertId_;
 			QPushButton* alertButton_;
 			TabComplete* completer_;
 			QLineEdit* subject_;
 			bool isCorrection_;
 			bool inputClearing_;
 			bool tabCompletion_;
 			UIEventStream* eventStream_;
 			bool inputEnabled_;
 			QSplitter *logRosterSplitter_;