7 files changed, 17 insertions, 12 deletions
diff --git a/Swift/QtUI/QtChatView.h b/Swift/QtUI/QtChatView.h
index 61c6f24..52125b7 100644
--- a/Swift/QtUI/QtChatView.h
+++ b/Swift/QtUI/QtChatView.h
@@ -1,62 +1,62 @@
 /*
  * Copyright (c) 2013 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <string>
 #include <boost/shared_ptr.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
 
 #include <QWidget>
 
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 
 namespace Swift {
 	class HighlightAction;
 	class SecurityLabel;
 
 	class QtChatView : public QWidget {
 		Q_OBJECT
 		public:
 			QtChatView(QWidget* parent);
 			virtual ~QtChatView();
 
 			/** Add message to window.
 			 * @return id of added message (for acks).
 			 */
 			virtual std::string addMessage(const ChatWindow::ChatMessage& message, const std::string& senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) = 0;
 			/** Adds action to window.
 			 * @return id of added message (for acks);
 			 */
 			virtual std::string addAction(const ChatWindow::ChatMessage& message, const std::string& senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) = 0;
 
 			virtual void addSystemMessage(const ChatWindow::ChatMessage& message, ChatWindow::Direction direction) = 0;
 			virtual void addPresenceMessage(const ChatWindow::ChatMessage& message, ChatWindow::Direction direction) = 0;
 
 			virtual void addErrorMessage(const ChatWindow::ChatMessage& message) = 0;
 			virtual void replaceMessage(const ChatWindow::ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& highlight) = 0;
 			virtual void replaceWithAction(const ChatWindow::ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& highlight) = 0;
-			virtual void replaceLastMessage(const ChatWindow::ChatMessage& message) = 0;
+			virtual void replaceLastMessage(const ChatWindow::ChatMessage& message, const ChatWindow::TimestampBehaviour /*timestampBehaviour*/) = 0;
 			virtual void setAckState(const std::string& id, ChatWindow::AckState state) = 0;
 			
 			virtual std::string addFileTransfer(const std::string& senderName, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes) = 0;
 			virtual void setFileTransferProgress(std::string, const int percentageDone) = 0;
 			virtual void setFileTransferStatus(std::string, const ChatWindow::FileTransferState state, const std::string& msg = "") = 0;
 			virtual void addMUCInvitation(const std::string& senderName, const JID& jid, const std::string& reason, const std::string& password, bool direct, bool isImpromptu, bool isContinuation) = 0;
 			virtual std::string addWhiteboardRequest(const QString& contact, bool senderIsSelf) = 0;
 			virtual void setWhiteboardSessionStatus(const std::string& id, const ChatWindow::WhiteboardSessionState state) = 0;
 			virtual void setMessageReceiptState(const std::string& id, ChatWindow::ReceiptState state) = 0;
 
 			virtual void showEmoticons(bool show) = 0;
 			virtual void addLastSeenLine() = 0;
 
 		public slots:
 			virtual void resizeFont(int fontSizeSteps) = 0;
 			virtual void scrollToBottom() = 0;
 			virtual void handleKeyPressEvent(QKeyEvent* event) = 0;
 
 	};
 }
diff --git a/Swift/QtUI/QtChatWindow.cpp b/Swift/QtUI/QtChatWindow.cpp
index f0d2038..74ff109 100644
--- a/Swift/QtUI/QtChatWindow.cpp
+++ b/Swift/QtUI/QtChatWindow.cpp
@@ -251,556 +251,556 @@ void QtChatWindow::handleKeyPressEvent(QKeyEvent* event) {
 		/* 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")));
 	} 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")));
 	}
 	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();
 	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();
 }
 
 void QtChatWindow::tabComplete() {
 	if (!completer_) {
 		return;
 	}
 
 	QTextCursor cursor;
 	if (tabCompleteCursor_.hasSelection()) {
 		cursor = tabCompleteCursor_;
 	} else {
 		cursor = input_->textCursor();
 		while(cursor.movePosition(QTextCursor::Left, QTextCursor::KeepAnchor) && cursor.document()->characterAt(cursor.position() - 1) != ' ') { }
 	}
 	QString root = cursor.selectedText();
 	if (root.isEmpty()) {
 		return;
 	}
 	QString suggestion = P2QSTRING(completer_->completeWord(Q2PSTRING(root)));
 	if (root == suggestion) {
 		return;
 	}
 	tabCompletion_ = true;
 	cursor.beginEditBlock();
 	cursor.removeSelectedText();
 	int oldPosition = cursor.position();
 
 	cursor.insertText(suggestion);
 	tabCompleteCursor_ = cursor;
 	tabCompleteCursor_.setPosition(oldPosition, QTextCursor::KeepAnchor);
 
 	cursor.endEditBlock();
 	tabCompletion_ = false;
 }
 
 void QtChatWindow::setRosterModel(Roster* roster) {
 	treeWidget_->setRosterModel(roster);
 }
 
 void QtChatWindow::setAvailableSecurityLabels(const std::vector<SecurityLabelsCatalog::Item>& labels) {
 	delete labelModel_;
 	labelModel_ = new LabelModel();
 	labelModel_->availableLabels_ = labels;
 	int i = 0;
 	int defaultIndex = 0;
 	labelsWidget_->setModel(labelModel_);
 	foreach (SecurityLabelsCatalog::Item label, labels) {
 		if (label.getIsDefault()) {
 			defaultIndex = i;
 			break;
 		}
 		i++;
 	}
 	labelsWidget_->setCurrentIndex(defaultIndex);
 }
 
 void QtChatWindow::handleCurrentLabelChanged(int index) {
 	if (static_cast<size_t>(index) >= labelModel_->availableLabels_.size()) {
 		qDebug() << "User selected a label that doesn't exist";
 		return;
 	}
 	const SecurityLabelsCatalog::Item& label = labelModel_->availableLabels_[index];
 	if (label.getLabel()) {
 		QPalette palette = labelsWidget_->palette();
 		//palette.setColor(QPalette::Base, P2QSTRING(label.getLabel()->getBackgroundColor()));
 		palette.setColor(labelsWidget_->backgroundRole(), P2QSTRING(label.getLabel()->getBackgroundColor()));
 		palette.setColor(labelsWidget_->foregroundRole(), P2QSTRING(label.getLabel()->getForegroundColor()));
 		labelsWidget_->setPalette(palette);
 		midBar_->setPalette(palette);
 		labelsWidget_->setAutoFillBackground(true);
 	}
 	else {
 		labelsWidget_->setAutoFillBackground(false);
 		labelsWidget_->setPalette(defaultLabelsPalette_);
 		midBar_->setPalette(defaultLabelsPalette_);
 	}
 }
 
 void QtChatWindow::setSecurityLabelsError() {
 	labelsWidget_->setEnabled(false);
 }
 
 void QtChatWindow::setSecurityLabelsEnabled(bool enabled) {
 	if (enabled) {
 		labelsWidget_->setEnabled(true);
 		labelsWidget_->show();
 	} else {
 		labelsWidget_->hide();
 	}
 }
 
 void QtChatWindow::setCorrectionEnabled(Tristate enabled) {
 	correctionEnabled_ = enabled;
 }
 
 void QtChatWindow::setFileTransferEnabled(Tristate enabled) {
 	fileTransferEnabled_ = enabled;
 }
 
 SecurityLabelsCatalog::Item QtChatWindow::getSelectedSecurityLabel() {
 	assert(labelsWidget_->isEnabled());
 	assert(labelsWidget_->currentIndex() >= 0 && static_cast<size_t>(labelsWidget_->currentIndex()) < labelModel_->availableLabels_.size());
 	return labelModel_->availableLabels_[labelsWidget_->currentIndex()];
 }
 
 void QtChatWindow::closeEvent(QCloseEvent* event) {
 	event->accept();
 	emit windowClosing();
 	onClosed();
 }
 
 void QtChatWindow::convertToMUC(MUCType mucType) {
 	impromptu_ = (mucType == ImpromptuMUC);
 	treeWidget_->setMessageTarget(impromptu_ ? QtTreeWidget::MessageDisplayJID : QtTreeWidget::MessageDefaultJID);
 	isMUC_ = true;
 	treeWidget_->show();
 	subject_->setVisible(!impromptu_);
 }
 
 void QtChatWindow::qAppFocusChanged(QWidget* /*old*/, QWidget* /*now*/) {
 	if (isWidgetSelected()) {
 		lastLineTracker_.setHasFocus(true);
 		input_->setFocus();
 		onAllMessagesRead();
 	}
 	else {
 		lastLineTracker_.setHasFocus(false);
 	}
 }
 
 void QtChatWindow::setInputEnabled(bool enabled) {
 	inputEnabled_ = enabled;
 	if (!enabled) {
 		if (mucConfigurationWindow_) {
 			delete mucConfigurationWindow_.data();
 		}
 		if (affiliationEditor_) {
 			delete affiliationEditor_.data();
 		}
 	}
 }
 
 void QtChatWindow::showEvent(QShowEvent* event) {
 	emit windowOpening();
 	QWidget::showEvent(event);
 }
 
 void QtChatWindow::setUnreadMessageCount(int count) {
 	if (unreadCount_ != count) {
 		unreadCount_ = count;
 		updateTitleWithUnreadCount();
 		emit countUpdated();
 	}
 }
 
 void QtChatWindow::setContactChatState(ChatState::ChatStateType state) {
 	contactIsTyping_ = (state == ChatState::Composing);
 	emit titleUpdated();
 }
 
 QtTabbable::AlertType QtChatWindow::getWidgetAlertState() {
 	if (contactIsTyping_) {
 		return ImpendingActivity;
 	}
 	if (unreadCount_ > 0) {
 		return WaitingActivity;
 	}
 	return NoActivity;
 }
 
 void QtChatWindow::setName(const std::string& name) {
 	contact_ = P2QSTRING(name);
 	updateTitleWithUnreadCount();
 }
 
 void QtChatWindow::updateTitleWithUnreadCount() {
 	if (isWindow()) {
 		setWindowTitle(unreadCount_ > 0 ? QString("(%1) %2").arg(unreadCount_).arg(contact_) : contact_);
 	} else {
 		setWindowTitle(contact_);
 	}
 	emit titleUpdated();
 }
 
 
 
 void QtChatWindow::flash() {
 	emit requestFlash();
 }
 
 int QtChatWindow::getCount() {
 	return unreadCount_;
 }
 
 
 void QtChatWindow::returnPressed() {
 	if (!inputEnabled_) {
 		return;
 	}
 	messageLog_->scrollToBottom();
 	lastSentMessage_ = QString(input_->toPlainText());
 	onSendMessageRequest(Q2PSTRING(input_->toPlainText()), isCorrection_);
 	inputClearing_ = true;
 	input_->clear();
 	cancelCorrection();
 	inputClearing_ = false;
 }
 
 void QtChatWindow::handleInputChanged() {
 	if (inputClearing_) {
 		return;
 	}
 	if (input_->toPlainText().isEmpty()) {
 		onUserCancelsTyping();
 	} else {
 		onUserTyping();
 	}
 }
 
 void QtChatWindow::handleCursorPositionChanged() {
 	if (tabCompletion_) {
 		return;
 	}
 	tabCompleteCursor_.clearSelection();
 }
 
 void QtChatWindow::show() {
 	if (parentWidget() == NULL) {
 		QWidget::show();
 	}
 	emit windowOpening();
 }
 
 void QtChatWindow::activate() {
 	if (isWindow()) {
 		QWidget::show();
 	}
 	emit wantsToActivate();
 	input_->setFocus();
 }
 
 void QtChatWindow::resizeEvent(QResizeEvent*) {
 	emit geometryChanged();
 }
 
 void QtChatWindow::moveEvent(QMoveEvent*) {
 	emit geometryChanged();
 }
 
 void QtChatWindow::dragEnterEvent(QDragEnterEvent *event) {
 	if (event->mimeData()->hasUrls() && event->mimeData()->urls().size() == 1) {
 		// TODO: check whether contact actually supports file transfer
 		if (!isMUC_) {
 			event->acceptProposedAction();
 		}
 	} else if (event->mimeData()->hasFormat("application/vnd.swift.contact-jid-list")) {
 		if (isMUC_ || supportsImpromptuChat_) {
 			event->acceptProposedAction();
 		}
 	}
 }
 
 void QtChatWindow::dropEvent(QDropEvent *event) {
 	if (fileTransferEnabled_ == ChatWindow::Yes && event->mimeData()->hasUrls()) {
 		if (event->mimeData()->urls().size() == 1) {
 			onSendFileRequest(Q2PSTRING(event->mimeData()->urls().at(0).toLocalFile()));
 		} else {
 			std::string messageText(Q2PSTRING(tr("Sending of multiple files at once isn't supported at this time.")));
 			ChatMessage message;
 			message.append(boost::make_shared<ChatTextMessagePart>(messageText));
 			addSystemMessage(message, DefaultDirection);
 		}
 	} else if (event->mimeData()->hasFormat("application/vnd.swift.contact-jid-list")) {
 		QByteArray dataBytes = event->mimeData()->data("application/vnd.swift.contact-jid-list");
 		QDataStream dataStream(&dataBytes, QIODevice::ReadOnly);
 		std::vector<JID> invites;
 		while (!dataStream.atEnd()) {
 			QString jidString;
 			dataStream >> jidString;
 			invites.push_back(Q2PSTRING(jidString));
 		}
 		onInviteToChat(invites);
 	}
 }
 
 void QtChatWindow::setAvailableOccupantActions(const std::vector<OccupantAction>& actions) {
 	treeWidget_->setAvailableOccupantActions(actions);
 }
 
 void QtChatWindow::setSubject(const std::string& subject) {
 	//subject_->setVisible(!subject.empty());
 	subject_->setText(P2QSTRING(subject));
 	subject_->setToolTip(P2QSTRING(subject));
 	subject_->setCursorPosition(0);
 }
 
 void QtChatWindow::handleActionButtonClicked() {
 	QMenu contextMenu;
 	QAction* changeSubject = NULL;
 	QAction* configure = NULL;
 	QAction* affiliations = NULL;
 	QAction* destroy = NULL;
 	QAction* invite = NULL;
 
 	QAction* block = NULL;
 	QAction* unblock = NULL;
 
 	if (availableRoomActions_.empty()) {
 		if (blockingState_ == IsBlocked) {
 			unblock = contextMenu.addAction(tr("Unblock"));
 		} else if (blockingState_ == IsUnblocked) {
 			block = contextMenu.addAction(tr("Block"));
 		}
 
 		if (supportsImpromptuChat_) {
 			invite = contextMenu.addAction(tr("Invite person to this chat…"));
 		}
 
 	} else {
 		foreach(ChatWindow::RoomAction availableAction, availableRoomActions_)
 		{
 			if (impromptu_) {
 				// hide options we don't need in impromptu chats
 				if (availableAction == ChatWindow::ChangeSubject ||
 					availableAction == ChatWindow::Configure ||
 					availableAction == ChatWindow::Affiliations ||
 					availableAction == ChatWindow::Destroy) {
 					continue;
 				}
 			}
 			switch(availableAction)
 			{
 				case ChatWindow::ChangeSubject: changeSubject = contextMenu.addAction(tr("Change subject…")); break;
 				case ChatWindow::Configure: configure = contextMenu.addAction(tr("Configure room…")); break;
 				case ChatWindow::Affiliations: affiliations = contextMenu.addAction(tr("Edit affiliations…")); break;
 				case ChatWindow::Destroy: destroy = contextMenu.addAction(tr("Destroy room")); break;
 				case ChatWindow::Invite: invite = contextMenu.addAction(tr("Invite person to this room…")); break;
 			}
 		}
 	}
 
 	QAction* bookmark = contextMenu.addAction(tr("Add boomark..."));
 
 	QAction* result = contextMenu.exec(QCursor::pos());
 	if (result == NULL) {
 		/* Skip processing. Note that otherwise, because the actions could be null they could match */
 	}
 	else if (result == changeSubject) {
 		bool ok;
 		QString subject = QInputDialog::getText(this, tr("Change room subject"), tr("New subject:"), QLineEdit::Normal, subject_->text(), &ok);
 		if (ok) {
 			onChangeSubjectRequest(Q2PSTRING(subject));
 		}
 	}
 	else if (result == configure) {
 		onConfigureRequest(Form::ref());
 	}
 	else if (result == affiliations) {
 		if (!affiliationEditor_) {
 			onGetAffiliationsRequest();
 			affiliationEditor_ = new QtAffiliationEditor(this);
 			connect(affiliationEditor_, SIGNAL(accepted()), this, SLOT(handleAffiliationEditorAccepted()));
 		}
 		affiliationEditor_->show();
 	}
 	else if (result == destroy) {
 		QMessageBox msgBox;
 		msgBox.setWindowTitle(tr("Confirm room destruction"));
 		msgBox.setText(tr("Are you sure you want to destroy the room?"));
 		msgBox.setInformativeText(tr("This will destroy the room."));
 		msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
 		msgBox.setDefaultButton(QMessageBox::No);
 		if (msgBox.exec() == QMessageBox::Yes) {
 			onDestroyRequest();
 		}
 	}
 	else if (result == invite) {
 		onInviteToChat(std::vector<JID>());
 	}
 	else if (result == block) {
 		onBlockUserRequest();
 	}
 	else if (result == unblock) {
 		onUnblockUserRequest();
 	} else if (result == bookmark) {
 		onBookmarkRequest();
 	}
 }
 
 void QtChatWindow::handleAffiliationEditorAccepted() {
 	onChangeAffiliationsRequest(affiliationEditor_->getChanges());
 }
 
 void QtChatWindow::setAffiliations(MUCOccupant::Affiliation affiliation, const std::vector<JID>& jids) {
 	if (!affiliationEditor_) return;
 	affiliationEditor_->setAffiliations(affiliation, jids);
 }
 
 void QtChatWindow::setAvailableRoomActions(const std::vector<RoomAction>& actions) {
 	availableRoomActions_ = actions;
 }
 
 void QtChatWindow::setBlockingState(BlockingState state) {
 	blockingState_ = state;
 }
 
 void QtChatWindow::setCanInitiateImpromptuChats(bool supportsImpromptu) {
 	supportsImpromptuChat_ = supportsImpromptu;
 }
 
 void QtChatWindow::showBookmarkWindow(const MUCBookmark& bookmark) {
 	QtAddBookmarkWindow* window = new QtAddBookmarkWindow(eventStream_, bookmark);
 	window->show();
 }
 
 void QtChatWindow::showRoomConfigurationForm(Form::ref form) {
 	if (mucConfigurationWindow_) {
 		delete mucConfigurationWindow_.data();
 	}
 	mucConfigurationWindow_ = new QtMUCConfigurationWindow(form);
 	mucConfigurationWindow_->onFormComplete.connect(boost::bind(boost::ref(onConfigureRequest), _1));
 	mucConfigurationWindow_->onFormCancelled.connect(boost::bind(boost::ref(onConfigurationFormCancelled)));
 }
 
 void QtChatWindow::handleAppendedToLog() {
 	if (lastLineTracker_.getShouldMoveLastLine()) {
 		/* should this be queued? */
 		messageLog_->addLastSeenLine();
 	}
 	if (isWidgetSelected()) {
 		onAllMessagesRead();
 	}
 }
 
 void QtChatWindow::addMUCInvitation(const std::string& senderName, const JID& jid, const std::string& reason, const std::string& password, bool direct, bool isImpromptu, bool isContinuation) {
 	handleAppendedToLog();
 	messageLog_->addMUCInvitation(senderName, jid, reason, password, direct, isImpromptu, isContinuation);
 }
 
 std::string QtChatWindow::addMessage(const ChatMessage& message, const std::string& senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) {
 	handleAppendedToLog();
 	return messageLog_->addMessage(message, senderName, senderIsSelf, label, avatarPath, time, highlight);
 }
 
 std::string QtChatWindow::addAction(const ChatMessage& message, const std::string& senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) {
 	handleAppendedToLog();
 	return messageLog_->addAction(message, senderName, senderIsSelf, label, avatarPath, time, highlight);
 }
 
 
 void QtChatWindow::addSystemMessage(const ChatMessage& message, Direction direction) {
 	handleAppendedToLog();
 	messageLog_->addSystemMessage(message, direction);
 }
 
 void QtChatWindow::addPresenceMessage(const ChatMessage& message, Direction direction) {
 	handleAppendedToLog();
 	messageLog_->addPresenceMessage(message, direction);
 }
 
 void QtChatWindow::addErrorMessage(const ChatMessage& message) {
 	handleAppendedToLog();
 	messageLog_->addErrorMessage(message);
 }
 
 
 void QtChatWindow::replaceMessage(const ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& highlight) {
 	handleAppendedToLog();
 	messageLog_->replaceMessage(message, id, time, highlight);
 }
 
 void QtChatWindow::replaceWithAction(const ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& highlight) {
 	handleAppendedToLog();
 	messageLog_->replaceWithAction(message, id, time, highlight);
 }
 
 std::string QtChatWindow::addFileTransfer(const std::string& senderName, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes) {
 	handleAppendedToLog();
 	return messageLog_->addFileTransfer(senderName, senderIsSelf, filename, sizeInBytes);
 }
 
 void QtChatWindow::setFileTransferProgress(std::string id, const int percentageDone) {
 	messageLog_->setFileTransferProgress(id, percentageDone);
 }
 
 void QtChatWindow::setFileTransferStatus(std::string id, const FileTransferState state, const std::string& msg) {
 	messageLog_->setFileTransferStatus(id, state, msg);
 }
 
 
 std::string QtChatWindow::addWhiteboardRequest(bool senderIsSelf) {
 	handleAppendedToLog();
 	return messageLog_->addWhiteboardRequest(contact_, senderIsSelf);
 }
 
 void QtChatWindow::setWhiteboardSessionStatus(std::string id, const ChatWindow::WhiteboardSessionState state) {
 	messageLog_->setWhiteboardSessionStatus(id, state);
 }
 
