13 files changed, 108 insertions, 54 deletions
diff --git a/Swift/Controllers/Chat/ChatController.cpp b/Swift/Controllers/Chat/ChatController.cpp
index 8cbf059..d0ee891 100644
--- a/Swift/Controllers/Chat/ChatController.cpp
+++ b/Swift/Controllers/Chat/ChatController.cpp
@@ -1,85 +1,86 @@
 /*
  * Copyright (c) 2010-2017 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swift/Controllers/Chat/ChatController.h>
 
 #include <memory>
 
 #include <boost/bind.hpp>
 
 #include <Swiften/Avatars/AvatarManager.h>
 #include <Swiften/Base/Algorithm.h>
 #include <Swiften/Base/Log.h>
 #include <Swiften/Base/Path.h>
 #include <Swiften/Base/format.h>
 #include <Swiften/Chat/ChatStateNotifier.h>
 #include <Swiften/Chat/ChatStateTracker.h>
 #include <Swiften/Client/ClientBlockListManager.h>
 #include <Swiften/Client/NickResolver.h>
 #include <Swiften/Client/StanzaChannel.h>
 #include <Swiften/Disco/EntityCapsProvider.h>
 #include <Swiften/Disco/FeatureOracle.h>
 #include <Swiften/Elements/DeliveryReceipt.h>
 #include <Swiften/Elements/DeliveryReceiptRequest.h>
 #include <Swiften/Elements/Idle.h>
 #include <Swiften/FileTransfer/FileTransferManager.h>
+#include <Swiften/Network/TimerFactory.h>
 
 #include <Swift/Controllers/Chat/ChatMessageParser.h>
 #include <Swift/Controllers/FileTransfer/FileTransferController.h>
 #include <Swift/Controllers/Highlighting/Highlighter.h>
 #include <Swift/Controllers/Intl.h>
 #include <Swift/Controllers/SettingConstants.h>
 #include <Swift/Controllers/StatusUtil.h>
 #include <Swift/Controllers/Translator.h>
 #include <Swift/Controllers/UIEvents/AcceptWhiteboardSessionUIEvent.h>
 #include <Swift/Controllers/UIEvents/CancelWhiteboardSessionUIEvent.h>
 #include <Swift/Controllers/UIEvents/InviteToMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestChangeBlockStateUIEvent.h>
 #include <Swift/Controllers/UIEvents/RequestInviteToMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/SendFileUIEvent.h>
 #include <Swift/Controllers/UIEvents/ShowWhiteboardUIEvent.h>
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindowFactory.h>
 #include <Swift/Controllers/XMPPEvents/EventController.h>
 #include <Swift/Controllers/XMPPEvents/IncomingFileTransferEvent.h>
 
 namespace Swift {
 
 /**
  * The controller does not gain ownership of the stanzaChannel, nor the factory.
  */
-ChatController::ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, SettingsProvider* settings, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider)
-    : ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, nickResolver, presenceOracle, avatarManager, useDelayForLatency, eventStream, eventController, timerFactory, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider), userWantsReceipts_(userWantsReceipts), settings_(settings), clientBlockListManager_(clientBlockListManager) {
+ChatController::ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, SettingsProvider* settings, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider)
+    : ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, contact, nickResolver, presenceOracle, avatarManager, useDelayForLatency, eventStream, eventController, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider), userWantsReceipts_(userWantsReceipts), settings_(settings), clientBlockListManager_(clientBlockListManager) {
     isInMUC_ = isInMUC;
     lastWasPresence_ = false;
     chatStateNotifier_ = new ChatStateNotifier(stanzaChannel, contact, entityCapsProvider, timerFactory, 20000);
     chatStateTracker_ = new ChatStateTracker();
     nickResolver_ = nickResolver;
     presenceOracle_->onPresenceChange.connect(boost::bind(&ChatController::handlePresenceChange, this, _1));
     chatStateTracker_->onChatStateChange.connect(boost::bind(&ChatWindow::setContactChatState, chatWindow_, _1));
     stanzaChannel_->onStanzaAcked.connect(boost::bind(&ChatController::handleStanzaAcked, this, _1));
     nickResolver_->onNickChanged.connect(boost::bind(&ChatController::handleContactNickChanged, this, _1, _2));
     std::string nick = nickResolver_->jidToNick(toJID_);
     chatWindow_->setName(nick);
     std::string startMessage;
     Presence::ref theirPresence;
     if (isInMUC) {
         startMessage = str(format(QT_TRANSLATE_NOOP("", "Starting chat with %1% in chatroom %2%")) % nick % contact.toBare().toString());
         theirPresence = presenceOracle->getLastPresence(contact);
     } else {
         startMessage = str(format(QT_TRANSLATE_NOOP("", "Starting chat with %1% - %2%")) % nick % contact.toBare().toString());
         theirPresence = contact.isBare() ? presenceOracle->getAccountPresence(contact) : presenceOracle->getLastPresence(contact);
     }
     Idle::ref idle;
     if (theirPresence && (idle = theirPresence->getPayload<Idle>())) {
         startMessage += str(format(QT_TRANSLATE_NOOP("", ", who has been idle since %1%")) % Swift::Translator::getInstance()->ptimeToHumanReadableString(idle->getSince()));
     }
     startMessage += ": " + statusShowTypeToFriendlyName(theirPresence ? theirPresence->getShow() : StatusShow::None);
     if (theirPresence && !theirPresence->getStatus().empty()) {
         startMessage += " (" + theirPresence->getStatus() + ")";
     }
     lastShownStatus_ = theirPresence ? theirPresence->getShow() : StatusShow::None;
     chatStateNotifier_->setContactIsOnline(theirPresence && theirPresence->getType() == Presence::Available);
diff --git a/Swift/Controllers/Chat/ChatController.h b/Swift/Controllers/Chat/ChatController.h
index 3c5656a..bae00c8 100644
--- a/Swift/Controllers/Chat/ChatController.h
+++ b/Swift/Controllers/Chat/ChatController.h
@@ -1,63 +1,64 @@
 /*
- * Copyright (c) 2010-2016 Isode Limited.
+ * Copyright (c) 2010-2017 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #pragma once
 
 #include <map>
 #include <string>
 
 #include <Swiften/Base/Override.h>
 #include <Swiften/Base/Tristate.h>
 
 #include <Swift/Controllers/Chat/ChatControllerBase.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 
 namespace Swift {
     class AvatarManager;
     class ChatStateNotifier;
     class ChatStateTracker;
-    class NickResolver;
+    class ClientBlockListManager;
     class EntityCapsProvider;
     class FileTransferController;
-    class SettingsProvider;
-    class HistoryController;
     class HighlightManager;
-    class ClientBlockListManager;
+    class HistoryController;
+    class NickResolver;
+    class SettingsProvider;
+    class TimerFactory;
     class UIEvent;
 
     class ChatController : public ChatControllerBase {
         public:
-            ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, SettingsProvider* settings, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider);
+            ChatController(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &contact, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool isInMUC, bool useDelayForLatency, UIEventStream* eventStream, TimerFactory* timerFactory, EventController* eventController, EntityCapsProvider* entityCapsProvider, bool userWantsReceipts, SettingsProvider* settings, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, ClientBlockListManager* clientBlockListManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider);
             virtual ~ChatController();
             virtual void setToJID(const JID& jid) SWIFTEN_OVERRIDE;
             virtual void setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info) SWIFTEN_OVERRIDE;
             virtual void setOnline(bool online) SWIFTEN_OVERRIDE;
             virtual void handleNewFileTransferController(FileTransferController* ftc);
             virtual void handleWhiteboardSessionRequest(bool senderIsSelf);
             virtual void handleWhiteboardStateChange(const ChatWindow::WhiteboardSessionState state);
             virtual void setContactIsReceivingPresence(bool /*isReceivingPresence*/) SWIFTEN_OVERRIDE;
             virtual ChatWindow* detachChatWindow() SWIFTEN_OVERRIDE;
             virtual void handleIncomingOwnMessage(std::shared_ptr<Message> message) SWIFTEN_OVERRIDE;
 
         protected:
             virtual void cancelReplaces() SWIFTEN_OVERRIDE;
             virtual JID getBaseJID() SWIFTEN_OVERRIDE;
             virtual void logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming) SWIFTEN_OVERRIDE;
 
         private:
             void handlePresenceChange(std::shared_ptr<Presence> newPresence);
             std::string getStatusChangeString(std::shared_ptr<Presence> presence);
             virtual bool isIncomingMessageFromMe(std::shared_ptr<Message> message) SWIFTEN_OVERRIDE;
             virtual void postSendMessage(const std::string &body, std::shared_ptr<Stanza> sentStanza) SWIFTEN_OVERRIDE;
             virtual void preHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent) SWIFTEN_OVERRIDE;
             virtual void postHandleIncomingMessage(std::shared_ptr<MessageEvent> messageEvent, const ChatWindow::ChatMessage& chatMessage) SWIFTEN_OVERRIDE;
             virtual void preSendMessageRequest(std::shared_ptr<Message>) SWIFTEN_OVERRIDE;
             virtual std::string senderHighlightNameFromMessage(const JID& from) SWIFTEN_OVERRIDE;
             virtual std::string senderDisplayNameFromMessage(const JID& from) SWIFTEN_OVERRIDE;
             virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(std::shared_ptr<Message>) const SWIFTEN_OVERRIDE;
             void handleStanzaAcked(std::shared_ptr<Stanza> stanza);
             virtual void dayTicked() SWIFTEN_OVERRIDE { lastWasPresence_ = false; }
             void handleContactNickChanged(const JID& jid, const std::string& /*oldNick*/);
