From 91d1f19058a31cc35ca1212f042a9dd6f501a7b7 Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Sat, 9 Nov 2019 03:06:10 +0100
Subject: Remove old timeline

---
 src/timeline/TimelineModel.cpp | 1220 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1220 insertions(+)
 create mode 100644 src/timeline/TimelineModel.cpp

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
new file mode 100644
index 00000000..ab7d3d47
--- /dev/null
+++ b/src/timeline/TimelineModel.cpp
@@ -0,0 +1,1220 @@
+#include "TimelineModel.h"
+
+#include <algorithm>
+#include <type_traits>
+
+#include <QRegularExpression>
+
+#include "ChatPage.h"
+#include "Logging.h"
+#include "MainWindow.h"
+#include "Olm.h"
+#include "TimelineViewManager.h"
+#include "Utils.h"
+#include "dialogs/RawMessage.h"
+
+Q_DECLARE_METATYPE(QModelIndex)
+
+namespace {
+template<class T>
+QString
+eventId(const mtx::events::RoomEvent<T> &event)
+{
+        return QString::fromStdString(event.event_id);
+}
+template<class T>
+QString
+roomId(const mtx::events::Event<T> &event)
+{
+        return QString::fromStdString(event.room_id);
+}
+template<class T>
+QString
+senderId(const mtx::events::RoomEvent<T> &event)
+{
+        return QString::fromStdString(event.sender);
+}
+
+template<class T>
+QDateTime
+eventTimestamp(const mtx::events::RoomEvent<T> &event)
+{
+        return QDateTime::fromMSecsSinceEpoch(event.origin_server_ts);
+}
+
+template<class T>
+std::string
+eventMsgType(const mtx::events::Event<T> &)
+{
+        return "";
+}
+template<class T>
+auto
+eventMsgType(const mtx::events::RoomEvent<T> &e) -> decltype(e.content.msgtype)
+{
+        return e.content.msgtype;
+}
+
+template<class T>
+QString
+eventBody(const mtx::events::Event<T> &)
+{
+        return QString("");
+}
+template<class T>
+auto
+eventBody(const mtx::events::RoomEvent<T> &e)
+  -> std::enable_if_t<std::is_same<decltype(e.content.body), std::string>::value, QString>
+{
+        return QString::fromStdString(e.content.body);
+}
+
+template<class T>
+QString
+eventFormattedBody(const mtx::events::Event<T> &)
+{
+        return QString("");
+}
+template<class T>
+auto
+eventFormattedBody(const mtx::events::RoomEvent<T> &e)
+  -> std::enable_if_t<std::is_same<decltype(e.content.formatted_body), std::string>::value, QString>
+{
+        auto temp = e.content.formatted_body;
+        if (!temp.empty()) {
+                return QString::fromStdString(temp);
+        } else {
+                return QString::fromStdString(e.content.body).toHtmlEscaped().replace("\n", "<br>");
+        }
+}
+
+template<class T>
+QString
+eventUrl(const mtx::events::Event<T> &)
+{
+        return "";
+}
+template<class T>
+auto
+eventUrl(const mtx::events::RoomEvent<T> &e)
+  -> std::enable_if_t<std::is_same<decltype(e.content.url), std::string>::value, QString>
+{
+        return QString::fromStdString(e.content.url);
+}
+
+template<class T>
+QString
+eventThumbnailUrl(const mtx::events::Event<T> &)
+{
+        return "";
+}
+template<class T>
+auto
+eventThumbnailUrl(const mtx::events::RoomEvent<T> &e)
+  -> std::enable_if_t<std::is_same<decltype(e.content.info.thumbnail_url), std::string>::value,
+                      QString>
+{
+        return QString::fromStdString(e.content.info.thumbnail_url);
+}
+
+template<class T>
+QString
+eventFilename(const mtx::events::Event<T> &)
+{
+        return "";
+}
+QString
+eventFilename(const mtx::events::RoomEvent<mtx::events::msg::Audio> &e)
+{
+        // body may be the original filename
+        return QString::fromStdString(e.content.body);
+}
+QString
+eventFilename(const mtx::events::RoomEvent<mtx::events::msg::Video> &e)
+{
+        // body may be the original filename
+        return QString::fromStdString(e.content.body);
+}
+QString
+eventFilename(const mtx::events::RoomEvent<mtx::events::msg::Image> &e)
+{
+        // body may be the original filename
+        return QString::fromStdString(e.content.body);
+}
+QString
+eventFilename(const mtx::events::RoomEvent<mtx::events::msg::File> &e)
+{
+        // body may be the original filename
+        if (!e.content.filename.empty())
+                return QString::fromStdString(e.content.filename);
+        return QString::fromStdString(e.content.body);
+}
+
+template<class T>
+auto
+eventFilesize(const mtx::events::RoomEvent<T> &e) -> decltype(e.content.info.size)
+{
+        return e.content.info.size;
+}
+
+template<class T>
+int64_t
+eventFilesize(const mtx::events::Event<T> &)
+{
+        return 0;
+}
+
+template<class T>
+QString
+eventMimeType(const mtx::events::Event<T> &)
+{
+        return QString();
+}
+template<class T>
+auto
+eventMimeType(const mtx::events::RoomEvent<T> &e)
+  -> std::enable_if_t<std::is_same<decltype(e.content.info.mimetype), std::string>::value, QString>
+{
+        return QString::fromStdString(e.content.info.mimetype);
+}
+
+template<class T>
+QString
+eventRelatesTo(const mtx::events::Event<T> &)
+{
+        return QString();
+}
+template<class T>
+auto
+eventRelatesTo(const mtx::events::RoomEvent<T> &e) -> std::enable_if_t<
+  std::is_same<decltype(e.content.relates_to.in_reply_to.event_id), std::string>::value,
+  QString>
+{
+        return QString::fromStdString(e.content.relates_to.in_reply_to.event_id);
+}
+
+template<class T>
+qml_mtx_events::EventType
+toRoomEventType(const mtx::events::Event<T> &e)
+{
+        using mtx::events::EventType;
+        switch (e.type) {
+        case EventType::RoomKeyRequest:
+                return qml_mtx_events::EventType::KeyRequest;
+        case EventType::RoomAliases:
+                return qml_mtx_events::EventType::Aliases;
+        case EventType::RoomAvatar:
+                return qml_mtx_events::EventType::Avatar;
+        case EventType::RoomCanonicalAlias:
+                return qml_mtx_events::EventType::CanonicalAlias;
+        case EventType::RoomCreate:
+                return qml_mtx_events::EventType::Create;
+        case EventType::RoomEncrypted:
+                return qml_mtx_events::EventType::Encrypted;
+        case EventType::RoomEncryption:
+                return qml_mtx_events::EventType::Encryption;
+        case EventType::RoomGuestAccess:
+                return qml_mtx_events::EventType::GuestAccess;
+        case EventType::RoomHistoryVisibility:
+                return qml_mtx_events::EventType::HistoryVisibility;
+        case EventType::RoomJoinRules:
+                return qml_mtx_events::EventType::JoinRules;
+        case EventType::RoomMember:
+                return qml_mtx_events::EventType::Member;
+        case EventType::RoomMessage:
+                return qml_mtx_events::EventType::UnknownMessage;
+        case EventType::RoomName:
+                return qml_mtx_events::EventType::Name;
+        case EventType::RoomPowerLevels:
+                return qml_mtx_events::EventType::PowerLevels;
+        case EventType::RoomTopic:
+                return qml_mtx_events::EventType::Topic;
+        case EventType::RoomTombstone:
+                return qml_mtx_events::EventType::Tombstone;
+        case EventType::RoomRedaction:
+                return qml_mtx_events::EventType::Redaction;
+        case EventType::RoomPinnedEvents:
+                return qml_mtx_events::EventType::PinnedEvents;
+        case EventType::Sticker:
+                return qml_mtx_events::EventType::Sticker;
+        case EventType::Tag:
+                return qml_mtx_events::EventType::Tag;
+        case EventType::Unsupported:
+        default:
+                return qml_mtx_events::EventType::Unsupported;
+        }
+}
+qml_mtx_events::EventType
+toRoomEventType(const mtx::events::Event<mtx::events::msg::Audio> &)
+{
+        return qml_mtx_events::EventType::AudioMessage;
+}
+qml_mtx_events::EventType
+toRoomEventType(const mtx::events::Event<mtx::events::msg::Emote> &)
+{
+        return qml_mtx_events::EventType::EmoteMessage;
+}
+qml_mtx_events::EventType
+toRoomEventType(const mtx::events::Event<mtx::events::msg::File> &)
+{
+        return qml_mtx_events::EventType::FileMessage;
+}
+qml_mtx_events::EventType
+toRoomEventType(const mtx::events::Event<mtx::events::msg::Image> &)
+{
+        return qml_mtx_events::EventType::ImageMessage;
+}
+qml_mtx_events::EventType
+toRoomEventType(const mtx::events::Event<mtx::events::msg::Notice> &)
+{
+        return qml_mtx_events::EventType::NoticeMessage;
+}
+qml_mtx_events::EventType
+toRoomEventType(const mtx::events::Event<mtx::events::msg::Text> &)
+{
+        return qml_mtx_events::EventType::TextMessage;
+}
+qml_mtx_events::EventType
+toRoomEventType(const mtx::events::Event<mtx::events::msg::Video> &)
+{
+        return qml_mtx_events::EventType::VideoMessage;
+}
+
+qml_mtx_events::EventType
+toRoomEventType(const mtx::events::Event<mtx::events::msg::Redacted> &)
+{
+        return qml_mtx_events::EventType::Redacted;
+}
+// ::EventType::Type toRoomEventType(const Event<mtx::events::msg::Location> &e) { return
+// ::EventType::LocationMessage; }
+
+template<class T>
+uint64_t
+eventHeight(const mtx::events::Event<T> &)
+{
+        return -1;
+}
+template<class T>
+auto
+eventHeight(const mtx::events::RoomEvent<T> &e) -> decltype(e.content.info.h)
+{
+        return e.content.info.h;
+}
+template<class T>
+uint64_t
+eventWidth(const mtx::events::Event<T> &)
+{
+        return -1;
+}
+template<class T>
+auto
+eventWidth(const mtx::events::RoomEvent<T> &e) -> decltype(e.content.info.w)
+{
+        return e.content.info.w;
+}
+
+template<class T>
+double
+eventPropHeight(const mtx::events::RoomEvent<T> &e)
+{
+        auto w = eventWidth(e);
+        if (w == 0)
+                w = 1;
+        return eventHeight(e) / (double)w;
+}
+}
+
+TimelineModel::TimelineModel(TimelineViewManager *manager, QString room_id, QObject *parent)
+  : QAbstractListModel(parent)
+  , room_id_(room_id)
+  , manager_(manager)
+{
+        connect(
+          this, &TimelineModel::oldMessagesRetrieved, this, &TimelineModel::addBackwardsEvents);
+        connect(this, &TimelineModel::messageFailed, this, [this](QString txn_id) {
+                pending.remove(txn_id);
+                failed.insert(txn_id);
+                int idx = idToIndex(txn_id);
+                if (idx < 0) {
+                        nhlog::ui()->warn("Failed index out of range");
+                        return;
+                }
+                emit dataChanged(index(idx, 0), index(idx, 0));
+        });
+        connect(this, &TimelineModel::messageSent, this, [this](QString txn_id, QString event_id) {
+                int idx = idToIndex(txn_id);
+                if (idx < 0) {
+                        nhlog::ui()->warn("Sent index out of range");
+                        return;
+                }
+                eventOrder[idx] = event_id;
+                auto ev         = events.value(txn_id);
+                ev              = boost::apply_visitor(
+                  [event_id](const auto &e) -> mtx::events::collections::TimelineEvents {
+                          auto eventCopy     = e;
+                          eventCopy.event_id = event_id.toStdString();
+                          return eventCopy;
+                  },
+                  ev);
+                events.remove(txn_id);
+                events.insert(event_id, ev);
+
+                // mark our messages as read
+                readEvent(event_id.toStdString());
+
+                // ask to be notified for read receipts
+                cache::client()->addPendingReceipt(room_id_, event_id);
+
+                emit dataChanged(index(idx, 0), index(idx, 0));
+        });
+        connect(this, &TimelineModel::redactionFailed, this, [](const QString &msg) {
+                emit ChatPage::instance()->showNotification(msg);
+        });
+}
+
+QHash<int, QByteArray>
+TimelineModel::roleNames() const
+{
+        return {
+          {Section, "section"},
+          {Type, "type"},
+          {Body, "body"},
+          {FormattedBody, "formattedBody"},
+          {UserId, "userId"},
+          {UserName, "userName"},
+          {Timestamp, "timestamp"},
+          {Url, "url"},
+          {ThumbnailUrl, "thumbnailUrl"},
+          {Filename, "filename"},
+          {Filesize, "filesize"},
+          {MimeType, "mimetype"},
+          {Height, "height"},
+          {Width, "width"},
+          {ProportionalHeight, "proportionalHeight"},
+          {Id, "id"},
+          {State, "state"},
+          {IsEncrypted, "isEncrypted"},
+          {ReplyTo, "replyTo"},
+        };
+}
+int
+TimelineModel::rowCount(const QModelIndex &parent) const
+{
+        Q_UNUSED(parent);
+        return (int)this->eventOrder.size();
+}
+
+QVariant
+TimelineModel::data(const QModelIndex &index, int role) const
+{
+        if (index.row() < 0 && index.row() >= (int)eventOrder.size())
+                return QVariant();
+
+        QString id = eventOrder[index.row()];
+
+        mtx::events::collections::TimelineEvents event = events.value(id);
+
+        if (auto e = boost::get<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(&event)) {
+                event = decryptEvent(*e).event;
+        }
+
+        switch (role) {
+        case Section: {
+                QDateTime date = boost::apply_visitor(
+                  [](const auto &e) -> QDateTime { return eventTimestamp(e); }, event);
+                date.setTime(QTime());
+
+                QString userId =
+                  boost::apply_visitor([](const auto &e) -> QString { return senderId(e); }, event);
+
+                for (int r = index.row() - 1; r > 0; r--) {
+                        QDateTime prevDate = boost::apply_visitor(
+                          [](const auto &e) -> QDateTime { return eventTimestamp(e); },
+                          events.value(eventOrder[r]));
+                        prevDate.setTime(QTime());
+                        if (prevDate != date)
+                                return QString("%2 %1").arg(date.toMSecsSinceEpoch()).arg(userId);
+
+                        QString prevUserId =
+                          boost::apply_visitor([](const auto &e) -> QString { return senderId(e); },
+                                               events.value(eventOrder[r]));
+                        if (userId != prevUserId)
+                                break;
+                }
+
+                return QString("%1").arg(userId);
+        }
+        case UserId:
+                return QVariant(boost::apply_visitor(
+                  [](const auto &e) -> QString { return senderId(e); }, event));
+        case UserName:
+                return QVariant(displayName(boost::apply_visitor(
+                  [](const auto &e) -> QString { return senderId(e); }, event)));
+
+        case Timestamp:
+                return QVariant(boost::apply_visitor(
+                  [](const auto &e) -> QDateTime { return eventTimestamp(e); }, event));
+        case Type:
+                return QVariant(boost::apply_visitor(
+                  [](const auto &e) -> qml_mtx_events::EventType { return toRoomEventType(e); },
+                  event));
+        case Body:
+                return QVariant(utils::replaceEmoji(boost::apply_visitor(
+                  [](const auto &e) -> QString { return eventBody(e); }, event)));
+        case FormattedBody:
+                return QVariant(
+                  utils::replaceEmoji(
+                    boost::apply_visitor(
+                      [](const auto &e) -> QString { return eventFormattedBody(e); }, event))
+                    .remove("<mx-reply>")
+                    .remove("</mx-reply>"));
+        case Url:
+                return QVariant(boost::apply_visitor(
+                  [](const auto &e) -> QString { return eventUrl(e); }, event));
+        case ThumbnailUrl:
+                return QVariant(boost::apply_visitor(
+                  [](const auto &e) -> QString { return eventThumbnailUrl(e); }, event));
+        case Filename:
+                return QVariant(boost::apply_visitor(
+                  [](const auto &e) -> QString { return eventFilename(e); }, event));
+        case Filesize:
+                return QVariant(boost::apply_visitor(
+                  [](const auto &e) -> QString {
+                          return utils::humanReadableFileSize(eventFilesize(e));
+                  },
+                  event));
+        case MimeType:
+                return QVariant(boost::apply_visitor(
+                  [](const auto &e) -> QString { return eventMimeType(e); }, event));
+        case Height:
+                return QVariant(boost::apply_visitor(
+                  [](const auto &e) -> qulonglong { return eventHeight(e); }, event));
+        case Width:
+                return QVariant(boost::apply_visitor(
+                  [](const auto &e) -> qulonglong { return eventWidth(e); }, event));
+        case ProportionalHeight:
+                return QVariant(boost::apply_visitor(
+                  [](const auto &e) -> double { return eventPropHeight(e); }, event));
+        case Id:
+                return id;
+        case State:
+                // only show read receipts for messages not from us
+                if (boost::apply_visitor([](const auto &e) -> QString { return senderId(e); },
+                                         event)
+                      .toStdString() != http::client()->user_id().to_string())
+                        return qml_mtx_events::Empty;
+                else if (failed.contains(id))
+                        return qml_mtx_events::Failed;
+                else if (pending.contains(id))
+                        return qml_mtx_events::Sent;
+                else if (read.contains(id) ||
+                         cache::client()->readReceipts(id, room_id_).size() > 1)
+                        return qml_mtx_events::Read;
+                else
+                        return qml_mtx_events::Received;
+        case IsEncrypted: {
+                auto tempEvent = events[id];
+                return boost::get<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(
+                         &tempEvent) != nullptr;
+        }
+        case ReplyTo: {
+                QString evId = boost::apply_visitor(
+                  [](const auto &e) -> QString { return eventRelatesTo(e); }, event);
+                return QVariant(evId);
+        }
+        default:
+                return QVariant();
+        }
+}
+
+void
+TimelineModel::addEvents(const mtx::responses::Timeline &timeline)
+{
+        if (isInitialSync) {
+                prev_batch_token_ = QString::fromStdString(timeline.prev_batch);
+                isInitialSync     = false;
+        }
+
+        if (timeline.events.empty())
+                return;
+
+        std::vector<QString> ids = internalAddEvents(timeline.events);
+
+        if (ids.empty())
+                return;
+
+        beginInsertRows(QModelIndex(),
+                        static_cast<int>(this->eventOrder.size()),
+                        static_cast<int>(this->eventOrder.size() + ids.size() - 1));
+        this->eventOrder.insert(this->eventOrder.end(), ids.begin(), ids.end());
+        endInsertRows();
+
+        updateLastMessage();
+}
+
+void
+TimelineModel::updateLastMessage()
+{
+        auto event = events.value(eventOrder.back());
+        if (auto e = boost::get<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(&event)) {
+                event = decryptEvent(*e).event;
+        }
+
+        auto description = utils::getMessageDescription(
+          event, QString::fromStdString(http::client()->user_id().to_string()), room_id_);
+        emit manager_->updateRoomsLastMessage(room_id_, description);
+}
+
+std::vector<QString>
+TimelineModel::internalAddEvents(
+  const std::vector<mtx::events::collections::TimelineEvents> &timeline)
+{
+        std::vector<QString> ids;
+        for (const auto &e : timeline) {
+                QString id =
+                  boost::apply_visitor([](const auto &e) -> QString { return eventId(e); }, e);
+
+                if (this->events.contains(id)) {
+                        this->events.insert(id, e);
+                        int idx = idToIndex(id);
+                        emit dataChanged(index(idx, 0), index(idx, 0));
+                        continue;
+                }
+
+                if (auto redaction =
+                      boost::get<mtx::events::RedactionEvent<mtx::events::msg::Redaction>>(&e)) {
+                        QString redacts = QString::fromStdString(redaction->redacts);
+                        auto redacted   = std::find(eventOrder.begin(), eventOrder.end(), redacts);
+
+                        if (redacted != eventOrder.end()) {
+                                auto redactedEvent = boost::apply_visitor(
+                                  [](const auto &ev)
+                                    -> mtx::events::RoomEvent<mtx::events::msg::Redacted> {
+                                          mtx::events::RoomEvent<mtx::events::msg::Redacted>
+                                            replacement                = {};
+                                          replacement.event_id         = ev.event_id;
+                                          replacement.room_id          = ev.room_id;
+                                          replacement.sender           = ev.sender;
+                                          replacement.origin_server_ts = ev.origin_server_ts;
+                                          replacement.type             = ev.type;
+                                          return replacement;
+                                  },
+                                  e);
+                                events.insert(redacts, redactedEvent);
+
+                                int row = (int)std::distance(eventOrder.begin(), redacted);
+                                emit dataChanged(index(row, 0), index(row, 0));
+                        }
+
+                        continue; // don't insert redaction into timeline
+                }
+
+                this->events.insert(id, e);
+                ids.push_back(id);
+        }
+        return ids;
+}
+
+void
+TimelineModel::fetchHistory()
+{
+        if (paginationInProgress) {
+                nhlog::ui()->warn("Already loading older messages");
+                return;
+        }
+
+        paginationInProgress = true;
+        mtx::http::MessagesOpts opts;
+        opts.room_id = room_id_.toStdString();
+        opts.from    = prev_batch_token_.toStdString();
+
+        nhlog::ui()->info("Paginationg room {}", opts.room_id);
+
+        http::client()->messages(
+          opts, [this, opts](const mtx::responses::Messages &res, mtx::http::RequestErr err) {
+                  if (err) {
+                          nhlog::net()->error("failed to call /messages ({}): {} - {}",
+                                              opts.room_id,
+                                              mtx::errors::to_string(err->matrix_error.errcode),
+                                              err->matrix_error.error);
+                          paginationInProgress = false;
+                          return;
+                  }
+
+                  emit oldMessagesRetrieved(std::move(res));
+                  paginationInProgress = false;
+          });
+}
+
+void
+TimelineModel::setCurrentIndex(int index)
+{
+        auto oldIndex = idToIndex(currentId);
+        currentId     = indexToId(index);
+        emit currentIndexChanged(index);
+
+        if (oldIndex < index && !pending.contains(currentId)) {
+                readEvent(currentId.toStdString());
+        }
+}
+
+void
+TimelineModel::readEvent(const std::string &id)
+{
+        http::client()->read_event(room_id_.toStdString(), id, [this](mtx::http::RequestErr err) {
+                if (err) {
+                        nhlog::net()->warn("failed to read_event ({}, {})",
+                                           room_id_.toStdString(),
+                                           currentId.toStdString());
+                }
+        });
+}
+
+void
+TimelineModel::addBackwardsEvents(const mtx::responses::Messages &msgs)
+{
+        std::vector<QString> ids = internalAddEvents(msgs.chunk);
+
+        if (!ids.empty()) {
+                beginInsertRows(QModelIndex(), 0, static_cast<int>(ids.size() - 1));
+                this->eventOrder.insert(this->eventOrder.begin(), ids.rbegin(), ids.rend());
+                endInsertRows();
+        }
+
+        prev_batch_token_ = QString::fromStdString(msgs.end);
+}
+
+QColor
+TimelineModel::userColor(QString id, QColor background)
+{
+        if (!userColors.contains(id))
+                userColors.insert(
+                  id, QColor(utils::generateContrastingHexColor(id, background.name())));
+        return userColors.value(id);
+}
+
+QString
+TimelineModel::displayName(QString id) const
+{
+        return Cache::displayName(room_id_, id);
+}
+
+QString
+TimelineModel::avatarUrl(QString id) const
+{
+        return Cache::avatarUrl(room_id_, id);
+}
+
+QString
+TimelineModel::formatDateSeparator(QDate date) const
+{
+        auto now = QDateTime::currentDateTime();
+
+        QString fmt = QLocale::system().dateFormat(QLocale::LongFormat);
+
+        if (now.date().year() == date.year()) {
+                QRegularExpression rx("[^a-zA-Z]*y+[^a-zA-Z]*");
+                fmt = fmt.remove(rx);
+        }
+
+        return date.toString(fmt);
+}
+
+QString
+TimelineModel::escapeEmoji(QString str) const
+{
+        return utils::replaceEmoji(str);
+}
+
+void
+TimelineModel::viewRawMessage(QString id) const
+{
+        std::string ev = utils::serialize_event(events.value(id)).dump(4);
+        auto dialog    = new dialogs::RawMessage(QString::fromStdString(ev));
+        Q_UNUSED(dialog);
+}
+
+void
+
+TimelineModel::openUserProfile(QString userid) const
+{
+        MainWindow::instance()->openUserProfile(userid, room_id_);
+}
+
+DecryptionResult
+TimelineModel::decryptEvent(const mtx::events::EncryptedEvent<mtx::events::msg::Encrypted> &e) const
+{
+        MegolmSessionIndex index;
+        index.room_id    = room_id_.toStdString();
+        index.session_id = e.content.session_id;
+        index.sender_key = e.content.sender_key;
+
+        mtx::events::RoomEvent<mtx::events::msg::Notice> dummy;
+        dummy.origin_server_ts = e.origin_server_ts;
+        dummy.event_id         = e.event_id;
+        dummy.sender           = e.sender;
+        dummy.content.body =
+          tr("-- Encrypted Event (No keys found for decryption) --",
+             "Placeholder, when the message was not decrypted yet or can't be decrypted")
+            .toStdString();
+
+        try {
+                if (!cache::client()->inboundMegolmSessionExists(index)) {
+                        nhlog::crypto()->info("Could not find inbound megolm session ({}, {}, {})",
+                                              index.room_id,
+                                              index.session_id,
+                                              e.sender);
+                        // TODO: request megolm session_id & session_key from the sender.
+                        return {dummy, false};
+                }
+        } catch (const lmdb::error &e) {
+                nhlog::db()->critical("failed to check megolm session's existence: {}", e.what());
+                dummy.content.body = tr("-- Decryption Error (failed to communicate with DB) --",
+                                        "Placeholder, when the message can't be decrypted, because "
+                                        "the DB access failed when trying to lookup the session.")
+                                       .toStdString();
+                return {dummy, false};
+        }
+
+        std::string msg_str;
+        try {
+                auto session = cache::client()->getInboundMegolmSession(index);
+                auto res     = olm::client()->decrypt_group_message(session, e.content.ciphertext);
+                msg_str      = std::string((char *)res.data.data(), res.data.size());
+        } catch (const lmdb::error &e) {
+                nhlog::db()->critical("failed to retrieve megolm session with index ({}, {}, {})",
+                                      index.room_id,
+                                      index.session_id,
+                                      index.sender_key,
+                                      e.what());
+                dummy.content.body =
+                  tr("-- Decryption Error (failed to retrieve megolm keys from db) --",
+                     "Placeholder, when the message can't be decrypted, because the DB access "
+                     "failed.")
+                    .toStdString();
+                return {dummy, false};
+        } catch (const mtx::crypto::olm_exception &e) {
+                nhlog::crypto()->critical("failed to decrypt message with index ({}, {}, {}): {}",
+                                          index.room_id,
+                                          index.session_id,
+                                          index.sender_key,
+                                          e.what());
+                dummy.content.body =
+                  tr("-- Decryption Error (%1) --",
+                     "Placeholder, when the message can't be decrypted. In this case, the Olm "
+                     "decrytion returned an error, which is passed ad %1")
+                    .arg(e.what())
+                    .toStdString();
+                return {dummy, false};
+        }
+
+        // Add missing fields for the event.
+        json body                = json::parse(msg_str);
+        body["event_id"]         = e.event_id;
+        body["sender"]           = e.sender;
+        body["origin_server_ts"] = e.origin_server_ts;
+        body["unsigned"]         = e.unsigned_data;
+
+        json event_array = json::array();
+        event_array.push_back(body);
+
+        std::vector<mtx::events::collections::TimelineEvents> temp_events;
+        mtx::responses::utils::parse_timeline_events(event_array, temp_events);
+
+        if (temp_events.size() == 1)
+                return {temp_events.at(0), true};
+
+        dummy.content.body =
+          tr("-- Encrypted Event (Unknown event type) --",
+             "Placeholder, when the message was decrypted, but we couldn't parse it, because "
+             "Nheko/mtxclient don't support that event type yet")
+            .toStdString();
+        return {dummy, false};
+}
+
+void
+TimelineModel::replyAction(QString id)
+{
+        auto event          = events.value(id);
+        RelatedInfo related = boost::apply_visitor(
+          [](const auto &ev) -> RelatedInfo {
+                  RelatedInfo related_   = {};
+                  related_.quoted_user   = QString::fromStdString(ev.sender);
+                  related_.related_event = ev.event_id;
+                  return related_;
+          },
+          event);
+        related.type        = mtx::events::getMessageType(boost::apply_visitor(
+          [](const auto &e) -> std::string { return eventMsgType(e); }, event));
+        related.quoted_body = boost::apply_visitor(
+          [](const auto &e) -> QString { return eventFormattedBody(e); }, event);
+        related.quoted_body.remove(QRegularExpression(
+          "<mx-reply>.*</mx-reply>", QRegularExpression::DotMatchesEverythingOption));
+        nhlog::ui()->debug("after replacement: {}", related.quoted_body.toStdString());
+        related.room = room_id_;
+
+        if (related.quoted_body.isEmpty())
+                return;
+
+        ChatPage::instance()->messageReply(related);
+}
+
+void
+TimelineModel::readReceiptsAction(QString id) const
+{
+        MainWindow::instance()->openReadReceiptsDialog(id);
+}
+
+void
+TimelineModel::redactEvent(QString id)
+{
+        if (!id.isEmpty())
+                http::client()->redact_event(
+                  room_id_.toStdString(),
+                  id.toStdString(),
+                  [this, id](const mtx::responses::EventId &, mtx::http::RequestErr err) {
+                          if (err) {
+                                  emit redactionFailed(
+                                    tr("Message redaction failed: %1")
+                                      .arg(QString::fromStdString(err->matrix_error.error)));
+                                  return;
+                          }
+
+                          emit eventRedacted(id);
+                  });
+}
+
+int
+TimelineModel::idToIndex(QString id) const
+{
+        if (id.isEmpty())
+                return -1;
+        for (int i = 0; i < (int)eventOrder.size(); i++)
+                if (id == eventOrder[i])
+                        return i;
+        return -1;
+}
+
+QString
+TimelineModel::indexToId(int index) const
+{
+        if (index < 0 || index >= (int)eventOrder.size())
+                return "";
+        return eventOrder[index];
+}
+
+// Note: this will only be called for our messages
+void
+TimelineModel::markEventsAsRead(const std::vector<QString> &event_ids)
+{
+        for (const auto &id : event_ids) {
+                read.insert(id);
+                int idx = idToIndex(id);
+                if (idx < 0) {
+                        nhlog::ui()->warn("Read index out of range");
+                        return;
+                }
+                emit dataChanged(index(idx, 0), index(idx, 0));
+        }
+}
+
+void
+TimelineModel::sendEncryptedMessage(const std::string &txn_id, nlohmann::json content)
+{
+        const auto room_id = room_id_.toStdString();
+
+        using namespace mtx::events;
+        using namespace mtx::identifiers;
+
+        json doc{{"type", "m.room.message"}, {"content", content}, {"room_id", room_id}};
+
+        try {
+                // Check if we have already an outbound megolm session then we can use.
+                if (cache::client()->outboundMegolmSessionExists(room_id)) {
+                        auto data = olm::encrypt_group_message(
+                          room_id, http::client()->device_id(), doc.dump());
+
+                        http::client()->send_room_message<msg::Encrypted, EventType::RoomEncrypted>(
+                          room_id,
+                          txn_id,
+                          data,
+                          [this, txn_id](const mtx::responses::EventId &res,
+                                         mtx::http::RequestErr err) {
+                                  if (err) {
+                                          const int status_code =
+                                            static_cast<int>(err->status_code);
+                                          nhlog::net()->warn("[{}] failed to send message: {} {}",
+                                                             txn_id,
+                                                             err->matrix_error.error,
+                                                             status_code);
+                                          emit messageFailed(QString::fromStdString(txn_id));
+                                  }
+                                  emit messageSent(
+                                    QString::fromStdString(txn_id),
+                                    QString::fromStdString(res.event_id.to_string()));
+                          });
+                        return;
+                }
+
+                nhlog::ui()->debug("creating new outbound megolm session");
+
+                // Create a new outbound megolm session.
+                auto outbound_session  = olm::client()->init_outbound_group_session();
+                const auto session_id  = mtx::crypto::session_id(outbound_session.get());
+                const auto session_key = mtx::crypto::session_key(outbound_session.get());
+
+                // TODO: needs to be moved in the lib.
+                auto megolm_payload = json{{"algorithm", "m.megolm.v1.aes-sha2"},
+                                           {"room_id", room_id},
+                                           {"session_id", session_id},
+                                           {"session_key", session_key}};
+
+                // Saving the new megolm session.
+                // TODO: Maybe it's too early to save.
+                OutboundGroupSessionData session_data;
+                session_data.session_id    = session_id;
+                session_data.session_key   = session_key;
+                session_data.message_index = 0; // TODO Update me
+                cache::client()->saveOutboundMegolmSession(
+                  room_id, session_data, std::move(outbound_session));
+
+                const auto members = cache::client()->roomMembers(room_id);
+                nhlog::ui()->info("retrieved {} members for {}", members.size(), room_id);
+
+                auto keeper =
+                  std::make_shared<StateKeeper>([megolm_payload, room_id, doc, txn_id, this]() {
+                          try {
+                                  auto data = olm::encrypt_group_message(
+                                    room_id, http::client()->device_id(), doc.dump());
+
+                                  http::client()
+                                    ->send_room_message<msg::Encrypted, EventType::RoomEncrypted>(
+                                      room_id,
+                                      txn_id,
+                                      data,
+                                      [this, txn_id](const mtx::responses::EventId &res,
+                                                     mtx::http::RequestErr err) {
+                                              if (err) {
+                                                      const int status_code =
+                                                        static_cast<int>(err->status_code);
+                                                      nhlog::net()->warn(
+                                                        "[{}] failed to send message: {} {}",
+                                                        txn_id,
+                                                        err->matrix_error.error,
+                                                        status_code);
+                                                      emit messageFailed(
+                                                        QString::fromStdString(txn_id));
+                                              }
+                                              emit messageSent(
+                                                QString::fromStdString(txn_id),
+                                                QString::fromStdString(res.event_id.to_string()));
+                                      });
+                          } catch (const lmdb::error &e) {
+                                  nhlog::db()->critical(
+                                    "failed to save megolm outbound session: {}", e.what());
+                          }
+                  });
+
+                mtx::requests::QueryKeys req;
+                for (const auto &member : members)
+                        req.device_keys[member] = {};
+
+                http::client()->query_keys(
+                  req,
+                  [keeper = std::move(keeper), megolm_payload, this](
+                    const mtx::responses::QueryKeys &res, mtx::http::RequestErr err) {
+                          if (err) {
+                                  nhlog::net()->warn("failed to query device keys: {} {}",
+                                                     err->matrix_error.error,
+                                                     static_cast<int>(err->status_code));
+                                  // TODO: Mark the event as failed. Communicate with the UI.
+                                  return;
+                          }
+
+                          for (const auto &user : res.device_keys) {
+                                  // Mapping from a device_id with valid identity keys to the
+                                  // generated room_key event used for sharing the megolm session.
+                                  std::map<std::string, std::string> room_key_msgs;
+                                  std::map<std::string, DevicePublicKeys> deviceKeys;
+
+                                  room_key_msgs.clear();
+                                  deviceKeys.clear();
+
+                                  for (const auto &dev : user.second) {
+                                          const auto user_id   = ::UserId(dev.second.user_id);
+                                          const auto device_id = DeviceId(dev.second.device_id);
+
+                                          const auto device_keys = dev.second.keys;
+                                          const auto curveKey    = "curve25519:" + device_id.get();
+                                          const auto edKey       = "ed25519:" + device_id.get();
+
+                                          if ((device_keys.find(curveKey) == device_keys.end()) ||
+                                              (device_keys.find(edKey) == device_keys.end())) {
+                                                  nhlog::net()->debug(
+                                                    "ignoring malformed keys for device {}",
+                                                    device_id.get());
+                                                  continue;
+                                          }
+
+                                          DevicePublicKeys pks;
+                                          pks.ed25519    = device_keys.at(edKey);
+                                          pks.curve25519 = device_keys.at(curveKey);
+
+                                          try {
+                                                  if (!mtx::crypto::verify_identity_signature(
+                                                        json(dev.second), device_id, user_id)) {
+                                                          nhlog::crypto()->warn(
+                                                            "failed to verify identity keys: {}",
+                                                            json(dev.second).dump(2));
+                                                          continue;
+                                                  }
+                                          } catch (const json::exception &e) {
+                                                  nhlog::crypto()->warn(
+                                                    "failed to parse device key json: {}",
+                                                    e.what());
+                                                  continue;
+                                          } catch (const mtx::crypto::olm_exception &e) {
+                                                  nhlog::crypto()->warn(
+                                                    "failed to verify device key json: {}",
+                                                    e.what());
+                                                  continue;
+                                          }
+
+                                          auto room_key = olm::client()
+                                                            ->create_room_key_event(
+                                                              user_id, pks.ed25519, megolm_payload)
+                                                            .dump();
+
+                                          room_key_msgs.emplace(device_id, room_key);
+                                          deviceKeys.emplace(device_id, pks);
+                                  }
+
+                                  std::vector<std::string> valid_devices;
+                                  valid_devices.reserve(room_key_msgs.size());
+                                  for (auto const &d : room_key_msgs) {
+                                          valid_devices.push_back(d.first);
+
+                                          nhlog::net()->info("{}", d.first);
+                                          nhlog::net()->info("  curve25519 {}",
+                                                             deviceKeys.at(d.first).curve25519);
+                                          nhlog::net()->info("  ed25519 {}",
+                                                             deviceKeys.at(d.first).ed25519);
+                                  }
+
+                                  nhlog::net()->info(
+                                    "sending claim request for user {} with {} devices",
+                                    user.first,
+                                    valid_devices.size());
+
+                                  http::client()->claim_keys(
+                                    user.first,
+                                    valid_devices,
+                                    std::bind(&TimelineModel::handleClaimedKeys,
+                                              this,
+                                              keeper,
+                                              room_key_msgs,
+                                              deviceKeys,
+                                              user.first,
+                                              std::placeholders::_1,
+                                              std::placeholders::_2));
+
+                                  // TODO: Wait before sending the next batch of requests.
+                                  std::this_thread::sleep_for(std::chrono::milliseconds(500));
+                          }
+                  });
+
+                // TODO: Let the user know about the errors.
+        } catch (const lmdb::error &e) {
+                nhlog::db()->critical(
+                  "failed to open outbound megolm session ({}): {}", room_id, e.what());
+        } catch (const mtx::crypto::olm_exception &e) {
+                nhlog::crypto()->critical(
+                  "failed to open outbound megolm session ({}): {}", room_id, e.what());
+        }
+}
+
+void
+TimelineModel::handleClaimedKeys(std::shared_ptr<StateKeeper> keeper,
+                                 const std::map<std::string, std::string> &room_keys,
+                                 const std::map<std::string, DevicePublicKeys> &pks,
+                                 const std::string &user_id,
+                                 const mtx::responses::ClaimKeys &res,
+                                 mtx::http::RequestErr err)
+{
+        if (err) {
+                nhlog::net()->warn("claim keys error: {} {} {}",
+                                   err->matrix_error.error,
+                                   err->parse_error,
+                                   static_cast<int>(err->status_code));
+                return;
+        }
+
+        nhlog::net()->debug("claimed keys for {}", user_id);
+
+        if (res.one_time_keys.size() == 0) {
+                nhlog::net()->debug("no one-time keys found for user_id: {}", user_id);
+                return;
+        }
+
+        if (res.one_time_keys.find(user_id) == res.one_time_keys.end()) {
+                nhlog::net()->debug("no one-time keys found for user_id: {}", user_id);
+                return;
+        }
+
+        auto retrieved_devices = res.one_time_keys.at(user_id);
+
+        // Payload with all the to_device message to be sent.
+        json body;
+        body["messages"][user_id] = json::object();
+
+        for (const auto &rd : retrieved_devices) {
+                const auto device_id = rd.first;
+                nhlog::net()->debug("{} : \n {}", device_id, rd.second.dump(2));
+
+                // TODO: Verify signatures
+                auto otk = rd.second.begin()->at("key");
+
+                if (pks.find(device_id) == pks.end()) {
+                        nhlog::net()->critical("couldn't find public key for device: {}",
+                                               device_id);
+                        continue;
+                }
+
+                auto id_key = pks.at(device_id).curve25519;
+                auto s      = olm::client()->create_outbound_session(id_key, otk);
+
+                if (room_keys.find(device_id) == room_keys.end()) {
+                        nhlog::net()->critical("couldn't find m.room_key for device: {}",
+                                               device_id);
+                        continue;
+                }
+
+                auto device_msg = olm::client()->create_olm_encrypted_content(
+                  s.get(), room_keys.at(device_id), pks.at(device_id).curve25519);
+
+                try {
+                        cache::client()->saveOlmSession(id_key, std::move(s));
+                } catch (const lmdb::error &e) {
+                        nhlog::db()->critical("failed to save outbound olm session: {}", e.what());
+                } catch (const mtx::crypto::olm_exception &e) {
+                        nhlog::crypto()->critical("failed to pickle outbound olm session: {}",
+                                                  e.what());
+                }
+
+                body["messages"][user_id][device_id] = device_msg;
+        }
+
+        nhlog::net()->info("send_to_device: {}", user_id);
+
+        http::client()->send_to_device(
+          "m.room.encrypted", body, [keeper](mtx::http::RequestErr err) {
+                  if (err) {
+                          nhlog::net()->warn("failed to send "
+                                             "send_to_device "
+                                             "message: {}",
+                                             err->matrix_error.error);
+                  }
+
+                  (void)keeper;
+          });
+}
-- 
cgit 1.5.1


From 562169965ce68cadbf8214e084477c60ddfdde0b Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Sat, 9 Nov 2019 03:30:17 +0100
Subject: Show only messages in room list

---
 src/timeline/TimelineModel.cpp | 37 ++++++++++++++++++++++++++++++-------
 1 file changed, 30 insertions(+), 7 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index ab7d3d47..9cae4608 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -552,17 +552,40 @@ TimelineModel::addEvents(const mtx::responses::Timeline &timeline)
         updateLastMessage();
 }
 
+template<typename T>
+auto
+isMessage(const mtx::events::RoomEvent<T> &e)
+  -> std::enable_if_t<std::is_same<decltype(e.content.msgtype), std::string>::value, bool>
+{
+        return true;
+}
+
+template<typename T>
+auto
+isMessage(const mtx::events::Event<T> &)
+{
+        return false;
+}
+
 void
 TimelineModel::updateLastMessage()
 {
-        auto event = events.value(eventOrder.back());
-        if (auto e = boost::get<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(&event)) {
-                event = decryptEvent(*e).event;
-        }
+        for (auto it = eventOrder.rbegin(); it != eventOrder.rend(); ++it) {
+                auto event = events.value(*it);
+                if (auto e = boost::get<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(
+                      &event)) {
+                        event = decryptEvent(*e).event;
+                }
 
-        auto description = utils::getMessageDescription(
-          event, QString::fromStdString(http::client()->user_id().to_string()), room_id_);
-        emit manager_->updateRoomsLastMessage(room_id_, description);
+                if (!boost::apply_visitor([](const auto &e) -> bool { return isMessage(e); },
+                                          event))
+                        continue;
+
+                auto description = utils::getMessageDescription(
+                  event, QString::fromStdString(http::client()->user_id().to_string()), room_id_);
+                emit manager_->updateRoomsLastMessage(room_id_, description);
+                return;
+        }
 }
 
 std::vector<QString>
-- 
cgit 1.5.1


From c424e397b01d8191568f951bdb754e1957681fb8 Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Sun, 10 Nov 2019 00:30:02 +0100
Subject: Add loading spinner and restore message send queue

---
 resources/qml/TimelineView.qml       | 13 +++--
 src/timeline/TimelineModel.cpp       | 97 +++++++++++++++++++++++++++++++++++-
 src/timeline/TimelineModel.h         | 41 ++++-----------
 src/timeline/TimelineViewManager.cpp |  3 ++
 src/timeline/TimelineViewManager.h   | 14 +++---
 5 files changed, 123 insertions(+), 45 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/resources/qml/TimelineView.qml b/resources/qml/TimelineView.qml
index b25b3a7c..3bbaa020 100644
--- a/resources/qml/TimelineView.qml
+++ b/resources/qml/TimelineView.qml
@@ -19,13 +19,20 @@ Item {
 		color: colors.window
 
 		Text {
-			visible: !timelineManager.timeline
+			visible: !timelineManager.timeline && !timelineManager.isInitialSync
 			anchors.centerIn: parent
 			text: qsTr("No room open")
 			font.pointSize: 24
 			color: colors.windowText
 		}
 
+		BusyIndicator {
+			anchors.centerIn: parent
+			running: timelineManager.isInitialSync
+			height: 200
+			width: 200
+		}
+
 		ListView {
 			id: chat
 
@@ -47,10 +54,6 @@ Item {
 					} else {
 						positionViewAtIndex(model.currentIndex, ListView.End)
 					}
-
-					//if (contentHeight < height) {
-					//	model.fetchHistory();
-					//}
 				}
 			}
 
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 9cae4608..6b0057a4 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -332,16 +332,18 @@ TimelineModel::TimelineModel(TimelineViewManager *manager, QString room_id, QObj
         connect(
           this, &TimelineModel::oldMessagesRetrieved, this, &TimelineModel::addBackwardsEvents);
         connect(this, &TimelineModel::messageFailed, this, [this](QString txn_id) {
-                pending.remove(txn_id);
+                pending.removeOne(txn_id);
                 failed.insert(txn_id);
                 int idx = idToIndex(txn_id);
                 if (idx < 0) {
                         nhlog::ui()->warn("Failed index out of range");
                         return;
                 }
+                isProcessingPending = false;
                 emit dataChanged(index(idx, 0), index(idx, 0));
         });
         connect(this, &TimelineModel::messageSent, this, [this](QString txn_id, QString event_id) {
+                pending.removeOne(txn_id);
                 int idx = idToIndex(txn_id);
                 if (idx < 0) {
                         nhlog::ui()->warn("Sent index out of range");
@@ -365,11 +367,19 @@ TimelineModel::TimelineModel(TimelineViewManager *manager, QString room_id, QObj
                 // ask to be notified for read receipts
                 cache::client()->addPendingReceipt(room_id_, event_id);
 
+                isProcessingPending = false;
                 emit dataChanged(index(idx, 0), index(idx, 0));
+
+                if (pending.size() > 0)
+                        emit nextPendingMessage();
         });
         connect(this, &TimelineModel::redactionFailed, this, [](const QString &msg) {
                 emit ChatPage::instance()->showNotification(msg);
         });
+
+        connect(
+          this, &TimelineModel::nextPendingMessage, this, &TimelineModel::processOnePendingMessage);
+        connect(this, &TimelineModel::newMessageToSend, this, &TimelineModel::addPendingMessage);
 }
 
 QHash<int, QByteArray>
@@ -1035,6 +1045,7 @@ TimelineModel::sendEncryptedMessage(const std::string &txn_id, nlohmann::json co
                           } catch (const lmdb::error &e) {
                                   nhlog::db()->critical(
                                     "failed to save megolm outbound session: {}", e.what());
+                                  emit messageFailed(QString::fromStdString(txn_id));
                           }
                   });
 
@@ -1044,13 +1055,14 @@ TimelineModel::sendEncryptedMessage(const std::string &txn_id, nlohmann::json co
 
                 http::client()->query_keys(
                   req,
-                  [keeper = std::move(keeper), megolm_payload, this](
+                  [keeper = std::move(keeper), megolm_payload, txn_id, this](
                     const mtx::responses::QueryKeys &res, mtx::http::RequestErr err) {
                           if (err) {
                                   nhlog::net()->warn("failed to query device keys: {} {}",
                                                      err->matrix_error.error,
                                                      static_cast<int>(err->status_code));
                                   // TODO: Mark the event as failed. Communicate with the UI.
+                                  emit messageFailed(QString::fromStdString(txn_id));
                                   return;
                           }
 
@@ -1150,9 +1162,11 @@ TimelineModel::sendEncryptedMessage(const std::string &txn_id, nlohmann::json co
         } catch (const lmdb::error &e) {
                 nhlog::db()->critical(
                   "failed to open outbound megolm session ({}): {}", room_id, e.what());
+                emit messageFailed(QString::fromStdString(txn_id));
         } catch (const mtx::crypto::olm_exception &e) {
                 nhlog::crypto()->critical(
                   "failed to open outbound megolm session ({}): {}", room_id, e.what());
+                emit messageFailed(QString::fromStdString(txn_id));
         }
 }
 
@@ -1241,3 +1255,82 @@ TimelineModel::handleClaimedKeys(std::shared_ptr<StateKeeper> keeper,
                   (void)keeper;
           });
 }
+
+struct SendMessageVisitor
+{
+        SendMessageVisitor(const QString &txn_id, TimelineModel *model)
+          : txn_id_qstr_(txn_id)
+          , model_(model)
+        {}
+
+        template<typename T>
+        void operator()(const mtx::events::Event<T> &)
+        {}
+
+        template<typename T,
+                 std::enable_if_t<std::is_same<decltype(T::msgtype), std::string>::value, int> = 0>
+        void operator()(const mtx::events::RoomEvent<T> &msg)
+
+        {
+                if (cache::client()->isRoomEncrypted(model_->room_id_.toStdString())) {
+                        model_->sendEncryptedMessage(txn_id_qstr_.toStdString(),
+                                                     nlohmann::json(msg.content));
+                } else {
+                        QString txn_id_qstr  = txn_id_qstr_;
+                        TimelineModel *model = model_;
+                        http::client()->send_room_message<T, mtx::events::EventType::RoomMessage>(
+                          model->room_id_.toStdString(),
+                          txn_id_qstr.toStdString(),
+                          msg.content,
+                          [txn_id_qstr, model](const mtx::responses::EventId &res,
+                                               mtx::http::RequestErr err) {
+                                  if (err) {
+                                          const int status_code =
+                                            static_cast<int>(err->status_code);
+                                          nhlog::net()->warn("[{}] failed to send message: {} {}",
+                                                             txn_id_qstr.toStdString(),
+                                                             err->matrix_error.error,
+                                                             status_code);
+                                          emit model->messageFailed(txn_id_qstr);
+                                  }
+                                  emit model->messageSent(
+                                    txn_id_qstr, QString::fromStdString(res.event_id.to_string()));
+                          });
+                }
+        }
+
+        QString txn_id_qstr_;
+        TimelineModel *model_;
+};
+
+void
+TimelineModel::processOnePendingMessage()
+{
+        if (isProcessingPending || pending.isEmpty())
+                return;
+
+        isProcessingPending = true;
+
+        QString txn_id_qstr = pending.first();
+
+        boost::apply_visitor(SendMessageVisitor{txn_id_qstr, this}, events.value(txn_id_qstr));
+}
+
+void
+TimelineModel::addPendingMessage(mtx::events::collections::TimelineEvents event)
+{
+        internalAddEvents({event});
+
+        QString txn_id_qstr =
+          boost::apply_visitor([](const auto &e) -> QString { return eventId(e); }, event);
+        beginInsertRows(QModelIndex(),
+                        static_cast<int>(this->eventOrder.size()),
+                        static_cast<int>(this->eventOrder.size()));
+        pending.push_back(txn_id_qstr);
+        this->eventOrder.insert(this->eventOrder.end(), txn_id_qstr);
+        endInsertRows();
+        updateLastMessage();
+
+        if (!isProcessingPending)
+                emit nextPendingMessage();
+}
diff --git a/src/timeline/TimelineModel.h b/src/timeline/TimelineModel.h
index 31e41315..e7842b99 100644
--- a/src/timeline/TimelineModel.h
+++ b/src/timeline/TimelineModel.h
@@ -173,6 +173,8 @@ public slots:
 private slots:
         // Add old events at the top of the timeline.
         void addBackwardsEvents(const mtx::responses::Messages &msgs);
+        void processOnePendingMessage();
+        void addPendingMessage(mtx::events::collections::TimelineEvents event);
 
 signals:
         void oldMessagesRetrieved(const mtx::responses::Messages &res);
@@ -181,6 +183,8 @@ signals:
         void currentIndexChanged(int index);
         void redactionFailed(QString id);
         void eventRedacted(QString id);
+        void nextPendingMessage();
+        void newMessageToSend(mtx::events::collections::TimelineEvents event);
 
 private:
         DecryptionResult decryptEvent(
@@ -198,7 +202,8 @@ private:
         void readEvent(const std::string &id);
 
         QHash<QString, mtx::events::collections::TimelineEvents> events;
-        QSet<QString> pending, failed, read;
+        QSet<QString> failed, read;
+        QList<QString> pending;
         std::vector<QString> eventOrder;
 
         QString room_id_;
@@ -206,11 +211,14 @@ private:
 
         bool isInitialSync        = true;
         bool paginationInProgress = false;
+        bool isProcessingPending  = false;
 
         QHash<QString, QColor> userColors;
         QString currentId;
 
         TimelineViewManager *manager_;
+
+        friend struct SendMessageVisitor;
 };
 
 template<class T>
@@ -224,35 +232,6 @@ TimelineModel::sendMessage(const T &msg)
         msgCopy.event_id                  = txn_id;
         msgCopy.sender                    = http::client()->user_id().to_string();
         msgCopy.origin_server_ts          = QDateTime::currentMSecsSinceEpoch();
-        internalAddEvents({msgCopy});
-
-        QString txn_id_qstr = QString::fromStdString(txn_id);
-        beginInsertRows(QModelIndex(),
-                        static_cast<int>(this->eventOrder.size()),
-                        static_cast<int>(this->eventOrder.size()));
-        pending.insert(txn_id_qstr);
-        this->eventOrder.insert(this->eventOrder.end(), txn_id_qstr);
-        endInsertRows();
-        updateLastMessage();
 
-        if (cache::client()->isRoomEncrypted(room_id_.toStdString()))
-                sendEncryptedMessage(txn_id, nlohmann::json(msg));
-        else
-                http::client()->send_room_message<T, mtx::events::EventType::RoomMessage>(
-                  room_id_.toStdString(),
-                  txn_id,
-                  msg,
-                  [this, txn_id, txn_id_qstr](const mtx::responses::EventId &res,
-                                              mtx::http::RequestErr err) {
-                          if (err) {
-                                  const int status_code = static_cast<int>(err->status_code);
-                                  nhlog::net()->warn("[{}] failed to send message: {} {}",
-                                                     txn_id,
-                                                     err->matrix_error.error,
-                                                     status_code);
-                                  emit messageFailed(txn_id_qstr);
-                          }
-                          emit messageSent(txn_id_qstr,
-                                           QString::fromStdString(res.event_id.to_string()));
-                  });
+        emit newMessageToSend(msgCopy);
 }
diff --git a/src/timeline/TimelineViewManager.cpp b/src/timeline/TimelineViewManager.cpp
index d733ad90..06c42a39 100644
--- a/src/timeline/TimelineViewManager.cpp
+++ b/src/timeline/TimelineViewManager.cpp
@@ -97,6 +97,9 @@ TimelineViewManager::sync(const mtx::responses::Rooms &rooms)
                 addRoom(QString::fromStdString(it->first));
                 models.value(QString::fromStdString(it->first))->addEvents(it->second.timeline);
         }
+
+        this->isInitialSync_ = false;
+        emit initialSyncChanged(false);
 }
 
 void
diff --git a/src/timeline/TimelineViewManager.h b/src/timeline/TimelineViewManager.h
index 691c8ddb..0bc58e68 100644
--- a/src/timeline/TimelineViewManager.h
+++ b/src/timeline/TimelineViewManager.h
@@ -12,10 +12,6 @@
 #include "TimelineModel.h"
 #include "Utils.h"
 
-// temporary for stubs
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-
 class MxcImageProvider;
 class ColorImageProvider;
 
@@ -25,6 +21,8 @@ class TimelineViewManager : public QObject
 
         Q_PROPERTY(
           TimelineModel *timeline MEMBER timeline_ READ activeTimeline NOTIFY activeTimelineChanged)
+        Q_PROPERTY(
+          bool isInitialSync MEMBER isInitialSync_ READ isInitialSync NOTIFY initialSyncChanged)
 
 public:
         TimelineViewManager(QWidget *parent = 0);
@@ -36,6 +34,7 @@ public:
         void clearAll() { models.clear(); }
 
         Q_INVOKABLE TimelineModel *activeTimeline() const { return timeline_; }
+        Q_INVOKABLE bool isInitialSync() const { return isInitialSync_; }
         void openImageOverlay(QString mxcUrl,
                               QString originalFilename,
                               QString mimeType,
@@ -66,6 +65,7 @@ signals:
         void clearRoomMessageCount(QString roomid);
         void updateRoomsLastMessage(QString roomid, const DescInfo &info);
         void activeTimelineChanged(TimelineModel *timeline);
+        void initialSyncChanged(bool isInitialSync);
         void mediaCached(QString mxcUrl, QString cacheUrl);
 
 public slots:
@@ -107,11 +107,11 @@ private:
         QQuickWidget *view;
 #endif
         QWidget *container;
-        TimelineModel *timeline_ = nullptr;
+
         MxcImageProvider *imgProvider;
         ColorImageProvider *colorImgProvider;
 
         QHash<QString, QSharedPointer<TimelineModel>> models;
+        TimelineModel *timeline_ = nullptr;
+        bool isInitialSync_      = true;
 };
-
-#pragma GCC diagnostic pop
-- 
cgit 1.5.1


From 001c94865c98836b06c827ff890a5589dd97320d Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Tue, 12 Nov 2019 15:10:59 +0000
Subject: Fix windows build

No idea, why apply visitor doesn't work with temporaries?
---
 src/dialogs/RoomSettings.cpp         | 2 +-
 src/timeline/TimelineModel.cpp       | 8 +++++---
 src/timeline/TimelineViewManager.cpp | 2 +-
 3 files changed, 7 insertions(+), 5 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/dialogs/RoomSettings.cpp b/src/dialogs/RoomSettings.cpp
index 00b034cc..25909cd8 100644
--- a/src/dialogs/RoomSettings.cpp
+++ b/src/dialogs/RoomSettings.cpp
@@ -488,7 +488,7 @@ RoomSettings::retrieveRoomInfo()
                 usesEncryption_ = cache::client()->isRoomEncrypted(room_id_.toStdString());
                 info_           = cache::client()->singleRoomInfo(room_id_.toStdString());
                 setAvatar();
-        } catch (const lmdb::error &e) {
+        } catch (const lmdb::error &) {
                 nhlog::db()->warn("failed to retrieve room info from cache: {}",
                                   room_id_.toStdString());
         }
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 6b0057a4..39abbf6f 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -438,16 +438,17 @@ TimelineModel::data(const QModelIndex &index, int role) const
                   boost::apply_visitor([](const auto &e) -> QString { return senderId(e); }, event);
 
                 for (int r = index.row() - 1; r > 0; r--) {
+                        auto tempEv        = events.value(eventOrder[r]);
                         QDateTime prevDate = boost::apply_visitor(
                           [](const auto &e) -> QDateTime { return eventTimestamp(e); },
-                          events.value(eventOrder[r]));
+                          tempEv);
                         prevDate.setTime(QTime());
                         if (prevDate != date)
                                 return QString("%2 %1").arg(date.toMSecsSinceEpoch()).arg(userId);
 
                         QString prevUserId =
                           boost::apply_visitor([](const auto &e) -> QString { return senderId(e); },
-                                               events.value(eventOrder[r]));
+                                               tempEv);
                         if (userId != prevUserId)
                                 break;
                 }
@@ -1313,7 +1314,8 @@ TimelineModel::processOnePendingMessage()
 
         QString txn_id_qstr = pending.first();
 
-        boost::apply_visitor(SendMessageVisitor{txn_id_qstr, this}, events.value(txn_id_qstr));
+        auto event = events.value(txn_id_qstr);
+        boost::apply_visitor(SendMessageVisitor{txn_id_qstr, this}, event);
 }
 
 void
diff --git a/src/timeline/TimelineViewManager.cpp b/src/timeline/TimelineViewManager.cpp
index 06c42a39..39bdfcf4 100644
--- a/src/timeline/TimelineViewManager.cpp
+++ b/src/timeline/TimelineViewManager.cpp
@@ -200,7 +200,7 @@ TimelineViewManager::saveMedia(QString mxcUrl,
                           if (!file.open(QIODevice::WriteOnly))
                                   return;
 
-                          file.write(QByteArray(data.data(), data.size()));
+                          file.write(QByteArray(data.data(), (int)data.size()));
                           file.close();
                   } catch (const std::exception &e) {
                           nhlog::ui()->warn("Error while saving file to: {}", e.what());
-- 
cgit 1.5.1


From cf88499ccb6709db3312cd675c87614389cc0aac Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Mon, 11 Nov 2019 19:58:20 +0100
Subject: Fix replies to encrypted events

---
 src/timeline/TimelineModel.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 39abbf6f..72c107d4 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -869,7 +869,11 @@ TimelineModel::decryptEvent(const mtx::events::EncryptedEvent<mtx::events::msg::
 void
 TimelineModel::replyAction(QString id)
 {
-        auto event          = events.value(id);
+        auto event = events.value(id);
+        if (auto e = boost::get<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(&event)) {
+                event = decryptEvent(*e).event;
+        }
+
         RelatedInfo related = boost::apply_visitor(
           [](const auto &ev) -> RelatedInfo {
                   RelatedInfo related_   = {};
-- 
cgit 1.5.1


From 5429b425e97f3482e7e5510a8606659168f58b7d Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Tue, 12 Nov 2019 17:46:09 +0100
Subject: Lint

---
 src/timeline/TimelineModel.cpp | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 72c107d4..7c78e552 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -440,15 +440,13 @@ TimelineModel::data(const QModelIndex &index, int role) const
                 for (int r = index.row() - 1; r > 0; r--) {
                         auto tempEv        = events.value(eventOrder[r]);
                         QDateTime prevDate = boost::apply_visitor(
-                          [](const auto &e) -> QDateTime { return eventTimestamp(e); },
-                          tempEv);
+                          [](const auto &e) -> QDateTime { return eventTimestamp(e); }, tempEv);
                         prevDate.setTime(QTime());
                         if (prevDate != date)
                                 return QString("%2 %1").arg(date.toMSecsSinceEpoch()).arg(userId);
 
-                        QString prevUserId =
-                          boost::apply_visitor([](const auto &e) -> QString { return senderId(e); },
-                                               tempEv);
+                        QString prevUserId = boost::apply_visitor(
+                          [](const auto &e) -> QString { return senderId(e); }, tempEv);
                         if (userId != prevUserId)
                                 break;
                 }
-- 
cgit 1.5.1


From 7bd875004f6995865a71a55facf56834c91bfb48 Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Fri, 22 Nov 2019 16:36:45 +0100
Subject: Only mark messages as read, when room is active

---
 src/timeline/TimelineModel.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 7c78e552..11344e60 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -685,7 +685,8 @@ TimelineModel::setCurrentIndex(int index)
         currentId     = indexToId(index);
         emit currentIndexChanged(index);
 
-        if (oldIndex < index && !pending.contains(currentId)) {
+        if (oldIndex < index && !pending.contains(currentId) &&
+            ChatPage::instance()->isActiveWindow()) {
                 readEvent(currentId.toStdString());
         }
 }
-- 
cgit 1.5.1


From 9fd279c020bba2f433a0f9862277bc59fd621130 Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Fri, 22 Nov 2019 17:08:32 +0100
Subject: Show encryption enabled and use a non zero size for zero size vide

---
 resources/qml/TimelineView.qml                   |  2 +-
 resources/qml/delegates/MessageDelegate.qml      | 10 +++++++++-
 resources/qml/delegates/Pill.qml                 | 14 ++++++++++++++
 resources/qml/delegates/PlayableMediaMessage.qml |  2 +-
 resources/qml/delegates/Redacted.qml             | 15 ---------------
 resources/res.qrc                                |  2 +-
 src/timeline/TimelineModel.cpp                   |  5 ++++-
 7 files changed, 30 insertions(+), 20 deletions(-)
 create mode 100644 resources/qml/delegates/Pill.qml
 delete mode 100644 resources/qml/delegates/Redacted.qml

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/resources/qml/TimelineView.qml b/resources/qml/TimelineView.qml
index 3bbaa020..a5520031 100644
--- a/resources/qml/TimelineView.qml
+++ b/resources/qml/TimelineView.qml
@@ -79,7 +79,7 @@ Item {
 				}
 			}
 
-			onAtYBeginningChanged: if (atYBeginning) model.fetchHistory()
+			onAtYBeginningChanged: if (atYBeginning) { chat.model.currentIndex = 0; chat.currentIndex = 0; model.fetchHistory(); }
 
 			function updatePosition() {
 				for (var y = chat.contentY + chat.height; y > chat.height; y -= 9) {
diff --git a/resources/qml/delegates/MessageDelegate.qml b/resources/qml/delegates/MessageDelegate.qml
index 49209f68..e31321f9 100644
--- a/resources/qml/delegates/MessageDelegate.qml
+++ b/resources/qml/delegates/MessageDelegate.qml
@@ -39,7 +39,15 @@ DelegateChooser {
 	}
 	DelegateChoice {
 		roleValue: MtxEvent.Redacted
-		Redacted {}
+		Pill {
+			text: qsTr("redacted")
+		}
+	}
+	DelegateChoice {
+		roleValue: MtxEvent.Encryption
+		Pill {
+			text: qsTr("Encryption enabled")
+		}
 	}
 	DelegateChoice {
 		Placeholder {}
diff --git a/resources/qml/delegates/Pill.qml b/resources/qml/delegates/Pill.qml
new file mode 100644
index 00000000..53a9684e
--- /dev/null
+++ b/resources/qml/delegates/Pill.qml
@@ -0,0 +1,14 @@
+import QtQuick 2.5
+import QtQuick.Controls 2.1
+
+Label {
+	color: inactiveColors.text
+	horizontalAlignment: Text.AlignHCenter
+
+	height: contentHeight * 1.2
+	width: contentWidth * 1.2
+	background: Rectangle {
+		radius: parent.height / 2
+		color: colors.dark
+	}
+}
diff --git a/resources/qml/delegates/PlayableMediaMessage.qml b/resources/qml/delegates/PlayableMediaMessage.qml
index 68b09f7b..1207ac77 100644
--- a/resources/qml/delegates/PlayableMediaMessage.qml
+++ b/resources/qml/delegates/PlayableMediaMessage.qml
@@ -20,7 +20,7 @@ Rectangle {
 		Rectangle {
 			id: videoContainer
 			visible: model.type == MtxEvent.VideoMessage
-			width: Math.min(parent.width, model.width)
+			width: Math.min(parent.width, model.width ? model.width : 400) // some media has 0 as size...
 			height: width*model.proportionalHeight
 			Image {
 				anchors.fill: parent
diff --git a/resources/qml/delegates/Redacted.qml b/resources/qml/delegates/Redacted.qml
deleted file mode 100644
index 42fb4835..00000000
--- a/resources/qml/delegates/Redacted.qml
+++ /dev/null
@@ -1,15 +0,0 @@
-import QtQuick 2.5
-import QtQuick.Controls 2.1
-
-Label {
-	text: qsTr("redacted")
-	color: inactiveColors.text
-	horizontalAlignment: Text.AlignHCenter
-
-	height: contentHeight * 1.2
-	width: contentWidth * 1.2
-	background: Rectangle {
-		radius: parent.height / 2
-		color: colors.dark
-	}
-}
diff --git a/resources/res.qrc b/resources/res.qrc
index c9938d57..53406c48 100644
--- a/resources/res.qrc
+++ b/resources/res.qrc
@@ -128,7 +128,7 @@
         <file>qml/delegates/ImageMessage.qml</file>
         <file>qml/delegates/PlayableMediaMessage.qml</file>
         <file>qml/delegates/FileMessage.qml</file>
-        <file>qml/delegates/Redacted.qml</file>
+        <file>qml/delegates/Pill.qml</file>
         <file>qml/delegates/Placeholder.qml</file>
     </qresource>
 </RCC>
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 11344e60..b904dfd7 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -320,7 +320,10 @@ eventPropHeight(const mtx::events::RoomEvent<T> &e)
         auto w = eventWidth(e);
         if (w == 0)
                 w = 1;
-        return eventHeight(e) / (double)w;
+
+        double prop = eventHeight(e) / (double)w;
+
+        return prop > 0 ? prop : 1.;
 }
 }
 
-- 
cgit 1.5.1


From b8f6e4ce6462f074c34a8b7a286cbabe0e2897aa Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Tue, 3 Dec 2019 02:26:41 +0100
Subject: Add encrypted file download

---
 deps/CMakeLists.txt                              |   4 +-
 resources/qml/TimelineRow.qml                    |   2 +-
 resources/qml/delegates/FileMessage.qml          |   2 +-
 resources/qml/delegates/ImageMessage.qml         |   2 +-
 resources/qml/delegates/PlayableMediaMessage.qml |   4 +-
 src/timeline/TimelineModel.cpp                   | 184 +++++++++++++++++++++++
 src/timeline/TimelineModel.h                     |   3 +
 src/timeline/TimelineViewManager.cpp             | 154 ++-----------------
 src/timeline/TimelineViewManager.h               |  27 +---
 9 files changed, 210 insertions(+), 172 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/deps/CMakeLists.txt b/deps/CMakeLists.txt
index d0a715e0..c5932ab7 100644
--- a/deps/CMakeLists.txt
+++ b/deps/CMakeLists.txt
@@ -46,10 +46,10 @@ set(BOOST_SHA256
 
 set(
   MTXCLIENT_URL
-  https://github.com/Nheko-Reborn/mtxclient/archive/6eee767cc25a9db9f125843e584656cde1ebb6c5.tar.gz
+  https://github.com/Nheko-Reborn/mtxclient/archive/f719236b08d373d9508f2467bbfc6dfa953b1f8d.zip
   )
 set(MTXCLIENT_HASH
-  72fe77da4fed98b3cf069299f66092c820c900359a27ec26070175f9ad208a03)
+    0660756c16cf297e02b0b29c07a59fc851723cc65f305893ae7238e6dd2e41c8)
 set(
   TWEENY_URL
   https://github.com/mobius3/tweeny/archive/b94ce07cfb02a0eb8ac8aaf66137dabdaea857cf.tar.gz
diff --git a/resources/qml/TimelineRow.qml b/resources/qml/TimelineRow.qml
index 4917e893..2c2ed02a 100644
--- a/resources/qml/TimelineRow.qml
+++ b/resources/qml/TimelineRow.qml
@@ -97,7 +97,7 @@ RowLayout {
 			MenuItem {
 				visible: model.type == MtxEvent.ImageMessage || model.type == MtxEvent.VideoMessage || model.type == MtxEvent.AudioMessage || model.type == MtxEvent.FileMessage || model.type == MtxEvent.Sticker
 				text: qsTr("Save as")
-				onTriggered: timelineManager.saveMedia(model.url, model.filename, model.mimetype, model.type)
+				onTriggered: timelineManager.timeline.saveMedia(model.id)
 			}
 		}
 	}
diff --git a/resources/qml/delegates/FileMessage.qml b/resources/qml/delegates/FileMessage.qml
index f4cf3f15..2c911c5e 100644
--- a/resources/qml/delegates/FileMessage.qml
+++ b/resources/qml/delegates/FileMessage.qml
@@ -31,7 +31,7 @@ Rectangle {
 			}
 			MouseArea {
 				anchors.fill: parent
-				onClicked: timelineManager.saveMedia(model.url, model.filename, model.mimetype, model.type)
+				onClicked: timelineManager.timeline.saveMedia(model.id)
 				cursorShape: Qt.PointingHandCursor
 			}
 		}
diff --git a/resources/qml/delegates/ImageMessage.qml b/resources/qml/delegates/ImageMessage.qml
index a1a06012..1b6e5729 100644
--- a/resources/qml/delegates/ImageMessage.qml
+++ b/resources/qml/delegates/ImageMessage.qml
@@ -17,7 +17,7 @@ Item {
 		MouseArea {
 			enabled: model.type == MtxEvent.ImageMessage
 			anchors.fill: parent
-			onClicked: timelineManager.openImageOverlay(model.url, model.filename, model.mimetype, model.type)
+			onClicked: timelineManager.openImageOverlay(model.url, model.id)
 		}
 	}
 }
diff --git a/resources/qml/delegates/PlayableMediaMessage.qml b/resources/qml/delegates/PlayableMediaMessage.qml
index 3b987545..d0d4d7cb 100644
--- a/resources/qml/delegates/PlayableMediaMessage.qml
+++ b/resources/qml/delegates/PlayableMediaMessage.qml
@@ -97,7 +97,7 @@ Rectangle {
 					anchors.fill: parent
 					onClicked: {
 						switch (button.state) {
-							case "": timelineManager.cacheMedia(model.url, model.mimetype); break;
+							case "": timelineManager.timeline.cacheMedia(model.id); break;
 							case "stopped":
 							media.play(); console.log("play");
 							button.state = "playing"
@@ -118,7 +118,7 @@ Rectangle {
 				}
 
 				Connections {
-					target: timelineManager
+					target: timelineManager.timeline
 					onMediaCached: {
 						if (mxcUrl == model.url) {
 							media.source = "file://" + cacheUrl
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index b904dfd7..f606b603 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -3,11 +3,15 @@
 #include <algorithm>
 #include <type_traits>
 
+#include <QFileDialog>
+#include <QMimeDatabase>
 #include <QRegularExpression>
+#include <QStandardPaths>
 
 #include "ChatPage.h"
 #include "Logging.h"
 #include "MainWindow.h"
+#include "MxcImageProvider.h"
 #include "Olm.h"
 #include "TimelineViewManager.h"
 #include "Utils.h"
@@ -88,17 +92,42 @@ eventFormattedBody(const mtx::events::RoomEvent<T> &e)
         }
 }
 
+template<class T>
+boost::optional<mtx::crypto::EncryptedFile>
+eventEncryptionInfo(const mtx::events::Event<T> &)
+{
+        return boost::none;
+}
+
+template<class T>
+auto
+eventEncryptionInfo(const mtx::events::RoomEvent<T> &e) -> std::enable_if_t<
+  std::is_same<decltype(e.content.file), boost::optional<mtx::crypto::EncryptedFile>>::value,
+  boost::optional<mtx::crypto::EncryptedFile>>
+{
+        return e.content.file;
+}
+
 template<class T>
 QString
 eventUrl(const mtx::events::Event<T> &)
 {
         return "";
 }
+
+QString
+eventUrl(const mtx::events::StateEvent<mtx::events::state::Avatar> &e)
+{
+        return QString::fromStdString(e.content.url);
+}
+
 template<class T>
 auto
 eventUrl(const mtx::events::RoomEvent<T> &e)
   -> std::enable_if_t<std::is_same<decltype(e.content.url), std::string>::value, QString>
 {
+        if (e.content.file)
+                return QString::fromStdString(e.content.file->url);
         return QString::fromStdString(e.content.url);
 }
 
@@ -1342,3 +1371,158 @@ TimelineModel::addPendingMessage(mtx::events::collections::TimelineEvents event)
         if (!isProcessingPending)
                 emit nextPendingMessage();
 }
+
+void
+TimelineModel::saveMedia(QString eventId) const
+{
+        mtx::events::collections::TimelineEvents event = events.value(eventId);
+
+        if (auto e = boost::get<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(&event)) {
+                event = decryptEvent(*e).event;
+        }
+
+        QString mxcUrl =
+          boost::apply_visitor([](const auto &e) -> QString { return eventUrl(e); }, event);
+        QString originalFilename =
+          boost::apply_visitor([](const auto &e) -> QString { return eventFilename(e); }, event);
+        QString mimeType =
+          boost::apply_visitor([](const auto &e) -> QString { return eventMimeType(e); }, event);
+
+        using EncF = boost::optional<mtx::crypto::EncryptedFile>;
+        EncF encryptionInfo =
+          boost::apply_visitor([](const auto &e) -> EncF { return eventEncryptionInfo(e); }, event);
+
+        qml_mtx_events::EventType eventType = boost::apply_visitor(
+          [](const auto &e) -> qml_mtx_events::EventType { return toRoomEventType(e); }, event);
+
+        QString dialogTitle;
+        if (eventType == qml_mtx_events::EventType::ImageMessage) {
+                dialogTitle = tr("Save image");
+        } else if (eventType == qml_mtx_events::EventType::VideoMessage) {
+                dialogTitle = tr("Save video");
+        } else if (eventType == qml_mtx_events::EventType::AudioMessage) {
+                dialogTitle = tr("Save audio");
+        } else {
+                dialogTitle = tr("Save file");
+        }
+
+        QString filterString = QMimeDatabase().mimeTypeForName(mimeType).filterString();
+
+        auto filename = QFileDialog::getSaveFileName(
+          manager_->getWidget(), dialogTitle, originalFilename, filterString);
+
+        if (filename.isEmpty())
+                return;
+
+        const auto url = mxcUrl.toStdString();
+
+        http::client()->download(
+          url,
+          [filename, url, encryptionInfo](const std::string &data,
+                                          const std::string &,
+                                          const std::string &,
+                                          mtx::http::RequestErr err) {
+                  if (err) {
+                          nhlog::net()->warn("failed to retrieve image {}: {} {}",
+                                             url,
+                                             err->matrix_error.error,
+                                             static_cast<int>(err->status_code));
+                          return;
+                  }
+
+                  try {
+                          auto temp = data;
+                          if (encryptionInfo)
+                                  temp = mtx::crypto::to_string(
+                                    mtx::crypto::decrypt_file(temp, encryptionInfo.value()));
+
+                          QFile file(filename);
+
+                          if (!file.open(QIODevice::WriteOnly))
+                                  return;
+
+                          file.write(QByteArray(temp.data(), (int)temp.size()));
+                          file.close();
+                  } catch (const std::exception &e) {
+                          nhlog::ui()->warn("Error while saving file to: {}", e.what());
+                  }
+          });
+}
+
+void
+TimelineModel::cacheMedia(QString eventId)
+{
+        mtx::events::collections::TimelineEvents event = events.value(eventId);
+
+        if (auto e = boost::get<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(&event)) {
+                event = decryptEvent(*e).event;
+        }
+
+        QString mxcUrl =
+          boost::apply_visitor([](const auto &e) -> QString { return eventUrl(e); }, event);
+        QString mimeType =
+          boost::apply_visitor([](const auto &e) -> QString { return eventMimeType(e); }, event);
+
+        using EncF = boost::optional<mtx::crypto::EncryptedFile>;
+        EncF encryptionInfo =
+          boost::apply_visitor([](const auto &e) -> EncF { return eventEncryptionInfo(e); }, event);
+
+        // If the message is a link to a non mxcUrl, don't download it
+        if (!mxcUrl.startsWith("mxc://")) {
+                emit mediaCached(mxcUrl, mxcUrl);
+                return;
+        }
+
+        QString suffix = QMimeDatabase().mimeTypeForName(mimeType).preferredSuffix();
+
+        const auto url = mxcUrl.toStdString();
+        QFileInfo filename(QString("%1/media_cache/%2.%3")
+                             .arg(QStandardPaths::writableLocation(QStandardPaths::CacheLocation))
+                             .arg(QString(mxcUrl).remove("mxc://"))
+                             .arg(suffix));
+        if (QDir::cleanPath(filename.path()) != filename.path()) {
+                nhlog::net()->warn("mxcUrl '{}' is not safe, not downloading file", url);
+                return;
+        }
+
+        QDir().mkpath(filename.path());
+
+        if (filename.isReadable()) {
+                emit mediaCached(mxcUrl, filename.filePath());
+                return;
+        }
+
+        http::client()->download(
+          url,
+          [this, mxcUrl, filename, url, encryptionInfo](const std::string &data,
+                                                        const std::string &,
+                                                        const std::string &,
+                                                        mtx::http::RequestErr err) {
+                  if (err) {
+                          nhlog::net()->warn("failed to retrieve image {}: {} {}",
+                                             url,
+                                             err->matrix_error.error,
+                                             static_cast<int>(err->status_code));
+                          return;
+                  }
+
+                  try {
+                          auto temp = data;
+                          if (encryptionInfo)
+                                  temp = mtx::crypto::to_string(
+                                    mtx::crypto::decrypt_file(temp, encryptionInfo.value()));
+
+                          QFile file(filename.filePath());
+
+                          if (!file.open(QIODevice::WriteOnly))
+                                  return;
+
+                          file.write(QByteArray(temp.data(), temp.size()));
+                          file.close();
+                  } catch (const std::exception &e) {
+                          nhlog::ui()->warn("Error while saving file to: {}", e.what());
+                  }
+
+                  emit mediaCached(mxcUrl, filename.filePath());
+          });
+}
diff --git a/src/timeline/TimelineModel.h b/src/timeline/TimelineModel.h
index e7842b99..f52091e6 100644
--- a/src/timeline/TimelineModel.h
+++ b/src/timeline/TimelineModel.h
@@ -159,6 +159,8 @@ public:
         Q_INVOKABLE void redactEvent(QString id);
         Q_INVOKABLE int idToIndex(QString id) const;
         Q_INVOKABLE QString indexToId(int index) const;
+        Q_INVOKABLE void cacheMedia(QString eventId);
+        Q_INVOKABLE void saveMedia(QString eventId) const;
 
         void addEvents(const mtx::responses::Timeline &events);
         template<class T>
@@ -185,6 +187,7 @@ signals:
         void eventRedacted(QString id);
         void nextPendingMessage();
         void newMessageToSend(mtx::events::collections::TimelineEvents event);
+        void mediaCached(QString mxcUrl, QString cacheUrl);
 
 private:
         DecryptionResult decryptEvent(
diff --git a/src/timeline/TimelineViewManager.cpp b/src/timeline/TimelineViewManager.cpp
index 2a88c882..6430a426 100644
--- a/src/timeline/TimelineViewManager.cpp
+++ b/src/timeline/TimelineViewManager.cpp
@@ -1,11 +1,8 @@
 #include "TimelineViewManager.h"
 
-#include <QFileDialog>
 #include <QMetaType>
-#include <QMimeDatabase>
 #include <QPalette>
 #include <QQmlContext>
-#include <QStandardPaths>
 
 #include "ChatPage.h"
 #include "ColorImageProvider.h"
@@ -124,146 +121,24 @@ TimelineViewManager::setHistoryView(const QString &room_id)
 }
 
 void
-TimelineViewManager::openImageOverlay(QString mxcUrl,
-                                      QString originalFilename,
-                                      QString mimeType,
-                                      qml_mtx_events::EventType eventType) const
+TimelineViewManager::openImageOverlay(QString mxcUrl, QString eventId) const
 {
         QQuickImageResponse *imgResponse =
           imgProvider->requestImageResponse(mxcUrl.remove("mxc://"), QSize());
-        connect(imgResponse,
-                &QQuickImageResponse::finished,
-                this,
-                [this, mxcUrl, originalFilename, mimeType, eventType, imgResponse]() {
-                        if (!imgResponse->errorString().isEmpty()) {
-                                nhlog::ui()->error("Error when retrieving image for overlay: {}",
-                                                   imgResponse->errorString().toStdString());
-                                return;
-                        }
-                        auto pixmap = QPixmap::fromImage(imgResponse->textureFactory()->image());
-
-                        auto imgDialog = new dialogs::ImageOverlay(pixmap);
-                        imgDialog->show();
-                        connect(imgDialog,
-                                &dialogs::ImageOverlay::saving,
-                                this,
-                                [this, mxcUrl, originalFilename, mimeType, eventType]() {
-                                        saveMedia(mxcUrl, originalFilename, mimeType, eventType);
-                                });
-                });
-}
-
-void
-TimelineViewManager::saveMedia(QString mxcUrl,
-                               QString originalFilename,
-                               QString mimeType,
-                               qml_mtx_events::EventType eventType) const
-{
-        QString dialogTitle;
-        if (eventType == qml_mtx_events::EventType::ImageMessage) {
-                dialogTitle = tr("Save image");
-        } else if (eventType == qml_mtx_events::EventType::VideoMessage) {
-                dialogTitle = tr("Save video");
-        } else if (eventType == qml_mtx_events::EventType::AudioMessage) {
-                dialogTitle = tr("Save audio");
-        } else {
-                dialogTitle = tr("Save file");
-        }
-
-        QString filterString = QMimeDatabase().mimeTypeForName(mimeType).filterString();
-
-        auto filename =
-          QFileDialog::getSaveFileName(container, dialogTitle, originalFilename, filterString);
-
-        if (filename.isEmpty())
-                return;
-
-        const auto url = mxcUrl.toStdString();
-
-        http::client()->download(
-          url,
-          [filename, url](const std::string &data,
-                          const std::string &,
-                          const std::string &,
-                          mtx::http::RequestErr err) {
-                  if (err) {
-                          nhlog::net()->warn("failed to retrieve image {}: {} {}",
-                                             url,
-                                             err->matrix_error.error,
-                                             static_cast<int>(err->status_code));
-                          return;
-                  }
-
-                  try {
-                          QFile file(filename);
-
-                          if (!file.open(QIODevice::WriteOnly))
-                                  return;
-
-                          file.write(QByteArray(data.data(), (int)data.size()));
-                          file.close();
-                  } catch (const std::exception &e) {
-                          nhlog::ui()->warn("Error while saving file to: {}", e.what());
-                  }
-          });
-}
-
-void
-TimelineViewManager::cacheMedia(QString mxcUrl, QString mimeType)
-{
-        // If the message is a link to a non mxcUrl, don't download it
-        if (!mxcUrl.startsWith("mxc://")) {
-                emit mediaCached(mxcUrl, mxcUrl);
-                return;
-        }
-
-        QString suffix = QMimeDatabase().mimeTypeForName(mimeType).preferredSuffix();
-
-        const auto url = mxcUrl.toStdString();
-        QFileInfo filename(QString("%1/media_cache/%2.%3")
-                             .arg(QStandardPaths::writableLocation(QStandardPaths::CacheLocation))
-                             .arg(QString(mxcUrl).remove("mxc://"))
-                             .arg(suffix));
-        if (QDir::cleanPath(filename.path()) != filename.path()) {
-                nhlog::net()->warn("mxcUrl '{}' is not safe, not downloading file", url);
-                return;
-        }
-
-        QDir().mkpath(filename.path());
-
-        if (filename.isReadable()) {
-                emit mediaCached(mxcUrl, filename.filePath());
-                return;
-        }
+        connect(imgResponse, &QQuickImageResponse::finished, this, [this, eventId, imgResponse]() {
+                if (!imgResponse->errorString().isEmpty()) {
+                        nhlog::ui()->error("Error when retrieving image for overlay: {}",
+                                           imgResponse->errorString().toStdString());
+                        return;
+                }
+                auto pixmap = QPixmap::fromImage(imgResponse->textureFactory()->image());
 
-        http::client()->download(
-          url,
-          [this, mxcUrl, filename, url](const std::string &data,
-                                        const std::string &,
-                                        const std::string &,
-                                        mtx::http::RequestErr err) {
-                  if (err) {
-                          nhlog::net()->warn("failed to retrieve image {}: {} {}",
-                                             url,
-                                             err->matrix_error.error,
-                                             static_cast<int>(err->status_code));
-                          return;
-                  }
-
-                  try {
-                          QFile file(filename.filePath());
-
-                          if (!file.open(QIODevice::WriteOnly))
-                                  return;
-
-                          file.write(QByteArray(data.data(), data.size()));
-                          file.close();
-                  } catch (const std::exception &e) {
-                          nhlog::ui()->warn("Error while saving file to: {}", e.what());
-                  }
-
-                  emit mediaCached(mxcUrl, filename.filePath());
-          });
+                auto imgDialog = new dialogs::ImageOverlay(pixmap);
+                imgDialog->show();
+                connect(imgDialog, &dialogs::ImageOverlay::saving, timeline_, [this, eventId]() {
+                        timeline_->saveMedia(eventId);
+                });
+        });
 }
 
 void
@@ -401,3 +276,4 @@ TimelineViewManager::queueVideoMessage(const QString &roomid,
         video.url           = url.toStdString();
         models.value(roomid)->sendMessage(video);
 }
+
diff --git a/src/timeline/TimelineViewManager.h b/src/timeline/TimelineViewManager.h
index 0bc58e68..1cb0de44 100644
--- a/src/timeline/TimelineViewManager.h
+++ b/src/timeline/TimelineViewManager.h
@@ -35,38 +35,13 @@ public:
 
         Q_INVOKABLE TimelineModel *activeTimeline() const { return timeline_; }
         Q_INVOKABLE bool isInitialSync() const { return isInitialSync_; }
-        void openImageOverlay(QString mxcUrl,
-                              QString originalFilename,
-                              QString mimeType,
-                              qml_mtx_events::EventType eventType) const;
-        void saveMedia(QString mxcUrl,
-                       QString originalFilename,
-                       QString mimeType,
-                       qml_mtx_events::EventType eventType) const;
-        Q_INVOKABLE void cacheMedia(QString mxcUrl, QString mimeType);
-        // Qml can only pass enum as int
-        Q_INVOKABLE void openImageOverlay(QString mxcUrl,
-                                          QString originalFilename,
-                                          QString mimeType,
-                                          int eventType) const
-        {
-                openImageOverlay(
-                  mxcUrl, originalFilename, mimeType, (qml_mtx_events::EventType)eventType);
-        }
-        Q_INVOKABLE void saveMedia(QString mxcUrl,
-                                   QString originalFilename,
-                                   QString mimeType,
-                                   int eventType) const
-        {
-                saveMedia(mxcUrl, originalFilename, mimeType, (qml_mtx_events::EventType)eventType);
-        }
+        Q_INVOKABLE void openImageOverlay(QString mxcUrl, QString eventId) const;
 
 signals:
         void clearRoomMessageCount(QString roomid);
         void updateRoomsLastMessage(QString roomid, const DescInfo &info);
         void activeTimelineChanged(TimelineModel *timeline);
         void initialSyncChanged(bool isInitialSync);
-        void mediaCached(QString mxcUrl, QString cacheUrl);
 
 public slots:
         void updateReadReceipts(const QString &room_id, const std::vector<QString> &event_ids);
-- 
cgit 1.5.1


From 5bfdaff7780bc4299c3edab85c688eebf21f7d4e Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Tue, 3 Dec 2019 23:34:16 +0100
Subject: Implement decryption of images

It is a bit of a hack, but it works...
---
 CMakeLists.txt                       |  1 +
 src/MxcImageProvider.cpp             |  9 +++++++--
 src/MxcImageProvider.h               | 30 ++++++++++++++++++++++++++----
 src/timeline/TimelineModel.cpp       | 13 +++++++++++++
 src/timeline/TimelineModel.h         |  2 ++
 src/timeline/TimelineViewManager.cpp | 11 ++++++++---
 6 files changed, 57 insertions(+), 9 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/CMakeLists.txt b/CMakeLists.txt
index c918d834..67a1dfb0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -365,6 +365,7 @@ qt5_wrap_cpp(MOC_HEADERS
     src/CommunitiesList.h
     src/LoginPage.h
     src/MainWindow.h
+    src/MxcImageProvider.h
     src/InviteeItem.h
     src/QuickSwitcher.h
     src/RegisterPage.h
diff --git a/src/MxcImageProvider.cpp b/src/MxcImageProvider.cpp
index 556b019b..edf6ceb5 100644
--- a/src/MxcImageProvider.cpp
+++ b/src/MxcImageProvider.cpp
@@ -5,7 +5,7 @@
 void
 MxcImageResponse::run()
 {
-        if (m_requestedSize.isValid()) {
+        if (m_requestedSize.isValid() && !m_encryptionInfo) {
                 QString fileName = QString("%1_%2x%3_crop")
                                      .arg(m_id)
                                      .arg(m_requestedSize.width())
@@ -65,7 +65,12 @@ MxcImageResponse::run()
                                   return;
                           }
 
-                          auto data = QByteArray(res.data(), res.size());
+                          auto temp = res;
+                          if (m_encryptionInfo)
+                                  temp = mtx::crypto::to_string(
+                                    mtx::crypto::decrypt_file(temp, m_encryptionInfo.value()));
+
+                          auto data = QByteArray(temp.data(), temp.size());
                           m_image.loadFromData(data);
                           m_image.setText("original filename",
                                           QString::fromStdString(originalFilename));
diff --git a/src/MxcImageProvider.h b/src/MxcImageProvider.h
index 19d8a74e..2c197a13 100644
--- a/src/MxcImageProvider.h
+++ b/src/MxcImageProvider.h
@@ -6,14 +6,21 @@
 #include <QImage>
 #include <QThreadPool>
 
+#include <mtx/common.hpp>
+
+#include <boost/optional.hpp>
+
 class MxcImageResponse
   : public QQuickImageResponse
   , public QRunnable
 {
 public:
-        MxcImageResponse(const QString &id, const QSize &requestedSize)
+        MxcImageResponse(const QString &id,
+                         const QSize &requestedSize,
+                         boost::optional<mtx::crypto::EncryptedFile> encryptionInfo)
           : m_id(id)
           , m_requestedSize(requestedSize)
+          , m_encryptionInfo(encryptionInfo)
         {
                 setAutoDelete(false);
         }
@@ -29,19 +36,34 @@ public:
         QString m_id, m_error;
         QSize m_requestedSize;
         QImage m_image;
+        boost::optional<mtx::crypto::EncryptedFile> m_encryptionInfo;
 };
 
-class MxcImageProvider : public QQuickAsyncImageProvider
+class MxcImageProvider
+  : public QObject
+  , public QQuickAsyncImageProvider
 {
-public:
+        Q_OBJECT
+public slots:
         QQuickImageResponse *requestImageResponse(const QString &id,
                                                   const QSize &requestedSize) override
         {
-                MxcImageResponse *response = new MxcImageResponse(id, requestedSize);
+                boost::optional<mtx::crypto::EncryptedFile> info;
+                auto temp = infos.find("mxc://" + id);
+                if (temp != infos.end())
+                        info = *temp;
+
+                MxcImageResponse *response = new MxcImageResponse(id, requestedSize, info);
                 pool.start(response);
                 return response;
         }
 
+        void addEncryptionInfo(mtx::crypto::EncryptedFile info)
+        {
+                infos.insert(QString::fromStdString(info.url), info);
+        }
+
 private:
         QThreadPool pool;
+        QHash<QString, mtx::crypto::EncryptedFile> infos;
 };
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index f606b603..2c58e2f5 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -673,6 +673,19 @@ TimelineModel::internalAddEvents(
                         continue; // don't insert redaction into timeline
                 }
 
+                if (auto event =
+                      boost::get<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(&e)) {
+                        auto temp    = decryptEvent(*event).event;
+                        auto encInfo = boost::apply_visitor(
+                          [](const auto &ev) -> boost::optional<mtx::crypto::EncryptedFile> {
+                                  return eventEncryptionInfo(ev);
+                          },
+                          temp);
+
+                        if (encInfo)
+                                emit newEncryptedImage(encInfo.value());
+                }
+
                 this->events.insert(id, e);
                 ids.push_back(id);
         }
diff --git a/src/timeline/TimelineModel.h b/src/timeline/TimelineModel.h
index f52091e6..06c64acf 100644
--- a/src/timeline/TimelineModel.h
+++ b/src/timeline/TimelineModel.h
@@ -6,6 +6,7 @@
 #include <QHash>
 #include <QSet>
 
+#include <mtx/common.hpp>
 #include <mtx/responses.hpp>
 
 #include "Cache.h"
@@ -188,6 +189,7 @@ signals:
         void nextPendingMessage();
         void newMessageToSend(mtx::events::collections::TimelineEvents event);
         void mediaCached(QString mxcUrl, QString cacheUrl);
+        void newEncryptedImage(mtx::crypto::EncryptedFile encryptionInfo);
 
 private:
         DecryptionResult decryptEvent(
diff --git a/src/timeline/TimelineViewManager.cpp b/src/timeline/TimelineViewManager.cpp
index c44bcbbf..25f72a6d 100644
--- a/src/timeline/TimelineViewManager.cpp
+++ b/src/timeline/TimelineViewManager.cpp
@@ -102,9 +102,14 @@ TimelineViewManager::sync(const mtx::responses::Rooms &rooms)
 void
 TimelineViewManager::addRoom(const QString &room_id)
 {
-        if (!models.contains(room_id))
-                models.insert(room_id,
-                              QSharedPointer<TimelineModel>(new TimelineModel(this, room_id)));
+        if (!models.contains(room_id)) {
+                QSharedPointer<TimelineModel> newRoom(new TimelineModel(this, room_id));
+                connect(newRoom.data(),
+                        &TimelineModel::newEncryptedImage,
+                        imgProvider,
+                        &MxcImageProvider::addEncryptionInfo);
+                models.insert(room_id, std::move(newRoom));
+        }
 }
 
 void
-- 
cgit 1.5.1


From 362efbf5b9ca4d3162d4fc7035959ce1da9f1c94 Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Fri, 6 Dec 2019 02:56:53 +0100
Subject: Restore linkification of messages

---
 src/timeline/TimelineModel.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 2c58e2f5..e3d87ae6 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -505,8 +505,8 @@ TimelineModel::data(const QModelIndex &index, int role) const
         case FormattedBody:
                 return QVariant(
                   utils::replaceEmoji(
-                    boost::apply_visitor(
-                      [](const auto &e) -> QString { return eventFormattedBody(e); }, event))
+                    utils::linkifyMessage(boost::apply_visitor(
+                      [](const auto &e) -> QString { return eventFormattedBody(e); }, event)))
                     .remove("<mx-reply>")
                     .remove("</mx-reply>"));
         case Url:
-- 
cgit 1.5.1


From e98a61fea60cf3b95441ce3d9591ced0cf93f566 Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Tue, 10 Dec 2019 14:46:52 +0100
Subject: Show topic and name changes in timeline

---
 resources/qml/delegates/MessageDelegate.qml | 12 +++++++++++
 resources/qml/delegates/NoticeMessage.qml   |  3 ++-
 src/timeline/TimelineModel.cpp              | 32 +++++++++++++++++++++++++++++
 src/timeline/TimelineModel.h                |  2 ++
 4 files changed, 48 insertions(+), 1 deletion(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/resources/qml/delegates/MessageDelegate.qml b/resources/qml/delegates/MessageDelegate.qml
index 178dfd86..20ec71e5 100644
--- a/resources/qml/delegates/MessageDelegate.qml
+++ b/resources/qml/delegates/MessageDelegate.qml
@@ -49,6 +49,18 @@ DelegateChooser {
 			text: qsTr("Encryption enabled")
 		}
 	}
+	DelegateChoice {
+		roleValue: MtxEvent.Name
+		NoticeMessage {
+			notice: model.roomName ? qsTr("room name changed to: %1").arg(model.roomName) : qsTr("removed room name")
+		}
+	}
+	DelegateChoice {
+		roleValue: MtxEvent.Topic
+		NoticeMessage {
+			notice: model.roomTopic ? qsTr("topic changed to: %1").arg(model.roomTopic) : qsTr("removed topic")
+		}
+	}
 	DelegateChoice {
 		Placeholder {}
 	}
diff --git a/resources/qml/delegates/NoticeMessage.qml b/resources/qml/delegates/NoticeMessage.qml
index a392eb5b..f7467eca 100644
--- a/resources/qml/delegates/NoticeMessage.qml
+++ b/resources/qml/delegates/NoticeMessage.qml
@@ -1,7 +1,8 @@
 import ".."
 
 MatrixText {
-	text: model.formattedBody
+	property string notice: model.formattedBody.replace("<pre>", "<pre style='white-space: pre-wrap'>")
+	text: notice
 	width: parent ? parent.width : undefined
 	font.italic: true
 	color: inactiveColors.text
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index e3d87ae6..9da8a194 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -59,6 +59,30 @@ eventMsgType(const mtx::events::RoomEvent<T> &e) -> decltype(e.content.msgtype)
         return e.content.msgtype;
 }
 
+template<class T>
+QString
+eventRoomName(const T &)
+{
+        return "";
+}
+QString
+eventRoomName(const mtx::events::StateEvent<mtx::events::state::Name> &e)
+{
+        return QString::fromStdString(e.content.name);
+}
+
+template<class T>
+QString
+eventRoomTopic(const T &)
+{
+        return "";
+}
+QString
+eventRoomTopic(const mtx::events::StateEvent<mtx::events::state::Topic> &e)
+{
+        return QString::fromStdString(e.content.topic);
+}
+
 template<class T>
 QString
 eventBody(const mtx::events::Event<T> &)
@@ -437,6 +461,8 @@ TimelineModel::roleNames() const
           {State, "state"},
           {IsEncrypted, "isEncrypted"},
           {ReplyTo, "replyTo"},
+          {RoomName, "roomName"},
+          {RoomTopic, "roomTopic"},
         };
 }
 int
@@ -563,6 +589,12 @@ TimelineModel::data(const QModelIndex &index, int role) const
                   [](const auto &e) -> QString { return eventRelatesTo(e); }, event);
                 return QVariant(evId);
         }
+        case RoomName:
+                return QVariant(boost::apply_visitor(
+                  [](const auto &e) -> QString { return eventRoomName(e); }, event));
+        case RoomTopic:
+                return QVariant(boost::apply_visitor(
+                  [](const auto &e) -> QString { return eventRoomTopic(e); }, event));
         default:
                 return QVariant();
         }
diff --git a/src/timeline/TimelineModel.h b/src/timeline/TimelineModel.h
index 06c64acf..05e05962 100644
--- a/src/timeline/TimelineModel.h
+++ b/src/timeline/TimelineModel.h
@@ -141,6 +141,8 @@ public:
                 State,
                 IsEncrypted,
                 ReplyTo,
+                RoomName,
+                RoomTopic,
         };
 
         QHash<int, QByteArray> roleNames() const override;
-- 
cgit 1.5.1


From 9c1912ed93cc0628c578a005f0c06bed7b88f63d Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Fri, 13 Dec 2019 01:31:14 +0100
Subject: Fix preview of sent encrypted images

---
 src/timeline/TimelineModel.cpp | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 9da8a194..e49fcf57 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -414,6 +414,7 @@ TimelineModel::TimelineModel(TimelineViewManager *manager, QString room_id, QObj
                           return eventCopy;
                   },
                   ev);
+
                 events.remove(txn_id);
                 events.insert(event_id, ev);
 
@@ -666,7 +667,7 @@ TimelineModel::internalAddEvents(
   const std::vector<mtx::events::collections::TimelineEvents> &timeline)
 {
         std::vector<QString> ids;
-        for (const auto &e : timeline) {
+        for (auto e : timeline) {
                 QString id =
                   boost::apply_visitor([](const auto &e) -> QString { return eventId(e); }, e);
 
@@ -707,16 +708,16 @@ TimelineModel::internalAddEvents(
 
                 if (auto event =
                       boost::get<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(&e)) {
-                        auto temp    = decryptEvent(*event).event;
-                        auto encInfo = boost::apply_visitor(
-                          [](const auto &ev) -> boost::optional<mtx::crypto::EncryptedFile> {
-                                  return eventEncryptionInfo(ev);
-                          },
-                          temp);
-
-                        if (encInfo)
-                                emit newEncryptedImage(encInfo.value());
+                        e = decryptEvent(*event).event;
                 }
+                auto encInfo = boost::apply_visitor(
+                  [](const auto &ev) -> boost::optional<mtx::crypto::EncryptedFile> {
+                          return eventEncryptionInfo(ev);
+                  },
+                  e);
+
+                if (encInfo)
+                        emit newEncryptedImage(encInfo.value());
 
                 this->events.insert(id, e);
                 ids.push_back(id);
-- 
cgit 1.5.1


From 659e36b113158ba9870e201dab7098888bf9d275 Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Sat, 14 Dec 2019 17:08:36 +0100
Subject: Update to c++17

---
 .ci/install.sh                       |  33 +-------
 .ci/linux/deploy.sh                  |   2 +-
 .ci/script.sh                        |   8 --
 .travis.yml                          | 105 ++++++++++++++++-------
 CMakeLists.txt                       |  13 ++-
 deps/CMakeLists.txt                  |   4 +-
 deps/cmake/Json.cmake                |   2 +-
 src/Cache.cpp                        |  30 ++++---
 src/Cache.h                          |  85 ++++++++++---------
 src/ChatPage.cpp                     |  10 +--
 src/ChatPage.h                       |  12 +--
 src/Olm.cpp                          |   7 +-
 src/Utils.cpp                        |  67 +++++++--------
 src/Utils.h                          |  17 ++--
 src/timeline/TimelineModel.cpp       | 157 +++++++++++++++++------------------
 src/timeline/TimelineViewManager.cpp |   8 +-
 src/timeline/TimelineViewManager.h   |   8 +-
 17 files changed, 284 insertions(+), 284 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/.ci/install.sh b/.ci/install.sh
index 57e73e03..776d4d23 100755
--- a/.ci/install.sh
+++ b/.ci/install.sh
@@ -3,14 +3,6 @@
 set -ex
 
 if [ "$TRAVIS_OS_NAME" = "osx" ]; then
-    brew update
-
-    # uninstall packages, that would get upgraded by upgrading cmake (and we don't need)
-    brew uninstall --force cgal node sfcgal postgis
-
-    brew install qt5 lmdb clang-format ninja libsodium cmark
-    brew upgrade boost cmake icu4c || true
-
     brew tap nlohmann/json
     brew install --with-cmake nlohmann_json
 
@@ -25,11 +17,11 @@ fi
 
 
 if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+    sudo update-alternatives --install /usr/bin/gcc gcc "/usr/bin/${CC}" 10
+    sudo update-alternatives --install /usr/bin/g++ g++ "/usr/bin/${CXX}" 10
 
-    if [ -z "$QT_VERSION" ]; then
-        QT_VERSION="592"
-        QT_PKG="59"
-    fi
+    sudo update-alternatives --set gcc "/usr/bin/${CC}"
+    sudo update-alternatives --set g++ "/usr/bin/${CXX}"
 
     wget https://cmake.org/files/v3.15/cmake-3.15.5-Linux-x86_64.sh
     sudo sh cmake-3.15.5-Linux-x86_64.sh  --skip-license  --prefix=/usr/local
@@ -40,21 +32,4 @@ if [ "$TRAVIS_OS_NAME" = "linux" ]; then
       tar xfz libsodium-1.0.17.tar.gz
       cd libsodium-1.0.17/
       ./configure && make && sudo make install )
-
-    sudo add-apt-repository -y ppa:beineri/opt-qt${QT_VERSION}-trusty
-    # needed for git-lfs, otherwise the follow apt update fails.
-    sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 6B05F25D762E3157
-
-    # needed for mongodb repository: https://github.com/travis-ci/travis-ci/issues/9037
-    sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 0C49F3730359A14518585931BC711F9BA15703C6
-
-    sudo apt update -qq
-    sudo apt install -qq -y \
-        qt${QT_PKG}base \
-        qt${QT_PKG}tools \
-        qt${QT_PKG}svg \
-        qt${QT_PKG}multimedia \
-        qt${QT_PKG}quickcontrols2 \
-        qt${QT_PKG}graphicaleffects \
-        liblmdb-dev
 fi
diff --git a/.ci/linux/deploy.sh b/.ci/linux/deploy.sh
index 524d72d5..ff8ef6ca 100755
--- a/.ci/linux/deploy.sh
+++ b/.ci/linux/deploy.sh
@@ -36,7 +36,7 @@ unset LD_LIBRARY_PATH
 
 ARCH=$(uname -m)
 export ARCH
-LD_LIBRARY_PATH=$(pwd)/.deps/usr/lib/:$LD_LIBRARY_PATH
+LD_LIBRARY_PATH=$(pwd)/.deps/usr/lib/:/usr/local/lib/:$LD_LIBRARY_PATH
 export LD_LIBRARY_PATH
 
 for res in ./linuxdeployqt*.AppImage
diff --git a/.ci/script.sh b/.ci/script.sh
index 06536278..7e9a8d81 100755
--- a/.ci/script.sh
+++ b/.ci/script.sh
@@ -3,17 +3,9 @@
 set -ex
 
 if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-    export CC=${C_COMPILER}
-    export CXX=${CXX_COMPILER}
     # make build use all available cores
     export CMAKE_BUILD_PARALLEL_LEVEL=$(cat /proc/cpuinfo | awk '/^processor/{print $3}' | wc -l)
 
-    sudo update-alternatives --install /usr/bin/gcc gcc "/usr/bin/${C_COMPILER}" 10
-    sudo update-alternatives --install /usr/bin/g++ g++ "/usr/bin/${CXX_COMPILER}" 10
-
-    sudo update-alternatives --set gcc "/usr/bin/${C_COMPILER}"
-    sudo update-alternatives --set g++ "/usr/bin/${CXX_COMPILER}"
-
     export PATH="/usr/local/bin/:${PATH}"
     cmake --version
 fi
diff --git a/.travis.yml b/.travis.yml
index 3abb8bfd..1e2bc5b8 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,6 +1,6 @@
 language: cpp
 sudo: required
-dist: trusty
+dist: xenial
 
 notifications:
   webhooks:
@@ -19,61 +19,108 @@ matrix:
     include:
         - os: osx
           compiler: clang
-          # Use the default osx image, because that one is actually tested to work with homebrew and probably the oldest supported version
-          #          osx_image: xcode9
+          # C++17 support
+          osx_image: xcode10.2
           env:
-              - DEPLOYMENT=1
-              - USE_BUNDLED_BOOST=0
-              - USE_BUNDLED_CMARK=0
-              - USE_BUNDLED_JSON=0
-              - MTX_STATIC=1
+            - DEPLOYMENT=1
+            - USE_BUNDLED_BOOST=0
+            - USE_BUNDLED_CMARK=0
+            - USE_BUNDLED_JSON=0
+            - MTX_STATIC=1
+          addons:
+            homebrew:
+              taps: nlohmann/json
+              packages:
+                - boost
+                - clang-format
+                - cmake
+                - cmark
+                - icu4c
+                - libsodium
+                - lmdb
+                - ninja
+                - openssl
+                - qt5
         - os: linux
-          compiler: gcc
+          compiler: gcc-7
           env:
-              - CXX_COMPILER=g++-5
-              - C_COMPILER=gcc-5
-              - QT_VERSION="-5.10.1"
-              - QT_PKG=510
+              - CXX=g++-7
+              - CC=gcc-7
+              - QT_PKG=512
               - DEPLOYMENT=1
               - USE_BUNDLED_BOOST=1
               - USE_BUNDLED_CMARK=1
               - USE_BUNDLED_JSON=1
           addons:
               apt:
-                  sources: ["ubuntu-toolchain-r-test"]
-                  packages: ["g++-5", "ninja-build"]
+                  sources: 
+                    - ubuntu-toolchain-r-test
+                    - sourceline: 'ppa:beineri/opt-qt-5.12.6-xenial'
+                  packages: 
+                    - g++-7 
+                    - ninja-build
+                    - qt512base
+                    - qt512tools
+                    - qt512svg
+                    - qt512multimedia
+                    - qt512quickcontrols2
+                    - qt512graphicaleffects
+                    - liblmdb-dev
+                    - libgl1-mesa-dev # needed for missing gl.h
         - os: linux
-          compiler: gcc
+          compiler: gcc-8
           env:
-              - CXX_COMPILER=g++-8
-              - C_COMPILER=gcc-8
-              - QT_VERSION=592
+              - CXX=g++-8
+              - CC=gcc-8
               - QT_PKG=59
               - USE_BUNDLED_BOOST=1
               - USE_BUNDLED_CMARK=1
               - USE_BUNDLED_JSON=1
           addons:
               apt:
-                  sources: ["ubuntu-toolchain-r-test"]
-                  packages: ["g++-8", "ninja-build"]
+                  sources: 
+                    - ubuntu-toolchain-r-test
+                    - sourceline: 'ppa:beineri/opt-qt597-xenial'
+                  packages: 
+                    - g++-8 
+                    - ninja-build
+                    - qt59base
+                    - qt59tools
+                    - qt59svg
+                    - qt59multimedia
+                    - qt59quickcontrols2
+                    - qt59graphicaleffects
+                    - liblmdb-dev
+                    - libgl1-mesa-dev # needed for missing gl.h
         - os: linux
-          compiler: clang
+          compiler: clang-6
           env:
-              - CXX_COMPILER=clang++-5.0
-              - C_COMPILER=clang-5.0
-              - QT_VERSION=592
+              - CXX=clang++-6.0
+              - CC=clang-6.0
               - QT_PKG=59
               - USE_BUNDLED_BOOST=1
               - USE_BUNDLED_CMARK=1
               - USE_BUNDLED_JSON=1
           addons:
               apt:
-                  sources: ["ubuntu-toolchain-r-test", "llvm-toolchain-trusty-5.0"]
-                  packages: ["clang-5.0", "g++-7", "ninja-build"]
+                  sources: 
+                    - ubuntu-toolchain-r-test
+                    - llvm-toolchain-xenial-6.0
+                    - sourceline: 'ppa:beineri/opt-qt597-xenial'
+                  packages: 
+                    - clang++-6.0
+                    - g++-7 
+                    - ninja-build
+                    - qt59base
+                    - qt59tools
+                    - qt59svg
+                    - qt59multimedia
+                    - qt59quickcontrols2
+                    - qt59graphicaleffects
+                    - liblmdb-dev
+                    - libgl1-mesa-dev # needed for missing gl.h
 
 before_install:
-    - export CXX=${CXX_COMPILER}
-    - export CC=${C_COMPILER}
     # Use TRAVIS_TAG if defined, or the short commit SHA otherwise
     - export VERSION=${TRAVIS_TAG:-$(git rev-parse --short HEAD)}
 install:
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 67a1dfb0..39dadc64 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -5,9 +5,6 @@ option(ASAN "Compile with address sanitizers" OFF)
 
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 
-add_definitions(-DBOOST_MPL_LIMIT_LIST_SIZE=30)
-add_definitions(-DBOOST_MPL_CFG_NO_PREPROCESSED_HEADERS)
-
 include(GNUInstallDirs)
 
 # Include Qt basic functions
@@ -15,8 +12,8 @@ include(QtCommon)
 
 project(nheko LANGUAGES C CXX)
 set(CPACK_PACKAGE_VERSION_MAJOR "0")
-set(CPACK_PACKAGE_VERSION_MINOR "6")
-set(CPACK_PACKAGE_VERSION_PATCH "4")
+set(CPACK_PACKAGE_VERSION_MINOR "7")
+set(CPACK_PACKAGE_VERSION_PATCH "0")
 set(PROJECT_VERSION_MAJOR ${CPACK_PACKAGE_VERSION_MAJOR})
 set(PROJECT_VERSION_MINOR ${CPACK_PACKAGE_VERSION_MINOR})
 set(PROJECT_VERSION_PATCH ${CPACK_PACKAGE_VERSION_PATCH})
@@ -27,7 +24,7 @@ fix_project_version()
 
 # Set additional project information
 set(COMPANY "Nheko")
-set(COPYRIGHT "Copyright (c) 2018 Nheko Contributors")
+set(COPYRIGHT "Copyright (c) 2019 Nheko Contributors")
 set(IDENTIFIER "com.github.mujx.nheko")
 
 add_project_meta(META_FILES_TO_INCLUDE)
@@ -91,7 +88,7 @@ if (NOT MSVC)
     set(CMAKE_C_COMPILER gcc)
 endif(NOT MSVC)
 
-set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 if(NOT MSVC)
@@ -106,7 +103,7 @@ if(NOT MSVC)
         -fsized-deallocation \
         -fdiagnostics-color=always \
         -Wunreachable-code \
-	-std=c++14"
+	-std=c++17"
     )
     if (NOT CMAKE_COMPILER_IS_GNUCXX)
         # -Wshadow is buggy and broken in GCC, so do not enable it.
diff --git a/deps/CMakeLists.txt b/deps/CMakeLists.txt
index fbe9275f..cf42b7b5 100644
--- a/deps/CMakeLists.txt
+++ b/deps/CMakeLists.txt
@@ -46,10 +46,10 @@ set(BOOST_SHA256
 
 set(
   MTXCLIENT_URL
-  https://github.com/Nheko-Reborn/mtxclient/archive/1945952864ef87a6afeb57b0beb80756d0647381.zip
+  https://github.com/Nheko-Reborn/mtxclient/archive/fd5208d85ecc9e077fe0fde5424ba225849cccf7.zip
   )
 set(MTXCLIENT_HASH
-    727cd145c0c1e9c168aaeded3b7cc9801c63b4da5e8cd0a4782982d08770816e)
+    24ef9d5562ed6d83d6c28f6c8de559487029f3bdc35d9fe8e5799283ff999513)
 set(
   TWEENY_URL
   https://github.com/mobius3/tweeny/archive/b94ce07cfb02a0eb8ac8aaf66137dabdaea857cf.tar.gz
diff --git a/deps/cmake/Json.cmake b/deps/cmake/Json.cmake
index 3b63550e..c5e66cea 100644
--- a/deps/cmake/Json.cmake
+++ b/deps/cmake/Json.cmake
@@ -13,7 +13,7 @@ ExternalProject_Add(
         -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
 
   BUILD_COMMAND ${CMAKE_COMMAND} --build ${DEPS_BUILD_DIR}/json 
-  INSTALL_COMMAND make install
+  INSTALL_COMMAND ${CMAKE_COMMAND} --build ${DEPS_BUILD_DIR}/json --target install
 )
 
 list(APPEND THIRD_PARTY_DEPS Json)
diff --git a/src/Cache.cpp b/src/Cache.cpp
index 083dbe89..d3aec9db 100644
--- a/src/Cache.cpp
+++ b/src/Cache.cpp
@@ -17,6 +17,7 @@
 
 #include <limits>
 #include <stdexcept>
+#include <variant>
 
 #include <QByteArray>
 #include <QCoreApplication>
@@ -26,7 +27,6 @@
 #include <QSettings>
 #include <QStandardPaths>
 
-#include <boost/variant.hpp>
 #include <mtx/responses/common.hpp>
 
 #include "Cache.h"
@@ -395,7 +395,7 @@ Cache::saveOlmSession(const std::string &curve25519, mtx::crypto::OlmSessionPtr
         txn.commit();
 }
 
-boost::optional<mtx::crypto::OlmSessionPtr>
+std::optional<mtx::crypto::OlmSessionPtr>
 Cache::getOlmSession(const std::string &curve25519, const std::string &session_id)
 {
         using namespace mtx::crypto;
@@ -413,7 +413,7 @@ Cache::getOlmSession(const std::string &curve25519, const std::string &session_i
                 return unpickle<SessionObject>(data, SECRET);
         }
 
-        return boost::none;
+        return std::nullopt;
 }
 
 std::vector<std::string>
@@ -967,8 +967,8 @@ Cache::saveState(const mtx::responses::Sync &res)
                 bool has_new_tags = false;
                 for (const auto &evt : room.second.account_data.events) {
                         // for now only fetch tag events
-                        if (evt.type() == typeid(Event<account_data::Tag>)) {
-                                auto tags_evt = boost::get<Event<account_data::Tag>>(evt);
+                        if (std::holds_alternative<Event<account_data::Tag>>(evt)) {
+                                auto tags_evt = std::get<Event<account_data::Tag>>(evt);
                                 has_new_tags  = true;
                                 for (const auto &tag : tags_evt.content.tags) {
                                         updatedInfo.tags.push_back(tag.first);
@@ -1049,19 +1049,17 @@ Cache::saveInvite(lmdb::txn &txn,
         using namespace mtx::events::state;
 
         for (const auto &e : room.invite_state) {
-                if (boost::get<StrippedEvent<Member>>(&e) != nullptr) {
-                        auto msg = boost::get<StrippedEvent<Member>>(e);
+                if (auto msg = std::get_if<StrippedEvent<Member>>(&e)) {
+                        auto display_name = msg->content.display_name.empty()
+                                              ? msg->state_key
+                                              : msg->content.display_name;
 
-                        auto display_name = msg.content.display_name.empty()
-                                              ? msg.state_key
-                                              : msg.content.display_name;
-
-                        MemberInfo tmp{display_name, msg.content.avatar_url};
+                        MemberInfo tmp{display_name, msg->content.avatar_url};
 
                         lmdb::dbi_put(
-                          txn, membersdb, lmdb::val(msg.state_key), lmdb::val(json(tmp).dump()));
+                          txn, membersdb, lmdb::val(msg->state_key), lmdb::val(json(tmp).dump()));
                 } else {
-                        boost::apply_visitor(
+                        std::visit(
                           [&txn, &statesdb](auto msg) {
                                   bool res = lmdb::dbi_put(txn,
                                                            statesdb,
@@ -1122,7 +1120,7 @@ Cache::roomsWithTagUpdates(const mtx::responses::Sync &res)
         for (const auto &room : res.rooms.join) {
                 bool hasUpdates = false;
                 for (const auto &evt : room.second.account_data.events) {
-                        if (evt.type() == typeid(Event<account_data::Tag>)) {
+                        if (std::holds_alternative<Event<account_data::Tag>>(evt)) {
                                 hasUpdates = true;
                         }
                 }
@@ -1940,7 +1938,7 @@ Cache::saveTimelineMessages(lmdb::txn &txn,
                 if (isStateEvent(e))
                         continue;
 
-                if (boost::get<RedactionEvent<msg::Redaction>>(&e) != nullptr)
+                if (std::holds_alternative<RedactionEvent<msg::Redaction>>(e))
                         continue;
 
                 json obj = json::object();
diff --git a/src/Cache.h b/src/Cache.h
index f5e1cfa0..878ac9ce 100644
--- a/src/Cache.h
+++ b/src/Cache.h
@@ -17,7 +17,8 @@
 
 #pragma once
 
-#include <boost/optional.hpp>
+#include <mutex>
+#include <optional>
 
 #include <QDateTime>
 #include <QDir>
@@ -25,11 +26,11 @@
 #include <QString>
 
 #include <lmdb++.h>
+#include <nlohmann/json.hpp>
+
 #include <mtx/events/join_rules.hpp>
 #include <mtx/responses.hpp>
 #include <mtxclient/crypto/client.hpp>
-#include <mutex>
-#include <nlohmann/json.hpp>
 
 #include "Logging.h"
 #include "MatrixClient.h"
@@ -453,8 +454,8 @@ public:
         //
         void saveOlmSession(const std::string &curve25519, mtx::crypto::OlmSessionPtr session);
         std::vector<std::string> getOlmSessions(const std::string &curve25519);
-        boost::optional<mtx::crypto::OlmSessionPtr> getOlmSession(const std::string &curve25519,
-                                                                  const std::string &session_id);
+        std::optional<mtx::crypto::OlmSessionPtr> getOlmSession(const std::string &curve25519,
+                                                                const std::string &session_id);
 
         void saveOlmAccount(const std::string &pickled);
         std::string restoreOlmAccount();
@@ -517,52 +518,50 @@ private:
                 using namespace mtx::events;
                 using namespace mtx::events::state;
 
-                if (boost::get<StateEvent<Member>>(&event) != nullptr) {
-                        const auto e = boost::get<StateEvent<Member>>(event);
-
-                        switch (e.content.membership) {
+                if (auto e = std::get_if<StateEvent<Member>>(&event); e != nullptr) {
+                        switch (e->content.membership) {
                         //
                         // We only keep users with invite or join membership.
                         //
                         case Membership::Invite:
                         case Membership::Join: {
-                                auto display_name = e.content.display_name.empty()
-                                                      ? e.state_key
-                                                      : e.content.display_name;
+                                auto display_name = e->content.display_name.empty()
+                                                      ? e->state_key
+                                                      : e->content.display_name;
 
                                 // Lightweight representation of a member.
-                                MemberInfo tmp{display_name, e.content.avatar_url};
+                                MemberInfo tmp{display_name, e->content.avatar_url};
 
                                 lmdb::dbi_put(txn,
                                               membersdb,
-                                              lmdb::val(e.state_key),
+                                              lmdb::val(e->state_key),
                                               lmdb::val(json(tmp).dump()));
 
                                 insertDisplayName(QString::fromStdString(room_id),
-                                                  QString::fromStdString(e.state_key),
+                                                  QString::fromStdString(e->state_key),
                                                   QString::fromStdString(display_name));
 
                                 insertAvatarUrl(QString::fromStdString(room_id),
-                                                QString::fromStdString(e.state_key),
-                                                QString::fromStdString(e.content.avatar_url));
+                                                QString::fromStdString(e->state_key),
+                                                QString::fromStdString(e->content.avatar_url));
 
                                 break;
                         }
                         default: {
                                 lmdb::dbi_del(
-                                  txn, membersdb, lmdb::val(e.state_key), lmdb::val(""));
+                                  txn, membersdb, lmdb::val(e->state_key), lmdb::val(""));
 
                                 removeDisplayName(QString::fromStdString(room_id),
-                                                  QString::fromStdString(e.state_key));
+                                                  QString::fromStdString(e->state_key));
                                 removeAvatarUrl(QString::fromStdString(room_id),
-                                                QString::fromStdString(e.state_key));
+                                                QString::fromStdString(e->state_key));
 
                                 break;
                         }
                         }
 
                         return;
-                } else if (boost::get<StateEvent<Encryption>>(&event) != nullptr) {
+                } else if (std::holds_alternative<StateEvent<Encryption>>(event)) {
                         setEncryptedRoom(txn, room_id);
                         return;
                 }
@@ -570,7 +569,7 @@ private:
                 if (!isStateEvent(event))
                         return;
 
-                boost::apply_visitor(
+                std::visit(
                   [&txn, &statesdb](auto e) {
                           lmdb::dbi_put(
                             txn, statesdb, lmdb::val(to_string(e.type)), lmdb::val(json(e).dump()));
@@ -584,17 +583,17 @@ private:
                 using namespace mtx::events;
                 using namespace mtx::events::state;
 
-                return boost::get<StateEvent<Aliases>>(&e) != nullptr ||
-                       boost::get<StateEvent<state::Avatar>>(&e) != nullptr ||
-                       boost::get<StateEvent<CanonicalAlias>>(&e) != nullptr ||
-                       boost::get<StateEvent<Create>>(&e) != nullptr ||
-                       boost::get<StateEvent<GuestAccess>>(&e) != nullptr ||
-                       boost::get<StateEvent<HistoryVisibility>>(&e) != nullptr ||
-                       boost::get<StateEvent<JoinRules>>(&e) != nullptr ||
-                       boost::get<StateEvent<Name>>(&e) != nullptr ||
-                       boost::get<StateEvent<Member>>(&e) != nullptr ||
-                       boost::get<StateEvent<PowerLevels>>(&e) != nullptr ||
-                       boost::get<StateEvent<Topic>>(&e) != nullptr;
+                return std::holds_alternative<StateEvent<Aliases>>(e) ||
+                       std::holds_alternative<StateEvent<state::Avatar>>(e) ||
+                       std::holds_alternative<StateEvent<CanonicalAlias>>(e) ||
+                       std::holds_alternative<StateEvent<Create>>(e) ||
+                       std::holds_alternative<StateEvent<GuestAccess>>(e) ||
+                       std::holds_alternative<StateEvent<HistoryVisibility>>(e) ||
+                       std::holds_alternative<StateEvent<JoinRules>>(e) ||
+                       std::holds_alternative<StateEvent<Name>>(e) ||
+                       std::holds_alternative<StateEvent<Member>>(e) ||
+                       std::holds_alternative<StateEvent<PowerLevels>>(e) ||
+                       std::holds_alternative<StateEvent<Topic>>(e);
         }
 
         template<class T>
@@ -603,11 +602,11 @@ private:
                 using namespace mtx::events;
                 using namespace mtx::events::state;
 
-                return boost::get<StateEvent<state::Avatar>>(&e) != nullptr ||
-                       boost::get<StateEvent<CanonicalAlias>>(&e) != nullptr ||
-                       boost::get<StateEvent<Name>>(&e) != nullptr ||
-                       boost::get<StateEvent<Member>>(&e) != nullptr ||
-                       boost::get<StateEvent<Topic>>(&e) != nullptr;
+                return std::holds_alternative<StateEvent<state::Avatar>>(e) ||
+                       std::holds_alternative<StateEvent<CanonicalAlias>>(e) ||
+                       std::holds_alternative<StateEvent<Name>>(e) ||
+                       std::holds_alternative<StateEvent<Member>>(e) ||
+                       std::holds_alternative<StateEvent<Topic>>(e);
         }
 
         bool containsStateUpdates(const mtx::events::collections::StrippedEvents &e)
@@ -615,11 +614,11 @@ private:
                 using namespace mtx::events;
                 using namespace mtx::events::state;
 
-                return boost::get<StrippedEvent<state::Avatar>>(&e) != nullptr ||
-                       boost::get<StrippedEvent<CanonicalAlias>>(&e) != nullptr ||
-                       boost::get<StrippedEvent<Name>>(&e) != nullptr ||
-                       boost::get<StrippedEvent<Member>>(&e) != nullptr ||
-                       boost::get<StrippedEvent<Topic>>(&e) != nullptr;
+                return std::holds_alternative<StrippedEvent<state::Avatar>>(e) ||
+                       std::holds_alternative<StrippedEvent<CanonicalAlias>>(e) ||
+                       std::holds_alternative<StrippedEvent<Name>>(e) ||
+                       std::holds_alternative<StrippedEvent<Member>>(e) ||
+                       std::holds_alternative<StrippedEvent<Topic>>(e);
         }
 
         void saveInvites(lmdb::txn &txn,
diff --git a/src/ChatPage.cpp b/src/ChatPage.cpp
index 35d262ac..c496acab 100644
--- a/src/ChatPage.cpp
+++ b/src/ChatPage.cpp
@@ -54,7 +54,7 @@ constexpr int CHECK_CONNECTIVITY_INTERVAL = 15'000;
 constexpr int RETRY_TIMEOUT               = 5'000;
 constexpr size_t MAX_ONETIME_KEYS         = 50;
 
-Q_DECLARE_METATYPE(boost::optional<mtx::crypto::EncryptedFile>)
+Q_DECLARE_METATYPE(std::optional<mtx::crypto::EncryptedFile>)
 
 ChatPage::ChatPage(QSharedPointer<UserSettings> userSettings, QWidget *parent)
   : QWidget(parent)
@@ -64,8 +64,8 @@ ChatPage::ChatPage(QSharedPointer<UserSettings> userSettings, QWidget *parent)
 {
         setObjectName("chatPage");
 
-        qRegisterMetaType<boost::optional<mtx::crypto::EncryptedFile>>(
-          "boost::optional<mtx::crypto::EncryptedFile>");
+        qRegisterMetaType<std::optional<mtx::crypto::EncryptedFile>>(
+          "std::optional<mtx::crypto::EncryptedFile>");
 
         topLayout_ = new QHBoxLayout(this);
         topLayout_->setSpacing(0);
@@ -318,7 +318,7 @@ ChatPage::ChatPage(QSharedPointer<UserSettings> userSettings, QWidget *parent)
 
                   auto bin     = dev->peek(dev->size());
                   auto payload = std::string(bin.data(), bin.size());
-                  boost::optional<mtx::crypto::EncryptedFile> encryptedFile;
+                  std::optional<mtx::crypto::EncryptedFile> encryptedFile;
                   if (cache::client()->isRoomEncrypted(current_room_.toStdString())) {
                           mtx::crypto::BinaryBuf buf;
                           std::tie(buf, encryptedFile) = mtx::crypto::encrypt_file(payload);
@@ -371,7 +371,7 @@ ChatPage::ChatPage(QSharedPointer<UserSettings> userSettings, QWidget *parent)
                 this,
                 [this](QString roomid,
                        QString filename,
-                       boost::optional<mtx::crypto::EncryptedFile> encryptedFile,
+                       std::optional<mtx::crypto::EncryptedFile> encryptedFile,
                        QString url,
                        QString mimeClass,
                        QString mime,
diff --git a/src/ChatPage.h b/src/ChatPage.h
index 20e156af..6ca30b3d 100644
--- a/src/ChatPage.h
+++ b/src/ChatPage.h
@@ -18,8 +18,9 @@
 #pragma once
 
 #include <atomic>
-#include <boost/optional.hpp>
-#include <boost/variant.hpp>
+#include <optional>
+#include <variant>
+
 #include <mtx/common.hpp>
 #include <mtx/responses.hpp>
 
@@ -98,7 +99,7 @@ signals:
         void uploadFailed(const QString &msg);
         void mediaUploaded(const QString &roomid,
                            const QString &filename,
-                           const boost::optional<mtx::crypto::EncryptedFile> &file,
+                           const std::optional<mtx::crypto::EncryptedFile> &file,
                            const QString &url,
                            const QString &mimeClass,
                            const QString &mime,
@@ -252,9 +253,8 @@ ChatPage::getMemberships(const std::vector<Collection> &collection) const
         using Member = mtx::events::StateEvent<mtx::events::state::Member>;
 
         for (const auto &event : collection) {
-                if (boost::get<Member>(event) != nullptr) {
-                        auto member = boost::get<Member>(event);
-                        memberships.emplace(member.state_key, member);
+                if (auto member = std::get_if<Member>(event)) {
+                        memberships.emplace(member->state_key, *member);
                 }
         }
 
diff --git a/src/Olm.cpp b/src/Olm.cpp
index c1598570..9c1a25df 100644
--- a/src/Olm.cpp
+++ b/src/Olm.cpp
@@ -1,4 +1,4 @@
-#include <boost/variant.hpp>
+#include <variant>
 
 #include "Olm.h"
 
@@ -289,14 +289,13 @@ request_keys(const std::string &room_id, const std::string &event_id)
                           return;
                   }
 
-                  if (boost::get<EncryptedEvent<msg::Encrypted>>(&res) == nullptr) {
+                  if (!std::holds_alternative<EncryptedEvent<msg::Encrypted>>(res)) {
                           nhlog::net()->info(
                             "retrieved event is not encrypted: {} from {}", event_id, room_id);
                           return;
                   }
 
-                  olm::send_key_request_for(room_id,
-                                            boost::get<EncryptedEvent<msg::Encrypted>>(res));
+                  olm::send_key_request_for(room_id, std::get<EncryptedEvent<msg::Encrypted>>(res));
           });
 }
 
diff --git a/src/Utils.cpp b/src/Utils.cpp
index 8f9e0643..3d69162f 100644
--- a/src/Utils.cpp
+++ b/src/Utils.cpp
@@ -9,9 +9,10 @@
 #include <QSettings>
 #include <QTextDocument>
 #include <QXmlStreamReader>
+
 #include <cmath>
+#include <variant>
 
-#include <boost/variant.hpp>
 #include <cmark.h>
 
 #include "Config.h"
@@ -122,34 +123,33 @@ utils::getMessageDescription(const TimelineEvent &event,
         using Video     = mtx::events::RoomEvent<mtx::events::msg::Video>;
         using Encrypted = mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>;
 
-        if (boost::get<Audio>(&event) != nullptr) {
+        if (std::holds_alternative<Audio>(event)) {
                 return createDescriptionInfo<Audio>(event, localUser, room_id);
-        } else if (boost::get<Emote>(&event) != nullptr) {
+        } else if (std::holds_alternative<Emote>(event)) {
                 return createDescriptionInfo<Emote>(event, localUser, room_id);
-        } else if (boost::get<File>(&event) != nullptr) {
+        } else if (std::holds_alternative<File>(event)) {
                 return createDescriptionInfo<File>(event, localUser, room_id);
-        } else if (boost::get<Image>(&event) != nullptr) {
+        } else if (std::holds_alternative<Image>(event)) {
                 return createDescriptionInfo<Image>(event, localUser, room_id);
-        } else if (boost::get<Notice>(&event) != nullptr) {
+        } else if (std::holds_alternative<Notice>(event)) {
                 return createDescriptionInfo<Notice>(event, localUser, room_id);
-        } else if (boost::get<Text>(&event) != nullptr) {
+        } else if (std::holds_alternative<Text>(event)) {
                 return createDescriptionInfo<Text>(event, localUser, room_id);
-        } else if (boost::get<Video>(&event) != nullptr) {
+        } else if (std::holds_alternative<Video>(event)) {
                 return createDescriptionInfo<Video>(event, localUser, room_id);
-        } else if (boost::get<mtx::events::Sticker>(&event) != nullptr) {
+        } else if (std::holds_alternative<mtx::events::Sticker>(event)) {
                 return createDescriptionInfo<mtx::events::Sticker>(event, localUser, room_id);
-        } else if (boost::get<Encrypted>(&event) != nullptr) {
-                const auto msg    = boost::get<Encrypted>(event);
-                const auto sender = QString::fromStdString(msg.sender);
+        } else if (auto msg = std::get_if<Encrypted>(&event); msg != nullptr) {
+                const auto sender = QString::fromStdString(msg->sender);
 
                 const auto username = Cache::displayName(room_id, sender);
-                const auto ts       = QDateTime::fromMSecsSinceEpoch(msg.origin_server_ts);
+                const auto ts       = QDateTime::fromMSecsSinceEpoch(msg->origin_server_ts);
 
                 DescInfo info;
                 info.userid    = sender;
                 info.body      = QString(" %1").arg(messageDescription<Encrypted>());
                 info.timestamp = utils::descriptiveTime(ts);
-                info.event_id  = QString::fromStdString(msg.event_id);
+                info.event_id  = QString::fromStdString(msg->event_id);
                 info.datetime  = ts;
 
                 return info;
@@ -217,30 +217,25 @@ utils::levenshtein_distance(const std::string &s1, const std::string &s2)
 }
 
 QString
-utils::event_body(const mtx::events::collections::TimelineEvents &event)
+utils::event_body(const mtx::events::collections::TimelineEvents &e)
 {
         using namespace mtx::events;
-        using namespace mtx::events::msg;
-
-        if (boost::get<RoomEvent<Audio>>(&event) != nullptr) {
-                return message_body<RoomEvent<Audio>>(event);
-        } else if (boost::get<RoomEvent<Emote>>(&event) != nullptr) {
-                return message_body<RoomEvent<Emote>>(event);
-        } else if (boost::get<RoomEvent<File>>(&event) != nullptr) {
-                return message_body<RoomEvent<File>>(event);
-        } else if (boost::get<RoomEvent<Image>>(&event) != nullptr) {
-                return message_body<RoomEvent<Image>>(event);
-        } else if (boost::get<RoomEvent<Notice>>(&event) != nullptr) {
-                return message_body<RoomEvent<Notice>>(event);
-        } else if (boost::get<Sticker>(&event) != nullptr) {
-                return message_body<Sticker>(event);
-        } else if (boost::get<RoomEvent<Text>>(&event) != nullptr) {
-                return message_body<RoomEvent<Text>>(event);
-        } else if (boost::get<RoomEvent<Video>>(&event) != nullptr) {
-                return message_body<RoomEvent<Video>>(event);
-        }
-
-        return QString();
+        if (auto ev = std::get_if<RoomEvent<msg::Audio>>(&e); ev != nullptr)
+                return QString::fromStdString(ev->content.body);
+        if (auto ev = std::get_if<RoomEvent<msg::Emote>>(&e); ev != nullptr)
+                return QString::fromStdString(ev->content.body);
+        if (auto ev = std::get_if<RoomEvent<msg::File>>(&e); ev != nullptr)
+                return QString::fromStdString(ev->content.body);
+        if (auto ev = std::get_if<RoomEvent<msg::Image>>(&e); ev != nullptr)
+                return QString::fromStdString(ev->content.body);
+        if (auto ev = std::get_if<RoomEvent<msg::Notice>>(&e); ev != nullptr)
+                return QString::fromStdString(ev->content.body);
+        if (auto ev = std::get_if<RoomEvent<msg::Text>>(&e); ev != nullptr)
+                return QString::fromStdString(ev->content.body);
+        if (auto ev = std::get_if<RoomEvent<msg::Video>>(&e); ev != nullptr)
+                return QString::fromStdString(ev->content.body);
+
+        return "";
 }
 
 QPixmap
diff --git a/src/Utils.h b/src/Utils.h
index bdb51844..6c0cf0dd 100644
--- a/src/Utils.h
+++ b/src/Utils.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <boost/variant.hpp>
+#include <variant>
 
 #include "Cache.h"
 #include "RoomInfoListItem.h"
@@ -165,7 +165,7 @@ template<class T, class Event>
 DescInfo
 createDescriptionInfo(const Event &event, const QString &localUser, const QString &room_id)
 {
-        const auto msg    = boost::get<T>(event);
+        const auto msg    = std::get<T>(event);
         const auto sender = QString::fromStdString(msg.sender);
 
         const auto username = Cache::displayName(room_id, sender);
@@ -200,25 +200,25 @@ erase_if(ContainerT &items, const PredicateT &predicate)
 inline uint64_t
 event_timestamp(const mtx::events::collections::TimelineEvents &event)
 {
-        return boost::apply_visitor([](auto msg) { return msg.origin_server_ts; }, event);
+        return std::visit([](auto msg) { return msg.origin_server_ts; }, event);
 }
 
 inline nlohmann::json
 serialize_event(const mtx::events::collections::TimelineEvents &event)
 {
-        return boost::apply_visitor([](auto msg) { return json(msg); }, event);
+        return std::visit([](auto msg) { return json(msg); }, event);
 }
 
 inline mtx::events::EventType
 event_type(const mtx::events::collections::TimelineEvents &event)
 {
-        return boost::apply_visitor([](auto msg) { return msg.type; }, event);
+        return std::visit([](auto msg) { return msg.type; }, event);
 }
 
 inline std::string
 event_id(const mtx::events::collections::TimelineEvents &event)
 {
-        return boost::apply_visitor([](auto msg) { return msg.event_id; }, event);
+        return std::visit([](auto msg) { return msg.event_id; }, event);
 }
 
 inline QString
@@ -230,15 +230,14 @@ eventId(const mtx::events::collections::TimelineEvents &event)
 inline QString
 event_sender(const mtx::events::collections::TimelineEvents &event)
 {
-        return boost::apply_visitor([](auto msg) { return QString::fromStdString(msg.sender); },
-                                    event);
+        return std::visit([](auto msg) { return QString::fromStdString(msg.sender); }, event);
 }
 
 template<class T>
 QString
 message_body(const mtx::events::collections::TimelineEvents &event)
 {
-        return QString::fromStdString(boost::get<T>(event).content.body);
+        return QString::fromStdString(std::get<T>(event).content.body);
 }
 
 //! Calculate the Levenshtein distance between two strings with character skipping.
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index e49fcf57..1e069d50 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -117,17 +117,17 @@ eventFormattedBody(const mtx::events::RoomEvent<T> &e)
 }
 
 template<class T>
-boost::optional<mtx::crypto::EncryptedFile>
+std::optional<mtx::crypto::EncryptedFile>
 eventEncryptionInfo(const mtx::events::Event<T> &)
 {
-        return boost::none;
+        return std::nullopt;
 }
 
 template<class T>
 auto
 eventEncryptionInfo(const mtx::events::RoomEvent<T> &e) -> std::enable_if_t<
-  std::is_same<decltype(e.content.file), boost::optional<mtx::crypto::EncryptedFile>>::value,
-  boost::optional<mtx::crypto::EncryptedFile>>
+  std::is_same<decltype(e.content.file), std::optional<mtx::crypto::EncryptedFile>>::value,
+  std::optional<mtx::crypto::EncryptedFile>>
 {
         return e.content.file;
 }
@@ -407,7 +407,7 @@ TimelineModel::TimelineModel(TimelineViewManager *manager, QString room_id, QObj
                 }
                 eventOrder[idx] = event_id;
                 auto ev         = events.value(txn_id);
-                ev              = boost::apply_visitor(
+                ev              = std::visit(
                   [event_id](const auto &e) -> mtx::events::collections::TimelineEvents {
                           auto eventCopy     = e;
                           eventCopy.event_id = event_id.toStdString();
@@ -483,29 +483,30 @@ TimelineModel::data(const QModelIndex &index, int role) const
 
         mtx::events::collections::TimelineEvents event = events.value(id);
 
-        if (auto e = boost::get<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(&event)) {
+        if (auto e =
+              std::get_if<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(&event)) {
                 event = decryptEvent(*e).event;
         }
 
         switch (role) {
         case Section: {
-                QDateTime date = boost::apply_visitor(
-                  [](const auto &e) -> QDateTime { return eventTimestamp(e); }, event);
+                QDateTime date =
+                  std::visit([](const auto &e) -> QDateTime { return eventTimestamp(e); }, event);
                 date.setTime(QTime());
 
                 QString userId =
-                  boost::apply_visitor([](const auto &e) -> QString { return senderId(e); }, event);
+                  std::visit([](const auto &e) -> QString { return senderId(e); }, event);
 
                 for (int r = index.row() - 1; r > 0; r--) {
                         auto tempEv        = events.value(eventOrder[r]);
-                        QDateTime prevDate = boost::apply_visitor(
+                        QDateTime prevDate = std::visit(
                           [](const auto &e) -> QDateTime { return eventTimestamp(e); }, tempEv);
                         prevDate.setTime(QTime());
                         if (prevDate != date)
                                 return QString("%2 %1").arg(date.toMSecsSinceEpoch()).arg(userId);
 
-                        QString prevUserId = boost::apply_visitor(
-                          [](const auto &e) -> QString { return senderId(e); }, tempEv);
+                        QString prevUserId =
+                          std::visit([](const auto &e) -> QString { return senderId(e); }, tempEv);
                         if (userId != prevUserId)
                                 break;
                 }
@@ -513,62 +514,61 @@ TimelineModel::data(const QModelIndex &index, int role) const
                 return QString("%1").arg(userId);
         }
         case UserId:
-                return QVariant(boost::apply_visitor(
-                  [](const auto &e) -> QString { return senderId(e); }, event));
+                return QVariant(
+                  std::visit([](const auto &e) -> QString { return senderId(e); }, event));
         case UserName:
-                return QVariant(displayName(boost::apply_visitor(
-                  [](const auto &e) -> QString { return senderId(e); }, event)));
+                return QVariant(displayName(
+                  std::visit([](const auto &e) -> QString { return senderId(e); }, event)));
 
         case Timestamp:
-                return QVariant(boost::apply_visitor(
-                  [](const auto &e) -> QDateTime { return eventTimestamp(e); }, event));
+                return QVariant(
+                  std::visit([](const auto &e) -> QDateTime { return eventTimestamp(e); }, event));
         case Type:
-                return QVariant(boost::apply_visitor(
+                return QVariant(std::visit(
                   [](const auto &e) -> qml_mtx_events::EventType { return toRoomEventType(e); },
                   event));
         case Body:
-                return QVariant(utils::replaceEmoji(boost::apply_visitor(
-                  [](const auto &e) -> QString { return eventBody(e); }, event)));
+                return QVariant(utils::replaceEmoji(
+                  std::visit([](const auto &e) -> QString { return eventBody(e); }, event)));
         case FormattedBody:
                 return QVariant(
                   utils::replaceEmoji(
-                    utils::linkifyMessage(boost::apply_visitor(
+                    utils::linkifyMessage(std::visit(
                       [](const auto &e) -> QString { return eventFormattedBody(e); }, event)))
                     .remove("<mx-reply>")
                     .remove("</mx-reply>"));
         case Url:
-                return QVariant(boost::apply_visitor(
-                  [](const auto &e) -> QString { return eventUrl(e); }, event));
+                return QVariant(
+                  std::visit([](const auto &e) -> QString { return eventUrl(e); }, event));
         case ThumbnailUrl:
-                return QVariant(boost::apply_visitor(
-                  [](const auto &e) -> QString { return eventThumbnailUrl(e); }, event));
+                return QVariant(
+                  std::visit([](const auto &e) -> QString { return eventThumbnailUrl(e); }, event));
         case Filename:
-                return QVariant(boost::apply_visitor(
-                  [](const auto &e) -> QString { return eventFilename(e); }, event));
+                return QVariant(
+                  std::visit([](const auto &e) -> QString { return eventFilename(e); }, event));
         case Filesize:
-                return QVariant(boost::apply_visitor(
+                return QVariant(std::visit(
                   [](const auto &e) -> QString {
                           return utils::humanReadableFileSize(eventFilesize(e));
                   },
                   event));
         case MimeType:
-                return QVariant(boost::apply_visitor(
-                  [](const auto &e) -> QString { return eventMimeType(e); }, event));
+                return QVariant(
+                  std::visit([](const auto &e) -> QString { return eventMimeType(e); }, event));
         case Height:
-                return QVariant(boost::apply_visitor(
-                  [](const auto &e) -> qulonglong { return eventHeight(e); }, event));
+                return QVariant(
+                  std::visit([](const auto &e) -> qulonglong { return eventHeight(e); }, event));
         case Width:
-                return QVariant(boost::apply_visitor(
-                  [](const auto &e) -> qulonglong { return eventWidth(e); }, event));
+                return QVariant(
+                  std::visit([](const auto &e) -> qulonglong { return eventWidth(e); }, event));
         case ProportionalHeight:
-                return QVariant(boost::apply_visitor(
-                  [](const auto &e) -> double { return eventPropHeight(e); }, event));
+                return QVariant(
+                  std::visit([](const auto &e) -> double { return eventPropHeight(e); }, event));
         case Id:
                 return id;
         case State:
                 // only show read receipts for messages not from us
-                if (boost::apply_visitor([](const auto &e) -> QString { return senderId(e); },
-                                         event)
+                if (std::visit([](const auto &e) -> QString { return senderId(e); }, event)
                       .toStdString() != http::client()->user_id().to_string())
                         return qml_mtx_events::Empty;
                 else if (failed.contains(id))
@@ -582,20 +582,20 @@ TimelineModel::data(const QModelIndex &index, int role) const
                         return qml_mtx_events::Received;
         case IsEncrypted: {
                 auto tempEvent = events[id];
-                return boost::get<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(
-                         &tempEvent) != nullptr;
+                return std::holds_alternative<
+                  mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(tempEvent);
         }
         case ReplyTo: {
-                QString evId = boost::apply_visitor(
-                  [](const auto &e) -> QString { return eventRelatesTo(e); }, event);
+                QString evId =
+                  std::visit([](const auto &e) -> QString { return eventRelatesTo(e); }, event);
                 return QVariant(evId);
         }
         case RoomName:
-                return QVariant(boost::apply_visitor(
-                  [](const auto &e) -> QString { return eventRoomName(e); }, event));
+                return QVariant(
+                  std::visit([](const auto &e) -> QString { return eventRoomName(e); }, event));
         case RoomTopic:
-                return QVariant(boost::apply_visitor(
-                  [](const auto &e) -> QString { return eventRoomTopic(e); }, event));
+                return QVariant(
+                  std::visit([](const auto &e) -> QString { return eventRoomTopic(e); }, event));
         default:
                 return QVariant();
         }
@@ -646,13 +646,12 @@ TimelineModel::updateLastMessage()
 {
         for (auto it = eventOrder.rbegin(); it != eventOrder.rend(); ++it) {
                 auto event = events.value(*it);
-                if (auto e = boost::get<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(
+                if (auto e = std::get_if<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(
                       &event)) {
                         event = decryptEvent(*e).event;
                 }
 
-                if (!boost::apply_visitor([](const auto &e) -> bool { return isMessage(e); },
-                                          event))
+                if (!std::visit([](const auto &e) -> bool { return isMessage(e); }, event))
                         continue;
 
                 auto description = utils::getMessageDescription(
@@ -668,8 +667,7 @@ TimelineModel::internalAddEvents(
 {
         std::vector<QString> ids;
         for (auto e : timeline) {
-                QString id =
-                  boost::apply_visitor([](const auto &e) -> QString { return eventId(e); }, e);
+                QString id = std::visit([](const auto &e) -> QString { return eventId(e); }, e);
 
                 if (this->events.contains(id)) {
                         this->events.insert(id, e);
@@ -679,12 +677,12 @@ TimelineModel::internalAddEvents(
                 }
 
                 if (auto redaction =
-                      boost::get<mtx::events::RedactionEvent<mtx::events::msg::Redaction>>(&e)) {
+                      std::get_if<mtx::events::RedactionEvent<mtx::events::msg::Redaction>>(&e)) {
                         QString redacts = QString::fromStdString(redaction->redacts);
                         auto redacted   = std::find(eventOrder.begin(), eventOrder.end(), redacts);
 
                         if (redacted != eventOrder.end()) {
-                                auto redactedEvent = boost::apply_visitor(
+                                auto redactedEvent = std::visit(
                                   [](const auto &ev)
                                     -> mtx::events::RoomEvent<mtx::events::msg::Redacted> {
                                           mtx::events::RoomEvent<mtx::events::msg::Redacted>
@@ -707,11 +705,11 @@ TimelineModel::internalAddEvents(
                 }
 
                 if (auto event =
-                      boost::get<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(&e)) {
+                      std::get_if<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(&e)) {
                         e = decryptEvent(*event).event;
                 }
-                auto encInfo = boost::apply_visitor(
-                  [](const auto &ev) -> boost::optional<mtx::crypto::EncryptedFile> {
+                auto encInfo = std::visit(
+                  [](const auto &ev) -> std::optional<mtx::crypto::EncryptedFile> {
                           return eventEncryptionInfo(ev);
                   },
                   e);
@@ -947,11 +945,12 @@ void
 TimelineModel::replyAction(QString id)
 {
         auto event = events.value(id);
-        if (auto e = boost::get<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(&event)) {
+        if (auto e =
+              std::get_if<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(&event)) {
                 event = decryptEvent(*e).event;
         }
 
-        RelatedInfo related = boost::apply_visitor(
+        RelatedInfo related = std::visit(
           [](const auto &ev) -> RelatedInfo {
                   RelatedInfo related_   = {};
                   related_.quoted_user   = QString::fromStdString(ev.sender);
@@ -959,10 +958,10 @@ TimelineModel::replyAction(QString id)
                   return related_;
           },
           event);
-        related.type        = mtx::events::getMessageType(boost::apply_visitor(
-          [](const auto &e) -> std::string { return eventMsgType(e); }, event));
-        related.quoted_body = boost::apply_visitor(
-          [](const auto &e) -> QString { return eventFormattedBody(e); }, event);
+        related.type = mtx::events::getMessageType(
+          std::visit([](const auto &e) -> std::string { return eventMsgType(e); }, event));
+        related.quoted_body =
+          std::visit([](const auto &e) -> QString { return eventFormattedBody(e); }, event);
         related.quoted_body.remove(QRegularExpression(
           "<mx-reply>.*</mx-reply>", QRegularExpression::DotMatchesEverythingOption));
         nhlog::ui()->debug("after replacement: {}", related.quoted_body.toStdString());
@@ -1396,7 +1395,7 @@ TimelineModel::processOnePendingMessage()
         QString txn_id_qstr = pending.first();
 
         auto event = events.value(txn_id_qstr);
-        boost::apply_visitor(SendMessageVisitor{txn_id_qstr, this}, event);
+        std::visit(SendMessageVisitor{txn_id_qstr, this}, event);
 }
 
 void
@@ -1405,7 +1404,7 @@ TimelineModel::addPendingMessage(mtx::events::collections::TimelineEvents event)
         internalAddEvents({event});
 
         QString txn_id_qstr =
-          boost::apply_visitor([](const auto &e) -> QString { return eventId(e); }, event);
+          std::visit([](const auto &e) -> QString { return eventId(e); }, event);
         beginInsertRows(QModelIndex(),
                         static_cast<int>(this->eventOrder.size()),
                         static_cast<int>(this->eventOrder.size()));
@@ -1423,22 +1422,22 @@ TimelineModel::saveMedia(QString eventId) const
 {
         mtx::events::collections::TimelineEvents event = events.value(eventId);
 
-        if (auto e = boost::get<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(&event)) {
+        if (auto e =
+              std::get_if<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(&event)) {
                 event = decryptEvent(*e).event;
         }
 
-        QString mxcUrl =
-          boost::apply_visitor([](const auto &e) -> QString { return eventUrl(e); }, event);
+        QString mxcUrl = std::visit([](const auto &e) -> QString { return eventUrl(e); }, event);
         QString originalFilename =
-          boost::apply_visitor([](const auto &e) -> QString { return eventFilename(e); }, event);
+          std::visit([](const auto &e) -> QString { return eventFilename(e); }, event);
         QString mimeType =
-          boost::apply_visitor([](const auto &e) -> QString { return eventMimeType(e); }, event);
+          std::visit([](const auto &e) -> QString { return eventMimeType(e); }, event);
 
-        using EncF = boost::optional<mtx::crypto::EncryptedFile>;
+        using EncF = std::optional<mtx::crypto::EncryptedFile>;
         EncF encryptionInfo =
-          boost::apply_visitor([](const auto &e) -> EncF { return eventEncryptionInfo(e); }, event);
+          std::visit([](const auto &e) -> EncF { return eventEncryptionInfo(e); }, event);
 
-        qml_mtx_events::EventType eventType = boost::apply_visitor(
+        qml_mtx_events::EventType eventType = std::visit(
           [](const auto &e) -> qml_mtx_events::EventType { return toRoomEventType(e); }, event);
 
         QString dialogTitle;
@@ -1500,18 +1499,18 @@ TimelineModel::cacheMedia(QString eventId)
 {
         mtx::events::collections::TimelineEvents event = events.value(eventId);
 
-        if (auto e = boost::get<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(&event)) {
+        if (auto e =
+              std::get_if<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(&event)) {
                 event = decryptEvent(*e).event;
         }
 
-        QString mxcUrl =
-          boost::apply_visitor([](const auto &e) -> QString { return eventUrl(e); }, event);
+        QString mxcUrl = std::visit([](const auto &e) -> QString { return eventUrl(e); }, event);
         QString mimeType =
-          boost::apply_visitor([](const auto &e) -> QString { return eventMimeType(e); }, event);
+          std::visit([](const auto &e) -> QString { return eventMimeType(e); }, event);
 
-        using EncF = boost::optional<mtx::crypto::EncryptedFile>;
+        using EncF = std::optional<mtx::crypto::EncryptedFile>;
         EncF encryptionInfo =
-          boost::apply_visitor([](const auto &e) -> EncF { return eventEncryptionInfo(e); }, event);
+          std::visit([](const auto &e) -> EncF { return eventEncryptionInfo(e); }, event);
 
         // If the message is a link to a non mxcUrl, don't download it
         if (!mxcUrl.startsWith("mxc://")) {
diff --git a/src/timeline/TimelineViewManager.cpp b/src/timeline/TimelineViewManager.cpp
index 6e18d111..74e09a33 100644
--- a/src/timeline/TimelineViewManager.cpp
+++ b/src/timeline/TimelineViewManager.cpp
@@ -222,7 +222,7 @@ TimelineViewManager::queueEmoteMessage(const QString &msg)
 void
 TimelineViewManager::queueImageMessage(const QString &roomid,
                                        const QString &filename,
-                                       const boost::optional<mtx::crypto::EncryptedFile> &file,
+                                       const std::optional<mtx::crypto::EncryptedFile> &file,
                                        const QString &url,
                                        const QString &mime,
                                        uint64_t dsize,
@@ -243,7 +243,7 @@ void
 TimelineViewManager::queueFileMessage(
   const QString &roomid,
   const QString &filename,
-  const boost::optional<mtx::crypto::EncryptedFile> &encryptedFile,
+  const std::optional<mtx::crypto::EncryptedFile> &encryptedFile,
   const QString &url,
   const QString &mime,
   uint64_t dsize)
@@ -260,7 +260,7 @@ TimelineViewManager::queueFileMessage(
 void
 TimelineViewManager::queueAudioMessage(const QString &roomid,
                                        const QString &filename,
-                                       const boost::optional<mtx::crypto::EncryptedFile> &file,
+                                       const std::optional<mtx::crypto::EncryptedFile> &file,
                                        const QString &url,
                                        const QString &mime,
                                        uint64_t dsize)
@@ -277,7 +277,7 @@ TimelineViewManager::queueAudioMessage(const QString &roomid,
 void
 TimelineViewManager::queueVideoMessage(const QString &roomid,
                                        const QString &filename,
-                                       const boost::optional<mtx::crypto::EncryptedFile> &file,
+                                       const std::optional<mtx::crypto::EncryptedFile> &file,
                                        const QString &url,
                                        const QString &mime,
                                        uint64_t dsize)
diff --git a/src/timeline/TimelineViewManager.h b/src/timeline/TimelineViewManager.h
index 9e8de616..587aa14e 100644
--- a/src/timeline/TimelineViewManager.h
+++ b/src/timeline/TimelineViewManager.h
@@ -56,26 +56,26 @@ public slots:
         void queueEmoteMessage(const QString &msg);
         void queueImageMessage(const QString &roomid,
                                const QString &filename,
-                               const boost::optional<mtx::crypto::EncryptedFile> &file,
+                               const std::optional<mtx::crypto::EncryptedFile> &file,
                                const QString &url,
                                const QString &mime,
                                uint64_t dsize,
                                const QSize &dimensions);
         void queueFileMessage(const QString &roomid,
                               const QString &filename,
-                              const boost::optional<mtx::crypto::EncryptedFile> &file,
+                              const std::optional<mtx::crypto::EncryptedFile> &file,
                               const QString &url,
                               const QString &mime,
                               uint64_t dsize);
         void queueAudioMessage(const QString &roomid,
                                const QString &filename,
-                               const boost::optional<mtx::crypto::EncryptedFile> &file,
+                               const std::optional<mtx::crypto::EncryptedFile> &file,
                                const QString &url,
                                const QString &mime,
                                uint64_t dsize);
         void queueVideoMessage(const QString &roomid,
                                const QString &filename,
-                               const boost::optional<mtx::crypto::EncryptedFile> &file,
+                               const std::optional<mtx::crypto::EncryptedFile> &file,
                                const QString &url,
                                const QString &mime,
                                uint64_t dsize);
-- 
cgit 1.5.1


From 5fc1f3bd678cca690268eafbb7e4595657a6e133 Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Sun, 15 Dec 2019 02:56:04 +0100
Subject: Reduce overhead of Cache.h

---
 .gitignore                     |   1 +
 CMakeLists.txt                 |   2 +-
 src/AvatarProvider.cpp         |  14 +-
 src/Cache.cpp                  | 561 +++++++++++++++++++++++++++++--
 src/Cache.h                    | 744 +++++++++++++++--------------------------
 src/Cache_p.h                  | 494 +++++++++++++++++++++++++++
 src/ChatPage.cpp               |  87 +++--
 src/CommunitiesList.cpp        |   4 +-
 src/MainWindow.cpp             |   6 +-
 src/MxcImageProvider.cpp       |  10 +-
 src/Olm.cpp                    |  27 +-
 src/QuickSwitcher.cpp          |   3 +-
 src/TextInputWidget.cpp        |   4 +-
 src/UserSettingsPage.cpp       |   4 +-
 src/Utils.cpp                  |   2 +-
 src/Utils.h                    |   2 +-
 src/dialogs/MemberList.cpp     |   4 +-
 src/dialogs/ReadReceipts.cpp   |   2 +-
 src/dialogs/RoomSettings.cpp   |  12 +-
 src/dialogs/RoomSettings.h     |   4 +-
 src/dialogs/UserProfile.cpp    |   8 +-
 src/popups/PopupItem.cpp       |   6 +-
 src/popups/PopupItem.h         |   3 +-
 src/popups/ReplyPopup.cpp      |   1 +
 src/popups/ReplyPopup.h        |   9 +-
 src/popups/SuggestionsPopup.h  |   7 +-
 src/popups/UserMentions.cpp    |   2 +-
 src/timeline/TimelineModel.cpp |  23 +-
 28 files changed, 1403 insertions(+), 643 deletions(-)
 create mode 100644 src/Cache_p.h

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/.gitignore b/.gitignore
index 2d772e58..6d178679 100644
--- a/.gitignore
+++ b/.gitignore
@@ -40,6 +40,7 @@ moc_*.cpp
 qrc_*.cpp
 ui_*.h
 *-build-*
+/.clangd/
 
 # QtCreator
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1e86ee14..5c68d614 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -357,7 +357,7 @@ qt5_wrap_cpp(MOC_HEADERS
     src/notifications/Manager.h
 
     src/AvatarProvider.h
-    src/Cache.h
+    src/Cache_p.h
     src/ChatPage.h
     src/CommunitiesListItem.h
     src/CommunitiesList.h
diff --git a/src/AvatarProvider.cpp b/src/AvatarProvider.cpp
index 68b6901e..1587a9a1 100644
--- a/src/AvatarProvider.cpp
+++ b/src/AvatarProvider.cpp
@@ -35,9 +35,6 @@ resolve(const QString &avatarUrl, int size, QObject *receiver, AvatarCallback ca
 
         const auto cacheKey = avatarUrl + "_size_" + size;
 
-        if (!cache::client())
-                return;
-
         if (avatarUrl.isEmpty())
                 return;
 
@@ -47,7 +44,7 @@ resolve(const QString &avatarUrl, int size, QObject *receiver, AvatarCallback ca
                 return;
         }
 
-        auto data = cache::client()->image(avatarUrl);
+        auto data = cache::image(avatarUrl);
         if (!data.isNull()) {
                 pixmap.loadFromData(data);
                 avatar_cache.insert(cacheKey, pixmap);
@@ -82,7 +79,7 @@ resolve(const QString &avatarUrl, int size, QObject *receiver, AvatarCallback ca
                           return;
                   }
 
-                  cache::client()->saveImage(opts.mxc_url, res);
+                  cache::saveImage(opts.mxc_url, res);
 
                   emit proxy->avatarDownloaded(QByteArray(res.data(), res.size()));
           });
@@ -95,12 +92,7 @@ resolve(const QString &room_id,
         QObject *receiver,
         AvatarCallback callback)
 {
-        const auto key       = QString("%1 %2").arg(room_id).arg(user_id);
-        const auto avatarUrl = Cache::avatarUrl(room_id, user_id);
-        const auto cacheKey  = avatarUrl + "_size_" + size;
-
-        if (!Cache::AvatarUrls.contains(key) || !cache::client())
-                return;
+        const auto avatarUrl = cache::avatarUrl(room_id, user_id);
 
         resolve(avatarUrl, size, receiver, callback);
 }
diff --git a/src/Cache.cpp b/src/Cache.cpp
index ee53ffbd..79425fa1 100644
--- a/src/Cache.cpp
+++ b/src/Cache.cpp
@@ -30,6 +30,7 @@
 #include <mtx/responses/common.hpp>
 
 #include "Cache.h"
+#include "Cache_p.h"
 #include "Utils.h"
 
 //! Should be changed when a breaking change occurs in the cache format.
@@ -89,29 +90,20 @@ namespace {
 std::unique_ptr<Cache> instance_ = nullptr;
 }
 
-namespace cache {
-void
-init(const QString &user_id)
+int
+numeric_key_comparison(const MDB_val *a, const MDB_val *b)
 {
-        qRegisterMetaType<SearchResult>();
-        qRegisterMetaType<QVector<SearchResult>>();
-        qRegisterMetaType<RoomMember>();
-        qRegisterMetaType<RoomSearchResult>();
-        qRegisterMetaType<RoomInfo>();
-        qRegisterMetaType<QMap<QString, RoomInfo>>();
-        qRegisterMetaType<QMap<QString, mtx::responses::Notifications>>();
-        qRegisterMetaType<std::map<QString, RoomInfo>>();
-        qRegisterMetaType<std::map<QString, mtx::responses::Timeline>>();
+        auto lhs = std::stoull(std::string((char *)a->mv_data, a->mv_size));
+        auto rhs = std::stoull(std::string((char *)b->mv_data, b->mv_size));
 
-        instance_ = std::make_unique<Cache>(user_id);
-}
+        if (lhs < rhs)
+                return 1;
+        else if (lhs == rhs)
+                return 0;
 
-Cache *
-client()
-{
-        return instance_.get();
+        return -1;
 }
-} // namespace cache
+
 
 Cache::Cache(const QString &userId, QObject *parent)
   : QObject{parent}
@@ -2321,20 +2313,6 @@ from_json(const json &j, RoomInfo &info)
                 info.tags = j.at("tags").get<std::vector<std::string>>();
 }
 
-int
-numeric_key_comparison(const MDB_val *a, const MDB_val *b)
-{
-        auto lhs = std::stoull(std::string((char *)a->mv_data, a->mv_size));
-        auto rhs = std::stoull(std::string((char *)b->mv_data, b->mv_size));
-
-        if (lhs < rhs)
-                return 1;
-        else if (lhs == rhs)
-                return 0;
-
-        return -1;
-}
-
 void
 to_json(json &j, const ReadReceiptKey &key)
 {
@@ -2407,3 +2385,520 @@ from_json(const nlohmann::json &obj, MegolmSessionIndex &msg)
         msg.session_id = obj.at("session_id");
         msg.sender_key = obj.at("sender_key");
 }
+
+namespace cache {
+void
+init(const QString &user_id)
+{
+        qRegisterMetaType<SearchResult>();
+        qRegisterMetaType<QVector<SearchResult>>();
+        qRegisterMetaType<RoomMember>();
+        qRegisterMetaType<RoomSearchResult>();
+        qRegisterMetaType<RoomInfo>();
+        qRegisterMetaType<QMap<QString, RoomInfo>>();
+        qRegisterMetaType<QMap<QString, mtx::responses::Notifications>>();
+        qRegisterMetaType<std::map<QString, RoomInfo>>();
+        qRegisterMetaType<std::map<QString, mtx::responses::Timeline>>();
+
+        instance_ = std::make_unique<Cache>(user_id);
+}
+
+Cache *
+client()
+{
+        return instance_.get();
+}
+
+std::string
+displayName(const std::string &room_id, const std::string &user_id)
+{
+        return instance_->displayName(room_id, user_id);
+}
+
+QString
+displayName(const QString &room_id, const QString &user_id)
+{
+        return instance_->displayName(room_id, user_id);
+}
+QString
+avatarUrl(const QString &room_id, const QString &user_id)
+{
+        return instance_->avatarUrl(room_id, user_id);
+}
+
+QString
+userColor(const QString &user_id)
+{
+        return instance_->userColor(user_id);
+}
+
+void
+removeDisplayName(const QString &room_id, const QString &user_id)
+{
+        instance_->removeDisplayName(room_id, user_id);
+}
+void
+removeAvatarUrl(const QString &room_id, const QString &user_id)
+{
+        instance_->removeAvatarUrl(room_id, user_id);
+}
+void
+removeUserColor(const QString &user_id)
+{
+        instance_->removeUserColor(user_id);
+}
+
+void
+insertDisplayName(const QString &room_id, const QString &user_id, const QString &display_name)
+{
+        instance_->insertDisplayName(room_id, user_id, display_name);
+}
+void
+insertAvatarUrl(const QString &room_id, const QString &user_id, const QString &avatar_url)
+{
+        instance_->insertAvatarUrl(room_id, user_id, avatar_url);
+}
+void
+insertUserColor(const QString &user_id, const QString &color_name)
+{
+        instance_->insertUserColor(user_id, color_name);
+}
+
+void
+clearUserColors()
+{
+        instance_->clearUserColors();
+}
+
+//! Load saved data for the display names & avatars.
+void
+populateMembers()
+{
+        instance_->populateMembers();
+}
+
+std::vector<std::string>
+joinedRooms()
+{
+        return instance_->joinedRooms();
+}
+
+QMap<QString, RoomInfo>
+roomInfo(bool withInvites)
+{
+        return instance_->roomInfo(withInvites);
+}
+std::map<QString, bool>
+invites()
+{
+        return instance_->invites();
+}
+
+QString
+getRoomName(lmdb::txn &txn, lmdb::dbi &statesdb, lmdb::dbi &membersdb)
+{
+        return instance_->getRoomName(txn, statesdb, membersdb);
+}
+mtx::events::state::JoinRule
+getRoomJoinRule(lmdb::txn &txn, lmdb::dbi &statesdb)
+{
+        return instance_->getRoomJoinRule(txn, statesdb);
+}
+bool
+getRoomGuestAccess(lmdb::txn &txn, lmdb::dbi &statesdb)
+{
+        return instance_->getRoomGuestAccess(txn, statesdb);
+}
+QString
+getRoomTopic(lmdb::txn &txn, lmdb::dbi &statesdb)
+{
+        return instance_->getRoomTopic(txn, statesdb);
+}
+QString
+getRoomAvatarUrl(lmdb::txn &txn, lmdb::dbi &statesdb, lmdb::dbi &membersdb, const QString &room_id)
+{
+        return instance_->getRoomAvatarUrl(txn, statesdb, membersdb, room_id);
+}
+
+QString
+getRoomVersion(lmdb::txn &txn, lmdb::dbi &statesdb)
+{
+        return instance_->getRoomVersion(txn, statesdb);
+}
+
+std::vector<RoomMember>
+getMembers(const std::string &room_id, std::size_t startIndex, std::size_t len)
+{
+        return instance_->getMembers(room_id, startIndex, len);
+}
+
+void
+saveState(const mtx::responses::Sync &res)
+{
+        instance_->saveState(res);
+}
+bool
+isInitialized()
+{
+        return instance_->isInitialized();
+}
+
+std::string
+nextBatchToken()
+{
+        return instance_->nextBatchToken();
+}
+
+void
+deleteData()
+{
+        instance_->deleteData();
+}
+
+void
+removeInvite(lmdb::txn &txn, const std::string &room_id)
+{
+        instance_->removeInvite(txn, room_id);
+}
+void
+removeInvite(const std::string &room_id)
+{
+        instance_->removeInvite(room_id);
+}
+void
+removeRoom(lmdb::txn &txn, const std::string &roomid)
+{
+        instance_->removeRoom(txn, roomid);
+}
+void
+removeRoom(const std::string &roomid)
+{
+        instance_->removeRoom(roomid);
+}
+void
+removeRoom(const QString &roomid)
+{
+        instance_->removeRoom(roomid.toStdString());
+}
+void
+setup()
+{
+        instance_->setup();
+}
+
+bool
+isFormatValid()
+{
+        return instance_->isFormatValid();
+}
+void
+setCurrentFormat()
+{
+        instance_->setCurrentFormat();
+}
+
+std::map<QString, mtx::responses::Timeline>
+roomMessages()
+{
+        return instance_->roomMessages();
+}
+
+QMap<QString, mtx::responses::Notifications>
+getTimelineMentions()
+{
+        return instance_->getTimelineMentions();
+}
+
+//! Retrieve all the user ids from a room.
+std::vector<std::string>
+roomMembers(const std::string &room_id)
+{
+        return instance_->roomMembers(room_id);
+}
+
+//! Check if the given user has power leve greater than than
+//! lowest power level of the given events.
+bool
+hasEnoughPowerLevel(const std::vector<mtx::events::EventType> &eventTypes,
+                    const std::string &room_id,
+                    const std::string &user_id)
+{
+        return instance_->hasEnoughPowerLevel(eventTypes, room_id, user_id);
+}
+
+//! Retrieves the saved room avatar.
+QImage
+getRoomAvatar(const QString &id)
+{
+        return instance_->getRoomAvatar(id);
+}
+QImage
+getRoomAvatar(const std::string &id)
+{
+        return instance_->getRoomAvatar(id);
+}
+
+void
+updateReadReceipt(lmdb::txn &txn, const std::string &room_id, const Receipts &receipts)
+{
+        instance_->updateReadReceipt(txn, room_id, receipts);
+}
+
+UserReceipts
+readReceipts(const QString &event_id, const QString &room_id)
+{
+        return instance_->readReceipts(event_id, room_id);
+}
+
+//! Filter the events that have at least one read receipt.
+std::vector<QString>
+filterReadEvents(const QString &room_id,
+                 const std::vector<QString> &event_ids,
+                 const std::string &excluded_user)
+{
+        return instance_->filterReadEvents(room_id, event_ids, excluded_user);
+}
+//! Add event for which we are expecting some read receipts.
+void
+addPendingReceipt(const QString &room_id, const QString &event_id)
+{
+        instance_->addPendingReceipt(room_id, event_id);
+}
+void
+removePendingReceipt(lmdb::txn &txn, const std::string &room_id, const std::string &event_id)
+{
+        instance_->removePendingReceipt(txn, room_id, event_id);
+}
+void
+notifyForReadReceipts(const std::string &room_id)
+{
+        instance_->notifyForReadReceipts(room_id);
+}
+std::vector<QString>
+pendingReceiptsEvents(lmdb::txn &txn, const std::string &room_id)
+{
+        return instance_->pendingReceiptsEvents(txn, room_id);
+}
+
+QByteArray
+image(const QString &url)
+{
+        return instance_->image(url);
+}
+QByteArray
+image(lmdb::txn &txn, const std::string &url)
+{
+        return instance_->image(txn, url);
+}
+void
+saveImage(const std::string &url, const std::string &data)
+{
+        instance_->saveImage(url, data);
+}
+void
+saveImage(const QString &url, const QByteArray &data)
+{
+        instance_->saveImage(url, data);
+}
+
+RoomInfo
+singleRoomInfo(const std::string &room_id)
+{
+        return instance_->singleRoomInfo(room_id);
+}
+std::vector<std::string>
+roomsWithStateUpdates(const mtx::responses::Sync &res)
+{
+        return instance_->roomsWithStateUpdates(res);
+}
+std::vector<std::string>
+roomsWithTagUpdates(const mtx::responses::Sync &res)
+{
+        return instance_->roomsWithTagUpdates(res);
+}
+std::map<QString, RoomInfo>
+getRoomInfo(const std::vector<std::string> &rooms)
+{
+        return instance_->getRoomInfo(rooms);
+}
+
+//! Calculates which the read status of a room.
+//! Whether all the events in the timeline have been read.
+bool
+calculateRoomReadStatus(const std::string &room_id)
+{
+        return instance_->calculateRoomReadStatus(room_id);
+}
+void
+calculateRoomReadStatus()
+{
+        instance_->calculateRoomReadStatus();
+}
+
+QVector<SearchResult>
+searchUsers(const std::string &room_id, const std::string &query, std::uint8_t max_items)
+{
+        return instance_->searchUsers(room_id, query, max_items);
+}
+std::vector<RoomSearchResult>
+searchRooms(const std::string &query, std::uint8_t max_items)
+{
+        return instance_->searchRooms(query, max_items);
+}
+
+void
+markSentNotification(const std::string &event_id)
+{
+        instance_->markSentNotification(event_id);
+}
+//! Removes an event from the sent notifications.
+void
+removeReadNotification(const std::string &event_id)
+{
+        instance_->removeReadNotification(event_id);
+}
+//! Check if we have sent a desktop notification for the given event id.
+bool
+isNotificationSent(const std::string &event_id)
+{
+        return instance_->isNotificationSent(event_id);
+}
+
+//! Add all notifications containing a user mention to the db.
+void
+saveTimelineMentions(const mtx::responses::Notifications &res)
+{
+        instance_->saveTimelineMentions(res);
+}
+
+//! Remove old unused data.
+void
+deleteOldMessages()
+{
+        instance_->deleteOldMessages();
+}
+void
+deleteOldData() noexcept
+{
+        instance_->deleteOldData();
+}
+//! Retrieve all saved room ids.
+std::vector<std::string>
+getRoomIds(lmdb::txn &txn)
+{
+        return instance_->getRoomIds(txn);
+}
+
+//! Mark a room that uses e2e encryption.
+void
+setEncryptedRoom(lmdb::txn &txn, const std::string &room_id)
+{
+        instance_->setEncryptedRoom(txn, room_id);
+}
+bool
+isRoomEncrypted(const std::string &room_id)
+{
+        return instance_->isRoomEncrypted(room_id);
+}
+
+//! Check if a user is a member of the room.
+bool
+isRoomMember(const std::string &user_id, const std::string &room_id)
+{
+        return instance_->isRoomMember(user_id, room_id);
+}
+
+//
+// Outbound Megolm Sessions
+//
+void
+saveOutboundMegolmSession(const std::string &room_id,
+                          const OutboundGroupSessionData &data,
+                          mtx::crypto::OutboundGroupSessionPtr session)
+{
+        instance_->saveOutboundMegolmSession(room_id, data, std::move(session));
+}
+OutboundGroupSessionDataRef
+getOutboundMegolmSession(const std::string &room_id)
+{
+        return instance_->getOutboundMegolmSession(room_id);
+}
+bool
+outboundMegolmSessionExists(const std::string &room_id) noexcept
+{
+        return instance_->outboundMegolmSessionExists(room_id);
+}
+void
+updateOutboundMegolmSession(const std::string &room_id, int message_index)
+{
+        instance_->updateOutboundMegolmSession(room_id, message_index);
+}
+
+void
+importSessionKeys(const mtx::crypto::ExportedSessionKeys &keys)
+{
+        instance_->importSessionKeys(keys);
+}
+mtx::crypto::ExportedSessionKeys
+exportSessionKeys()
+{
+        return instance_->exportSessionKeys();
+}
+
+//
+// Inbound Megolm Sessions
+//
+void
+saveInboundMegolmSession(const MegolmSessionIndex &index,
+                         mtx::crypto::InboundGroupSessionPtr session)
+{
+        instance_->saveInboundMegolmSession(index, std::move(session));
+}
+OlmInboundGroupSession *
+getInboundMegolmSession(const MegolmSessionIndex &index)
+{
+        return instance_->getInboundMegolmSession(index);
+}
+bool
+inboundMegolmSessionExists(const MegolmSessionIndex &index)
+{
+        return instance_->inboundMegolmSessionExists(index);
+}
+
+//
+// Olm Sessions
+//
+void
+saveOlmSession(const std::string &curve25519, mtx::crypto::OlmSessionPtr session)
+{
+        instance_->saveOlmSession(curve25519, std::move(session));
+}
+std::vector<std::string>
+getOlmSessions(const std::string &curve25519)
+{
+        return instance_->getOlmSessions(curve25519);
+}
+std::optional<mtx::crypto::OlmSessionPtr>
+getOlmSession(const std::string &curve25519, const std::string &session_id)
+{
+        return instance_->getOlmSession(curve25519, session_id);
+}
+
+void
+saveOlmAccount(const std::string &pickled)
+{
+        instance_->saveOlmAccount(pickled);
+}
+std::string
+restoreOlmAccount()
+{
+        return instance_->restoreOlmAccount();
+}
+
+void
+restoreSessions()
+{
+        return instance_->restoreSessions();
+}
+} // namespace cache
+
diff --git a/src/Cache.h b/src/Cache.h
index 02346287..da4e2040 100644
--- a/src/Cache.h
+++ b/src/Cache.h
@@ -17,501 +17,285 @@
 
 #pragma once
 
-#include <mutex>
-#include <optional>
-
 #include <QDateTime>
 #include <QDir>
 #include <QImage>
 #include <QString>
 
 #include <lmdb++.h>
-#include <nlohmann/json.hpp>
 
 #include <mtx/responses.hpp>
-#include <mtxclient/crypto/client.hpp>
 
 #include "CacheCryptoStructs.h"
 #include "CacheStructs.h"
-#include "Logging.h"
-#include "MatrixClient.h"
 
-int
-numeric_key_comparison(const MDB_val *a, const MDB_val *b);
+namespace cache {
+void
+init(const QString &user_id);
+
+std::string
+displayName(const std::string &room_id, const std::string &user_id);
+QString
+displayName(const QString &room_id, const QString &user_id);
+QString
+avatarUrl(const QString &room_id, const QString &user_id);
+QString
+userColor(const QString &user_id);
+
+void
+removeDisplayName(const QString &room_id, const QString &user_id);
+void
+removeAvatarUrl(const QString &room_id, const QString &user_id);
+void
+removeUserColor(const QString &user_id);
+
+void
+insertDisplayName(const QString &room_id, const QString &user_id, const QString &display_name);
+void
+insertAvatarUrl(const QString &room_id, const QString &user_id, const QString &avatar_url);
+void
+insertUserColor(const QString &user_id, const QString &color_name);
+
+void
+clearUserColors();
+
+//! Load saved data for the display names & avatars.
+void
+populateMembers();
+std::vector<std::string>
+joinedRooms();
+
+QMap<QString, RoomInfo>
+roomInfo(bool withInvites = true);
+std::map<QString, bool>
+invites();
+
+//! Calculate & return the name of the room.
+QString
+getRoomName(lmdb::txn &txn, lmdb::dbi &statesdb, lmdb::dbi &membersdb);
+//! Get room join rules
+mtx::events::state::JoinRule
+getRoomJoinRule(lmdb::txn &txn, lmdb::dbi &statesdb);
+bool
+getRoomGuestAccess(lmdb::txn &txn, lmdb::dbi &statesdb);
+//! Retrieve the topic of the room if any.
+QString
+getRoomTopic(lmdb::txn &txn, lmdb::dbi &statesdb);
+//! Retrieve the room avatar's url if any.
+QString
+getRoomAvatarUrl(lmdb::txn &txn, lmdb::dbi &statesdb, lmdb::dbi &membersdb, const QString &room_id);
+//! Retrieve the version of the room if any.
+QString
+getRoomVersion(lmdb::txn &txn, lmdb::dbi &statesdb);
+
+//! Retrieve member info from a room.
+std::vector<RoomMember>
+getMembers(const std::string &room_id, std::size_t startIndex = 0, std::size_t len = 30);
 
-class Cache : public QObject
+void
+saveState(const mtx::responses::Sync &res);
+bool
+isInitialized();
+
+std::string
+nextBatchToken();
+
+void
+deleteData();
+
+void
+removeInvite(lmdb::txn &txn, const std::string &room_id);
+void
+removeInvite(const std::string &room_id);
+void
+removeRoom(lmdb::txn &txn, const std::string &roomid);
+void
+removeRoom(const std::string &roomid);
+void
+removeRoom(const QString &roomid);
+void
+setup();
+
+bool
+isFormatValid();
+void
+setCurrentFormat();
+
+std::map<QString, mtx::responses::Timeline>
+roomMessages();
+
+QMap<QString, mtx::responses::Notifications>
+getTimelineMentions();
+
+//! Retrieve all the user ids from a room.
+std::vector<std::string>
+roomMembers(const std::string &room_id);
+
+//! Check if the given user has power leve greater than than
+//! lowest power level of the given events.
+bool
+hasEnoughPowerLevel(const std::vector<mtx::events::EventType> &eventTypes,
+                    const std::string &room_id,
+                    const std::string &user_id);
+
+//! Retrieves the saved room avatar.
+QImage
+getRoomAvatar(const QString &id);
+QImage
+getRoomAvatar(const std::string &id);
+
+//! Adds a user to the read list for the given event.
+//!
+//! There should be only one user id present in a receipt list per room.
+//! The user id should be removed from any other lists.
+using Receipts = std::map<std::string, std::map<std::string, uint64_t>>;
+void
+updateReadReceipt(lmdb::txn &txn, const std::string &room_id, const Receipts &receipts);
+
+//! Retrieve all the read receipts for the given event id and room.
+//!
+//! Returns a map of user ids and the time of the read receipt in milliseconds.
+using UserReceipts = std::multimap<uint64_t, std::string, std::greater<uint64_t>>;
+UserReceipts
+readReceipts(const QString &event_id, const QString &room_id);
+
+//! Filter the events that have at least one read receipt.
+std::vector<QString>
+filterReadEvents(const QString &room_id,
+                 const std::vector<QString> &event_ids,
+                 const std::string &excluded_user);
+//! Add event for which we are expecting some read receipts.
+void
+addPendingReceipt(const QString &room_id, const QString &event_id);
+void
+removePendingReceipt(lmdb::txn &txn, const std::string &room_id, const std::string &event_id);
+void
+notifyForReadReceipts(const std::string &room_id);
+std::vector<QString>
+pendingReceiptsEvents(lmdb::txn &txn, const std::string &room_id);
+
+QByteArray
+image(const QString &url);
+QByteArray
+image(lmdb::txn &txn, const std::string &url);
+inline QByteArray
+image(const std::string &url)
+{
+        return image(QString::fromStdString(url));
+}
+void
+saveImage(const std::string &url, const std::string &data);
+void
+saveImage(const QString &url, const QByteArray &data);
+
+RoomInfo
+singleRoomInfo(const std::string &room_id);
+std::vector<std::string>
+roomsWithStateUpdates(const mtx::responses::Sync &res);
+std::vector<std::string>
+roomsWithTagUpdates(const mtx::responses::Sync &res);
+std::map<QString, RoomInfo>
+getRoomInfo(const std::vector<std::string> &rooms);
+inline std::map<QString, RoomInfo>
+roomUpdates(const mtx::responses::Sync &sync)
 {
-        Q_OBJECT
-
-public:
-        Cache(const QString &userId, QObject *parent = nullptr);
-
-        static QHash<QString, QString> DisplayNames;
-        static QHash<QString, QString> AvatarUrls;
-        static QHash<QString, QString> UserColors;
-
-        static std::string displayName(const std::string &room_id, const std::string &user_id);
-        static QString displayName(const QString &room_id, const QString &user_id);
-        static QString avatarUrl(const QString &room_id, const QString &user_id);
-        static QString userColor(const QString &user_id);
-
-        static void removeDisplayName(const QString &room_id, const QString &user_id);
-        static void removeAvatarUrl(const QString &room_id, const QString &user_id);
-        static void removeUserColor(const QString &user_id);
-
-        static void insertDisplayName(const QString &room_id,
-                                      const QString &user_id,
-                                      const QString &display_name);
-        static void insertAvatarUrl(const QString &room_id,
-                                    const QString &user_id,
-                                    const QString &avatar_url);
-        static void insertUserColor(const QString &user_id, const QString &color_name);
-
-        static void clearUserColors();
-
-        //! Load saved data for the display names & avatars.
-        void populateMembers();
-        std::vector<std::string> joinedRooms();
-
-        QMap<QString, RoomInfo> roomInfo(bool withInvites = true);
-        std::map<QString, bool> invites();
-
-        //! Calculate & return the name of the room.
-        QString getRoomName(lmdb::txn &txn, lmdb::dbi &statesdb, lmdb::dbi &membersdb);
-        //! Get room join rules
-        mtx::events::state::JoinRule getRoomJoinRule(lmdb::txn &txn, lmdb::dbi &statesdb);
-        bool getRoomGuestAccess(lmdb::txn &txn, lmdb::dbi &statesdb);
-        //! Retrieve the topic of the room if any.
-        QString getRoomTopic(lmdb::txn &txn, lmdb::dbi &statesdb);
-        //! Retrieve the room avatar's url if any.
-        QString getRoomAvatarUrl(lmdb::txn &txn,
-                                 lmdb::dbi &statesdb,
-                                 lmdb::dbi &membersdb,
-                                 const QString &room_id);
-        //! Retrieve the version of the room if any.
-        QString getRoomVersion(lmdb::txn &txn, lmdb::dbi &statesdb);
-
-        //! Retrieve member info from a room.
-        std::vector<RoomMember> getMembers(const std::string &room_id,
-                                           std::size_t startIndex = 0,
-                                           std::size_t len        = 30);
-
-        void saveState(const mtx::responses::Sync &res);
-        bool isInitialized() const;
-
-        std::string nextBatchToken() const;
-
-        void deleteData();
-
-        void removeInvite(lmdb::txn &txn, const std::string &room_id);
-        void removeInvite(const std::string &room_id);
-        void removeRoom(lmdb::txn &txn, const std::string &roomid);
-        void removeRoom(const std::string &roomid);
-        void removeRoom(const QString &roomid) { removeRoom(roomid.toStdString()); };
-        void setup();
-
-        bool isFormatValid();
-        void setCurrentFormat();
-
-        std::map<QString, mtx::responses::Timeline> roomMessages();
-
-        QMap<QString, mtx::responses::Notifications> getTimelineMentions();
-
-        //! Retrieve all the user ids from a room.
-        std::vector<std::string> roomMembers(const std::string &room_id);
-
-        //! Check if the given user has power leve greater than than
-        //! lowest power level of the given events.
-        bool hasEnoughPowerLevel(const std::vector<mtx::events::EventType> &eventTypes,
-                                 const std::string &room_id,
-                                 const std::string &user_id);
-
-        //! Retrieves the saved room avatar.
-        QImage getRoomAvatar(const QString &id);
-        QImage getRoomAvatar(const std::string &id);
-
-        //! Adds a user to the read list for the given event.
-        //!
-        //! There should be only one user id present in a receipt list per room.
-        //! The user id should be removed from any other lists.
-        using Receipts = std::map<std::string, std::map<std::string, uint64_t>>;
-        void updateReadReceipt(lmdb::txn &txn,
-                               const std::string &room_id,
-                               const Receipts &receipts);
-
-        //! Retrieve all the read receipts for the given event id and room.
-        //!
-        //! Returns a map of user ids and the time of the read receipt in milliseconds.
-        using UserReceipts = std::multimap<uint64_t, std::string, std::greater<uint64_t>>;
-        UserReceipts readReceipts(const QString &event_id, const QString &room_id);
-
-        //! Filter the events that have at least one read receipt.
-        std::vector<QString> filterReadEvents(const QString &room_id,
-                                              const std::vector<QString> &event_ids,
-                                              const std::string &excluded_user);
-        //! Add event for which we are expecting some read receipts.
-        void addPendingReceipt(const QString &room_id, const QString &event_id);
-        void removePendingReceipt(lmdb::txn &txn,
-                                  const std::string &room_id,
-                                  const std::string &event_id);
-        void notifyForReadReceipts(const std::string &room_id);
-        std::vector<QString> pendingReceiptsEvents(lmdb::txn &txn, const std::string &room_id);
-
-        QByteArray image(const QString &url) const;
-        QByteArray image(lmdb::txn &txn, const std::string &url) const;
-        QByteArray image(const std::string &url) const
-        {
-                return image(QString::fromStdString(url));
-        }
-        void saveImage(const std::string &url, const std::string &data);
-        void saveImage(const QString &url, const QByteArray &data);
-
-        RoomInfo singleRoomInfo(const std::string &room_id);
-        std::vector<std::string> roomsWithStateUpdates(const mtx::responses::Sync &res);
-        std::vector<std::string> roomsWithTagUpdates(const mtx::responses::Sync &res);
-        std::map<QString, RoomInfo> getRoomInfo(const std::vector<std::string> &rooms);
-        std::map<QString, RoomInfo> roomUpdates(const mtx::responses::Sync &sync)
-        {
-                return getRoomInfo(roomsWithStateUpdates(sync));
-        }
-        std::map<QString, RoomInfo> roomTagUpdates(const mtx::responses::Sync &sync)
-        {
-                return getRoomInfo(roomsWithTagUpdates(sync));
-        }
-
-        //! Calculates which the read status of a room.
-        //! Whether all the events in the timeline have been read.
-        bool calculateRoomReadStatus(const std::string &room_id);
-        void calculateRoomReadStatus();
-
-        QVector<SearchResult> searchUsers(const std::string &room_id,
-                                          const std::string &query,
-                                          std::uint8_t max_items = 5);
-        std::vector<RoomSearchResult> searchRooms(const std::string &query,
-                                                  std::uint8_t max_items = 5);
-
-        void markSentNotification(const std::string &event_id);
-        //! Removes an event from the sent notifications.
-        void removeReadNotification(const std::string &event_id);
-        //! Check if we have sent a desktop notification for the given event id.
-        bool isNotificationSent(const std::string &event_id);
-
-        //! Add all notifications containing a user mention to the db.
-        void saveTimelineMentions(const mtx::responses::Notifications &res);
-
-        //! Remove old unused data.
-        void deleteOldMessages();
-        void deleteOldData() noexcept;
-        //! Retrieve all saved room ids.
-        std::vector<std::string> getRoomIds(lmdb::txn &txn);
-
-        //! Mark a room that uses e2e encryption.
-        void setEncryptedRoom(lmdb::txn &txn, const std::string &room_id);
-        bool isRoomEncrypted(const std::string &room_id);
-
-        //! Save the public keys for a device.
-        void saveDeviceKeys(const std::string &device_id);
-        void getDeviceKeys(const std::string &device_id);
-
-        //! Save the device list for a user.
-        void setDeviceList(const std::string &user_id, const std::vector<std::string> &devices);
-        std::vector<std::string> getDeviceList(const std::string &user_id);
-
-        //! Check if a user is a member of the room.
-        bool isRoomMember(const std::string &user_id, const std::string &room_id);
-
-        //
-        // Outbound Megolm Sessions
-        //
-        void saveOutboundMegolmSession(const std::string &room_id,
-                                       const OutboundGroupSessionData &data,
-                                       mtx::crypto::OutboundGroupSessionPtr session);
-        OutboundGroupSessionDataRef getOutboundMegolmSession(const std::string &room_id);
-        bool outboundMegolmSessionExists(const std::string &room_id) noexcept;
-        void updateOutboundMegolmSession(const std::string &room_id, int message_index);
-
-        void importSessionKeys(const mtx::crypto::ExportedSessionKeys &keys);
-        mtx::crypto::ExportedSessionKeys exportSessionKeys();
-
-        //
-        // Inbound Megolm Sessions
-        //
-        void saveInboundMegolmSession(const MegolmSessionIndex &index,
-                                      mtx::crypto::InboundGroupSessionPtr session);
-        OlmInboundGroupSession *getInboundMegolmSession(const MegolmSessionIndex &index);
-        bool inboundMegolmSessionExists(const MegolmSessionIndex &index);
-
-        //
-        // Olm Sessions
-        //
-        void saveOlmSession(const std::string &curve25519, mtx::crypto::OlmSessionPtr session);
-        std::vector<std::string> getOlmSessions(const std::string &curve25519);
-        std::optional<mtx::crypto::OlmSessionPtr> getOlmSession(const std::string &curve25519,
-                                                                const std::string &session_id);
-
-        void saveOlmAccount(const std::string &pickled);
-        std::string restoreOlmAccount();
-
-        void restoreSessions();
-
-        OlmSessionStorage session_storage;
-
-signals:
-        void newReadReceipts(const QString &room_id, const std::vector<QString> &event_ids);
-        void roomReadStatus(const std::map<QString, bool> &status);
-
-private:
-        //! Save an invited room.
-        void saveInvite(lmdb::txn &txn,
-                        lmdb::dbi &statesdb,
-                        lmdb::dbi &membersdb,
-                        const mtx::responses::InvitedRoom &room);
-
-        //! Add a notification containing a user mention to the db.
-        void saveTimelineMentions(lmdb::txn &txn,
-                                  const std::string &room_id,
-                                  const QList<mtx::responses::Notification> &res);
-
-        //! Get timeline items that a user was mentions in for a given room
-        mtx::responses::Notifications getTimelineMentionsForRoom(lmdb::txn &txn,
-                                                                 const std::string &room_id);
-
-        QString getInviteRoomName(lmdb::txn &txn, lmdb::dbi &statesdb, lmdb::dbi &membersdb);
-        QString getInviteRoomTopic(lmdb::txn &txn, lmdb::dbi &statesdb);
-        QString getInviteRoomAvatarUrl(lmdb::txn &txn, lmdb::dbi &statesdb, lmdb::dbi &membersdb);
-
-        DescInfo getLastMessageInfo(lmdb::txn &txn, const std::string &room_id);
-        void saveTimelineMessages(lmdb::txn &txn,
-                                  const std::string &room_id,
-                                  const mtx::responses::Timeline &res);
-
-        mtx::responses::Timeline getTimelineMessages(lmdb::txn &txn, const std::string &room_id);
-
-        //! Remove a room from the cache.
-        // void removeLeftRoom(lmdb::txn &txn, const std::string &room_id);
-        template<class T>
-        void saveStateEvents(lmdb::txn &txn,
-                             const lmdb::dbi &statesdb,
-                             const lmdb::dbi &membersdb,
-                             const std::string &room_id,
-                             const std::vector<T> &events)
-        {
-                for (const auto &e : events)
-                        saveStateEvent(txn, statesdb, membersdb, room_id, e);
-        }
-
-        template<class T>
-        void saveStateEvent(lmdb::txn &txn,
-                            const lmdb::dbi &statesdb,
-                            const lmdb::dbi &membersdb,
-                            const std::string &room_id,
-                            const T &event)
-        {
-                using namespace mtx::events;
-                using namespace mtx::events::state;
-
-                if (auto e = std::get_if<StateEvent<Member>>(&event); e != nullptr) {
-                        switch (e->content.membership) {
-                        //
-                        // We only keep users with invite or join membership.
-                        //
-                        case Membership::Invite:
-                        case Membership::Join: {
-                                auto display_name = e->content.display_name.empty()
-                                                      ? e->state_key
-                                                      : e->content.display_name;
-
-                                // Lightweight representation of a member.
-                                MemberInfo tmp{display_name, e->content.avatar_url};
-
-                                lmdb::dbi_put(txn,
-                                              membersdb,
-                                              lmdb::val(e->state_key),
-                                              lmdb::val(json(tmp).dump()));
-
-                                insertDisplayName(QString::fromStdString(room_id),
-                                                  QString::fromStdString(e->state_key),
-                                                  QString::fromStdString(display_name));
-
-                                insertAvatarUrl(QString::fromStdString(room_id),
-                                                QString::fromStdString(e->state_key),
-                                                QString::fromStdString(e->content.avatar_url));
-
-                                break;
-                        }
-                        default: {
-                                lmdb::dbi_del(
-                                  txn, membersdb, lmdb::val(e->state_key), lmdb::val(""));
-
-                                removeDisplayName(QString::fromStdString(room_id),
-                                                  QString::fromStdString(e->state_key));
-                                removeAvatarUrl(QString::fromStdString(room_id),
-                                                QString::fromStdString(e->state_key));
-
-                                break;
-                        }
-                        }
-
-                        return;
-                } else if (std::holds_alternative<StateEvent<Encryption>>(event)) {
-                        setEncryptedRoom(txn, room_id);
-                        return;
-                }
-
-                if (!isStateEvent(event))
-                        return;
-
-                std::visit(
-                  [&txn, &statesdb](auto e) {
-                          lmdb::dbi_put(
-                            txn, statesdb, lmdb::val(to_string(e.type)), lmdb::val(json(e).dump()));
-                  },
-                  event);
-        }
-
-        template<class T>
-        bool isStateEvent(const T &e)
-        {
-                using namespace mtx::events;
-                using namespace mtx::events::state;
-
-                return std::holds_alternative<StateEvent<Aliases>>(e) ||
-                       std::holds_alternative<StateEvent<state::Avatar>>(e) ||
-                       std::holds_alternative<StateEvent<CanonicalAlias>>(e) ||
-                       std::holds_alternative<StateEvent<Create>>(e) ||
-                       std::holds_alternative<StateEvent<GuestAccess>>(e) ||
-                       std::holds_alternative<StateEvent<HistoryVisibility>>(e) ||
-                       std::holds_alternative<StateEvent<JoinRules>>(e) ||
-                       std::holds_alternative<StateEvent<Name>>(e) ||
-                       std::holds_alternative<StateEvent<Member>>(e) ||
-                       std::holds_alternative<StateEvent<PowerLevels>>(e) ||
-                       std::holds_alternative<StateEvent<Topic>>(e);
-        }
-
-        template<class T>
-        bool containsStateUpdates(const T &e)
-        {
-                using namespace mtx::events;
-                using namespace mtx::events::state;
-
-                return std::holds_alternative<StateEvent<state::Avatar>>(e) ||
-                       std::holds_alternative<StateEvent<CanonicalAlias>>(e) ||
-                       std::holds_alternative<StateEvent<Name>>(e) ||
-                       std::holds_alternative<StateEvent<Member>>(e) ||
-                       std::holds_alternative<StateEvent<Topic>>(e);
-        }
-
-        bool containsStateUpdates(const mtx::events::collections::StrippedEvents &e)
-        {
-                using namespace mtx::events;
-                using namespace mtx::events::state;
-
-                return std::holds_alternative<StrippedEvent<state::Avatar>>(e) ||
-                       std::holds_alternative<StrippedEvent<CanonicalAlias>>(e) ||
-                       std::holds_alternative<StrippedEvent<Name>>(e) ||
-                       std::holds_alternative<StrippedEvent<Member>>(e) ||
-                       std::holds_alternative<StrippedEvent<Topic>>(e);
-        }
-
-        void saveInvites(lmdb::txn &txn,
-                         const std::map<std::string, mtx::responses::InvitedRoom> &rooms);
-
-        //! Sends signals for the rooms that are removed.
-        void removeLeftRooms(lmdb::txn &txn,
-                             const std::map<std::string, mtx::responses::LeftRoom> &rooms)
-        {
-                for (const auto &room : rooms) {
-                        removeRoom(txn, room.first);
-
-                        // Clean up leftover invites.
-                        removeInvite(txn, room.first);
-                }
-        }
-
-        lmdb::dbi getPendingReceiptsDb(lmdb::txn &txn)
-        {
-                return lmdb::dbi::open(txn, "pending_receipts", MDB_CREATE);
-        }
-
-        lmdb::dbi getMessagesDb(lmdb::txn &txn, const std::string &room_id)
-        {
-                auto db =
-                  lmdb::dbi::open(txn, std::string(room_id + "/messages").c_str(), MDB_CREATE);
-                lmdb::dbi_set_compare(txn, db, numeric_key_comparison);
-
-                return db;
-        }
-
-        lmdb::dbi getInviteStatesDb(lmdb::txn &txn, const std::string &room_id)
-        {
-                return lmdb::dbi::open(
-                  txn, std::string(room_id + "/invite_state").c_str(), MDB_CREATE);
-        }
-
-        lmdb::dbi getInviteMembersDb(lmdb::txn &txn, const std::string &room_id)
-        {
-                return lmdb::dbi::open(
-                  txn, std::string(room_id + "/invite_members").c_str(), MDB_CREATE);
-        }
-
-        lmdb::dbi getStatesDb(lmdb::txn &txn, const std::string &room_id)
-        {
-                return lmdb::dbi::open(txn, std::string(room_id + "/state").c_str(), MDB_CREATE);
-        }
-
-        lmdb::dbi getMembersDb(lmdb::txn &txn, const std::string &room_id)
-        {
-                return lmdb::dbi::open(txn, std::string(room_id + "/members").c_str(), MDB_CREATE);
-        }
-
-        lmdb::dbi getMentionsDb(lmdb::txn &txn, const std::string &room_id)
-        {
-                return lmdb::dbi::open(txn, std::string(room_id + "/mentions").c_str(), MDB_CREATE);
-        }
-
-        //! Retrieves or creates the database that stores the open OLM sessions between our device
-        //! and the given curve25519 key which represents another device.
-        //!
-        //! Each entry is a map from the session_id to the pickled representation of the session.
-        lmdb::dbi getOlmSessionsDb(lmdb::txn &txn, const std::string &curve25519_key)
-        {
-                return lmdb::dbi::open(
-                  txn, std::string("olm_sessions/" + curve25519_key).c_str(), MDB_CREATE);
-        }
-
-        QString getDisplayName(const mtx::events::StateEvent<mtx::events::state::Member> &event)
-        {
-                if (!event.content.display_name.empty())
-                        return QString::fromStdString(event.content.display_name);
-
-                return QString::fromStdString(event.state_key);
-        }
-
-        void setNextBatchToken(lmdb::txn &txn, const std::string &token);
-        void setNextBatchToken(lmdb::txn &txn, const QString &token);
-
-        lmdb::env env_;
-        lmdb::dbi syncStateDb_;
-        lmdb::dbi roomsDb_;
-        lmdb::dbi invitesDb_;
-        lmdb::dbi mediaDb_;
-        lmdb::dbi readReceiptsDb_;
-        lmdb::dbi notificationsDb_;
-
-        lmdb::dbi devicesDb_;
-        lmdb::dbi deviceKeysDb_;
-
-        lmdb::dbi inboundMegolmSessionDb_;
-        lmdb::dbi outboundMegolmSessionDb_;
-
-        QString localUserId_;
-        QString cacheDirectory_;
-};
+        return getRoomInfo(roomsWithStateUpdates(sync));
+}
+inline std::map<QString, RoomInfo>
+roomTagUpdates(const mtx::responses::Sync &sync)
+{
+        return getRoomInfo(roomsWithTagUpdates(sync));
+}
 
-namespace cache {
+//! Calculates which the read status of a room.
+//! Whether all the events in the timeline have been read.
+bool
+calculateRoomReadStatus(const std::string &room_id);
 void
-init(const QString &user_id);
+calculateRoomReadStatus();
+
+QVector<SearchResult>
+searchUsers(const std::string &room_id, const std::string &query, std::uint8_t max_items = 5);
+std::vector<RoomSearchResult>
+searchRooms(const std::string &query, std::uint8_t max_items = 5);
+
+void
+markSentNotification(const std::string &event_id);
+//! Removes an event from the sent notifications.
+void
+removeReadNotification(const std::string &event_id);
+//! Check if we have sent a desktop notification for the given event id.
+bool
+isNotificationSent(const std::string &event_id);
+
+//! Add all notifications containing a user mention to the db.
+void
+saveTimelineMentions(const mtx::responses::Notifications &res);
 
-Cache *
-client();
+//! Remove old unused data.
+void
+deleteOldMessages();
+void
+deleteOldData() noexcept;
+//! Retrieve all saved room ids.
+std::vector<std::string>
+getRoomIds(lmdb::txn &txn);
+
+//! Mark a room that uses e2e encryption.
+void
+setEncryptedRoom(lmdb::txn &txn, const std::string &room_id);
+bool
+isRoomEncrypted(const std::string &room_id);
+
+//! Check if a user is a member of the room.
+bool
+isRoomMember(const std::string &user_id, const std::string &room_id);
+
+//
+// Outbound Megolm Sessions
+//
+void
+saveOutboundMegolmSession(const std::string &room_id,
+                          const OutboundGroupSessionData &data,
+                          mtx::crypto::OutboundGroupSessionPtr session);
+OutboundGroupSessionDataRef
+getOutboundMegolmSession(const std::string &room_id);
+bool
+outboundMegolmSessionExists(const std::string &room_id) noexcept;
+void
+updateOutboundMegolmSession(const std::string &room_id, int message_index);
+
+void
+importSessionKeys(const mtx::crypto::ExportedSessionKeys &keys);
+mtx::crypto::ExportedSessionKeys
+exportSessionKeys();
+
+//
+// Inbound Megolm Sessions
+//
+void
+saveInboundMegolmSession(const MegolmSessionIndex &index,
+                         mtx::crypto::InboundGroupSessionPtr session);
+OlmInboundGroupSession *
+getInboundMegolmSession(const MegolmSessionIndex &index);
+bool
+inboundMegolmSessionExists(const MegolmSessionIndex &index);
+
+//
+// Olm Sessions
+//
+void
+saveOlmSession(const std::string &curve25519, mtx::crypto::OlmSessionPtr session);
+std::vector<std::string>
+getOlmSessions(const std::string &curve25519);
+std::optional<mtx::crypto::OlmSessionPtr>
+getOlmSession(const std::string &curve25519, const std::string &session_id);
+
+void
+saveOlmAccount(const std::string &pickled);
+std::string
+restoreOlmAccount();
+
+void
+restoreSessions();
 }
diff --git a/src/Cache_p.h b/src/Cache_p.h
new file mode 100644
index 00000000..47dd945a
--- /dev/null
+++ b/src/Cache_p.h
@@ -0,0 +1,494 @@
+/*
+ * nheko Copyright (C) 2019  The nheko authors
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <mutex>
+#include <optional>
+
+#include <QDateTime>
+#include <QDir>
+#include <QImage>
+#include <QString>
+
+#include <lmdb++.h>
+#include <nlohmann/json.hpp>
+
+#include <mtx/responses.hpp>
+#include <mtxclient/crypto/client.hpp>
+
+#include "CacheCryptoStructs.h"
+#include "CacheStructs.h"
+#include "Logging.h"
+#include "MatrixClient.h"
+
+int
+numeric_key_comparison(const MDB_val *a, const MDB_val *b);
+
+class Cache : public QObject
+{
+        Q_OBJECT
+
+public:
+        Cache(const QString &userId, QObject *parent = nullptr);
+
+        static std::string displayName(const std::string &room_id, const std::string &user_id);
+        static QString displayName(const QString &room_id, const QString &user_id);
+        static QString avatarUrl(const QString &room_id, const QString &user_id);
+        static QString userColor(const QString &user_id);
+
+        static void removeDisplayName(const QString &room_id, const QString &user_id);
+        static void removeAvatarUrl(const QString &room_id, const QString &user_id);
+        static void removeUserColor(const QString &user_id);
+
+        static void insertDisplayName(const QString &room_id,
+                                      const QString &user_id,
+                                      const QString &display_name);
+        static void insertAvatarUrl(const QString &room_id,
+                                    const QString &user_id,
+                                    const QString &avatar_url);
+        static void insertUserColor(const QString &user_id, const QString &color_name);
+
+        static void clearUserColors();
+
+        //! Load saved data for the display names & avatars.
+        void populateMembers();
+        std::vector<std::string> joinedRooms();
+
+        QMap<QString, RoomInfo> roomInfo(bool withInvites = true);
+        std::map<QString, bool> invites();
+
+        //! Calculate & return the name of the room.
+        QString getRoomName(lmdb::txn &txn, lmdb::dbi &statesdb, lmdb::dbi &membersdb);
+        //! Get room join rules
+        mtx::events::state::JoinRule getRoomJoinRule(lmdb::txn &txn, lmdb::dbi &statesdb);
+        bool getRoomGuestAccess(lmdb::txn &txn, lmdb::dbi &statesdb);
+        //! Retrieve the topic of the room if any.
+        QString getRoomTopic(lmdb::txn &txn, lmdb::dbi &statesdb);
+        //! Retrieve the room avatar's url if any.
+        QString getRoomAvatarUrl(lmdb::txn &txn,
+                                 lmdb::dbi &statesdb,
+                                 lmdb::dbi &membersdb,
+                                 const QString &room_id);
+        //! Retrieve the version of the room if any.
+        QString getRoomVersion(lmdb::txn &txn, lmdb::dbi &statesdb);
+
+        //! Retrieve member info from a room.
+        std::vector<RoomMember> getMembers(const std::string &room_id,
+                                           std::size_t startIndex = 0,
+                                           std::size_t len        = 30);
+
+        void saveState(const mtx::responses::Sync &res);
+        bool isInitialized() const;
+
+        std::string nextBatchToken() const;
+
+        void deleteData();
+
+        void removeInvite(lmdb::txn &txn, const std::string &room_id);
+        void removeInvite(const std::string &room_id);
+        void removeRoom(lmdb::txn &txn, const std::string &roomid);
+        void removeRoom(const std::string &roomid);
+        void setup();
+
+        bool isFormatValid();
+        void setCurrentFormat();
+
+        std::map<QString, mtx::responses::Timeline> roomMessages();
+
+        QMap<QString, mtx::responses::Notifications> getTimelineMentions();
+
+        //! Retrieve all the user ids from a room.
+        std::vector<std::string> roomMembers(const std::string &room_id);
+
+        //! Check if the given user has power leve greater than than
+        //! lowest power level of the given events.
+        bool hasEnoughPowerLevel(const std::vector<mtx::events::EventType> &eventTypes,
+                                 const std::string &room_id,
+                                 const std::string &user_id);
+
+        //! Retrieves the saved room avatar.
+        QImage getRoomAvatar(const QString &id);
+        QImage getRoomAvatar(const std::string &id);
+
+        //! Adds a user to the read list for the given event.
+        //!
+        //! There should be only one user id present in a receipt list per room.
+        //! The user id should be removed from any other lists.
+        using Receipts = std::map<std::string, std::map<std::string, uint64_t>>;
+        void updateReadReceipt(lmdb::txn &txn,
+                               const std::string &room_id,
+                               const Receipts &receipts);
+
+        //! Retrieve all the read receipts for the given event id and room.
+        //!
+        //! Returns a map of user ids and the time of the read receipt in milliseconds.
+        using UserReceipts = std::multimap<uint64_t, std::string, std::greater<uint64_t>>;
+        UserReceipts readReceipts(const QString &event_id, const QString &room_id);
+
+        //! Filter the events that have at least one read receipt.
+        std::vector<QString> filterReadEvents(const QString &room_id,
+                                              const std::vector<QString> &event_ids,
+                                              const std::string &excluded_user);
+        //! Add event for which we are expecting some read receipts.
+        void addPendingReceipt(const QString &room_id, const QString &event_id);
+        void removePendingReceipt(lmdb::txn &txn,
+                                  const std::string &room_id,
+                                  const std::string &event_id);
+        void notifyForReadReceipts(const std::string &room_id);
+        std::vector<QString> pendingReceiptsEvents(lmdb::txn &txn, const std::string &room_id);
+
+        QByteArray image(const QString &url) const;
+        QByteArray image(lmdb::txn &txn, const std::string &url) const;
+        void saveImage(const std::string &url, const std::string &data);
+        void saveImage(const QString &url, const QByteArray &data);
+
+        RoomInfo singleRoomInfo(const std::string &room_id);
+        std::vector<std::string> roomsWithStateUpdates(const mtx::responses::Sync &res);
+        std::vector<std::string> roomsWithTagUpdates(const mtx::responses::Sync &res);
+        std::map<QString, RoomInfo> getRoomInfo(const std::vector<std::string> &rooms);
+
+        //! Calculates which the read status of a room.
+        //! Whether all the events in the timeline have been read.
+        bool calculateRoomReadStatus(const std::string &room_id);
+        void calculateRoomReadStatus();
+
+        QVector<SearchResult> searchUsers(const std::string &room_id,
+                                          const std::string &query,
+                                          std::uint8_t max_items = 5);
+        std::vector<RoomSearchResult> searchRooms(const std::string &query,
+                                                  std::uint8_t max_items = 5);
+
+        void markSentNotification(const std::string &event_id);
+        //! Removes an event from the sent notifications.
+        void removeReadNotification(const std::string &event_id);
+        //! Check if we have sent a desktop notification for the given event id.
+        bool isNotificationSent(const std::string &event_id);
+
+        //! Add all notifications containing a user mention to the db.
+        void saveTimelineMentions(const mtx::responses::Notifications &res);
+
+        //! Remove old unused data.
+        void deleteOldMessages();
+        void deleteOldData() noexcept;
+        //! Retrieve all saved room ids.
+        std::vector<std::string> getRoomIds(lmdb::txn &txn);
+
+        //! Mark a room that uses e2e encryption.
+        void setEncryptedRoom(lmdb::txn &txn, const std::string &room_id);
+        bool isRoomEncrypted(const std::string &room_id);
+
+        //! Check if a user is a member of the room.
+        bool isRoomMember(const std::string &user_id, const std::string &room_id);
+
+        //
+        // Outbound Megolm Sessions
+        //
+        void saveOutboundMegolmSession(const std::string &room_id,
+                                       const OutboundGroupSessionData &data,
+                                       mtx::crypto::OutboundGroupSessionPtr session);
+        OutboundGroupSessionDataRef getOutboundMegolmSession(const std::string &room_id);
+        bool outboundMegolmSessionExists(const std::string &room_id) noexcept;
+        void updateOutboundMegolmSession(const std::string &room_id, int message_index);
+
+        void importSessionKeys(const mtx::crypto::ExportedSessionKeys &keys);
+        mtx::crypto::ExportedSessionKeys exportSessionKeys();
+
+        //
+        // Inbound Megolm Sessions
+        //
+        void saveInboundMegolmSession(const MegolmSessionIndex &index,
+                                      mtx::crypto::InboundGroupSessionPtr session);
+        OlmInboundGroupSession *getInboundMegolmSession(const MegolmSessionIndex &index);
+        bool inboundMegolmSessionExists(const MegolmSessionIndex &index);
+
+        //
+        // Olm Sessions
+        //
+        void saveOlmSession(const std::string &curve25519, mtx::crypto::OlmSessionPtr session);
+        std::vector<std::string> getOlmSessions(const std::string &curve25519);
+        std::optional<mtx::crypto::OlmSessionPtr> getOlmSession(const std::string &curve25519,
+                                                                const std::string &session_id);
+
+        void saveOlmAccount(const std::string &pickled);
+        std::string restoreOlmAccount();
+
+        void restoreSessions();
+
+signals:
+        void newReadReceipts(const QString &room_id, const std::vector<QString> &event_ids);
+        void roomReadStatus(const std::map<QString, bool> &status);
+
+private:
+        //! Save an invited room.
+        void saveInvite(lmdb::txn &txn,
+                        lmdb::dbi &statesdb,
+                        lmdb::dbi &membersdb,
+                        const mtx::responses::InvitedRoom &room);
+
+        //! Add a notification containing a user mention to the db.
+        void saveTimelineMentions(lmdb::txn &txn,
+                                  const std::string &room_id,
+                                  const QList<mtx::responses::Notification> &res);
+
+        //! Get timeline items that a user was mentions in for a given room
+        mtx::responses::Notifications getTimelineMentionsForRoom(lmdb::txn &txn,
+                                                                 const std::string &room_id);
+
+        QString getInviteRoomName(lmdb::txn &txn, lmdb::dbi &statesdb, lmdb::dbi &membersdb);
+        QString getInviteRoomTopic(lmdb::txn &txn, lmdb::dbi &statesdb);
+        QString getInviteRoomAvatarUrl(lmdb::txn &txn, lmdb::dbi &statesdb, lmdb::dbi &membersdb);
+
+        DescInfo getLastMessageInfo(lmdb::txn &txn, const std::string &room_id);
+        void saveTimelineMessages(lmdb::txn &txn,
+                                  const std::string &room_id,
+                                  const mtx::responses::Timeline &res);
+
+        mtx::responses::Timeline getTimelineMessages(lmdb::txn &txn, const std::string &room_id);
+
+        //! Remove a room from the cache.
+        // void removeLeftRoom(lmdb::txn &txn, const std::string &room_id);
+        template<class T>
+        void saveStateEvents(lmdb::txn &txn,
+                             const lmdb::dbi &statesdb,
+                             const lmdb::dbi &membersdb,
+                             const std::string &room_id,
+                             const std::vector<T> &events)
+        {
+                for (const auto &e : events)
+                        saveStateEvent(txn, statesdb, membersdb, room_id, e);
+        }
+
+        template<class T>
+        void saveStateEvent(lmdb::txn &txn,
+                            const lmdb::dbi &statesdb,
+                            const lmdb::dbi &membersdb,
+                            const std::string &room_id,
+                            const T &event)
+        {
+                using namespace mtx::events;
+                using namespace mtx::events::state;
+
+                if (auto e = std::get_if<StateEvent<Member>>(&event); e != nullptr) {
+                        switch (e->content.membership) {
+                        //
+                        // We only keep users with invite or join membership.
+                        //
+                        case Membership::Invite:
+                        case Membership::Join: {
+                                auto display_name = e->content.display_name.empty()
+                                                      ? e->state_key
+                                                      : e->content.display_name;
+
+                                // Lightweight representation of a member.
+                                MemberInfo tmp{display_name, e->content.avatar_url};
+
+                                lmdb::dbi_put(txn,
+                                              membersdb,
+                                              lmdb::val(e->state_key),
+                                              lmdb::val(json(tmp).dump()));
+
+                                insertDisplayName(QString::fromStdString(room_id),
+                                                  QString::fromStdString(e->state_key),
+                                                  QString::fromStdString(display_name));
+
+                                insertAvatarUrl(QString::fromStdString(room_id),
+                                                QString::fromStdString(e->state_key),
+                                                QString::fromStdString(e->content.avatar_url));
+
+                                break;
+                        }
+                        default: {
+                                lmdb::dbi_del(
+                                  txn, membersdb, lmdb::val(e->state_key), lmdb::val(""));
+
+                                removeDisplayName(QString::fromStdString(room_id),
+                                                  QString::fromStdString(e->state_key));
+                                removeAvatarUrl(QString::fromStdString(room_id),
+                                                QString::fromStdString(e->state_key));
+
+                                break;
+                        }
+                        }
+
+                        return;
+                } else if (std::holds_alternative<StateEvent<Encryption>>(event)) {
+                        setEncryptedRoom(txn, room_id);
+                        return;
+                }
+
+                if (!isStateEvent(event))
+                        return;
+
+                std::visit(
+                  [&txn, &statesdb](auto e) {
+                          lmdb::dbi_put(
+                            txn, statesdb, lmdb::val(to_string(e.type)), lmdb::val(json(e).dump()));
+                  },
+                  event);
+        }
+
+        template<class T>
+        bool isStateEvent(const T &e)
+        {
+                using namespace mtx::events;
+                using namespace mtx::events::state;
+
+                return std::holds_alternative<StateEvent<Aliases>>(e) ||
+                       std::holds_alternative<StateEvent<state::Avatar>>(e) ||
+                       std::holds_alternative<StateEvent<CanonicalAlias>>(e) ||
+                       std::holds_alternative<StateEvent<Create>>(e) ||
+                       std::holds_alternative<StateEvent<GuestAccess>>(e) ||
+                       std::holds_alternative<StateEvent<HistoryVisibility>>(e) ||
+                       std::holds_alternative<StateEvent<JoinRules>>(e) ||
+                       std::holds_alternative<StateEvent<Name>>(e) ||
+                       std::holds_alternative<StateEvent<Member>>(e) ||
+                       std::holds_alternative<StateEvent<PowerLevels>>(e) ||
+                       std::holds_alternative<StateEvent<Topic>>(e);
+        }
+
+        template<class T>
+        bool containsStateUpdates(const T &e)
+        {
+                using namespace mtx::events;
+                using namespace mtx::events::state;
+
+                return std::holds_alternative<StateEvent<state::Avatar>>(e) ||
+                       std::holds_alternative<StateEvent<CanonicalAlias>>(e) ||
+                       std::holds_alternative<StateEvent<Name>>(e) ||
+                       std::holds_alternative<StateEvent<Member>>(e) ||
+                       std::holds_alternative<StateEvent<Topic>>(e);
+        }
+
+        bool containsStateUpdates(const mtx::events::collections::StrippedEvents &e)
+        {
+                using namespace mtx::events;
+                using namespace mtx::events::state;
+
+                return std::holds_alternative<StrippedEvent<state::Avatar>>(e) ||
+                       std::holds_alternative<StrippedEvent<CanonicalAlias>>(e) ||
+                       std::holds_alternative<StrippedEvent<Name>>(e) ||
+                       std::holds_alternative<StrippedEvent<Member>>(e) ||
+                       std::holds_alternative<StrippedEvent<Topic>>(e);
+        }
+
+        void saveInvites(lmdb::txn &txn,
+                         const std::map<std::string, mtx::responses::InvitedRoom> &rooms);
+
+        //! Sends signals for the rooms that are removed.
+        void removeLeftRooms(lmdb::txn &txn,
+                             const std::map<std::string, mtx::responses::LeftRoom> &rooms)
+        {
+                for (const auto &room : rooms) {
+                        removeRoom(txn, room.first);
+
+                        // Clean up leftover invites.
+                        removeInvite(txn, room.first);
+                }
+        }
+
+        lmdb::dbi getPendingReceiptsDb(lmdb::txn &txn)
+        {
+                return lmdb::dbi::open(txn, "pending_receipts", MDB_CREATE);
+        }
+
+        lmdb::dbi getMessagesDb(lmdb::txn &txn, const std::string &room_id)
+        {
+                auto db =
+                  lmdb::dbi::open(txn, std::string(room_id + "/messages").c_str(), MDB_CREATE);
+                lmdb::dbi_set_compare(txn, db, numeric_key_comparison);
+
+                return db;
+        }
+
+        lmdb::dbi getInviteStatesDb(lmdb::txn &txn, const std::string &room_id)
+        {
+                return lmdb::dbi::open(
+                  txn, std::string(room_id + "/invite_state").c_str(), MDB_CREATE);
+        }
+
+        lmdb::dbi getInviteMembersDb(lmdb::txn &txn, const std::string &room_id)
+        {
+                return lmdb::dbi::open(
+                  txn, std::string(room_id + "/invite_members").c_str(), MDB_CREATE);
+        }
+
+        lmdb::dbi getStatesDb(lmdb::txn &txn, const std::string &room_id)
+        {
+                return lmdb::dbi::open(txn, std::string(room_id + "/state").c_str(), MDB_CREATE);
+        }
+
+        lmdb::dbi getMembersDb(lmdb::txn &txn, const std::string &room_id)
+        {
+                return lmdb::dbi::open(txn, std::string(room_id + "/members").c_str(), MDB_CREATE);
+        }
+
+        lmdb::dbi getMentionsDb(lmdb::txn &txn, const std::string &room_id)
+        {
+                return lmdb::dbi::open(txn, std::string(room_id + "/mentions").c_str(), MDB_CREATE);
+        }
+
+        //! Retrieves or creates the database that stores the open OLM sessions between our device
+        //! and the given curve25519 key which represents another device.
+        //!
+        //! Each entry is a map from the session_id to the pickled representation of the session.
+        lmdb::dbi getOlmSessionsDb(lmdb::txn &txn, const std::string &curve25519_key)
+        {
+                return lmdb::dbi::open(
+                  txn, std::string("olm_sessions/" + curve25519_key).c_str(), MDB_CREATE);
+        }
+
+        QString getDisplayName(const mtx::events::StateEvent<mtx::events::state::Member> &event)
+        {
+                if (!event.content.display_name.empty())
+                        return QString::fromStdString(event.content.display_name);
+
+                return QString::fromStdString(event.state_key);
+        }
+
+        void setNextBatchToken(lmdb::txn &txn, const std::string &token);
+        void setNextBatchToken(lmdb::txn &txn, const QString &token);
+
+        lmdb::env env_;
+        lmdb::dbi syncStateDb_;
+        lmdb::dbi roomsDb_;
+        lmdb::dbi invitesDb_;
+        lmdb::dbi mediaDb_;
+        lmdb::dbi readReceiptsDb_;
+        lmdb::dbi notificationsDb_;
+
+        lmdb::dbi devicesDb_;
+        lmdb::dbi deviceKeysDb_;
+
+        lmdb::dbi inboundMegolmSessionDb_;
+        lmdb::dbi outboundMegolmSessionDb_;
+
+        QString localUserId_;
+        QString cacheDirectory_;
+
+        static QHash<QString, QString> DisplayNames;
+        static QHash<QString, QString> AvatarUrls;
+        static QHash<QString, QString> UserColors;
+
+        OlmSessionStorage session_storage;
+};
+
+namespace cache {
+Cache *
+client();
+}
diff --git a/src/ChatPage.cpp b/src/ChatPage.cpp
index c496acab..ad07efdd 100644
--- a/src/ChatPage.cpp
+++ b/src/ChatPage.cpp
@@ -22,6 +22,7 @@
 
 #include "AvatarProvider.h"
 #include "Cache.h"
+#include "Cache_p.h"
 #include "ChatPage.h"
 #include "Logging.h"
 #include "MainWindow.h"
@@ -319,7 +320,7 @@ ChatPage::ChatPage(QSharedPointer<UserSettings> userSettings, QWidget *parent)
                   auto bin     = dev->peek(dev->size());
                   auto payload = std::string(bin.data(), bin.size());
                   std::optional<mtx::crypto::EncryptedFile> encryptedFile;
-                  if (cache::client()->isRoomEncrypted(current_room_.toStdString())) {
+                  if (cache::isRoomEncrypted(current_room_.toStdString())) {
                           mtx::crypto::BinaryBuf buf;
                           std::tie(buf, encryptedFile) = mtx::crypto::encrypt_file(payload);
                           payload                      = mtx::crypto::to_string(buf);
@@ -408,7 +409,7 @@ ChatPage::ChatPage(QSharedPointer<UserSettings> userSettings, QWidget *parent)
                 this,
                 [](const mtx::responses::Notifications &notif) {
                         try {
-                                cache::client()->saveTimelineMentions(notif);
+                                cache::saveTimelineMentions(notif);
                         } catch (const lmdb::error &e) {
                                 nhlog::db()->error("failed to save mentions: {}", e.what());
                         }
@@ -457,7 +458,7 @@ ChatPage::ChatPage(QSharedPointer<UserSettings> userSettings, QWidget *parent)
                 &popups::UserMentions::initializeMentions);
         connect(this, &ChatPage::syncUI, this, [this](const mtx::responses::Rooms &rooms) {
                 try {
-                        room_list_->cleanupInvites(cache::client()->invites());
+                        room_list_->cleanupInvites(cache::invites());
                 } catch (const lmdb::error &e) {
                         nhlog::db()->error("failed to retrieve invites: {}", e.what());
                 }
@@ -575,7 +576,7 @@ ChatPage::deleteConfigs()
         settings.remove("");
         settings.endGroup();
 
-        cache::client()->deleteData();
+        cache::deleteData();
         http::client()->clear();
 }
 
@@ -610,18 +611,18 @@ ChatPage::bootstrap(QString userid, QString homeserver, QString token)
                 connect(
                   cache::client(), &Cache::roomReadStatus, room_list_, &RoomList::updateReadStatus);
 
-                const bool isInitialized = cache::client()->isInitialized();
-                const bool isValid       = cache::client()->isFormatValid();
+                const bool isInitialized = cache::isInitialized();
+                const bool isValid       = cache::isFormatValid();
 
                 if (!isInitialized) {
-                        cache::client()->setCurrentFormat();
+                        cache::setCurrentFormat();
                 } else if (isInitialized && !isValid) {
                         // TODO: Deleting session data but keep using the
                         //	 same device doesn't work.
-                        cache::client()->deleteData();
+                        cache::deleteData();
 
                         cache::init(userid);
-                        cache::client()->setCurrentFormat();
+                        cache::setCurrentFormat();
                 } else if (isInitialized) {
                         loadStateFromCache();
                         return;
@@ -629,7 +630,7 @@ ChatPage::bootstrap(QString userid, QString homeserver, QString token)
 
         } catch (const lmdb::error &e) {
                 nhlog::db()->critical("failure during boot: {}", e.what());
-                cache::client()->deleteData();
+                cache::deleteData();
                 nhlog::net()->info("falling back to initial sync");
         }
 
@@ -638,7 +639,7 @@ ChatPage::bootstrap(QString userid, QString homeserver, QString token)
                 // There isn't a saved olm account to restore.
                 nhlog::crypto()->info("creating new olm account");
                 olm::client()->create_new_account();
-                cache::client()->saveOlmAccount(olm::client()->save(STORAGE_SECRET_KEY));
+                cache::saveOlmAccount(olm::client()->save(STORAGE_SECRET_KEY));
         } catch (const lmdb::error &e) {
                 nhlog::crypto()->critical("failed to save olm account {}", e.what());
                 emit dropToLoginPageCb(QString::fromStdString(e.what()));
@@ -671,7 +672,7 @@ ChatPage::changeTopRoomInfo(const QString &room_id)
         }
 
         try {
-                auto room_info = cache::client()->getRoomInfo({room_id.toStdString()});
+                auto room_info = cache::getRoomInfo({room_id.toStdString()});
 
                 if (room_info.find(room_id) == room_info.end())
                         return;
@@ -682,7 +683,7 @@ ChatPage::changeTopRoomInfo(const QString &room_id)
                 top_bar_->updateRoomName(name);
                 top_bar_->updateRoomTopic(QString::fromStdString(room_info[room_id].topic));
 
-                auto img = cache::client()->getRoomAvatar(room_id);
+                auto img = cache::getRoomAvatar(room_id);
 
                 if (img.isNull())
                         top_bar_->updateRoomAvatarFromName(name);
@@ -719,18 +720,17 @@ ChatPage::loadStateFromCache()
 
         QtConcurrent::run([this]() {
                 try {
-                        cache::client()->restoreSessions();
-                        olm::client()->load(cache::client()->restoreOlmAccount(),
-                                            STORAGE_SECRET_KEY);
+                        cache::restoreSessions();
+                        olm::client()->load(cache::restoreOlmAccount(), STORAGE_SECRET_KEY);
 
-                        cache::client()->populateMembers();
+                        cache::populateMembers();
 
-                        emit initializeEmptyViews(cache::client()->roomMessages());
-                        emit initializeRoomList(cache::client()->roomInfo());
-                        emit initializeMentions(cache::client()->getTimelineMentions());
-                        emit syncTags(cache::client()->roomInfo().toStdMap());
+                        emit initializeEmptyViews(cache::roomMessages());
+                        emit initializeRoomList(cache::roomInfo());
+                        emit initializeMentions(cache::getTimelineMentions());
+                        emit syncTags(cache::roomInfo().toStdMap());
 
-                        cache::client()->calculateRoomReadStatus();
+                        cache::calculateRoomReadStatus();
 
                 } catch (const mtx::crypto::olm_exception &e) {
                         nhlog::crypto()->critical("failed to restore olm account: {}", e.what());
@@ -773,8 +773,8 @@ void
 ChatPage::removeRoom(const QString &room_id)
 {
         try {
-                cache::client()->removeRoom(room_id);
-                cache::client()->removeInvite(room_id.toStdString());
+                cache::removeRoom(room_id);
+                cache::removeInvite(room_id.toStdString());
         } catch (const lmdb::error &e) {
                 nhlog::db()->critical("failure while removing room: {}", e.what());
                 // TODO: Notify the user.
@@ -807,7 +807,7 @@ ChatPage::generateTypingUsers(const QString &room_id, const std::vector<std::str
                 if (remote_user == local_user)
                         continue;
 
-                users.append(Cache::displayName(room_id, remote_user));
+                users.append(cache::displayName(room_id, remote_user));
         }
 
         users.sort();
@@ -853,16 +853,16 @@ ChatPage::sendDesktopNotifications(const mtx::responses::Notifications &res)
 
                 try {
                         if (item.read) {
-                                cache::client()->removeReadNotification(event_id);
+                                cache::removeReadNotification(event_id);
                                 continue;
                         }
 
-                        if (!cache::client()->isNotificationSent(event_id)) {
+                        if (!cache::isNotificationSent(event_id)) {
                                 const auto room_id = QString::fromStdString(item.room_id);
                                 const auto user_id = utils::event_sender(item.event);
 
                                 // We should only sent one notification per event.
-                                cache::client()->markSentNotification(event_id);
+                                cache::markSentNotification(event_id);
 
                                 // Don't send a notification when the current room is opened.
                                 if (isRoomActive(room_id))
@@ -871,11 +871,10 @@ ChatPage::sendDesktopNotifications(const mtx::responses::Notifications &res)
                                 notificationsManager.postNotification(
                                   room_id,
                                   QString::fromStdString(event_id),
-                                  QString::fromStdString(
-                                    cache::client()->singleRoomInfo(item.room_id).name),
-                                  Cache::displayName(room_id, user_id),
+                                  QString::fromStdString(cache::singleRoomInfo(item.room_id).name),
+                                  cache::displayName(room_id, user_id),
                                   utils::event_body(item.event),
-                                  cache::client()->getRoomAvatar(room_id));
+                                  cache::getRoomAvatar(room_id));
                         }
                 } catch (const lmdb::error &e) {
                         nhlog::db()->warn("error while sending desktop notification: {}", e.what());
@@ -962,7 +961,7 @@ ChatPage::trySync()
                 connectivityTimer_.start();
 
         try {
-                opts.since = cache::client()->nextBatchToken();
+                opts.since = cache::nextBatchToken();
         } catch (const lmdb::error &e) {
                 nhlog::db()->error("failed to retrieve next batch token: {}", e.what());
                 return;
@@ -1015,22 +1014,22 @@ ChatPage::trySync()
 
                   // TODO: fine grained error handling
                   try {
-                          cache::client()->saveState(res);
+                          cache::saveState(res);
                           olm::handle_to_device_messages(res.to_device);
 
                           emit syncUI(res.rooms);
 
-                          auto updates = cache::client()->roomUpdates(res);
+                          auto updates = cache::roomUpdates(res);
 
                           emit syncTopBar(updates);
                           emit syncRoomlist(updates);
 
-                          emit syncTags(cache::client()->roomTagUpdates(res));
+                          emit syncTags(cache::roomTagUpdates(res));
 
-                          cache::client()->deleteOldData();
+                          cache::deleteOldData();
                   } catch (const lmdb::map_full_error &e) {
                           nhlog::db()->error("lmdb is full: {}", e.what());
-                          cache::client()->deleteOldData();
+                          cache::deleteOldData();
                   } catch (const lmdb::error &e) {
                           nhlog::db()->error("saving sync response: {}", e.what());
                   }
@@ -1058,7 +1057,7 @@ ChatPage::joinRoom(const QString &room)
 
                   // We remove any invites with the same room_id.
                   try {
-                          cache::client()->removeInvite(room_id);
+                          cache::removeInvite(room_id);
                   } catch (const lmdb::error &e) {
                           emit showNotification(
                             QString("Failed to remove invite: %1").arg(e.what()));
@@ -1156,16 +1155,16 @@ ChatPage::initialSyncHandler(const mtx::responses::Sync &res, mtx::http::Request
         nhlog::net()->info("initial sync completed");
 
         try {
-                cache::client()->saveState(res);
+                cache::saveState(res);
 
                 olm::handle_to_device_messages(res.to_device);
 
                 emit initializeViews(std::move(res.rooms));
-                emit initializeRoomList(cache::client()->roomInfo());
-                emit initializeMentions(cache::client()->getTimelineMentions());
+                emit initializeRoomList(cache::roomInfo());
+                emit initializeMentions(cache::getTimelineMentions());
 
-                cache::client()->calculateRoomReadStatus();
-                emit syncTags(cache::client()->roomInfo().toStdMap());
+                cache::calculateRoomReadStatus();
+                emit syncTags(cache::roomInfo().toStdMap());
         } catch (const lmdb::error &e) {
                 nhlog::db()->error("failed to save state after initial sync: {}", e.what());
                 startInitialSync();
diff --git a/src/CommunitiesList.cpp b/src/CommunitiesList.cpp
index 6e46741b..4ea99408 100644
--- a/src/CommunitiesList.cpp
+++ b/src/CommunitiesList.cpp
@@ -215,7 +215,7 @@ CommunitiesList::highlightSelectedCommunity(const QString &community_id)
 void
 CommunitiesList::fetchCommunityAvatar(const QString &id, const QString &avatarUrl)
 {
-        auto savedImgData = cache::client()->image(avatarUrl);
+        auto savedImgData = cache::image(avatarUrl);
         if (!savedImgData.isNull()) {
                 QPixmap pix;
                 pix.loadFromData(savedImgData);
@@ -238,7 +238,7 @@ CommunitiesList::fetchCommunityAvatar(const QString &id, const QString &avatarUr
                           return;
                   }
 
-                  cache::client()->saveImage(opts.mxc_url, res);
+                  cache::saveImage(opts.mxc_url, res);
 
                   auto data = QByteArray(res.data(), res.size());
 
diff --git a/src/MainWindow.cpp b/src/MainWindow.cpp
index 7d9a8902..b13f1b80 100644
--- a/src/MainWindow.cpp
+++ b/src/MainWindow.cpp
@@ -114,7 +114,7 @@ MainWindow::MainWindow(QWidget *parent)
         connect(
           userSettingsPage_, SIGNAL(trayOptionChanged(bool)), trayIcon_, SLOT(setVisible(bool)));
         connect(userSettingsPage_, &UserSettingsPage::themeChanged, this, []() {
-                Cache::clearUserColors();
+                cache::clearUserColors();
         });
         connect(
           userSettingsPage_, &UserSettingsPage::themeChanged, chat_page_, &ChatPage::themeChanged);
@@ -444,7 +444,7 @@ MainWindow::openReadReceiptsDialog(const QString &event_id)
         const auto room_id = chat_page_->currentRoom();
 
         try {
-                dialog->addUsers(cache::client()->readReceipts(event_id, room_id));
+                dialog->addUsers(cache::readReceipts(event_id, room_id));
         } catch (const lmdb::error &e) {
                 nhlog::db()->warn("failed to retrieve read receipts for {} {}",
                                   event_id.toStdString(),
@@ -507,4 +507,4 @@ MainWindow::loadJdenticonPlugin()
 
         nhlog::ui()->info("jdenticon plugin not found.");
         return false;
-}
\ No newline at end of file
+}
diff --git a/src/MxcImageProvider.cpp b/src/MxcImageProvider.cpp
index edf6ceb5..02ca2806 100644
--- a/src/MxcImageProvider.cpp
+++ b/src/MxcImageProvider.cpp
@@ -1,6 +1,8 @@
 #include "MxcImageProvider.h"
 
 #include "Cache.h"
+#include "MatrixClient.h"
+#include "Logging.h"
 
 void
 MxcImageResponse::run()
@@ -11,7 +13,7 @@ MxcImageResponse::run()
                                      .arg(m_requestedSize.width())
                                      .arg(m_requestedSize.height());
 
-                auto data = cache::client()->image(fileName);
+                auto data = cache::image(fileName);
                 if (!data.isNull() && m_image.loadFromData(data)) {
                         m_image = m_image.scaled(m_requestedSize, Qt::KeepAspectRatio);
                         m_image.setText("mxc url", "mxc://" + m_id);
@@ -36,14 +38,14 @@ MxcImageResponse::run()
                           }
 
                           auto data = QByteArray(res.data(), res.size());
-                          cache::client()->saveImage(fileName, data);
+                          cache::saveImage(fileName, data);
                           m_image.loadFromData(data);
                           m_image.setText("mxc url", "mxc://" + m_id);
 
                           emit finished();
                   });
         } else {
-                auto data = cache::client()->image(m_id);
+                auto data = cache::image(m_id);
                 if (!data.isNull() && m_image.loadFromData(data)) {
                         m_image.setText("mxc url", "mxc://" + m_id);
                         emit finished();
@@ -75,7 +77,7 @@ MxcImageResponse::run()
                           m_image.setText("original filename",
                                           QString::fromStdString(originalFilename));
                           m_image.setText("mxc url", "mxc://" + m_id);
-                          cache::client()->saveImage(m_id, data);
+                          cache::saveImage(m_id, data);
 
                           emit finished();
                   });
diff --git a/src/Olm.cpp b/src/Olm.cpp
index 9c1a25df..5859fe8e 100644
--- a/src/Olm.cpp
+++ b/src/Olm.cpp
@@ -121,7 +121,7 @@ handle_pre_key_olm_message(const std::string &sender,
 
                 // We also remove the one time key used to establish that
                 // session so we'll have to update our copy of the account object.
-                cache::client()->saveOlmAccount(olm::client()->save("secret"));
+                cache::saveOlmAccount(olm::client()->save("secret"));
         } catch (const mtx::crypto::olm_exception &e) {
                 nhlog::crypto()->critical(
                   "failed to create inbound session with {}: {}", sender, e.what());
@@ -149,7 +149,7 @@ handle_pre_key_olm_message(const std::string &sender,
         nhlog::crypto()->debug("decrypted message: \n {}", plaintext.dump(2));
 
         try {
-                cache::client()->saveOlmSession(sender_key, std::move(inbound_session));
+                cache::saveOlmSession(sender_key, std::move(inbound_session));
         } catch (const lmdb::error &e) {
                 nhlog::db()->warn(
                   "failed to save inbound olm session from {}: {}", sender, e.what());
@@ -166,7 +166,7 @@ encrypt_group_message(const std::string &room_id,
         using namespace mtx::events;
 
         // Always chech before for existence.
-        auto res     = cache::client()->getOutboundMegolmSession(room_id);
+        auto res     = cache::getOutboundMegolmSession(room_id);
         auto payload = olm::client()->encrypt_group_message(res.session, body);
 
         // Prepare the m.room.encrypted event.
@@ -181,7 +181,7 @@ encrypt_group_message(const std::string &room_id,
         nhlog::crypto()->info("next message_index {}", message_index);
 
         // We need to re-pickle the session after we send a message to save the new message_index.
-        cache::client()->updateOutboundMegolmSession(room_id, message_index);
+        cache::updateOutboundMegolmSession(room_id, message_index);
 
         return data;
 }
@@ -189,13 +189,13 @@ encrypt_group_message(const std::string &room_id,
 nlohmann::json
 try_olm_decryption(const std::string &sender_key, const mtx::events::msg::OlmCipherContent &msg)
 {
-        auto session_ids = cache::client()->getOlmSessions(sender_key);
+        auto session_ids = cache::getOlmSessions(sender_key);
 
         nhlog::crypto()->info("attempt to decrypt message with {} known session_ids",
                               session_ids.size());
 
         for (const auto &id : session_ids) {
-                auto session = cache::client()->getOlmSession(sender_key, id);
+                auto session = cache::getOlmSession(sender_key, id);
 
                 if (!session)
                         continue;
@@ -204,7 +204,7 @@ try_olm_decryption(const std::string &sender_key, const mtx::events::msg::OlmCip
 
                 try {
                         text = olm::client()->decrypt_message(session->get(), msg.type, msg.body);
-                        cache::client()->saveOlmSession(id, std::move(session.value()));
+                        cache::saveOlmSession(id, std::move(session.value()));
                 } catch (const mtx::crypto::olm_exception &e) {
                         nhlog::crypto()->debug("failed to decrypt olm message ({}, {}) with {}: {}",
                                                msg.type,
@@ -252,7 +252,7 @@ create_inbound_megolm_session(const std::string &sender,
 
         try {
                 auto megolm_session = olm::client()->init_inbound_group_session(session_key);
-                cache::client()->saveInboundMegolmSession(index, std::move(megolm_session));
+                cache::saveInboundMegolmSession(index, std::move(megolm_session));
         } catch (const lmdb::error &e) {
                 nhlog::crypto()->critical("failed to save inbound megolm session: {}", e.what());
                 return;
@@ -268,7 +268,7 @@ void
 mark_keys_as_published()
 {
         olm::client()->mark_keys_as_published();
-        cache::client()->saveOlmAccount(olm::client()->save(STORAGE_SECRET_KEY));
+        cache::saveOlmAccount(olm::client()->save(STORAGE_SECRET_KEY));
 }
 
 void
@@ -355,13 +355,13 @@ handle_key_request_message(const mtx::events::msg::KeyRequest &req)
         }
 
         // Check if we have the keys for the requested session.
-        if (!cache::client()->outboundMegolmSessionExists(req.room_id)) {
+        if (!cache::outboundMegolmSessionExists(req.room_id)) {
                 nhlog::crypto()->warn("requested session not found in room: {}", req.room_id);
                 return;
         }
 
         // Check that the requested session_id and the one we have saved match.
-        const auto session = cache::client()->getOutboundMegolmSession(req.room_id);
+        const auto session = cache::getOutboundMegolmSession(req.room_id);
         if (req.session_id != session.data.session_id) {
                 nhlog::crypto()->warn("session id of retrieved session doesn't match the request: "
                                       "requested({}), ours({})",
@@ -370,7 +370,7 @@ handle_key_request_message(const mtx::events::msg::KeyRequest &req)
                 return;
         }
 
-        if (!cache::client()->isRoomMember(req.sender, req.room_id)) {
+        if (!cache::isRoomMember(req.sender, req.room_id)) {
                 nhlog::crypto()->warn(
                   "user {} that requested the session key is not member of the room {}",
                   req.sender,
@@ -509,8 +509,7 @@ send_megolm_key_to_device(const std::string &user_id,
                                     device_msg = olm::client()->create_olm_encrypted_content(
                                       olm_session.get(), room_key, pks.curve25519);
 
-                                    cache::client()->saveOlmSession(pks.curve25519,
-                                                                    std::move(olm_session));
+                                    cache::saveOlmSession(pks.curve25519, std::move(olm_session));
                             } catch (const json::exception &e) {
                                     nhlog::crypto()->warn("creating outbound session: {}",
                                                           e.what());
diff --git a/src/QuickSwitcher.cpp b/src/QuickSwitcher.cpp
index f8f6c001..29683bb3 100644
--- a/src/QuickSwitcher.cpp
+++ b/src/QuickSwitcher.cpp
@@ -93,8 +93,7 @@ QuickSwitcher::QuickSwitcher(QWidget *parent)
 
                 QtConcurrent::run([this, query = query.toLower()]() {
                         try {
-                                emit queryResults(
-                                  cache::client()->searchRooms(query.toStdString()));
+                                emit queryResults(cache::searchRooms(query.toStdString()));
                         } catch (const lmdb::error &e) {
                                 qWarning() << "room search failed:" << e.what();
                         }
diff --git a/src/TextInputWidget.cpp b/src/TextInputWidget.cpp
index 66700dbc..5e63eca5 100644
--- a/src/TextInputWidget.cpp
+++ b/src/TextInputWidget.cpp
@@ -529,12 +529,12 @@ TextInputWidget::TextInputWidget(QWidget *parent)
                         emit heightChanged(widgetHeight);
                 });
         connect(input_, &FilteredTextEdit::showSuggestions, this, [this](const QString &q) {
-                if (q.isEmpty() || !cache::client())
+                if (q.isEmpty())
                         return;
 
                 QtConcurrent::run([this, q = q.toLower().toStdString()]() {
                         try {
-                                emit input_->resultsRetrieved(cache::client()->searchUsers(
+                                emit input_->resultsRetrieved(cache::searchUsers(
                                   ChatPage::instance()->currentRoom().toStdString(), q));
                         } catch (const lmdb::error &e) {
                                 std::cout << e.what() << '\n';
diff --git a/src/UserSettingsPage.cpp b/src/UserSettingsPage.cpp
index 1caea449..772a8d13 100644
--- a/src/UserSettingsPage.cpp
+++ b/src/UserSettingsPage.cpp
@@ -555,7 +555,7 @@ UserSettingsPage::importSessionKeys()
         try {
                 auto sessions =
                   mtx::crypto::decrypt_exported_sessions(payload, password.toStdString());
-                cache::client()->importSessionKeys(std::move(sessions));
+                cache::importSessionKeys(std::move(sessions));
         } catch (const mtx::crypto::sodium_exception &e) {
                 QMessageBox::warning(this, tr("Error"), e.what());
         } catch (const lmdb::error &e) {
@@ -597,7 +597,7 @@ UserSettingsPage::exportSessionKeys()
         // Export sessions & save to file.
         try {
                 auto encrypted_blob = mtx::crypto::encrypt_exported_sessions(
-                  cache::client()->exportSessionKeys(), password.toStdString());
+                  cache::exportSessionKeys(), password.toStdString());
 
                 QString b64 = QString::fromStdString(mtx::crypto::bin2base64(encrypted_blob));
 
diff --git a/src/Utils.cpp b/src/Utils.cpp
index 3d69162f..918e1996 100644
--- a/src/Utils.cpp
+++ b/src/Utils.cpp
@@ -142,7 +142,7 @@ utils::getMessageDescription(const TimelineEvent &event,
         } else if (auto msg = std::get_if<Encrypted>(&event); msg != nullptr) {
                 const auto sender = QString::fromStdString(msg->sender);
 
-                const auto username = Cache::displayName(room_id, sender);
+                const auto username = cache::displayName(room_id, sender);
                 const auto ts       = QDateTime::fromMSecsSinceEpoch(msg->origin_server_ts);
 
                 DescInfo info;
diff --git a/src/Utils.h b/src/Utils.h
index 6c0cf0dd..aa62b8e7 100644
--- a/src/Utils.h
+++ b/src/Utils.h
@@ -168,7 +168,7 @@ createDescriptionInfo(const Event &event, const QString &localUser, const QStrin
         const auto msg    = std::get<T>(event);
         const auto sender = QString::fromStdString(msg.sender);
 
-        const auto username = Cache::displayName(room_id, sender);
+        const auto username = cache::displayName(room_id, sender);
         const auto ts       = QDateTime::fromMSecsSinceEpoch(msg.origin_server_ts);
 
         return DescInfo{QString::fromStdString(msg.event_id),
diff --git a/src/dialogs/MemberList.cpp b/src/dialogs/MemberList.cpp
index f62cf9fe..dfb3d984 100644
--- a/src/dialogs/MemberList.cpp
+++ b/src/dialogs/MemberList.cpp
@@ -110,11 +110,11 @@ MemberList::MemberList(const QString &room_id, QWidget *parent)
                 const size_t numMembers = list_->count() - 1;
 
                 if (numMembers > 0)
-                        addUsers(cache::client()->getMembers(room_id_.toStdString(), numMembers));
+                        addUsers(cache::getMembers(room_id_.toStdString(), numMembers));
         });
 
         try {
-                addUsers(cache::client()->getMembers(room_id_.toStdString()));
+                addUsers(cache::getMembers(room_id_.toStdString()));
         } catch (const lmdb::error &e) {
                 qCritical() << e.what();
         }
diff --git a/src/dialogs/ReadReceipts.cpp b/src/dialogs/ReadReceipts.cpp
index 58ad59c3..0edd1ebf 100644
--- a/src/dialogs/ReadReceipts.cpp
+++ b/src/dialogs/ReadReceipts.cpp
@@ -35,7 +35,7 @@ ReceiptItem::ReceiptItem(QWidget *parent,
         QFont nameFont;
         nameFont.setPointSizeF(nameFont.pointSizeF() * 1.1);
 
-        auto displayName = Cache::displayName(room_id, user_id);
+        auto displayName = cache::displayName(room_id, user_id);
 
         avatar_ = new Avatar(this, 44);
         avatar_->setLetter(utils::firstChar(displayName));
diff --git a/src/dialogs/RoomSettings.cpp b/src/dialogs/RoomSettings.cpp
index 1be33d33..fcaa4fdc 100644
--- a/src/dialogs/RoomSettings.cpp
+++ b/src/dialogs/RoomSettings.cpp
@@ -485,8 +485,8 @@ void
 RoomSettings::retrieveRoomInfo()
 {
         try {
-                usesEncryption_ = cache::client()->isRoomEncrypted(room_id_.toStdString());
-                info_           = cache::client()->singleRoomInfo(room_id_.toStdString());
+                usesEncryption_ = cache::isRoomEncrypted(room_id_.toStdString());
+                info_           = cache::singleRoomInfo(room_id_.toStdString());
                 setAvatar();
         } catch (const lmdb::error &) {
                 nhlog::db()->warn("failed to retrieve room info from cache: {}",
@@ -529,8 +529,7 @@ bool
 RoomSettings::canChangeJoinRules(const std::string &room_id, const std::string &user_id) const
 {
         try {
-                return cache::client()->hasEnoughPowerLevel(
-                  {EventType::RoomJoinRules}, room_id, user_id);
+                return cache::hasEnoughPowerLevel({EventType::RoomJoinRules}, room_id, user_id);
         } catch (const lmdb::error &e) {
                 nhlog::db()->warn("lmdb error: {}", e.what());
         }
@@ -542,7 +541,7 @@ bool
 RoomSettings::canChangeNameAndTopic(const std::string &room_id, const std::string &user_id) const
 {
         try {
-                return cache::client()->hasEnoughPowerLevel(
+                return cache::hasEnoughPowerLevel(
                   {EventType::RoomName, EventType::RoomTopic}, room_id, user_id);
         } catch (const lmdb::error &e) {
                 nhlog::db()->warn("lmdb error: {}", e.what());
@@ -555,8 +554,7 @@ bool
 RoomSettings::canChangeAvatar(const std::string &room_id, const std::string &user_id) const
 {
         try {
-                return cache::client()->hasEnoughPowerLevel(
-                  {EventType::RoomAvatar}, room_id, user_id);
+                return cache::hasEnoughPowerLevel({EventType::RoomAvatar}, room_id, user_id);
         } catch (const lmdb::error &e) {
                 nhlog::db()->warn("lmdb error: {}", e.what());
         }
diff --git a/src/dialogs/RoomSettings.h b/src/dialogs/RoomSettings.h
index e1807ba1..d71b70db 100644
--- a/src/dialogs/RoomSettings.h
+++ b/src/dialogs/RoomSettings.h
@@ -5,7 +5,9 @@
 #include <QImage>
 #include <QLabel>
 
-#include "Cache.h"
+#include <mtx/events/guest_access.hpp>
+
+#include "CacheStructs.h"
 
 class Avatar;
 class FlatButton;
diff --git a/src/dialogs/UserProfile.cpp b/src/dialogs/UserProfile.cpp
index 5ad3afa2..50c1c990 100644
--- a/src/dialogs/UserProfile.cpp
+++ b/src/dialogs/UserProfile.cpp
@@ -203,7 +203,7 @@ UserProfile::init(const QString &userId, const QString &roomId)
 {
         resetToDefaults();
 
-        auto displayName = Cache::displayName(roomId, userId);
+        auto displayName = cache::displayName(roomId, userId);
 
         userIdLabel_->setText(userId);
         displayNameLabel_->setText(displayName);
@@ -215,9 +215,9 @@ UserProfile::init(const QString &userId, const QString &roomId)
 
         try {
                 bool hasMemberRights =
-                  cache::client()->hasEnoughPowerLevel({mtx::events::EventType::RoomMember},
-                                                       roomId.toStdString(),
-                                                       localUser.toStdString());
+                  cache::hasEnoughPowerLevel({mtx::events::EventType::RoomMember},
+                                             roomId.toStdString(),
+                                             localUser.toStdString());
                 if (!hasMemberRights) {
                         kickBtn_->hide();
                         banBtn_->hide();
diff --git a/src/popups/PopupItem.cpp b/src/popups/PopupItem.cpp
index c4d4327f..db97e4a3 100644
--- a/src/popups/PopupItem.cpp
+++ b/src/popups/PopupItem.cpp
@@ -49,7 +49,7 @@ UserItem::UserItem(QWidget *parent, const QString &user_id)
   : PopupItem(parent)
   , userId_{user_id}
 {
-        auto displayName = Cache::displayName(ChatPage::instance()->currentRoom(), userId_);
+        auto displayName = cache::displayName(ChatPage::instance()->currentRoom(), userId_);
 
         avatar_->setLetter(utils::firstChar(displayName));
 
@@ -70,7 +70,7 @@ UserItem::updateItem(const QString &user_id)
 {
         userId_ = user_id;
 
-        auto displayName = Cache::displayName(ChatPage::instance()->currentRoom(), userId_);
+        auto displayName = cache::displayName(ChatPage::instance()->currentRoom(), userId_);
 
         // If it's a matrix id we use the second letter.
         if (displayName.size() > 1 && displayName.at(0) == '@')
@@ -93,7 +93,7 @@ UserItem::mousePressEvent(QMouseEvent *event)
 {
         if (event->buttons() != Qt::RightButton)
                 emit clicked(
-                  Cache::displayName(ChatPage::instance()->currentRoom(), selectedText()));
+                  cache::displayName(ChatPage::instance()->currentRoom(), selectedText()));
 
         QWidget::mousePressEvent(event);
 }
diff --git a/src/popups/PopupItem.h b/src/popups/PopupItem.h
index cab73a9d..7a710fdb 100644
--- a/src/popups/PopupItem.h
+++ b/src/popups/PopupItem.h
@@ -6,7 +6,6 @@
 #include <QWidget>
 
 #include "../AvatarProvider.h"
-#include "../Cache.h"
 #include "../ChatPage.h"
 
 class Avatar;
@@ -81,4 +80,4 @@ private:
         QLabel *roomName_;
         QString roomId_;
         RoomSearchResult info_;
-};
\ No newline at end of file
+};
diff --git a/src/popups/ReplyPopup.cpp b/src/popups/ReplyPopup.cpp
index 0ebf7c88..42a5a6d3 100644
--- a/src/popups/ReplyPopup.cpp
+++ b/src/popups/ReplyPopup.cpp
@@ -8,6 +8,7 @@
 #include "../ui/Avatar.h"
 #include "../ui/DropShadow.h"
 #include "../ui/TextLabel.h"
+#include "PopupItem.h"
 #include "ReplyPopup.h"
 
 ReplyPopup::ReplyPopup(QWidget *parent)
diff --git a/src/popups/ReplyPopup.h b/src/popups/ReplyPopup.h
index b28cd0cf..1fa3bb83 100644
--- a/src/popups/ReplyPopup.h
+++ b/src/popups/ReplyPopup.h
@@ -2,17 +2,14 @@
 
 #include <QHBoxLayout>
 #include <QLabel>
-#include <QPoint>
 #include <QVBoxLayout>
 #include <QWidget>
 
-#include "../AvatarProvider.h"
-#include "../Cache.h"
-#include "../ChatPage.h"
-#include "../Utils.h"
 #include "../ui/FlatButton.h"
 #include "../ui/TextLabel.h"
-#include "PopupItem.h"
+
+struct RelatedInfo;
+class UserItem;
 
 class ReplyPopup : public QWidget
 {
diff --git a/src/popups/SuggestionsPopup.h b/src/popups/SuggestionsPopup.h
index 536c82fb..de52760a 100644
--- a/src/popups/SuggestionsPopup.h
+++ b/src/popups/SuggestionsPopup.h
@@ -5,9 +5,8 @@
 #include <QPoint>
 #include <QWidget>
 
-#include "../AvatarProvider.h"
-#include "../Cache.h"
-#include "../ChatPage.h"
+#include "CacheStructs.h"
+#include "ChatPage.h"
 #include "PopupItem.h"
 
 Q_DECLARE_METATYPE(QVector<SearchResult>)
@@ -28,7 +27,7 @@ public:
 
                 const auto &widget = qobject_cast<Item *>(item->widget());
                 emit itemSelected(
-                  Cache::displayName(ChatPage::instance()->currentRoom(), widget->selectedText()));
+                  cache::displayName(ChatPage::instance()->currentRoom(), widget->selectedText()));
 
                 resetSelection();
         }
diff --git a/src/popups/UserMentions.cpp b/src/popups/UserMentions.cpp
index 3be5c462..763eeffc 100644
--- a/src/popups/UserMentions.cpp
+++ b/src/popups/UserMentions.cpp
@@ -103,7 +103,7 @@ UserMentions::showPopup()
                 delete widget;
         }
 
-        auto notifs = cache::client()->getTimelineMentions();
+        auto notifs = cache::getTimelineMentions();
 
         initializeMentions(notifs);
         show();
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 1e069d50..d3d1ad34 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -422,7 +422,7 @@ TimelineModel::TimelineModel(TimelineViewManager *manager, QString room_id, QObj
                 readEvent(event_id.toStdString());
 
                 // ask to be notified for read receipts
-                cache::client()->addPendingReceipt(room_id_, event_id);
+                cache::addPendingReceipt(room_id_, event_id);
 
                 isProcessingPending = false;
                 emit dataChanged(index(idx, 0), index(idx, 0));
@@ -575,8 +575,7 @@ TimelineModel::data(const QModelIndex &index, int role) const
                         return qml_mtx_events::Failed;
                 else if (pending.contains(id))
                         return qml_mtx_events::Sent;
-                else if (read.contains(id) ||
-                         cache::client()->readReceipts(id, room_id_).size() > 1)
+                else if (read.contains(id) || cache::readReceipts(id, room_id_).size() > 1)
                         return qml_mtx_events::Read;
                 else
                         return qml_mtx_events::Received;
@@ -805,13 +804,13 @@ TimelineModel::userColor(QString id, QColor background)
 QString
 TimelineModel::displayName(QString id) const
 {
-        return Cache::displayName(room_id_, id);
+        return cache::displayName(room_id_, id);
 }
 
 QString
 TimelineModel::avatarUrl(QString id) const
 {
-        return Cache::avatarUrl(room_id_, id);
+        return cache::avatarUrl(room_id_, id);
 }
 
 QString
@@ -868,7 +867,7 @@ TimelineModel::decryptEvent(const mtx::events::EncryptedEvent<mtx::events::msg::
             .toStdString();
 
         try {
-                if (!cache::client()->inboundMegolmSessionExists(index)) {
+                if (!cache::inboundMegolmSessionExists(index)) {
                         nhlog::crypto()->info("Could not find inbound megolm session ({}, {}, {})",
                                               index.room_id,
                                               index.session_id,
@@ -887,7 +886,7 @@ TimelineModel::decryptEvent(const mtx::events::EncryptedEvent<mtx::events::msg::
 
         std::string msg_str;
         try {
-                auto session = cache::client()->getInboundMegolmSession(index);
+                auto session = cache::getInboundMegolmSession(index);
                 auto res     = olm::client()->decrypt_group_message(session, e.content.ciphertext);
                 msg_str      = std::string((char *)res.data.data(), res.data.size());
         } catch (const lmdb::error &e) {
@@ -1044,7 +1043,7 @@ TimelineModel::sendEncryptedMessage(const std::string &txn_id, nlohmann::json co
 
         try {
                 // Check if we have already an outbound megolm session then we can use.
-                if (cache::client()->outboundMegolmSessionExists(room_id)) {
+                if (cache::outboundMegolmSessionExists(room_id)) {
                         auto data = olm::encrypt_group_message(
                           room_id, http::client()->device_id(), doc.dump());
 
@@ -1089,10 +1088,10 @@ TimelineModel::sendEncryptedMessage(const std::string &txn_id, nlohmann::json co
                 session_data.session_id    = session_id;
                 session_data.session_key   = session_key;
                 session_data.message_index = 0; // TODO Update me
-                cache::client()->saveOutboundMegolmSession(
+                cache::saveOutboundMegolmSession(
                   room_id, session_data, std::move(outbound_session));
 
-                const auto members = cache::client()->roomMembers(room_id);
+                const auto members = cache::roomMembers(room_id);
                 nhlog::ui()->info("retrieved {} members for {}", members.size(), room_id);
 
                 auto keeper =
@@ -1311,7 +1310,7 @@ TimelineModel::handleClaimedKeys(std::shared_ptr<StateKeeper> keeper,
                   s.get(), room_keys.at(device_id), pks.at(device_id).curve25519);
 
                 try {
-                        cache::client()->saveOlmSession(id_key, std::move(s));
+                        cache::saveOlmSession(id_key, std::move(s));
                 } catch (const lmdb::error &e) {
                         nhlog::db()->critical("failed to save outbound olm session: {}", e.what());
                 } catch (const mtx::crypto::olm_exception &e) {
@@ -1353,7 +1352,7 @@ struct SendMessageVisitor
         void operator()(const mtx::events::RoomEvent<T> &msg)
 
         {
-                if (cache::client()->isRoomEncrypted(model_->room_id_.toStdString())) {
+                if (cache::isRoomEncrypted(model_->room_id_.toStdString())) {
                         model_->sendEncryptedMessage(txn_id_qstr_.toStdString(),
                                                      nlohmann::json(msg.content));
                 } else {
-- 
cgit 1.5.1


From 37fbcaf07b205cc0bb89690a415cd06a2814d1a4 Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Sun, 15 Dec 2019 03:19:33 +0100
Subject: Reduce includes of MatrixClient.h, as it is the most expensive header

---
 src/ChatPage.h                 |  6 +++++-
 src/timeline/TimelineModel.cpp | 10 ++++++++++
 src/timeline/TimelineModel.h   | 12 +++++-------
 3 files changed, 20 insertions(+), 8 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/ChatPage.h b/src/ChatPage.h
index 6337f800..a7fb31a8 100644
--- a/src/ChatPage.h
+++ b/src/ChatPage.h
@@ -23,6 +23,7 @@
 
 #include <mtx/common.hpp>
 #include <mtx/responses.hpp>
+#include <mtxclient/http/errors.hpp>
 
 #include <QFrame>
 #include <QHBoxLayout>
@@ -34,7 +35,6 @@
 
 #include "CacheStructs.h"
 #include "CommunitiesList.h"
-#include "MatrixClient.h"
 #include "Utils.h"
 #include "notifications/Manager.h"
 #include "popups/UserMentions.h"
@@ -56,6 +56,10 @@ constexpr int CONSENSUS_TIMEOUT      = 1000;
 constexpr int SHOW_CONTENT_TIMEOUT   = 3000;
 constexpr int TYPING_REFRESH_TIMEOUT = 10000;
 
+namespace mtx::http {
+using RequestErr = const std::optional<mtx::http::ClientError> &;
+}
+
 class ChatPage : public QWidget
 {
         Q_OBJECT
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index d3d1ad34..ce238d94 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -11,6 +11,7 @@
 #include "ChatPage.h"
 #include "Logging.h"
 #include "MainWindow.h"
+#include "MatrixClient.h"
 #include "MxcImageProvider.h"
 #include "Olm.h"
 #include "TimelineViewManager.h"
@@ -1400,6 +1401,15 @@ TimelineModel::processOnePendingMessage()
 void
 TimelineModel::addPendingMessage(mtx::events::collections::TimelineEvents event)
 {
+        std::visit(
+          [](auto &msg) {
+                  msg.type             = mtx::events::EventType::RoomMessage;
+                  msg.event_id         = http::client()->generate_txn_id();
+                  msg.sender           = http::client()->user_id().to_string();
+                  msg.origin_server_ts = QDateTime::currentMSecsSinceEpoch();
+          },
+          event);
+
         internalAddEvents({event});
 
         QString txn_id_qstr =
diff --git a/src/timeline/TimelineModel.h b/src/timeline/TimelineModel.h
index 5391c7c1..7ff80c45 100644
--- a/src/timeline/TimelineModel.h
+++ b/src/timeline/TimelineModel.h
@@ -8,10 +8,14 @@
 
 #include <mtx/common.hpp>
 #include <mtx/responses.hpp>
+#include <mtxclient/http/errors.hpp>
 
 #include "CacheCryptoStructs.h"
 #include "Logging.h"
-#include "MatrixClient.h"
+
+namespace mtx::http {
+using RequestErr = const std::optional<mtx::http::ClientError> &;
+}
 
 namespace qml_mtx_events {
 Q_NAMESPACE
@@ -232,13 +236,7 @@ template<class T>
 void
 TimelineModel::sendMessage(const T &msg)
 {
-        auto txn_id                       = http::client()->generate_txn_id();
         mtx::events::RoomEvent<T> msgCopy = {};
         msgCopy.content                   = msg;
-        msgCopy.type                      = mtx::events::EventType::RoomMessage;
-        msgCopy.event_id                  = txn_id;
-        msgCopy.sender                    = http::client()->user_id().to_string();
-        msgCopy.origin_server_ts          = QDateTime::currentMSecsSinceEpoch();
-
         emit newMessageToSend(msgCopy);
 }
-- 
cgit 1.5.1


From e084543cc07bb430995aaeaf7fc779bfb4e03106 Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Fri, 27 Dec 2019 21:49:55 +0100
Subject: Move visitors out of TimelineModel

---
 CMakeLists.txt                 |   1 +
 src/EventAccessors.cpp         | 363 +++++++++++++++++++++++++
 src/EventAccessors.h           |  62 +++++
 src/timeline/TimelineModel.cpp | 589 ++++++++++-------------------------------
 4 files changed, 570 insertions(+), 445 deletions(-)
 create mode 100644 src/EventAccessors.cpp
 create mode 100644 src/EventAccessors.h

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5c68d614..7871bb6a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -219,6 +219,7 @@ set(SRC_FILES
     src/ChatPage.cpp
     src/CommunitiesListItem.cpp
     src/CommunitiesList.cpp
+    src/EventAccessors.cpp
     src/InviteeItem.cpp
     src/LoginPage.cpp
     src/Logging.cpp
diff --git a/src/EventAccessors.cpp b/src/EventAccessors.cpp
new file mode 100644
index 00000000..6264af58
--- /dev/null
+++ b/src/EventAccessors.cpp
@@ -0,0 +1,363 @@
+#include "EventAccessors.h"
+
+#include <type_traits>
+
+namespace {
+struct nonesuch
+{
+        ~nonesuch()                = delete;
+        nonesuch(nonesuch const &) = delete;
+        void operator=(nonesuch const &) = delete;
+};
+
+namespace detail {
+template<class Default, class AlwaysVoid, template<class...> class Op, class... Args>
+struct detector
+{
+        using value_t = std::false_type;
+        using type    = Default;
+};
+
+template<class Default, template<class...> class Op, class... Args>
+struct detector<Default, std::void_t<Op<Args...>>, Op, Args...>
+{
+        using value_t = std::true_type;
+        using type    = Op<Args...>;
+};
+
+} // namespace detail
+
+template<template<class...> class Op, class... Args>
+using is_detected = typename detail::detector<nonesuch, void, Op, Args...>::value_t;
+
+struct EventMsgType
+{
+        template<class E>
+        using msgtype_t = decltype(E::msgtype);
+        template<class T>
+        mtx::events::MessageType operator()(const mtx::events::Event<T> &e)
+        {
+                if constexpr (is_detected<msgtype_t, T>::value)
+                        return mtx::events::getMessageType(e.content.msgtype);
+                return mtx::events::MessageType::Unknown;
+        }
+};
+
+struct EventRoomName
+{
+        template<class T>
+        std::string operator()(const T &e)
+        {
+                if constexpr (std::is_same_v<mtx::events::StateEvent<mtx::events::state::Name>, T>)
+                        return e.content.name;
+                return "";
+        }
+};
+
+struct EventRoomTopic
+{
+        template<class T>
+        std::string operator()(const T &e)
+        {
+                if constexpr (std::is_same_v<mtx::events::StateEvent<mtx::events::state::Topic>, T>)
+                        return e.content.topic;
+                return "";
+        }
+};
+
+struct EventBody
+{
+        template<class C>
+        using body_t = decltype(C::body);
+        template<class T>
+        std::string operator()(const mtx::events::Event<T> &e)
+        {
+                if constexpr (is_detected<body_t, T>::value)
+                        return e.content.body;
+                return "";
+        }
+};
+
+struct EventFormattedBody
+{
+        template<class C>
+        using formatted_body_t = decltype(C::formatted_body);
+        template<class T>
+        std::string operator()(const mtx::events::RoomEvent<T> &e)
+        {
+                if constexpr (is_detected<formatted_body_t, T>::value)
+                        return e.content.formatted_body;
+                return "";
+        }
+};
+
+struct EventFile
+{
+        template<class Content>
+        using file_t = decltype(Content::file);
+        template<class T>
+        std::optional<mtx::crypto::EncryptedFile> operator()(const mtx::events::Event<T> &e)
+        {
+                if constexpr (is_detected<file_t, T>::value)
+                        return e.content.file;
+                return std::nullopt;
+        }
+};
+
+struct EventUrl
+{
+        template<class Content>
+        using url_t = decltype(Content::url);
+        template<class T>
+        std::string operator()(const mtx::events::Event<T> &e)
+        {
+                if constexpr (is_detected<url_t, T>::value) {
+                        if (auto file = EventFile{}(e))
+                                return file->url;
+                        return e.content.url;
+                }
+                return "";
+        }
+};
+
+struct EventThumbnailUrl
+{
+        template<class Content>
+        using thumbnail_url_t = decltype(Content::info.thumbnail_url);
+        template<class T>
+        std::string operator()(const mtx::events::Event<T> &e)
+        {
+                if constexpr (is_detected<thumbnail_url_t, T>::value) {
+                        return e.content.info.thumbnail_url;
+                }
+                return "";
+        }
+};
+
+struct EventFilename
+{
+        template<class T>
+        std::string operator()(const mtx::events::Event<T> &)
+        {
+                return "";
+        }
+        std::string operator()(const mtx::events::RoomEvent<mtx::events::msg::Audio> &e)
+        {
+                // body may be the original filename
+                return e.content.body;
+        }
+        std::string operator()(const mtx::events::RoomEvent<mtx::events::msg::Video> &e)
+        {
+                // body may be the original filename
+                return e.content.body;
+        }
+        std::string operator()(const mtx::events::RoomEvent<mtx::events::msg::Image> &e)
+        {
+                // body may be the original filename
+                return e.content.body;
+        }
+        std::string operator()(const mtx::events::RoomEvent<mtx::events::msg::File> &e)
+        {
+                // body may be the original filename
+                if (!e.content.filename.empty())
+                        return e.content.filename;
+                return e.content.body;
+        }
+};
+
+struct EventMimeType
+{
+        template<class Content>
+        using mimetype_t = decltype(Content::info.mimetype);
+        template<class T>
+        std::string operator()(const mtx::events::Event<T> &e)
+        {
+                if constexpr (is_detected<mimetype_t, T>::value) {
+                        return e.content.info.mimetype;
+                }
+                return "";
+        }
+};
+
+struct EventFilesize
+{
+        template<class Content>
+        using filesize_t = decltype(Content::info.size);
+        template<class T>
+        int64_t operator()(const mtx::events::RoomEvent<T> &e)
+        {
+                if constexpr (is_detected<filesize_t, T>::value) {
+                        return e.content.info.size;
+                }
+                return 0;
+        }
+};
+
+struct EventInReplyTo
+{
+        template<class Content>
+        using related_ev_id_t = decltype(Content::relates_to.in_reply_to.event_id);
+        template<class T>
+        std::string operator()(const mtx::events::Event<T> &e)
+        {
+                if constexpr (is_detected<related_ev_id_t, T>::value) {
+                        return e.content.relates_to.in_reply_to.event_id;
+                }
+                return "";
+        }
+};
+
+struct EventMediaHeight
+{
+        template<class Content>
+        using h_t = decltype(Content::info.h);
+        template<class T>
+        uint64_t operator()(const mtx::events::Event<T> &e)
+        {
+                if constexpr (is_detected<h_t, T>::value) {
+                        return e.content.info.h;
+                }
+                return -1;
+        }
+};
+
+struct EventMediaWidth
+{
+        template<class Content>
+        using w_t = decltype(Content::info.w);
+        template<class T>
+        uint64_t operator()(const mtx::events::Event<T> &e)
+        {
+                if constexpr (is_detected<w_t, T>::value) {
+                        return e.content.info.w;
+                }
+                return -1;
+        }
+};
+
+template<class T>
+double
+eventPropHeight(const mtx::events::RoomEvent<T> &e)
+{
+        auto w = eventWidth(e);
+        if (w == 0)
+                w = 1;
+
+        double prop = eventHeight(e) / (double)w;
+
+        return prop > 0 ? prop : 1.;
+}
+}
+
+std::string
+mtx::accessors::event_id(const mtx::events::collections::TimelineEvents &event)
+{
+        return std::visit([](const auto e) { return e.event_id; }, event);
+}
+std::string
+mtx::accessors::room_id(const mtx::events::collections::TimelineEvents &event)
+{
+        return std::visit([](const auto e) { return e.room_id; }, event);
+}
+
+std::string
+mtx::accessors::sender(const mtx::events::collections::TimelineEvents &event)
+{
+        return std::visit([](const auto e) { return e.sender; }, event);
+}
+
+QDateTime
+mtx::accessors::origin_server_ts(const mtx::events::collections::TimelineEvents &event)
+{
+        return QDateTime::fromMSecsSinceEpoch(
+          std::visit([](const auto e) { return e.origin_server_ts; }, event));
+}
+
+std::string
+mtx::accessors::filename(const mtx::events::collections::TimelineEvents &event)
+{
+        return std::visit(EventFilename{}, event);
+}
+
+mtx::events::MessageType
+mtx::accessors::msg_type(const mtx::events::collections::TimelineEvents &event)
+{
+        return std::visit(EventMsgType{}, event);
+}
+std::string
+mtx::accessors::room_name(const mtx::events::collections::TimelineEvents &event)
+{
+        return std::visit(EventRoomName{}, event);
+}
+std::string
+mtx::accessors::room_topic(const mtx::events::collections::TimelineEvents &event)
+{
+        return std::visit(EventRoomTopic{}, event);
+}
+
+std::string
+mtx::accessors::body(const mtx::events::collections::TimelineEvents &event)
+{
+        return std::visit(EventBody{}, event);
+}
+
+std::string
+mtx::accessors::formatted_body(const mtx::events::collections::TimelineEvents &event)
+{
+        return std::visit(EventFormattedBody{}, event);
+}
+
+QString
+mtx::accessors::formattedBodyWithFallback(const mtx::events::collections::TimelineEvents &event)
+{
+        auto formatted = formatted_body(event);
+        if (!formatted.empty())
+                return QString::fromStdString(formatted);
+        else
+                return QString::fromStdString(body(event)).toHtmlEscaped().replace("\n", "<br>");
+}
+
+std::optional<mtx::crypto::EncryptedFile>
+mtx::accessors::file(const mtx::events::collections::TimelineEvents &event)
+{
+        return std::visit(EventFile{}, event);
+}
+
+std::string
+mtx::accessors::url(const mtx::events::collections::TimelineEvents &event)
+{
+        return std::visit(EventUrl{}, event);
+}
+std::string
+mtx::accessors::thumbnail_url(const mtx::events::collections::TimelineEvents &event)
+{
+        return std::visit(EventThumbnailUrl{}, event);
+}
+std::string
+mtx::accessors::mimetype(const mtx::events::collections::TimelineEvents &event)
+{
+        return std::visit(EventMimeType{}, event);
+}
+std::string
+mtx::accessors::in_reply_to_event(const mtx::events::collections::TimelineEvents &event)
+{
+        return std::visit(EventInReplyTo{}, event);
+}
+
+int64_t
+mtx::accessors::filesize(const mtx::events::collections::TimelineEvents &event)
+{
+        return std::visit(EventFilesize{}, event);
+}
+
+uint64_t
+mtx::accessors::media_height(const mtx::events::collections::TimelineEvents &event)
+{
+        return std::visit(EventMediaHeight{}, event);
+}
+
+uint64_t
+mtx::accessors::media_width(const mtx::events::collections::TimelineEvents &event)
+{
+        return std::visit(EventMediaWidth{}, event);
+}
diff --git a/src/EventAccessors.h b/src/EventAccessors.h
new file mode 100644
index 00000000..5c03861d
--- /dev/null
+++ b/src/EventAccessors.h
@@ -0,0 +1,62 @@
+#pragma once
+
+#include <string>
+
+#include <QDateTime>
+#include <QString>
+
+#include <mtx/events/collections.hpp>
+
+namespace mtx::accessors {
+std::string
+event_id(const mtx::events::collections::TimelineEvents &event);
+
+std::string
+room_id(const mtx::events::collections::TimelineEvents &event);
+
+std::string
+sender(const mtx::events::collections::TimelineEvents &event);
+
+QDateTime
+origin_server_ts(const mtx::events::collections::TimelineEvents &event);
+
+std::string
+filename(const mtx::events::collections::TimelineEvents &event);
+
+mtx::events::MessageType
+msg_type(const mtx::events::collections::TimelineEvents &event);
+std::string
+room_name(const mtx::events::collections::TimelineEvents &event);
+std::string
+room_topic(const mtx::events::collections::TimelineEvents &event);
+
+std::string
+body(const mtx::events::collections::TimelineEvents &event);
+
+std::string
+formatted_body(const mtx::events::collections::TimelineEvents &event);
+
+QString
+formattedBodyWithFallback(const mtx::events::collections::TimelineEvents &event);
+
+std::optional<mtx::crypto::EncryptedFile>
+file(const mtx::events::collections::TimelineEvents &event);
+
+std::string
+url(const mtx::events::collections::TimelineEvents &event);
+std::string
+thumbnail_url(const mtx::events::collections::TimelineEvents &event);
+std::string
+mimetype(const mtx::events::collections::TimelineEvents &event);
+std::string
+in_reply_to_event(const mtx::events::collections::TimelineEvents &event);
+
+int64_t
+filesize(const mtx::events::collections::TimelineEvents &event);
+
+uint64_t
+media_height(const mtx::events::collections::TimelineEvents &event);
+
+uint64_t
+media_width(const mtx::events::collections::TimelineEvents &event);
+}
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index ce238d94..593a21df 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -9,6 +9,7 @@
 #include <QStandardPaths>
 
 #include "ChatPage.h"
+#include "EventAccessors.h"
 #include "Logging.h"
 #include "MainWindow.h"
 #include "MatrixClient.h"
@@ -21,364 +22,100 @@
 Q_DECLARE_METATYPE(QModelIndex)
 
 namespace {
-template<class T>
-QString
-eventId(const mtx::events::RoomEvent<T> &event)
-{
-        return QString::fromStdString(event.event_id);
-}
-template<class T>
-QString
-roomId(const mtx::events::Event<T> &event)
-{
-        return QString::fromStdString(event.room_id);
-}
-template<class T>
-QString
-senderId(const mtx::events::RoomEvent<T> &event)
-{
-        return QString::fromStdString(event.sender);
-}
-
-template<class T>
-QDateTime
-eventTimestamp(const mtx::events::RoomEvent<T> &event)
-{
-        return QDateTime::fromMSecsSinceEpoch(event.origin_server_ts);
-}
-
-template<class T>
-std::string
-eventMsgType(const mtx::events::Event<T> &)
-{
-        return "";
-}
-template<class T>
-auto
-eventMsgType(const mtx::events::RoomEvent<T> &e) -> decltype(e.content.msgtype)
-{
-        return e.content.msgtype;
-}
-
-template<class T>
-QString
-eventRoomName(const T &)
-{
-        return "";
-}
-QString
-eventRoomName(const mtx::events::StateEvent<mtx::events::state::Name> &e)
-{
-        return QString::fromStdString(e.content.name);
-}
-
-template<class T>
-QString
-eventRoomTopic(const T &)
-{
-        return "";
-}
-QString
-eventRoomTopic(const mtx::events::StateEvent<mtx::events::state::Topic> &e)
-{
-        return QString::fromStdString(e.content.topic);
-}
-
-template<class T>
-QString
-eventBody(const mtx::events::Event<T> &)
-{
-        return QString("");
-}
-template<class T>
-auto
-eventBody(const mtx::events::RoomEvent<T> &e)
-  -> std::enable_if_t<std::is_same<decltype(e.content.body), std::string>::value, QString>
-{
-        return QString::fromStdString(e.content.body);
-}
-
-template<class T>
-QString
-eventFormattedBody(const mtx::events::Event<T> &)
-{
-        return QString("");
-}
-template<class T>
-auto
-eventFormattedBody(const mtx::events::RoomEvent<T> &e)
-  -> std::enable_if_t<std::is_same<decltype(e.content.formatted_body), std::string>::value, QString>
+struct RoomEventType
 {
-        auto temp = e.content.formatted_body;
-        if (!temp.empty()) {
-                return QString::fromStdString(temp);
-        } else {
-                return QString::fromStdString(e.content.body).toHtmlEscaped().replace("\n", "<br>");
+        template<class T>
+        qml_mtx_events::EventType operator()(const mtx::events::Event<T> &e)
+        {
+                using mtx::events::EventType;
+                switch (e.type) {
+                case EventType::RoomKeyRequest:
+                        return qml_mtx_events::EventType::KeyRequest;
+                case EventType::RoomAliases:
+                        return qml_mtx_events::EventType::Aliases;
+                case EventType::RoomAvatar:
+                        return qml_mtx_events::EventType::Avatar;
+                case EventType::RoomCanonicalAlias:
+                        return qml_mtx_events::EventType::CanonicalAlias;
+                case EventType::RoomCreate:
+                        return qml_mtx_events::EventType::Create;
+                case EventType::RoomEncrypted:
+                        return qml_mtx_events::EventType::Encrypted;
+                case EventType::RoomEncryption:
+                        return qml_mtx_events::EventType::Encryption;
+                case EventType::RoomGuestAccess:
+                        return qml_mtx_events::EventType::GuestAccess;
+                case EventType::RoomHistoryVisibility:
+                        return qml_mtx_events::EventType::HistoryVisibility;
+                case EventType::RoomJoinRules:
+                        return qml_mtx_events::EventType::JoinRules;
+                case EventType::RoomMember:
+                        return qml_mtx_events::EventType::Member;
+                case EventType::RoomMessage:
+                        return qml_mtx_events::EventType::UnknownMessage;
+                case EventType::RoomName:
+                        return qml_mtx_events::EventType::Name;
+                case EventType::RoomPowerLevels:
+                        return qml_mtx_events::EventType::PowerLevels;
+                case EventType::RoomTopic:
+                        return qml_mtx_events::EventType::Topic;
+                case EventType::RoomTombstone:
+                        return qml_mtx_events::EventType::Tombstone;
+                case EventType::RoomRedaction:
+                        return qml_mtx_events::EventType::Redaction;
+                case EventType::RoomPinnedEvents:
+                        return qml_mtx_events::EventType::PinnedEvents;
+                case EventType::Sticker:
+                        return qml_mtx_events::EventType::Sticker;
+                case EventType::Tag:
+                        return qml_mtx_events::EventType::Tag;
+                case EventType::Unsupported:
+                default:
+                        return qml_mtx_events::EventType::Unsupported;
+                }
+        }
+        qml_mtx_events::EventType operator()(const mtx::events::Event<mtx::events::msg::Audio> &)
+        {
+                return qml_mtx_events::EventType::AudioMessage;
+        }
+        qml_mtx_events::EventType operator()(const mtx::events::Event<mtx::events::msg::Emote> &)
+        {
+                return qml_mtx_events::EventType::EmoteMessage;
+        }
+        qml_mtx_events::EventType operator()(const mtx::events::Event<mtx::events::msg::File> &)
+        {
+                return qml_mtx_events::EventType::FileMessage;
+        }
+        qml_mtx_events::EventType operator()(const mtx::events::Event<mtx::events::msg::Image> &)
+        {
+                return qml_mtx_events::EventType::ImageMessage;
+        }
+        qml_mtx_events::EventType operator()(const mtx::events::Event<mtx::events::msg::Notice> &)
+        {
+                return qml_mtx_events::EventType::NoticeMessage;
+        }
+        qml_mtx_events::EventType operator()(const mtx::events::Event<mtx::events::msg::Text> &)
+        {
+                return qml_mtx_events::EventType::TextMessage;
+        }
+        qml_mtx_events::EventType operator()(const mtx::events::Event<mtx::events::msg::Video> &)
+        {
+                return qml_mtx_events::EventType::VideoMessage;
         }
-}
-
-template<class T>
-std::optional<mtx::crypto::EncryptedFile>
-eventEncryptionInfo(const mtx::events::Event<T> &)
-{
-        return std::nullopt;
-}
-
-template<class T>
-auto
-eventEncryptionInfo(const mtx::events::RoomEvent<T> &e) -> std::enable_if_t<
-  std::is_same<decltype(e.content.file), std::optional<mtx::crypto::EncryptedFile>>::value,
-  std::optional<mtx::crypto::EncryptedFile>>
-{
-        return e.content.file;
-}
-
-template<class T>
-QString
-eventUrl(const mtx::events::Event<T> &)
-{
-        return "";
-}
-
-QString
-eventUrl(const mtx::events::StateEvent<mtx::events::state::Avatar> &e)
-{
-        return QString::fromStdString(e.content.url);
-}
-
-template<class T>
-auto
-eventUrl(const mtx::events::RoomEvent<T> &e)
-  -> std::enable_if_t<std::is_same<decltype(e.content.url), std::string>::value, QString>
-{
-        if (e.content.file)
-                return QString::fromStdString(e.content.file->url);
-        return QString::fromStdString(e.content.url);
-}
-
-template<class T>
-QString
-eventThumbnailUrl(const mtx::events::Event<T> &)
-{
-        return "";
-}
-template<class T>
-auto
-eventThumbnailUrl(const mtx::events::RoomEvent<T> &e)
-  -> std::enable_if_t<std::is_same<decltype(e.content.info.thumbnail_url), std::string>::value,
-                      QString>
-{
-        return QString::fromStdString(e.content.info.thumbnail_url);
-}
-
-template<class T>
-QString
-eventFilename(const mtx::events::Event<T> &)
-{
-        return "";
-}
-QString
-eventFilename(const mtx::events::RoomEvent<mtx::events::msg::Audio> &e)
-{
-        // body may be the original filename
-        return QString::fromStdString(e.content.body);
-}
-QString
-eventFilename(const mtx::events::RoomEvent<mtx::events::msg::Video> &e)
-{
-        // body may be the original filename
-        return QString::fromStdString(e.content.body);
-}
-QString
-eventFilename(const mtx::events::RoomEvent<mtx::events::msg::Image> &e)
-{
-        // body may be the original filename
-        return QString::fromStdString(e.content.body);
-}
-QString
-eventFilename(const mtx::events::RoomEvent<mtx::events::msg::File> &e)
-{
-        // body may be the original filename
-        if (!e.content.filename.empty())
-                return QString::fromStdString(e.content.filename);
-        return QString::fromStdString(e.content.body);
-}
-
-template<class T>
-auto
-eventFilesize(const mtx::events::RoomEvent<T> &e) -> decltype(e.content.info.size)
-{
-        return e.content.info.size;
-}
-
-template<class T>
-int64_t
-eventFilesize(const mtx::events::Event<T> &)
-{
-        return 0;
-}
-
-template<class T>
-QString
-eventMimeType(const mtx::events::Event<T> &)
-{
-        return QString();
-}
-template<class T>
-auto
-eventMimeType(const mtx::events::RoomEvent<T> &e)
-  -> std::enable_if_t<std::is_same<decltype(e.content.info.mimetype), std::string>::value, QString>
-{
-        return QString::fromStdString(e.content.info.mimetype);
-}
-
-template<class T>
-QString
-eventRelatesTo(const mtx::events::Event<T> &)
-{
-        return QString();
-}
-template<class T>
-auto
-eventRelatesTo(const mtx::events::RoomEvent<T> &e) -> std::enable_if_t<
-  std::is_same<decltype(e.content.relates_to.in_reply_to.event_id), std::string>::value,
-  QString>
-{
-        return QString::fromStdString(e.content.relates_to.in_reply_to.event_id);
-}
 
-template<class T>
-qml_mtx_events::EventType
-toRoomEventType(const mtx::events::Event<T> &e)
-{
-        using mtx::events::EventType;
-        switch (e.type) {
-        case EventType::RoomKeyRequest:
-                return qml_mtx_events::EventType::KeyRequest;
-        case EventType::RoomAliases:
-                return qml_mtx_events::EventType::Aliases;
-        case EventType::RoomAvatar:
-                return qml_mtx_events::EventType::Avatar;
-        case EventType::RoomCanonicalAlias:
-                return qml_mtx_events::EventType::CanonicalAlias;
-        case EventType::RoomCreate:
-                return qml_mtx_events::EventType::Create;
-        case EventType::RoomEncrypted:
-                return qml_mtx_events::EventType::Encrypted;
-        case EventType::RoomEncryption:
-                return qml_mtx_events::EventType::Encryption;
-        case EventType::RoomGuestAccess:
-                return qml_mtx_events::EventType::GuestAccess;
-        case EventType::RoomHistoryVisibility:
-                return qml_mtx_events::EventType::HistoryVisibility;
-        case EventType::RoomJoinRules:
-                return qml_mtx_events::EventType::JoinRules;
-        case EventType::RoomMember:
-                return qml_mtx_events::EventType::Member;
-        case EventType::RoomMessage:
-                return qml_mtx_events::EventType::UnknownMessage;
-        case EventType::RoomName:
-                return qml_mtx_events::EventType::Name;
-        case EventType::RoomPowerLevels:
-                return qml_mtx_events::EventType::PowerLevels;
-        case EventType::RoomTopic:
-                return qml_mtx_events::EventType::Topic;
-        case EventType::RoomTombstone:
-                return qml_mtx_events::EventType::Tombstone;
-        case EventType::RoomRedaction:
-                return qml_mtx_events::EventType::Redaction;
-        case EventType::RoomPinnedEvents:
-                return qml_mtx_events::EventType::PinnedEvents;
-        case EventType::Sticker:
-                return qml_mtx_events::EventType::Sticker;
-        case EventType::Tag:
-                return qml_mtx_events::EventType::Tag;
-        case EventType::Unsupported:
-        default:
-                return qml_mtx_events::EventType::Unsupported;
+        qml_mtx_events::EventType operator()(const mtx::events::Event<mtx::events::msg::Redacted> &)
+        {
+                return qml_mtx_events::EventType::Redacted;
         }
-}
-qml_mtx_events::EventType
-toRoomEventType(const mtx::events::Event<mtx::events::msg::Audio> &)
-{
-        return qml_mtx_events::EventType::AudioMessage;
-}
-qml_mtx_events::EventType
-toRoomEventType(const mtx::events::Event<mtx::events::msg::Emote> &)
-{
-        return qml_mtx_events::EventType::EmoteMessage;
-}
-qml_mtx_events::EventType
-toRoomEventType(const mtx::events::Event<mtx::events::msg::File> &)
-{
-        return qml_mtx_events::EventType::FileMessage;
-}
-qml_mtx_events::EventType
-toRoomEventType(const mtx::events::Event<mtx::events::msg::Image> &)
-{
-        return qml_mtx_events::EventType::ImageMessage;
-}
-qml_mtx_events::EventType
-toRoomEventType(const mtx::events::Event<mtx::events::msg::Notice> &)
-{
-        return qml_mtx_events::EventType::NoticeMessage;
-}
-qml_mtx_events::EventType
-toRoomEventType(const mtx::events::Event<mtx::events::msg::Text> &)
-{
-        return qml_mtx_events::EventType::TextMessage;
-}
-qml_mtx_events::EventType
-toRoomEventType(const mtx::events::Event<mtx::events::msg::Video> &)
-{
-        return qml_mtx_events::EventType::VideoMessage;
+        // ::EventType::Type operator()(const Event<mtx::events::msg::Location> &e) { return
+        // ::EventType::LocationMessage; }
+};
 }
 
 qml_mtx_events::EventType
-toRoomEventType(const mtx::events::Event<mtx::events::msg::Redacted> &)
-{
-        return qml_mtx_events::EventType::Redacted;
-}
-// ::EventType::Type toRoomEventType(const Event<mtx::events::msg::Location> &e) { return
-// ::EventType::LocationMessage; }
-
-template<class T>
-uint64_t
-eventHeight(const mtx::events::Event<T> &)
-{
-        return -1;
-}
-template<class T>
-auto
-eventHeight(const mtx::events::RoomEvent<T> &e) -> decltype(e.content.info.h)
-{
-        return e.content.info.h;
-}
-template<class T>
-uint64_t
-eventWidth(const mtx::events::Event<T> &)
-{
-        return -1;
-}
-template<class T>
-auto
-eventWidth(const mtx::events::RoomEvent<T> &e) -> decltype(e.content.info.w)
+toRoomEventType(const mtx::events::collections::TimelineEvents &event)
 {
-        return e.content.info.w;
-}
-
-template<class T>
-double
-eventPropHeight(const mtx::events::RoomEvent<T> &e)
-{
-        auto w = eventWidth(e);
-        if (w == 0)
-                w = 1;
-
-        double prop = eventHeight(e) / (double)w;
-
-        return prop > 0 ? prop : 1.;
-}
+        return std::visit(RoomEventType{}, event);
 }
 
 TimelineModel::TimelineModel(TimelineViewManager *manager, QString room_id, QObject *parent)
@@ -477,6 +214,8 @@ TimelineModel::rowCount(const QModelIndex &parent) const
 QVariant
 TimelineModel::data(const QModelIndex &index, int role) const
 {
+        using namespace mtx::accessors;
+        namespace acc = mtx::accessors;
         if (index.row() < 0 && index.row() >= (int)eventOrder.size())
                 return QVariant();
 
@@ -491,86 +230,71 @@ TimelineModel::data(const QModelIndex &index, int role) const
 
         switch (role) {
         case Section: {
-                QDateTime date =
-                  std::visit([](const auto &e) -> QDateTime { return eventTimestamp(e); }, event);
+                QDateTime date = origin_server_ts(event);
                 date.setTime(QTime());
 
-                QString userId =
-                  std::visit([](const auto &e) -> QString { return senderId(e); }, event);
+                std::string userId = acc::sender(event);
 
                 for (int r = index.row() - 1; r > 0; r--) {
                         auto tempEv        = events.value(eventOrder[r]);
-                        QDateTime prevDate = std::visit(
-                          [](const auto &e) -> QDateTime { return eventTimestamp(e); }, tempEv);
+                        QDateTime prevDate = origin_server_ts(tempEv);
                         prevDate.setTime(QTime());
                         if (prevDate != date)
-                                return QString("%2 %1").arg(date.toMSecsSinceEpoch()).arg(userId);
+                                return QString("%2 %1")
+                                  .arg(date.toMSecsSinceEpoch())
+                                  .arg(QString::fromStdString(userId));
 
-                        QString prevUserId =
-                          std::visit([](const auto &e) -> QString { return senderId(e); }, tempEv);
+                        std::string prevUserId = acc::sender(tempEv);
                         if (userId != prevUserId)
                                 break;
                 }
 
-                return QString("%1").arg(userId);
+                return QString("%1").arg(QString::fromStdString(userId));
         }
         case UserId:
-                return QVariant(
-                  std::visit([](const auto &e) -> QString { return senderId(e); }, event));
+                return QVariant(QString::fromStdString(acc::sender(event)));
         case UserName:
-                return QVariant(displayName(
-                  std::visit([](const auto &e) -> QString { return senderId(e); }, event)));
+                return QVariant(displayName(QString::fromStdString(acc::sender(event))));
 
         case Timestamp:
-                return QVariant(
-                  std::visit([](const auto &e) -> QDateTime { return eventTimestamp(e); }, event));
+                return QVariant(origin_server_ts(event));
         case Type:
-                return QVariant(std::visit(
-                  [](const auto &e) -> qml_mtx_events::EventType { return toRoomEventType(e); },
-                  event));
+                return QVariant(toRoomEventType(event));
         case Body:
-                return QVariant(utils::replaceEmoji(
-                  std::visit([](const auto &e) -> QString { return eventBody(e); }, event)));
+                return QVariant(utils::replaceEmoji(QString::fromStdString(body(event))));
         case FormattedBody:
                 return QVariant(
-                  utils::replaceEmoji(
-                    utils::linkifyMessage(std::visit(
-                      [](const auto &e) -> QString { return eventFormattedBody(e); }, event)))
+                  utils::replaceEmoji(utils::linkifyMessage(formattedBodyWithFallback(event)))
                     .remove("<mx-reply>")
                     .remove("</mx-reply>"));
         case Url:
-                return QVariant(
-                  std::visit([](const auto &e) -> QString { return eventUrl(e); }, event));
+                return QVariant(QString::fromStdString(url(event)));
         case ThumbnailUrl:
-                return QVariant(
-                  std::visit([](const auto &e) -> QString { return eventThumbnailUrl(e); }, event));
+                return QVariant(QString::fromStdString(thumbnail_url(event)));
         case Filename:
-                return QVariant(
-                  std::visit([](const auto &e) -> QString { return eventFilename(e); }, event));
+                return QVariant(QString::fromStdString(filename(event)));
         case Filesize:
-                return QVariant(std::visit(
-                  [](const auto &e) -> QString {
-                          return utils::humanReadableFileSize(eventFilesize(e));
-                  },
-                  event));
+                return QVariant(utils::humanReadableFileSize(filesize(event)));
         case MimeType:
-                return QVariant(
-                  std::visit([](const auto &e) -> QString { return eventMimeType(e); }, event));
+                return QVariant(QString::fromStdString(mimetype(event)));
         case Height:
-                return QVariant(
-                  std::visit([](const auto &e) -> qulonglong { return eventHeight(e); }, event));
+                return QVariant(qulonglong{media_height(event)});
         case Width:
-                return QVariant(
-                  std::visit([](const auto &e) -> qulonglong { return eventWidth(e); }, event));
-        case ProportionalHeight:
-                return QVariant(
-                  std::visit([](const auto &e) -> double { return eventPropHeight(e); }, event));
+                return QVariant(qulonglong{media_width(event)});
+        case ProportionalHeight: {
+                auto w = media_width(event);
+                if (w == 0)
+                        w = 1;
+
+                double prop = media_height(event) / (double)w;
+
+                return QVariant(prop > 0 ? prop : 1.);
+        }
         case Id:
                 return id;
         case State:
                 // only show read receipts for messages not from us
-                if (std::visit([](const auto &e) -> QString { return senderId(e); }, event)
-                      .toStdString() != http::client()->user_id().to_string())
+                if (acc::sender(event) != http::client()->user_id().to_string())
                         return qml_mtx_events::Empty;
                 else if (failed.contains(id))
                         return qml_mtx_events::Failed;
@@ -581,21 +305,15 @@ TimelineModel::data(const QModelIndex &index, int role) const
                 else
                         return qml_mtx_events::Received;
         case IsEncrypted: {
-                auto tempEvent = events[id];
                 return std::holds_alternative<
-                  mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(tempEvent);
-        }
-        case ReplyTo: {
-                QString evId =
-                  std::visit([](const auto &e) -> QString { return eventRelatesTo(e); }, event);
-                return QVariant(evId);
+                  mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(events[id]);
         }
+        case ReplyTo:
+                return QVariant(QString::fromStdString(in_reply_to_event(event)));
         case RoomName:
-                return QVariant(
-                  std::visit([](const auto &e) -> QString { return eventRoomName(e); }, event));
+                return QVariant(QString::fromStdString(room_name(event)));
         case RoomTopic:
-                return QVariant(
-                  std::visit([](const auto &e) -> QString { return eventRoomTopic(e); }, event));
+                return QVariant(QString::fromStdString(room_topic(event)));
         default:
                 return QVariant();
         }
@@ -667,7 +385,7 @@ TimelineModel::internalAddEvents(
 {
         std::vector<QString> ids;
         for (auto e : timeline) {
-                QString id = std::visit([](const auto &e) -> QString { return eventId(e); }, e);
+                QString id = QString::fromStdString(mtx::accessors::event_id(e));
 
                 if (this->events.contains(id)) {
                         this->events.insert(id, e);
@@ -708,11 +426,7 @@ TimelineModel::internalAddEvents(
                       std::get_if<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(&e)) {
                         e = decryptEvent(*event).event;
                 }
-                auto encInfo = std::visit(
-                  [](const auto &ev) -> std::optional<mtx::crypto::EncryptedFile> {
-                          return eventEncryptionInfo(ev);
-                  },
-                  e);
+                auto encInfo = mtx::accessors::file(e);
 
                 if (encInfo)
                         emit newEncryptedImage(encInfo.value());
@@ -950,25 +664,18 @@ TimelineModel::replyAction(QString id)
                 event = decryptEvent(*e).event;
         }
 
-        RelatedInfo related = std::visit(
-          [](const auto &ev) -> RelatedInfo {
-                  RelatedInfo related_   = {};
-                  related_.quoted_user   = QString::fromStdString(ev.sender);
-                  related_.related_event = ev.event_id;
-                  return related_;
-          },
-          event);
-        related.type = mtx::events::getMessageType(
-          std::visit([](const auto &e) -> std::string { return eventMsgType(e); }, event));
-        related.quoted_body =
-          std::visit([](const auto &e) -> QString { return eventFormattedBody(e); }, event);
+        RelatedInfo related   = {};
+        related.quoted_user   = QString::fromStdString(mtx::accessors::sender(event));
+        related.related_event = mtx::accessors::event_id(event);
+        related.type          = mtx::accessors::msg_type(event);
+        related.quoted_body   = mtx::accessors::formattedBodyWithFallback(event);
         related.quoted_body.remove(QRegularExpression(
           "<mx-reply>.*</mx-reply>", QRegularExpression::DotMatchesEverythingOption));
         nhlog::ui()->debug("after replacement: {}", related.quoted_body.toStdString());
         related.room = room_id_;
 
-        if (related.quoted_body.isEmpty())
-                return;
+        // if (related.quoted_body.isEmpty())
+        //        return;
 
         ChatPage::instance()->messageReply(related);
 }
@@ -1412,8 +1119,7 @@ TimelineModel::addPendingMessage(mtx::events::collections::TimelineEvents event)
 
         internalAddEvents({event});
 
-        QString txn_id_qstr =
-          std::visit([](const auto &e) -> QString { return eventId(e); }, event);
+        QString txn_id_qstr = QString::fromStdString(mtx::accessors::event_id(event));
         beginInsertRows(QModelIndex(),
                         static_cast<int>(this->eventOrder.size()),
                         static_cast<int>(this->eventOrder.size()));
@@ -1436,18 +1142,13 @@ TimelineModel::saveMedia(QString eventId) const
                 event = decryptEvent(*e).event;
         }
 
-        QString mxcUrl = std::visit([](const auto &e) -> QString { return eventUrl(e); }, event);
-        QString originalFilename =
-          std::visit([](const auto &e) -> QString { return eventFilename(e); }, event);
-        QString mimeType =
-          std::visit([](const auto &e) -> QString { return eventMimeType(e); }, event);
+        QString mxcUrl           = QString::fromStdString(mtx::accessors::url(event));
+        QString originalFilename = QString::fromStdString(mtx::accessors::filename(event));
+        QString mimeType         = QString::fromStdString(mtx::accessors::mimetype(event));
 
-        using EncF = std::optional<mtx::crypto::EncryptedFile>;
-        EncF encryptionInfo =
-          std::visit([](const auto &e) -> EncF { return eventEncryptionInfo(e); }, event);
+        auto encryptionInfo = mtx::accessors::file(event);
 
-        qml_mtx_events::EventType eventType = std::visit(
-          [](const auto &e) -> qml_mtx_events::EventType { return toRoomEventType(e); }, event);
+        qml_mtx_events::EventType eventType = toRoomEventType(event);
 
         QString dialogTitle;
         if (eventType == qml_mtx_events::EventType::ImageMessage) {
@@ -1513,13 +1214,11 @@ TimelineModel::cacheMedia(QString eventId)
                 event = decryptEvent(*e).event;
         }
 
-        QString mxcUrl = std::visit([](const auto &e) -> QString { return eventUrl(e); }, event);
-        QString mimeType =
-          std::visit([](const auto &e) -> QString { return eventMimeType(e); }, event);
+        QString mxcUrl           = QString::fromStdString(mtx::accessors::url(event));
+        QString originalFilename = QString::fromStdString(mtx::accessors::filename(event));
+        QString mimeType         = QString::fromStdString(mtx::accessors::mimetype(event));
 
-        using EncF = std::optional<mtx::crypto::EncryptedFile>;
-        EncF encryptionInfo =
-          std::visit([](const auto &e) -> EncF { return eventEncryptionInfo(e); }, event);
+        auto encryptionInfo = mtx::accessors::file(event);
 
         // If the message is a link to a non mxcUrl, don't download it
         if (!mxcUrl.startsWith("mxc://")) {
-- 
cgit 1.5.1


From 946ab4d0f287307c24e310c6d2faef931f094ec5 Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Fri, 3 Jan 2020 23:21:33 +0100
Subject: invert timeline

---
 resources/qml/TimelineView.qml | 56 +++++++++++++++++++++++++++++++++++-------
 src/timeline/TimelineModel.cpp | 52 ++++++++++++++++++++++++++++++---------
 src/timeline/TimelineModel.h   |  1 +
 3 files changed, 88 insertions(+), 21 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/resources/qml/TimelineView.qml b/resources/qml/TimelineView.qml
index 1a1900ad..6bc2eb53 100644
--- a/resources/qml/TimelineView.qml
+++ b/resources/qml/TimelineView.qml
@@ -115,30 +115,68 @@ Item {
 			onMovementEnded: updatePosition()
 
 			spacing: 4
-			delegate: TimelineRow {
+			verticalLayoutDirection: ListView.BottomToTop
+
+			delegate: Rectangle {
+				// This would normally be previousSection, but our model's order is inverted.
+				property bool sectionBoundary: (ListView.nextSection != "" && ListView.nextSection !== ListView.section) || model.index === chat.count - 1
+
+				id: wrapper
+				property Item section
+				width: chat.width
+				height: section ? section.height + timelinerow.height : timelinerow.height
+
+				TimelineRow {
+					id: timelinerow
+					y: section ? section.y + section.height : 0
+				}
 				function isFullyVisible() {
 					return height > 1 && (y - chat.contentY - 1) + height < chat.height
 				}
 				function getIndex() {
 					return index;
 				}
+
+				onSectionBoundaryChanged: {
+					if (sectionBoundary) {
+						var properties = {
+							'modelData': model.dump,
+							'section': ListView.section,
+							'nextSection': ListView.nextSection
+						}
+						section = sectionHeader.createObject(wrapper, properties)
+					} else {
+						section.destroy()
+						section = null
+					}
+				}
+
 			}
 
 			section {
 				property: "section"
-				delegate: Column {
+			}
+			Component {
+				id: sectionHeader
+				Column {
+					property var modelData
+					property string section
+					property string nextSection
+
 					topPadding: 4
 					bottomPadding: 4
 					spacing: 8
 
+					visible: !!modelData
+
 					width: parent.width
 					height: (section.includes(" ") ? dateBubble.height + 8 + userName.height : userName.height) + 8
 
 					Label {
 						id: dateBubble
-						anchors.horizontalCenter: parent.horizontalCenter
+						anchors.horizontalCenter: parent ? parent.horizontalCenter : undefined
 						visible: section.includes(" ")
-						text: chat.model.formatDateSeparator(new Date(Number(section.split(" ")[1])))
+						text: chat.model.formatDateSeparator(modelData.timestamp)
 						color: colors.windowText
 
 						height: contentHeight * 1.2
@@ -155,20 +193,20 @@ Item {
 						Avatar {
 							width: avatarSize
 							height: avatarSize
-							url: chat.model.avatarUrl(section.split(" ")[0]).replace("mxc://", "image://MxcImage/")
-							displayName: chat.model.displayName(section.split(" ")[0])
+							url: chat.model.avatarUrl(modelData.userId).replace("mxc://", "image://MxcImage/")
+							displayName: modelData.userName
 
 							MouseArea {
 								anchors.fill: parent
-								onClicked: chat.model.openUserProfile(section.split(" ")[0])
+								onClicked: chat.model.openUserProfile(modelData.userId)
 								cursorShape: Qt.PointingHandCursor
 							}
 						}
 
 						Text { 
 							id: userName
-							text: chat.model.escapeEmoji(chat.model.displayName(section.split(" ")[0]))
-							color: chat.model.userColor(section.split(" ")[0], colors.window)
+							text: chat.model.escapeEmoji(modelData.userName)
+							color: chat.model.userColor(modelData.userId, colors.window)
 							textFormat: Text.RichText
 
 							MouseArea {
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 593a21df..8746a31f 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -202,6 +202,7 @@ TimelineModel::roleNames() const
           {ReplyTo, "replyTo"},
           {RoomName, "roomName"},
           {RoomTopic, "roomTopic"},
+          {Dump, "dump"},
         };
 }
 int
@@ -235,7 +236,7 @@ TimelineModel::data(const QModelIndex &index, int role) const
 
                 std::string userId = acc::sender(event);
 
-                for (int r = index.row() - 1; r > 0; r--) {
+                for (size_t r = index.row() + 1; r < eventOrder.size(); r++) {
                         auto tempEv        = events.value(eventOrder[r]);
                         QDateTime prevDate = origin_server_ts(tempEv);
                         prevDate.setTime(QTime());
@@ -314,6 +315,35 @@ TimelineModel::data(const QModelIndex &index, int role) const
                 return QVariant(QString::fromStdString(room_name(event)));
         case RoomTopic:
                 return QVariant(QString::fromStdString(room_topic(event)));
+        case Dump: {
+                QVariantMap m;
+                auto names = roleNames();
+
+                // m.insert(names[Section], data(index, static_cast<int>(Section)));
+                m.insert(names[Type], data(index, static_cast<int>(Type)));
+                m.insert(names[Body], data(index, static_cast<int>(Body)));
+                m.insert(names[FormattedBody], data(index, static_cast<int>(FormattedBody)));
+                m.insert(names[UserId], data(index, static_cast<int>(UserId)));
+                m.insert(names[UserName], data(index, static_cast<int>(UserName)));
+                m.insert(names[Timestamp], data(index, static_cast<int>(Timestamp)));
+                m.insert(names[Url], data(index, static_cast<int>(Url)));
+                m.insert(names[ThumbnailUrl], data(index, static_cast<int>(ThumbnailUrl)));
+                m.insert(names[Filename], data(index, static_cast<int>(Filename)));
+                m.insert(names[Filesize], data(index, static_cast<int>(Filesize)));
+                m.insert(names[MimeType], data(index, static_cast<int>(MimeType)));
+                m.insert(names[Height], data(index, static_cast<int>(Height)));
+                m.insert(names[Width], data(index, static_cast<int>(Width)));
+                m.insert(names[ProportionalHeight],
+                         data(index, static_cast<int>(ProportionalHeight)));
+                m.insert(names[Id], data(index, static_cast<int>(Id)));
+                m.insert(names[State], data(index, static_cast<int>(State)));
+                m.insert(names[IsEncrypted], data(index, static_cast<int>(IsEncrypted)));
+                m.insert(names[ReplyTo], data(index, static_cast<int>(ReplyTo)));
+                m.insert(names[RoomName], data(index, static_cast<int>(RoomName)));
+                m.insert(names[RoomTopic], data(index, static_cast<int>(RoomTopic)));
+
+                return QVariant(m);
+        }
         default:
                 return QVariant();
         }
@@ -335,10 +365,8 @@ TimelineModel::addEvents(const mtx::responses::Timeline &timeline)
         if (ids.empty())
                 return;
 
-        beginInsertRows(QModelIndex(),
-                        static_cast<int>(this->eventOrder.size()),
-                        static_cast<int>(this->eventOrder.size() + ids.size() - 1));
-        this->eventOrder.insert(this->eventOrder.end(), ids.begin(), ids.end());
+        beginInsertRows(QModelIndex(), 0, static_cast<int>(ids.size() - 1));
+        this->eventOrder.insert(this->eventOrder.begin(), ids.rbegin(), ids.rend());
         endInsertRows();
 
         updateLastMessage();
@@ -362,7 +390,7 @@ isMessage(const mtx::events::Event<T> &)
 void
 TimelineModel::updateLastMessage()
 {
-        for (auto it = eventOrder.rbegin(); it != eventOrder.rend(); ++it) {
+        for (auto it = eventOrder.begin(); it != eventOrder.end(); ++it) {
                 auto event = events.value(*it);
                 if (auto e = std::get_if<mtx::events::EncryptedEvent<mtx::events::msg::Encrypted>>(
                       &event)) {
@@ -499,8 +527,10 @@ TimelineModel::addBackwardsEvents(const mtx::responses::Messages &msgs)
         std::vector<QString> ids = internalAddEvents(msgs.chunk);
 
         if (!ids.empty()) {
-                beginInsertRows(QModelIndex(), 0, static_cast<int>(ids.size() - 1));
-                this->eventOrder.insert(this->eventOrder.begin(), ids.rbegin(), ids.rend());
+                beginInsertRows(QModelIndex(),
+                                static_cast<int>(this->eventOrder.size()),
+                                static_cast<int>(this->eventOrder.size() + ids.size() - 1));
+                this->eventOrder.insert(this->eventOrder.end(), ids.begin(), ids.end());
                 endInsertRows();
         }
 
@@ -1120,11 +1150,9 @@ TimelineModel::addPendingMessage(mtx::events::collections::TimelineEvents event)
         internalAddEvents({event});
 
         QString txn_id_qstr = QString::fromStdString(mtx::accessors::event_id(event));
-        beginInsertRows(QModelIndex(),
-                        static_cast<int>(this->eventOrder.size()),
-                        static_cast<int>(this->eventOrder.size()));
+        beginInsertRows(QModelIndex(), 0, 0);
         pending.push_back(txn_id_qstr);
-        this->eventOrder.insert(this->eventOrder.end(), txn_id_qstr);
+        this->eventOrder.insert(this->eventOrder.begin(), txn_id_qstr);
         endInsertRows();
         updateLastMessage();
 
diff --git a/src/timeline/TimelineModel.h b/src/timeline/TimelineModel.h
index 7ff80c45..4161a0fc 100644
--- a/src/timeline/TimelineModel.h
+++ b/src/timeline/TimelineModel.h
@@ -147,6 +147,7 @@ public:
                 ReplyTo,
                 RoomName,
                 RoomTopic,
+                Dump,
         };
 
         QHash<int, QByteArray> roleNames() const override;
-- 
cgit 1.5.1


From 5af6f6528ba05974edd359833194c6f1dd3e1c96 Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Mon, 6 Jan 2020 16:42:56 +0100
Subject: Use fetchMore for native lazy loading of item model data

---
 resources/qml/TimelineView.qml |  6 +---
 src/timeline/TimelineModel.cpp | 75 +++++++++++++++++++++++++-----------------
 src/timeline/TimelineModel.h   |  4 ++-
 3 files changed, 48 insertions(+), 37 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/resources/qml/TimelineView.qml b/resources/qml/TimelineView.qml
index 6bc2eb53..18ae3793 100644
--- a/resources/qml/TimelineView.qml
+++ b/resources/qml/TimelineView.qml
@@ -93,13 +93,9 @@ Item {
 					currentIndex = newIndex
 					model.currentIndex = newIndex
 				}
-
-				if (contentHeight < height && model) {
-					model.fetchHistory();
-				}
 			}
 
-			onAtYBeginningChanged: if (atYBeginning) { chat.model.currentIndex = 0; chat.currentIndex = 0; model.fetchHistory(); }
+			onAtYBeginningChanged: if (atYBeginning) { chat.model.currentIndex = 0; chat.currentIndex = 0; }
 
 			function updatePosition() {
 				for (var y = chat.contentY + chat.height; y > chat.height; y -= 9) {
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 8746a31f..3dafb8c2 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -349,6 +349,50 @@ TimelineModel::data(const QModelIndex &index, int role) const
         }
 }
 
+bool
+TimelineModel::canFetchMore(const QModelIndex &) const
+{
+        if (eventOrder.empty())
+                return true;
+        if (!std::holds_alternative<mtx::events::StateEvent<mtx::events::state::Create>>(
+              events[eventOrder.back()]))
+                return true;
+        else
+
+                return false;
+}
+
+void
+TimelineModel::fetchMore(const QModelIndex &)
+{
+        if (paginationInProgress) {
+                nhlog::ui()->warn("Already loading older messages");
+                return;
+        }
+
+        paginationInProgress = true;
+        mtx::http::MessagesOpts opts;
+        opts.room_id = room_id_.toStdString();
+        opts.from    = prev_batch_token_.toStdString();
+
+        nhlog::ui()->debug("Paginationg room {}", opts.room_id);
+
+        http::client()->messages(
+          opts, [this, opts](const mtx::responses::Messages &res, mtx::http::RequestErr err) {
+                  if (err) {
+                          nhlog::net()->error("failed to call /messages ({}): {} - {}",
+                                              opts.room_id,
+                                              mtx::errors::to_string(err->matrix_error.errcode),
+                                              err->matrix_error.error);
+                          paginationInProgress = false;
+                          return;
+                  }
+
+                  emit oldMessagesRetrieved(std::move(res));
+                  paginationInProgress = false;
+          });
+}
+
 void
 TimelineModel::addEvents(const mtx::responses::Timeline &timeline)
 {
@@ -465,37 +509,6 @@ TimelineModel::internalAddEvents(
         return ids;
 }
 
-void
-TimelineModel::fetchHistory()
-{
-        if (paginationInProgress) {
-                nhlog::ui()->warn("Already loading older messages");
-                return;
-        }
-
-        paginationInProgress = true;
-        mtx::http::MessagesOpts opts;
-        opts.room_id = room_id_.toStdString();
-        opts.from    = prev_batch_token_.toStdString();
-
-        nhlog::ui()->info("Paginationg room {}", opts.room_id);
-
-        http::client()->messages(
-          opts, [this, opts](const mtx::responses::Messages &res, mtx::http::RequestErr err) {
-                  if (err) {
-                          nhlog::net()->error("failed to call /messages ({}): {} - {}",
-                                              opts.room_id,
-                                              mtx::errors::to_string(err->matrix_error.errcode),
-                                              err->matrix_error.error);
-                          paginationInProgress = false;
-                          return;
-                  }
-
-                  emit oldMessagesRetrieved(std::move(res));
-                  paginationInProgress = false;
-          });
-}
-
 void
 TimelineModel::setCurrentIndex(int index)
 {
diff --git a/src/timeline/TimelineModel.h b/src/timeline/TimelineModel.h
index 4161a0fc..0f18f7ef 100644
--- a/src/timeline/TimelineModel.h
+++ b/src/timeline/TimelineModel.h
@@ -154,6 +154,9 @@ public:
         int rowCount(const QModelIndex &parent = QModelIndex()) const override;
         QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
 
+        bool canFetchMore(const QModelIndex &) const override;
+        void fetchMore(const QModelIndex &) override;
+
         Q_INVOKABLE QColor userColor(QString id, QColor background);
         Q_INVOKABLE QString displayName(QString id) const;
         Q_INVOKABLE QString avatarUrl(QString id) const;
@@ -175,7 +178,6 @@ public:
         void sendMessage(const T &msg);
 
 public slots:
-        void fetchHistory();
         void setCurrentIndex(int index);
         int currentIndex() const { return idToIndex(currentId); }
         void markEventsAsRead(const std::vector<QString> &event_ids);
-- 
cgit 1.5.1


From 51d7e6499269af9106a8e36a25eb9ac1dfd8c57d Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Mon, 6 Jan 2020 18:08:01 +0100
Subject: Simplify read message logic with inverted timeline

---
 resources/qml/TimelineView.qml | 58 +++++++++---------------------------------
 src/timeline/TimelineModel.cpp |  2 +-
 2 files changed, 13 insertions(+), 47 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/resources/qml/TimelineView.qml b/resources/qml/TimelineView.qml
index 18ae3793..0be8609d 100644
--- a/resources/qml/TimelineView.qml
+++ b/resources/qml/TimelineView.qml
@@ -31,6 +31,7 @@ Item {
 			running: timelineManager.isInitialSync
 			height: 200
 			width: 200
+			z: 3
 		}
 
 		ListView {
@@ -48,8 +49,6 @@ Item {
 
 			boundsBehavior: Flickable.StopAtBounds
 
-			onVerticalOvershootChanged: contentY = contentY - verticalOvershoot
-
 			MouseArea {
 				anchors.fill: parent
 				acceptedButtons: Qt.NoButton
@@ -60,18 +59,7 @@ Item {
 						chat.contentY = chat.contentY - wheel.angleDelta.y
 						wheel.accepted = true
 						chat.forceLayout()
-						chat.updatePosition()
-					}
-				}
-			}
-
-			onModelChanged: {
-				if (model) {
-					currentIndex = model.currentIndex
-					if (model.currentIndex == count - 1) {
-						positionViewAtEnd()
-					} else {
-						positionViewAtIndex(model.currentIndex, ListView.End)
+						chat.returnToBounds()
 					}
 				}
 			}
@@ -82,37 +70,13 @@ Item {
 				anchors.top: chat.top
 				anchors.left: chat.right
 				anchors.bottom: chat.bottom
-				onPressedChanged: if (!pressed) chat.updatePosition()
-			}
-
-			property bool atBottom: false
-			onCountChanged: {
-				if (atBottom) {
-					var newIndex = count - 1 // last index
-					positionViewAtEnd()
-					currentIndex = newIndex
-					model.currentIndex = newIndex
-				}
 			}
 
-			onAtYBeginningChanged: if (atYBeginning) { chat.model.currentIndex = 0; chat.currentIndex = 0; }
-
-			function updatePosition() {
-				for (var y = chat.contentY + chat.height; y > chat.height; y -= 9) {
-					var i = chat.itemAt(100, y);
-					if (!i) continue;
-					if (!i.isFullyVisible()) continue;
-					chat.model.currentIndex = i.getIndex();
-					chat.currentIndex = i.getIndex()
-					atBottom = i.getIndex() == count - 1;
-					break;
-				}
-			}
-			onMovementEnded: updatePosition()
-
 			spacing: 4
 			verticalLayoutDirection: ListView.BottomToTop
 
+			onCountChanged: if (atYEnd) model.currentIndex = 0 // Mark last event as read, since we are at the bottom
+
 			delegate: Rectangle {
 				// This would normally be previousSection, but our model's order is inverted.
 				property bool sectionBoundary: (ListView.nextSection != "" && ListView.nextSection !== ListView.section) || model.index === chat.count - 1
@@ -126,12 +90,6 @@ Item {
 					id: timelinerow
 					y: section ? section.y + section.height : 0
 				}
-				function isFullyVisible() {
-					return height > 1 && (y - chat.contentY - 1) + height < chat.height
-				}
-				function getIndex() {
-					return index;
-				}
 
 				onSectionBoundaryChanged: {
 					if (sectionBoundary) {
@@ -147,6 +105,14 @@ Item {
 					}
 				}
 
+				Binding {
+					target: chat.model
+					property: "currentIndex"
+					when: y + height > chat.contentY + chat.height && y < chat.contentY + chat.height
+					value: index
+					delayed: true
+				}
+
 			}
 
 			section {
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 3dafb8c2..0e7f5259 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -516,7 +516,7 @@ TimelineModel::setCurrentIndex(int index)
         currentId     = indexToId(index);
         emit currentIndexChanged(index);
 
-        if (oldIndex < index && !pending.contains(currentId) &&
+        if ((oldIndex > index || oldIndex == -1) && !pending.contains(currentId) &&
             ChatPage::instance()->isActiveWindow()) {
                 readEvent(currentId.toStdString());
         }
-- 
cgit 1.5.1


From 2b3dc3d8b9d1108c3f6ad226ad65060bd3999033 Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Sat, 11 Jan 2020 14:07:51 +0100
Subject: Implement fancy reply rendering

This currently assumes the event, that is replied to, is already
fetched. If it isn't, it will render an empty reply. In the future we
should fetch replies before rendering them.
---
 resources/qml/TimelineRow.qml                    |  61 +++++++++--
 resources/qml/delegates/FileMessage.qml          |   6 +-
 resources/qml/delegates/ImageMessage.qml         |  12 +--
 resources/qml/delegates/MessageDelegate.qml      | 128 +++++++++++++----------
 resources/qml/delegates/NoticeMessage.qml        |   2 +-
 resources/qml/delegates/Placeholder.qml          |   2 +-
 resources/qml/delegates/PlayableMediaMessage.qml |  16 +--
 resources/qml/delegates/TextMessage.qml          |   2 +-
 src/timeline/TimelineModel.cpp                   |  16 ++-
 src/timeline/TimelineModel.h                     |   1 +
 10 files changed, 159 insertions(+), 87 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/resources/qml/TimelineRow.qml b/resources/qml/TimelineRow.qml
index 2c2ed02a..86780413 100644
--- a/resources/qml/TimelineRow.qml
+++ b/resources/qml/TimelineRow.qml
@@ -14,23 +14,70 @@ RowLayout {
 	anchors.left: parent.left
 	anchors.right: parent.right
 
-	height: Math.max(contentItem.height, 16)
+	//height: Math.max(model.replyTo ? reply.height + contentItem.height + 4 : contentItem.height, 16)
 
 	Column {
 		Layout.fillWidth: true
 		Layout.alignment: Qt.AlignTop
+		spacing: 4
 
-		//property var replyTo: model.replyTo
+		// fancy reply, if this is a reply
+		Rectangle {
+			visible: model.replyTo
+			width: parent.width
+			height: replyContainer.height
+
+			Rectangle {
+				id: colorLine
+				height: replyContainer.height
+				width: 4
+				color: chat.model.userColor(reply.modelData.userId, colors.window)
+			}
+
+			Column {
+				id: replyContainer
+				anchors.left: colorLine.right
+				anchors.leftMargin: 4
+				width: parent.width - 8
+
+
+				Text { 
+					id: userName
+					text: chat.model.escapeEmoji(reply.modelData.userName)
+					color: chat.model.userColor(reply.modelData.userId, colors.window)
+					textFormat: Text.RichText
+
+					MouseArea {
+						anchors.fill: parent
+						onClicked: chat.model.openUserProfile(reply.modelData.userId)
+						cursorShape: Qt.PointingHandCursor
+					}
+				}
+
+				MessageDelegate {
+					id: reply
+					width: parent.width
 
-		//Text {
-		//	property int idx: timelineManager.timeline.idToIndex(replyTo)
-		//	text: "" + (idx != -1 ? timelineManager.timeline.data(timelineManager.timeline.index(idx, 0), 2) : "nothing")
-		//}
+					modelData: chat.model.getDump(model.replyTo)
+				}
+			}
+
+			color: { var col = chat.model.userColor(reply.modelData.userId, colors.window); col.a = 0.2; return col }
+
+			MouseArea {
+				anchors.fill: parent
+				onClicked: chat.positionViewAtIndex(chat.model.idToIndex(model.replyTo), ListView.Contain)
+				cursorShape: Qt.PointingHandCursor
+			}
+		}
+
+		// actual message content
 		MessageDelegate {
 			id: contentItem
 
 			width: parent.width
-			height: childrenRect.height
+
+			modelData: model
 		}
 	}
 
diff --git a/resources/qml/delegates/FileMessage.qml b/resources/qml/delegates/FileMessage.qml
index 2c911c5e..9a5300bb 100644
--- a/resources/qml/delegates/FileMessage.qml
+++ b/resources/qml/delegates/FileMessage.qml
@@ -31,7 +31,7 @@ Rectangle {
 			}
 			MouseArea {
 				anchors.fill: parent
-				onClicked: timelineManager.timeline.saveMedia(model.id)
+				onClicked: timelineManager.timeline.saveMedia(model.data.id)
 				cursorShape: Qt.PointingHandCursor
 			}
 		}
@@ -40,14 +40,14 @@ Rectangle {
 
 			Text {
 				Layout.fillWidth: true
-				text: model.body
+				text: model.data.body
 				textFormat: Text.PlainText
 				elide: Text.ElideRight
 				color: colors.text
 			}
 			Text {
 				Layout.fillWidth: true
-				text: model.filesize
+				text: model.data.filesize
 				textFormat: Text.PlainText
 				elide: Text.ElideRight
 				color: colors.text
diff --git a/resources/qml/delegates/ImageMessage.qml b/resources/qml/delegates/ImageMessage.qml
index 15ce29b7..3393f043 100644
--- a/resources/qml/delegates/ImageMessage.qml
+++ b/resources/qml/delegates/ImageMessage.qml
@@ -3,26 +3,26 @@ import QtQuick 2.6
 import im.nheko 1.0
 
 Item {
-	property double tempWidth: Math.min(parent ? parent.width : undefined, model.width)
-	property double tempHeight: tempWidth * model.proportionalHeight
+	property double tempWidth: Math.min(parent ? parent.width : undefined, model.data.width)
+	property double tempHeight: tempWidth * model.data.proportionalHeight
 
 	property bool tooHigh: tempHeight > chat.height - 40
 
 	height: tooHigh ? chat.height - 40 : tempHeight
-	width: tooHigh ? (chat.height - 40) / model.proportionalHeight : tempWidth
+	width: tooHigh ? (chat.height - 40) / model.data.proportionalHeight : tempWidth
 
 	Image {
 		id: img
 		anchors.fill: parent
 
-		source: model.url.replace("mxc://", "image://MxcImage/")
+		source: model.data.url.replace("mxc://", "image://MxcImage/")
 		asynchronous: true
 		fillMode: Image.PreserveAspectFit
 
 		MouseArea {
-			enabled: model.type == MtxEvent.ImageMessage
+			enabled: model.data.type == MtxEvent.ImageMessage
 			anchors.fill: parent
-			onClicked: timelineManager.openImageOverlay(model.url, model.id)
+			onClicked: timelineManager.openImageOverlay(model.data.url, model.data.id)
 		}
 	}
 }
diff --git a/resources/qml/delegates/MessageDelegate.qml b/resources/qml/delegates/MessageDelegate.qml
index 20ec71e5..1716d2d4 100644
--- a/resources/qml/delegates/MessageDelegate.qml
+++ b/resources/qml/delegates/MessageDelegate.qml
@@ -1,67 +1,81 @@
 import QtQuick 2.6
 import im.nheko 1.0
 
-DelegateChooser {
-	//role: "type" //< not supported in our custom implementation, have to use roleValue
-	roleValue: model.type
-
-	DelegateChoice {
-		roleValue: MtxEvent.TextMessage
-		TextMessage {}
-	}
-	DelegateChoice {
-		roleValue: MtxEvent.NoticeMessage
-		NoticeMessage {}
-	}
-	DelegateChoice {
-		roleValue: MtxEvent.EmoteMessage
-		TextMessage {}
-	}
-	DelegateChoice {
-		roleValue: MtxEvent.ImageMessage
-		ImageMessage {}
-	}
-	DelegateChoice {
-		roleValue: MtxEvent.Sticker
-		ImageMessage {}
-	}
-	DelegateChoice {
-		roleValue: MtxEvent.FileMessage
-		FileMessage {}
+Item {
+	// Workaround to have an assignable global property
+	Item {
+		id: model
+		property var data;
 	}
-	DelegateChoice {
-		roleValue: MtxEvent.VideoMessage
-		PlayableMediaMessage {}
-	}
-	DelegateChoice {
-		roleValue: MtxEvent.AudioMessage
-		PlayableMediaMessage {}
-	}
-	DelegateChoice {
-		roleValue: MtxEvent.Redacted
-		Pill {
-			text: qsTr("redacted")
+	
+	property alias modelData: model.data
+
+	height: chooser.childrenRect.height
+
+	DelegateChooser {
+		id: chooser
+		//role: "type" //< not supported in our custom implementation, have to use roleValue
+		roleValue: model.data.type
+		anchors.fill: parent
+
+		DelegateChoice {
+			roleValue: MtxEvent.TextMessage
+			TextMessage {}
 		}
-	}
-	DelegateChoice {
-		roleValue: MtxEvent.Encryption
-		Pill {
-			text: qsTr("Encryption enabled")
+		DelegateChoice {
+			roleValue: MtxEvent.NoticeMessage
+			NoticeMessage {}
 		}
-	}
-	DelegateChoice {
-		roleValue: MtxEvent.Name
-		NoticeMessage {
-			notice: model.roomName ? qsTr("room name changed to: %1").arg(model.roomName) : qsTr("removed room name")
+		DelegateChoice {
+			roleValue: MtxEvent.EmoteMessage
+			TextMessage {}
 		}
-	}
-	DelegateChoice {
-		roleValue: MtxEvent.Topic
-		NoticeMessage {
-			notice: model.roomTopic ? qsTr("topic changed to: %1").arg(model.roomTopic) : qsTr("removed topic")
+		DelegateChoice {
+			roleValue: MtxEvent.ImageMessage
+			ImageMessage {}
+		}
+		DelegateChoice {
+			roleValue: MtxEvent.Sticker
+			ImageMessage {}
+		}
+		DelegateChoice {
+			roleValue: MtxEvent.FileMessage
+			FileMessage {}
+		}
+		DelegateChoice {
+			roleValue: MtxEvent.VideoMessage
+			PlayableMediaMessage {}
+		}
+		DelegateChoice {
+			roleValue: MtxEvent.AudioMessage
+			PlayableMediaMessage {}
+		}
+		DelegateChoice {
+			roleValue: MtxEvent.Redacted
+			Pill {
+				text: qsTr("redacted")
+			}
+		}
+		DelegateChoice {
+			roleValue: MtxEvent.Encryption
+			Pill {
+				text: qsTr("Encryption enabled")
+			}
+		}
+		DelegateChoice {
+			roleValue: MtxEvent.Name
+			NoticeMessage {
+				notice: model.data.roomName ? qsTr("room name changed to: %1").arg(model.data.roomName) : qsTr("removed room name")
+			}
+		}
+		DelegateChoice {
+			roleValue: MtxEvent.Topic
+			NoticeMessage {
+				notice: model.data.roomTopic ? qsTr("topic changed to: %1").arg(model.data.roomTopic) : qsTr("removed topic")
+			}
+		}
+		DelegateChoice {
+			Placeholder {}
 		}
-	}
-	DelegateChoice {
-		Placeholder {}
 	}
 }
diff --git a/resources/qml/delegates/NoticeMessage.qml b/resources/qml/delegates/NoticeMessage.qml
index f7467eca..34132bcf 100644
--- a/resources/qml/delegates/NoticeMessage.qml
+++ b/resources/qml/delegates/NoticeMessage.qml
@@ -1,7 +1,7 @@
 import ".."
 
 MatrixText {
-	property string notice: model.formattedBody.replace("<pre>", "<pre style='white-space: pre-wrap'>")
+	property string notice: model.data.formattedBody.replace("<pre>", "<pre style='white-space: pre-wrap'>")
 	text: notice
 	width: parent ? parent.width : undefined
 	font.italic: true
diff --git a/resources/qml/delegates/Placeholder.qml b/resources/qml/delegates/Placeholder.qml
index 4c0e68c3..36d7b2bc 100644
--- a/resources/qml/delegates/Placeholder.qml
+++ b/resources/qml/delegates/Placeholder.qml
@@ -1,7 +1,7 @@
 import ".."
 
 MatrixText {
-	text: qsTr("unimplemented event: ") + model.type
+	text: qsTr("unimplemented event: ") + model.data.type
 	width: parent ? parent.width : undefined
 	color: inactiveColors.text
 }
diff --git a/resources/qml/delegates/PlayableMediaMessage.qml b/resources/qml/delegates/PlayableMediaMessage.qml
index b3275462..ebf7487c 100644
--- a/resources/qml/delegates/PlayableMediaMessage.qml
+++ b/resources/qml/delegates/PlayableMediaMessage.qml
@@ -19,12 +19,12 @@ Rectangle {
 
 		Rectangle {
 			id: videoContainer
-			visible: model.type == MtxEvent.VideoMessage
-			width: Math.min(parent.width, model.width ? model.width : 400) // some media has 0 as size...
-			height: width*model.proportionalHeight
+			visible: model.data.type == MtxEvent.VideoMessage
+			width: Math.min(parent.width, model.data.width ? model.data.width : 400) // some media has 0 as size...
+			height: width*model.data.proportionalHeight
 			Image {
 				anchors.fill: parent
-				source: model.thumbnailUrl.replace("mxc://", "image://MxcImage/")
+				source: model.data.thumbnailUrl.replace("mxc://", "image://MxcImage/")
 				asynchronous: true
 				fillMode: Image.PreserveAspectFit
 
@@ -97,7 +97,7 @@ Rectangle {
 					anchors.fill: parent
 					onClicked: {
 						switch (button.state) {
-							case "": timelineManager.timeline.cacheMedia(model.id); break;
+							case "": timelineManager.timeline.cacheMedia(model.data.id); break;
 							case "stopped":
 							media.play(); console.log("play");
 							button.state = "playing"
@@ -120,7 +120,7 @@ Rectangle {
 				Connections {
 					target: timelineManager.timeline
 					onMediaCached: {
-						if (mxcUrl == model.url) {
+						if (mxcUrl == model.data.url) {
 							media.source = "file://" + cacheUrl
 							button.state = "stopped"
 							console.log("media loaded: " + mxcUrl + " at " + cacheUrl)
@@ -145,14 +145,14 @@ Rectangle {
 
 				Text {
 					Layout.fillWidth: true
-					text: model.body
+					text: model.data.body
 					textFormat: Text.PlainText
 					elide: Text.ElideRight
 					color: colors.text
 				}
 				Text {
 					Layout.fillWidth: true
-					text: model.filesize
+					text: model.data.filesize
 					textFormat: Text.PlainText
 					elide: Text.ElideRight
 					color: colors.text
diff --git a/resources/qml/delegates/TextMessage.qml b/resources/qml/delegates/TextMessage.qml
index f984b32f..92ba560b 100644
--- a/resources/qml/delegates/TextMessage.qml
+++ b/resources/qml/delegates/TextMessage.qml
@@ -1,6 +1,6 @@
 import ".."
 
 MatrixText {
-	text: model.formattedBody.replace("<pre>", "<pre style='white-space: pre-wrap'>")
+	text: model.data.formattedBody.replace("<pre>", "<pre style='white-space: pre-wrap'>")
 	width: parent ? parent.width : undefined
 }
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 0e7f5259..41d864bd 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -212,6 +212,14 @@ TimelineModel::rowCount(const QModelIndex &parent) const
         return (int)this->eventOrder.size();
 }
 
+QVariantMap
+TimelineModel::getDump(QString eventId) const
+{
+        if (events.contains(eventId))
+                return data(index(idToIndex(eventId), 0), Dump).toMap();
+        return {};
+}
+
 QVariant
 TimelineModel::data(const QModelIndex &index, int role) const
 {
@@ -263,11 +271,13 @@ TimelineModel::data(const QModelIndex &index, int role) const
                 return QVariant(toRoomEventType(event));
         case Body:
                 return QVariant(utils::replaceEmoji(QString::fromStdString(body(event))));
-        case FormattedBody:
+        case FormattedBody: {
+                const static QRegularExpression replyFallback(
+                  "<mx-reply>.*</mx-reply>", QRegularExpression::DotMatchesEverythingOption);
                 return QVariant(
                   utils::replaceEmoji(utils::linkifyMessage(formattedBodyWithFallback(event)))
-                    .remove("<mx-reply>")
-                    .remove("</mx-reply>"));
+                    .remove(replyFallback));
+        }
         case Url:
                 return QVariant(QString::fromStdString(url(event)));
         case ThumbnailUrl:
diff --git a/src/timeline/TimelineModel.h b/src/timeline/TimelineModel.h
index 0f18f7ef..61dd6b69 100644
--- a/src/timeline/TimelineModel.h
+++ b/src/timeline/TimelineModel.h
@@ -181,6 +181,7 @@ public slots:
         void setCurrentIndex(int index);
         int currentIndex() const { return idToIndex(currentId); }
         void markEventsAsRead(const std::vector<QString> &event_ids);
+        QVariantMap getDump(QString eventId) const;
 
 private slots:
         // Add old events at the top of the timeline.
-- 
cgit 1.5.1


From 4727f1c2bbeb5ba10299e716f681bd22bd92f16c Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Sat, 11 Jan 2020 18:53:32 +0100
Subject: Fetch missing events for replies

---
 resources/qml/delegates/MessageDelegate.qml |   4 +
 src/timeline/TimelineModel.cpp              | 149 ++++++++++++++++++----------
 src/timeline/TimelineModel.h                |   2 +
 src/timeline/TimelineViewManager.cpp        |   3 +
 4 files changed, 105 insertions(+), 53 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/resources/qml/delegates/MessageDelegate.qml b/resources/qml/delegates/MessageDelegate.qml
index 1716d2d4..ae18d505 100644
--- a/resources/qml/delegates/MessageDelegate.qml
+++ b/resources/qml/delegates/MessageDelegate.qml
@@ -18,6 +18,10 @@ Item {
 		roleValue: model.data.type
 		anchors.fill: parent
 
+		DelegateChoice {
+			roleValue: MtxEvent.UnknownMessage
+			Placeholder { text: "Unretrieved event" }
+		}
 		DelegateChoice {
 			roleValue: MtxEvent.TextMessage
 			TextMessage {}
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 41d864bd..a1367bf3 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -70,8 +70,9 @@ struct RoomEventType
                 case EventType::Tag:
                         return qml_mtx_events::EventType::Tag;
                 case EventType::Unsupported:
-                default:
                         return qml_mtx_events::EventType::Unsupported;
+                default:
+                        return qml_mtx_events::EventType::UnknownMessage;
                 }
         }
         qml_mtx_events::EventType operator()(const mtx::events::Event<mtx::events::msg::Audio> &)
@@ -175,6 +176,17 @@ TimelineModel::TimelineModel(TimelineViewManager *manager, QString room_id, QObj
         connect(
           this, &TimelineModel::nextPendingMessage, this, &TimelineModel::processOnePendingMessage);
         connect(this, &TimelineModel::newMessageToSend, this, &TimelineModel::addPendingMessage);
+
+        connect(this,
+                &TimelineModel::replyFetched,
+                this,
+                [this](QString requestingEvent, mtx::events::collections::TimelineEvents event) {
+                        events.insert(QString::fromStdString(mtx::accessors::event_id(event)),
+                                      event);
+                        auto idx = idToIndex(requestingEvent);
+                        if (idx >= 0)
+                                emit dataChanged(index(idx, 0), index(idx, 0));
+                });
 }
 
 QHash<int, QByteArray>
@@ -216,20 +228,15 @@ QVariantMap
 TimelineModel::getDump(QString eventId) const
 {
         if (events.contains(eventId))
-                return data(index(idToIndex(eventId), 0), Dump).toMap();
+                return data(eventId, Dump).toMap();
         return {};
 }
 
 QVariant
-TimelineModel::data(const QModelIndex &index, int role) const
+TimelineModel::data(const QString &id, int role) const
 {
         using namespace mtx::accessors;
-        namespace acc = mtx::accessors;
-        if (index.row() < 0 && index.row() >= (int)eventOrder.size())
-                return QVariant();
-
-        QString id = eventOrder[index.row()];
-
+        namespace acc                                  = mtx::accessors;
         mtx::events::collections::TimelineEvents event = events.value(id);
 
         if (auto e =
@@ -238,28 +245,6 @@ TimelineModel::data(const QModelIndex &index, int role) const
         }
 
         switch (role) {
-        case Section: {
-                QDateTime date = origin_server_ts(event);
-                date.setTime(QTime());
-
-                std::string userId = acc::sender(event);
-
-                for (size_t r = index.row() + 1; r < eventOrder.size(); r++) {
-                        auto tempEv        = events.value(eventOrder[r]);
-                        QDateTime prevDate = origin_server_ts(tempEv);
-                        prevDate.setTime(QTime());
-                        if (prevDate != date)
-                                return QString("%2 %1")
-                                  .arg(date.toMSecsSinceEpoch())
-                                  .arg(QString::fromStdString(userId));
-
-                        std::string prevUserId = acc::sender(tempEv);
-                        if (userId != prevUserId)
-                                break;
-                }
-
-                return QString("%1").arg(QString::fromStdString(userId));
-        }
         case UserId:
                 return QVariant(QString::fromStdString(acc::sender(event)));
         case UserName:
@@ -329,28 +314,27 @@ TimelineModel::data(const QModelIndex &index, int role) const
                 QVariantMap m;
                 auto names = roleNames();
 
-                // m.insert(names[Section], data(index, static_cast<int>(Section)));
-                m.insert(names[Type], data(index, static_cast<int>(Type)));
-                m.insert(names[Body], data(index, static_cast<int>(Body)));
-                m.insert(names[FormattedBody], data(index, static_cast<int>(FormattedBody)));
-                m.insert(names[UserId], data(index, static_cast<int>(UserId)));
-                m.insert(names[UserName], data(index, static_cast<int>(UserName)));
-                m.insert(names[Timestamp], data(index, static_cast<int>(Timestamp)));
-                m.insert(names[Url], data(index, static_cast<int>(Url)));
-                m.insert(names[ThumbnailUrl], data(index, static_cast<int>(ThumbnailUrl)));
-                m.insert(names[Filename], data(index, static_cast<int>(Filename)));
-                m.insert(names[Filesize], data(index, static_cast<int>(Filesize)));
-                m.insert(names[MimeType], data(index, static_cast<int>(MimeType)));
-                m.insert(names[Height], data(index, static_cast<int>(Height)));
-                m.insert(names[Width], data(index, static_cast<int>(Width)));
-                m.insert(names[ProportionalHeight],
-                         data(index, static_cast<int>(ProportionalHeight)));
-                m.insert(names[Id], data(index, static_cast<int>(Id)));
-                m.insert(names[State], data(index, static_cast<int>(State)));
-                m.insert(names[IsEncrypted], data(index, static_cast<int>(IsEncrypted)));
-                m.insert(names[ReplyTo], data(index, static_cast<int>(ReplyTo)));
-                m.insert(names[RoomName], data(index, static_cast<int>(RoomName)));
-                m.insert(names[RoomTopic], data(index, static_cast<int>(RoomTopic)));
+                // m.insert(names[Section], data(id, static_cast<int>(Section)));
+                m.insert(names[Type], data(id, static_cast<int>(Type)));
+                m.insert(names[Body], data(id, static_cast<int>(Body)));
+                m.insert(names[FormattedBody], data(id, static_cast<int>(FormattedBody)));
+                m.insert(names[UserId], data(id, static_cast<int>(UserId)));
+                m.insert(names[UserName], data(id, static_cast<int>(UserName)));
+                m.insert(names[Timestamp], data(id, static_cast<int>(Timestamp)));
+                m.insert(names[Url], data(id, static_cast<int>(Url)));
+                m.insert(names[ThumbnailUrl], data(id, static_cast<int>(ThumbnailUrl)));
+                m.insert(names[Filename], data(id, static_cast<int>(Filename)));
+                m.insert(names[Filesize], data(id, static_cast<int>(Filesize)));
+                m.insert(names[MimeType], data(id, static_cast<int>(MimeType)));
+                m.insert(names[Height], data(id, static_cast<int>(Height)));
+                m.insert(names[Width], data(id, static_cast<int>(Width)));
+                m.insert(names[ProportionalHeight], data(id, static_cast<int>(ProportionalHeight)));
+                m.insert(names[Id], data(id, static_cast<int>(Id)));
+                m.insert(names[State], data(id, static_cast<int>(State)));
+                m.insert(names[IsEncrypted], data(id, static_cast<int>(IsEncrypted)));
+                m.insert(names[ReplyTo], data(id, static_cast<int>(ReplyTo)));
+                m.insert(names[RoomName], data(id, static_cast<int>(RoomName)));
+                m.insert(names[RoomTopic], data(id, static_cast<int>(RoomTopic)));
 
                 return QVariant(m);
         }
@@ -359,6 +343,44 @@ TimelineModel::data(const QModelIndex &index, int role) const
         }
 }
 
+QVariant
+TimelineModel::data(const QModelIndex &index, int role) const
+{
+        using namespace mtx::accessors;
+        namespace acc = mtx::accessors;
+        if (index.row() < 0 && index.row() >= (int)eventOrder.size())
+                return QVariant();
+
+        QString id = eventOrder[index.row()];
+
+        mtx::events::collections::TimelineEvents event = events.value(id);
+
+        if (role == Section) {
+                QDateTime date = origin_server_ts(event);
+                date.setTime(QTime());
+
+                std::string userId = acc::sender(event);
+
+                for (size_t r = index.row() + 1; r < eventOrder.size(); r++) {
+                        auto tempEv        = events.value(eventOrder[r]);
+                        QDateTime prevDate = origin_server_ts(tempEv);
+                        prevDate.setTime(QTime());
+                        if (prevDate != date)
+                                return QString("%2 %1")
+                                  .arg(date.toMSecsSinceEpoch())
+                                  .arg(QString::fromStdString(userId));
+
+                        std::string prevUserId = acc::sender(tempEv);
+                        if (userId != prevUserId)
+                                break;
+                }
+
+                return QString("%1").arg(QString::fromStdString(userId));
+        }
+
+        return data(id, role);
+}
+
 bool
 TimelineModel::canFetchMore(const QModelIndex &) const
 {
@@ -515,6 +537,27 @@ TimelineModel::internalAddEvents(
 
                 this->events.insert(id, e);
                 ids.push_back(id);
+
+                auto replyTo  = mtx::accessors::in_reply_to_event(e);
+                auto qReplyTo = QString::fromStdString(replyTo);
+                if (!replyTo.empty() && !events.contains(qReplyTo)) {
+                        http::client()->get_event(
+                          this->room_id_.toStdString(),
+                          replyTo,
+                          [this, id, replyTo](
+                            const mtx::events::collections::TimelineEvents &timeline,
+                            mtx::http::RequestErr err) {
+                                  if (err) {
+                                          nhlog::net()->error(
+                                            "Failed to retrieve event with id {}, which was "
+                                            "requested to show the replyTo for event {}",
+                                            replyTo,
+                                            id.toStdString());
+                                          return;
+                                  }
+                                  emit replyFetched(id, timeline);
+                          });
+                }
         }
         return ids;
 }
diff --git a/src/timeline/TimelineModel.h b/src/timeline/TimelineModel.h
index 61dd6b69..ae505c17 100644
--- a/src/timeline/TimelineModel.h
+++ b/src/timeline/TimelineModel.h
@@ -153,6 +153,7 @@ public:
         QHash<int, QByteArray> roleNames() const override;
         int rowCount(const QModelIndex &parent = QModelIndex()) const override;
         QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+        QVariant data(const QString &id, int role) const;
 
         bool canFetchMore(const QModelIndex &) const override;
         void fetchMore(const QModelIndex &) override;
@@ -200,6 +201,7 @@ signals:
         void newMessageToSend(mtx::events::collections::TimelineEvents event);
         void mediaCached(QString mxcUrl, QString cacheUrl);
         void newEncryptedImage(mtx::crypto::EncryptedFile encryptionInfo);
+        void replyFetched(QString requestingEvent, mtx::events::collections::TimelineEvents event);
 
 private:
         DecryptionResult decryptEvent(
diff --git a/src/timeline/TimelineViewManager.cpp b/src/timeline/TimelineViewManager.cpp
index 74e09a33..8cb204a6 100644
--- a/src/timeline/TimelineViewManager.cpp
+++ b/src/timeline/TimelineViewManager.cpp
@@ -12,6 +12,8 @@
 #include "UserSettingsPage.h"
 #include "dialogs/ImageOverlay.h"
 
+Q_DECLARE_METATYPE(mtx::events::collections::TimelineEvents)
+
 void
 TimelineViewManager::updateColorPalette()
 {
@@ -59,6 +61,7 @@ TimelineViewManager::TimelineViewManager(QWidget *parent)
                                          "Can't instantiate enum!");
         qmlRegisterType<DelegateChoice>("im.nheko", 1, 0, "DelegateChoice");
         qmlRegisterType<DelegateChooser>("im.nheko", 1, 0, "DelegateChooser");
+        qRegisterMetaType<mtx::events::collections::TimelineEvents>();
 
 #ifdef USE_QUICK_VIEW
         view      = new QQuickView();
-- 
cgit 1.5.1


From 62f17dffbd30a3d2e69d5110359055eed0cdca5a Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Mon, 13 Jan 2020 12:37:02 +0100
Subject: Fix replies in encrypted rooms

The relation needs to be unencrypted...
---
 deps/CMakeLists.txt            |  4 ++--
 src/Olm.cpp                    | 18 +++++++++++++-----
 src/Olm.h                      |  2 +-
 src/timeline/TimelineModel.cpp | 12 ++++++++----
 4 files changed, 24 insertions(+), 12 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/deps/CMakeLists.txt b/deps/CMakeLists.txt
index f4d454a0..64189772 100644
--- a/deps/CMakeLists.txt
+++ b/deps/CMakeLists.txt
@@ -46,10 +46,10 @@ set(BOOST_SHA256
 
 set(
   MTXCLIENT_URL
-  https://github.com/Nheko-Reborn/mtxclient/archive/6d2a02b6079c9d888c28cd24504618aaadb7fa97.zip
+  https://github.com/Nheko-Reborn/mtxclient/archive/84c6778cc367bca79755e73e77b2cc69950375b2.zip
   )
 set(MTXCLIENT_HASH
-    30811e076ee1fee22ba5d5d92c94a5425ff714a7ccb245ff4ac64fecb04dc539)
+    009fc9628cbdb94694eff3bba3fe54415e432385200c886bb1c1182bcf290c0a)
 set(
   TWEENY_URL
   https://github.com/mobius3/tweeny/archive/b94ce07cfb02a0eb8ac8aaf66137dabdaea857cf.tar.gz
diff --git a/src/Olm.cpp b/src/Olm.cpp
index 5859fe8e..4fa473d3 100644
--- a/src/Olm.cpp
+++ b/src/Olm.cpp
@@ -159,15 +159,22 @@ handle_pre_key_olm_message(const std::string &sender,
 }
 
 mtx::events::msg::Encrypted
-encrypt_group_message(const std::string &room_id,
-                      const std::string &device_id,
-                      const std::string &body)
+encrypt_group_message(const std::string &room_id, const std::string &device_id, nlohmann::json body)
 {
         using namespace mtx::events;
 
-        // Always chech before for existence.
+        nhlog::crypto()->info("message body {}", body.dump());
+
+        // relations shouldn't be encrypted...
+        mtx::common::RelatesTo relation;
+        if (body["content"].count("m.relates_to") != 0) {
+                relation = body["content"]["m.relates_to"];
+                body["content"].erase("m.relates_to");
+        }
+
+        // Always check before for existence.
         auto res     = cache::getOutboundMegolmSession(room_id);
-        auto payload = olm::client()->encrypt_group_message(res.session, body);
+        auto payload = olm::client()->encrypt_group_message(res.session, body.dump());
 
         // Prepare the m.room.encrypted event.
         msg::Encrypted data;
@@ -176,6 +183,7 @@ encrypt_group_message(const std::string &room_id,
         data.session_id = res.data.session_id;
         data.device_id  = device_id;
         data.algorithm  = MEGOLM_ALGO;
+        data.relates_to = relation;
 
         auto message_index = olm_outbound_group_session_message_index(res.session);
         nhlog::crypto()->info("next message_index {}", message_index);
diff --git a/src/Olm.h b/src/Olm.h
index ae4e0659..501a1621 100644
--- a/src/Olm.h
+++ b/src/Olm.h
@@ -62,7 +62,7 @@ handle_pre_key_olm_message(const std::string &sender,
 mtx::events::msg::Encrypted
 encrypt_group_message(const std::string &room_id,
                       const std::string &device_id,
-                      const std::string &body);
+                      nlohmann::json body);
 
 void
 mark_keys_as_published();
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index a1367bf3..3064ab4a 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -734,6 +734,10 @@ TimelineModel::decryptEvent(const mtx::events::EncryptedEvent<mtx::events::msg::
         body["origin_server_ts"] = e.origin_server_ts;
         body["unsigned"]         = e.unsigned_data;
 
+        // relations are unencrypted in content...
+        if (json old_ev = e; old_ev["content"].count("m.relates_to") != 0)
+                body["content"]["m.relates_to"] = old_ev["content"]["m.relates_to"];
+
         json event_array = json::array();
         event_array.push_back(body);
 
@@ -843,13 +847,13 @@ TimelineModel::sendEncryptedMessage(const std::string &txn_id, nlohmann::json co
         using namespace mtx::events;
         using namespace mtx::identifiers;
 
-        json doc{{"type", "m.room.message"}, {"content", content}, {"room_id", room_id}};
+        json doc = {{"type", "m.room.message"}, {"content", content}, {"room_id", room_id}};
 
         try {
                 // Check if we have already an outbound megolm session then we can use.
                 if (cache::outboundMegolmSessionExists(room_id)) {
-                        auto data = olm::encrypt_group_message(
-                          room_id, http::client()->device_id(), doc.dump());
+                        auto data =
+                          olm::encrypt_group_message(room_id, http::client()->device_id(), doc);
 
                         http::client()->send_room_message<msg::Encrypted, EventType::RoomEncrypted>(
                           room_id,
@@ -902,7 +906,7 @@ TimelineModel::sendEncryptedMessage(const std::string &txn_id, nlohmann::json co
                   std::make_shared<StateKeeper>([megolm_payload, room_id, doc, txn_id, this]() {
                           try {
                                   auto data = olm::encrypt_group_message(
-                                    room_id, http::client()->device_id(), doc.dump());
+                                    room_id, http::client()->device_id(), doc);
 
                                   http::client()
                                     ->send_room_message<msg::Encrypted, EventType::RoomEncrypted>(
-- 
cgit 1.5.1


From 3f02b0bf56f887fb4cca631bde644d6106335169 Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Tue, 14 Jan 2020 17:47:30 +0100
Subject: Escape blacklisted html tags

---
 src/Utils.cpp                  | 56 ++++++++++++++++++++++++++++++++----------
 src/Utils.h                    |  4 +++
 src/timeline/TimelineModel.cpp |  4 +--
 3 files changed, 49 insertions(+), 15 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/Utils.cpp b/src/Utils.cpp
index 1c94761d..ddd066d7 100644
--- a/src/Utils.cpp
+++ b/src/Utils.cpp
@@ -314,37 +314,67 @@ utils::linkifyMessage(const QString &body)
         return doc;
 }
 
-QByteArray
-escapeRawHtml(const QByteArray &data)
+QString
+utils::escapeBlacklistedHtml(const QString &rawStr)
 {
+        static const std::vector<std::string_view> allowedTags = {
+          "font",       "/font",       "del",    "/del",    "h1",    "/h1",    "h2",     "/h2",
+          "h3",         "/h3",         "h4",     "/h4",     "h5",    "/h5",    "h6",     "/h6",
+          "blockquote", "/blockquote", "p",      "/p",      "a",     "/a",     "ul",     "/ul",
+          "ol",         "/ol",         "sup",    "/sup",    "sub",   "/sub",   "li",     "/li",
+          "b",          "/b",          "i",      "/i",      "u",     "/u",     "strong", "/strong",
+          "em",         "/em",         "strike", "/strike", "code",  "/code",  "hr",     "/hr",
+          "br",         "br/",         "div",    "/div",    "table", "/table", "thead",  "/thead",
+          "tbody",      "/tbody",      "tr",     "/tr",     "th",    "/th",    "td",     "/td",
+          "caption",    "/caption",    "pre",    "/pre",    "span",  "/span",  "img",    "/img"};
+        QByteArray data = rawStr.toUtf8();
         QByteArray buffer;
         const size_t length = data.size();
         buffer.reserve(length);
+        bool escapingTag = false;
         for (size_t pos = 0; pos != length; ++pos) {
                 switch (data.at(pos)) {
-                case '&':
-                        buffer.append("&amp;");
-                        break;
-                case '<':
-                        buffer.append("&lt;");
+                case '<': {
+                        bool oneTagMatched = false;
+                        size_t endPos      = std::min(static_cast<size_t>(data.indexOf('>', pos)),
+                                                 static_cast<size_t>(data.indexOf(' ', pos)));
+
+                        auto mid = data.mid(pos + 1, endPos - pos - 1);
+                        for (const auto &tag : allowedTags) {
+                                // TODO: Check src and href attribute
+                                if (mid.compare(tag.data(), Qt::CaseInsensitive) == 0) {
+                                        oneTagMatched = true;
+                                }
+                        }
+                        if (oneTagMatched)
+                                buffer.append('<');
+                        else {
+                                escapingTag = true;
+                                buffer.append("&lt;");
+                        }
                         break;
+                }
                 case '>':
-                        buffer.append("&gt;");
+                        if (escapingTag)
+                                buffer.append("&gt;");
+                        else {
+                                escapingTag = false;
+                                buffer.append('>');
+                        }
                         break;
                 default:
                         buffer.append(data.at(pos));
                         break;
                 }
         }
-        return buffer;
+        return QString::fromUtf8(buffer);
 }
 
 QString
 utils::markdownToHtml(const QString &text)
 {
-        const auto str = escapeRawHtml(text.toUtf8());
-        const char *tmp_buf =
-          cmark_markdown_to_html(str.constData(), str.size(), CMARK_OPT_DEFAULT);
+        const auto str      = text.toUtf8();
+        const char *tmp_buf = cmark_markdown_to_html(str.constData(), str.size(), CMARK_OPT_UNSAFE);
 
         // Copy the null terminated output buffer.
         std::string html(tmp_buf);
@@ -352,7 +382,7 @@ utils::markdownToHtml(const QString &text)
         // The buffer is no longer needed.
         free((char *)tmp_buf);
 
-        auto result = QString::fromStdString(html).trimmed();
+        auto result = escapeBlacklistedHtml(QString::fromStdString(html)).trimmed();
 
         return result;
 }
diff --git a/src/Utils.h b/src/Utils.h
index 6b809d63..119d660a 100644
--- a/src/Utils.h
+++ b/src/Utils.h
@@ -286,6 +286,10 @@ linkifyMessage(const QString &body);
 QString
 markdownToHtml(const QString &text);
 
+//! Escape every html tag, that was not whitelisted
+QString
+escapeBlacklistedHtml(const QString &data);
+
 //! Generate a Rich Reply quote message
 QString
 getFormattedQuoteBody(const RelatedInfo &related, const QString &html);
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 3064ab4a..eef4ec31 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -260,8 +260,8 @@ TimelineModel::data(const QString &id, int role) const
                 const static QRegularExpression replyFallback(
                   "<mx-reply>.*</mx-reply>", QRegularExpression::DotMatchesEverythingOption);
                 return QVariant(
-                  utils::replaceEmoji(utils::linkifyMessage(formattedBodyWithFallback(event)))
-                    .remove(replyFallback));
+                  utils::replaceEmoji(utils::linkifyMessage(utils::escapeBlacklistedHtml(
+                    formattedBodyWithFallback(event).remove(replyFallback)))));
         }
         case Url:
                 return QVariant(QString::fromStdString(url(event)));
-- 
cgit 1.5.1


From 54a16ae2d7d811a7f2e4454daf398ace8f97170a Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Tue, 14 Jan 2020 20:43:35 +0100
Subject: Fix duplicate messages in timeline after sending

---
 src/timeline/TimelineModel.cpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index eef4ec31..08c29927 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -139,6 +139,17 @@ TimelineModel::TimelineModel(TimelineViewManager *manager, QString room_id, QObj
         });
         connect(this, &TimelineModel::messageSent, this, [this](QString txn_id, QString event_id) {
                 pending.removeOne(txn_id);
+
+                // we could have received the message via sync
+                if (events.contains(event_id)) {
+                        int idx = idToIndex(event_id);
+                        if (idx >= 0) {
+                                beginRemoveRows(QModelIndex(), idx, idx);
+                                eventOrder.erase(eventOrder.begin() + idx);
+                                endRemoveRows();
+                        }
+                }
+
                 int idx = idToIndex(txn_id);
                 if (idx < 0) {
                         nhlog::ui()->warn("Sent index out of range");
-- 
cgit 1.5.1


From fe912240bc1ab89b8a20ce87d5183f328f704d23 Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Fri, 17 Jan 2020 01:25:14 +0100
Subject: Move typing display to qml

---
 CMakeLists.txt                       |  2 -
 resources/langs/nheko_de.ts          | 67 ++++++++++++++--------------
 resources/langs/nheko_el.ts          | 67 ++++++++++++++--------------
 resources/langs/nheko_en.ts          | 67 ++++++++++++++--------------
 resources/langs/nheko_fi.ts          | 67 ++++++++++++++--------------
 resources/langs/nheko_fr.ts          | 67 ++++++++++++++--------------
 resources/langs/nheko_nl.ts          | 67 ++++++++++++++--------------
 resources/langs/nheko_pl.ts          | 69 ++++++++++++++---------------
 resources/langs/nheko_ru.ts          | 69 ++++++++++++++---------------
 resources/langs/nheko_zh_CN.ts       | 65 +++++++++++++--------------
 resources/qml/TimelineView.qml       | 31 ++++++++++++-
 src/ChatPage.cpp                     | 53 ----------------------
 src/ChatPage.h                       |  9 ----
 src/TypingDisplay.cpp                | 86 ------------------------------------
 src/TypingDisplay.h                  | 36 ---------------
 src/timeline/TimelineModel.cpp       | 30 +++++++++++++
 src/timeline/TimelineModel.h         | 13 ++++++
 src/timeline/TimelineViewManager.cpp | 18 ++++++--
 18 files changed, 377 insertions(+), 506 deletions(-)
 delete mode 100644 src/TypingDisplay.cpp
 delete mode 100644 src/TypingDisplay.h

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7871bb6a..4ef6f378 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -242,7 +242,6 @@ set(SRC_FILES
     src/TextInputWidget.cpp
     src/TopRoomBar.cpp
     src/TrayIcon.cpp
-    src/TypingDisplay.cpp
     src/Utils.cpp
     src/UserInfoWidget.cpp
     src/UserSettingsPage.cpp
@@ -379,7 +378,6 @@ qt5_wrap_cpp(MOC_HEADERS
     src/TextInputWidget.h
     src/TopRoomBar.h
     src/TrayIcon.h
-    src/TypingDisplay.h
     src/UserInfoWidget.h
     src/UserSettingsPage.h
     src/WelcomePage.h
diff --git a/resources/langs/nheko_de.ts b/resources/langs/nheko_de.ts
index fbc2aa4f..a6d0e98d 100644
--- a/resources/langs/nheko_de.ts
+++ b/resources/langs/nheko_de.ts
@@ -4,12 +4,12 @@
 <context>
     <name>ChatPage</name>
     <message>
-        <location filename="../../src/ChatPage.cpp" line="+346"/>
+        <location filename="../../src/ChatPage.cpp" line="+329"/>
         <source>Failed to upload media. Please try again.</source>
         <translation>Medienupload fehlgeschlagen. Bitte versuche es erneut.</translation>
     </message>
     <message>
-        <location line="+389"/>
+        <location line="+392"/>
         <source>Failed to restore OLM account. Please login again.</source>
         <translation>Wiederherstellung des OLM Accounts fehlgeschlagen. Bitte logge dich erneut ein.</translation>
     </message>
@@ -19,7 +19,7 @@
         <translation>Gespeicherte Nachrichten konnten nicht wiederhergestellt werden. Bitte melde Dich erneut an.</translation>
     </message>
     <message>
-        <location line="+181"/>
+        <location line="+148"/>
         <source>Failed to setup encryption keys. Server response: %1 %2. Please try again later.</source>
         <translation>Fehler beim Setup der Verschlüsselungsschlüssel. Servermeldung: %1 %2. Bitte versuche es später erneut.</translation>
     </message>
@@ -72,7 +72,7 @@
 <context>
     <name>EditModal</name>
     <message>
-        <location filename="../../src/dialogs/RoomSettings.cpp" line="+58"/>
+        <location filename="../../src/dialogs/RoomSettings.cpp" line="+59"/>
         <source>Apply</source>
         <translation>Anwenden</translation>
     </message>
@@ -182,7 +182,7 @@
 <context>
     <name>MessageDelegate</name>
     <message>
-        <location filename="../qml/delegates/MessageDelegate.qml" line="+43"/>
+        <location filename="../qml/delegates/MessageDelegate.qml" line="+60"/>
         <source>redacted</source>
         <translation>gelöscht</translation>
     </message>
@@ -223,7 +223,7 @@
 <context>
     <name>QuickSwitcher</name>
     <message>
-        <location filename="../../src/QuickSwitcher.cpp" line="+71"/>
+        <location filename="../../src/QuickSwitcher.cpp" line="+72"/>
         <source>Search for a room...</source>
         <translation>Raum suchen…</translation>
     </message>
@@ -279,7 +279,7 @@
 <context>
     <name>ReplyPopup</name>
     <message>
-        <location filename="../../src/popups/ReplyPopup.cpp" line="+45"/>
+        <location filename="../../src/popups/ReplyPopup.cpp" line="+46"/>
         <source>Logout</source>
         <translation>Abmelden</translation>
     </message>
@@ -287,7 +287,7 @@
 <context>
     <name>RoomInfo</name>
     <message>
-        <location filename="../../src/Cache.cpp" line="+2307"/>
+        <location filename="../../src/Cache.cpp" line="+2303"/>
         <source>no version stored</source>
         <translation>keine Version gespeichert</translation>
     </message>
@@ -300,12 +300,12 @@
         <translation>Raum verlassen</translation>
     </message>
     <message>
-        <location line="+161"/>
+        <location line="+151"/>
         <source>Accept</source>
         <translation>Akzeptieren</translation>
     </message>
     <message>
-        <location line="+1"/>
+        <location line="+3"/>
         <source>Decline</source>
         <translation>Ablehnen</translation>
     </message>
@@ -364,13 +364,13 @@
 <context>
     <name>TextInputWidget</name>
     <message>
-        <location filename="../../src/TextInputWidget.cpp" line="+502"/>
+        <location filename="../../src/TextInputWidget.cpp" line="+496"/>
         <source>Send a file</source>
         <translation>Versende Datei</translation>
     </message>
     <message>
         <location line="+13"/>
-        <location filename="../../src/TextInputWidget.h" line="+161"/>
+        <location filename="../../src/TextInputWidget.h" line="+163"/>
         <source>Write a message...</source>
         <translation>Schreibe eine Nachricht…</translation>
     </message>
@@ -385,7 +385,7 @@
         <translation>Emoji</translation>
     </message>
     <message>
-        <location line="+72"/>
+        <location line="+73"/>
         <source>Select a file</source>
         <translation>Datei auswählen</translation>
     </message>
@@ -403,7 +403,7 @@
 <context>
     <name>TimelineModel</name>
     <message>
-        <location filename="../../src/timeline/TimelineModel.cpp" line="+867"/>
+        <location filename="../../src/timeline/TimelineModel.cpp" line="+687"/>
         <source>-- Encrypted Event (No keys found for decryption) --</source>
         <comment>Placeholder, when the message was not decrypted yet or can&apos;t be decrypted</comment>
         <translation>-- verschlüsselter Event (keine Schlüssel zur Entschlüsselung gefunden) --</translation>
@@ -427,18 +427,18 @@
         <translation>-- Entschlüsselungsfehler (%1) --</translation>
     </message>
     <message>
-        <location line="+25"/>
+        <location line="+29"/>
         <source>-- Encrypted Event (Unknown event type) --</source>
         <comment>Placeholder, when the message was decrypted, but we couldn&apos;t parse it, because Nheko/mtxclient don&apos;t support that event type yet</comment>
         <translation>-- verschlüsselter Event (Unbekannter Eventtyp) --</translation>
     </message>
     <message>
-        <location line="+54"/>
+        <location line="+48"/>
         <source>Message redaction failed: %1</source>
         <translation>Nachricht zurückziehen fehlgeschlagen: %1</translation>
     </message>
     <message>
-        <location line="+453"/>
+        <location line="+454"/>
         <source>Save image</source>
         <translation>Bild speichern</translation>
     </message>
@@ -457,11 +457,20 @@
         <source>Save file</source>
         <translation>Datei speichern</translation>
     </message>
+    <message numerus="yes">
+        <location line="+126"/>
+        <source>%1 and %2 are typing</source>
+        <comment>Multiple users are typing. First argument is a comma separated list of potentially multiple users. Second argument is the last user of that list. (If only one user is typing, %1 is empty. You should still use it in your string though to silence Qt warnings.)</comment>
+        <translation type="unfinished">
+            <numerusform>%1%2 tippt</numerusform>
+            <numerusform>%1 und %2 tippen</numerusform>
+        </translation>
+    </message>
 </context>
 <context>
     <name>TimelineRow</name>
     <message>
-        <location filename="../qml/TimelineRow.qml" line="+57"/>
+        <location filename="../qml/TimelineRow.qml" line="+104"/>
         <source>Reply</source>
         <translation>Antworten</translation>
     </message>
@@ -550,18 +559,6 @@
         <translation>Schließen</translation>
     </message>
 </context>
-<context>
-    <name>TypingDisplay</name>
-    <message numerus="yes">
-        <location filename="../../src/TypingDisplay.cpp" line="+37"/>
-        <source>%1 and %2 are typing</source>
-        <comment>Multiple users are typing. First argument is a comma separated list of potentially multiple users. Second argument is the last user of that list. (If only one user is typing, %1 is empty. You should still use it in your string though to silence Qt warnings.)</comment>
-        <translation>
-            <numerusform>%1%2 tippt</numerusform>
-            <numerusform>%1 und %2 tippen</numerusform>
-        </translation>
-    </message>
-</context>
 <context>
     <name>UserInfoWidget</name>
     <message>
@@ -573,7 +570,7 @@
 <context>
     <name>UserSettingsPage</name>
     <message>
-        <location filename="../../src/UserSettingsPage.cpp" line="+171"/>
+        <location filename="../../src/UserSettingsPage.cpp" line="+172"/>
         <source>Minimize to tray</source>
         <translation>Ins Benachrichtigungsfeld minimieren</translation>
     </message>
@@ -740,7 +737,7 @@
 <context>
     <name>descriptiveTime</name>
     <message>
-        <location filename="../../src/Utils.cpp" line="+104"/>
+        <location filename="../../src/Utils.cpp" line="+106"/>
         <source>Yesterday</source>
         <translation>Gestern</translation>
     </message>
@@ -1014,7 +1011,7 @@ Medien-Größe: %2
         <translation>Aktivierung der Verschlüsselung fehlgeschlagen: %1</translation>
     </message>
     <message>
-        <location line="+148"/>
+        <location line="+146"/>
         <source>Select an avatar</source>
         <translation>Wähle einen Avatar</translation>
     </message>
@@ -1114,7 +1111,7 @@ Medien-Größe: %2
 <context>
     <name>message-description sent:</name>
     <message>
-        <location filename="../../src/Utils.h" line="+95"/>
+        <location filename="../../src/Utils.h" line="+100"/>
         <source>You sent an audio clip</source>
         <translation>Du hast eine Audiodatei gesendet.</translation>
     </message>
@@ -1210,7 +1207,7 @@ Medien-Größe: %2
 <context>
     <name>utils</name>
     <message>
-        <location filename="../../src/Utils.cpp" line="+282"/>
+        <location filename="../../src/Utils.cpp" line="+306"/>
         <source>sent a file.</source>
         <translation type="unfinished"></translation>
     </message>
diff --git a/resources/langs/nheko_el.ts b/resources/langs/nheko_el.ts
index 1d9720ee..35fdeb80 100644
--- a/resources/langs/nheko_el.ts
+++ b/resources/langs/nheko_el.ts
@@ -4,12 +4,12 @@
 <context>
     <name>ChatPage</name>
     <message>
-        <location filename="../../src/ChatPage.cpp" line="+346"/>
+        <location filename="../../src/ChatPage.cpp" line="+329"/>
         <source>Failed to upload media. Please try again.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+389"/>
+        <location line="+392"/>
         <source>Failed to restore OLM account. Please login again.</source>
         <translation type="unfinished"></translation>
     </message>
@@ -19,7 +19,7 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+181"/>
+        <location line="+148"/>
         <source>Failed to setup encryption keys. Server response: %1 %2. Please try again later.</source>
         <translation type="unfinished"></translation>
     </message>
@@ -72,7 +72,7 @@
 <context>
     <name>EditModal</name>
     <message>
-        <location filename="../../src/dialogs/RoomSettings.cpp" line="+58"/>
+        <location filename="../../src/dialogs/RoomSettings.cpp" line="+59"/>
         <source>Apply</source>
         <translation type="unfinished"></translation>
     </message>
@@ -182,7 +182,7 @@
 <context>
     <name>MessageDelegate</name>
     <message>
-        <location filename="../qml/delegates/MessageDelegate.qml" line="+43"/>
+        <location filename="../qml/delegates/MessageDelegate.qml" line="+60"/>
         <source>redacted</source>
         <translation type="unfinished"></translation>
     </message>
@@ -223,7 +223,7 @@
 <context>
     <name>QuickSwitcher</name>
     <message>
-        <location filename="../../src/QuickSwitcher.cpp" line="+71"/>
+        <location filename="../../src/QuickSwitcher.cpp" line="+72"/>
         <source>Search for a room...</source>
         <translation>Αναζήτηση συνομιλίας...</translation>
     </message>
@@ -279,7 +279,7 @@
 <context>
     <name>ReplyPopup</name>
     <message>
-        <location filename="../../src/popups/ReplyPopup.cpp" line="+45"/>
+        <location filename="../../src/popups/ReplyPopup.cpp" line="+46"/>
         <source>Logout</source>
         <translation type="unfinished"></translation>
     </message>
@@ -287,7 +287,7 @@
 <context>
     <name>RoomInfo</name>
     <message>
-        <location filename="../../src/Cache.cpp" line="+2307"/>
+        <location filename="../../src/Cache.cpp" line="+2303"/>
         <source>no version stored</source>
         <translation type="unfinished"></translation>
     </message>
@@ -300,12 +300,12 @@
         <translation>Βγές</translation>
     </message>
     <message>
-        <location line="+161"/>
+        <location line="+151"/>
         <source>Accept</source>
         <translation>Αποδοχή</translation>
     </message>
     <message>
-        <location line="+1"/>
+        <location line="+3"/>
         <source>Decline</source>
         <translation>Απόρριψη</translation>
     </message>
@@ -364,13 +364,13 @@
 <context>
     <name>TextInputWidget</name>
     <message>
-        <location filename="../../src/TextInputWidget.cpp" line="+502"/>
+        <location filename="../../src/TextInputWidget.cpp" line="+496"/>
         <source>Send a file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+13"/>
-        <location filename="../../src/TextInputWidget.h" line="+161"/>
+        <location filename="../../src/TextInputWidget.h" line="+163"/>
         <source>Write a message...</source>
         <translation>Γράψε ένα μήνυμα...</translation>
     </message>
@@ -385,7 +385,7 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+72"/>
+        <location line="+73"/>
         <source>Select a file</source>
         <translation>Διάλεξε ένα αρχείο</translation>
     </message>
@@ -403,7 +403,7 @@
 <context>
     <name>TimelineModel</name>
     <message>
-        <location filename="../../src/timeline/TimelineModel.cpp" line="+867"/>
+        <location filename="../../src/timeline/TimelineModel.cpp" line="+687"/>
         <source>-- Encrypted Event (No keys found for decryption) --</source>
         <comment>Placeholder, when the message was not decrypted yet or can&apos;t be decrypted</comment>
         <translation type="unfinished"></translation>
@@ -427,18 +427,18 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+25"/>
+        <location line="+29"/>
         <source>-- Encrypted Event (Unknown event type) --</source>
         <comment>Placeholder, when the message was decrypted, but we couldn&apos;t parse it, because Nheko/mtxclient don&apos;t support that event type yet</comment>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+54"/>
+        <location line="+48"/>
         <source>Message redaction failed: %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+453"/>
+        <location line="+454"/>
         <source>Save image</source>
         <translation type="unfinished">Αποθήκευση Εικόνας</translation>
     </message>
@@ -457,11 +457,20 @@
         <source>Save file</source>
         <translation type="unfinished"></translation>
     </message>
+    <message numerus="yes">
+        <location line="+126"/>
+        <source>%1 and %2 are typing</source>
+        <comment>Multiple users are typing. First argument is a comma separated list of potentially multiple users. Second argument is the last user of that list. (If only one user is typing, %1 is empty. You should still use it in your string though to silence Qt warnings.)</comment>
+        <translation type="unfinished">
+            <numerusform></numerusform>
+            <numerusform></numerusform>
+        </translation>
+    </message>
 </context>
 <context>
     <name>TimelineRow</name>
     <message>
-        <location filename="../qml/TimelineRow.qml" line="+57"/>
+        <location filename="../qml/TimelineRow.qml" line="+104"/>
         <source>Reply</source>
         <translation type="unfinished"></translation>
     </message>
@@ -550,18 +559,6 @@
         <translation>Έξοδος</translation>
     </message>
 </context>
-<context>
-    <name>TypingDisplay</name>
-    <message numerus="yes">
-        <location filename="../../src/TypingDisplay.cpp" line="+37"/>
-        <source>%1 and %2 are typing</source>
-        <comment>Multiple users are typing. First argument is a comma separated list of potentially multiple users. Second argument is the last user of that list. (If only one user is typing, %1 is empty. You should still use it in your string though to silence Qt warnings.)</comment>
-        <translation type="unfinished">
-            <numerusform></numerusform>
-            <numerusform></numerusform>
-        </translation>
-    </message>
-</context>
 <context>
     <name>UserInfoWidget</name>
     <message>
@@ -573,7 +570,7 @@
 <context>
     <name>UserSettingsPage</name>
     <message>
-        <location filename="../../src/UserSettingsPage.cpp" line="+171"/>
+        <location filename="../../src/UserSettingsPage.cpp" line="+172"/>
         <source>Minimize to tray</source>
         <translation>Ελαχιστοποίηση</translation>
     </message>
@@ -740,7 +737,7 @@
 <context>
     <name>descriptiveTime</name>
     <message>
-        <location filename="../../src/Utils.cpp" line="+104"/>
+        <location filename="../../src/Utils.cpp" line="+106"/>
         <source>Yesterday</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1012,7 +1009,7 @@ Media size: %2
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+148"/>
+        <location line="+146"/>
         <source>Select an avatar</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1112,7 +1109,7 @@ Media size: %2
 <context>
     <name>message-description sent:</name>
     <message>
-        <location filename="../../src/Utils.h" line="+95"/>
+        <location filename="../../src/Utils.h" line="+100"/>
         <source>You sent an audio clip</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1208,7 +1205,7 @@ Media size: %2
 <context>
     <name>utils</name>
     <message>
-        <location filename="../../src/Utils.cpp" line="+282"/>
+        <location filename="../../src/Utils.cpp" line="+306"/>
         <source>sent a file.</source>
         <translation type="unfinished"></translation>
     </message>
diff --git a/resources/langs/nheko_en.ts b/resources/langs/nheko_en.ts
index fd8b4b25..40b6f09b 100644
--- a/resources/langs/nheko_en.ts
+++ b/resources/langs/nheko_en.ts
@@ -4,12 +4,12 @@
 <context>
     <name>ChatPage</name>
     <message>
-        <location filename="../../src/ChatPage.cpp" line="+346"/>
+        <location filename="../../src/ChatPage.cpp" line="+329"/>
         <source>Failed to upload media. Please try again.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+389"/>
+        <location line="+392"/>
         <source>Failed to restore OLM account. Please login again.</source>
         <translation>Failed to restore OLM account. Please login again.</translation>
     </message>
@@ -19,7 +19,7 @@
         <translation>Failed to restore save data. Please login again.</translation>
     </message>
     <message>
-        <location line="+181"/>
+        <location line="+148"/>
         <source>Failed to setup encryption keys. Server response: %1 %2. Please try again later.</source>
         <translation>Failed to setup encryption keys. Server response: %1 %2. Please try again later.</translation>
     </message>
@@ -72,7 +72,7 @@
 <context>
     <name>EditModal</name>
     <message>
-        <location filename="../../src/dialogs/RoomSettings.cpp" line="+58"/>
+        <location filename="../../src/dialogs/RoomSettings.cpp" line="+59"/>
         <source>Apply</source>
         <translation>Apply</translation>
     </message>
@@ -182,7 +182,7 @@
 <context>
     <name>MessageDelegate</name>
     <message>
-        <location filename="../qml/delegates/MessageDelegate.qml" line="+43"/>
+        <location filename="../qml/delegates/MessageDelegate.qml" line="+60"/>
         <source>redacted</source>
         <translation type="unfinished"></translation>
     </message>
@@ -223,7 +223,7 @@
 <context>
     <name>QuickSwitcher</name>
     <message>
-        <location filename="../../src/QuickSwitcher.cpp" line="+71"/>
+        <location filename="../../src/QuickSwitcher.cpp" line="+72"/>
         <source>Search for a room...</source>
         <translation>Search for a room…</translation>
     </message>
@@ -279,7 +279,7 @@
 <context>
     <name>ReplyPopup</name>
     <message>
-        <location filename="../../src/popups/ReplyPopup.cpp" line="+45"/>
+        <location filename="../../src/popups/ReplyPopup.cpp" line="+46"/>
         <source>Logout</source>
         <translation>Logout</translation>
     </message>
@@ -287,7 +287,7 @@
 <context>
     <name>RoomInfo</name>
     <message>
-        <location filename="../../src/Cache.cpp" line="+2307"/>
+        <location filename="../../src/Cache.cpp" line="+2303"/>
         <source>no version stored</source>
         <translation>no version stored</translation>
     </message>
@@ -300,12 +300,12 @@
         <translation>Leave room</translation>
     </message>
     <message>
-        <location line="+161"/>
+        <location line="+151"/>
         <source>Accept</source>
         <translation>Accept</translation>
     </message>
     <message>
-        <location line="+1"/>
+        <location line="+3"/>
         <source>Decline</source>
         <translation>Decline</translation>
     </message>
@@ -364,13 +364,13 @@
 <context>
     <name>TextInputWidget</name>
     <message>
-        <location filename="../../src/TextInputWidget.cpp" line="+502"/>
+        <location filename="../../src/TextInputWidget.cpp" line="+496"/>
         <source>Send a file</source>
         <translation>Send a file</translation>
     </message>
     <message>
         <location line="+13"/>
-        <location filename="../../src/TextInputWidget.h" line="+161"/>
+        <location filename="../../src/TextInputWidget.h" line="+163"/>
         <source>Write a message...</source>
         <translation>Write a message…</translation>
     </message>
@@ -385,7 +385,7 @@
         <translation>Emoji</translation>
     </message>
     <message>
-        <location line="+72"/>
+        <location line="+73"/>
         <source>Select a file</source>
         <translation>Select a file</translation>
     </message>
@@ -403,7 +403,7 @@
 <context>
     <name>TimelineModel</name>
     <message>
-        <location filename="../../src/timeline/TimelineModel.cpp" line="+867"/>
+        <location filename="../../src/timeline/TimelineModel.cpp" line="+687"/>
         <source>-- Encrypted Event (No keys found for decryption) --</source>
         <comment>Placeholder, when the message was not decrypted yet or can&apos;t be decrypted</comment>
         <translation type="unfinished">-- Encrypted Event (No keys found for decryption) --</translation>
@@ -427,18 +427,18 @@
         <translation type="unfinished">-- Decryption Error (%1) --</translation>
     </message>
     <message>
-        <location line="+25"/>
+        <location line="+29"/>
         <source>-- Encrypted Event (Unknown event type) --</source>
         <comment>Placeholder, when the message was decrypted, but we couldn&apos;t parse it, because Nheko/mtxclient don&apos;t support that event type yet</comment>
         <translation type="unfinished">-- Encrypted Event (Unknown event type) --</translation>
     </message>
     <message>
-        <location line="+54"/>
+        <location line="+48"/>
         <source>Message redaction failed: %1</source>
         <translation type="unfinished">Message redaction failed: %1</translation>
     </message>
     <message>
-        <location line="+453"/>
+        <location line="+454"/>
         <source>Save image</source>
         <translation type="unfinished">Save image</translation>
     </message>
@@ -457,11 +457,20 @@
         <source>Save file</source>
         <translation type="unfinished"></translation>
     </message>
+    <message numerus="yes">
+        <location line="+126"/>
+        <source>%1 and %2 are typing</source>
+        <comment>Multiple users are typing. First argument is a comma separated list of potentially multiple users. Second argument is the last user of that list. (If only one user is typing, %1 is empty. You should still use it in your string though to silence Qt warnings.)</comment>
+        <translation type="unfinished">
+            <numerusform>%1%2 is typing</numerusform>
+            <numerusform>%1 and %2 are typing</numerusform>
+        </translation>
+    </message>
 </context>
 <context>
     <name>TimelineRow</name>
     <message>
-        <location filename="../qml/TimelineRow.qml" line="+57"/>
+        <location filename="../qml/TimelineRow.qml" line="+104"/>
         <source>Reply</source>
         <translation type="unfinished"></translation>
     </message>
@@ -550,18 +559,6 @@
         <translation>Quit</translation>
     </message>
 </context>
-<context>
-    <name>TypingDisplay</name>
-    <message numerus="yes">
-        <location filename="../../src/TypingDisplay.cpp" line="+37"/>
-        <source>%1 and %2 are typing</source>
-        <comment>Multiple users are typing. First argument is a comma separated list of potentially multiple users. Second argument is the last user of that list. (If only one user is typing, %1 is empty. You should still use it in your string though to silence Qt warnings.)</comment>
-        <translation>
-            <numerusform>%1%2 is typing</numerusform>
-            <numerusform>%1 and %2 are typing</numerusform>
-        </translation>
-    </message>
-</context>
 <context>
     <name>UserInfoWidget</name>
     <message>
@@ -573,7 +570,7 @@
 <context>
     <name>UserSettingsPage</name>
     <message>
-        <location filename="../../src/UserSettingsPage.cpp" line="+171"/>
+        <location filename="../../src/UserSettingsPage.cpp" line="+172"/>
         <source>Minimize to tray</source>
         <translation>Minimize to tray</translation>
     </message>
@@ -740,7 +737,7 @@
 <context>
     <name>descriptiveTime</name>
     <message>
-        <location filename="../../src/Utils.cpp" line="+104"/>
+        <location filename="../../src/Utils.cpp" line="+106"/>
         <source>Yesterday</source>
         <translation>Yesterday</translation>
     </message>
@@ -1016,7 +1013,7 @@ Media size: %2
         <translation>Failed to enable encryption: %1</translation>
     </message>
     <message>
-        <location line="+148"/>
+        <location line="+146"/>
         <source>Select an avatar</source>
         <translation>Select an avatar</translation>
     </message>
@@ -1116,7 +1113,7 @@ Media size: %2
 <context>
     <name>message-description sent:</name>
     <message>
-        <location filename="../../src/Utils.h" line="+95"/>
+        <location filename="../../src/Utils.h" line="+100"/>
         <source>You sent an audio clip</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1212,7 +1209,7 @@ Media size: %2
 <context>
     <name>utils</name>
     <message>
-        <location filename="../../src/Utils.cpp" line="+282"/>
+        <location filename="../../src/Utils.cpp" line="+306"/>
         <source>sent a file.</source>
         <translation>sent a file.</translation>
     </message>
diff --git a/resources/langs/nheko_fi.ts b/resources/langs/nheko_fi.ts
index d851b879..cae5a109 100644
--- a/resources/langs/nheko_fi.ts
+++ b/resources/langs/nheko_fi.ts
@@ -4,12 +4,12 @@
 <context>
     <name>ChatPage</name>
     <message>
-        <location filename="../../src/ChatPage.cpp" line="+346"/>
+        <location filename="../../src/ChatPage.cpp" line="+329"/>
         <source>Failed to upload media. Please try again.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+389"/>
+        <location line="+392"/>
         <source>Failed to restore OLM account. Please login again.</source>
         <translation>OLM-tilin palauttaminen epäonnistui. Ole hyvä ja kirjaudu sisään uudelleen.</translation>
     </message>
@@ -19,7 +19,7 @@
         <translation>Tallennettujen tietojen palauttaminen epäonnistui. Ole hyvä ja kirjaudu sisään uudelleen.</translation>
     </message>
     <message>
-        <location line="+181"/>
+        <location line="+148"/>
         <source>Failed to setup encryption keys. Server response: %1 %2. Please try again later.</source>
         <translation>Salausavainten lähetys epäonnistui. Palvelimen vastaus: %1 %2. Ole hyvä ja yritä uudelleen myöhemmin.</translation>
     </message>
@@ -72,7 +72,7 @@
 <context>
     <name>EditModal</name>
     <message>
-        <location filename="../../src/dialogs/RoomSettings.cpp" line="+58"/>
+        <location filename="../../src/dialogs/RoomSettings.cpp" line="+59"/>
         <source>Apply</source>
         <translation>Tallenna</translation>
     </message>
@@ -182,7 +182,7 @@
 <context>
     <name>MessageDelegate</name>
     <message>
-        <location filename="../qml/delegates/MessageDelegate.qml" line="+43"/>
+        <location filename="../qml/delegates/MessageDelegate.qml" line="+60"/>
         <source>redacted</source>
         <translation type="unfinished"></translation>
     </message>
@@ -223,7 +223,7 @@
 <context>
     <name>QuickSwitcher</name>
     <message>
-        <location filename="../../src/QuickSwitcher.cpp" line="+71"/>
+        <location filename="../../src/QuickSwitcher.cpp" line="+72"/>
         <source>Search for a room...</source>
         <translation>Etsi huonetta…</translation>
     </message>
@@ -279,7 +279,7 @@
 <context>
     <name>ReplyPopup</name>
     <message>
-        <location filename="../../src/popups/ReplyPopup.cpp" line="+45"/>
+        <location filename="../../src/popups/ReplyPopup.cpp" line="+46"/>
         <source>Logout</source>
         <translation>Kirjaudu ulos</translation>
     </message>
@@ -287,7 +287,7 @@
 <context>
     <name>RoomInfo</name>
     <message>
-        <location filename="../../src/Cache.cpp" line="+2307"/>
+        <location filename="../../src/Cache.cpp" line="+2303"/>
         <source>no version stored</source>
         <translation>ei tallennettua versiota</translation>
     </message>
@@ -300,12 +300,12 @@
         <translation>Poistu huoneesta</translation>
     </message>
     <message>
-        <location line="+161"/>
+        <location line="+151"/>
         <source>Accept</source>
         <translation>Hyväksy</translation>
     </message>
     <message>
-        <location line="+1"/>
+        <location line="+3"/>
         <source>Decline</source>
         <translation>Hylkää</translation>
     </message>
@@ -364,13 +364,13 @@
 <context>
     <name>TextInputWidget</name>
     <message>
-        <location filename="../../src/TextInputWidget.cpp" line="+502"/>
+        <location filename="../../src/TextInputWidget.cpp" line="+496"/>
         <source>Send a file</source>
         <translation>Lähetä tiedosto</translation>
     </message>
     <message>
         <location line="+13"/>
-        <location filename="../../src/TextInputWidget.h" line="+161"/>
+        <location filename="../../src/TextInputWidget.h" line="+163"/>
         <source>Write a message...</source>
         <translation>Kirjoita viesti…</translation>
     </message>
@@ -385,7 +385,7 @@
         <translation>Emoji</translation>
     </message>
     <message>
-        <location line="+72"/>
+        <location line="+73"/>
         <source>Select a file</source>
         <translation>Valitse tiedosto</translation>
     </message>
@@ -403,7 +403,7 @@
 <context>
     <name>TimelineModel</name>
     <message>
-        <location filename="../../src/timeline/TimelineModel.cpp" line="+867"/>
+        <location filename="../../src/timeline/TimelineModel.cpp" line="+687"/>
         <source>-- Encrypted Event (No keys found for decryption) --</source>
         <comment>Placeholder, when the message was not decrypted yet or can&apos;t be decrypted</comment>
         <translation type="unfinished">-- Salattu viesti (salauksen purkuavaimia ei löydetty) --</translation>
@@ -427,18 +427,18 @@
         <translation type="unfinished">-- Virhe purkaessa salausta (%1) --</translation>
     </message>
     <message>
-        <location line="+25"/>
+        <location line="+29"/>
         <source>-- Encrypted Event (Unknown event type) --</source>
         <comment>Placeholder, when the message was decrypted, but we couldn&apos;t parse it, because Nheko/mtxclient don&apos;t support that event type yet</comment>
         <translation type="unfinished">-- Salattu viesti (tuntematon viestityyppi) --</translation>
     </message>
     <message>
-        <location line="+54"/>
+        <location line="+48"/>
         <source>Message redaction failed: %1</source>
         <translation type="unfinished">Viestin poisto epäonnistui: %1</translation>
     </message>
     <message>
-        <location line="+453"/>
+        <location line="+454"/>
         <source>Save image</source>
         <translation type="unfinished">Tallenna kuva</translation>
     </message>
@@ -457,11 +457,20 @@
         <source>Save file</source>
         <translation type="unfinished"></translation>
     </message>
+    <message numerus="yes">
+        <location line="+126"/>
+        <source>%1 and %2 are typing</source>
+        <comment>Multiple users are typing. First argument is a comma separated list of potentially multiple users. Second argument is the last user of that list. (If only one user is typing, %1 is empty. You should still use it in your string though to silence Qt warnings.)</comment>
+        <translation type="unfinished">
+            <numerusform>%1%2 kirjoittaa</numerusform>
+            <numerusform>%1 ja %2 kirjoittavat</numerusform>
+        </translation>
+    </message>
 </context>
 <context>
     <name>TimelineRow</name>
     <message>
-        <location filename="../qml/TimelineRow.qml" line="+57"/>
+        <location filename="../qml/TimelineRow.qml" line="+104"/>
         <source>Reply</source>
         <translation type="unfinished"></translation>
     </message>
@@ -550,18 +559,6 @@
         <translation>Lopeta</translation>
     </message>
 </context>
-<context>
-    <name>TypingDisplay</name>
-    <message numerus="yes">
-        <location filename="../../src/TypingDisplay.cpp" line="+37"/>
-        <source>%1 and %2 are typing</source>
-        <comment>Multiple users are typing. First argument is a comma separated list of potentially multiple users. Second argument is the last user of that list. (If only one user is typing, %1 is empty. You should still use it in your string though to silence Qt warnings.)</comment>
-        <translation>
-            <numerusform>%1%2 kirjoittaa</numerusform>
-            <numerusform>%1 ja %2 kirjoittavat</numerusform>
-        </translation>
-    </message>
-</context>
 <context>
     <name>UserInfoWidget</name>
     <message>
@@ -573,7 +570,7 @@
 <context>
     <name>UserSettingsPage</name>
     <message>
-        <location filename="../../src/UserSettingsPage.cpp" line="+171"/>
+        <location filename="../../src/UserSettingsPage.cpp" line="+172"/>
         <source>Minimize to tray</source>
         <translation>Pienennä ilmoitusalueelle</translation>
     </message>
@@ -740,7 +737,7 @@
 <context>
     <name>descriptiveTime</name>
     <message>
-        <location filename="../../src/Utils.cpp" line="+104"/>
+        <location filename="../../src/Utils.cpp" line="+106"/>
         <source>Yesterday</source>
         <translation>Eilen</translation>
     </message>
@@ -1016,7 +1013,7 @@ Median koko: %2
         <translation>Salauksen aktivointi epäonnistui: %1</translation>
     </message>
     <message>
-        <location line="+148"/>
+        <location line="+146"/>
         <source>Select an avatar</source>
         <translation>Valitse profiilikuva</translation>
     </message>
@@ -1116,7 +1113,7 @@ Median koko: %2
 <context>
     <name>message-description sent:</name>
     <message>
-        <location filename="../../src/Utils.h" line="+95"/>
+        <location filename="../../src/Utils.h" line="+100"/>
         <source>You sent an audio clip</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1212,7 +1209,7 @@ Median koko: %2
 <context>
     <name>utils</name>
     <message>
-        <location filename="../../src/Utils.cpp" line="+282"/>
+        <location filename="../../src/Utils.cpp" line="+306"/>
         <source>sent a file.</source>
         <translation type="unfinished"></translation>
     </message>
diff --git a/resources/langs/nheko_fr.ts b/resources/langs/nheko_fr.ts
index 15494953..3646d061 100644
--- a/resources/langs/nheko_fr.ts
+++ b/resources/langs/nheko_fr.ts
@@ -4,12 +4,12 @@
 <context>
     <name>ChatPage</name>
     <message>
-        <location filename="../../src/ChatPage.cpp" line="+346"/>
+        <location filename="../../src/ChatPage.cpp" line="+329"/>
         <source>Failed to upload media. Please try again.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+389"/>
+        <location line="+392"/>
         <source>Failed to restore OLM account. Please login again.</source>
         <translation type="unfinished"></translation>
     </message>
@@ -19,7 +19,7 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+181"/>
+        <location line="+148"/>
         <source>Failed to setup encryption keys. Server response: %1 %2. Please try again later.</source>
         <translation type="unfinished"></translation>
     </message>
@@ -72,7 +72,7 @@
 <context>
     <name>EditModal</name>
     <message>
-        <location filename="../../src/dialogs/RoomSettings.cpp" line="+58"/>
+        <location filename="../../src/dialogs/RoomSettings.cpp" line="+59"/>
         <source>Apply</source>
         <translation type="unfinished"></translation>
     </message>
@@ -182,7 +182,7 @@
 <context>
     <name>MessageDelegate</name>
     <message>
-        <location filename="../qml/delegates/MessageDelegate.qml" line="+43"/>
+        <location filename="../qml/delegates/MessageDelegate.qml" line="+60"/>
         <source>redacted</source>
         <translation type="unfinished"></translation>
     </message>
@@ -223,7 +223,7 @@
 <context>
     <name>QuickSwitcher</name>
     <message>
-        <location filename="../../src/QuickSwitcher.cpp" line="+71"/>
+        <location filename="../../src/QuickSwitcher.cpp" line="+72"/>
         <source>Search for a room...</source>
         <translation>Chercher un salon…</translation>
     </message>
@@ -280,7 +280,7 @@
 <context>
     <name>ReplyPopup</name>
     <message>
-        <location filename="../../src/popups/ReplyPopup.cpp" line="+45"/>
+        <location filename="../../src/popups/ReplyPopup.cpp" line="+46"/>
         <source>Logout</source>
         <translation type="unfinished"></translation>
     </message>
@@ -288,7 +288,7 @@
 <context>
     <name>RoomInfo</name>
     <message>
-        <location filename="../../src/Cache.cpp" line="+2307"/>
+        <location filename="../../src/Cache.cpp" line="+2303"/>
         <source>no version stored</source>
         <translation type="unfinished"></translation>
     </message>
@@ -301,12 +301,12 @@
         <translation>Quitter le salon</translation>
     </message>
     <message>
-        <location line="+161"/>
+        <location line="+151"/>
         <source>Accept</source>
         <translation>Accepter</translation>
     </message>
     <message>
-        <location line="+1"/>
+        <location line="+3"/>
         <source>Decline</source>
         <translation>Décliner</translation>
     </message>
@@ -365,13 +365,13 @@
 <context>
     <name>TextInputWidget</name>
     <message>
-        <location filename="../../src/TextInputWidget.cpp" line="+502"/>
+        <location filename="../../src/TextInputWidget.cpp" line="+496"/>
         <source>Send a file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+13"/>
-        <location filename="../../src/TextInputWidget.h" line="+161"/>
+        <location filename="../../src/TextInputWidget.h" line="+163"/>
         <source>Write a message...</source>
         <translation>Écrivez un message...</translation>
     </message>
@@ -386,7 +386,7 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+72"/>
+        <location line="+73"/>
         <source>Select a file</source>
         <translation>Sélectionnez un fichier</translation>
     </message>
@@ -404,7 +404,7 @@
 <context>
     <name>TimelineModel</name>
     <message>
-        <location filename="../../src/timeline/TimelineModel.cpp" line="+867"/>
+        <location filename="../../src/timeline/TimelineModel.cpp" line="+687"/>
         <source>-- Encrypted Event (No keys found for decryption) --</source>
         <comment>Placeholder, when the message was not decrypted yet or can&apos;t be decrypted</comment>
         <translation type="unfinished"></translation>
@@ -428,18 +428,18 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+25"/>
+        <location line="+29"/>
         <source>-- Encrypted Event (Unknown event type) --</source>
         <comment>Placeholder, when the message was decrypted, but we couldn&apos;t parse it, because Nheko/mtxclient don&apos;t support that event type yet</comment>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+54"/>
+        <location line="+48"/>
         <source>Message redaction failed: %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+453"/>
+        <location line="+454"/>
         <source>Save image</source>
         <translation type="unfinished">Enregistrer l&apos;image</translation>
     </message>
@@ -458,11 +458,20 @@
         <source>Save file</source>
         <translation type="unfinished"></translation>
     </message>
+    <message numerus="yes">
+        <location line="+126"/>
+        <source>%1 and %2 are typing</source>
+        <comment>Multiple users are typing. First argument is a comma separated list of potentially multiple users. Second argument is the last user of that list. (If only one user is typing, %1 is empty. You should still use it in your string though to silence Qt warnings.)</comment>
+        <translation type="unfinished">
+            <numerusform></numerusform>
+            <numerusform></numerusform>
+        </translation>
+    </message>
 </context>
 <context>
     <name>TimelineRow</name>
     <message>
-        <location filename="../qml/TimelineRow.qml" line="+57"/>
+        <location filename="../qml/TimelineRow.qml" line="+104"/>
         <source>Reply</source>
         <translation type="unfinished"></translation>
     </message>
@@ -551,18 +560,6 @@
         <translation>Quitter</translation>
     </message>
 </context>
-<context>
-    <name>TypingDisplay</name>
-    <message numerus="yes">
-        <location filename="../../src/TypingDisplay.cpp" line="+37"/>
-        <source>%1 and %2 are typing</source>
-        <comment>Multiple users are typing. First argument is a comma separated list of potentially multiple users. Second argument is the last user of that list. (If only one user is typing, %1 is empty. You should still use it in your string though to silence Qt warnings.)</comment>
-        <translation type="unfinished">
-            <numerusform></numerusform>
-            <numerusform></numerusform>
-        </translation>
-    </message>
-</context>
 <context>
     <name>UserInfoWidget</name>
     <message>
@@ -574,7 +571,7 @@
 <context>
     <name>UserSettingsPage</name>
     <message>
-        <location filename="../../src/UserSettingsPage.cpp" line="+171"/>
+        <location filename="../../src/UserSettingsPage.cpp" line="+172"/>
         <source>Minimize to tray</source>
         <translation>Réduire à la barre des tâches</translation>
     </message>
@@ -741,7 +738,7 @@
 <context>
     <name>descriptiveTime</name>
     <message>
-        <location filename="../../src/Utils.cpp" line="+104"/>
+        <location filename="../../src/Utils.cpp" line="+106"/>
         <source>Yesterday</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1015,7 +1012,7 @@ Taille du média : %2
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+148"/>
+        <location line="+146"/>
         <source>Select an avatar</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1115,7 +1112,7 @@ Taille du média : %2
 <context>
     <name>message-description sent:</name>
     <message>
-        <location filename="../../src/Utils.h" line="+95"/>
+        <location filename="../../src/Utils.h" line="+100"/>
         <source>You sent an audio clip</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1211,7 +1208,7 @@ Taille du média : %2
 <context>
     <name>utils</name>
     <message>
-        <location filename="../../src/Utils.cpp" line="+282"/>
+        <location filename="../../src/Utils.cpp" line="+306"/>
         <source>sent a file.</source>
         <translation type="unfinished"></translation>
     </message>
diff --git a/resources/langs/nheko_nl.ts b/resources/langs/nheko_nl.ts
index 8ff6d5d8..960feb6e 100644
--- a/resources/langs/nheko_nl.ts
+++ b/resources/langs/nheko_nl.ts
@@ -4,12 +4,12 @@
 <context>
     <name>ChatPage</name>
     <message>
-        <location filename="../../src/ChatPage.cpp" line="+346"/>
+        <location filename="../../src/ChatPage.cpp" line="+329"/>
         <source>Failed to upload media. Please try again.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+389"/>
+        <location line="+392"/>
         <source>Failed to restore OLM account. Please login again.</source>
         <translation type="unfinished"></translation>
     </message>
@@ -19,7 +19,7 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+181"/>
+        <location line="+148"/>
         <source>Failed to setup encryption keys. Server response: %1 %2. Please try again later.</source>
         <translation type="unfinished"></translation>
     </message>
@@ -72,7 +72,7 @@
 <context>
     <name>EditModal</name>
     <message>
-        <location filename="../../src/dialogs/RoomSettings.cpp" line="+58"/>
+        <location filename="../../src/dialogs/RoomSettings.cpp" line="+59"/>
         <source>Apply</source>
         <translation type="unfinished"></translation>
     </message>
@@ -182,7 +182,7 @@
 <context>
     <name>MessageDelegate</name>
     <message>
-        <location filename="../qml/delegates/MessageDelegate.qml" line="+43"/>
+        <location filename="../qml/delegates/MessageDelegate.qml" line="+60"/>
         <source>redacted</source>
         <translation type="unfinished"></translation>
     </message>
@@ -223,7 +223,7 @@
 <context>
     <name>QuickSwitcher</name>
     <message>
-        <location filename="../../src/QuickSwitcher.cpp" line="+71"/>
+        <location filename="../../src/QuickSwitcher.cpp" line="+72"/>
         <source>Search for a room...</source>
         <translation>Zoek een kamer...</translation>
     </message>
@@ -279,7 +279,7 @@
 <context>
     <name>ReplyPopup</name>
     <message>
-        <location filename="../../src/popups/ReplyPopup.cpp" line="+45"/>
+        <location filename="../../src/popups/ReplyPopup.cpp" line="+46"/>
         <source>Logout</source>
         <translation type="unfinished"></translation>
     </message>
@@ -287,7 +287,7 @@
 <context>
     <name>RoomInfo</name>
     <message>
-        <location filename="../../src/Cache.cpp" line="+2307"/>
+        <location filename="../../src/Cache.cpp" line="+2303"/>
         <source>no version stored</source>
         <translation type="unfinished"></translation>
     </message>
@@ -300,12 +300,12 @@
         <translation>Kamer verlaten</translation>
     </message>
     <message>
-        <location line="+161"/>
+        <location line="+151"/>
         <source>Accept</source>
         <translation>Accepteren</translation>
     </message>
     <message>
-        <location line="+1"/>
+        <location line="+3"/>
         <source>Decline</source>
         <translation>Afwijzen</translation>
     </message>
@@ -364,13 +364,13 @@
 <context>
     <name>TextInputWidget</name>
     <message>
-        <location filename="../../src/TextInputWidget.cpp" line="+502"/>
+        <location filename="../../src/TextInputWidget.cpp" line="+496"/>
         <source>Send a file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location line="+13"/>
-        <location filename="../../src/TextInputWidget.h" line="+161"/>
+        <location filename="../../src/TextInputWidget.h" line="+163"/>
         <source>Write a message...</source>
         <translation>Typ een bericht...</translation>
     </message>
@@ -385,7 +385,7 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+72"/>
+        <location line="+73"/>
         <source>Select a file</source>
         <translation>Kies een bestand</translation>
     </message>
@@ -403,7 +403,7 @@
 <context>
     <name>TimelineModel</name>
     <message>
-        <location filename="../../src/timeline/TimelineModel.cpp" line="+867"/>
+        <location filename="../../src/timeline/TimelineModel.cpp" line="+687"/>
         <source>-- Encrypted Event (No keys found for decryption) --</source>
         <comment>Placeholder, when the message was not decrypted yet or can&apos;t be decrypted</comment>
         <translation type="unfinished"></translation>
@@ -427,18 +427,18 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+25"/>
+        <location line="+29"/>
         <source>-- Encrypted Event (Unknown event type) --</source>
         <comment>Placeholder, when the message was decrypted, but we couldn&apos;t parse it, because Nheko/mtxclient don&apos;t support that event type yet</comment>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+54"/>
+        <location line="+48"/>
         <source>Message redaction failed: %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+453"/>
+        <location line="+454"/>
         <source>Save image</source>
         <translation type="unfinished">Afbeelding opslaan</translation>
     </message>
@@ -457,11 +457,20 @@
         <source>Save file</source>
         <translation type="unfinished"></translation>
     </message>
+    <message numerus="yes">
+        <location line="+126"/>
+        <source>%1 and %2 are typing</source>
+        <comment>Multiple users are typing. First argument is a comma separated list of potentially multiple users. Second argument is the last user of that list. (If only one user is typing, %1 is empty. You should still use it in your string though to silence Qt warnings.)</comment>
+        <translation type="unfinished">
+            <numerusform></numerusform>
+            <numerusform></numerusform>
+        </translation>
+    </message>
 </context>
 <context>
     <name>TimelineRow</name>
     <message>
-        <location filename="../qml/TimelineRow.qml" line="+57"/>
+        <location filename="../qml/TimelineRow.qml" line="+104"/>
         <source>Reply</source>
         <translation type="unfinished"></translation>
     </message>
@@ -550,18 +559,6 @@
         <translation>Afsluiten</translation>
     </message>
 </context>
-<context>
-    <name>TypingDisplay</name>
-    <message numerus="yes">
-        <location filename="../../src/TypingDisplay.cpp" line="+37"/>
-        <source>%1 and %2 are typing</source>
-        <comment>Multiple users are typing. First argument is a comma separated list of potentially multiple users. Second argument is the last user of that list. (If only one user is typing, %1 is empty. You should still use it in your string though to silence Qt warnings.)</comment>
-        <translation type="unfinished">
-            <numerusform></numerusform>
-            <numerusform></numerusform>
-        </translation>
-    </message>
-</context>
 <context>
     <name>UserInfoWidget</name>
     <message>
@@ -573,7 +570,7 @@
 <context>
     <name>UserSettingsPage</name>
     <message>
-        <location filename="../../src/UserSettingsPage.cpp" line="+171"/>
+        <location filename="../../src/UserSettingsPage.cpp" line="+172"/>
         <source>Minimize to tray</source>
         <translation>Minimaliseren naar systeemvak</translation>
     </message>
@@ -740,7 +737,7 @@
 <context>
     <name>descriptiveTime</name>
     <message>
-        <location filename="../../src/Utils.cpp" line="+104"/>
+        <location filename="../../src/Utils.cpp" line="+106"/>
         <source>Yesterday</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1014,7 +1011,7 @@ Mediagrootte: %2
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+148"/>
+        <location line="+146"/>
         <source>Select an avatar</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1114,7 +1111,7 @@ Mediagrootte: %2
 <context>
     <name>message-description sent:</name>
     <message>
-        <location filename="../../src/Utils.h" line="+95"/>
+        <location filename="../../src/Utils.h" line="+100"/>
         <source>You sent an audio clip</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1210,7 +1207,7 @@ Mediagrootte: %2
 <context>
     <name>utils</name>
     <message>
-        <location filename="../../src/Utils.cpp" line="+282"/>
+        <location filename="../../src/Utils.cpp" line="+306"/>
         <source>sent a file.</source>
         <translation type="unfinished"></translation>
     </message>
diff --git a/resources/langs/nheko_pl.ts b/resources/langs/nheko_pl.ts
index cb628fa6..a94ab30e 100644
--- a/resources/langs/nheko_pl.ts
+++ b/resources/langs/nheko_pl.ts
@@ -4,12 +4,12 @@
 <context>
     <name>ChatPage</name>
     <message>
-        <location filename="../../src/ChatPage.cpp" line="+346"/>
+        <location filename="../../src/ChatPage.cpp" line="+329"/>
         <source>Failed to upload media. Please try again.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+389"/>
+        <location line="+392"/>
         <source>Failed to restore OLM account. Please login again.</source>
         <translation>Nie udało się przywrócić konta OLM. Spróbuj zalogować się ponownie.</translation>
     </message>
@@ -19,7 +19,7 @@
         <translation>Nie udało się przywrócić zapisanych danych. Spróbuj zalogować się ponownie.</translation>
     </message>
     <message>
-        <location line="+181"/>
+        <location line="+148"/>
         <source>Failed to setup encryption keys. Server response: %1 %2. Please try again later.</source>
         <translation type="unfinished"></translation>
     </message>
@@ -72,7 +72,7 @@
 <context>
     <name>EditModal</name>
     <message>
-        <location filename="../../src/dialogs/RoomSettings.cpp" line="+58"/>
+        <location filename="../../src/dialogs/RoomSettings.cpp" line="+59"/>
         <source>Apply</source>
         <translation type="unfinished"></translation>
     </message>
@@ -182,7 +182,7 @@
 <context>
     <name>MessageDelegate</name>
     <message>
-        <location filename="../qml/delegates/MessageDelegate.qml" line="+43"/>
+        <location filename="../qml/delegates/MessageDelegate.qml" line="+60"/>
         <source>redacted</source>
         <translation type="unfinished"></translation>
     </message>
@@ -223,7 +223,7 @@
 <context>
     <name>QuickSwitcher</name>
     <message>
-        <location filename="../../src/QuickSwitcher.cpp" line="+71"/>
+        <location filename="../../src/QuickSwitcher.cpp" line="+72"/>
         <source>Search for a room...</source>
         <translation>Wyszukaj pokoju…</translation>
     </message>
@@ -279,7 +279,7 @@
 <context>
     <name>ReplyPopup</name>
     <message>
-        <location filename="../../src/popups/ReplyPopup.cpp" line="+45"/>
+        <location filename="../../src/popups/ReplyPopup.cpp" line="+46"/>
         <source>Logout</source>
         <translation type="unfinished">Wyloguj</translation>
     </message>
@@ -287,7 +287,7 @@
 <context>
     <name>RoomInfo</name>
     <message>
-        <location filename="../../src/Cache.cpp" line="+2307"/>
+        <location filename="../../src/Cache.cpp" line="+2303"/>
         <source>no version stored</source>
         <translation type="unfinished"></translation>
     </message>
@@ -300,12 +300,12 @@
         <translation>Opuść pokój</translation>
     </message>
     <message>
-        <location line="+161"/>
+        <location line="+151"/>
         <source>Accept</source>
         <translation>Akceptuj</translation>
     </message>
     <message>
-        <location line="+1"/>
+        <location line="+3"/>
         <source>Decline</source>
         <translation>Odrzuć</translation>
     </message>
@@ -364,13 +364,13 @@
 <context>
     <name>TextInputWidget</name>
     <message>
-        <location filename="../../src/TextInputWidget.cpp" line="+502"/>
+        <location filename="../../src/TextInputWidget.cpp" line="+496"/>
         <source>Send a file</source>
         <translation>Wyślij plik</translation>
     </message>
     <message>
         <location line="+13"/>
-        <location filename="../../src/TextInputWidget.h" line="+161"/>
+        <location filename="../../src/TextInputWidget.h" line="+163"/>
         <source>Write a message...</source>
         <translation>Napisz wiadomość…</translation>
     </message>
@@ -385,7 +385,7 @@
         <translation>Emoji</translation>
     </message>
     <message>
-        <location line="+72"/>
+        <location line="+73"/>
         <source>Select a file</source>
         <translation>Wybierz plik</translation>
     </message>
@@ -403,7 +403,7 @@
 <context>
     <name>TimelineModel</name>
     <message>
-        <location filename="../../src/timeline/TimelineModel.cpp" line="+867"/>
+        <location filename="../../src/timeline/TimelineModel.cpp" line="+687"/>
         <source>-- Encrypted Event (No keys found for decryption) --</source>
         <comment>Placeholder, when the message was not decrypted yet or can&apos;t be decrypted</comment>
         <translation type="unfinished"></translation>
@@ -427,18 +427,18 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+25"/>
+        <location line="+29"/>
         <source>-- Encrypted Event (Unknown event type) --</source>
         <comment>Placeholder, when the message was decrypted, but we couldn&apos;t parse it, because Nheko/mtxclient don&apos;t support that event type yet</comment>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+54"/>
+        <location line="+48"/>
         <source>Message redaction failed: %1</source>
         <translation type="unfinished">Redagowanie wiadomości nie powiodło się: %1</translation>
     </message>
     <message>
-        <location line="+453"/>
+        <location line="+454"/>
         <source>Save image</source>
         <translation type="unfinished">Zapisz obraz</translation>
     </message>
@@ -457,11 +457,21 @@
         <source>Save file</source>
         <translation type="unfinished"></translation>
     </message>
+    <message numerus="yes">
+        <location line="+126"/>
+        <source>%1 and %2 are typing</source>
+        <comment>Multiple users are typing. First argument is a comma separated list of potentially multiple users. Second argument is the last user of that list. (If only one user is typing, %1 is empty. You should still use it in your string though to silence Qt warnings.)</comment>
+        <translation type="unfinished">
+            <numerusform></numerusform>
+            <numerusform></numerusform>
+            <numerusform></numerusform>
+        </translation>
+    </message>
 </context>
 <context>
     <name>TimelineRow</name>
     <message>
-        <location filename="../qml/TimelineRow.qml" line="+57"/>
+        <location filename="../qml/TimelineRow.qml" line="+104"/>
         <source>Reply</source>
         <translation type="unfinished"></translation>
     </message>
@@ -550,19 +560,6 @@
         <translation>Zakończ</translation>
     </message>
 </context>
-<context>
-    <name>TypingDisplay</name>
-    <message numerus="yes">
-        <location filename="../../src/TypingDisplay.cpp" line="+37"/>
-        <source>%1 and %2 are typing</source>
-        <comment>Multiple users are typing. First argument is a comma separated list of potentially multiple users. Second argument is the last user of that list. (If only one user is typing, %1 is empty. You should still use it in your string though to silence Qt warnings.)</comment>
-        <translation type="unfinished">
-            <numerusform></numerusform>
-            <numerusform></numerusform>
-            <numerusform></numerusform>
-        </translation>
-    </message>
-</context>
 <context>
     <name>UserInfoWidget</name>
     <message>
@@ -574,7 +571,7 @@
 <context>
     <name>UserSettingsPage</name>
     <message>
-        <location filename="../../src/UserSettingsPage.cpp" line="+171"/>
+        <location filename="../../src/UserSettingsPage.cpp" line="+172"/>
         <source>Minimize to tray</source>
         <translation>Zminimalizuj do paska zadań</translation>
     </message>
@@ -741,7 +738,7 @@
 <context>
     <name>descriptiveTime</name>
     <message>
-        <location filename="../../src/Utils.cpp" line="+104"/>
+        <location filename="../../src/Utils.cpp" line="+106"/>
         <source>Yesterday</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1018,7 +1015,7 @@ Rozmiar multimediów: %2
         <translation>Nie udało się włączyć szyfrowania: %1</translation>
     </message>
     <message>
-        <location line="+148"/>
+        <location line="+146"/>
         <source>Select an avatar</source>
         <translation>Wybierz awatar</translation>
     </message>
@@ -1118,7 +1115,7 @@ Rozmiar multimediów: %2
 <context>
     <name>message-description sent:</name>
     <message>
-        <location filename="../../src/Utils.h" line="+95"/>
+        <location filename="../../src/Utils.h" line="+100"/>
         <source>You sent an audio clip</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1214,7 +1211,7 @@ Rozmiar multimediów: %2
 <context>
     <name>utils</name>
     <message>
-        <location filename="../../src/Utils.cpp" line="+282"/>
+        <location filename="../../src/Utils.cpp" line="+306"/>
         <source>sent a file.</source>
         <translation type="unfinished"></translation>
     </message>
diff --git a/resources/langs/nheko_ru.ts b/resources/langs/nheko_ru.ts
index 12b9873e..e8c7a4e8 100644
--- a/resources/langs/nheko_ru.ts
+++ b/resources/langs/nheko_ru.ts
@@ -4,12 +4,12 @@
 <context>
     <name>ChatPage</name>
     <message>
-        <location filename="../../src/ChatPage.cpp" line="+346"/>
+        <location filename="../../src/ChatPage.cpp" line="+329"/>
         <source>Failed to upload media. Please try again.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+389"/>
+        <location line="+392"/>
         <source>Failed to restore OLM account. Please login again.</source>
         <translation>Не удалось восстановить учетную запись OLM. Пожалуйста, войдите снова.</translation>
     </message>
@@ -19,7 +19,7 @@
         <translation>Не удалось восстановить сохраненные данные. Пожалуйста, войдите снова.</translation>
     </message>
     <message>
-        <location line="+181"/>
+        <location line="+148"/>
         <source>Failed to setup encryption keys. Server response: %1 %2. Please try again later.</source>
         <translation>Не удалось настроить ключи шифрования. Ответ сервера:%1 %2. Пожалуйста, попробуйте позже.</translation>
     </message>
@@ -72,7 +72,7 @@
 <context>
     <name>EditModal</name>
     <message>
-        <location filename="../../src/dialogs/RoomSettings.cpp" line="+58"/>
+        <location filename="../../src/dialogs/RoomSettings.cpp" line="+59"/>
         <source>Apply</source>
         <translation>Применить</translation>
     </message>
@@ -182,7 +182,7 @@
 <context>
     <name>MessageDelegate</name>
     <message>
-        <location filename="../qml/delegates/MessageDelegate.qml" line="+43"/>
+        <location filename="../qml/delegates/MessageDelegate.qml" line="+60"/>
         <source>redacted</source>
         <translation type="unfinished"></translation>
     </message>
@@ -223,7 +223,7 @@
 <context>
     <name>QuickSwitcher</name>
     <message>
-        <location filename="../../src/QuickSwitcher.cpp" line="+71"/>
+        <location filename="../../src/QuickSwitcher.cpp" line="+72"/>
         <source>Search for a room...</source>
         <translation>Поиск комнаты...</translation>
     </message>
@@ -279,7 +279,7 @@
 <context>
     <name>ReplyPopup</name>
     <message>
-        <location filename="../../src/popups/ReplyPopup.cpp" line="+45"/>
+        <location filename="../../src/popups/ReplyPopup.cpp" line="+46"/>
         <source>Logout</source>
         <translation type="unfinished">Выйти</translation>
     </message>
@@ -287,7 +287,7 @@
 <context>
     <name>RoomInfo</name>
     <message>
-        <location filename="../../src/Cache.cpp" line="+2307"/>
+        <location filename="../../src/Cache.cpp" line="+2303"/>
         <source>no version stored</source>
         <translation type="unfinished"></translation>
     </message>
@@ -300,12 +300,12 @@
         <translation>Покинуть комнату</translation>
     </message>
     <message>
-        <location line="+161"/>
+        <location line="+151"/>
         <source>Accept</source>
         <translation>Принять</translation>
     </message>
     <message>
-        <location line="+1"/>
+        <location line="+3"/>
         <source>Decline</source>
         <translation>Отказаться</translation>
     </message>
@@ -364,13 +364,13 @@
 <context>
     <name>TextInputWidget</name>
     <message>
-        <location filename="../../src/TextInputWidget.cpp" line="+502"/>
+        <location filename="../../src/TextInputWidget.cpp" line="+496"/>
         <source>Send a file</source>
         <translation>Отправить файл</translation>
     </message>
     <message>
         <location line="+13"/>
-        <location filename="../../src/TextInputWidget.h" line="+161"/>
+        <location filename="../../src/TextInputWidget.h" line="+163"/>
         <source>Write a message...</source>
         <translation>Написать сообщение...</translation>
     </message>
@@ -385,7 +385,7 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+72"/>
+        <location line="+73"/>
         <source>Select a file</source>
         <translation>Выберите файл</translation>
     </message>
@@ -403,7 +403,7 @@
 <context>
     <name>TimelineModel</name>
     <message>
-        <location filename="../../src/timeline/TimelineModel.cpp" line="+867"/>
+        <location filename="../../src/timeline/TimelineModel.cpp" line="+687"/>
         <source>-- Encrypted Event (No keys found for decryption) --</source>
         <comment>Placeholder, when the message was not decrypted yet or can&apos;t be decrypted</comment>
         <translation type="unfinished"></translation>
@@ -427,18 +427,18 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+25"/>
+        <location line="+29"/>
         <source>-- Encrypted Event (Unknown event type) --</source>
         <comment>Placeholder, when the message was decrypted, but we couldn&apos;t parse it, because Nheko/mtxclient don&apos;t support that event type yet</comment>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+54"/>
+        <location line="+48"/>
         <source>Message redaction failed: %1</source>
         <translation type="unfinished">Ошибка редактирования сообщения: %1</translation>
     </message>
     <message>
-        <location line="+453"/>
+        <location line="+454"/>
         <source>Save image</source>
         <translation type="unfinished">Сохранить изображение</translation>
     </message>
@@ -457,11 +457,21 @@
         <source>Save file</source>
         <translation type="unfinished"></translation>
     </message>
+    <message numerus="yes">
+        <location line="+126"/>
+        <source>%1 and %2 are typing</source>
+        <comment>Multiple users are typing. First argument is a comma separated list of potentially multiple users. Second argument is the last user of that list. (If only one user is typing, %1 is empty. You should still use it in your string though to silence Qt warnings.)</comment>
+        <translation type="unfinished">
+            <numerusform></numerusform>
+            <numerusform></numerusform>
+            <numerusform></numerusform>
+        </translation>
+    </message>
 </context>
 <context>
     <name>TimelineRow</name>
     <message>
-        <location filename="../qml/TimelineRow.qml" line="+57"/>
+        <location filename="../qml/TimelineRow.qml" line="+104"/>
         <source>Reply</source>
         <translation type="unfinished"></translation>
     </message>
@@ -550,19 +560,6 @@
         <translation>Выйти</translation>
     </message>
 </context>
-<context>
-    <name>TypingDisplay</name>
-    <message numerus="yes">
-        <location filename="../../src/TypingDisplay.cpp" line="+37"/>
-        <source>%1 and %2 are typing</source>
-        <comment>Multiple users are typing. First argument is a comma separated list of potentially multiple users. Second argument is the last user of that list. (If only one user is typing, %1 is empty. You should still use it in your string though to silence Qt warnings.)</comment>
-        <translation type="unfinished">
-            <numerusform></numerusform>
-            <numerusform></numerusform>
-            <numerusform></numerusform>
-        </translation>
-    </message>
-</context>
 <context>
     <name>UserInfoWidget</name>
     <message>
@@ -574,7 +571,7 @@
 <context>
     <name>UserSettingsPage</name>
     <message>
-        <location filename="../../src/UserSettingsPage.cpp" line="+171"/>
+        <location filename="../../src/UserSettingsPage.cpp" line="+172"/>
         <source>Minimize to tray</source>
         <translation>Сворачивать в системную панель</translation>
     </message>
@@ -742,7 +739,7 @@
 <context>
     <name>descriptiveTime</name>
     <message>
-        <location filename="../../src/Utils.cpp" line="+104"/>
+        <location filename="../../src/Utils.cpp" line="+106"/>
         <source>Yesterday</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1017,7 +1014,7 @@ Media size: %2
         <translation>Не удалось включить шифрование: %1</translation>
     </message>
     <message>
-        <location line="+148"/>
+        <location line="+146"/>
         <source>Select an avatar</source>
         <translation>Выберите аватар</translation>
     </message>
@@ -1117,7 +1114,7 @@ Media size: %2
 <context>
     <name>message-description sent:</name>
     <message>
-        <location filename="../../src/Utils.h" line="+95"/>
+        <location filename="../../src/Utils.h" line="+100"/>
         <source>You sent an audio clip</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1213,7 +1210,7 @@ Media size: %2
 <context>
     <name>utils</name>
     <message>
-        <location filename="../../src/Utils.cpp" line="+282"/>
+        <location filename="../../src/Utils.cpp" line="+306"/>
         <source>sent a file.</source>
         <translation type="unfinished"></translation>
     </message>
diff --git a/resources/langs/nheko_zh_CN.ts b/resources/langs/nheko_zh_CN.ts
index 799a534d..718bcb55 100644
--- a/resources/langs/nheko_zh_CN.ts
+++ b/resources/langs/nheko_zh_CN.ts
@@ -4,12 +4,12 @@
 <context>
     <name>ChatPage</name>
     <message>
-        <location filename="../../src/ChatPage.cpp" line="+346"/>
+        <location filename="../../src/ChatPage.cpp" line="+329"/>
         <source>Failed to upload media. Please try again.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+389"/>
+        <location line="+392"/>
         <source>Failed to restore OLM account. Please login again.</source>
         <translation>恢复 OLM 账户失败。请重新登录。</translation>
     </message>
@@ -19,7 +19,7 @@
         <translation>恢复保存的数据失败。请重新登录。</translation>
     </message>
     <message>
-        <location line="+181"/>
+        <location line="+148"/>
         <source>Failed to setup encryption keys. Server response: %1 %2. Please try again later.</source>
         <translation type="unfinished"></translation>
     </message>
@@ -72,7 +72,7 @@
 <context>
     <name>EditModal</name>
     <message>
-        <location filename="../../src/dialogs/RoomSettings.cpp" line="+58"/>
+        <location filename="../../src/dialogs/RoomSettings.cpp" line="+59"/>
         <source>Apply</source>
         <translation type="unfinished"></translation>
     </message>
@@ -182,7 +182,7 @@
 <context>
     <name>MessageDelegate</name>
     <message>
-        <location filename="../qml/delegates/MessageDelegate.qml" line="+43"/>
+        <location filename="../qml/delegates/MessageDelegate.qml" line="+60"/>
         <source>redacted</source>
         <translation type="unfinished"></translation>
     </message>
@@ -223,7 +223,7 @@
 <context>
     <name>QuickSwitcher</name>
     <message>
-        <location filename="../../src/QuickSwitcher.cpp" line="+71"/>
+        <location filename="../../src/QuickSwitcher.cpp" line="+72"/>
         <source>Search for a room...</source>
         <translation>寻找一个聊天室...</translation>
     </message>
@@ -279,7 +279,7 @@
 <context>
     <name>ReplyPopup</name>
     <message>
-        <location filename="../../src/popups/ReplyPopup.cpp" line="+45"/>
+        <location filename="../../src/popups/ReplyPopup.cpp" line="+46"/>
         <source>Logout</source>
         <translation type="unfinished">登出</translation>
     </message>
@@ -287,7 +287,7 @@
 <context>
     <name>RoomInfo</name>
     <message>
-        <location filename="../../src/Cache.cpp" line="+2307"/>
+        <location filename="../../src/Cache.cpp" line="+2303"/>
         <source>no version stored</source>
         <translation type="unfinished"></translation>
     </message>
@@ -300,12 +300,12 @@
         <translation>离开聊天室</translation>
     </message>
     <message>
-        <location line="+161"/>
+        <location line="+151"/>
         <source>Accept</source>
         <translation>接受</translation>
     </message>
     <message>
-        <location line="+1"/>
+        <location line="+3"/>
         <source>Decline</source>
         <translation>拒绝</translation>
     </message>
@@ -364,13 +364,13 @@
 <context>
     <name>TextInputWidget</name>
     <message>
-        <location filename="../../src/TextInputWidget.cpp" line="+502"/>
+        <location filename="../../src/TextInputWidget.cpp" line="+496"/>
         <source>Send a file</source>
         <translation>发送一个文件</translation>
     </message>
     <message>
         <location line="+13"/>
-        <location filename="../../src/TextInputWidget.h" line="+161"/>
+        <location filename="../../src/TextInputWidget.h" line="+163"/>
         <source>Write a message...</source>
         <translation>写一条消息...</translation>
     </message>
@@ -385,7 +385,7 @@
         <translation></translation>
     </message>
     <message>
-        <location line="+72"/>
+        <location line="+73"/>
         <source>Select a file</source>
         <translation>选择一个文件</translation>
     </message>
@@ -403,7 +403,7 @@
 <context>
     <name>TimelineModel</name>
     <message>
-        <location filename="../../src/timeline/TimelineModel.cpp" line="+867"/>
+        <location filename="../../src/timeline/TimelineModel.cpp" line="+687"/>
         <source>-- Encrypted Event (No keys found for decryption) --</source>
         <comment>Placeholder, when the message was not decrypted yet or can&apos;t be decrypted</comment>
         <translation type="unfinished"></translation>
@@ -427,18 +427,18 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+25"/>
+        <location line="+29"/>
         <source>-- Encrypted Event (Unknown event type) --</source>
         <comment>Placeholder, when the message was decrypted, but we couldn&apos;t parse it, because Nheko/mtxclient don&apos;t support that event type yet</comment>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location line="+54"/>
+        <location line="+48"/>
         <source>Message redaction failed: %1</source>
         <translation type="unfinished">删除消息失败：%1</translation>
     </message>
     <message>
-        <location line="+453"/>
+        <location line="+454"/>
         <source>Save image</source>
         <translation type="unfinished">保存图像</translation>
     </message>
@@ -457,11 +457,19 @@
         <source>Save file</source>
         <translation type="unfinished"></translation>
     </message>
+    <message numerus="yes">
+        <location line="+126"/>
+        <source>%1 and %2 are typing</source>
+        <comment>Multiple users are typing. First argument is a comma separated list of potentially multiple users. Second argument is the last user of that list. (If only one user is typing, %1 is empty. You should still use it in your string though to silence Qt warnings.)</comment>
+        <translation type="unfinished">
+            <numerusform></numerusform>
+        </translation>
+    </message>
 </context>
 <context>
     <name>TimelineRow</name>
     <message>
-        <location filename="../qml/TimelineRow.qml" line="+57"/>
+        <location filename="../qml/TimelineRow.qml" line="+104"/>
         <source>Reply</source>
         <translation type="unfinished"></translation>
     </message>
@@ -550,17 +558,6 @@
         <translation>退出</translation>
     </message>
 </context>
-<context>
-    <name>TypingDisplay</name>
-    <message numerus="yes">
-        <location filename="../../src/TypingDisplay.cpp" line="+37"/>
-        <source>%1 and %2 are typing</source>
-        <comment>Multiple users are typing. First argument is a comma separated list of potentially multiple users. Second argument is the last user of that list. (If only one user is typing, %1 is empty. You should still use it in your string though to silence Qt warnings.)</comment>
-        <translation type="unfinished">
-            <numerusform></numerusform>
-        </translation>
-    </message>
-</context>
 <context>
     <name>UserInfoWidget</name>
     <message>
@@ -572,7 +569,7 @@
 <context>
     <name>UserSettingsPage</name>
     <message>
-        <location filename="../../src/UserSettingsPage.cpp" line="+171"/>
+        <location filename="../../src/UserSettingsPage.cpp" line="+172"/>
         <source>Minimize to tray</source>
         <translation>最小化至托盘</translation>
     </message>
@@ -739,7 +736,7 @@
 <context>
     <name>descriptiveTime</name>
     <message>
-        <location filename="../../src/Utils.cpp" line="+104"/>
+        <location filename="../../src/Utils.cpp" line="+106"/>
         <source>Yesterday</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1014,7 +1011,7 @@ Media size: %2
         <translation>启用加密失败：%1</translation>
     </message>
     <message>
-        <location line="+148"/>
+        <location line="+146"/>
         <source>Select an avatar</source>
         <translation>选择一个头像</translation>
     </message>
@@ -1122,7 +1119,7 @@ Media size: %2
 <context>
     <name>message-description sent:</name>
     <message>
-        <location filename="../../src/Utils.h" line="+95"/>
+        <location filename="../../src/Utils.h" line="+100"/>
         <source>You sent an audio clip</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1218,7 +1215,7 @@ Media size: %2
 <context>
     <name>utils</name>
     <message>
-        <location filename="../../src/Utils.cpp" line="+282"/>
+        <location filename="../../src/Utils.cpp" line="+306"/>
         <source>sent a file.</source>
         <translation type="unfinished"></translation>
     </message>
diff --git a/resources/qml/TimelineView.qml b/resources/qml/TimelineView.qml
index bfea79ee..60a8e6c1 100644
--- a/resources/qml/TimelineView.qml
+++ b/resources/qml/TimelineView.qml
@@ -38,7 +38,11 @@ Item {
 			id: chat
 
 			visible: timelineManager.timeline != null
-			anchors.fill: parent
+
+			anchors.left: parent.left
+			anchors.right: parent.right
+			anchors.top: parent.top
+			anchors.bottom: chatFooter.top
 
 			anchors.leftMargin: 4
 			anchors.rightMargin: scrollbar.width
@@ -179,6 +183,31 @@ Item {
 					}
 				}
 			}
+
+		}
+
+		Rectangle {
+			id: chatFooter
+
+			height: Math.max(16, typingDisplay.height)
+			anchors.left: parent.left
+			anchors.right: parent.right
+			anchors.bottom: parent.bottom
+			z: 3
+
+			color: colors.window
+
+			Text {
+				anchors.left: parent.left
+				anchors.right: parent.right
+				anchors.bottom: parent.bottom
+				anchors.leftMargin: 10
+				anchors.rightMargin: 10
+
+				id: typingDisplay
+				text: chat.model ? chat.model.formatTypingUsers(chat.model.typingUsers, chatFooter.color) : ""
+				color: colors.windowText
+			}
 		}
 	}
 }
diff --git a/src/ChatPage.cpp b/src/ChatPage.cpp
index 777709be..125e229a 100644
--- a/src/ChatPage.cpp
+++ b/src/ChatPage.cpp
@@ -34,7 +34,6 @@
 #include "Splitter.h"
 #include "TextInputWidget.h"
 #include "TopRoomBar.h"
-#include "TypingDisplay.h"
 #include "UserInfoWidget.h"
 #include "UserSettingsPage.h"
 #include "Utils.h"
@@ -130,11 +129,6 @@ ChatPage::ChatPage(QSharedPointer<UserSettings> userSettings, QWidget *parent)
         text_input_ = new TextInputWidget(this);
         contentLayout_->addWidget(text_input_);
 
-        typingDisplay_ = new TypingDisplay(content_);
-        typingDisplay_->hide();
-        connect(
-          text_input_, &TextInputWidget::heightChanged, typingDisplay_, &TypingDisplay::setOffset);
-
         typingRefresher_ = new QTimer(this);
         typingRefresher_->setInterval(TYPING_REFRESH_TIMEOUT);
 
@@ -225,19 +219,6 @@ ChatPage::ChatPage(QSharedPointer<UserSettings> userSettings, QWidget *parent)
                 }
         });
 
-        connect(room_list_, &RoomList::roomChanged, this, [this](const QString &roomid) {
-                QStringList users;
-
-                if (!userSettings_->isTypingNotificationsEnabled()) {
-                        typingDisplay_->setUsers(users);
-                        return;
-                }
-
-                if (typingUsers_.find(roomid) != typingUsers_.end())
-                        users = typingUsers_[roomid];
-
-                typingDisplay_->setUsers(users);
-        });
         connect(room_list_, &RoomList::roomChanged, text_input_, &TextInputWidget::stopTyping);
         connect(room_list_, &RoomList::roomChanged, this, &ChatPage::changeTopRoomInfo);
         connect(room_list_, &RoomList::roomChanged, splitter, &Splitter::showChatView);
@@ -472,8 +453,6 @@ ChatPage::ChatPage(QSharedPointer<UserSettings> userSettings, QWidget *parent)
                 bool hasNotifications = false;
                 for (const auto &room : rooms.join) {
                         auto room_id = QString::fromStdString(room.first);
-
-                        updateTypingUsers(room_id, room.second.ephemeral.typing);
                         updateRoomNotificationCount(
                           room_id,
                           room.second.unread_notifications.notification_count,
@@ -786,38 +765,6 @@ ChatPage::removeRoom(const QString &room_id)
         room_list_->removeRoom(room_id, room_id == current_room_);
 }
 
-void
-ChatPage::updateTypingUsers(const QString &roomid, const std::vector<std::string> &user_ids)
-{
-        if (!userSettings_->isTypingNotificationsEnabled())
-                return;
-
-        typingUsers_[roomid] = generateTypingUsers(roomid, user_ids);
-
-        if (current_room_ == roomid)
-                typingDisplay_->setUsers(typingUsers_[roomid]);
-}
-
-QStringList
-ChatPage::generateTypingUsers(const QString &room_id, const std::vector<std::string> &typing_users)
-{
-        QStringList users;
-        auto local_user = utils::localUser();
-
-        for (const auto &uid : typing_users) {
-                const auto remote_user = QString::fromStdString(uid);
-
-                if (remote_user == local_user)
-                        continue;
-
-                users.append(cache::displayName(room_id, remote_user));
-        }
-
-        users.sort();
-
-        return users;
-}
-
 void
 ChatPage::removeLeftRooms(const std::map<std::string, mtx::responses::LeftRoom> &rooms)
 {
diff --git a/src/ChatPage.h b/src/ChatPage.h
index e4c0ef16..354a21f3 100644
--- a/src/ChatPage.h
+++ b/src/ChatPage.h
@@ -48,7 +48,6 @@ class Splitter;
 class TextInputWidget;
 class TimelineViewManager;
 class TopRoomBar;
-class TypingDisplay;
 class UserInfoWidget;
 class UserSettings;
 class NotificationsManager;
@@ -187,8 +186,6 @@ private:
         using LeftRooms = std::map<std::string, mtx::responses::LeftRoom>;
         void removeLeftRooms(const LeftRooms &rooms);
 
-        void updateTypingUsers(const QString &roomid, const std::vector<std::string> &user_ids);
-
         void loadStateFromCache();
         void resetUI();
         //! Decides whether or not to hide the group's sidebar.
@@ -206,9 +203,6 @@ private:
 
         void showNotificationsDialog(const QPoint &point);
 
-        QStringList generateTypingUsers(const QString &room_id,
-                                        const std::vector<std::string> &typing_users);
-
         QHBoxLayout *topLayout_;
         Splitter *splitter;
 
@@ -228,7 +222,6 @@ private:
 
         TopRoomBar *top_bar_;
         TextInputWidget *text_input_;
-        TypingDisplay *typingDisplay_;
 
         QTimer connectivityTimer_;
         std::atomic_bool isConnected_;
@@ -240,8 +233,6 @@ private:
 
         popups::UserMentions *user_mentions_popup_;
 
-        // Keeps track of the users currently typing on each room.
-        std::map<QString, QList<QString>> typingUsers_;
         QTimer *typingRefresher_;
 
         // Global user settings.
diff --git a/src/TypingDisplay.cpp b/src/TypingDisplay.cpp
deleted file mode 100644
index 43fabcd8..00000000
--- a/src/TypingDisplay.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#include <QDebug>
-#include <QPainter>
-#include <QPoint>
-#include <QShowEvent>
-#include <QtGlobal>
-
-#include "Config.h"
-#include "TypingDisplay.h"
-#include "ui/Painter.h"
-
-constexpr int LEFT_PADDING = 24;
-constexpr int RECT_PADDING = 2;
-
-TypingDisplay::TypingDisplay(QWidget *parent)
-  : OverlayWidget(parent)
-  , offset_{conf::textInput::height}
-{
-        setFixedHeight(QFontMetrics(font()).height() + RECT_PADDING);
-        setAttribute(Qt::WA_TransparentForMouseEvents);
-}
-
-void
-TypingDisplay::setOffset(int margin)
-{
-        offset_ = margin;
-        move(0, parentWidget()->height() - offset_ - height());
-}
-
-void
-TypingDisplay::setUsers(const QStringList &uid)
-{
-        move(0, parentWidget()->height() - offset_ - height());
-
-        text_.clear();
-
-        QString temp = text_ +=
-          tr("%1 and %2 are typing",
-             "Multiple users are typing. First argument is a comma separated list of potentially "
-             "multiple users. Second argument is the last user of that list. (If only one user is "
-             "typing, %1 is empty. You should still use it in your string though to silence Qt "
-             "warnings.)",
-             uid.size());
-
-        if (uid.isEmpty()) {
-                hide();
-                update();
-
-                return;
-        }
-
-        QStringList uidWithoutLast = uid;
-        uidWithoutLast.pop_back();
-        text_ = temp.arg(uidWithoutLast.join(", ")).arg(uid.back());
-
-        show();
-        update();
-}
-
-void
-TypingDisplay::paintEvent(QPaintEvent *)
-{
-        Painter p(this);
-        PainterHighQualityEnabler hq(p);
-
-        QFont f;
-        f.setPointSizeF(f.pointSizeF() * 0.9);
-
-        p.setFont(f);
-        p.setPen(QPen(textColor()));
-
-        QRect region = rect();
-        region.translate(LEFT_PADDING, 0);
-
-        QFontMetrics fm(f);
-        text_ = fm.elidedText(text_, Qt::ElideRight, (double)(width() * 0.75));
-
-        QPainterPath path;
-#if QT_VERSION < QT_VERSION_CHECK(5, 11, 0)
-        path.addRoundedRect(QRectF(0, 0, fm.width(text_) + 2 * LEFT_PADDING, height()), 3, 3);
-#else
-        path.addRoundedRect(
-          QRectF(0, 0, fm.horizontalAdvance(text_) + 2 * LEFT_PADDING, height()), 3, 3);
-#endif
-        p.fillPath(path, backgroundColor());
-        p.drawText(region, Qt::AlignVCenter, text_);
-}
diff --git a/src/TypingDisplay.h b/src/TypingDisplay.h
deleted file mode 100644
index 332d9c66..00000000
--- a/src/TypingDisplay.h
+++ /dev/null
@@ -1,36 +0,0 @@
-#pragma once
-
-#include "ui/OverlayWidget.h"
-
-class QPaintEvent;
-
-class TypingDisplay : public OverlayWidget
-{
-        Q_OBJECT
-
-        Q_PROPERTY(QColor textColor WRITE setTextColor READ textColor)
-        Q_PROPERTY(QColor backgroundColor WRITE setBackgroundColor READ backgroundColor)
-
-public:
-        TypingDisplay(QWidget *parent = nullptr);
-
-        void setUsers(const QStringList &user_ids);
-
-        void setTextColor(const QColor &color) { textColor_ = color; };
-        QColor textColor() const { return textColor_; };
-
-        void setBackgroundColor(const QColor &color) { bgColor_ = color; };
-        QColor backgroundColor() const { return bgColor_; };
-
-public slots:
-        void setOffset(int margin);
-
-protected:
-        void paintEvent(QPaintEvent *event) override;
-
-private:
-        int offset_;
-        QColor textColor_;
-        QColor bgColor_;
-        QString text_;
-};
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 08c29927..2fd4b6d4 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -1388,3 +1388,33 @@ TimelineModel::cacheMedia(QString eventId)
                   emit mediaCached(mxcUrl, filename.filePath());
           });
 }
+
+QString
+TimelineModel::formatTypingUsers(const std::vector<QString> &users, QColor bg)
+{
+        QString temp =
+          tr("%1 and %2 are typing",
+             "Multiple users are typing. First argument is a comma separated list of potentially "
+             "multiple users. Second argument is the last user of that list. (If only one user is "
+             "typing, %1 is empty. You should still use it in your string though to silence Qt "
+             "warnings.)",
+             users.size());
+
+        if (users.empty()) {
+                return "";
+        }
+
+        QStringList uidWithoutLast;
+
+        auto formatUser = [this, bg](const QString &user_id) -> QString {
+                return QString("<font color=\"%1\">%2</font>")
+                  .arg(userColor(user_id, bg).name())
+                  .arg(escapeEmoji(displayName(user_id).toHtmlEscaped()));
+        };
+
+        for (size_t i = 0; i + 1 < users.size(); i++) {
+                uidWithoutLast.append(formatUser(users[i]));
+        }
+
+        return temp.arg(uidWithoutLast.join(", ")).arg(formatUser(users.back()));
+}
diff --git a/src/timeline/TimelineModel.h b/src/timeline/TimelineModel.h
index ae505c17..6d351359 100644
--- a/src/timeline/TimelineModel.h
+++ b/src/timeline/TimelineModel.h
@@ -120,6 +120,8 @@ class TimelineModel : public QAbstractListModel
         Q_OBJECT
         Q_PROPERTY(
           int currentIndex READ currentIndex WRITE setCurrentIndex NOTIFY currentIndexChanged)
+        Q_PROPERTY(std::vector<QString> typingUsers READ typingUsers WRITE updateTypingUsers NOTIFY
+                     typingUsersChanged)
 
 public:
         explicit TimelineModel(TimelineViewManager *manager, QString room_id, QObject *parent = 0);
@@ -162,6 +164,7 @@ public:
         Q_INVOKABLE QString displayName(QString id) const;
         Q_INVOKABLE QString avatarUrl(QString id) const;
         Q_INVOKABLE QString formatDateSeparator(QDate date) const;
+        Q_INVOKABLE QString formatTypingUsers(const std::vector<QString> &users, QColor bg);
 
         Q_INVOKABLE QString escapeEmoji(QString str) const;
         Q_INVOKABLE void viewRawMessage(QString id) const;
@@ -183,6 +186,14 @@ public slots:
         int currentIndex() const { return idToIndex(currentId); }
         void markEventsAsRead(const std::vector<QString> &event_ids);
         QVariantMap getDump(QString eventId) const;
+        void updateTypingUsers(const std::vector<QString> &users)
+        {
+                if (this->typingUsers_ != users) {
+                        this->typingUsers_ = users;
+                        emit typingUsersChanged(typingUsers_);
+                }
+        }
+        std::vector<QString> typingUsers() const { return typingUsers_; }
 
 private slots:
         // Add old events at the top of the timeline.
@@ -202,6 +213,7 @@ signals:
         void mediaCached(QString mxcUrl, QString cacheUrl);
         void newEncryptedImage(mtx::crypto::EncryptedFile encryptionInfo);
         void replyFetched(QString requestingEvent, mtx::events::collections::TimelineEvents event);
+        void typingUsersChanged(std::vector<QString> users);
 
 private:
         DecryptionResult decryptEvent(
@@ -232,6 +244,7 @@ private:
 
         QHash<QString, QColor> userColors;
         QString currentId;
+        std::vector<QString> typingUsers_;
 
         TimelineViewManager *manager_;
 
diff --git a/src/timeline/TimelineViewManager.cpp b/src/timeline/TimelineViewManager.cpp
index ddbc6af8..c7a4e50e 100644
--- a/src/timeline/TimelineViewManager.cpp
+++ b/src/timeline/TimelineViewManager.cpp
@@ -8,6 +8,7 @@
 #include "ColorImageProvider.h"
 #include "DelegateChooser.h"
 #include "Logging.h"
+#include "MatrixClient.h"
 #include "MxcImageProvider.h"
 #include "UserSettingsPage.h"
 #include "dialogs/ImageOverlay.h"
@@ -92,10 +93,21 @@ TimelineViewManager::TimelineViewManager(QWidget *parent)
 void
 TimelineViewManager::sync(const mtx::responses::Rooms &rooms)
 {
-        for (auto it = rooms.join.cbegin(); it != rooms.join.cend(); ++it) {
+        for (const auto &[room_id, room] : rooms.join) {
                 // addRoom will only add the room, if it doesn't exist
-                addRoom(QString::fromStdString(it->first));
-                models.value(QString::fromStdString(it->first))->addEvents(it->second.timeline);
+                addRoom(QString::fromStdString(room_id));
+                const auto &room_model = models.value(QString::fromStdString(room_id));
+                room_model->addEvents(room.timeline);
+
+                if (ChatPage::instance()->userSettings()->isTypingNotificationsEnabled()) {
+                        std::vector<QString> typing;
+                        typing.reserve(room.ephemeral.typing.size());
+                        for (const auto &user : room.ephemeral.typing) {
+                                if (user != http::client()->user_id().to_string())
+                                        typing.push_back(QString::fromStdString(user));
+                        }
+                        room_model->updateTypingUsers(typing);
+                }
         }
 
         this->isInitialSync_ = false;
-- 
cgit 1.5.1


From dc44ac50a3768f26ad242af263c043e0e94febef Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Tue, 21 Jan 2020 03:36:26 +0100
Subject: Linkify links before sending

---
 src/Utils.cpp                  | 27 ++++++++++++++++++++++++---
 src/Utils.h                    |  2 +-
 src/timeline/TimelineModel.cpp | 17 ++++++++---------
 3 files changed, 33 insertions(+), 13 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/Utils.cpp b/src/Utils.cpp
index 1746883e..5e8e1a16 100644
--- a/src/Utils.cpp
+++ b/src/Utils.cpp
@@ -308,7 +308,7 @@ QString
 utils::linkifyMessage(const QString &body)
 {
         // Convert to valid XML.
-        auto doc = QString("<html>%1</html>").arg(body);
+        auto doc = body;
         doc.replace(conf::strings::url_regex, conf::strings::url_html);
 
         return doc;
@@ -382,7 +382,7 @@ utils::markdownToHtml(const QString &text)
         // The buffer is no longer needed.
         free((char *)tmp_buf);
 
-        auto result = escapeBlacklistedHtml(QString::fromStdString(html)).trimmed();
+        auto result = linkifyMessage(escapeBlacklistedHtml(QString::fromStdString(html))).trimmed();
 
         return result;
 }
@@ -390,6 +390,27 @@ utils::markdownToHtml(const QString &text)
 QString
 utils::getFormattedQuoteBody(const RelatedInfo &related, const QString &html)
 {
+        auto getFormattedBody = [related]() {
+                using MsgType = mtx::events::MessageType;
+
+                switch (related.type) {
+                case MsgType::File: {
+                        return QString(QCoreApplication::translate("utils", "sent a file."));
+                }
+                case MsgType::Image: {
+                        return QString(QCoreApplication::translate("utils", "sent an image."));
+                }
+                case MsgType::Audio: {
+                        return QString(QCoreApplication::translate("utils", "sent an audio file."));
+                }
+                case MsgType::Video: {
+                        return QString(QCoreApplication::translate("utils", "sent a video"));
+                }
+                default: {
+                        return related.quoted_formatted_body;
+                }
+                }
+        };
         return QString("<mx-reply><blockquote><a "
                        "href=\"https://matrix.to/#/%1/%2\">In reply "
                        "to</a> <a href=\"https://matrix.to/#/%3\">%4</a><br"
@@ -398,7 +419,7 @@ utils::getFormattedQuoteBody(const RelatedInfo &related, const QString &html)
                       QString::fromStdString(related.related_event),
                       related.quoted_user,
                       related.quoted_user,
-                      getQuoteBody(related)) +
+                      getFormattedBody()) +
                html;
 }
 
diff --git a/src/Utils.h b/src/Utils.h
index 119d660a..505d8e6a 100644
--- a/src/Utils.h
+++ b/src/Utils.h
@@ -27,7 +27,7 @@ struct RelatedInfo
         using MsgType = mtx::events::MessageType;
         MsgType type;
         QString room;
-        QString quoted_body;
+        QString quoted_body, quoted_formatted_body;
         std::string related_event;
         QString quoted_user;
 };
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 2fd4b6d4..54e054ec 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -775,19 +775,18 @@ TimelineModel::replyAction(QString id)
                 event = decryptEvent(*e).event;
         }
 
-        RelatedInfo related   = {};
-        related.quoted_user   = QString::fromStdString(mtx::accessors::sender(event));
-        related.related_event = mtx::accessors::event_id(event);
-        related.type          = mtx::accessors::msg_type(event);
-        related.quoted_body   = mtx::accessors::formattedBodyWithFallback(event);
-        related.quoted_body.remove(QRegularExpression(
+        RelatedInfo related           = {};
+        related.quoted_user           = QString::fromStdString(mtx::accessors::sender(event));
+        related.related_event         = mtx::accessors::event_id(event);
+        related.type                  = mtx::accessors::msg_type(event);
+        related.quoted_body           = QString::fromStdString(mtx::accessors::body(event));
+        related.quoted_body           = utils::getQuoteBody(related);
+        related.quoted_formatted_body = mtx::accessors::formattedBodyWithFallback(event);
+        related.quoted_formatted_body.remove(QRegularExpression(
           "<mx-reply>.*</mx-reply>", QRegularExpression::DotMatchesEverythingOption));
         nhlog::ui()->debug("after replacement: {}", related.quoted_body.toStdString());
         related.room = room_id_;
 
-        // if (related.quoted_body.isEmpty())
-        //        return;
-
         ChatPage::instance()->messageReply(related);
 }
 
-- 
cgit 1.5.1


From c95f4d82769b9eb5836f0ffbf9f87e054c393cec Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Tue, 21 Jan 2020 20:41:09 +0100
Subject: Fix colors in typing display, when username contains emoji

---
 resources/qml/Avatar.qml       |  3 ++-
 resources/qml/TimelineView.qml |  1 +
 src/Utils.cpp                  |  5 ++++-
 src/timeline/TimelineModel.cpp | 31 ++++++++++++++++++++++++++++---
 4 files changed, 35 insertions(+), 5 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/resources/qml/Avatar.qml b/resources/qml/Avatar.qml
index a53f057b..25fff7f3 100644
--- a/resources/qml/Avatar.qml
+++ b/resources/qml/Avatar.qml
@@ -19,7 +19,8 @@ Rectangle {
 
 	Text {
 		anchors.fill: parent
-		text: String.fromCodePoint(displayName.codePointAt(0))
+		text: chat.model.escapeEmoji(String.fromCodePoint(displayName.codePointAt(0)))
+		textFormat: Text.RichText
 		color: colors.text
 		font.pixelSize: avatar.height/2
 		verticalAlignment: Text.AlignVCenter
diff --git a/resources/qml/TimelineView.qml b/resources/qml/TimelineView.qml
index 60a8e6c1..a93f50c0 100644
--- a/resources/qml/TimelineView.qml
+++ b/resources/qml/TimelineView.qml
@@ -206,6 +206,7 @@ Item {
 
 				id: typingDisplay
 				text: chat.model ? chat.model.formatTypingUsers(chat.model.typingUsers, chatFooter.color) : ""
+				textFormat: Text.RichText
 				color: colors.windowText
 			}
 		}
diff --git a/src/Utils.cpp b/src/Utils.cpp
index ab8631f7..911e57fc 100644
--- a/src/Utils.cpp
+++ b/src/Utils.cpp
@@ -39,7 +39,7 @@ utils::replaceEmoji(const QString &body)
         QSettings settings;
         QString userFontFamily = settings.value("user/emoji_font_family", "emoji").toString();
 
-        bool insideFontBlock = true;
+        bool insideFontBlock = false;
         for (auto &code : utf32_string) {
                 // TODO: Be more precise here.
                 if ((code >= 0x2600 && code <= 0x27bf) || (code >= 0x1f300 && code <= 0x1f3ff) ||
@@ -57,6 +57,9 @@ utils::replaceEmoji(const QString &body)
                 }
                 fmtBody += QString::fromUcs4(&code, 1);
         }
+        if (insideFontBlock) {
+                fmtBody += "</font>";
+        }
 
         return fmtBody;
 }
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 54e054ec..65a6e470 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -1406,9 +1406,34 @@ TimelineModel::formatTypingUsers(const std::vector<QString> &users, QColor bg)
         QStringList uidWithoutLast;
 
         auto formatUser = [this, bg](const QString &user_id) -> QString {
-                return QString("<font color=\"%1\">%2</font>")
-                  .arg(userColor(user_id, bg).name())
-                  .arg(escapeEmoji(displayName(user_id).toHtmlEscaped()));
+                auto uncoloredUsername = escapeEmoji(displayName(user_id).toHtmlEscaped());
+                QString prefix = QString("<font color=\"%1\">").arg(userColor(user_id, bg).name());
+
+                // color only parts that don't have a font already specified
+                QString coloredUsername;
+                int index = 0;
+                do {
+                        auto startIndex = uncoloredUsername.indexOf("<font", index);
+
+                        if (startIndex - index != 0)
+                                coloredUsername +=
+                                  prefix +
+                                  uncoloredUsername.midRef(
+                                    index, startIndex > 0 ? startIndex - index : -1) +
+                                  "</font>";
+
+                        auto endIndex = uncoloredUsername.indexOf("</font>", startIndex);
+                        if (endIndex > 0)
+                                endIndex += sizeof("</font>") - 1;
+
+                        if (endIndex - startIndex != 0)
+                                coloredUsername +=
+                                  uncoloredUsername.midRef(startIndex, endIndex - startIndex);
+
+                        index = endIndex;
+                } while (index > 0 && index < uncoloredUsername.size());
+
+                return coloredUsername;
         };
 
         for (size_t i = 0; i + 1 < users.size(); i++) {
-- 
cgit 1.5.1


From 86960e67ec93f9c739540201814f09c6277bbff8 Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Thu, 23 Jan 2020 20:34:04 +0100
Subject: Implement display of membership events

---
 resources/qml/delegates/MessageDelegate.qml |   6 ++
 src/timeline/TimelineModel.cpp              | 102 +++++++++++++++++++++++++++-
 src/timeline/TimelineModel.h                |   3 +-
 3 files changed, 108 insertions(+), 3 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/resources/qml/delegates/MessageDelegate.qml b/resources/qml/delegates/MessageDelegate.qml
index ae18d505..512c790b 100644
--- a/resources/qml/delegates/MessageDelegate.qml
+++ b/resources/qml/delegates/MessageDelegate.qml
@@ -78,6 +78,12 @@ Item {
 				notice: model.data.roomTopic ? qsTr("topic changed to: %1").arg(model.data.roomTopic) : qsTr("removed topic")
 			}
 		}
+		DelegateChoice {
+			roleValue: MtxEvent.Member
+			NoticeMessage {
+				notice: timelineManager.timeline.formatMemberEvent(model.data.id);
+			}
+		}
 		DelegateChoice {
 			Placeholder {}
 		}
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 65a6e470..774e30da 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -189,7 +189,7 @@ TimelineModel::TimelineModel(TimelineViewManager *manager, QString room_id, QObj
         connect(this, &TimelineModel::newMessageToSend, this, &TimelineModel::addPendingMessage);
 
         connect(this,
-                &TimelineModel::replyFetched,
+                &TimelineModel::eventFetched,
                 this,
                 [this](QString requestingEvent, mtx::events::collections::TimelineEvents event) {
                         events.insert(QString::fromStdString(mtx::accessors::event_id(event)),
@@ -566,7 +566,7 @@ TimelineModel::internalAddEvents(
                                             id.toStdString());
                                           return;
                                   }
-                                  emit replyFetched(id, timeline);
+                                  emit eventFetched(id, timeline);
                           });
                 }
         }
@@ -1442,3 +1442,101 @@ TimelineModel::formatTypingUsers(const std::vector<QString> &users, QColor bg)
 
         return temp.arg(uidWithoutLast.join(", ")).arg(formatUser(users.back()));
 }
+
+QString
+TimelineModel::formatMemberEvent(QString id)
+{
+        if (!events.contains(id))
+                return "";
+
+        auto event = std::get_if<mtx::events::StateEvent<mtx::events::state::Member>>(&events[id]);
+        if (!event)
+                return "";
+
+        mtx::events::StateEvent<mtx::events::state::Member> *prevEvent = nullptr;
+        QString prevEventId = QString::fromStdString(event->unsigned_data.replaces_state);
+        if (!prevEventId.isEmpty()) {
+                if (!events.contains(prevEventId)) {
+                        http::client()->get_event(
+                          this->room_id_.toStdString(),
+                          event->unsigned_data.replaces_state,
+                          [this, id, prevEventId](
+                            const mtx::events::collections::TimelineEvents &timeline,
+                            mtx::http::RequestErr err) {
+                                  if (err) {
+                                          nhlog::net()->error(
+                                            "Failed to retrieve event with id {}, which was "
+                                            "requested to show the membership for event {}",
+                                            prevEventId.toStdString(),
+                                            id.toStdString());
+                                          return;
+                                  }
+                                  emit eventFetched(id, timeline);
+                          });
+                } else {
+                        prevEvent =
+                          std::get_if<mtx::events::StateEvent<mtx::events::state::Member>>(
+                            &events[prevEventId]);
+                }
+        }
+
+        QString user = QString::fromStdString(event->state_key);
+        QString name = escapeEmoji(displayName(user));
+
+        // see table https://matrix.org/docs/spec/client_server/latest#m-room-member
+        using namespace mtx::events::state;
+        switch (event->content.membership) {
+        case Membership::Invite:
+                return tr("%1 was invited.").arg(name);
+        case Membership::Join:
+                if (prevEvent && prevEvent->content.membership == Membership::Join) {
+                        bool displayNameChanged =
+                          prevEvent->content.display_name != event->content.display_name;
+                        bool avatarChanged =
+                          prevEvent->content.avatar_url != event->content.avatar_url;
+
+                        if (displayNameChanged && avatarChanged)
+                                return tr("%1 changed their display name and avatar.").arg(name);
+                        else if (displayNameChanged)
+                                return tr("%1 changed their display name.").arg(name);
+                        else if (avatarChanged)
+                                return tr("%1 changed their avatar.").arg(name);
+                        // the case of nothing changed but join follows join shouldn't happen, so
+                        // just show it as join
+                }
+                return tr("%1 joined.").arg(name);
+        case Membership::Leave:
+                if (!prevEvent) // Should only ever happen temporarily
+                        return "";
+
+                if (prevEvent->content.membership == Membership::Invite) {
+                        if (event->state_key == event->sender)
+                                return tr("%1 rejected their invite.").arg(name);
+                        else
+                                return tr("Revoked the invite to %1.").arg(name);
+                } else if (prevEvent->content.membership == Membership::Join) {
+                        if (event->state_key == event->sender)
+                                return tr("%1 left the room.").arg(name);
+                        else
+                                return tr("Kicked %1.").arg(name);
+                } else if (prevEvent->content.membership == Membership::Ban) {
+                        return tr("Unbanned %1").arg(name);
+                } else if (prevEvent->content.membership == Membership::Knock) {
+                        if (event->state_key == event->sender)
+                                return tr("%1 redacted their knock.").arg(name);
+                        else
+                                return tr("Rejected the knock from %1.").arg(name);
+                } else
+                        return tr("%1 left after having already left!",
+                                  "This is a leave event after the user already left and shouln't "
+                                  "happen apart from state resets")
+                          .arg(name);
+
+        case Membership::Ban:
+                return tr("%1 was banned.").arg(name);
+        case Membership::Knock:
+                return tr("%1 knocked.").arg(name);
+        default:
+                return "";
+        }
+}
diff --git a/src/timeline/TimelineModel.h b/src/timeline/TimelineModel.h
index 6d351359..52ab28cf 100644
--- a/src/timeline/TimelineModel.h
+++ b/src/timeline/TimelineModel.h
@@ -165,6 +165,7 @@ public:
         Q_INVOKABLE QString avatarUrl(QString id) const;
         Q_INVOKABLE QString formatDateSeparator(QDate date) const;
         Q_INVOKABLE QString formatTypingUsers(const std::vector<QString> &users, QColor bg);
+        Q_INVOKABLE QString formatMemberEvent(QString id);
 
         Q_INVOKABLE QString escapeEmoji(QString str) const;
         Q_INVOKABLE void viewRawMessage(QString id) const;
@@ -212,7 +213,7 @@ signals:
         void newMessageToSend(mtx::events::collections::TimelineEvents event);
         void mediaCached(QString mxcUrl, QString cacheUrl);
         void newEncryptedImage(mtx::crypto::EncryptedFile encryptionInfo);
-        void replyFetched(QString requestingEvent, mtx::events::collections::TimelineEvents event);
+        void eventFetched(QString requestingEvent, mtx::events::collections::TimelineEvents event);
         void typingUsersChanged(std::vector<QString> users);
 
 private:
-- 
cgit 1.5.1


From e9267ffc7617cfbeb26c62cde3c28f33a898161c Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Thu, 23 Jan 2020 20:59:17 +0100
Subject: Show event type string in placeholder

---
 resources/qml/delegates/Placeholder.qml |  2 +-
 src/timeline/TimelineModel.cpp          | 11 +++++++++++
 src/timeline/TimelineModel.h            |  1 +
 3 files changed, 13 insertions(+), 1 deletion(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/resources/qml/delegates/Placeholder.qml b/resources/qml/delegates/Placeholder.qml
index 36d7b2bc..26de2067 100644
--- a/resources/qml/delegates/Placeholder.qml
+++ b/resources/qml/delegates/Placeholder.qml
@@ -1,7 +1,7 @@
 import ".."
 
 MatrixText {
-	text: qsTr("unimplemented event: ") + model.data.type
+	text: qsTr("unimplemented event: ") + model.data.typeString
 	width: parent ? parent.width : undefined
 	color: inactiveColors.text
 }
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 774e30da..f66099a0 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -119,6 +119,13 @@ toRoomEventType(const mtx::events::collections::TimelineEvents &event)
         return std::visit(RoomEventType{}, event);
 }
 
+QString
+toRoomEventTypeString(const mtx::events::collections::TimelineEvents &event)
+{
+        return std::visit([](const auto &e) { return QString::fromStdString(to_string(e.type)); },
+                          event);
+}
+
 TimelineModel::TimelineModel(TimelineViewManager *manager, QString room_id, QObject *parent)
   : QAbstractListModel(parent)
   , room_id_(room_id)
@@ -206,6 +213,7 @@ TimelineModel::roleNames() const
         return {
           {Section, "section"},
           {Type, "type"},
+          {TypeString, "typeString"},
           {Body, "body"},
           {FormattedBody, "formattedBody"},
           {UserId, "userId"},
@@ -265,6 +273,8 @@ TimelineModel::data(const QString &id, int role) const
                 return QVariant(origin_server_ts(event));
         case Type:
                 return QVariant(toRoomEventType(event));
+        case TypeString:
+                return QVariant(toRoomEventTypeString(event));
         case Body:
                 return QVariant(utils::replaceEmoji(QString::fromStdString(body(event))));
         case FormattedBody: {
@@ -327,6 +337,7 @@ TimelineModel::data(const QString &id, int role) const
 
                 // m.insert(names[Section], data(id, static_cast<int>(Section)));
                 m.insert(names[Type], data(id, static_cast<int>(Type)));
+                m.insert(names[TypeString], data(id, static_cast<int>(TypeString)));
                 m.insert(names[Body], data(id, static_cast<int>(Body)));
                 m.insert(names[FormattedBody], data(id, static_cast<int>(FormattedBody)));
                 m.insert(names[UserId], data(id, static_cast<int>(UserId)));
diff --git a/src/timeline/TimelineModel.h b/src/timeline/TimelineModel.h
index 52ab28cf..44cf79f4 100644
--- a/src/timeline/TimelineModel.h
+++ b/src/timeline/TimelineModel.h
@@ -130,6 +130,7 @@ public:
         {
                 Section,
                 Type,
+                TypeString,
                 Body,
                 FormattedBody,
                 UserId,
-- 
cgit 1.5.1


From f755550418cac8c088a4d05c5be161c447c964c3 Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Sat, 25 Jan 2020 01:06:01 +0100
Subject: Add missing thread include

---
 src/timeline/TimelineModel.cpp | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index f66099a0..fb8c0095 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -1,6 +1,7 @@
 #include "TimelineModel.h"
 
 #include <algorithm>
+#include <thread>
 #include <type_traits>
 
 #include <QFileDialog>
-- 
cgit 1.5.1


From 9c368fa7f448715c2ce04c61097e0cb18091774b Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Mon, 27 Jan 2020 17:05:40 +0100
Subject: Fix reply rendering without markdown in riot

---
 src/timeline/TimelineModel.cpp       | 23 ++++++++++++++++++++---
 src/timeline/TimelineViewManager.cpp | 25 ++++++++++++++++---------
 2 files changed, 36 insertions(+), 12 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index fb8c0095..03b7d6a7 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -281,9 +281,26 @@ TimelineModel::data(const QString &id, int role) const
         case FormattedBody: {
                 const static QRegularExpression replyFallback(
                   "<mx-reply>.*</mx-reply>", QRegularExpression::DotMatchesEverythingOption);
-                return QVariant(
-                  utils::replaceEmoji(utils::linkifyMessage(utils::escapeBlacklistedHtml(
-                    formattedBodyWithFallback(event).remove(replyFallback)))));
+
+                bool isReply = !in_reply_to_event(event).empty();
+
+                auto formattedBody_ = QString::fromStdString(formatted_body(event));
+                if (formattedBody_.isEmpty()) {
+                        auto body_ = QString::fromStdString(body(event));
+
+                        if (isReply) {
+                                while (body_.startsWith("> "))
+                                        body_ = body_.right(body_.size() - body_.indexOf('\n') - 1);
+                                if (body_.startsWith('\n'))
+                                        body_ = body_.right(body_.size() - 1);
+                        }
+                        formattedBody_ = body_.toHtmlEscaped();
+                } else {
+                        if (isReply)
+                                formattedBody_ = formattedBody_.remove(replyFallback);
+                }
+                return QVariant(utils::replaceEmoji(
+                  utils::linkifyMessage(utils::escapeBlacklistedHtml(formattedBody_))));
         }
         case Url:
                 return QVariant(QString::fromStdString(url(event)));
diff --git a/src/timeline/TimelineViewManager.cpp b/src/timeline/TimelineViewManager.cpp
index 578d075f..9008d9d2 100644
--- a/src/timeline/TimelineViewManager.cpp
+++ b/src/timeline/TimelineViewManager.cpp
@@ -186,8 +186,11 @@ TimelineViewManager::queueTextMessage(const QString &msg, const std::optional<Re
 {
         mtx::events::msg::Text text = {};
         text.body                   = msg.trimmed().toStdString();
-        text.format                 = "org.matrix.custom.html";
-        text.formatted_body         = utils::markdownToHtml(msg).toStdString();
+
+        if (settings->isMarkdownEnabled()) {
+                text.format         = "org.matrix.custom.html";
+                text.formatted_body = utils::markdownToHtml(msg).toStdString();
+        }
 
         if (related) {
                 QString body;
@@ -202,14 +205,18 @@ TimelineViewManager::queueTextMessage(const QString &msg, const std::optional<Re
                 }
 
                 text.body = QString("%1\n%2").arg(body).arg(msg).toStdString();
-                text.formatted_body =
-                  utils::getFormattedQuoteBody(*related, utils::markdownToHtml(msg)).toStdString();
-                text.relates_to.in_reply_to.event_id = related->related_event;
-        }
 
-        if (!settings->isMarkdownEnabled()) {
-                text.format         = "";
-                text.formatted_body = "";
+                // NOTE(Nico): rich replies always need a formatted_body!
+                text.format = "org.matrix.custom.html";
+                if (settings->isMarkdownEnabled())
+                        text.formatted_body =
+                          utils::getFormattedQuoteBody(*related, utils::markdownToHtml(msg))
+                            .toStdString();
+                else
+                        text.formatted_body =
+                          utils::getFormattedQuoteBody(*related, msg.toHtmlEscaped()).toStdString();
+
+                text.relates_to.in_reply_to.event_id = related->related_event;
         }
 
         if (timeline_)
-- 
cgit 1.5.1


From 760d4ddef9b5af92272a4422f8bc5ed4b3f005ed Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Mon, 27 Jan 2020 18:36:34 +0100
Subject: Fix newlines in plain text messages again

---
 src/timeline/TimelineModel.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 03b7d6a7..f34cb405 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -294,7 +294,7 @@ TimelineModel::data(const QString &id, int role) const
                                 if (body_.startsWith('\n'))
                                         body_ = body_.right(body_.size() - 1);
                         }
-                        formattedBody_ = body_.toHtmlEscaped();
+                        formattedBody_ = body_.toHtmlEscaped().replace('\n', "<br>");
                 } else {
                         if (isReply)
                                 formattedBody_ = formattedBody_.remove(replyFallback);
-- 
cgit 1.5.1


From 96e3a7735d9b8da172aadba0c69c3dbe105354a5 Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Sun, 2 Feb 2020 15:15:00 +0100
Subject: Fix <displaynames>

---
 src/timeline/TimelineModel.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index f34cb405..f084b4dd 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -655,7 +655,7 @@ TimelineModel::userColor(QString id, QColor background)
 QString
 TimelineModel::displayName(QString id) const
 {
-        return cache::displayName(room_id_, id);
+        return cache::displayName(room_id_, id).toHtmlEscaped();
 }
 
 QString
-- 
cgit 1.5.1


From 17b5cc32dc56552ac3ae7285f7ffdb194b907ffd Mon Sep 17 00:00:00 2001
From: Adasauce <adasauce@with.parts>
Date: Fri, 14 Feb 2020 16:24:53 -0400
Subject: use the standard system download path for downloads

QFileDialog's dir arg (which was set to the incoming file name from the
Matrix download) can take a full path to suggest. By prepending
QStandardPaths::DownloadLocation, it opens to the system's download
folder and proposes the filename as the download name.

Using QStandardPaths should make this work on other platforms, and from
what I read, its possible for this to return an empty string on
platforms where it doesn't support it, so this should essentially
revert to the previous functionality if Qt can't determine the system's
download location.
---
 src/timeline/TimelineModel.cpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index f084b4dd..625377fb 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -1298,10 +1298,12 @@ TimelineModel::saveMedia(QString eventId) const
                 dialogTitle = tr("Save file");
         }
 
-        QString filterString = QMimeDatabase().mimeTypeForName(mimeType).filterString();
+        const QString filterString = QMimeDatabase().mimeTypeForName(mimeType).filterString();
+        const QString downloadsFolder = QStandardPaths::writableLocation(QStandardPaths::DownloadLocation);
+        const QString openLocation = downloadsFolder + "/" + originalFilename;
 
-        auto filename = QFileDialog::getSaveFileName(
-          manager_->getWidget(), dialogTitle, originalFilename, filterString);
+        const QString filename = QFileDialog::getSaveFileName(
+          manager_->getWidget(), dialogTitle, openLocation, filterString);
 
         if (filename.isEmpty())
                 return;
-- 
cgit 1.5.1


From cb360508226a320846660709f26457a54782b164 Mon Sep 17 00:00:00 2001
From: Adasauce <adasauce@with.parts>
Date: Fri, 14 Feb 2020 21:35:26 -0400
Subject: use QStandardPaths locations for all file dialogs.

---
 src/TextInputWidget.cpp        | 3 ++-
 src/UserSettingsPage.cpp       | 8 ++++++--
 src/dialogs/RoomSettings.cpp   | 7 +++++--
 src/timeline/TimelineModel.cpp | 3 ++-
 4 files changed, 15 insertions(+), 6 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/TextInputWidget.cpp b/src/TextInputWidget.cpp
index ce0c7cb8..11f7ddda 100644
--- a/src/TextInputWidget.cpp
+++ b/src/TextInputWidget.cpp
@@ -626,8 +626,9 @@ TextInputWidget::command(QString command, QString args)
 void
 TextInputWidget::openFileSelection()
 {
+        const QString homeFolder = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
         const auto fileName =
-          QFileDialog::getOpenFileName(this, tr("Select a file"), "", tr("All Files (*)"));
+          QFileDialog::getOpenFileName(this, tr("Select a file"), homeFolder, tr("All Files (*)"));
 
         if (fileName.isEmpty())
                 return;
diff --git a/src/UserSettingsPage.cpp b/src/UserSettingsPage.cpp
index a0f37c26..166a0a67 100644
--- a/src/UserSettingsPage.cpp
+++ b/src/UserSettingsPage.cpp
@@ -27,6 +27,7 @@
 #include <QPushButton>
 #include <QScrollArea>
 #include <QSettings>
+#include <QStandardPaths>
 #include <QString>
 #include <QTextStream>
 
@@ -513,7 +514,9 @@ UserSettingsPage::paintEvent(QPaintEvent *)
 void
 UserSettingsPage::importSessionKeys()
 {
-        auto fileName = QFileDialog::getOpenFileName(this, tr("Open Sessions File"), "", "");
+        const QString homeFolder = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
+        const QString fileName =
+          QFileDialog::getOpenFileName(this, tr("Open Sessions File"), homeFolder, "");
 
         QFile file(fileName);
         if (!file.open(QIODevice::ReadOnly)) {
@@ -572,7 +575,8 @@ UserSettingsPage::exportSessionKeys()
         }
 
         // Open file dialog to save the file.
-        auto fileName =
+        const QString homeFolder = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
+        const QString fileName =
           QFileDialog::getSaveFileName(this, tr("File to save the exported session keys"), "", "");
 
         QFile file(fileName);
diff --git a/src/dialogs/RoomSettings.cpp b/src/dialogs/RoomSettings.cpp
index 69d5a9c2..cc10ac91 100644
--- a/src/dialogs/RoomSettings.cpp
+++ b/src/dialogs/RoomSettings.cpp
@@ -11,6 +11,7 @@
 #include <QPushButton>
 #include <QShortcut>
 #include <QShowEvent>
+#include <QStandardPaths>
 #include <QStyleOption>
 #include <QVBoxLayout>
 
@@ -740,8 +741,10 @@ RoomSettings::resetErrorLabel()
 void
 RoomSettings::updateAvatar()
 {
-        const auto fileName =
-          QFileDialog::getOpenFileName(this, tr("Select an avatar"), "", tr("All Files (*)"));
+        const QString picturesFolder =
+          QStandardPaths::writableLocation(QStandardPaths::PicturesLocation);
+        const QString fileName = QFileDialog::getOpenFileName(
+          this, tr("Select an avatar"), picturesFolder, tr("All Files (*)"));
 
         if (fileName.isEmpty())
                 return;
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 625377fb..104d564b 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -1299,7 +1299,8 @@ TimelineModel::saveMedia(QString eventId) const
         }
 
         const QString filterString = QMimeDatabase().mimeTypeForName(mimeType).filterString();
-        const QString downloadsFolder = QStandardPaths::writableLocation(QStandardPaths::DownloadLocation);
+        const QString downloadsFolder =
+          QStandardPaths::writableLocation(QStandardPaths::DownloadLocation);
         const QString openLocation = downloadsFolder + "/" + originalFilename;
 
         const QString filename = QFileDialog::getSaveFileName(
-- 
cgit 1.5.1


From ec9da9f42a29ef12e266ee1e05aebd17f98a3371 Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Sun, 16 Feb 2020 00:20:41 +0100
Subject: Try to fix flickering, if sync return event before send completes

---
 src/EventAccessors.cpp         | 20 ++++++++++++++++++++
 src/EventAccessors.h           |  2 ++
 src/timeline/TimelineModel.cpp | 14 ++++++++++++++
 3 files changed, 36 insertions(+)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/EventAccessors.cpp b/src/EventAccessors.cpp
index 6264af58..20cdb63c 100644
--- a/src/EventAccessors.cpp
+++ b/src/EventAccessors.cpp
@@ -207,6 +207,20 @@ struct EventInReplyTo
         }
 };
 
+struct EventTransactionId
+{
+        template<class T>
+        std::string operator()(const mtx::events::RoomEvent<T> &e)
+        {
+                return e.unsigned_data.transaction_id;
+        }
+        template<class T>
+        std::string operator()(const mtx::events::Event<T> &e)
+        {
+                return e.unsigned_data.transaction_id;
+        }
+};
+
 struct EventMediaHeight
 {
         template<class Content>
@@ -344,6 +358,12 @@ mtx::accessors::in_reply_to_event(const mtx::events::collections::TimelineEvents
         return std::visit(EventInReplyTo{}, event);
 }
 
+std::string
+mtx::accessors::transaction_id(const mtx::events::collections::TimelineEvents &event)
+{
+        return std::visit(EventTransactionId{}, event);
+}
+
 int64_t
 mtx::accessors::filesize(const mtx::events::collections::TimelineEvents &event)
 {
diff --git a/src/EventAccessors.h b/src/EventAccessors.h
index 5c03861d..cf79f68f 100644
--- a/src/EventAccessors.h
+++ b/src/EventAccessors.h
@@ -50,6 +50,8 @@ std::string
 mimetype(const mtx::events::collections::TimelineEvents &event);
 std::string
 in_reply_to_event(const mtx::events::collections::TimelineEvents &event);
+std::string
+transaction_id(const mtx::events::collections::TimelineEvents &event);
 
 int64_t
 filesize(const mtx::events::collections::TimelineEvents &event);
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 104d564b..432cd329 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -538,6 +538,20 @@ TimelineModel::internalAddEvents(
                         continue;
                 }
 
+                QString txid = QString::fromStdString(mtx::accessors::transaction_id(e));
+                if (this->pending.removeOne(txid)) {
+                        this->events.insert(id, e);
+                        this->events.remove(txid);
+                        int idx = idToIndex(txid);
+                        if (idx < 0) {
+                                nhlog::ui()->warn("Received index out of range");
+                                continue;
+                        }
+                        eventOrder[idx] = id;
+                        emit dataChanged(index(idx, 0), index(idx, 0));
+                        continue;
+                }
+
                 if (auto redaction =
                       std::get_if<mtx::events::RedactionEvent<mtx::events::msg::Redaction>>(&e)) {
                         QString redacts = QString::fromStdString(redaction->redacts);
-- 
cgit 1.5.1


From 65bd0993729deaa167c11daedcae65feb8bdf95a Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Sun, 16 Feb 2020 18:58:38 +0100
Subject: Don't delete messages received out of order (fixup the flickering
 fix)

---
 src/timeline/TimelineModel.cpp | 12 +-----------
 1 file changed, 1 insertion(+), 11 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 432cd329..004da9d0 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -148,19 +148,9 @@ TimelineModel::TimelineModel(TimelineViewManager *manager, QString room_id, QObj
         connect(this, &TimelineModel::messageSent, this, [this](QString txn_id, QString event_id) {
                 pending.removeOne(txn_id);
 
-                // we could have received the message via sync
-                if (events.contains(event_id)) {
-                        int idx = idToIndex(event_id);
-                        if (idx >= 0) {
-                                beginRemoveRows(QModelIndex(), idx, idx);
-                                eventOrder.erase(eventOrder.begin() + idx);
-                                endRemoveRows();
-                        }
-                }
-
                 int idx = idToIndex(txn_id);
                 if (idx < 0) {
-                        nhlog::ui()->warn("Sent index out of range");
+                        // transaction already received via sync
                         return;
                 }
                 eventOrder[idx] = event_id;
-- 
cgit 1.5.1


From b24165371c11a4fbae54dd22507b292be73ea8ae Mon Sep 17 00:00:00 2001
From: Adasauce <adasauce@with.parts>
Date: Mon, 17 Feb 2020 11:49:22 -0400
Subject: Paginationg != Paginating in debug message

---
 src/timeline/TimelineModel.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 004da9d0..ed1b3075 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -437,7 +437,7 @@ TimelineModel::fetchMore(const QModelIndex &)
         opts.room_id = room_id_.toStdString();
         opts.from    = prev_batch_token_.toStdString();
 
-        nhlog::ui()->debug("Paginationg room {}", opts.room_id);
+        nhlog::ui()->debug("Paginating room {}", opts.room_id);
 
         http::client()->messages(
           opts, [this, opts](const mtx::responses::Messages &res, mtx::http::RequestErr err) {
-- 
cgit 1.5.1


From 2895162971bedea1f4033ea90c9867615f405023 Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Thu, 20 Feb 2020 20:28:23 +0100
Subject: Clear user colors on theme change

---
 src/timeline/TimelineModel.cpp | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index ed1b3075..8de6bec6 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -196,6 +196,9 @@ TimelineModel::TimelineModel(TimelineViewManager *manager, QString room_id, QObj
                         if (idx >= 0)
                                 emit dataChanged(index(idx, 0), index(idx, 0));
                 });
+
+        connect(
+          ChatPage::instance(), &ChatPage::themeChanged, this, [this]() { userColors.clear(); });
 }
 
 QHash<int, QByteArray>
-- 
cgit 1.5.1


From 6bdc75d07319b3b2a846ee4a905288ec0d9371f6 Mon Sep 17 00:00:00 2001
From: Nicolas Werner <nicolas.werner@hotmail.de>
Date: Thu, 20 Feb 2020 20:51:07 +0100
Subject: Reset user colors on theme change (in qml timeline)

---
 resources/qml/TimelineRow.qml               |  2 +-
 resources/qml/TimelineView.qml              |  4 +--
 resources/qml/delegates/MessageDelegate.qml |  2 +-
 resources/qml/delegates/Reply.qml           |  2 +-
 src/Cache.cpp                               | 51 -----------------------------
 src/Cache.h                                 |  9 -----
 src/Cache_p.h                               |  6 ----
 src/MainWindow.cpp                          |  3 --
 src/timeline/TimelineModel.cpp              | 15 ++-------
 src/timeline/TimelineModel.h                |  2 --
 src/timeline/TimelineViewManager.cpp        | 11 +++++++
 src/timeline/TimelineViewManager.h          |  2 ++
 12 files changed, 20 insertions(+), 89 deletions(-)

(limited to 'src/timeline/TimelineModel.cpp')

diff --git a/resources/qml/TimelineRow.qml b/resources/qml/TimelineRow.qml
index a371f78b..fa427bfd 100644
--- a/resources/qml/TimelineRow.qml
+++ b/resources/qml/TimelineRow.qml
@@ -23,7 +23,7 @@ RowLayout {
 		Reply {
 			visible: model.replyTo
 			modelData: chat.model.getDump(model.replyTo)
-			userColor: chat.model.userColor(modelData.userId, colors.window)
+			userColor: timelineManager.userColor(modelData.userId, colors.window)
 		}
 
 		// actual message content
diff --git a/resources/qml/TimelineView.qml b/resources/qml/TimelineView.qml
index 9730422d..46cf484b 100644
--- a/resources/qml/TimelineView.qml
+++ b/resources/qml/TimelineView.qml
@@ -218,7 +218,7 @@ Item {
 						Text { 
 							id: userName
 							text: chat.model.escapeEmoji(modelData.userName)
-							color: chat.model.userColor(modelData.userId, colors.window)
+							color: timelineManager.userColor(modelData.userId, colors.window)
 							textFormat: Text.RichText
 
 							MouseArea {
@@ -283,7 +283,7 @@ Item {
 						anchors.bottom: parent.bottom
 
 						modelData: chat.model ? chat.model.getDump(timelineManager.replyingEvent) : {}
-						userColor: chat.model ? chat.model.userColor(modelData.userId, colors.window) : colors.window
+						userColor: timelineManager.userColor(modelData.userId, colors.window)
 					}
 
 					ImageButton {
diff --git a/resources/qml/delegates/MessageDelegate.qml b/resources/qml/delegates/MessageDelegate.qml
index f043efec..ab633087 100644
--- a/resources/qml/delegates/MessageDelegate.qml
+++ b/resources/qml/delegates/MessageDelegate.qml
@@ -34,7 +34,7 @@ Item {
 			roleValue: MtxEvent.EmoteMessage
 			NoticeMessage {
 				formatted: chat.model.escapeEmoji(modelData.userName) + " " + model.data.formattedBody
-				color: chat.model.userColor(modelData.userId, colors.window)
+				color: timelineManager.userColor(modelData.userId, colors.window)
 			}
 		}
 		DelegateChoice {
diff --git a/resources/qml/delegates/Reply.qml b/resources/qml/delegates/Reply.qml
index a1ddc8f0..8bb9ed38 100644
--- a/resources/qml/delegates/Reply.qml
+++ b/resources/qml/delegates/Reply.qml
@@ -19,7 +19,7 @@ Rectangle {
 		anchors.bottom: replyContainer.bottom
 		width: 4
 
-		color: chat.model ? chat.model.userColor(reply.modelData.userId, colors.window) : colors.window
+		color: timelineManager.userColor(reply.modelData.userId, colors.window)
 	}
 
 	Column {
diff --git a/src/Cache.cpp b/src/Cache.cpp
index e73f7754..caa3f1ec 100644
--- a/src/Cache.cpp
+++ b/src/Cache.cpp
@@ -2186,7 +2186,6 @@ Cache::roomMembers(const std::string &room_id)
 
 QHash<QString, QString> Cache::DisplayNames;
 QHash<QString, QString> Cache::AvatarUrls;
-QHash<QString, QString> Cache::UserColors;
 
 QString
 Cache::displayName(const QString &room_id, const QString &user_id)
@@ -2218,16 +2217,6 @@ Cache::avatarUrl(const QString &room_id, const QString &user_id)
         return QString();
 }
 
-QString
-Cache::userColor(const QString &user_id)
-{
-        if (UserColors.contains(user_id)) {
-                return UserColors[user_id];
-        }
-
-        return QString();
-}
-
 void
 Cache::insertDisplayName(const QString &room_id,
                          const QString &user_id,
@@ -2258,24 +2247,6 @@ Cache::removeAvatarUrl(const QString &room_id, const QString &user_id)
         AvatarUrls.remove(fmt);
 }
 
-void
-Cache::insertUserColor(const QString &user_id, const QString &color_name)
-{
-        UserColors.insert(user_id, color_name);
-}
-
-void
-Cache::removeUserColor(const QString &user_id)
-{
-        UserColors.remove(user_id);
-}
-
-void
-Cache::clearUserColors()
-{
-        UserColors.clear();
-}
-
 void
 to_json(json &j, const RoomInfo &info)
 {
@@ -2425,12 +2396,6 @@ avatarUrl(const QString &room_id, const QString &user_id)
         return instance_->avatarUrl(room_id, user_id);
 }
 
-QString
-userColor(const QString &user_id)
-{
-        return instance_->userColor(user_id);
-}
-
 void
 removeDisplayName(const QString &room_id, const QString &user_id)
 {
@@ -2441,11 +2406,6 @@ removeAvatarUrl(const QString &room_id, const QString &user_id)
 {
         instance_->removeAvatarUrl(room_id, user_id);
 }
-void
-removeUserColor(const QString &user_id)
-{
-        instance_->removeUserColor(user_id);
-}
 
 void
 insertDisplayName(const QString &room_id, const QString &user_id, const QString &display_name)
@@ -2457,17 +2417,6 @@ insertAvatarUrl(const QString &room_id, const QString &user_id, const QString &a
 {
         instance_->insertAvatarUrl(room_id, user_id, avatar_url);
 }
-void
-insertUserColor(const QString &user_id, const QString &color_name)
-{
-        instance_->insertUserColor(user_id, color_name);
-}
-
-void
-clearUserColors()
-{
-        instance_->clearUserColors();
-}
 
 //! Load saved data for the display names & avatars.
 void
diff --git a/src/Cache.h b/src/Cache.h
index 69b3ef2d..bb042ea9 100644
--- a/src/Cache.h
+++ b/src/Cache.h
@@ -43,25 +43,16 @@ QString
 displayName(const QString &room_id, const QString &user_id);
 QString
 avatarUrl(const QString &room_id, const QString &user_id);
-QString
-userColor(const QString &user_id);
 
 void
 removeDisplayName(const QString &room_id, const QString &user_id);
 void
 removeAvatarUrl(const QString &room_id, const QString &user_id);
-void
-removeUserColor(const QString &user_id);
 
 void
 insertDisplayName(const QString &room_id, const QString &user_id, const QString &display_name);
 void
 insertAvatarUrl(const QString &room_id, const QString &user_id, const QString &avatar_url);
-void
-insertUserColor(const QString &user_id, const QString &color_name);
-
-void
-clearUserColors();
 
 //! Load saved data for the display names & avatars.
 void
diff --git a/src/Cache_p.h b/src/Cache_p.h
index eacb28a7..137408b9 100644
--- a/src/Cache_p.h
+++ b/src/Cache_p.h
@@ -51,11 +51,9 @@ public:
         static std::string displayName(const std::string &room_id, const std::string &user_id);
         static QString displayName(const QString &room_id, const QString &user_id);
         static QString avatarUrl(const QString &room_id, const QString &user_id);
-        static QString userColor(const QString &user_id);
 
         static void removeDisplayName(const QString &room_id, const QString &user_id);
         static void removeAvatarUrl(const QString &room_id, const QString &user_id);
-        static void removeUserColor(const QString &user_id);
 
         static void insertDisplayName(const QString &room_id,
                                       const QString &user_id,
@@ -63,9 +61,6 @@ public:
         static void insertAvatarUrl(const QString &room_id,
                                     const QString &user_id,
                                     const QString &avatar_url);
-        static void insertUserColor(const QString &user_id, const QString &color_name);
-
-        static void clearUserColors();
 
         //! Load saved data for the display names & avatars.
         void populateMembers();
@@ -484,7 +479,6 @@ private:
 
         static QHash<QString, QString> DisplayNames;
         static QHash<QString, QString> AvatarUrls;
-        static QHash<QString, QString> UserColors;
 
         OlmSessionStorage session_storage;
 };
diff --git a/src/MainWindow.cpp b/src/MainWindow.cpp
index 1b378ca9..17a04a41 100644
--- a/src/MainWindow.cpp
+++ b/src/MainWindow.cpp
@@ -115,9 +115,6 @@ MainWindow::MainWindow(QWidget *parent)
 
         connect(
           userSettingsPage_, SIGNAL(trayOptionChanged(bool)), trayIcon_, SLOT(setVisible(bool)));
-        connect(userSettingsPage_, &UserSettingsPage::themeChanged, this, []() {
-                cache::clearUserColors();
-        });
         connect(
           userSettingsPage_, &UserSettingsPage::themeChanged, chat_page_, &ChatPage::themeChanged);
         connect(trayIcon_,
diff --git a/src/timeline/TimelineModel.cpp b/src/timeline/TimelineModel.cpp
index 8de6bec6..cad39bc5 100644
--- a/src/timeline/TimelineModel.cpp
+++ b/src/timeline/TimelineModel.cpp
@@ -196,9 +196,6 @@ TimelineModel::TimelineModel(TimelineViewManager *manager, QString room_id, QObj
                         if (idx >= 0)
                                 emit dataChanged(index(idx, 0), index(idx, 0));
                 });
-
-        connect(
-          ChatPage::instance(), &ChatPage::themeChanged, this, [this]() { userColors.clear(); });
 }
 
 QHash<int, QByteArray>
@@ -650,15 +647,6 @@ TimelineModel::addBackwardsEvents(const mtx::responses::Messages &msgs)
         prev_batch_token_ = QString::fromStdString(msgs.end);
 }
 
-QColor
-TimelineModel::userColor(QString id, QColor background)
-{
-        if (!userColors.contains(id))
-                userColors.insert(
-                  id, QColor(utils::generateContrastingHexColor(id, background.name())));
-        return userColors.value(id);
-}
-
 QString
 TimelineModel::displayName(QString id) const
 {
@@ -1446,7 +1434,8 @@ TimelineModel::formatTypingUsers(const std::vector<QString> &users, QColor bg)
 
         auto formatUser = [this, bg](const QString &user_id) -> QString {
                 auto uncoloredUsername = escapeEmoji(displayName(user_id).toHtmlEscaped());
-                QString prefix = QString("<font color=\"%1\">").arg(userColor(user_id, bg).name());
+                QString prefix =
+                  QString("<font color=\"%1\">").arg(manager_->userColor(user_id, bg).name());
 
                 // color only parts that don't have a font already specified
                 QString coloredUsername;
diff --git a/src/timeline/TimelineModel.h b/src/timeline/TimelineModel.h
index 642e9bbc..f06de5d9 100644
--- a/src/timeline/TimelineModel.h
+++ b/src/timeline/TimelineModel.h
@@ -165,7 +165,6 @@ public:
         bool canFetchMore(const QModelIndex &) const override;
         void fetchMore(const QModelIndex &) override;
 
-        Q_INVOKABLE QColor userColor(QString id, QColor background);
         Q_INVOKABLE QString displayName(QString id) const;
         Q_INVOKABLE QString avatarUrl(QString id) const;
         Q_INVOKABLE QString formatDateSeparator(QDate date) const;
@@ -248,7 +247,6 @@ private:
         bool paginationInProgress = false;
         bool isProcessingPending  = false;
 
-        QHash<QString, QColor> userColors;
         QString currentId;
         std::vector<QString> typingUsers_;
 
diff --git a/src/timeline/TimelineViewManager.cpp b/src/timeline/TimelineViewManager.cpp
index 7cd1432d..14f903a1 100644
--- a/src/timeline/TimelineViewManager.cpp
+++ b/src/timeline/TimelineViewManager.cpp
@@ -18,6 +18,8 @@ Q_DECLARE_METATYPE(mtx::events::collections::TimelineEvents)
 void
 TimelineViewManager::updateColorPalette()
 {
+        userColors.clear();
+
         if (settings->theme() == "light") {
                 QPalette lightActive(/*windowText*/ QColor("#333"),
                                      /*button*/ QColor("#333"),
@@ -53,6 +55,15 @@ TimelineViewManager::updateColorPalette()
         }
 }
 
+QColor
+TimelineViewManager::userColor(QString id, QColor background)
+{
+        if (!userColors.contains(id))
+                userColors.insert(
+                  id, QColor(utils::generateContrastingHexColor(id, background.name())));
+        return userColors.value(id);
+}
+
 TimelineViewManager::TimelineViewManager(QSharedPointer<UserSettings> userSettings, QWidget *parent)
   : imgProvider(new MxcImageProvider())
   , colorImgProvider(new ColorImageProvider())
diff --git a/src/timeline/TimelineViewManager.h b/src/timeline/TimelineViewManager.h
index 625999c9..338101c7 100644
--- a/src/timeline/TimelineViewManager.h
+++ b/src/timeline/TimelineViewManager.h
@@ -40,6 +40,7 @@ public:
         Q_INVOKABLE TimelineModel *activeTimeline() const { return timeline_; }
         Q_INVOKABLE bool isInitialSync() const { return isInitialSync_; }
         Q_INVOKABLE void openImageOverlay(QString mxcUrl, QString eventId) const;
+        Q_INVOKABLE QColor userColor(QString id, QColor background);
 
 signals:
         void clearRoomMessageCount(QString roomid);
@@ -118,4 +119,5 @@ private:
         QString replyingEvent_;
 
         QSharedPointer<UserSettings> settings;
+        QHash<QString, QColor> userColors;
 };
-- 
cgit 1.5.1