-void QtChatWindow::replaceLastMessage(const ChatMessage& message) {
-	messageLog_->replaceLastMessage(message);
+void QtChatWindow::replaceLastMessage(const ChatMessage& message, const TimestampBehaviour timestampBehaviour) {
+	messageLog_->replaceLastMessage(message, timestampBehaviour);
 }
 
 void QtChatWindow::setAckState(const std::string& id, AckState state) {
 	messageLog_->setAckState(id, state);
 }
 
 void QtChatWindow::setMessageReceiptState(const std::string& id, ChatWindow::ReceiptState state) {
 	messageLog_->setMessageReceiptState(id, state);
 }
 
 }
diff --git a/Swift/QtUI/QtChatWindow.h b/Swift/QtUI/QtChatWindow.h
index 95edcd0..b8e3c6a 100644
--- a/Swift/QtUI/QtChatWindow.h
+++ b/Swift/QtUI/QtChatWindow.h
@@ -1,220 +1,220 @@
 /*
  * Copyright (c) 2010-2014 Kevin Smith
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <map>
 
 #include <QPointer>
 #include <QTextCursor>
 #include <QMap>
 
 #include <SwifTools/LastLineTracker.h>
 
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 
 #include <Swift/QtUI/ChatSnippet.h>
 #include <Swift/QtUI/QtAffiliationEditor.h>
 #include <Swift/QtUI/QtMUCConfigurationWindow.h>
 #include <Swift/QtUI/QtSwiftUtil.h>
 #include <Swift/QtUI/QtTabbable.h>
 
 
 
 class QTextEdit;
 class QLineEdit;
 class QComboBox;
 class QLabel;
 class QSplitter;
 class QPushButton;
 
 namespace Swift {
 	class QtChatView;
 	class QtOccupantListWidget;
 	class QtChatTheme;
 	class TreeWidget;
 	class QtTextEdit;
 	class UIEventStream;
 	class QtChatWindowJSBridge;
 	class SettingsProvider;
 
 	class LabelModel : public QAbstractListModel {
 		Q_OBJECT
 		public:
 			LabelModel(QObject* parent = NULL) : QAbstractListModel(parent) {}
 
 			virtual int rowCount(const QModelIndex& /*index*/) const {
 				return static_cast<int>(availableLabels_.size());
 			}
 
 			virtual QVariant data(const QModelIndex& index, int role) const {
 				if (!index.isValid()) {
 					return QVariant();
 				}
 				boost::shared_ptr<SecurityLabel> label = availableLabels_[index.row()].getLabel();
 				if (label && role == Qt::TextColorRole) {
 					return P2QSTRING(label->getForegroundColor());
 				}
 				if (label && role == Qt::TextColorRole) {
 					return P2QSTRING(label->getBackgroundColor());
 				}
 				if (role == Qt::DisplayRole) {
 					std::string selector = availableLabels_[index.row()].getSelector();
 					std::string displayMarking = label ? label->getDisplayMarking() : "";
 					QString labelName = selector.empty() ? displayMarking.c_str() : selector.c_str();
 					return labelName;
 				}
 				return QVariant();
 			}
 
 			std::vector<SecurityLabelsCatalog::Item> availableLabels_;
 	};
 
 	class QtChatWindow : public QtTabbable, public ChatWindow {
 		Q_OBJECT
 
 		public:
 			QtChatWindow(const QString &contact, QtChatTheme* theme, UIEventStream* eventStream, SettingsProvider* settings);
 			~QtChatWindow();
 			std::string addMessage(const ChatMessage& message, const std::string &senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight);
 			std::string addAction(const ChatMessage& message, const std::string &senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight);
 
 			void addSystemMessage(const ChatMessage& message, Direction direction);
 			void addPresenceMessage(const ChatMessage& message, Direction direction);
 			void addErrorMessage(const ChatMessage& message);
 
 			void replaceMessage(const ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& highlight);
 			void replaceWithAction(const ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& highlight);
 			// File transfer related stuff
 			std::string addFileTransfer(const std::string& senderName, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes);
 			void setFileTransferProgress(std::string id, const int percentageDone);
 			void setFileTransferStatus(std::string id, const FileTransferState state, const std::string& msg);
 			
 			std::string addWhiteboardRequest(bool senderIsSelf);
 			void setWhiteboardSessionStatus(std::string id, const ChatWindow::WhiteboardSessionState state);
 
 			void show();
 			void activate();
 			void setUnreadMessageCount(int count);
 			void convertToMUC(MUCType mucType);
 //			TreeWidget *getTreeWidget();
 			void setAvailableSecurityLabels(const std::vector<SecurityLabelsCatalog::Item>& labels);
 			void setSecurityLabelsEnabled(bool enabled);
 			void setSecurityLabelsError();
 			SecurityLabelsCatalog::Item getSelectedSecurityLabel();
 			void setName(const std::string& name);
 			void setInputEnabled(bool enabled);
 			QtTabbable::AlertType getWidgetAlertState();
 			void setContactChatState(ChatState::ChatStateType state);
 			void setRosterModel(Roster* roster);
 			void setTabComplete(TabComplete* completer);
 			int getCount();
-			void replaceLastMessage(const ChatMessage& message);
+			void replaceLastMessage(const ChatMessage& message, const TimestampBehaviour timestampBehaviour);
 			void setAckState(const std::string& id, AckState state);
 
 			// message receipts
 			void setMessageReceiptState(const std::string& id, ChatWindow::ReceiptState state);
 
 			void flash();
 			QByteArray getSplitterState();
 			virtual void setAvailableOccupantActions(const std::vector<OccupantAction>& actions);
 			void setSubject(const std::string& subject);
 			void showRoomConfigurationForm(Form::ref);
 			void addMUCInvitation(const std::string& senderName, const JID& jid, const std::string& reason, const std::string& password, bool direct = true, bool isImpromptu = false, bool isContinuation = false);
 			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();
 			void setCorrectionEnabled(Tristate enabled);
 			void setFileTransferEnabled(Tristate enabled);
 
 		signals:
 			void geometryChanged();
 			void splitterMoved();
 			void fontResized(int);
 
 		protected slots:
 			void qAppFocusChanged(QWidget* old, QWidget* now);
 			void closeEvent(QCloseEvent* event);
 			void resizeEvent(QResizeEvent* event);
 			void moveEvent(QMoveEvent* event);
 
 			void dragEnterEvent(QDragEnterEvent *event);
 			void dropEvent(QDropEvent *event);
 
 		protected:
 			void showEvent(QShowEvent* event);
 
 		private slots:
 			void handleLogCleared();
 			void returnPressed();
 			void handleInputChanged();
 			void handleCursorPositionChanged();
 			void handleKeyPressEvent(QKeyEvent* event);
 			void handleSplitterMoved(int pos, int index);
 			void handleAlertButtonClicked();
 			void handleActionButtonClicked();
 			void handleAffiliationEditorAccepted();
 			void handleCurrentLabelChanged(int);
 
 		private:
 			void updateTitleWithUnreadCount();
 			void tabComplete();
 			void beginCorrection();
 			void cancelCorrection();
 			void handleSettingChanged(const std::string& setting);
 
 			void handleOccupantSelectionChanged(RosterItem* item);
 			void handleAppendedToLog();
 
 
 			int unreadCount_;
 			bool contactIsTyping_;
 			LastLineTracker lastLineTracker_;
 			QString contact_;
 			QString lastSentMessage_;
 			QTextCursor tabCompleteCursor_;
 			QtChatView* messageLog_;
 			QtChatTheme* theme_;
 			QtTextEdit* input_;
 			QWidget* midBar_; 
 			QBoxLayout* subjectLayout_;
 			QComboBox* labelsWidget_;
 			QtOccupantListWidget* treeWidget_;
 			QLabel* correctingLabel_;
 			QLabel* alertLabel_;
 			QWidget* alertWidget_;
 			QPushButton* alertButton_;
 			TabComplete* completer_;
 			QLineEdit* subject_;
 			bool isCorrection_;
 			bool inputClearing_;
 			bool tabCompletion_;
 			UIEventStream* eventStream_;
 			bool inputEnabled_;
 			QSplitter *logRosterSplitter_;
 			Tristate correctionEnabled_;
 			Tristate fileTransferEnabled_;
 			QString alertStyleSheet_;
 			QPointer<QtMUCConfigurationWindow> mucConfigurationWindow_;
 			QPointer<QtAffiliationEditor> affiliationEditor_;
 			SettingsProvider* settings_;
 			std::vector<ChatWindow::RoomAction> availableRoomActions_;
 			QPalette defaultLabelsPalette_;
 			LabelModel* labelModel_;
 			BlockingState blockingState_;
 			bool impromptu_;
 			bool isMUC_;
 			bool supportsImpromptuChat_;
 	};
 }