diff --git a/Swift/Controllers/Chat/ChatControllerBase.cpp b/Swift/Controllers/Chat/ChatControllerBase.cpp
index 5839d6c..f5865ea 100644
--- a/Swift/Controllers/Chat/ChatControllerBase.cpp
+++ b/Swift/Controllers/Chat/ChatControllerBase.cpp
@@ -11,123 +11,97 @@
 #include <sstream>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/bind.hpp>
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <Swiften/Avatars/AvatarManager.h>
 #include <Swiften/Base/Path.h>
 #include <Swiften/Base/format.h>
 #include <Swiften/Client/StanzaChannel.h>
 #include <Swiften/Disco/EntityCapsProvider.h>
 #include <Swiften/Elements/Delay.h>
 #include <Swiften/Elements/MUCInvitationPayload.h>
 #include <Swiften/Elements/MUCUserPayload.h>
 #include <Swiften/Queries/Requests/GetSecurityLabelsCatalogRequest.h>
 
 #include <Swift/Controllers/Chat/AutoAcceptMUCInviteDecider.h>
 #include <Swift/Controllers/Chat/ChatMessageParser.h>
 #include <Swift/Controllers/Highlighting/HighlightManager.h>
 #include <Swift/Controllers/Highlighting/Highlighter.h>
 #include <Swift/Controllers/Intl.h>
 #include <Swift/Controllers/UIEvents/JoinMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindowFactory.h>
 #include <Swift/Controllers/XMPPEvents/EventController.h>
 #include <Swift/Controllers/XMPPEvents/MUCInviteEvent.h>
 
 namespace Swift {
 
-ChatControllerBase::ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), timerFactory_(timerFactory), entityCapsProvider_(entityCapsProvider), historyController_(historyController), mucRegistry_(mucRegistry), chatMessageParser_(chatMessageParser), autoAcceptMUCInviteDecider_(autoAcceptMUCInviteDecider), eventStream_(eventStream) {
+ChatControllerBase::ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider) : selfJID_(self), stanzaChannel_(stanzaChannel), iqRouter_(iqRouter), chatWindowFactory_(chatWindowFactory), toJID_(toJID), labelsEnabled_(false), presenceOracle_(presenceOracle), avatarManager_(avatarManager), useDelayForLatency_(useDelayForLatency), eventController_(eventController), entityCapsProvider_(entityCapsProvider), historyController_(historyController), mucRegistry_(mucRegistry), chatMessageParser_(chatMessageParser), autoAcceptMUCInviteDecider_(autoAcceptMUCInviteDecider), eventStream_(eventStream) {
     chatWindow_ = chatWindowFactory_->createChatWindow(toJID, eventStream);
     chatWindow_->onAllMessagesRead.connect(boost::bind(&ChatControllerBase::handleAllMessagesRead, this));
     chatWindow_->onSendMessageRequest.connect(boost::bind(&ChatControllerBase::handleSendMessageRequest, this, _1, _2));
-    chatWindow_->onLogCleared.connect(boost::bind(&ChatControllerBase::handleLogCleared, this));
+    chatWindow_->onContinuationsBroken.connect(boost::bind(&ChatControllerBase::handleContinuationsBroken, this));
     entityCapsProvider_->onCapsChanged.connect(boost::bind(&ChatControllerBase::handleCapsChanged, this, _1));
     highlighter_ = highlightManager->createHighlighter(nickResolver);
     ChatControllerBase::setOnline(stanzaChannel->isAvailable() && iqRouter->isAvailable());
-    createDayChangeTimer();
 }
 
 ChatControllerBase::~ChatControllerBase() {
-    if (dateChangeTimer_) {
-        dateChangeTimer_->onTick.disconnect(boost::bind(&ChatControllerBase::handleDayChangeTick, this));
-        dateChangeTimer_->stop();
-    }
-
     delete highlighter_;
     delete chatWindow_;
 }
 