diff --git a/Swift/QtUI/QtPlainChatView.cpp b/Swift/QtUI/QtPlainChatView.cpp
index ee76438..23bf0af 100644
--- a/Swift/QtUI/QtPlainChatView.cpp
+++ b/Swift/QtUI/QtPlainChatView.cpp
@@ -1,413 +1,413 @@
 /*
  * Copyright (c) 2013-2014 Kevin Smith and Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include <Swift/QtUI/QtPlainChatView.h>
 
 #include <QTextEdit>
 #include <QScrollBar>
 #include <QVBoxLayout>
 #include <QPushButton>
 #include <QLabel>
 #include <QDialog>
 #include <QProgressBar>
 #include <QFileDialog>
 #include <QInputDialog>
 #include <QMenu>
 
 #include <Swiften/Base/foreach.h>
 #include <Swiften/Base/FileSize.h>
 
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 #include <Swift/Controllers/UIEvents/JoinMUCUIEvent.h>
 
 #include <Swift/QtUI/ChatSnippet.h>
 #include <Swift/QtUI/QtSwiftUtil.h>
 #include <Swift/QtUI/QtUtilities.h>
 
 namespace Swift {
 
 QtPlainChatView::QtPlainChatView(QtChatWindow *window, UIEventStream* eventStream)
 : QtChatView(window), window_(window), eventStream_(eventStream), idGenerator_(0) {
 	QVBoxLayout* mainLayout = new QVBoxLayout(this);
 	mainLayout->setSpacing(0);
 	mainLayout->setContentsMargins(0,0,0,0);
 	log_ = new LogTextEdit(this);
 	log_->setReadOnly(true);
 	log_->setAccessibleName(tr("Chat Messages"));
 	mainLayout->addWidget(log_);
 }
 
 QtPlainChatView::~QtPlainChatView() {
 }
 
 QString chatMessageToString(const ChatWindow::ChatMessage& message) {
 	QString result;
 	foreach (boost::shared_ptr<ChatWindow::ChatMessagePart> part, message.getParts()) {
 		boost::shared_ptr<ChatWindow::ChatTextMessagePart> textPart;
 		boost::shared_ptr<ChatWindow::ChatURIMessagePart> uriPart;
 		boost::shared_ptr<ChatWindow::ChatEmoticonMessagePart> emoticonPart;
 		boost::shared_ptr<ChatWindow::ChatHighlightingMessagePart> highlightPart;
 
 		if ((textPart = boost::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(part))) {
 			QString text = QtUtilities::htmlEscape(P2QSTRING(textPart->text));
 			text.replace("\n","<br/>");
 			result += text;
 			continue;
 		}
 		if ((uriPart = boost::dynamic_pointer_cast<ChatWindow::ChatURIMessagePart>(part))) {
 			QString uri = QtUtilities::htmlEscape(P2QSTRING(uriPart->target));
 			result += "<a href='" + uri + "' >" + uri + "</a>";
 			continue;
 		}
 		if ((emoticonPart = boost::dynamic_pointer_cast<ChatWindow::ChatEmoticonMessagePart>(part))) {
 			result += P2QSTRING(emoticonPart->alternativeText);
 			continue;
 		}
 		if ((highlightPart = boost::dynamic_pointer_cast<ChatWindow::ChatHighlightingMessagePart>(part))) {
 			//FIXME: Maybe do something here. Anything, really.
 			continue;
 		}
 	}
 	return result;
 }
 
 std::string QtPlainChatView::addMessage(const ChatWindow::ChatMessage& message, const std::string& senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& /*avatarPath*/, const boost::posix_time::ptime& time, const HighlightAction& /*highlight*/) {
 	QString text = "<p>";
 	if (label) {
 		text += P2QSTRING(label->getLabel()) + "<br/>";
 	}
 	QString name = senderIsSelf ? "you" : P2QSTRING(senderName);
 	text += QString(tr("At %1 %2 said:")).arg(ChatSnippet::timeToEscapedString(B2QDATE(time))).arg(name) + "<br/>";
 	text += chatMessageToString(message);
 	text += "</p>";
 	log_->append(text);
 	const std::string idx = senderIsSelf ? "" : senderName;
 	lastMessageLabel_[idx] = label;
 	return idx;
 }
 
 std::string QtPlainChatView::addAction(const ChatWindow::ChatMessage& message, const std::string& senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& /*avatarPath*/, const boost::posix_time::ptime& time, const HighlightAction& /*highlight*/) {
 	QString text = "<p>";
 	if (label) {
 		text += P2QSTRING(label->getLabel()) + "<br/>";
 	}
 	QString name = senderIsSelf ? "you" : P2QSTRING(senderName);
 	text += QString(tr("At %1 <i>%2 ")).arg(ChatSnippet::timeToEscapedString(B2QDATE(time))).arg(name);
 	text += chatMessageToString(message);
 	text += "</i></p>";
 	log_->append(text);
 	const std::string idx = senderIsSelf ? "" : senderName;
 	lastMessageLabel_[idx] = label;
 	return idx;
 }
 
 void QtPlainChatView::addSystemMessage(const ChatWindow::ChatMessage& message, ChatWindow::Direction /*direction*/)
 {
 	QString text = "<p><i>";
 	text += chatMessageToString(message);
 	text += "</i></p>";
 	log_->append(text);
 }
 
 void QtPlainChatView::addPresenceMessage(const ChatWindow::ChatMessage& message, ChatWindow::Direction /*direction*/)
 {
 	QString text = "<p><i>";
 	text += chatMessageToString(message);
 	text += "</i></p>";
 	log_->append(text);
 }
 
 void QtPlainChatView::addErrorMessage(const ChatWindow::ChatMessage& message)
 {
 	QString text = "<p><i>";
 	text += chatMessageToString(message);
 	text += "</i></p>";
 	log_->append(text);
 }
 
 void QtPlainChatView::replaceMessage(const ChatWindow::ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& /*highlight*/)
 {
 	QString text = "<p>";
 	if (lastMessageLabel_[id]) {
 		text += P2QSTRING(lastMessageLabel_[id]->getLabel()) + "<br/>";
 	}
 	QString name = id.empty() ? "you" : P2QSTRING(id);
 	text += QString(tr("At %1 %2 corrected the last message to:")).arg(ChatSnippet::timeToEscapedString(B2QDATE(time))).arg(name) + "<br/>";
 	text += chatMessageToString(message);
 	text += "</p>";
 	log_->append(text);
 }
 
 void QtPlainChatView::replaceWithAction(const ChatWindow::ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& /*highlight*/)
 {
 	QString text = "<p>";
 	if (lastMessageLabel_[id]) {
 		text += P2QSTRING(lastMessageLabel_[id]->getLabel()) + "<br/>";
 	}
 	QString name = id.empty() ? "you" : P2QSTRING(id);
 	text += QString(tr("At %1 %2 corrected the last action to: <i>")).arg(ChatSnippet::timeToEscapedString(B2QDATE(time))).arg(name);
 	text += chatMessageToString(message);
 	text += "</i></p>";
 	log_->append(text);
 }
 