-void ChatControllerBase::handleLogCleared() {
+void ChatControllerBase::handleContinuationsBroken() {
     cancelReplaces();
 }
 
 ChatWindow* ChatControllerBase::detachChatWindow() {
     ChatWindow* chatWindow = chatWindow_;
     chatWindow_ = nullptr;
     return chatWindow;
 }
 
 void ChatControllerBase::handleCapsChanged(const JID& jid) {
     if (jid.compare(toJID_, JID::WithoutResource) == 0) {
         handleBareJIDCapsChanged(jid);
     }
 }
 
 void ChatControllerBase::setCanStartImpromptuChats(bool supportsImpromptu) {
     if (chatWindow_) {
         chatWindow_->setCanInitiateImpromptuChats(supportsImpromptu);
     }
 }
 
-void ChatControllerBase::createDayChangeTimer() {
-    if (timerFactory_) {
-        boost::posix_time::ptime now = boost::posix_time::second_clock::local_time();
-        boost::posix_time::ptime midnight(now.date() + boost::gregorian::days(1));
-        int millisecondsUntilMidnight = boost::numeric_cast<int>((midnight - now).total_milliseconds());
-        dateChangeTimer_ = timerFactory_->createTimer(millisecondsUntilMidnight);
-        dateChangeTimer_->onTick.connect(boost::bind(&ChatControllerBase::handleDayChangeTick, this));
-        dateChangeTimer_->start();
-    }
-}
-
-void ChatControllerBase::handleDayChangeTick() {
-    dateChangeTimer_->stop();
-    boost::posix_time::ptime now = boost::posix_time::second_clock::local_time();
-    chatWindow_->addSystemMessage(chatMessageParser_->parseMessageBody(str(format(QT_TRANSLATE_NOOP("", "The day is now %1%")) % std::string(boost::posix_time::to_iso_extended_string(now)).substr(0,10))), ChatWindow::DefaultDirection);
-    lastWasPresence_ = false;
-    dayTicked();
-    createDayChangeTimer();
-}
-
 void ChatControllerBase::setEnabled(bool enabled) {
     chatWindow_->setOnline(enabled);
     chatWindow_->setCanInitiateImpromptuChats(false);
 }
 
 void ChatControllerBase::setOnline(bool online) {
     setEnabled(online);
 }
 
 JID ChatControllerBase::getBaseJID() {
     return JID(toJID_.toBare());
 }
 
 void ChatControllerBase::setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info) {
     if (iqRouter_->isAvailable() && info->hasFeature(DiscoInfo::SecurityLabelsCatalogFeature)) {
         GetSecurityLabelsCatalogRequest::ref request = GetSecurityLabelsCatalogRequest::create(getBaseJID(), iqRouter_);
         request->onResponse.connect(boost::bind(&ChatControllerBase::handleSecurityLabelsCatalogResponse, this, _1, _2));
         request->send();
     } else {
         chatWindow_->setSecurityLabelsEnabled(false);
         labelsEnabled_ = false;
     }
 }
 
 void ChatControllerBase::handleAllMessagesRead() {
     if (!unreadMessages_.empty()) {
         targetedUnreadMessages_.clear();
         for (std::shared_ptr<StanzaEvent> stanzaEvent : unreadMessages_) {
             stanzaEvent->conclude();
         }
diff --git a/Swift/Controllers/Chat/ChatControllerBase.h b/Swift/Controllers/Chat/ChatControllerBase.h
index 7f118bd..5ddda52 100644
--- a/Swift/Controllers/Chat/ChatControllerBase.h
+++ b/Swift/Controllers/Chat/ChatControllerBase.h
@@ -1,144 +1,138 @@
 /*
  * Copyright (c) 2010-2017 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #pragma once
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include <boost/date_time/posix_time/posix_time.hpp>
 #include <boost/filesystem/path.hpp>
 #include <boost/optional.hpp>
 #include <boost/signals2.hpp>
 
 #include <Swiften/Base/IDGenerator.h>
 #include <Swiften/Elements/DiscoInfo.h>
 #include <Swiften/Elements/ErrorPayload.h>
 #include <Swiften/Elements/SecurityLabelsCatalog.h>
 #include <Swiften/Elements/Stanza.h>
 #include <Swiften/JID/JID.h>
 #include <Swiften/MUC/MUCRegistry.h>
-#include <Swiften/Network/Timer.h>
-#include <Swiften/Network/TimerFactory.h>
 #include <Swiften/Presence/PresenceOracle.h>
 #include <Swiften/Queries/IQRouter.h>
 
 #include <Swift/Controllers/Highlighting/HighlightManager.h>
 #include <Swift/Controllers/HistoryController.h>
 #include <Swift/Controllers/UIInterfaces/ChatWindow.h>
 #include <Swift/Controllers/XMPPEvents/MUCInviteEvent.h>
 #include <Swift/Controllers/XMPPEvents/MessageEvent.h>
 
 namespace Swift {
     class AutoAcceptMUCInviteDecider;
     class AvatarManager;
     class ChatMessageParser;
     class ChatWindowFactory;
     class EntityCapsProvider;
     class EventController;
     class HighlightManager;
     class Highlighter;
     class IQRouter;
     class NickResolver;
     class StanzaChannel;
     class UIEventStream;
 
     class ChatControllerBase : public boost::signals2::trackable {
         public:
             virtual ~ChatControllerBase();
             void showChatWindow();
             void activateChatWindow();
             bool hasOpenWindow() const;
             virtual void setAvailableServerFeatures(std::shared_ptr<DiscoInfo> info);
             virtual void handleIncomingOwnMessage(std::shared_ptr<Message> /*message*/) {}
             void handleIncomingMessage(std::shared_ptr<MessageEvent> message);
             std::string addMessage(const ChatWindow::ChatMessage& chatMessage, const std::string& senderName, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::filesystem::path& avatarPath, const boost::posix_time::ptime& time);
             void replaceMessage(const ChatWindow::ChatMessage& chatMessage, const std::string& id, const boost::posix_time::ptime& time);
             virtual void setOnline(bool online);
             void setEnabled(bool enabled);
             virtual void setToJID(const JID& jid) {toJID_ = jid;}
             /** Used for determining when something is recent.*/
             boost::signals2::signal<void (const std::string& /*activity*/)> onActivity;
             boost::signals2::signal<void ()> onUnreadCountChanged;
             boost::signals2::signal<void ()> onWindowClosed;
             int getUnreadCount();
             const JID& getToJID() {return toJID_;}
             void handleCapsChanged(const JID& jid);
             void setCanStartImpromptuChats(bool supportsImpromptu);
             virtual ChatWindow* detachChatWindow();
             boost::signals2::signal<void(ChatWindow* /*window to reuse*/, const std::vector<JID>& /*invite people*/, const std::string& /*reason*/)> onConvertToMUC;
 
         protected:
-            ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, TimerFactory* timerFactory, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider);
+            ChatControllerBase(const JID& self, StanzaChannel* stanzaChannel, IQRouter* iqRouter, ChatWindowFactory* chatWindowFactory, const JID &toJID, NickResolver* nickResolver, PresenceOracle* presenceOracle, AvatarManager* avatarManager, bool useDelayForLatency, UIEventStream* eventStream, EventController* eventController, EntityCapsProvider* entityCapsProvider, HistoryController* historyController, MUCRegistry* mucRegistry, HighlightManager* highlightManager, std::shared_ptr<ChatMessageParser> chatMessageParser, AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider);
 
             /**
              * Pass the Message appended, and the stanza used to send it.
              */
             virtual void postSendMessage(const std::string&, std::shared_ptr<Stanza>) {}
             virtual std::string senderDisplayNameFromMessage(const JID& from) = 0;
             virtual std::string senderHighlightNameFromMessage(const JID& from) = 0;
             virtual bool isIncomingMessageFromMe(std::shared_ptr<Message>) = 0;
             virtual void preHandleIncomingMessage(std::shared_ptr<MessageEvent>) {}
             virtual void addMessageHandleIncomingMessage(const JID& from, const ChatWindow::ChatMessage& message, bool senderIsSelf, std::shared_ptr<SecurityLabel> label, const boost::posix_time::ptime& time);
             virtual void postHandleIncomingMessage(std::shared_ptr<MessageEvent>, const ChatWindow::ChatMessage&) {}
             virtual void preSendMessageRequest(std::shared_ptr<Message>) {}
             virtual bool isFromContact(const JID& from);
             virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(std::shared_ptr<Message>) const = 0;
             virtual void dayTicked() {}
             virtual void handleBareJIDCapsChanged(const JID& jid) = 0;
             std::string getErrorMessage(std::shared_ptr<ErrorPayload>);
             virtual void setContactIsReceivingPresence(bool /* isReceivingPresence */) {}
             virtual void cancelReplaces() = 0;
             /** JID any iq for account should go to - bare except for PMs */
             virtual JID getBaseJID();
             virtual void logMessage(const std::string& message, const JID& fromJID, const JID& toJID, const boost::posix_time::ptime& timeStamp, bool isIncoming) = 0;
             ChatWindow::ChatMessage buildChatWindowChatMessage(const std::string& message, const std::string& senderName, bool senderIsSelf);
             void updateMessageCount();
 
         private:
             IDGenerator idGenerator_;
             std::string lastSentMessageStanzaID_;