-void QtPlainChatView::replaceLastMessage(const ChatWindow::ChatMessage& message)
+void QtPlainChatView::replaceLastMessage(const ChatWindow::ChatMessage& message, const ChatWindow::TimestampBehaviour /*timestampBehaviour*/)
 {
 	QString text = "<p>The last message was corrected to:<br/>";
 	text += chatMessageToString(message);
 	text += "</p>";
 	log_->append(text);
 }
 
 void QtPlainChatView::setAckState(const std::string& /*id*/, ChatWindow::AckState state)
 {
 	if (state == ChatWindow::Failed) {
 		addSystemMessage(ChatWindow::ChatMessage("Message delivery failed due to disconnection from server."), ChatWindow::DefaultDirection);
 	}
 }
 
 std::string QtPlainChatView::addFileTransfer(const std::string& senderName, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes)
 {
 	const std::string ftId = "ft" + boost::lexical_cast<std::string>(idGenerator_++);
 	const std::string sizeString = formatSize(sizeInBytes);
 
 	FileTransfer* transfer;
 	if (senderIsSelf) {
 		QString description = QInputDialog::getText(this, tr("File transfer description"),
 			tr("Description:"), QLineEdit::Normal, "");
 		/* NOTE: it is not possible to abort if description is not provided, since we must always return a valid transfer id */
 		const std::string message = std::string() + "Confirm file transfer: <i>" + filename + " (" + sizeString + " bytes)</i>";
 		transfer = new FileTransfer(this, senderIsSelf, ftId, filename, ChatWindow::WaitingForAccept, Q2PSTRING(description), message, true);
 		addSystemMessage(ChatWindow::ChatMessage("Preparing to start file transfer..."), ChatWindow::DefaultDirection);
 	} else { /* incoming transfer */
 		const std::string message = std::string() + "Incoming file transfer: <i>" + filename + " (" + sizeString + " bytes)</i>";
 		transfer = new FileTransfer(this, senderIsSelf, ftId, filename, ChatWindow::WaitingForAccept, "", message, true);
 		addSystemMessage("Incoming file transfer from " + senderName + "...", ChatWindow::DefaultDirection);
 	}
 
 	fileTransfers_[ftId] = transfer;
 	layout()->addWidget(transfer->dialog_);
 
 	return ftId;
 }
 
 void QtPlainChatView::setFileTransferProgress(std::string id, const int percentageDone)
 {
 	FileTransferMap::iterator transfer = fileTransfers_.find(id);
 	if (transfer != fileTransfers_.end()) {
 		transfer->second->bar_->setValue(percentageDone);
 	}
 }
 
 void QtPlainChatView::setFileTransferStatus(std::string id, const ChatWindow::FileTransferState state, const std::string& msg)
 {
 	FileTransferMap::iterator transferIter = fileTransfers_.find(id);
 	if (transferIter == fileTransfers_.end()) {
 		return;
 	}
 
 	/* store the layout index so we can restore it to the same location */
 	FileTransfer* oldTransfer = transferIter->second;
 	const int layoutIndex = layout()->indexOf(oldTransfer->dialog_);
 	layout()->removeWidget(oldTransfer->dialog_);
 	const std::string &label = (!msg.empty() ? msg : oldTransfer->message_);
 	FileTransfer* transfer = new FileTransfer(this, oldTransfer->senderIsSelf_, oldTransfer->ftId_, oldTransfer->filename_, state, oldTransfer->description_, label, false);
 	fileTransfers_[oldTransfer->ftId_] = transfer; /* replace the transfer object for this file id */
 	delete oldTransfer;
 
 	/* insert the new dialog at the old position in the layout list */
 	QBoxLayout* parentLayout = dynamic_cast<QBoxLayout*>(layout());
 	assert(parentLayout);
 	parentLayout->insertWidget(layoutIndex, transfer->dialog_);
 
 	/* log the transfer end result as a system message */
 	if (state == ChatWindow::Finished) {
 		addSystemMessage(ChatWindow::ChatMessage("The file transfer completed successfully."), ChatWindow::DefaultDirection);
 	} else if (state == ChatWindow::Canceled) {
 		addSystemMessage(ChatWindow::ChatMessage("The file transfer was canceled."), ChatWindow::DefaultDirection);
 	} else if (state == ChatWindow::FTFailed) {
 		addSystemMessage(ChatWindow::ChatMessage("The file transfer failed."), ChatWindow::DefaultDirection);
 	}
 }
 
 void QtPlainChatView::addMUCInvitation(const std::string& senderName, const JID& jid, const std::string& /*reason*/, const std::string& password, bool /*direct*/, bool isImpromptu, bool isContinuation)
 {
 	PopupDialog *invite = new PopupDialog(this);
 
 	QLabel* statusLabel = new QLabel;
 	std::string msg = senderName + " has invited you to join " + jid.toString() + "...";
 	statusLabel->setText(P2QSTRING(msg));
 	invite->layout_->addWidget(statusLabel);
 	invite->layout_->addWidget(new QLabel); /* padding */
 
 	AcceptMUCInviteAction* accept = new AcceptMUCInviteAction(invite, "Accept", jid, senderName, password, isImpromptu, isContinuation);
 	connect(accept, SIGNAL(clicked()), SLOT(acceptMUCInvite()));
 	invite->layout_->addWidget(accept);
 
 	AcceptMUCInviteAction* reject = new AcceptMUCInviteAction(invite, "Reject", jid, senderName, password, isImpromptu, isContinuation);
 	connect(reject, SIGNAL(clicked()), SLOT(rejectMUCInvite()));
 	invite->layout_->addWidget(reject);
 	statusLabel->setText(P2QSTRING(msg));
 
 	layout()->addWidget(invite->dialog_);
 
 	addSystemMessage(ChatWindow::ChatMessage(msg), ChatWindow::DefaultDirection);
 }
 
 void QtPlainChatView::scrollToBottom()
 {
 	log_->ensureCursorVisible();
 	log_->verticalScrollBar()->setValue(log_->verticalScrollBar()->maximum());
 }
 
 void QtPlainChatView::fileTransferAccept()
 {
 	FileTransfer::Action* action = dynamic_cast<FileTransfer::Action*>(sender());
 	if (!action) {
 		return;
 	}
 
 	FileTransferMap::iterator transferIter = fileTransfers_.find(action->id_);
 	if (transferIter == fileTransfers_.end()) {
 		return;
 	}
 
 	FileTransfer* transfer = transferIter->second;
 
 	if (transfer->senderIsSelf_) { /* if we are the sender, kick of the transfer */
 		window_->onFileTransferStart(transfer->ftId_, transfer->description_);
 	} else { /* ask the user where to save the file first */
 		QString path = QFileDialog::getSaveFileName(this, tr("Save File"), P2QSTRING(transfer->filename_));
 		if (path.isEmpty()) {
 			fileTransferReject(); /* because the user did not select a desintation path */
 			return;
 		}
 		window_->onFileTransferAccept(transfer->ftId_, Q2PSTRING(path));
 	}
 
 	setFileTransferStatus(transfer->ftId_, ChatWindow::Negotiating, transfer->message_);
 }
 
 void QtPlainChatView::fileTransferReject()
 {
 	FileTransfer::Action* action = dynamic_cast<FileTransfer::Action*>(sender());
 	if (action) {
 		window_->onFileTransferCancel(action->id_);
 		fileTransferFinish();
 	}
 }
 
 void QtPlainChatView::fileTransferFinish()
 {
 	FileTransfer::Action* action = dynamic_cast<FileTransfer::Action*>(sender());
 	if (action) {
 		FileTransferMap::iterator transferIter = fileTransfers_.find(action->id_);
 		if (transferIter != fileTransfers_.end()) {
 			delete transferIter->second; /* cause the dialog to close */
 			fileTransfers_.erase(transferIter);
 		}
 	}
 }
 
 void QtPlainChatView::acceptMUCInvite()
 {
 	AcceptMUCInviteAction *action = dynamic_cast<AcceptMUCInviteAction*>(sender());
 	if (action) {
 		eventStream_->send(boost::make_shared<JoinMUCUIEvent>(action->jid_.toString(), action->password_, boost::optional<std::string>(), false, false, action->isImpromptu_, action->isContinuation_));
 		delete action->parent_;
 	}
 }
 
 void QtPlainChatView::rejectMUCInvite()
 {
 	AcceptMUCInviteAction *action = dynamic_cast<AcceptMUCInviteAction*>(sender());
 	if (action) {
 		/* NOTE: no action required to reject an invite? */
 		delete action->parent_;
 	}
 }
 
 QtPlainChatView::FileTransfer::FileTransfer(QtPlainChatView* parent, bool senderIsSelf, const std::string& ftId, const std::string& filename, const ChatWindow::FileTransferState state, const std::string &desc, const std::string& msg, bool initializing)
 : PopupDialog(parent), bar_(0), senderIsSelf_(senderIsSelf), ftId_(ftId), filename_(filename), description_(desc), message_(msg), initializing_(initializing)
 {
 	QHBoxLayout* layout = new QHBoxLayout;
 	QLabel* statusLabel = new QLabel;
 	layout_->addWidget(statusLabel);
 	layout_->addWidget(new QLabel); /* padding */
 
 	if (initializing_) {
 		FileTransfer::Action* accept = new FileTransfer::Action(senderIsSelf?"Confirm":"Accept", ftId);
 		parent->connect(accept, SIGNAL(clicked()), SLOT(fileTransferAccept()));
 		layout_->addWidget(accept);
 		FileTransfer::Action* reject = new FileTransfer::Action(senderIsSelf?"Cancel":"Reject", ftId);
 		parent->connect(reject, SIGNAL(clicked()), SLOT(fileTransferReject()));
 		layout_->addWidget(reject);
 		statusLabel->setText(P2QSTRING(msg));
 		return;
 	}
 
 	std::string status = msg;
 
 	switch (state) {
 		case ChatWindow::WaitingForAccept: {
 			status = "Waiting for user to accept <i>" + filename + "</i>...";
 			FileTransfer::Action* cancel = new FileTransfer::Action("Cancel", ftId);
 			parent->connect(cancel, SIGNAL(clicked()), SLOT(fileTransferReject()));
 			layout_->addWidget(cancel);
 			break;
 		}
 		case ChatWindow::Negotiating: {
 			status = "Preparing to transfer <i>" + filename + "</i>...";
 			FileTransfer::Action* cancel = new FileTransfer::Action("Cancel", ftId);
 			parent->connect(cancel, SIGNAL(clicked()), SLOT(fileTransferReject()));
 			layout_->addWidget(cancel);
 			break;
 		}
 		case ChatWindow::Transferring: {
 			status = "Transferring <i>" + filename + "</i>...";
 			bar_ = new QProgressBar;
 			bar_->setRange(0, 100);
 			bar_->setValue(0);
 			layout->addWidget(bar_);
 			FileTransfer::Action* cancel = new FileTransfer::Action("Cancel", ftId);
 			parent->connect(cancel, SIGNAL(clicked()), SLOT(fileTransferReject()));
 			layout_->addWidget(cancel);
 			break;
 		}
 		case ChatWindow::Canceled: {
 			status = "File <i>" + filename + "</i> was canceled.";
 			FileTransfer::Action* finish = new FileTransfer::Action("Hide", ftId);
 			parent->connect(finish, SIGNAL(clicked()), SLOT(fileTransferFinish()));
 			layout_->addWidget(finish);
 			break;
 		}
 		case ChatWindow::Finished: {
 			status = "File <i>" + filename + "</i> was transfered successfully.";
 			FileTransfer::Action* finish = new FileTransfer::Action("Hide", ftId);
 			parent->connect(finish, SIGNAL(clicked()), SLOT(fileTransferFinish()));
 			layout_->addWidget(finish);
 			break;
 		}
 		case ChatWindow::FTFailed: {
 			status = "File transfer failed: <i>" + filename + "</i>";
 			FileTransfer::Action* finish = new FileTransfer::Action("Hide", ftId);
 			parent->connect(finish, SIGNAL(clicked()), SLOT(fileTransferFinish()));
 			layout_->addWidget(finish);
 			break;
 		}
 	}
 
 	statusLabel->setText(P2QSTRING(status));
 }
 
 void QtPlainChatView::LogTextEdit::contextMenuEvent(QContextMenuEvent *event)
 {
 	QMenu *menu = createStandardContextMenu();
 	menu->exec(event->globalPos());
 	delete menu;
 }
 
 }
diff --git a/Swift/QtUI/QtPlainChatView.h b/Swift/QtUI/QtPlainChatView.h
index cf65fb3..06613f9 100644
--- a/Swift/QtUI/QtPlainChatView.h
+++ b/Swift/QtUI/QtPlainChatView.h
@@ -1,132 +1,132 @@
 /*
  * Copyright (c) 2013-2014 Kevin Smith and Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <string>
 #include <boost/shared_ptr.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
 
 #include <QWidget>
 #include <QTextEdit>
 
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 
 #include <Swift/QtUI/QtChatView.h>
 #include <Swift/QtUI/QtChatWindow.h>
 
 class QTextEdit;
 class QProgressBar;
 
 namespace Swift {
 	class HighlightAction;
 	class SecurityLabel;
 
 	class QtPlainChatView : public QtChatView {
 		Q_OBJECT
 		public:
 			QtPlainChatView(QtChatWindow *window, UIEventStream* eventStream);
 			virtual ~QtPlainChatView();
 
 			/** Add message to window.
 			 * @return id of added message (for acks).
 			 */
 			virtual std::string addMessage(const ChatWindow::ChatMessage& /*message*/, const std::string& /*senderName*/, bool /*senderIsSelf*/, boost::shared_ptr<SecurityLabel> /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime& /*time*/, const HighlightAction& /*highlight*/);
 			/** Adds action to window.
 			 * @return id of added message (for acks);
 			 */
 			virtual std::string addAction(const ChatWindow::ChatMessage& /*message*/, const std::string& /*senderName*/, bool /*senderIsSelf*/, boost::shared_ptr<SecurityLabel> /*label*/, const std::string& /*avatarPath*/, const boost::posix_time::ptime& /*time*/, const HighlightAction& /*highlight*/);
 
 			virtual void addSystemMessage(const ChatWindow::ChatMessage& /*message*/, ChatWindow::Direction /*direction*/);
 			virtual void addPresenceMessage(const ChatWindow::ChatMessage& /*message*/, ChatWindow::Direction /*direction*/);
 			virtual void addErrorMessage(const ChatWindow::ChatMessage& /*message*/);
 
 			virtual void replaceMessage(const ChatWindow::ChatMessage& /*message*/, const std::string& /*id*/, const boost::posix_time::ptime& /*time*/, const HighlightAction& /*highlight*/);
 			virtual void replaceWithAction(const ChatWindow::ChatMessage& /*message*/, const std::string& /*id*/, const boost::posix_time::ptime& /*time*/, const HighlightAction& /*highlight*/);
-			virtual void replaceLastMessage(const ChatWindow::ChatMessage& /*message*/);
+			virtual void replaceLastMessage(const ChatWindow::ChatMessage& /*message*/, const ChatWindow::TimestampBehaviour /*timestampBehaviour*/);
 			virtual void setAckState(const std::string& /*id*/, ChatWindow::AckState /*state*/);
 
 			virtual std::string addFileTransfer(const std::string& /*senderName*/, bool /*senderIsSelf*/, const std::string& /*filename*/, const boost::uintmax_t /*sizeInBytes*/);
 			virtual void setFileTransferProgress(std::string, const int /*percentageDone*/);
 			virtual void setFileTransferStatus(std::string, const ChatWindow::FileTransferState /*state*/, const std::string& /*msg*/ = "");
 			virtual void addMUCInvitation(const std::string& /*senderName*/, const JID& /*jid*/, const std::string& /*reason*/, const std::string& /*password*/, bool /*direct*/, bool /*isImpromptu*/, bool /*isContinuation*/);
 			virtual std::string addWhiteboardRequest(const QString& /*contact*/, bool /*senderIsSelf*/) {return "";};
 			virtual void setWhiteboardSessionStatus(const std::string& /*id*/, const ChatWindow::WhiteboardSessionState /*state*/) {};
 			virtual void setMessageReceiptState(const std::string& /*id*/, ChatWindow::ReceiptState /*state*/) {};
 
 			virtual void showEmoticons(bool /*show*/) {};
 			virtual void addLastSeenLine() {};
 
 		public slots:
 			virtual void resizeFont(int /*fontSizeSteps*/) {};
 			virtual void scrollToBottom();
 			virtual void handleKeyPressEvent(QKeyEvent* /*event*/) {};
 			virtual void fileTransferAccept();
 			virtual void fileTransferReject();
 			virtual void fileTransferFinish();
 			virtual void acceptMUCInvite();
 			virtual void rejectMUCInvite();
 
 		private:
 			struct PopupDialog {
 				PopupDialog(QtPlainChatView* parent) {
 					dialog_ = new QFrame(parent);
 					dialog_->setFrameShape(QFrame::Panel);
 					dialog_->setFrameShadow(QFrame::Raised);
 					layout_ = new QHBoxLayout;
 					dialog_->setLayout(layout_);
 				}
 				virtual ~PopupDialog() {
 					delete dialog_;
 				}
 				QFrame* dialog_;
 				QHBoxLayout* layout_;
 			};
 
 			struct AcceptMUCInviteAction : public QPushButton {
 				AcceptMUCInviteAction(PopupDialog* parent, const std::string& text, const JID& jid, const std::string& senderName, const std::string& password, bool isImpromptu, bool isContinuation)
 				: QPushButton(P2QSTRING(text)), parent_(parent), jid_(jid), senderName_(senderName), password_(password), isImpromptu_(isImpromptu), isContinuation_(isContinuation) {}
 				PopupDialog *parent_;
 				JID jid_;
 				std::string senderName_;
 				std::string password_;
 				bool isImpromptu_;
 				bool isContinuation_;
 			};
 
 			struct FileTransfer : public PopupDialog {
 				struct Action : QPushButton {
 					Action(const std::string& text, const std::string& id)
 					: QPushButton(P2QSTRING(text)), id_(id) {}
 					std::string id_;
 				};
 				FileTransfer(QtPlainChatView* parent, bool senderIsSelf, const std::string& ftId, const std::string& filename, const ChatWindow::FileTransferState state, const std::string& desc, const std::string& msg, bool initializing);
 				QProgressBar* bar_;
 				bool senderIsSelf_;
 				std::string ftId_;
 				std::string filename_;
 				std::string description_;
 				std::string message_;
 				bool initializing_;
 			};
 
 			class LogTextEdit : public QTextEdit {
 			public:
 				LogTextEdit(QWidget* parent) : QTextEdit(parent) {}
 				virtual ~LogTextEdit() {}
 				virtual void contextMenuEvent(QContextMenuEvent *event);
 			};
 
 			typedef std::map<std::string, FileTransfer*> FileTransferMap;
 			QtChatWindow* window_;
 			UIEventStream* eventStream_;
 			LogTextEdit* log_;
 			FileTransferMap fileTransfers_;
 			std::map<std::string, boost::shared_ptr<SecurityLabel> > lastMessageLabel_;
 			int idGenerator_;
 
 	};
 }
diff --git a/Swift/QtUI/QtWebKitChatView.cpp b/Swift/QtUI/QtWebKitChatView.cpp
index 3f021e9..23bc099 100644
--- a/Swift/QtUI/QtWebKitChatView.cpp
+++ b/Swift/QtUI/QtWebKitChatView.cpp
@@ -1,937 +1,942 @@
 /*
  * Copyright (c) 2010-2014 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include "QtWebKitChatView.h"
 
 #include <QtDebug>
 #include <QEventLoop>
 #include <QFile>
 #include <QDesktopServices>
 #include <QVBoxLayout>
 #include <QWebFrame>
 #include <QKeyEvent>
 #include <QStackedWidget>
 #include <QTimer>
 #include <QMessageBox>
 #include <QApplication>
 #include <QInputDialog>
 #include <QFileDialog>
 
 #include <Swiften/Base/Log.h>
 #include <Swiften/Base/FileSize.h>
 #include <Swiften/StringCodecs/Base64.h>
 
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 #include <Swift/Controllers/UIEvents/JoinMUCUIEvent.h>
 
 #include <Swift/QtUI/QtWebView.h>
 #include <Swift/QtUI/QtChatWindow.h>
 #include <Swift/QtUI/QtChatWindowJSBridge.h>
 #include <Swift/QtUI/QtScaledAvatarCache.h>
 #include <Swift/QtUI/QtSwiftUtil.h>
 #include <Swift/QtUI/QtUtilities.h>
 #include <Swift/QtUI/MessageSnippet.h>
 #include <Swift/QtUI/SystemMessageSnippet.h>
 
 namespace Swift {
 
 const QString QtWebKitChatView::ButtonWhiteboardSessionCancel = QString("whiteboard-cancel");
 const QString QtWebKitChatView::ButtonWhiteboardSessionAcceptRequest = QString("whiteboard-acceptrequest");
 const QString QtWebKitChatView::ButtonWhiteboardShowWindow = QString("whiteboard-showwindow");
 const QString QtWebKitChatView::ButtonFileTransferCancel = QString("filetransfer-cancel");
 const QString QtWebKitChatView::ButtonFileTransferSetDescription = QString("filetransfer-setdescription");
 const QString QtWebKitChatView::ButtonFileTransferSendRequest = QString("filetransfer-sendrequest");
 const QString QtWebKitChatView::ButtonFileTransferAcceptRequest = QString("filetransfer-acceptrequest");
 const QString QtWebKitChatView::ButtonMUCInvite = QString("mucinvite");
 
 QtWebKitChatView::QtWebKitChatView(QtChatWindow* window, UIEventStream* eventStream, QtChatTheme* theme, QWidget* parent, bool disableAutoScroll) : QtChatView(parent), window_(window), eventStream_(eventStream), fontSizeSteps_(0), disableAutoScroll_(disableAutoScroll), previousMessageKind_(PreviosuMessageWasNone), previousMessageWasSelf_(false), showEmoticons_(false), insertingLastLine_(false), idCounter_(0) {
 	theme_ = theme;
 
 	QVBoxLayout* mainLayout = new QVBoxLayout(this);
 	mainLayout->setSpacing(0);
 	mainLayout->setContentsMargins(0,0,0,0);
 	webView_ = new QtWebView(this);
 	connect(webView_, SIGNAL(linkClicked(const QUrl&)), SLOT(handleLinkClicked(const QUrl&)));
 	connect(webView_, SIGNAL(loadFinished(bool)), SLOT(handleViewLoadFinished(bool)));
 	connect(webView_, SIGNAL(gotFocus()), SIGNAL(gotFocus()));
 	connect(webView_, SIGNAL(clearRequested()), SLOT(handleClearRequested()));
 	connect(webView_, SIGNAL(fontGrowRequested()), SLOT(increaseFontSize()));
 	connect(webView_, SIGNAL(fontShrinkRequested()), SLOT(decreaseFontSize()));
 #if defined (Q_OS_UNIX) && !defined(Q_OS_MAC)
 	/* To give a border on Linux, where it looks bad without */
 	QStackedWidget* stack = new QStackedWidget(this);
 	stack->addWidget(webView_);
 	stack->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
 	stack->setLineWidth(2);
 	mainLayout->addWidget(stack);
 #else
 	mainLayout->addWidget(webView_);
 #endif
 
 #ifdef SWIFT_EXPERIMENTAL_FT
 	setAcceptDrops(true);
 #endif
 
 	webPage_ = new QWebPage(this);
 	webPage_->setLinkDelegationPolicy(QWebPage::DelegateAllLinks);
 	if (Log::getLogLevel() == Log::debug) {
 		webPage_->settings()->setAttribute(QWebSettings::DeveloperExtrasEnabled, true);
 	}
 	webView_->setPage(webPage_);
 	connect(webPage_, SIGNAL(selectionChanged()), SLOT(copySelectionToClipboard()));
 	connect(webPage_, SIGNAL(scrollRequested(int, int, const QRect&)), SLOT(handleScrollRequested(int, int, const QRect&)));
 
 	viewReady_ = false;
 	isAtBottom_ = true;
 	resetView();
 
 	jsBridge = new QtChatWindowJSBridge();
 	addToJSEnvironment("chatwindow", jsBridge);
 	connect(jsBridge, SIGNAL(buttonClicked(QString,QString,QString,QString,QString,QString)), this, SLOT(handleHTMLButtonClicked(QString,QString,QString,QString,QString,QString)));
 
 }
 
 QtWebKitChatView::~QtWebKitChatView() {
 	delete jsBridge;
 }
 
 void QtWebKitChatView::handleClearRequested() {
 	QMessageBox messageBox(this);
 	messageBox.setWindowTitle(tr("Clear log"));
 	messageBox.setText(tr("You are about to clear the contents of your chat log."));
 	messageBox.setInformativeText(tr("Are you sure?"));
 	messageBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
 	messageBox.setDefaultButton(QMessageBox::Yes);
 	int button = messageBox.exec();
 	if (button == QMessageBox::Yes) {
 		logCleared();
 		resetView();
 	}
 }
 
 void QtWebKitChatView::handleKeyPressEvent(QKeyEvent* event) {
 	webView_->keyPressEvent(event);
 }
 
 void QtWebKitChatView::addMessageBottom(boost::shared_ptr<ChatSnippet> snippet) {
 	if (viewReady_) {
 		addToDOM(snippet);
 	} else {
 		/* If this asserts, the previous queuing code was necessary and should be reinstated */
 		assert(false);
 	}
 }
 
 void QtWebKitChatView::addMessageTop(boost::shared_ptr<ChatSnippet> snippet) {
 	// save scrollbar maximum value
 	if (!topMessageAdded_) {
 		scrollBarMaximum_ = webPage_->mainFrame()->scrollBarMaximum(Qt::Vertical);
 	}
 	topMessageAdded_ = true;
 
 	QWebElement continuationElement = firstElement_.findFirst("#insert");
 
 	bool insert = snippet->getAppendToPrevious();
 	bool fallback = continuationElement.isNull();
 
 	boost::shared_ptr<ChatSnippet> newSnippet = (insert && fallback) ? snippet->getContinuationFallbackSnippet() : snippet;
 	QWebElement newElement = snippetToDOM(newSnippet);
 
 	if (insert && !fallback) {
 		Q_ASSERT(!continuationElement.isNull());
 		continuationElement.replace(newElement);
 	} else {
 		continuationElement.removeFromDocument();
 		topInsertPoint_.prependOutside(newElement);
 	}
 
 	firstElement_ = newElement;
 
 	if (lastElement_.isNull()) {
 		lastElement_ = firstElement_;
 	}
 
 	if (fontSizeSteps_ != 0) {
 		double size = 1.0 + 0.2 * fontSizeSteps_;
 		QString sizeString(QString().setNum(size, 'g', 3) + "em");
 		const QWebElementCollection spans = firstElement_.findAll("span.swift_resizable");
 		Q_FOREACH (QWebElement span, spans) {
 			span.setStyleProperty("font-size", sizeString);
 		}
 	}
 }
 
 QWebElement QtWebKitChatView::snippetToDOM(boost::shared_ptr<ChatSnippet> snippet) {
 	QWebElement newElement = newInsertPoint_.clone();
 	newElement.setInnerXml(snippet->getContent());
 	Q_ASSERT(!newElement.isNull());
 	return newElement;
 }
 
 void QtWebKitChatView::addToDOM(boost::shared_ptr<ChatSnippet> snippet) {
 	//qDebug() << snippet->getContent();
 	rememberScrolledToBottom();
 	bool insert = snippet->getAppendToPrevious();
 	QWebElement continuationElement = lastElement_.findFirst("#insert");
 	bool fallback = insert && continuationElement.isNull();
 	boost::shared_ptr<ChatSnippet> newSnippet = (insert && fallback) ? snippet->getContinuationFallbackSnippet() : snippet;
 	QWebElement newElement = snippetToDOM(newSnippet);
 	if (insert && !fallback) {
 		Q_ASSERT(!continuationElement.isNull());
 		continuationElement.replace(newElement);
 	} else {
 		continuationElement.removeFromDocument();
 		newInsertPoint_.prependOutside(newElement);
 	}
 	lastElement_ = newElement;
 	if (fontSizeSteps_ != 0) {
 		double size = 1.0 + 0.2 * fontSizeSteps_;
 		QString sizeString(QString().setNum(size, 'g', 3) + "em");
 		const QWebElementCollection spans = lastElement_.findAll("span.swift_resizable");
 		Q_FOREACH (QWebElement span, spans) {
 			span.setStyleProperty("font-size", sizeString);
 		}
 	}
 	//qDebug() << "-----------------";
 	//qDebug() << webPage_->mainFrame()->toHtml();
 }
 
 void QtWebKitChatView::addLastSeenLine() {
 	/* if the line is added we should break the snippet */
 	insertingLastLine_ = true;
 	if (lineSeparator_.isNull()) {
 		lineSeparator_ = newInsertPoint_.clone();
 		lineSeparator_.setInnerXml(QString("<hr/>"));
 		newInsertPoint_.prependOutside(lineSeparator_);
 	}
 	else {
 		QWebElement lineSeparatorC = lineSeparator_.clone();
 		lineSeparatorC.removeFromDocument();
 	}
 	newInsertPoint_.prependOutside(lineSeparator_);
 }
 