-            void createDayChangeTimer();
 
             void handleSendMessageRequest(const std::string &body, bool isCorrectionMessage);
             void handleAllMessagesRead();
             void handleSecurityLabelsCatalogResponse(std::shared_ptr<SecurityLabelsCatalog>, ErrorPayload::ref error);
-            void handleDayChangeTick();
             void handleMUCInvitation(Message::ref message);
             void handleMediatedMUCInvitation(Message::ref message);
             void handleGeneralMUCInvitation(MUCInviteEvent::ref event);
-            void handleLogCleared();
+            void handleContinuationsBroken();
 
         protected:
             JID selfJID_;
             std::vector<std::shared_ptr<StanzaEvent> > unreadMessages_;
             std::vector<std::shared_ptr<StanzaEvent> > targetedUnreadMessages_;
             StanzaChannel* stanzaChannel_;
             IQRouter* iqRouter_;
             ChatWindowFactory* chatWindowFactory_;
             ChatWindow* chatWindow_;
             JID toJID_;
             bool labelsEnabled_;
             std::map<JID, std::string> lastMessagesUIID_;
             PresenceOracle* presenceOracle_;
             AvatarManager* avatarManager_;
             bool useDelayForLatency_;
             EventController* eventController_;
-            std::shared_ptr<Timer> dateChangeTimer_;
-            TimerFactory* timerFactory_;
             EntityCapsProvider* entityCapsProvider_;
             SecurityLabelsCatalog::Item lastLabel_;
             HistoryController* historyController_;
             MUCRegistry* mucRegistry_;
             Highlighter* highlighter_;
             std::shared_ptr<ChatMessageParser> chatMessageParser_;
             AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider_;
             UIEventStream* eventStream_;
             bool lastWasPresence_ = false;
     };
 }