-void QtWebKitChatView::replaceLastMessage(const QString& newMessage) {
+void QtWebKitChatView::replaceLastMessage(const QString& newMessage, const ChatWindow::TimestampBehaviour timestampBehaviour) {
 	assert(viewReady_);
 	rememberScrolledToBottom();
 	assert(!lastElement_.isNull());
 	QWebElement replace = lastElement_.findFirst("span.swift_message");
 	assert(!replace.isNull());
 	QString old = lastElement_.toOuterXml();
 	replace.setInnerXml(ChatSnippet::escape(newMessage));
+	if (timestampBehaviour == ChatWindow::UpdateTimestamp) {
+		replace = lastElement_.findFirst("span.swift_time");
+		assert(!replace.isNull());
+		replace.setInnerXml(ChatSnippet::timeToEscapedString(QDateTime::currentDateTime()));
+	}
 }
 
 void QtWebKitChatView::replaceLastMessage(const QString& newMessage, const QString& note) {
 	rememberScrolledToBottom();
-	replaceLastMessage(newMessage);
+	replaceLastMessage(newMessage, ChatWindow::KeepTimestamp);
 	QWebElement replace = lastElement_.findFirst("span.swift_time");
 	assert(!replace.isNull());
 	replace.setInnerXml(ChatSnippet::escape(note));
 }
 
 QString QtWebKitChatView::getLastSentMessage() {
 	return lastElement_.toPlainText();
 }
 
 void QtWebKitChatView::addToJSEnvironment(const QString& name, QObject* obj) {
 	webView_->page()->currentFrame()->addToJavaScriptWindowObject(name, obj);
 }
 
 void QtWebKitChatView::replaceMessage(const QString& newMessage, const QString& id, const QDateTime& editTime) {
 	rememberScrolledToBottom();
 	QWebElement message = document_.findFirst("#" + id);
 	if (!message.isNull()) {
 		QWebElement replaceContent = message.findFirst("span.swift_inner_message");
 		assert(!replaceContent.isNull());
 		QString old = replaceContent.toOuterXml();
 		replaceContent.setInnerXml(ChatSnippet::escape(newMessage));
 		QWebElement replaceTime = message.findFirst("span.swift_time");
 		assert(!replaceTime.isNull());
 		old = replaceTime.toOuterXml();
 		replaceTime.setInnerXml(ChatSnippet::escape(tr("%1 edited").arg(ChatSnippet::timeToEscapedString(editTime))));
 	}
 	else {
 		qWarning() << "Trying to replace element with id " << id << " but it's not there.";
 	}
 }
 
 void QtWebKitChatView::showEmoticons(bool show) {
 	showEmoticons_ = show;
 	{
 		const QWebElementCollection spans = document_.findAll("span.swift_emoticon_image");
 		Q_FOREACH (QWebElement span, spans) {
 			span.setStyleProperty("display", show ? "inline" : "none");
 		}
 	}
 	{
 		const QWebElementCollection spans = document_.findAll("span.swift_emoticon_text");
 		Q_FOREACH (QWebElement span, spans) {
 			span.setStyleProperty("display", show ? "none" : "inline");
 		}
 	}
 }
 
 void QtWebKitChatView::copySelectionToClipboard() {
 	if (!webPage_->selectedText().isEmpty()) {
 		webPage_->triggerAction(QWebPage::Copy);
 	}
 }
 
 void QtWebKitChatView::setAckXML(const QString& id, const QString& xml) {
 	QWebElement message = document_.findFirst("#" + id);
 	/* Deliberately not asserting here, so that when we start expiring old messages it won't hit us */
 	if (message.isNull()) return;
 	QWebElement ackElement = message.findFirst("span.swift_ack");
 	assert(!ackElement.isNull());
 	ackElement.setInnerXml(xml);
 }
 
 void QtWebKitChatView::setReceiptXML(const QString& id, const QString& xml) {
 	QWebElement message = document_.findFirst("#" + id);
 	if (message.isNull()) return;
 	QWebElement receiptElement = message.findFirst("span.swift_receipt");
 	assert(!receiptElement.isNull());
 	receiptElement.setInnerXml(xml);
 }
 
 void QtWebKitChatView::displayReceiptInfo(const QString& id, bool showIt) {
 	QWebElement message = document_.findFirst("#" + id);
 	if (message.isNull()) return;
 	QWebElement receiptElement = message.findFirst("span.swift_receipt");
 	assert(!receiptElement.isNull());
 	receiptElement.setStyleProperty("display", showIt ? "inline" : "none");
 }
 
 void QtWebKitChatView::rememberScrolledToBottom() {
 	isAtBottom_ = webPage_->mainFrame()->scrollBarValue(Qt::Vertical) >= (webPage_->mainFrame()->scrollBarMaximum(Qt::Vertical) - 1);
 }
 
 void QtWebKitChatView::scrollToBottom() {
 	isAtBottom_ = true;
 	webPage_->mainFrame()->setScrollBarValue(Qt::Vertical, webPage_->mainFrame()->scrollBarMaximum(Qt::Vertical));
 	webView_->update(); /* Work around redraw bug in some versions of Qt. */
 }
 
 void QtWebKitChatView::handleFrameSizeChanged() {
 	if (topMessageAdded_) {
 		// adjust new scrollbar position
 		int newMaximum = webPage_->mainFrame()->scrollBarMaximum(Qt::Vertical);
 		webPage_->mainFrame()->setScrollBarValue(Qt::Vertical, newMaximum - scrollBarMaximum_);
 		topMessageAdded_ = false;
 	}
 
 	if (isAtBottom_ && !disableAutoScroll_) {
 		scrollToBottom();
 	}
 }
 
 void QtWebKitChatView::handleLinkClicked(const QUrl& url) {
 	QDesktopServices::openUrl(url);
 }
 
 void QtWebKitChatView::handleViewLoadFinished(bool ok) {
 	Q_ASSERT(ok);
 	viewReady_ = true;
 }
 
 void QtWebKitChatView::increaseFontSize(int numSteps) {
 	//qDebug() << "Increasing";
 	fontSizeSteps_ += numSteps;
 	emit fontResized(fontSizeSteps_);
 }
 
 void QtWebKitChatView::decreaseFontSize() {
 	fontSizeSteps_--;
 	if (fontSizeSteps_ < 0) {
 		fontSizeSteps_ = 0;
 	}
 	emit fontResized(fontSizeSteps_);
 }
 
 void QtWebKitChatView::resizeFont(int fontSizeSteps) {
 	fontSizeSteps_ = fontSizeSteps;
 	double size = 1.0 + 0.2 * fontSizeSteps_;
 	QString sizeString(QString().setNum(size, 'g', 3) + "em");
 	//qDebug() << "Setting to " << sizeString;
 	const QWebElementCollection spans = document_.findAll("span.swift_resizable");
 	Q_FOREACH (QWebElement span, spans) {
 		span.setStyleProperty("font-size", sizeString);
 	}
 	webView_->setFontSizeIsMinimal(size == 1.0);
 }
 
 void QtWebKitChatView::resetView() {
 	lastElement_ = QWebElement();
 	firstElement_ = lastElement_;
 	topMessageAdded_ = false;
 	scrollBarMaximum_ = 0;
 	QString pageHTML = theme_->getTemplate();
 	pageHTML.replace("==bodyBackground==", "background-color:#e3e3e3");
 	pageHTML.replace(pageHTML.indexOf("%@"), 2, theme_->getBase());
 	if (pageHTML.count("%@") > 3) {
 		pageHTML.replace(pageHTML.indexOf("%@"), 2, theme_->getMainCSS());
 	}
 	pageHTML.replace(pageHTML.indexOf("%@"), 2, "Variants/Blue on Green.css");
 	pageHTML.replace(pageHTML.indexOf("%@"), 2, ""/*headerSnippet.getContent()*/);
 	pageHTML.replace(pageHTML.indexOf("%@"), 2, ""/*footerSnippet.getContent()*/);
 	QEventLoop syncLoop;
 	connect(webView_, SIGNAL(loadFinished(bool)), &syncLoop, SLOT(quit()));
 	webPage_->mainFrame()->setHtml(pageHTML);
 	while (!viewReady_) {
 		QTimer t;
 		t.setSingleShot(true);
 		connect(&t, SIGNAL(timeout()), &syncLoop, SLOT(quit()));
 		t.start(50);
 		syncLoop.exec();
 	}
 	document_ = webPage_->mainFrame()->documentElement();
 
 	resetTopInsertPoint();
 	QWebElement chatElement = document_.findFirst("#Chat");
 	newInsertPoint_ = chatElement.clone();
 	newInsertPoint_.setOuterXml("<div id='swift_insert'/>");
 	chatElement.appendInside(newInsertPoint_);
 	Q_ASSERT(!newInsertPoint_.isNull());
 
 	scrollToBottom();
 
 	connect(webPage_->mainFrame(), SIGNAL(contentsSizeChanged(const QSize&)), this, SLOT(handleFrameSizeChanged()), Qt::UniqueConnection);
 }
 
 static QWebElement findElementWithID(QWebElement document, QString elementName, QString id) {
 	QWebElementCollection elements = document.findAll(elementName);
 	Q_FOREACH(QWebElement element, elements) {
 		if (element.attribute("id") == id) {
 			return element;
 		}
 	}
 	return QWebElement();
 }
 
 void QtWebKitChatView::setFileTransferProgress(QString id, const int percentageDone) {
 	QWebElement ftElement = findElementWithID(document_, "div", id);
 	if (ftElement.isNull()) {
 		SWIFT_LOG(debug) << "Tried to access FT UI via invalid id!" << std::endl;
 		return;
 	}
 	QWebElement progressBar = ftElement.findFirst("div.progressbar");
 	progressBar.setStyleProperty("width", QString::number(percentageDone) + "%");
 
 	QWebElement progressBarValue = ftElement.findFirst("div.progressbar-value");
 	progressBarValue.setInnerXml(QString::number(percentageDone) + " %");
 }
 
 void QtWebKitChatView::setFileTransferStatus(QString id, const ChatWindow::FileTransferState state, const QString& /* msg */) {
 	QWebElement ftElement = findElementWithID(document_, "div", id);
 	if (ftElement.isNull()) {
 		SWIFT_LOG(debug) << "Tried to access FT UI via invalid id! id = " << Q2PSTRING(id) << std::endl;
 		return;
 	}
 
 	QString newInnerHTML = "";
 	if (state == ChatWindow::WaitingForAccept) {
 		newInnerHTML =	tr("Waiting for other side to accept the transfer.") + "<br/>" +
 			buildChatWindowButton(tr("Cancel"), ButtonFileTransferCancel, id);
 	}
 	if (state == ChatWindow::Negotiating) {
 		// replace with text "Negotiaging" + Cancel button
 		newInnerHTML =	tr("Negotiating...") + "<br/>" +
 			buildChatWindowButton(tr("Cancel"), ButtonFileTransferCancel, id);
 	}
 	else if (state == ChatWindow::Transferring) {
 		// progress bar + Cancel Button
 		newInnerHTML =	"<div style=\"position: relative; width: 90%; height: 20px; border: 2px solid grey; -webkit-border-radius: 10px;\">"
 							"<div class=\"progressbar\" style=\"width: 0%; height: 100%; background: #AAA; -webkit-border-radius: 6px;\">"
 								"<div class=\"progressbar-value\" style=\"position: absolute; top: 0px; left: 0px; width: 100%; text-align: center; padding-top: 2px;\">"
 									"0%"
 								"</div>"
 							"</div>"
 						"</div>" +
 						buildChatWindowButton(tr("Cancel"), ButtonFileTransferCancel, id);
 	}
 	else if (state == ChatWindow::Canceled) {
 		newInnerHTML = tr("Transfer has been canceled!");
 	}
 	else if (state == ChatWindow::Finished) {
 		// text "Successful transfer"
 		newInnerHTML = tr("Transfer completed successfully.");
 	}
 	else if (state == ChatWindow::FTFailed) {
 		newInnerHTML = tr("Transfer failed.");
 	}
 
 	ftElement.setInnerXml(newInnerHTML);
 }
 
 void QtWebKitChatView::setWhiteboardSessionStatus(QString id, const ChatWindow::WhiteboardSessionState state) {
 	QWebElement divElement = findElementWithID(document_, "div", id);
 	QString newInnerHTML;
 	if (state == ChatWindow::WhiteboardAccepted) {
 		newInnerHTML =	tr("Started whiteboard chat") + "<br/>" + buildChatWindowButton(tr("Show whiteboard"), ButtonWhiteboardShowWindow, id);
 	} else if (state == ChatWindow::WhiteboardTerminated) {
 		newInnerHTML =	tr("Whiteboard chat has been canceled");
 	} else if (state == ChatWindow::WhiteboardRejected) {
 		newInnerHTML =	tr("Whiteboard chat request has been rejected");
 	}
 	divElement.setInnerXml(newInnerHTML);
 }
 
 void QtWebKitChatView::setMUCInvitationJoined(QString id) {
 	QWebElement divElement = findElementWithID(document_, "div", id);
 	QWebElement buttonElement = findElementWithID(divElement, "input", "mucinvite");
 	if (!buttonElement.isNull()) {
 		buttonElement.setAttribute("value", tr("Return to room"));
 	}
 }
 
 void QtWebKitChatView::handleScrollRequested(int, int dy, const QRect&) {
 	rememberScrolledToBottom();
 
 	int pos = webPage_->mainFrame()->scrollBarValue(Qt::Vertical) - dy;
 	emit scrollRequested(pos);
 
 	if (pos == 0) {
 		emit scrollReachedTop();
 	}
 	else if (pos == webPage_->mainFrame()->scrollBarMaximum(Qt::Vertical)) {
 		emit scrollReachedBottom();
 	}
 }
 
 int QtWebKitChatView::getSnippetPositionByDate(const QDate& date) {
 	QWebElement message = webPage_->mainFrame()->documentElement().findFirst(".date" + date.toString(Qt::ISODate));
 
 	return message.geometry().top();
 }
 
 void QtWebKitChatView::resetTopInsertPoint() {
 	QWebElement continuationElement = firstElement_.findFirst("#insert");
 	continuationElement.removeFromDocument();
 	firstElement_ = QWebElement();
 
 	topInsertPoint_.removeFromDocument();
 	QWebElement chatElement = document_.findFirst("#Chat");
 	topInsertPoint_ = chatElement.clone();
 	topInsertPoint_.setOuterXml("<div id='swift_insert'/>");
 	chatElement.prependInside(topInsertPoint_);
 }
 
 
 std::string QtWebKitChatView::addMessage(
 		const ChatWindow::ChatMessage& message, 
 		const std::string& senderName, 
 		bool senderIsSelf, 
 		boost::shared_ptr<SecurityLabel> label, 
 		const std::string& avatarPath, 
 		const boost::posix_time::ptime& time, 
 		const HighlightAction& highlight) {
 	return addMessage(chatMessageToHTML(message), senderName, senderIsSelf, label, avatarPath, "", time, highlight, ChatSnippet::getDirection(message));
 }
 
 QString QtWebKitChatView::chatMessageToHTML(const ChatWindow::ChatMessage& message) {
 	QString result;
 	foreach (boost::shared_ptr<ChatWindow::ChatMessagePart> part, message.getParts()) {
 		boost::shared_ptr<ChatWindow::ChatTextMessagePart> textPart;
 		boost::shared_ptr<ChatWindow::ChatURIMessagePart> uriPart;
 		boost::shared_ptr<ChatWindow::ChatEmoticonMessagePart> emoticonPart;
 		boost::shared_ptr<ChatWindow::ChatHighlightingMessagePart> highlightPart;
 
 		if ((textPart = boost::dynamic_pointer_cast<ChatWindow::ChatTextMessagePart>(part))) {
 			QString text = QtUtilities::htmlEscape(P2QSTRING(textPart->text));
 			text.replace("\n","<br/>");
 			result += text;
 			continue;
 		}
 		if ((uriPart = boost::dynamic_pointer_cast<ChatWindow::ChatURIMessagePart>(part))) {
 			QString uri = QtUtilities::htmlEscape(P2QSTRING(uriPart->target));
 			result += "<a href='" + uri + "' >" + uri + "</a>";
 			continue;
 		}
 		if ((emoticonPart = boost::dynamic_pointer_cast<ChatWindow::ChatEmoticonMessagePart>(part))) {
 			QString textStyle = showEmoticons_ ? "style='display:none'" : "";
 			QString imageStyle = showEmoticons_ ? "" : "style='display:none'";
 			result += "<span class='swift_emoticon_image' " + imageStyle + "><img src='" + P2QSTRING(emoticonPart->imagePath) + "'/></span><span class='swift_emoticon_text' " + textStyle + ">" + QtUtilities::htmlEscape(P2QSTRING(emoticonPart->alternativeText)) + "</span>";
 			continue;
 		}
 		if ((highlightPart = boost::dynamic_pointer_cast<ChatWindow::ChatHighlightingMessagePart>(part))) {
 			//FIXME: Maybe do something here. Anything, really.
 			continue;
 		}
 
 	}
 	return result;
 }
 
 
 QString QtWebKitChatView::getHighlightSpanStart(const HighlightAction& highlight) {
 	QString color = QtUtilities::htmlEscape(P2QSTRING(highlight.getTextColor()));
 	QString background = QtUtilities::htmlEscape(P2QSTRING(highlight.getTextBackground()));
 	if (color.isEmpty()) {
 		color = "black";
 	}
 	if (background.isEmpty()) {
 		background = "yellow";
 	}
 
 	return QString("<span style=\"color: %1; background: %2\">").arg(color).arg(background);
 }
 
 std::string QtWebKitChatView::addMessage(
 		const QString& message, 
 		const std::string& senderName, 
 		bool senderIsSelf, 
 		boost::shared_ptr<SecurityLabel> label, 
 		const std::string& avatarPath, 
 		const QString& style, 
 		const boost::posix_time::ptime& time, 
 		const HighlightAction& highlight,
 		ChatSnippet::Direction direction) {
 
 	QString scaledAvatarPath = QtScaledAvatarCache(32).getScaledAvatarPath(avatarPath.c_str());
 
 	QString htmlString;
 	if (label) {
 		htmlString = QString("<span style=\"border: thin dashed grey; padding-left: .5em; padding-right: .5em; color: %1; background-color: %2; font-size: 90%; margin-right: .5em; \" class='swift_label'>").arg(QtUtilities::htmlEscape(P2QSTRING(label->getForegroundColor()))).arg(QtUtilities::htmlEscape(P2QSTRING(label->getBackgroundColor())));
 		htmlString += QString("%1</span> ").arg(QtUtilities::htmlEscape(P2QSTRING(label->getDisplayMarking())));
 	}
 
 	QString styleSpanStart = style == "" ? "" : "<span style=\"" + style + "\">";
 	QString styleSpanEnd = style == "" ? "" : "</span>";
 	QString highlightSpanStart = highlight.highlightText() ? getHighlightSpanStart(highlight) : "";
 	QString highlightSpanEnd = highlight.highlightText() ? "</span>" : "";
 	htmlString += "<span class='swift_inner_message'>" + styleSpanStart + highlightSpanStart + message + highlightSpanEnd + styleSpanEnd + "</span>" ;
 
 	bool appendToPrevious = appendToPreviousCheck(PreviousMessageWasMessage, senderName, senderIsSelf);
 
 	QString qAvatarPath =  scaledAvatarPath.isEmpty() ? "qrc:/icons/avatar.png" : QUrl::fromLocalFile(scaledAvatarPath).toEncoded();
 	std::string id = "id" + boost::lexical_cast<std::string>(idCounter_++);
 	addMessageBottom(boost::make_shared<MessageSnippet>(htmlString, QtUtilities::htmlEscape(P2QSTRING(senderName)), B2QDATE(time), qAvatarPath, senderIsSelf, appendToPrevious, theme_, P2QSTRING(id), direction));
 
 	previousMessageWasSelf_ = senderIsSelf;
 	previousSenderName_ = P2QSTRING(senderName);
 	previousMessageKind_ = PreviousMessageWasMessage;
 	return id;
 }
 
 std::string QtWebKitChatView::addAction(const ChatWindow::ChatMessage& message, const std::string &senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) {
 	return addMessage(" *" + chatMessageToHTML(message) + "*", senderName, senderIsSelf, label, avatarPath, "font-style:italic ", time, highlight, ChatSnippet::getDirection(message));
 }
 
 static QString encodeButtonArgument(const QString& str) {
 	return QtUtilities::htmlEscape(P2QSTRING(Base64::encode(createByteArray(Q2PSTRING(str)))));
 }
 
 static QString decodeButtonArgument(const QString& str) {
 	return P2QSTRING(byteArrayToString(Base64::decode(Q2PSTRING(str))));
 }
 
 QString QtWebKitChatView::buildChatWindowButton(const QString& name, const QString& id, const QString& arg1, const QString& arg2, const QString& arg3, const QString& arg4, const QString& arg5) {
 	QRegExp regex("[A-Za-z][A-Za-z0-9\\-\\_]+");
 	Q_ASSERT(regex.exactMatch(id));
 	QString html = QString("<input id='%2' type='submit' value='%1' onclick='chatwindow.buttonClicked(\"%2\", \"%3\", \"%4\", \"%5\", \"%6\", \"%7\");' />").arg(name).arg(id).arg(encodeButtonArgument(arg1)).arg(encodeButtonArgument(arg2)).arg(encodeButtonArgument(arg3)).arg(encodeButtonArgument(arg4)).arg(encodeButtonArgument(arg5));
 	return html;
 }
 
 std::string QtWebKitChatView::addFileTransfer(const std::string& senderName, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes) {
 	SWIFT_LOG(debug) << "addFileTransfer" << std::endl;
 	QString ft_id = QString("ft%1").arg(P2QSTRING(boost::lexical_cast<std::string>(idCounter_++)));
 	
 	QString actionText;
 	QString htmlString;
 	QString formattedFileSize = P2QSTRING(formatSize(sizeInBytes));
 	if (senderIsSelf) {
 		// outgoing
 		actionText = tr("Send file");
 		htmlString = actionText + ": " + P2QSTRING(filename) + " ( " + formattedFileSize + ") <br/>" +
 			"<div id='" + ft_id + "'>" +
 				buildChatWindowButton(tr("Cancel"), ButtonFileTransferCancel, ft_id) +
 				buildChatWindowButton(tr("Set Description"), ButtonFileTransferSetDescription, ft_id) +
 				buildChatWindowButton(tr("Send"), ButtonFileTransferSendRequest, ft_id) +
 			"</div>";
 	} else {
 		// incoming
 		actionText = tr("Receiving file");
 		htmlString = actionText + ": " + P2QSTRING(filename) + " ( " + formattedFileSize  + ") <br/>" +
 			"<div id='" + ft_id + "'>" +
 				buildChatWindowButton(tr("Cancel"), ButtonFileTransferCancel, ft_id) +
 				buildChatWindowButton(tr("Accept"), ButtonFileTransferAcceptRequest, ft_id, P2QSTRING(filename)) +
 			"</div>";
 	}
 
 	//addMessage(message, senderName, senderIsSelf, boost::shared_ptr<SecurityLabel>(), "", boost::posix_time::second_clock::local_time());
 
 	bool appendToPrevious = appendToPreviousCheck(PreviousMessageWasFileTransfer, senderName, senderIsSelf);
 
 	QString qAvatarPath = "qrc:/icons/avatar.png";
 	std::string id = "ftmessage" + boost::lexical_cast<std::string>(idCounter_++);
 	addMessageBottom(boost::make_shared<MessageSnippet>(htmlString, QtUtilities::htmlEscape(P2QSTRING(senderName)), B2QDATE(boost::posix_time::second_clock::local_time()), qAvatarPath, senderIsSelf, appendToPrevious, theme_, P2QSTRING(id), ChatSnippet::getDirection(actionText)));
 
 	previousMessageWasSelf_ = senderIsSelf;
 	previousSenderName_ = P2QSTRING(senderName);
 	previousMessageKind_ = PreviousMessageWasFileTransfer;
 	return Q2PSTRING(ft_id);
 }
 
 void QtWebKitChatView::setFileTransferProgress(std::string id, const int percentageDone) {
 	setFileTransferProgress(P2QSTRING(id), percentageDone);
 }
 
 void QtWebKitChatView::setFileTransferStatus(std::string id, const ChatWindow::FileTransferState state, const std::string& msg) {
 	setFileTransferStatus(P2QSTRING(id), state, P2QSTRING(msg));
 }
 
 std::string QtWebKitChatView::addWhiteboardRequest(const QString& contact, bool senderIsSelf) {
 	QString wb_id = QString("wb%1").arg(P2QSTRING(boost::lexical_cast<std::string>(idCounter_++)));
 	QString htmlString;
 	QString actionText;
 	if (senderIsSelf) {
 		actionText = tr("Starting whiteboard chat");
 		htmlString = "<div id='" + wb_id + "'>" + actionText + "<br />"+
 				buildChatWindowButton(tr("Cancel"), ButtonWhiteboardSessionCancel, wb_id) +
 			"</div>";
 	} else {
 		actionText = tr("%1 would like to start a whiteboard chat");
 		htmlString = "<div id='" + wb_id + "'>" + actionText.arg(QtUtilities::htmlEscape(contact)) + ": <br/>" +
 				buildChatWindowButton(tr("Cancel"), ButtonWhiteboardSessionCancel, wb_id) +
 				buildChatWindowButton(tr("Accept"), ButtonWhiteboardSessionAcceptRequest, wb_id) +
 			"</div>";
 	}
 	QString qAvatarPath = "qrc:/icons/avatar.png";
 	std::string id = "wbmessage" + boost::lexical_cast<std::string>(idCounter_++);
 	addMessageBottom(boost::make_shared<MessageSnippet>(htmlString, QtUtilities::htmlEscape(contact), B2QDATE(boost::posix_time::second_clock::local_time()), qAvatarPath, false, false, theme_, P2QSTRING(id), ChatSnippet::getDirection(actionText)));
 	previousMessageWasSelf_ = false;
 	previousSenderName_ = contact;
 	return Q2PSTRING(wb_id);
 }
 
 void QtWebKitChatView::setWhiteboardSessionStatus(const std::string& id, const ChatWindow::WhiteboardSessionState state) {
 	setWhiteboardSessionStatus(P2QSTRING(id), state);
 }
 
 
 
 
 void QtWebKitChatView::handleHTMLButtonClicked(QString id, QString encodedArgument1, QString encodedArgument2, QString encodedArgument3, QString encodedArgument4, QString encodedArgument5) {
 	QString arg1 = decodeButtonArgument(encodedArgument1);
 	QString arg2 = decodeButtonArgument(encodedArgument2);
 	QString arg3 = decodeButtonArgument(encodedArgument3);
 	QString arg4 = decodeButtonArgument(encodedArgument4);
 	QString arg5 = decodeButtonArgument(encodedArgument5);
 
 	if (id.startsWith(ButtonFileTransferCancel)) {
 		QString ft_id = arg1;
 		window_->onFileTransferCancel(Q2PSTRING(ft_id));
 	}
 	else if (id.startsWith(ButtonFileTransferSetDescription)) {
 		QString ft_id = arg1;
 		bool ok = false;
 		QString text = QInputDialog::getText(this, tr("File transfer description"),
 			tr("Description:"), QLineEdit::Normal, "", &ok);
 		if (ok) {
 			descriptions_[ft_id] = text;
 		}
 	}
 	else if (id.startsWith(ButtonFileTransferSendRequest)) {
 		QString ft_id = arg1;
 		QString text = descriptions_.find(ft_id) == descriptions_.end() ? QString() : descriptions_[ft_id];
 		window_->onFileTransferStart(Q2PSTRING(ft_id), Q2PSTRING(text));
 	}
 	else if (id.startsWith(ButtonFileTransferAcceptRequest)) {
 		QString ft_id = arg1;
 		QString filename = arg2;
 
 		QString path = QFileDialog::getSaveFileName(this, tr("Save File"), filename);
 		if (!path.isEmpty()) {
 			window_->onFileTransferAccept(Q2PSTRING(ft_id), Q2PSTRING(path));
 		}
 	}
 	else if (id.startsWith(ButtonWhiteboardSessionAcceptRequest)) {
 		QString id = arg1;
 		setWhiteboardSessionStatus(id, ChatWindow::WhiteboardAccepted);
 		window_->onWhiteboardSessionAccept();
 	}
 	else if (id.startsWith(ButtonWhiteboardSessionCancel)) {
 		QString id = arg1;
 		setWhiteboardSessionStatus(id, ChatWindow::WhiteboardTerminated);
 		window_->onWhiteboardSessionCancel();
 	}
 	else if (id.startsWith(ButtonWhiteboardShowWindow)) {
 		QString id = arg1;
 		window_->onWhiteboardWindowShow();
 	}
 	else if (id.startsWith(ButtonMUCInvite)) {
 		QString roomJID = arg1;
 		QString password = arg2;
 		QString elementID = arg3;
 		QString isImpromptu = arg4;
 		QString isContinuation = arg5;
 		eventStream_->send(boost::make_shared<JoinMUCUIEvent>(Q2PSTRING(roomJID), Q2PSTRING(password), boost::optional<std::string>(), false, false, isImpromptu.contains("true"), isContinuation.contains("true")));
 		setMUCInvitationJoined(elementID);
 	}
 	else {
 		SWIFT_LOG(debug) << "Unknown HTML button! ( " << Q2PSTRING(id) << " )" << std::endl;
 	}
 }
 
 void QtWebKitChatView::addErrorMessage(const ChatWindow::ChatMessage& errorMessage) {
 	if (window_->isWidgetSelected()) {
 		window_->onAllMessagesRead();
 	}
 
 	QString errorMessageHTML(chatMessageToHTML(errorMessage));
 	
 	addMessageBottom(boost::make_shared<SystemMessageSnippet>("<span class=\"error\">" + errorMessageHTML + "</span>", QDateTime::currentDateTime(), false, theme_, ChatSnippet::getDirection(errorMessage)));
 
 	previousMessageWasSelf_ = false;
 	previousMessageKind_ = PreviousMessageWasSystem;
 }
 
 void QtWebKitChatView::addSystemMessage(const ChatWindow::ChatMessage& message, ChatWindow::Direction direction) {
 	if (window_->isWidgetSelected()) {
 		window_->onAllMessagesRead();
 	}
 
 	QString messageHTML = chatMessageToHTML(message);
 	addMessageBottom(boost::make_shared<SystemMessageSnippet>(messageHTML, QDateTime::currentDateTime(), false, theme_, getActualDirection(message, direction)));
 
 	previousMessageKind_ = PreviousMessageWasSystem;
 }
 
 void QtWebKitChatView::replaceWithAction(const ChatWindow::ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& highlight) {
 	replaceMessage(" *" + chatMessageToHTML(message) + "*", id, time, "font-style:italic ", highlight);
 }
 
 void QtWebKitChatView::replaceMessage(const ChatWindow::ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& highlight) {
 	replaceMessage(chatMessageToHTML(message), id, time, "", highlight);
 }
 
 void QtWebKitChatView::replaceMessage(const QString& message, const std::string& id, const boost::posix_time::ptime& time, const QString& style, const HighlightAction& highlight) {
 	if (!id.empty()) {
 		if (window_->isWidgetSelected()) {
 			window_->onAllMessagesRead();
 		}
 
 		QString messageHTML(message);
 
 		QString styleSpanStart = style == "" ? "" : "<span style=\"" + style + "\">";
 		QString styleSpanEnd = style == "" ? "" : "</span>";
 		QString highlightSpanStart = highlight.highlightText() ? getHighlightSpanStart(highlight) : "";
 		QString highlightSpanEnd = highlight.highlightText() ? "</span>" : "";
 		messageHTML = styleSpanStart + highlightSpanStart + messageHTML + highlightSpanEnd + styleSpanEnd;
 
 		replaceMessage(messageHTML, P2QSTRING(id), B2QDATE(time));
 	}
 	else {
 		std::cerr << "Trying to replace a message with no id";
 	}
 }
 
 void QtWebKitChatView::addPresenceMessage(const ChatWindow::ChatMessage& message, ChatWindow::Direction direction) {
 	if (window_->isWidgetSelected()) {
 		window_->onAllMessagesRead();
 	}
 
 	QString messageHTML = chatMessageToHTML(message);
 	addMessageBottom(boost::make_shared<SystemMessageSnippet>(messageHTML, QDateTime::currentDateTime(), false, theme_, getActualDirection(message, direction)));
 
 	previousMessageKind_ = PreviousMessageWasPresence;
 }
 
-void QtWebKitChatView::replaceLastMessage(const ChatWindow::ChatMessage& message) {
-	replaceLastMessage(chatMessageToHTML(message));
+void QtWebKitChatView::replaceLastMessage(const ChatWindow::ChatMessage& message, const ChatWindow::TimestampBehaviour timestampBehaviour) {
+	replaceLastMessage(chatMessageToHTML(message), timestampBehaviour);
 }
 
 void QtWebKitChatView::addMUCInvitation(const std::string& senderName, const JID& jid, const std::string& reason, const std::string& password, bool direct, bool isImpromptu, bool isContinuation) {
 	if (window_->isWidgetSelected()) {
 		window_->onAllMessagesRead();
 	}
 
 	QString message;
 	if (isImpromptu) {
 		message = QObject::tr("You've been invited to join a chat.") + "\n";
 	} else {
 		message = QObject::tr("You've been invited to enter the %1 room.").arg(P2QSTRING(jid.toString())) + "\n";
 	}
 	QString htmlString = message;
 	if (!reason.empty()) {
 		htmlString += QObject::tr("Reason: %1").arg(P2QSTRING(reason)) + "\n";
 	}
 	if (!direct) {
 		htmlString += QObject::tr("This person may not have really sent this invitation!") + "\n";
 	}
 	htmlString = chatMessageToHTML(ChatWindow::ChatMessage(Q2PSTRING(htmlString)));
 
 
 	QString id = QString(ButtonMUCInvite + "%1").arg(P2QSTRING(boost::lexical_cast<std::string>(idCounter_++)));
 	htmlString += "<div id='" + id + "'>" +
 			buildChatWindowButton(chatMessageToHTML(ChatWindow::ChatMessage(Q2PSTRING((tr("Accept Invite"))))), ButtonMUCInvite, QtUtilities::htmlEscape(P2QSTRING(jid.toString())), QtUtilities::htmlEscape(P2QSTRING(password)), id, QtUtilities::htmlEscape(isImpromptu ? "true" : "false"), QtUtilities::htmlEscape(isContinuation ? "true" : "false")) +
 		"</div>";
 
 	bool appendToPrevious = appendToPreviousCheck(PreviousMessageWasMUCInvite, senderName, false);
 
 	QString qAvatarPath = "qrc:/icons/avatar.png";
 
 	addMessageBottom(boost::make_shared<MessageSnippet>(htmlString, QtUtilities::htmlEscape(P2QSTRING(senderName)), B2QDATE(boost::posix_time::second_clock::local_time()), qAvatarPath, false, appendToPrevious, theme_, id, ChatSnippet::getDirection(message)));
 	previousMessageWasSelf_ = false;
 	previousSenderName_ = P2QSTRING(senderName);
 	previousMessageKind_ = PreviousMessageWasMUCInvite;
 }
 
 void QtWebKitChatView::setAckState(std::string const& id, ChatWindow::AckState state) {
 	QString xml;
 	switch (state) {
 		case ChatWindow::Pending:
 			xml = "<img src='qrc:/icons/throbber.gif' title='" + tr("This message has not been received by your server yet.") + "'/>";
 			displayReceiptInfo(P2QSTRING(id), false);
 			break;
 		case ChatWindow::Received:
 			xml = "";
 			displayReceiptInfo(P2QSTRING(id), true);
 			break;
 		case ChatWindow::Failed: xml = "<img src='qrc:/icons/error.png' title='" + tr("This message may not have been transmitted.") + "'/>"; break;
 	}
 	setAckXML(P2QSTRING(id), xml);
 }
 
 void QtWebKitChatView::setMessageReceiptState(const std::string& id, ChatWindow::ReceiptState state) {
 	QString xml;
 	switch (state) {
 		case ChatWindow::ReceiptReceived:
 			xml = "<img src='qrc:/icons/check.png' title='" + tr("The receipt for this message has been received.") + "'/>";
 			break;
 		case ChatWindow::ReceiptRequested:
 			xml = "<img src='qrc:/icons/warn.png' title='" + tr("The receipt for this message has not yet been received. The recipient(s) might not have received this message.") + "'/>";
 			break;
 		case ChatWindow::ReceiptFailed:
 			xml = "<img src='qrc:/icons/error.png' title='" + tr("Failed to transmit message to the receipient(s).") + "'/>";
 	}
 	setReceiptXML(P2QSTRING(id), xml);
 }
 
 bool QtWebKitChatView::appendToPreviousCheck(PreviousMessageKind messageKind, const std::string& senderName, bool senderIsSelf) {
 	bool result = previousMessageKind_ == messageKind && ((senderIsSelf && previousMessageWasSelf_) || (!senderIsSelf && !previousMessageWasSelf_&& previousSenderName_ == P2QSTRING(senderName)));
 	if (insertingLastLine_) {
 		insertingLastLine_ = false;
 		return false;
 	}
 	return result;
 }
 
 ChatSnippet::Direction QtWebKitChatView::getActualDirection(const ChatWindow::ChatMessage& message, ChatWindow::Direction direction) {
 	if (direction == ChatWindow::DefaultDirection) {
 		return QCoreApplication::translate("QApplication", "QT_LAYOUT_DIRECTION") == "RTL" ? ChatSnippet::RTL : ChatSnippet::LTR;
 	}
 	else {
 		return ChatSnippet::getDirection(message);
 	}
 }
 
 // void QtWebKitChatView::setShowEmoticons(bool value) {
 // 	showEmoticons_ = value;
 // }
 
 
 }
diff --git a/Swift/QtUI/QtWebKitChatView.h b/Swift/QtUI/QtWebKitChatView.h
index bdb2a75..fb6e4da 100644
--- a/Swift/QtUI/QtWebKitChatView.h
+++ b/Swift/QtUI/QtWebKitChatView.h
@@ -1,187 +1,187 @@
 /*
  * Copyright (c) 2010-2013 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #pragma once
 
 #include <QString>
 #include <QWidget>
 #include <QList>
 #include <QWebElement>
 
 #include <boost/shared_ptr.hpp>
 
 #include <Swiften/Base/Override.h>
 
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 
 #include <Swift/QtUI/ChatSnippet.h>
 #include <Swift/QtUI/QtChatView.h>
 
 class QWebPage;
 class QUrl;
 class QDate;
 
 namespace Swift {
 	class QtWebView;
 	class QtChatTheme;
 	class QtChatWindowJSBridge;
 	class UIEventStream;
 	class QtChatWindow;
 	class QtWebKitChatView : public QtChatView {
 			Q_OBJECT
 
 		public:
 			static const QString ButtonWhiteboardSessionCancel;
 			static const QString ButtonWhiteboardSessionAcceptRequest;
 			static const QString ButtonWhiteboardShowWindow;
 			static const QString ButtonFileTransferCancel;
 			static const QString ButtonFileTransferSetDescription;
 			static const QString ButtonFileTransferSendRequest;
 			static const QString ButtonFileTransferAcceptRequest;
 			static const QString ButtonMUCInvite;
 		public:
 			QtWebKitChatView(QtChatWindow* window, UIEventStream* eventStream, QtChatTheme* theme, QWidget* parent, bool disableAutoScroll = false);
 			~QtWebKitChatView();
 
 			/** Add message to window.
 			 * @return id of added message (for acks).
 			 */
 			virtual std::string addMessage(const ChatWindow::ChatMessage& message, const std::string& senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) SWIFTEN_OVERRIDE;
 			/** Adds action to window.
 			 * @return id of added message (for acks);
 			 */
 			virtual std::string addAction(const ChatWindow::ChatMessage& message, const std::string& senderName, bool senderIsSelf, boost::shared_ptr<SecurityLabel> label, const std::string& avatarPath, const boost::posix_time::ptime& time, const HighlightAction& highlight) SWIFTEN_OVERRIDE;
 
 			virtual void addSystemMessage(const ChatWindow::ChatMessage& message, ChatWindow::Direction direction) SWIFTEN_OVERRIDE;
 			virtual void addPresenceMessage(const ChatWindow::ChatMessage& message, ChatWindow::Direction direction) SWIFTEN_OVERRIDE;
 
 			virtual void addErrorMessage(const ChatWindow::ChatMessage& message) SWIFTEN_OVERRIDE;
 			virtual void replaceMessage(const ChatWindow::ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& highlight) SWIFTEN_OVERRIDE;
 			virtual void replaceWithAction(const ChatWindow::ChatMessage& message, const std::string& id, const boost::posix_time::ptime& time, const HighlightAction& highlight) SWIFTEN_OVERRIDE;
-			void replaceLastMessage(const ChatWindow::ChatMessage& message);
+			void replaceLastMessage(const ChatWindow::ChatMessage& message, const ChatWindow::TimestampBehaviour timestampBehaviour);
 			void setAckState(const std::string& id, ChatWindow::AckState state);
 			
 			virtual std::string addFileTransfer(const std::string& senderName, bool senderIsSelf, const std::string& filename, const boost::uintmax_t sizeInBytes) SWIFTEN_OVERRIDE;
 			virtual void setFileTransferProgress(std::string, const int percentageDone) SWIFTEN_OVERRIDE;
 			virtual void setFileTransferStatus(std::string, const ChatWindow::FileTransferState state, const std::string& msg = "") SWIFTEN_OVERRIDE;
 			virtual void addMUCInvitation(const std::string& senderName, const JID& jid, const std::string& reason, const std::string& password, bool direct, bool isImpromptu, bool isContinuation) SWIFTEN_OVERRIDE;
 			virtual std::string addWhiteboardRequest(const QString& contact, bool senderIsSelf) SWIFTEN_OVERRIDE;
 			virtual void setWhiteboardSessionStatus(const std::string& id, const ChatWindow::WhiteboardSessionState state) SWIFTEN_OVERRIDE;
 			virtual void setMessageReceiptState(const std::string& id, ChatWindow::ReceiptState state) SWIFTEN_OVERRIDE;
 
 			virtual void showEmoticons(bool show) SWIFTEN_OVERRIDE;
 			void addMessageTop(boost::shared_ptr<ChatSnippet> snippet);
 			void addMessageBottom(boost::shared_ptr<ChatSnippet> snippet);
 
 			int getSnippetPositionByDate(const QDate& date); // FIXME : This probably shouldn't have been public
 			void addLastSeenLine();
 
 		private: // previously public, now private
-			void replaceLastMessage(const QString& newMessage);
+			void replaceLastMessage(const QString& newMessage, const ChatWindow::TimestampBehaviour timestampBehaviour);
 			void replaceLastMessage(const QString& newMessage, const QString& note);
 			void replaceMessage(const QString& newMessage, const QString& id, const QDateTime& time);
 			void rememberScrolledToBottom();
 			void setAckXML(const QString& id, const QString& xml);
 			void setReceiptXML(const QString& id, const QString& xml);
 			void displayReceiptInfo(const QString& id, bool showIt);
 
 			QString getLastSentMessage();
 			void addToJSEnvironment(const QString&, QObject*);
 			void setFileTransferProgress(QString id, const int percentageDone);
 			void setFileTransferStatus(QString id, const ChatWindow::FileTransferState state, const QString& msg);
 			void setWhiteboardSessionStatus(QString id, const ChatWindow::WhiteboardSessionState state);
 			void setMUCInvitationJoined(QString id);
 			
 		signals:
 			void gotFocus();
 			void fontResized(int);
 			void logCleared();
 			void scrollRequested(int pos);
 			void scrollReachedTop();
 			void scrollReachedBottom();
 
 		public slots:
 			void copySelectionToClipboard();
 			void handleLinkClicked(const QUrl&);
 			void resetView();
 			void resetTopInsertPoint();
 			void increaseFontSize(int numSteps = 1);
 			void decreaseFontSize();
 			void resizeFont(int fontSizeSteps);
 			void scrollToBottom();
 			void handleKeyPressEvent(QKeyEvent* event);
 
 		private slots:
 			void handleViewLoadFinished(bool);
 			void handleFrameSizeChanged();
 			void handleClearRequested();
 			void handleScrollRequested(int dx, int dy, const QRect& rectToScroll);
 			void handleHTMLButtonClicked(QString id, QString arg1, QString arg2, QString arg3, QString arg4, QString arg5);
 
 		private:
 			enum PreviousMessageKind {
 				PreviosuMessageWasNone,
 				PreviousMessageWasMessage,
 				PreviousMessageWasSystem,
 				PreviousMessageWasPresence,
 				PreviousMessageWasFileTransfer,
 				PreviousMessageWasMUCInvite
 			};
 			std::string addMessage(
 					const QString& message, 
 					const std::string& senderName, 
 					bool senderIsSelf, 
 					boost::shared_ptr<SecurityLabel> label, 
 					const std::string& avatarPath, 
 					const QString& style, 
 					const boost::posix_time::ptime& time, 
 					const HighlightAction& highlight,
 					ChatSnippet::Direction direction);
 			void replaceMessage(
 					const QString& message, 
 					const std::string& id, 
 					const boost::posix_time::ptime& time, 
 					const QString& style, 
 					const HighlightAction& highlight);
 			bool appendToPreviousCheck(PreviousMessageKind messageKind, const std::string& senderName, bool senderIsSelf);
 			static ChatSnippet::Direction getActualDirection(const ChatWindow::ChatMessage& message, ChatWindow::Direction direction);
 			QString chatMessageToHTML(const ChatWindow::ChatMessage& message);
 			QString getHighlightSpanStart(const HighlightAction& highlight);
 			static QString buildChatWindowButton(const QString& name, const QString& id, const QString& arg1 = QString(), const QString& arg2 = QString(), const QString& arg3 = QString(), const QString& arg4 = QString(), const QString& arg5 = QString());
 
 		private:
 			void headerEncode();
 			void messageEncode();
 			void addToDOM(boost::shared_ptr<ChatSnippet> snippet);
 			QWebElement snippetToDOM(boost::shared_ptr<ChatSnippet> snippet);
 
 			QtChatWindow* window_;
 			UIEventStream* eventStream_;
 			bool viewReady_;
 			bool isAtBottom_;
 			bool topMessageAdded_;
 			int scrollBarMaximum_;
 			QtWebView* webView_;
 			QWebPage* webPage_;
 			int fontSizeSteps_;
 			QtChatTheme* theme_;
 			QWebElement newInsertPoint_;
 			QWebElement topInsertPoint_;
 			QWebElement lineSeparator_;
 			QWebElement lastElement_;
 			QWebElement firstElement_;
 			QWebElement document_;
 			bool disableAutoScroll_;
 			QtChatWindowJSBridge* jsBridge;
 			PreviousMessageKind previousMessageKind_;
 			bool previousMessageWasSelf_;
 			bool showEmoticons_;
 			bool insertingLastLine_;
 			int idCounter_;
 			QString previousSenderName_;
 			std::map<QString, QString> descriptions_;
 	};
 }