diff --git a/Swift/Controllers/Chat/ChatsManager.cpp b/Swift/Controllers/Chat/ChatsManager.cpp
index fc96701..db3b3b7 100644
--- a/Swift/Controllers/Chat/ChatsManager.cpp
+++ b/Swift/Controllers/Chat/ChatsManager.cpp
@@ -720,61 +720,61 @@ void ChatsManager::setOnline(bool enabled) {
         localMUCServiceFinderWalker_->onWalkComplete.connect(boost::bind(&ChatsManager::handleLocalServiceWalkFinished, this));
         localMUCServiceFinderWalker_->beginWalk();
     }
 
     if (chatListWindow_) {
         chatListWindow_->setBookmarksEnabled(enabled);
     }
 }
 
 void ChatsManager::handleChatRequest(const std::string &contact) {
     ChatController* controller = getChatControllerOrFindAnother(JID(contact));
     controller->activateChatWindow();
 }
 
 ChatController* ChatsManager::getChatControllerOrFindAnother(const JID &contact) {
     ChatController* controller = getChatControllerIfExists(contact);
     if (!controller && !mucRegistry_->isMUC(contact.toBare())) {
         for (JIDChatControllerPair pair : chatControllers_) {
             if (pair.first.toBare() == contact.toBare()) {
                 controller = pair.second;
                 break;
             }
         }
     }
     return controller ? controller : createNewChatController(contact);
 }
 
 ChatController* ChatsManager::createNewChatController(const JID& contact) {
     assert(chatControllers_.find(contact) == chatControllers_.end());
     std::shared_ptr<ChatMessageParser> chatMessageParser = std::make_shared<ChatMessageParser>(emoticons_, highlightManager_->getConfiguration(), ChatMessageParser::Mode::Chat); /* a message parser that knows this is a chat (not a room/MUC) */
-    ChatController* controller = new ChatController(jid_, stanzaChannel_, iqRouter_, chatWindowFactory_, contact, nickResolver_, presenceOracle_, avatarManager_, mucRegistry_->isMUC(contact.toBare()), useDelayForLatency_, uiEventStream_, eventController_, timerFactory_, entityCapsProvider_, userWantsReceipts_, settings_, historyController_, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser, autoAcceptMUCInviteDecider_);
+    ChatController* controller = new ChatController(jid_, stanzaChannel_, iqRouter_, chatWindowFactory_, contact, nickResolver_, presenceOracle_, avatarManager_, mucRegistry_->isMUC(contact.toBare()), useDelayForLatency_, uiEventStream_, timerFactory_, eventController_, entityCapsProvider_, userWantsReceipts_, settings_, historyController_, mucRegistry_, highlightManager_, clientBlockListManager_, chatMessageParser, autoAcceptMUCInviteDecider_);
     chatControllers_[contact] = controller;
     controller->setAvailableServerFeatures(serverDiscoInfo_);
     controller->onActivity.connect(boost::bind(&ChatsManager::handleChatActivity, this, contact, _1, false));
     controller->onWindowClosed.connect(boost::bind(&ChatsManager::handleChatClosed, this, contact));
     controller->onUnreadCountChanged.connect(boost::bind(&ChatsManager::handleUnreadCountChanged, this, controller));
     controller->onConvertToMUC.connect(boost::bind(&ChatsManager::handleTransformChatToMUC, this, controller, _1, _2, _3));
     updatePresenceReceivingStateOnChatController(contact);
     controller->setCanStartImpromptuChats(!localMUCServiceJID_.toString().empty());
     return controller;
 }
 
 ChatController* ChatsManager::getChatControllerOrCreate(const JID &contact) {
     ChatController* controller = getChatControllerIfExists(contact);
     return controller ? controller : createNewChatController(contact);
 }
 
 ChatController* ChatsManager::getChatControllerIfExists(const JID &contact, bool rebindIfNeeded) {
     if (chatControllers_.find(contact) == chatControllers_.end()) {
         if (mucRegistry_->isMUC(contact.toBare())) {
             return nullptr;
         }
         //Need to look for an unbound window to bind first
         JID bare(contact.toBare());
         if (chatControllers_.find(bare) != chatControllers_.end()) {
             if (rebindIfNeeded) {
                 rebindControllerJID(bare, contact);
             }
             else {
                 return chatControllers_[bare];
             }
diff --git a/Swift/Controllers/Chat/MUCController.cpp b/Swift/Controllers/Chat/MUCController.cpp
index e65bfa6..a142ee0 100644
--- a/Swift/Controllers/Chat/MUCController.cpp
+++ b/Swift/Controllers/Chat/MUCController.cpp
@@ -72,61 +72,61 @@ class MUCBookmarkPredicate {
 
 /**
  * The controller does not gain ownership of the stanzaChannel, nor the factory.
  */
 MUCController::MUCController (
         const JID& self,
         MUC::ref muc,
         const boost::optional<std::string>& password,
         const std::string &nick,
         StanzaChannel* stanzaChannel,
         IQRouter* iqRouter,
         ChatWindowFactory* chatWindowFactory,
         NickResolver* nickResolver,
         PresenceOracle* presenceOracle,
         AvatarManager* avatarManager,
         UIEventStream* uiEventStream,
         bool useDelayForLatency,
         TimerFactory* timerFactory,
         EventController* eventController,
         EntityCapsProvider* entityCapsProvider,
         XMPPRoster* xmppRoster,
         HistoryController* historyController,
         MUCRegistry* mucRegistry,
         HighlightManager* highlightManager,
         ClientBlockListManager* clientBlockListManager,
         std::shared_ptr<ChatMessageParser> chatMessageParser,
         bool isImpromptu,
         AutoAcceptMUCInviteDecider* autoAcceptMUCInviteDecider,
         VCardManager* vcardManager,
         MUCBookmarkManager* mucBookmarkManager) :
-    ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), nickResolver, presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, timerFactory, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider), muc_(muc), nick_(nick), desiredNick_(nick), password_(password), renameCounter_(0), isImpromptu_(isImpromptu), isImpromptuAlreadyConfigured_(false), clientBlockListManager_(clientBlockListManager), mucBookmarkManager_(mucBookmarkManager) {
+    ChatControllerBase(self, stanzaChannel, iqRouter, chatWindowFactory, muc->getJID(), nickResolver, presenceOracle, avatarManager, useDelayForLatency, uiEventStream, eventController, entityCapsProvider, historyController, mucRegistry, highlightManager, chatMessageParser, autoAcceptMUCInviteDecider), muc_(muc), nick_(nick), desiredNick_(nick), password_(password), renameCounter_(0), isImpromptu_(isImpromptu), isImpromptuAlreadyConfigured_(false), clientBlockListManager_(clientBlockListManager), mucBookmarkManager_(mucBookmarkManager) {
     assert(avatarManager_);
 
     parting_ = true;
     joined_ = false;
     lastWasPresence_ = false;
     shouldJoinOnReconnect_ = true;
     doneGettingHistory_ = false;
     xmppRoster_ = xmppRoster;
     subject_ = "";
     isInitialJoin_ = true;
 
     roster_ = std::unique_ptr<Roster>(new Roster(false, true));
     rosterVCardProvider_ = new RosterVCardProvider(roster_.get(), vcardManager, JID::WithResource);
     completer_ = new TabComplete();
     chatWindow_->setRosterModel(roster_.get());
     chatWindow_->setTabComplete(completer_);
     chatWindow_->onClosed.connect(boost::bind(&MUCController::handleWindowClosed, this));
     chatWindow_->onOccupantSelectionChanged.connect(boost::bind(&MUCController::handleWindowOccupantSelectionChanged, this, _1));
     chatWindow_->onOccupantActionSelected.connect(boost::bind(&MUCController::handleActionRequestedOnOccupant, this, _1, _2));
     chatWindow_->onChangeSubjectRequest.connect(boost::bind(&MUCController::handleChangeSubjectRequest, this, _1));
     chatWindow_->onBookmarkRequest.connect(boost::bind(&MUCController::handleBookmarkRequest, this));
     chatWindow_->onConfigureRequest.connect(boost::bind(&MUCController::handleConfigureRequest, this, _1));
     chatWindow_->onConfigurationFormCancelled.connect(boost::bind(&MUCController::handleConfigurationCancelled, this));
     chatWindow_->onDestroyRequest.connect(boost::bind(&MUCController::handleDestroyRoomRequest, this));
     chatWindow_->onInviteToChat.connect(boost::bind(&MUCController::handleInvitePersonToThisMUCRequest, this, _1));
     chatWindow_->onGetAffiliationsRequest.connect(boost::bind(&MUCController::handleGetAffiliationsRequest, this));
     chatWindow_->onChangeAffiliationsRequest.connect(boost::bind(&MUCController::handleChangeAffiliationsRequest, this, _1));
     chatWindow_->onUnblockUserRequest.connect(boost::bind(&MUCController::handleUnblockUserRequest, this));
     muc_->onJoinComplete.connect(boost::bind(&MUCController::handleJoinComplete, this, _1));
     muc_->onJoinFailed.connect(boost::bind(&MUCController::handleJoinFailed, this, _1));
diff --git a/Swift/Controllers/UIInterfaces/ChatWindow.h b/Swift/Controllers/UIInterfaces/ChatWindow.h
index f9c4164..8273802 100644
--- a/Swift/Controllers/UIInterfaces/ChatWindow.h
+++ b/Swift/Controllers/UIInterfaces/ChatWindow.h
@@ -237,49 +237,49 @@ namespace Swift {
 
             /**
              * Actions that can be performed on the selected occupant.
              */
             virtual void setAvailableOccupantActions(const std::vector<OccupantAction>& actions) = 0;
 
             /**
              * A room configuration has been requested, show the form.
              * If the form is cancelled, must emit onConfigurationFormCancelled().
              */
             virtual void showRoomConfigurationForm(Form::ref) = 0;
 
             boost::signals2::signal<void ()> onClosed;
             boost::signals2::signal<void ()> onAllMessagesRead;
             boost::signals2::signal<void (const std::string&, bool isCorrection)> onSendMessageRequest;
             boost::signals2::signal<void ()> onSendCorrectionMessageRequest;
             boost::signals2::signal<void ()> onUserTyping;
             boost::signals2::signal<void ()> onUserCancelsTyping;
             boost::signals2::signal<void ()> onAlertButtonClicked;
             boost::signals2::signal<void (ContactRosterItem*)> onOccupantSelectionChanged;
             boost::signals2::signal<void (ChatWindow::OccupantAction, ContactRosterItem*)> onOccupantActionSelected;
             boost::signals2::signal<void (const std::string&)> onChangeSubjectRequest;
             boost::signals2::signal<void ()> onBookmarkRequest;
             boost::signals2::signal<void (Form::ref)> onConfigureRequest;
             boost::signals2::signal<void ()> onDestroyRequest;
             boost::signals2::signal<void (const std::vector<JID>&)> onInviteToChat;
             boost::signals2::signal<void ()> onConfigurationFormCancelled;
             boost::signals2::signal<void ()> onGetAffiliationsRequest;
             boost::signals2::signal<void (MUCOccupant::Affiliation, const JID&)> onSetAffiliationRequest;
             boost::signals2::signal<void (const std::vector<std::pair<MUCOccupant::Affiliation, JID> >& changes)> onChangeAffiliationsRequest;
-            boost::signals2::signal<void ()> onLogCleared;
+            boost::signals2::signal<void ()> onContinuationsBroken;
 
             // File transfer related
             boost::signals2::signal<void (std::string /* id */)> onFileTransferCancel;
             boost::signals2::signal<void (std::string /* id */, std::string /* description */)> onFileTransferStart;
             boost::signals2::signal<void (std::string /* id */, std::string /* path */)> onFileTransferAccept;
             boost::signals2::signal<void (std::string /* path */)> onSendFileRequest;
 
             //Whiteboard related
             boost::signals2::signal<void ()> onWhiteboardSessionAccept;
             boost::signals2::signal<void ()> onWhiteboardSessionCancel;
             boost::signals2::signal<void ()> onWhiteboardWindowShow;
 
             // Blocking Command related
             boost::signals2::signal<void ()> onBlockUserRequest;
             boost::signals2::signal<void ()> onUnblockUserRequest;
     };
 }
 
diff --git a/Swift/QtUI/QtChatWindow.cpp b/Swift/QtUI/QtChatWindow.cpp
index c509ab3..48d331e 100644
--- a/Swift/QtUI/QtChatWindow.cpp
+++ b/Swift/QtUI/QtChatWindow.cpp
@@ -9,60 +9,61 @@
 #include <map>
 #include <memory>
 #include <string>
 
 #include <boost/cstdint.hpp>
 #include <boost/lexical_cast.hpp>
 
 #include <QApplication>
 #include <QBoxLayout>
 #include <QCloseEvent>
 #include <QComboBox>
 #include <QCursor>
 #include <QDebug>
 #include <QFileDialog>
 #include <QFileInfo>
 #include <QFontMetrics>
 #include <QInputDialog>
 #include <QLabel>
 #include <QLineEdit>
 #include <QMenu>
 #include <QMessageBox>
 #include <QMimeData>
 #include <QPoint>
 #include <QPushButton>
 #include <QSize>
 #include <QSplitter>
 #include <QString>
 #include <QTextDocument>
 #include <QTextEdit>
 #include <QTime>
+#include <QTimer>
 #include <QToolButton>
 #include <QUrl>
 
 #include <Swiften/Base/Log.h>
 #include <Swiften/Base/Platform.h>
 
 #include <Swift/Controllers/Roster/ContactRosterItem.h>
 #include <Swift/Controllers/Roster/Roster.h>
 #include <Swift/Controllers/Roster/RosterItem.h>
 #include <Swift/Controllers/Settings/SettingsProvider.h>
 #include <Swift/Controllers/UIEvents/JoinMUCUIEvent.h>
 #include <Swift/Controllers/UIEvents/SendFileUIEvent.h>
 #include <Swift/Controllers/UIEvents/UIEventStream.h>
 
 #include <SwifTools/EmojiMapper.h>
 #include <SwifTools/TabComplete.h>
 
 #include <Swift/QtUI/QtAddBookmarkWindow.h>
 #include <Swift/QtUI/QtEditBookmarkWindow.h>
 #include <Swift/QtUI/QtEmojisSelector.h>
 #include <Swift/QtUI/QtPlainChatView.h>
 #include <Swift/QtUI/QtScaledAvatarCache.h>
 #include <Swift/QtUI/QtSettingsProvider.h>
 #include <Swift/QtUI/QtTextEdit.h>
 #include <Swift/QtUI/QtUISettingConstants.h>
 #include <Swift/QtUI/QtUtilities.h>
 #include <Swift/QtUI/QtWebKitChatView.h>
 #include <Swift/QtUI/Roster/QtOccupantListWidget.h>
 
 namespace Swift {
@@ -162,78 +163,89 @@ QtChatWindow::QtChatWindow(const QString& contact, QtChatTheme* theme, UIEventSt
     QHBoxLayout* actionLayout = new QHBoxLayout();
     actionLayout->addWidget(emojisButton_);
     actionLayout->addWidget(actionButton_);
 
     inputBarLayout->addLayout(actionLayout);
     layout->addLayout(inputBarLayout);
 
     inputClearing_ = false;
     contactIsTyping_ = false;
     tabCompletion_ = false;
 
     connect(input_, SIGNAL(unhandledKeyPressEvent(QKeyEvent*)), this, SLOT(handleKeyPressEvent(QKeyEvent*)));
     connect(input_, SIGNAL(returnPressed()), this, SLOT(returnPressed()));
     connect(input_, SIGNAL(textChanged()), this, SLOT(handleInputChanged()));
     connect(input_, SIGNAL(cursorPositionChanged()), this, SLOT(handleCursorPositionChanged()));
     setFocusProxy(input_);
     logRosterSplitter_->setFocusProxy(input_);
     midBar_->setFocusProxy(input_);
     messageLog_->setFocusProxy(input_);
     connect(messageLog_, SIGNAL(gotFocus()), input_, SLOT(setFocus()));
     resize(400,300);
     connect(messageLog_, SIGNAL(fontResized(int)), this, SIGNAL(fontResized(int)));
     connect(messageLog_, SIGNAL(logCleared()), this, SLOT(handleLogCleared()));
 
     treeWidget_->onSomethingSelectedChanged.connect(boost::bind(&QtChatWindow::handleOccupantSelectionChanged, this, _1));
     treeWidget_->onOccupantActionSelected.connect(boost::bind(boost::ref(onOccupantActionSelected), _1, _2));
 
     settings_->onSettingChanged.connect(boost::bind(&QtChatWindow::handleSettingChanged, this, _1));
     messageLog_->showEmoticons(settings_->getSetting(QtUISettingConstants::SHOW_EMOTICONS));
     setMinimumSize(100, 100);
+
+    dayChangeTimer = new QTimer(this);
+    dayChangeTimer->setSingleShot(true);
+    connect(dayChangeTimer, &QTimer::timeout, [this](){
+        addSystemMessage(ChatMessage(Q2PSTRING(tr("The day is now %1").arg(QDateTime::currentDateTime().date().toString(Qt::SystemLocaleLongDate)))), ChatWindow::DefaultDirection);
+        onContinuationsBroken();
+        resetDayChangeTimer();
+    });
+
+    resetDayChangeTimer();
 }
 
 QtChatWindow::~QtChatWindow() {
+    dayChangeTimer->stop();
     settings_->onSettingChanged.disconnect(boost::bind(&QtChatWindow::handleSettingChanged, this, _1));
     if (mucConfigurationWindow_) {
         delete mucConfigurationWindow_.data();
     }
 }
 
 void QtChatWindow::handleSettingChanged(const std::string& setting) {
     if (setting == QtUISettingConstants::SHOW_EMOTICONS.getKey()) {
         bool showEmoticons = settings_->getSetting(QtUISettingConstants::SHOW_EMOTICONS);
         messageLog_->showEmoticons(showEmoticons);
     }
 }
 
 void QtChatWindow::handleLogCleared() {
-    onLogCleared();
+    onContinuationsBroken();
 }
 
 void QtChatWindow::handleOccupantSelectionChanged(RosterItem* item) {
     onOccupantSelectionChanged(dynamic_cast<ContactRosterItem*>(item));
 }
 
 void QtChatWindow::handleFontResized(int fontSizeSteps) {
     messageLog_->resizeFont(fontSizeSteps);
 }
 
 void QtChatWindow::handleAlertButtonClicked() {
     const QObject* alertWidget = QObject::sender()->parent();
     std::map<AlertID, QWidget*>::const_iterator i = alertWidgets_.begin();
     for ( ; i != alertWidgets_.end(); ++i) {
         if (i->second == alertWidget) {
             removeAlert(i->first);
             break;
         }
     }
 }
 
 QtChatWindow::AlertID QtChatWindow::addAlert(const std::string& alertText) {
     QWidget* alertWidget = new QWidget(this);
     QHBoxLayout* alertLayout = new QHBoxLayout(alertWidget);
     alertLayout_->addWidget(alertWidget);
     QLabel* alertLabel = new QLabel(this);
     alertLabel->setText(alertText.c_str());
     alertLayout->addWidget(alertLabel);
 
     QToolButton* closeButton = new QToolButton(alertWidget);
@@ -629,60 +641,66 @@ void QtChatWindow::dragEnterEvent(QDragEnterEvent *event) {
 
 void QtChatWindow::dropEvent(QDropEvent *event) {
     if (fileTransferEnabled_ == 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(std::make_shared<ChatTextMessagePart>(messageText));
             addSystemMessage(message, DefaultDirection);
         }
     }
     else if (event->mimeData()->hasFormat("application/vnd.swift.contact-jid-list")) {
         std::vector<JID> invites = jidListFromQByteArray(event->mimeData()->data("application/vnd.swift.contact-jid-list"));
         onInviteToChat(invites);
     }
 }
 
 std::vector<JID> QtChatWindow::jidListFromQByteArray(const QByteArray& dataBytes) {
     QDataStream dataStream(dataBytes);
     std::vector<JID> invites;
     while (!dataStream.atEnd()) {
         QString jidString;
         dataStream >> jidString;
         invites.push_back(Q2PSTRING(jidString));
     }
     return invites;
 }
 
+void QtChatWindow::resetDayChangeTimer() {
+    assert(dayChangeTimer);
+    // Add a second so the handled is definitly called on the next day, and not multiple times exactly at midnight.
+    dayChangeTimer->start(QtUtilities::secondsToNextMidnight(QDateTime::currentDateTime()) * 1000 + 1000);
+}
+
 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::handleEmojisButtonClicked() {
     // Create QtEmojisSelector and QMenu
     emojisGrid_ = new QtEmojisSelector(qtOnlySettings_->getQSettings(), emoticonsMap_);
     auto emojisLayout = new QVBoxLayout();
     emojisLayout->setContentsMargins(style()->pixelMetric(QStyle::PM_MenuHMargin),style()->pixelMetric(QStyle::PM_MenuVMargin),
                                      style()->pixelMetric(QStyle::PM_MenuHMargin),style()->pixelMetric(QStyle::PM_MenuVMargin));
     emojisLayout->addWidget(emojisGrid_);
     emojisMenu_ = std::unique_ptr<QMenu>(new QMenu());
     emojisMenu_->setLayout(emojisLayout);
     emojisMenu_->adjustSize();
 
     connect(emojisGrid_, SIGNAL(emojiClicked(QString)), this, SLOT(handleEmojiClicked(QString)));
 
     QSize menuSize = emojisMenu_->size();
     emojisMenu_->exec(QPoint(QCursor::pos().x() - menuSize.width(), QCursor::pos().y() - menuSize.height()));
 }
 
 void QtChatWindow::handleEmojiClicked(QString emoji) {
     if (isVisible()) {
diff --git a/Swift/QtUI/QtChatWindow.h b/Swift/QtUI/QtChatWindow.h
index 46186ba..361d7c6 100644
--- a/Swift/QtUI/QtChatWindow.h
+++ b/Swift/QtUI/QtChatWindow.h
@@ -165,78 +165,81 @@ namespace Swift {
         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);
             void handleEmojisButtonClicked();
             void handleTextInputReceivedFocus();
             void handleTextInputLostFocus();
 
         private:
             void updateTitleWithUnreadCount();
             void tabComplete();
             void beginCorrection();
             void cancelCorrection();
             void handleSettingChanged(const std::string& setting);
 
             void handleOccupantSelectionChanged(RosterItem* item);
             void handleAppendedToLog();
 
             static std::vector<JID> jidListFromQByteArray(const QByteArray& dataBytes);
 
+            void resetDayChangeTimer();
+
         private:
             int unreadCount_;
             bool contactIsTyping_;
             LastLineTracker lastLineTracker_;
             std::string id_;
             QString contact_;
             QString lastSentMessage_;
             QTextCursor tabCompleteCursor_;
             QtChatView* messageLog_;
             QtChatTheme* theme_;
             QtTextEdit* input_;
             QWidget* midBar_;
             QBoxLayout* subjectLayout_;
             QComboBox* labelsWidget_;
             QtOccupantListWidget* treeWidget_;
             QLabel* correctingLabel_;
             boost::optional<AlertID> correctingAlert_;
             QVBoxLayout* alertLayout_;
             std::map<AlertID, QWidget*> alertWidgets_;
             AlertID nextAlertId_;
             TabComplete* completer_;
             QLineEdit* subject_;
             bool isCorrection_;
             bool inputClearing_;
             bool tabCompletion_;
             UIEventStream* eventStream_;
             bool isOnline_;
-            QSplitter *logRosterSplitter_;
+            QSplitter* logRosterSplitter_;
             Tristate correctionEnabled_;
             Tristate fileTransferEnabled_;
             QString alertStyleSheet_;
             QPointer<QtMUCConfigurationWindow> mucConfigurationWindow_;
             QPointer<QtAffiliationEditor> affiliationEditor_;
             SettingsProvider* settings_ = nullptr;
             QtSettingsProvider* qtOnlySettings_ = nullptr;
             std::vector<ChatWindow::RoomAction> availableRoomActions_;
             QPalette defaultLabelsPalette_;
             LabelModel* labelModel_;
             BlockingState blockingState_;
             bool impromptu_;
             bool isMUC_;
             bool supportsImpromptuChat_;
             RoomBookmarkState roomBookmarkState_;
             std::unique_ptr<QMenu> emojisMenu_;
             QPointer<QtEmojisSelector> emojisGrid_;
             std::map<std::string, std::string> emoticonsMap_;
+            QTimer* dayChangeTimer = nullptr;
     };
 }
diff --git a/Swift/QtUI/QtUtilities.cpp b/Swift/QtUI/QtUtilities.cpp
index 401af17..6eb0b04 100644
--- a/Swift/QtUI/QtUtilities.cpp
+++ b/Swift/QtUI/QtUtilities.cpp
@@ -1,45 +1,54 @@
 /*
- * Copyright (c) 2010-2015 Isode Limited.
+ * Copyright (c) 2010-2017 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
-#include "QtUtilities.h"
+#include <Swift/QtUI/QtUtilities.h>
 
 #include <QtGui>
 #if defined (Q_OS_UNIX) && !defined(Q_OS_MAC)
 #include <QX11Info>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #endif
 #include <QTextDocument>
 #include <QWidget>
+#include <QDateTime>
 
-#include "Swift/Controllers/ApplicationInfo.h"
+#include <Swift/Controllers/ApplicationInfo.h>
 
 namespace QtUtilities {
 
 
 void setX11Resource(QWidget* widget, const QString& c) {
 #if defined (Q_OS_UNIX) && !defined(Q_OS_MAC) && QT_VERSION < 0x050000
     char res_class[] = SWIFT_APPLICATION_NAME;
     XClassHint hint;
     QByteArray resName = (QString(SWIFT_APPLICATION_NAME) + "-" + c).toUtf8();
     hint.res_name = resName.data();
     hint.res_class = res_class;
     XSetClassHint(widget->x11Info().display(), widget->winId(), &hint);
 #else
     (void) widget;
     (void) c;
 #endif
 }
 
 QString htmlEscape(const QString& s) {
 #if QT_VERSION >= 0x050000
     return s.toHtmlEscaped();
 #else
     return Qt::escape(s);
 #endif
 }
 
+long long secondsToNextMidnight(const QDateTime& currentTime) {
+    auto secondsToMidnight = 0ll;
+    auto nextMidnight = currentTime.addDays(1);
+    nextMidnight.setTime(QTime(0,0));
+    secondsToMidnight = currentTime.secsTo(nextMidnight);
+    return secondsToMidnight;
+}
+
 }
diff --git a/Swift/QtUI/QtUtilities.h b/Swift/QtUI/QtUtilities.h
index ad58499..c6f4311 100644
--- a/Swift/QtUI/QtUtilities.h
+++ b/Swift/QtUI/QtUtilities.h
@@ -1,22 +1,31 @@
 /*
- * Copyright (c) 2010-2013 Isode Limited.
+ * Copyright (c) 2010-2017 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #pragma once
 
 class QWidget;
 class QString;
+class QDateTime;
 
 #include <QKeyEvent>
 
 namespace QtUtilities {
     void setX11Resource(QWidget* widget, const QString& c);
     QString htmlEscape(const QString& s);
     #ifdef SWIFTEN_PLATFORM_MACOSX
     const Qt::KeyboardModifier ctrlHardwareKeyModifier = Qt::MetaModifier;
     #else
     const Qt::KeyboardModifier ctrlHardwareKeyModifier = Qt::ControlModifier;
     #endif
+
+    /**
+     * @brief secondsToNextMidnight calculates the seconds until next midnight.
+     * @param currentTime This is the current time, which SHOULD have a Qt::TimeSpec
+     * of Qt::LocalTime to correctly handle DST changes in the current locale.
+     * @return
+     */
+    long long secondsToNextMidnight(const QDateTime& currentTime);
 }
diff --git a/Swift/QtUI/SConscript b/Swift/QtUI/SConscript
index 2f95b3e..3ce2057 100644
--- a/Swift/QtUI/SConscript
+++ b/Swift/QtUI/SConscript
@@ -44,60 +44,75 @@ if myenv.get("HAVE_GROWL", False) :
 if myenv["swift_mobile"] :
     myenv.Append(CPPDEFINES = ["SWIFT_MOBILE"])
 if myenv.get("HAVE_HUNSPELL", True):
     myenv.Append(CPPDEFINES = ["HAVE_HUNSPELL"])
     myenv.UseFlags(myenv["HUNSPELL_FLAGS"])
 if env["PLATFORM"] == "win32" :
     myenv.Append(LIBS = ["cryptui"])
 myenv.UseFlags(myenv["PLATFORM_FLAGS"])
 
 myenv.Tool("qt4", toolpath = ["#/BuildTools/SCons/Tools"])
 myenv.Tool("nsis", toolpath = ["#/BuildTools/SCons/Tools"])
 myenv.Tool("wix", toolpath = ["#/BuildTools/SCons/Tools"])
 myenv.Tool("textfile", toolpath = ["#/BuildTools/SCons/Tools"])
 qt4modules = ['QtCore', 'QtWebKit', 'QtGui']
 if myenv["qt5"] :
     qt_version = '5'
     # QtSvg is required so the image format plugin for SVG images is installed 
     # correctly by Qt's deployment tools.
     qt4modules += ['QtWidgets', 'QtWebKitWidgets', 'QtMultimedia', 'QtSvg']
     if env["PLATFORM"] != "win32" and env["PLATFORM"] != "darwin" :
         qt4modules += ['QtX11Extras']
 else :
     qt_version = '4'
 if env["PLATFORM"] == "posix" :
     qt4modules += ["QtDBus"]
 if env["PLATFORM"] != "win32" and env["PLATFORM"] != "darwin" :
     qt4modules += ["QtNetwork"]
 
 myenv.EnableQt4Modules(qt4modules, debug = False, version = qt_version)
 
+
+## Qt related unit tests
+testQtEnv = env.Clone();
+testQtEnv.Tool("qt4", toolpath = ["#/BuildTools/SCons/Tools"])
+testQtEnv.EnableQt4Modules(qt4modules, debug = False, version = qt_version)
+env["SWIFT_QTUI_TEST_FLAGS"] = {
+    "CPPFLAGS": testQtEnv["CPPFLAGS"],
+    "LIBS": testQtEnv["LIBS"],
+    "LINKFLAGS": testQtEnv["LINKFLAGS"],
+}
+
+env.Append(UNITTEST_SOURCES = [
+    File("UnitTest/QtUtilitiesTest.cpp")
+])
+
 myenv.Append(CPPPATH = ["."])
 
 # Qt requires applications to be build with the -fPIC flag on some 32-bit Linux distributions.
 if env["PLATFORM"] == "posix" :
     testEnv = myenv.Clone()
     conf = Configure(testEnv)
     if conf.CheckDeclaration("QT_REDUCE_RELOCATIONS", "#include <QtCore/qconfig.h>") and conf.CheckDeclaration("__i386__"):
         myenv.AppendUnique(CXXFLAGS = "-fPIC")
     testEnv = conf.Finish()
 
 if env["PLATFORM"] == "win32" :
     #myenv.Append(LINKFLAGS = ["/SUBSYSTEM:CONSOLE"])
     myenv.Append(LINKFLAGS = ["/SUBSYSTEM:WINDOWS"])
     myenv.Append(LIBS = "qtmain")
     if myenv.get("HAVE_SCHANNEL", 0) :
         myenv.Append(LIBS = "Cryptui")
         myenv.Append(CPPDEFINES = "HAVE_SCHANNEL")
 
 if env["PLATFORM"] == "darwin" and env["HAVE_SPARKLE"] :
     myenv.Append(LINKFLAGS = ["-Wl,-rpath,@loader_path/../Frameworks"])
 
 myenv.WriteVal("DefaultTheme.qrc", myenv.Value(generateQRCTheme(myenv.Dir("#/Swift/resources/themes/Default"), "Default")))
 
 sources = [
     "main.cpp",
     "FlowLayout.cpp",
     "QtAboutWidget.cpp",
     "QtSpellCheckerWindow.cpp",
     "QtAvatarWidget.cpp",
     "QtUIFactory.cpp",
diff --git a/Swift/QtUI/UnitTest/QtUtilitiesTest.cpp b/Swift/QtUI/UnitTest/QtUtilitiesTest.cpp
new file mode 100644
index 0000000..45d2239
--- /dev/null
+++ b/Swift/QtUI/UnitTest/QtUtilitiesTest.cpp
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2017 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+
+#include <gtest/gtest.h>
+
+#include <QDateTime>
+#include <QLocale>
+
+#include <Swift/QtUI/QtUtilities.h>
+#include <Swift/QtUI/QtUtilities.cpp>
+
+TEST(QtUtilitiesTest, testDSTawareness) {
+    QLocale::setDefault(QLocale(QLocale::English, QLocale::Germany));
+
+    auto beforeDSTpoint = QDateTime(QDate(2017, 3, 26), QTime(0, 0));
+
+    ASSERT_EQ(23 * 60 * 60, QtUtilities::secondsToNextMidnight(beforeDSTpoint));
+}
+
+
+TEST(QtUtilitiesTest, testNoDSTChange) {
+    QLocale::setDefault(QLocale(QLocale::English, QLocale::Germany));
+
+    auto beforeDSTpoint = QDateTime(QDate(2017, 3, 23), QTime(0, 0));
+
+    ASSERT_EQ(24 * 60 * 60, QtUtilities::secondsToNextMidnight(beforeDSTpoint));
+}