Separate out a base MessageContentModel.

Separate out a base `MessageContentModel` that can be extended to get the component types from different places. This is used currently for `EventMessageContentModel` but will be used later as part of the rich chat bar.

All display text is now in the text component so it never needs special casing. This also cleans up some of the model parameters so more things come from attributes including location and file data (which was already a qvariantmap anyway).

Also cleaned up the itinerary and file enhancement views,

src/messagecontent/models/eventmessagecontentmodel.cpp

@@ -0,0 +1,525 @@
+// SPDX-FileCopyrightText: 2024 James Graham <james.h.graham@protonmail.com>
+// SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
+
+#include "eventmessagecontentmodel.h"
+
+#include <Quotient/events/eventcontent.h>
+#include <Quotient/events/roommessageevent.h>
+#include <Quotient/events/stickerevent.h>
+#include <Quotient/qt_connection_util.h>
+#if Quotient_VERSION_MINOR > 9 || (Quotient_VERSION_MINOR == 9 && Quotient_VERSION_PATCH > 1)
+#include <Quotient/thread.h>
+#endif
+
+#include <KLocalizedString>
+#include <Kirigami/Platform/PlatformTheme>
+
+#include "chatbarcache.h"
+#include "contentprovider.h"
+#include "eventhandler.h"
+#include "models/reactionmodel.h"
+#include "neochatroom.h"
+#include "texthandler.h"
+
+using namespace Quotient;
+
+bool EventMessageContentModel::m_threadsEnabled = false;
+
+EventMessageContentModel::EventMessageContentModel(NeoChatRoom *room, const QString &eventId, bool isReply, bool isPending, MessageContentModel *parent)
+    : MessageContentModel(room, parent, eventId)
+    , m_currentState(isPending ? Pending : Unknown)
+    , m_isReply(isReply)
+{
+    initializeModel();
+}
+
+void EventMessageContentModel::initializeModel()
+{
+    Q_ASSERT(m_room != nullptr);
+    Q_ASSERT(!m_eventId.isEmpty());
+
+    connect(m_room, &NeoChatRoom::pendingEventAdded, this, [this]() {
+        if (m_room != nullptr && m_currentState == Unknown) {
+            initializeEvent();
+            resetModel();
+        }
+    });
+    connect(m_room, &NeoChatRoom::pendingEventAboutToMerge, this, [this](Quotient::RoomEvent *serverEvent) {
+        if (m_room != nullptr) {
+            if (m_eventId == serverEvent->id() || m_eventId == serverEvent->transactionId()) {
+                m_eventId = serverEvent->id();
+            }
+        }
+    });
+    connect(m_room, &NeoChatRoom::pendingEventMerged, this, [this]() {
+        if (m_room != nullptr && m_currentState == Pending) {
+            initializeEvent();
+            resetModel();
+        }
+    });
+    connect(m_room, &NeoChatRoom::addedMessages, this, [this](int fromIndex, int toIndex) {
+        if (!m_room) {
+            return;
+        }
+        for (int i = fromIndex; i <= toIndex; i++) {
+            if (m_room->findInTimeline(i)->event()->id() == m_eventId) {
+                initializeEvent();
+                resetModel();
+            }
+        }
+    });
+    connect(m_room, &NeoChatRoom::replacedEvent, this, [this](const Quotient::RoomEvent *newEvent) {
+        if (m_room != nullptr) {
+            if (m_eventId == newEvent->id()) {
+                initializeEvent();
+                resetContent();
+            }
+        }
+    });
+    connect(m_room->editCache(), &ChatBarCache::relationIdChanged, this, [this](const QString &oldEventId, const QString &newEventId) {
+        if (oldEventId == m_eventId || newEventId == m_eventId) {
+            resetContent(newEventId == m_eventId);
+        }
+    });
+    connect(m_room->threadCache(), &ChatBarCache::threadIdChanged, this, [this](const QString &oldThreadId, const QString &newThreadId) {
+        if (oldThreadId == m_eventId || newThreadId == m_eventId) {
+            resetContent(false, newThreadId == m_eventId);
+        }
+    });
+    connect(m_room, &NeoChatRoom::urlPreviewEnabledChanged, this, [this]() {
+        resetContent();
+    });
+    connect(m_room, &Room::memberNameUpdated, this, [this](RoomMember member) {
+        if (m_room != nullptr) {
+            if (authorId().isEmpty() || authorId() == member.id()) {
+                Q_EMIT dataChanged(index(0, 0), index(rowCount() - 1, 0), {AuthorRole});
+                Q_EMIT authorChanged();
+            }
+        }
+    });
+    connect(m_room, &Room::memberAvatarUpdated, this, [this](RoomMember member) {
+        if (m_room != nullptr) {
+            if (authorId().isEmpty() || authorId() == member.id()) {
+                Q_EMIT dataChanged(index(0, 0), index(rowCount() - 1, 0), {AuthorRole});
+                Q_EMIT authorChanged();
+            }
+        }
+    });
+    connect(this, &EventMessageContentModel::threadsEnabledChanged, this, [this]() {
+        resetModel();
+    });
+    connect(m_room, &Room::updatedEvent, this, [this](const QString &eventId) {
+        if (eventId == m_eventId) {
+            updateReactionModel();
+        }
+    });
+
+    initializeEvent();
+    resetModel();
+}
+
+QDateTime EventMessageContentModel::time() const
+{
+    const auto event = m_room->getEvent(m_eventId);
+    if (event.first == nullptr) {
+        return MessageContentModel::time();
+    };
+    return EventHandler::time(m_room, event.first, m_currentState == Pending);
+}
+
+QString EventMessageContentModel::timeString() const
+{
+    const auto event = m_room->getEvent(m_eventId);
+    if (event.first == nullptr) {
+        return MessageContentModel::timeString();
+    };
+    return EventHandler::timeString(m_room, event.first, u"hh:mm"_s, m_currentState == Pending);
+}
+
+QString EventMessageContentModel::authorId() const
+{
+    const auto eventResult = m_room->getEvent(m_eventId);
+    if (eventResult.first == nullptr) {
+        return {};
+    }
+    auto authorId = eventResult.first->senderId();
+    if (authorId.isEmpty()) {
+        return MessageContentModel::authorId();
+    }
+    return authorId;
+}
+
+QString EventMessageContentModel::threadRootId() const
+{
+    const auto event = m_room->getEvent(m_eventId);
+    if (event.first == nullptr) {
+        return {};
+    }
+    auto roomMessageEvent = eventCast<const RoomMessageEvent>(event.first);
+#if Quotient_VERSION_MINOR > 9 || (Quotient_VERSION_MINOR == 9 && Quotient_VERSION_PATCH > 1)
+    if (roomMessageEvent && (roomMessageEvent->isThreaded() || m_room->threads().contains(roomMessageEvent->id()))) {
+#else
+    if (roomMessageEvent && roomMessageEvent->isThreaded()) {
+#endif
+        return roomMessageEvent->threadRootEventId();
+    }
+    return {};
+}
+
+void EventMessageContentModel::initializeEvent()
+{
+    if (m_currentState == UnAvailable) {
+        return;
+    }
+
+    const auto eventResult = m_room->getEvent(m_eventId);
+    if (eventResult.first == nullptr) {
+        if (m_currentState != Pending) {
+            getEvent();
+        }
+        return;
+    }
+    if (eventResult.second) {
+        m_currentState = Pending;
+    } else {
+        m_currentState = Available;
+    }
+    Q_EMIT eventUpdated();
+}
+
+void EventMessageContentModel::getEvent()
+{
+    Quotient::connectUntil(m_room.get(), &NeoChatRoom::extraEventLoaded, this, [this](const QString &eventId) {
+        if (m_room != nullptr) {
+            if (eventId == m_eventId) {
+                initializeEvent();
+                resetModel();
+                return true;
+            }
+        }
+        return false;
+    });
+    Quotient::connectUntil(m_room.get(), &NeoChatRoom::extraEventNotFound, this, [this](const QString &eventId) {
+        if (m_room != nullptr) {
+            if (eventId == m_eventId) {
+                m_currentState = UnAvailable;
+                resetModel();
+                return true;
+            }
+        }
+        return false;
+    });
+
+    m_room->downloadEventFromServer(m_eventId);
+}
+
+MessageComponent EventMessageContentModel::unavailableMessageComponent() const
+{
+    const auto theme = static_cast<Kirigami::Platform::PlatformTheme *>(qmlAttachedPropertiesObject<Kirigami::Platform::PlatformTheme>(this, true));
+
+    QString disabledTextColor;
+    if (theme != nullptr) {
+        disabledTextColor = theme->disabledTextColor().name();
+    } else {
+        disabledTextColor = u"#000000"_s;
+    }
+
+    return MessageComponent{
+        .type = MessageComponentType::Text,
+        .display = u"<span style=\"color:%1\">"_s.arg(disabledTextColor)
+            + i18nc("@info", "This message was either not found, you do not have permission to view it, or it was sent by an ignored user") + u"</span>"_s,
+        .attributes = {},
+    };
+}
+
+void EventMessageContentModel::resetModel()
+{
+    beginResetModel();
+    m_components.clear();
+
+    if (m_room->connection()->isIgnored(authorId()) || m_currentState == UnAvailable) {
+        m_components += unavailableMessageComponent();
+        endResetModel();
+        return;
+    }
+
+    const auto event = m_room->getEvent(m_eventId);
+    if (event.first == nullptr) {
+        m_components += MessageComponent{MessageComponentType::Loading, m_isReply ? i18n("Loading reply") : i18n("Loading"), {}};
+        endResetModel();
+        return;
+    }
+
+    m_components += MessageComponent{MessageComponentType::Author,
+                                     QString(),
+                                     {
+                                         {u"time"_s, EventHandler::time(m_room, event.first, m_currentState == Pending)},
+                                         {u"timeString"_s, EventHandler::timeString(m_room, event.first, u"hh:mm"_s, m_currentState == Pending)},
+                                     }};
+
+    m_components += messageContentComponents();
+    endResetModel();
+
+    updateReplyModel();
+    updateReactionModel();
+    updateItineraryModel();
+
+    Q_EMIT componentsUpdated();
+}
+
+void EventMessageContentModel::resetContent(bool isEditing, bool isThreading)
+{
+    const auto startRow = m_components[0].type == MessageComponentType::Author ? 1 : 0;
+    beginRemoveRows({}, startRow, rowCount() - 1);
+    m_components.remove(startRow, rowCount() - startRow);
+    endRemoveRows();
+
+    const auto newComponents = messageContentComponents(isEditing, isThreading);
+    if (newComponents.size() == 0) {
+        return;
+    }
+    beginInsertRows({}, startRow, startRow + newComponents.size() - 1);
+    m_components += newComponents;
+    endInsertRows();
+
+    updateReplyModel();
+    updateReactionModel();
+    updateItineraryModel();
+
+    Q_EMIT componentsUpdated();
+}
+
+QList<MessageComponent> EventMessageContentModel::messageContentComponents(bool isEditing, bool isThreading)
+{
+    const auto event = m_room->getEvent(m_eventId);
+    if (event.first == nullptr) {
+        return {};
+    }
+
+    QList<MessageComponent> newComponents;
+
+    if (isEditing) {
+        newComponents += MessageComponent{MessageComponentType::ChatBar, QString(), {}};
+    } else {
+        newComponents.append(componentsForType(MessageComponentType::typeForEvent(*event.first, m_isReply)));
+    }
+
+    const auto roomMessageEvent = eventCast<const Quotient::RoomMessageEvent>(event.first);
+#if Quotient_VERSION_MINOR > 9 || (Quotient_VERSION_MINOR == 9 && Quotient_VERSION_PATCH > 1)
+    if (m_threadsEnabled && roomMessageEvent && (roomMessageEvent->isThreaded() || m_room->threads().contains(roomMessageEvent->id()))
+        && roomMessageEvent->id() == roomMessageEvent->threadRootEventId()) {
+#else
+    if (m_threadsEnabled && roomMessageEvent && roomMessageEvent->isThreaded() && roomMessageEvent->id() == roomMessageEvent->threadRootEventId()) {
+#endif
+        newComponents += MessageComponent{MessageComponentType::Separator, {}, {}};
+        newComponents += MessageComponent{MessageComponentType::ThreadBody, u"Thread Body"_s, {}};
+    }
+
+    // If the event is already threaded the ThreadModel will handle displaying a chat bar.
+#if Quotient_VERSION_MINOR > 9 || (Quotient_VERSION_MINOR == 9 && Quotient_VERSION_PATCH > 1)
+    if (isThreading && roomMessageEvent && !(roomMessageEvent->isThreaded() || m_room->threads().contains(roomMessageEvent->id()))) {
+#else
+    if (isThreading && roomMessageEvent && roomMessageEvent->isThreaded()) {
+#endif
+        newComponents += MessageComponent{MessageComponentType::ChatBar, QString(), {}};
+    }
+
+    return newComponents;
+}
+
+void EventMessageContentModel::updateReplyModel()
+{
+    const auto event = m_room->getEvent(m_eventId);
+    if (event.first == nullptr || m_isReply) {
+        return;
+    }
+
+    const auto roomMessageEvent = eventCast<const Quotient::RoomMessageEvent>(event.first);
+    if (roomMessageEvent == nullptr) {
+        return;
+    }
+    if (!roomMessageEvent->isReply(m_threadsEnabled) || (roomMessageEvent->isThreaded() && m_threadsEnabled)) {
+        if (m_replyModel) {
+            m_replyModel->disconnect(this);
+            m_replyModel->deleteLater();
+        }
+        return;
+    }
+
+    m_replyModel = new EventMessageContentModel(m_room, roomMessageEvent->replyEventId(!m_threadsEnabled), true, false, this);
+
+    bool hasModel = hasComponentType(MessageComponentType::Reply);
+    if (m_replyModel && !hasModel) {
+        int insertRow = 0;
+        if (m_components.first().type == MessageComponentType::Author) {
+            insertRow = 1;
+        }
+        beginInsertRows({}, insertRow, insertRow);
+        m_components.insert(insertRow, MessageComponent{MessageComponentType::Reply, QString(), {}});
+    } else if (!m_replyModel && hasModel) {
+        int removeRow = 0;
+        if (m_components.first().type == MessageComponentType::Author) {
+            removeRow = 1;
+        }
+        beginRemoveRows({}, removeRow, removeRow);
+        m_components.removeAt(removeRow);
+        endRemoveRows();
+    }
+}
+
+QList<MessageComponent> EventMessageContentModel::componentsForType(MessageComponentType::Type type)
+{
+    const auto event = m_room->getEvent(m_eventId);
+    if (event.first == nullptr) {
+        return {};
+    }
+
+    switch (type) {
+    case MessageComponentType::Verification: {
+        return {MessageComponent{MessageComponentType::Verification, QString(), {}}};
+    }
+    case MessageComponentType::Text: {
+        if (const auto roomMessageEvent = eventCast<const Quotient::RoomMessageEvent>(event.first)) {
+            return TextHandler().textComponents(EventHandler::rawMessageBody(*roomMessageEvent),
+                                                EventHandler::messageBodyInputFormat(*roomMessageEvent),
+                                                m_room,
+                                                roomMessageEvent,
+                                                roomMessageEvent->isReplaced());
+        } else {
+            return TextHandler().textComponents(EventHandler::plainBody(m_room, event.first), Qt::TextFormat::PlainText, m_room, event.first, false);
+        }
+
+        const auto roomMessageEvent = eventCast<const Quotient::RoomMessageEvent>(event.first);
+        return TextHandler().textComponents(EventHandler::rawMessageBody(*roomMessageEvent),
+                                            EventHandler::messageBodyInputFormat(*roomMessageEvent),
+                                            m_room,
+                                            roomMessageEvent,
+                                            roomMessageEvent->isReplaced());
+    }
+    case MessageComponentType::File: {
+        QList<MessageComponent> components;
+        components += MessageComponent{MessageComponentType::File, {}, EventHandler::mediaInfo(m_room, event.first)};
+        const auto roomMessageEvent = eventCast<const Quotient::RoomMessageEvent>(event.first);
+        auto body = EventHandler::rawMessageBody(*roomMessageEvent);
+        if (!body.isEmpty()) {
+            components += TextHandler().textComponents(body,
+                                                    EventHandler::messageBodyInputFormat(*roomMessageEvent),
+                                                    m_room,
+                                                    roomMessageEvent,
+                                                    roomMessageEvent->isReplaced());
+        }
+        return components;
+    }
+    case MessageComponentType::Image:
+    case MessageComponentType::Audio:
+    case MessageComponentType::Video: {
+        QList<MessageComponent> components = {
+            MessageComponent{type, EventHandler::richBody(m_room, event.first), EventHandler::mediaInfo(m_room, event.first)}};
+
+        if (!event.first->is<StickerEvent>()) {
+            const auto roomMessageEvent = eventCast<const Quotient::RoomMessageEvent>(event.first);
+            const auto fileContent = roomMessageEvent->get<EventContent::FileContentBase>();
+            if (fileContent != nullptr) {
+                const auto fileInfo = fileContent->commonInfo();
+                const auto body = EventHandler::rawMessageBody(*roomMessageEvent);
+                // Do not attach the description to the image, if it's the same as the original filename.
+                if (fileInfo.originalName != body) {
+                    components += TextHandler().textComponents(body,
+                                                               EventHandler::messageBodyInputFormat(*roomMessageEvent),
+                                                               m_room,
+                                                               roomMessageEvent,
+                                                               roomMessageEvent->isReplaced());
+                }
+            }
+        }
+        return components;
+    }
+    case MessageComponentType::Location:
+        return {MessageComponent{type,
+                                 QString(),
+                                 {
+                                     {u"latitude"_s, EventHandler::latitude(event.first)},
+                                     {u"longitude"_s, EventHandler::longitude(event.first)},
+                                     {u"asset"_s, EventHandler::locationAssetType(event.first)},
+                                 }}};
+    default:
+        return {MessageComponent{type, QString(), {}}};
+    }
+}
+
+void EventMessageContentModel::updateItineraryModel()
+{
+    if (!hasComponentType(MessageComponentType::File) || !m_room) {
+        return;
+    }
+
+    const auto roomMessageEvent = eventCast<const Quotient::RoomMessageEvent>(m_room->getEvent(m_eventId).first);
+    if (!roomMessageEvent || !roomMessageEvent->has<EventContent::FileContent>()) {
+        return;
+    }
+
+    auto filePath = m_room->cachedFileTransferInfo(roomMessageEvent).localPath;
+    if (filePath.isEmpty() && m_itineraryModel != nullptr) {
+        delete m_itineraryModel;
+        m_itineraryModel = nullptr;
+    } else if (!filePath.isEmpty()) {
+        if (m_itineraryModel == nullptr) {
+            m_itineraryModel = new ItineraryModel(this);
+            connect(m_itineraryModel, &ItineraryModel::loaded, this, [this]() {
+                if (m_itineraryModel->rowCount() == 0) {
+                    m_emptyItinerary = true;
+                    m_itineraryModel->deleteLater();
+                    m_itineraryModel = nullptr;
+                }
+                Q_EMIT itineraryUpdated();
+            });
+            connect(m_itineraryModel, &ItineraryModel::loadErrorOccurred, this, [this]() {
+                m_emptyItinerary = true;
+                m_itineraryModel->deleteLater();
+                m_itineraryModel = nullptr;
+                Q_EMIT itineraryUpdated();
+            });
+        }
+        m_itineraryModel->setPath(filePath.toString());
+    }
+}
+
+void EventMessageContentModel::updateReactionModel()
+{
+    if (m_reactionModel && m_reactionModel->rowCount() > 0) {
+        return;
+    }
+
+    if (m_reactionModel == nullptr) {
+        m_reactionModel = new ReactionModel(this, m_eventId, m_room);
+        connect(m_reactionModel, &ReactionModel::reactionsUpdated, this, &EventMessageContentModel::updateReactionModel);
+    }
+
+    if (m_reactionModel->rowCount() <= 0) {
+        m_reactionModel->disconnect(this);
+        m_reactionModel->deleteLater();
+        m_reactionModel = nullptr;
+    }
+
+    if (m_reactionModel && m_components.last().type != MessageComponentType::Reaction) {
+        beginInsertRows({}, rowCount(), rowCount());
+        m_components += MessageComponent{MessageComponentType::Reaction, QString(), {}};
+        endInsertRows();
+    } else if (rowCount() > 0 && m_components.last().type == MessageComponentType::Reaction) {
+        beginRemoveRows({}, rowCount() - 1, rowCount() - 1);
+        m_components.removeLast();
+        endRemoveRows();
+    }
+}
+
+ThreadModel *EventMessageContentModel::modelForThread(const QString &threadRootId)
+{
+    return ContentProvider::self().modelForThread(m_room, threadRootId);
+}
+
+void EventMessageContentModel::setThreadsEnabled(bool enableThreads)
+{
+    m_threadsEnabled = enableThreads;
+}
+
+#include "moc_eventmessagecontentmodel.cpp"

src/messagecontent/models/eventmessagecontentmodel.h

@@ -0,0 +1,80 @@
+// SPDX-FileCopyrightText: 2024 James Graham <james.h.graham@protonmail.com>
+// SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
+
+#pragma once
+
+#include <QAbstractListModel>
+#include <QQmlEngine>
+
+#include "models/messagecontentmodel.h"
+#include "models/threadmodel.h"
+
+/**
+ * @class EventMessageContentModel
+ *
+ * Inherited from MessageContentModel this visulaises the content of a Quotient::RoomMessageEvent.
+ */
+class EventMessageContentModel : public MessageContentModel
+{
+    Q_OBJECT
+    QML_ELEMENT
+    QML_UNCREATABLE("")
+
+public:
+    enum MessageState {
+        Unknown, /**< The message state is unknown. */
+        Pending, /**< The message is a new pending message which the server has not yet acknowledged. */
+        Available, /**< The message is available and acknowledged by the server. */
+        UnAvailable, /**< The message can't be retrieved either because it doesn't exist or is blocked. */
+    };
+    Q_ENUM(MessageState)
+
+    explicit EventMessageContentModel(NeoChatRoom *room,
+                                         const QString &eventId,
+                                         bool isReply = false,
+                                         bool isPending = false,
+                                         MessageContentModel *parent = nullptr);
+
+    /**
+     * @brief Returns the thread model for the given thread root event ID.
+     *
+     * A model is created if one doesn't exist. Will return nullptr if threadRootId
+     * is empty.
+     */
+    Q_INVOKABLE ThreadModel *modelForThread(const QString &threadRootId);
+
+    static void setThreadsEnabled(bool enableThreads);
+
+Q_SIGNALS:
+    void eventUpdated();
+    void threadsEnabledChanged();
+
+private:
+    void initializeModel();
+
+    QDateTime time() const override;
+    QString timeString() const override;
+    QString authorId() const override;
+    QString threadRootId() const override;
+
+    MessageState m_currentState = Unknown;
+    bool m_isReply;
+
+    void initializeEvent();
+    void getEvent();
+
+    MessageComponent unavailableMessageComponent() const;
+    void resetModel();
+    void resetContent(bool isEditing = false, bool isThreading = false);
+    QList<MessageComponent> messageContentComponents(bool isEditing = false, bool isThreading = false);
+
+    void updateReplyModel();
+
+    QList<MessageComponent> componentsForType(MessageComponentType::Type type);
+
+    void updateItineraryModel();
+
+    void updateReactionModel();
+
+    static bool m_threadsEnabled;
+};

src/messagecontent/models/messagecontentmodel.cpp

@@ -2,48 +2,20 @@
 // SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
 
 #include "messagecontentmodel.h"
-#include "contentprovider.h"
-#include "enums/messagecomponenttype.h"
-#include "eventhandler.h"
-#include "messagecomponent.h"
-
-#include <QImageReader>
-
-#include <Quotient/events/eventcontent.h>
-#include <Quotient/events/redactionevent.h>
-#include <Quotient/events/roommessageevent.h>
-#include <Quotient/events/stickerevent.h>
-#include <Quotient/qt_connection_util.h>
-#if Quotient_VERSION_MINOR > 9 || (Quotient_VERSION_MINOR == 9 && Quotient_VERSION_PATCH > 1)
-#include <Quotient/thread.h>
-#endif
 
 #include <KLocalizedString>
-#include <Kirigami/Platform/PlatformTheme>
-
-#ifndef Q_OS_ANDROID
-#include <KSyntaxHighlighting/Definition>
-#include <KSyntaxHighlighting/Repository>
-#endif
 
 #include "chatbarcache.h"
 #include "contentprovider.h"
-#include "filetype.h"
-#include "models/reactionmodel.h"
+#include "enums/messagecomponenttype.h"
 #include "neochatconnection.h"
-#include "neochatroom.h"
-#include "texthandler.h"
 
 using namespace Quotient;
 
-bool MessageContentModel::m_threadsEnabled = false;
-
-MessageContentModel::MessageContentModel(NeoChatRoom *room, const QString &eventId, bool isReply, bool isPending, MessageContentModel *parent)
+MessageContentModel::MessageContentModel(NeoChatRoom *room, MessageContentModel *parent, const QString &eventId)
     : QAbstractListModel(parent)
     , m_room(room)
     , m_eventId(eventId)
-    , m_currentState(isPending ? Pending : Unknown)
-    , m_isReply(isReply)
 {
     initializeModel();
 }
@@ -51,43 +23,18 @@ MessageContentModel::MessageContentModel(NeoChatRoom *room, const QString &event
 void MessageContentModel::initializeModel()
 {
     Q_ASSERT(m_room != nullptr);
-    Q_ASSERT(!m_eventId.isEmpty());
 
-    connect(m_room, &NeoChatRoom::pendingEventAdded, this, [this]() {
-        if (m_room != nullptr && m_currentState == Unknown) {
-            initializeEvent();
-            resetModel();
+    connect(this, &MessageContentModel::componentsUpdated, this, [this]() {
+        if (m_room->urlPreviewEnabled()) {
+            forEachComponentOfType({MessageComponentType::Text, MessageComponentType::Quote}, m_linkPreviewAddFunction);
+        } else {
+            forEachComponentOfType({MessageComponentType::LinkPreview, MessageComponentType::LinkPreviewLoad}, m_linkPreviewRemoveFunction);
         }
+        m_components.squeeze();
     });
-    connect(m_room, &NeoChatRoom::pendingEventAboutToMerge, this, [this](Quotient::RoomEvent *serverEvent) {
-        if (m_room != nullptr) {
-            if (m_eventId == serverEvent->id() || m_eventId == serverEvent->transactionId()) {
-                m_eventId = serverEvent->id();
-            }
-        }
-    });
-    connect(m_room, &NeoChatRoom::pendingEventMerged, this, [this]() {
-        if (m_room != nullptr && m_currentState == Pending) {
-            initializeEvent();
-            resetModel();
-        }
-    });
-    connect(m_room, &NeoChatRoom::addedMessages, this, [this](int fromIndex, int toIndex) {
-        if (m_room != nullptr) {
-            for (int i = fromIndex; i <= toIndex; i++) {
-                if (m_room->findInTimeline(i)->event()->id() == m_eventId) {
-                    initializeEvent();
-                    resetModel();
-                }
-            }
-        }
-    });
-    connect(m_room, &NeoChatRoom::replacedEvent, this, [this](const Quotient::RoomEvent *newEvent) {
-        if (m_room != nullptr) {
-            if (m_eventId == newEvent->id()) {
-                initializeEvent();
-                resetContent();
-            }
+    connect(this, &MessageContentModel::itineraryUpdated, this, [this]() {
+        if (hasComponentType(MessageComponentType::File)) {
+            forEachComponentOfType(MessageComponentType::File, m_fileFunction);
         }
     });
     connect(m_room, &NeoChatRoom::newFileTransfer, this, [this](const QString &eventId) {
@@ -120,117 +67,38 @@ void MessageContentModel::initializeModel()
             }
         }
     });
-    connect(m_room->editCache(), &ChatBarCache::relationIdChanged, this, [this](const QString &oldEventId, const QString &newEventId) {
-        if (oldEventId == m_eventId || newEventId == m_eventId) {
-            resetContent(newEventId == m_eventId);
-        }
-    });
-    connect(m_room->threadCache(), &ChatBarCache::threadIdChanged, this, [this](const QString &oldThreadId, const QString &newThreadId) {
-        if (oldThreadId == m_eventId || newThreadId == m_eventId) {
-            resetContent(false, newThreadId == m_eventId);
-        }
-    });
-    connect(m_room, &NeoChatRoom::urlPreviewEnabledChanged, this, [this]() {
-        resetContent();
-    });
-    connect(m_room, &Room::memberNameUpdated, this, [this](RoomMember member) {
-        if (m_room != nullptr) {
-            if (senderId().isEmpty() || senderId() == member.id()) {
-                Q_EMIT dataChanged(index(0, 0), index(rowCount() - 1, 0), {AuthorRole});
-            }
-        }
-    });
-    connect(m_room, &Room::memberAvatarUpdated, this, [this](RoomMember member) {
-        if (m_room != nullptr) {
-            if (senderId().isEmpty() || senderId() == member.id()) {
-                Q_EMIT dataChanged(index(0, 0), index(rowCount() - 1, 0), {AuthorRole});
-            }
-        }
-    });
-
-    connect(this, &MessageContentModel::threadsEnabledChanged, this, [this]() {
-        resetModel();
-    });
-    connect(m_room, &Room::updatedEvent, this, [this](const QString &eventId) {
-        if (eventId == m_eventId) {
-            updateReactionModel();
-        }
-    });
-
-    initializeEvent();
-    resetModel();
+    connect(m_room, &NeoChatRoom::urlPreviewEnabledChanged, this, &MessageContentModel::componentsUpdated);
 }
 
-void MessageContentModel::initializeEvent()
+QString MessageContentModel::eventId() const
 {
-    if (m_currentState == UnAvailable) {
-        return;
-    }
-
-    const auto eventResult = m_room->getEvent(m_eventId);
-    if (eventResult.first == nullptr) {
-        if (m_currentState != Pending) {
-            getEvent();
-        }
-        return;
-    }
-    if (eventResult.second) {
-        m_currentState = Pending;
-    } else {
-        m_currentState = Available;
-    }
-    Q_EMIT eventUpdated();
+    return m_eventId;
 }
 
-void MessageContentModel::getEvent()
+QDateTime MessageContentModel::time() const
 {
-    Quotient::connectUntil(m_room.get(), &NeoChatRoom::extraEventLoaded, this, [this](const QString &eventId) {
-        if (m_room != nullptr) {
-            if (eventId == m_eventId) {
-                initializeEvent();
-                resetModel();
-                return true;
-            }
-        }
-        return false;
-    });
-    Quotient::connectUntil(m_room.get(), &NeoChatRoom::extraEventNotFound, this, [this](const QString &eventId) {
-        if (m_room != nullptr) {
-            if (eventId == m_eventId) {
-                m_currentState = UnAvailable;
-                resetModel();
-                return true;
-            }
-        }
-        return false;
-    });
-
-    m_room->downloadEventFromServer(m_eventId);
+    return QDateTime::currentDateTime();
 }
 
-QString MessageContentModel::senderId() const
+QString MessageContentModel::timeString() const
 {
-    const auto eventResult = m_room->getEvent(m_eventId);
-    if (eventResult.first == nullptr) {
-        return {};
-    }
-    auto senderId = eventResult.first->senderId();
-    if (senderId.isEmpty()) {
-        senderId = m_room->localMember().id();
-    }
-    return senderId;
+    return time().toLocalTime().toString(u"hh:mm"_s);
+    ;
 }
 
-NeochatRoomMember *MessageContentModel::senderObject() const
+QString MessageContentModel::authorId() const
 {
-    const auto eventResult = m_room->getEvent(m_eventId);
-    if (eventResult.first == nullptr) {
-        return nullptr;
-    }
-    if (eventResult.first->senderId().isEmpty()) {
-        return m_room->qmlSafeMember(m_room->localMember().id());
-    }
-    return m_room->qmlSafeMember(eventResult.first->senderId());
+    return m_room->localMember().id();
+}
+
+NeochatRoomMember *MessageContentModel::author() const
+{
+    return m_room->qmlSafeMember(authorId());
+}
+
+QString MessageContentModel::threadRootId() const
+{
+    return {};
 }
 
 static LinkPreviewer *emptyLinkPreview = new LinkPreviewer;
@@ -248,47 +116,8 @@ QVariant MessageContentModel::data(const QModelIndex &index, int role) const
 
     const auto component = m_components[index.row()];
 
-    const auto event = m_room->getEvent(m_eventId);
-    if (event.first == nullptr) {
-        if (role == DisplayRole) {
-            if (m_isReply) {
-                return i18n("Loading reply");
-            } else {
-                return i18n("Loading");
-            }
-        }
-        if (role == ComponentTypeRole) {
-            return component.type;
-        }
-        return {};
-    }
-
     if (role == DisplayRole) {
-        if (m_currentState == UnAvailable || m_room->connection()->isIgnored(senderId())) {
-            Kirigami::Platform::PlatformTheme *theme =
-                static_cast<Kirigami::Platform::PlatformTheme *>(qmlAttachedPropertiesObject<Kirigami::Platform::PlatformTheme>(this, true));
-
-            QString disabledTextColor;
-            if (theme != nullptr) {
-                disabledTextColor = theme->disabledTextColor().name();
-            } else {
-                disabledTextColor = u"#000000"_s;
-            }
-            return QString(u"<span style=\"color:%1\">"_s.arg(disabledTextColor)
-                           + i18nc("@info", "This message was either not found, you do not have permission to view it, or it was sent by an ignored user")
-                           + u"</span>"_s);
-        }
-        if (component.type == MessageComponentType::Loading) {
-            if (m_isReply) {
-                return i18n("Loading reply");
-            } else {
-                return i18n("Loading");
-            }
-        }
-        if (!component.content.isEmpty()) {
-            return component.content;
-        }
-        return EventHandler::richBody(m_room, event.first);
+        return component.display;
     }
     if (role == ComponentTypeRole) {
         return component.type;
@@ -297,63 +126,34 @@ QVariant MessageContentModel::data(const QModelIndex &index, int role) const
         return component.attributes;
     }
     if (role == EventIdRole) {
-        return event.first->displayId();
+        return eventId();
     }
     if (role == TimeRole) {
-        return EventHandler::time(m_room, event.first, m_currentState == Pending);
+        return time();
     }
     if (role == TimeStringRole) {
-        return EventHandler::timeString(m_room, event.first, u"hh:mm"_s, m_currentState == Pending);
+        return timeString();
     }
     if (role == AuthorRole) {
-        return QVariant::fromValue<NeochatRoomMember *>(senderObject());
-    }
-    if (role == MediaInfoRole) {
-        return EventHandler::mediaInfo(m_room, event.first);
+        return QVariant::fromValue<NeochatRoomMember *>(author());
     }
     if (role == FileTransferInfoRole) {
-        return QVariant::fromValue(m_room->cachedFileTransferInfo(event.first));
+        return QVariant::fromValue(m_room->cachedFileTransferInfo(m_eventId));
     }
     if (role == ItineraryModelRole) {
         return QVariant::fromValue<ItineraryModel *>(m_itineraryModel);
     }
-    if (role == LatitudeRole) {
-        return EventHandler::latitude(event.first);
-    }
-    if (role == LongitudeRole) {
-        return EventHandler::longitude(event.first);
-    }
-    if (role == AssetRole) {
-        return EventHandler::locationAssetType(event.first);
-    }
     if (role == PollHandlerRole) {
         return QVariant::fromValue<PollHandler *>(ContentProvider::self().handlerForPoll(m_room, m_eventId));
     }
-    if (role == ReplyEventIdRole) {
-        if (const auto roomMessageEvent = eventCast<const RoomMessageEvent>(event.first)) {
-            return roomMessageEvent->replyEventId();
-        }
-    }
-    if (role == ReplyAuthorRole) {
-        return QVariant::fromValue(EventHandler::replyAuthor(m_room, event.first));
-    }
     if (role == ReplyContentModelRole) {
         return QVariant::fromValue<MessageContentModel *>(m_replyModel);
     }
     if (role == ReactionModelRole) {
         return QVariant::fromValue<ReactionModel *>(m_reactionModel);
-        ;
     }
     if (role == ThreadRootRole) {
-        auto roomMessageEvent = eventCast<const RoomMessageEvent>(event.first);
-#if Quotient_VERSION_MINOR > 9 || (Quotient_VERSION_MINOR == 9 && Quotient_VERSION_PATCH > 1)
-        if (roomMessageEvent && (roomMessageEvent->isThreaded() || m_room->threads().contains(roomMessageEvent->id()))) {
-#else
-        if (roomMessageEvent && roomMessageEvent->isThreaded()) {
-#endif
-            return roomMessageEvent->threadRootEventId();
-        }
-        return {};
+        return threadRootId();
     }
     if (role == LinkPreviewerRole) {
         if (component.type == MessageComponentType::LinkPreview) {
@@ -394,15 +194,9 @@ QHash<int, QByteArray> MessageContentModel::roleNamesStatic()
     roles[MessageContentModel::TimeRole] = "time";
     roles[MessageContentModel::TimeStringRole] = "timeString";
     roles[MessageContentModel::AuthorRole] = "author";
-    roles[MessageContentModel::MediaInfoRole] = "mediaInfo";
     roles[MessageContentModel::FileTransferInfoRole] = "fileTransferInfo";
     roles[MessageContentModel::ItineraryModelRole] = "itineraryModel";
-    roles[MessageContentModel::LatitudeRole] = "latitude";
-    roles[MessageContentModel::LongitudeRole] = "longitude";
-    roles[MessageContentModel::AssetRole] = "asset";
     roles[MessageContentModel::PollHandlerRole] = "pollHandler";
-    roles[MessageContentModel::ReplyEventIdRole] = "replyEventId";
-    roles[MessageContentModel::ReplyAuthorRole] = "replyAuthor";
     roles[MessageContentModel::ReplyContentModelRole] = "replyContentModel";
     roles[MessageContentModel::ReactionModelRole] = "reactionModel";
     roles[MessageContentModel::ThreadRootRole] = "threadRoot";
@@ -443,256 +237,6 @@ void MessageContentModel::forEachComponentOfType(QList<MessageComponentType::Typ
     }
 }
 
-void MessageContentModel::resetModel()
-{
-    beginResetModel();
-    m_components.clear();
-
-    if (m_room->connection()->isIgnored(senderId()) || m_currentState == UnAvailable) {
-        m_components += MessageComponent{MessageComponentType::Text, QString(), {}};
-        endResetModel();
-        return;
-    }
-
-    const auto event = m_room->getEvent(m_eventId);
-    if (event.first == nullptr) {
-        m_components += MessageComponent{MessageComponentType::Loading, QString(), {}};
-        endResetModel();
-        return;
-    }
-
-    m_components += MessageComponent{MessageComponentType::Author, QString(), {}};
-
-    m_components += messageContentComponents();
-    endResetModel();
-
-    if (m_room->urlPreviewEnabled()) {
-        forEachComponentOfType({MessageComponentType::Text, MessageComponentType::Quote}, m_linkPreviewFunction);
-    }
-
-    updateReplyModel();
-    updateReactionModel();
-}
-
-void MessageContentModel::resetContent(bool isEditing, bool isThreading)
-{
-    const auto startRow = m_components[0].type == MessageComponentType::Author ? 1 : 0;
-    beginRemoveRows({}, startRow, rowCount() - 1);
-    m_components.remove(startRow, rowCount() - startRow);
-    endRemoveRows();
-
-    const auto newComponents = messageContentComponents(isEditing, isThreading);
-    if (newComponents.size() == 0) {
-        return;
-    }
-    beginInsertRows({}, startRow, startRow + newComponents.size() - 1);
-    m_components += newComponents;
-    endInsertRows();
-
-    if (m_room->urlPreviewEnabled()) {
-        forEachComponentOfType({MessageComponentType::Text, MessageComponentType::Quote}, m_linkPreviewFunction);
-    }
-
-    updateReplyModel();
-    updateReactionModel();
-}
-
-QList<MessageComponent> MessageContentModel::messageContentComponents(bool isEditing, bool isThreading)
-{
-    const auto event = m_room->getEvent(m_eventId);
-    if (event.first == nullptr) {
-        return {};
-    }
-
-    QList<MessageComponent> newComponents;
-
-    if (isEditing) {
-        newComponents += MessageComponent{MessageComponentType::ChatBar, QString(), {}};
-    } else {
-        newComponents.append(componentsForType(MessageComponentType::typeForEvent(*event.first, m_isReply)));
-    }
-
-    const auto roomMessageEvent = eventCast<const Quotient::RoomMessageEvent>(event.first);
-#if Quotient_VERSION_MINOR > 9 || (Quotient_VERSION_MINOR == 9 && Quotient_VERSION_PATCH > 1)
-    if (m_threadsEnabled && roomMessageEvent && (roomMessageEvent->isThreaded() || m_room->threads().contains(roomMessageEvent->id()))
-        && roomMessageEvent->id() == roomMessageEvent->threadRootEventId()) {
-#else
-    if (m_threadsEnabled && roomMessageEvent && roomMessageEvent->isThreaded() && roomMessageEvent->id() == roomMessageEvent->threadRootEventId()) {
-#endif
-        newComponents += MessageComponent{MessageComponentType::Separator, {}, {}};
-        newComponents += MessageComponent{MessageComponentType::ThreadBody, u"Thread Body"_s, {}};
-    }
-
-    // If the event is already threaded the ThreadModel will handle displaying a chat bar.
-#if Quotient_VERSION_MINOR > 9 || (Quotient_VERSION_MINOR == 9 && Quotient_VERSION_PATCH > 1)
-    if (isThreading && roomMessageEvent && !(roomMessageEvent->isThreaded() || m_room->threads().contains(roomMessageEvent->id()))) {
-#else
-    if (isThreading && roomMessageEvent && roomMessageEvent->isThreaded()) {
-#endif
-        newComponents += MessageComponent{MessageComponentType::ChatBar, QString(), {}};
-    }
-
-    return newComponents;
-}
-
-void MessageContentModel::updateReplyModel()
-{
-    const auto event = m_room->getEvent(m_eventId);
-    if (event.first == nullptr || m_isReply) {
-        return;
-    }
-
-    const auto roomMessageEvent = eventCast<const Quotient::RoomMessageEvent>(event.first);
-    if (roomMessageEvent == nullptr) {
-        return;
-    }
-    if (!roomMessageEvent->isReply(m_threadsEnabled) || (roomMessageEvent->isThreaded() && m_threadsEnabled)) {
-        if (m_replyModel) {
-            m_replyModel->disconnect(this);
-            m_replyModel->deleteLater();
-        }
-        return;
-    }
-
-    if (m_replyModel != nullptr) {
-        return;
-    }
-
-    m_replyModel = new MessageContentModel(m_room, roomMessageEvent->replyEventId(!m_threadsEnabled), true, false, this);
-
-    connect(m_replyModel, &MessageContentModel::eventUpdated, this, [this]() {
-        Q_EMIT dataChanged(index(0), index(0), {ReplyAuthorRole});
-    });
-
-    bool hasModel = hasComponentType(MessageComponentType::Reply);
-    if (m_replyModel && !hasModel) {
-        int insertRow = 0;
-        if (m_components.first().type == MessageComponentType::Author) {
-            insertRow = 1;
-        }
-        beginInsertRows({}, insertRow, insertRow);
-        m_components.insert(insertRow, MessageComponent{MessageComponentType::Reply, QString(), {}});
-    } else if (!m_replyModel && hasModel) {
-        int removeRow = 0;
-        if (m_components.first().type == MessageComponentType::Author) {
-            removeRow = 1;
-        }
-        beginRemoveRows({}, removeRow, removeRow);
-        m_components.removeAt(removeRow);
-        endRemoveRows();
-    }
-}
-
-QList<MessageComponent> MessageContentModel::componentsForType(MessageComponentType::Type type)
-{
-    const auto event = m_room->getEvent(m_eventId);
-    if (event.first == nullptr) {
-        return {};
-    }
-
-    switch (type) {
-    case MessageComponentType::Verification: {
-        return {MessageComponent{MessageComponentType::Verification, QString(), {}}};
-    }
-    case MessageComponentType::Text: {
-        if (const auto roomMessageEvent = eventCast<const Quotient::RoomMessageEvent>(event.first)) {
-            return TextHandler().textComponents(EventHandler::rawMessageBody(*roomMessageEvent),
-                                            EventHandler::messageBodyInputFormat(*roomMessageEvent),
-                                            m_room,
-                                            roomMessageEvent,
-                                            roomMessageEvent->isReplaced());
-        } else {
-            return TextHandler().textComponents(EventHandler::plainBody(m_room, event.first), Qt::TextFormat::PlainText, m_room, event.first, false);
-        }
-
-        const auto roomMessageEvent = eventCast<const Quotient::RoomMessageEvent>(event.first);
-        return TextHandler().textComponents(EventHandler::rawMessageBody(*roomMessageEvent),
-                                            EventHandler::messageBodyInputFormat(*roomMessageEvent),
-                                            m_room,
-                                            roomMessageEvent,
-                                            roomMessageEvent->isReplaced());
-    }
-    case MessageComponentType::File: {
-        QList<MessageComponent> components;
-        components += MessageComponent{MessageComponentType::File, QString(), {}};
-        const auto roomMessageEvent = eventCast<const Quotient::RoomMessageEvent>(event.first);
-
-        if (m_emptyItinerary) {
-            if (!m_isReply) {
-                auto fileTransferInfo = m_room->cachedFileTransferInfo(event.first);
-
-#ifndef Q_OS_ANDROID
-                Q_ASSERT(roomMessageEvent->content() != nullptr && roomMessageEvent->has<EventContent::FileContent>());
-                const QMimeType mimeType = roomMessageEvent->get<EventContent::FileContent>()->mimeType;
-                if (mimeType.name() == u"text/plain"_s || mimeType.parentMimeTypes().contains(u"text/plain"_s)) {
-                    QString originalName = roomMessageEvent->get<EventContent::FileContent>()->originalName;
-                    if (originalName.isEmpty()) {
-                        originalName = roomMessageEvent->plainBody();
-                    }
-                    KSyntaxHighlighting::Repository repository;
-                    KSyntaxHighlighting::Definition definitionForFile = repository.definitionForFileName(originalName);
-                    if (!definitionForFile.isValid()) {
-                        definitionForFile = repository.definitionForMimeType(mimeType.name());
-                    }
-
-                    QFile file(fileTransferInfo.localPath.path());
-                    file.open(QIODevice::ReadOnly);
-                    components += MessageComponent{MessageComponentType::Code,
-                                                   QString::fromStdString(file.readAll().toStdString()),
-                                                   {{u"class"_s, definitionForFile.name()}}};
-                }
-#endif
-
-                if (FileType::instance().fileHasImage(fileTransferInfo.localPath)) {
-                    QImageReader reader(fileTransferInfo.localPath.path());
-                    components += MessageComponent{MessageComponentType::Pdf, QString(), {{u"size"_s, reader.size()}}};
-                }
-            }
-        } else if (m_itineraryModel != nullptr) {
-            components += MessageComponent{MessageComponentType::Itinerary, QString(), {}};
-            if (m_itineraryModel->rowCount() > 0) {
-                updateItineraryModel();
-            }
-        } else {
-            updateItineraryModel();
-        }
-        auto body = EventHandler::rawMessageBody(*roomMessageEvent);
-        components += TextHandler().textComponents(body,
-                                                   EventHandler::messageBodyInputFormat(*roomMessageEvent),
-                                                   m_room,
-                                                   roomMessageEvent,
-                                                   roomMessageEvent->isReplaced());
-        return components;
-    }
-    case MessageComponentType::Image:
-    case MessageComponentType::Audio:
-    case MessageComponentType::Video: {
-        if (!event.first->is<StickerEvent>()) {
-            const auto roomMessageEvent = eventCast<const Quotient::RoomMessageEvent>(event.first);
-            const auto fileContent = roomMessageEvent->get<EventContent::FileContentBase>();
-            if (fileContent != nullptr) {
-                const auto fileInfo = fileContent->commonInfo();
-                const auto body = EventHandler::rawMessageBody(*roomMessageEvent);
-                // Do not attach the description to the image, if it's the same as the original filename.
-                if (fileInfo.originalName != body) {
-                    QList<MessageComponent> components;
-                    components += MessageComponent{type, QString(), {}};
-                    components += TextHandler().textComponents(body,
-                                                               EventHandler::messageBodyInputFormat(*roomMessageEvent),
-                                                               m_room,
-                                                               roomMessageEvent,
-                                                               roomMessageEvent->isReplaced());
-                    return components;
-                }
-            }
-        }
-    }
-        [[fallthrough]];
-    default:
-        return {MessageComponent{type, QString(), {}}};
-    }
-}
-
 MessageComponent MessageContentModel::linkPreviewComponent(const QUrl &link)
 {
     const auto linkPreviewer = dynamic_cast<NeoChatConnection *>(m_room->connection())->previewerForLink(link);
@@ -733,79 +277,4 @@ void MessageContentModel::closeLinkPreview(int row)
     }
 }
 
-void MessageContentModel::updateItineraryModel()
-{
-    const auto event = m_room->getEvent(m_eventId);
-    if (m_room == nullptr || event.first == nullptr) {
-        return;
-    }
-
-    if (auto roomMessageEvent = eventCast<const Quotient::RoomMessageEvent>(event.first)) {
-        if (roomMessageEvent->has<EventContent::FileContent>()) {
-            auto filePath = m_room->cachedFileTransferInfo(event.first).localPath;
-            if (filePath.isEmpty() && m_itineraryModel != nullptr) {
-                delete m_itineraryModel;
-                m_itineraryModel = nullptr;
-            } else if (!filePath.isEmpty()) {
-                if (m_itineraryModel == nullptr) {
-                    m_itineraryModel = new ItineraryModel(this);
-                    connect(m_itineraryModel, &ItineraryModel::loaded, this, [this]() {
-                        if (m_itineraryModel->rowCount() == 0) {
-                            m_emptyItinerary = true;
-                            m_itineraryModel->deleteLater();
-                            m_itineraryModel = nullptr;
-                            resetContent();
-                        }
-                    });
-                    connect(m_itineraryModel, &ItineraryModel::loadErrorOccurred, this, [this]() {
-                        m_emptyItinerary = true;
-                        m_itineraryModel->deleteLater();
-                        m_itineraryModel = nullptr;
-                        resetContent();
-                    });
-                }
-                m_itineraryModel->setPath(filePath.toString());
-            }
-        }
-    }
-}
-
-void MessageContentModel::updateReactionModel()
-{
-    if (m_reactionModel && m_reactionModel->rowCount() > 0) {
-        return;
-    }
-
-    if (m_reactionModel == nullptr) {
-        m_reactionModel = new ReactionModel(this, m_eventId, m_room);
-        connect(m_reactionModel, &ReactionModel::reactionsUpdated, this, &MessageContentModel::updateReactionModel);
-    }
-
-    if (m_reactionModel->rowCount() <= 0) {
-        m_reactionModel->disconnect(this);
-        m_reactionModel->deleteLater();
-        m_reactionModel = nullptr;
-    }
-
-    if (m_reactionModel && m_components.last().type != MessageComponentType::Reaction) {
-        beginInsertRows({}, rowCount(), rowCount());
-        m_components += MessageComponent{MessageComponentType::Reaction, QString(), {}};
-        endInsertRows();
-    } else if (rowCount() > 0 && m_components.last().type == MessageComponentType::Reaction) {
-        beginRemoveRows({}, rowCount() - 1, rowCount() - 1);
-        m_components.removeLast();
-        endRemoveRows();
-    }
-}
-
-ThreadModel *MessageContentModel::modelForThread(const QString &threadRootId)
-{
-    return ContentProvider::self().modelForThread(m_room, threadRootId);
-}
-
-void MessageContentModel::setThreadsEnabled(bool enableThreads)
-{
-    m_threadsEnabled = enableThreads;
-}
-
 #include "moc_messagecontentmodel.cpp"

src/messagecontent/models/messagecontentmodel.h

@@ -5,22 +5,29 @@
 
 #include <QAbstractListModel>
 #include <QQmlEngine>
+#include <QImageReader>
 
-#include <Quotient/events/roomevent.h>
+#ifndef Q_OS_ANDROID
+#include <KSyntaxHighlighting/Definition>
+#include <KSyntaxHighlighting/Repository>
+#endif
 
 #include "enums/messagecomponenttype.h"
+#include "filetype.h"
 #include "linkpreviewer.h"
 #include "messagecomponent.h"
 #include "models/itinerarymodel.h"
 #include "models/reactionmodel.h"
+#include "neochatroom.h"
 #include "neochatroommember.h"
 
-class ThreadModel;
-
 /**
  * @class MessageContentModel
  *
- * A model to visualise the components of a single RoomMessageEvent.
+ * A model to visualise the content of a message.
+ *
+ * This is a base model designed to be extended. The inherited class needs to define
+ * how the MessageComponents are added.
  */
 class MessageContentModel : public QAbstractListModel
 {
@@ -28,15 +35,9 @@ class MessageContentModel : public QAbstractListModel
     QML_ELEMENT
     QML_UNCREATABLE("")
 
-public:
-    enum MessageState {
-        Unknown, /**< The message state is unknown. */
-        Pending, /**< The message is a new pending message which the server has not yet acknowledged. */
-        Available, /**< The message is available and acknowledged by the server. */
-        UnAvailable, /**< The message can't be retrieved either because it doesn't exist or is blocked. */
-    };
-    Q_ENUM(MessageState)
+    Q_PROPERTY(NeochatRoomMember *author READ author NOTIFY authorChanged)
 
+public:
     /**
      * @brief Defines the model roles.
      */
@@ -48,32 +49,18 @@ public:
         TimeRole, /**< The timestamp for when the event was sent (as a QDateTime). */
         TimeStringRole, /**< The timestamp for when the event was sent as a string (in QLocale::ShortFormat). */
         AuthorRole, /**< The author of the event. */
-        MediaInfoRole, /**< The media info for the event. */
         FileTransferInfoRole, /**< FileTransferInfo for any downloading files. */
         ItineraryModelRole, /**< The itinerary model for a file. */
-        LatitudeRole, /**< Latitude for a location event. */
-        LongitudeRole, /**< Longitude for a location event. */
-        AssetRole, /**< Type of location event, e.g. self pin of the user location. */
         PollHandlerRole, /**< The PollHandler for the event, if any. */
-
-        ReplyEventIdRole, /**< The matrix ID of the message that was replied to. */
-        ReplyAuthorRole, /**< The author of the event that was replied to. */
         ReplyContentModelRole, /**< The MessageContentModel for the reply event. */
-
         ReactionModelRole, /**< Reaction model for this event. */
-
         ThreadRootRole, /**< The thread root event ID for the event. */
-
         LinkPreviewerRole, /**< The link preview details. */
         ChatBarCacheRole, /**< The ChatBarCache to use. */
     };
     Q_ENUM(Roles)
 
-    explicit MessageContentModel(NeoChatRoom *room,
-                                 const QString &eventId,
-                                 bool isReply = false,
-                                 bool isPending = false,
-                                 MessageContentModel *parent = nullptr);
+    explicit MessageContentModel(NeoChatRoom *room, MessageContentModel *parent = nullptr, const QString &eventId = {});
 
     /**
      * @brief Get the given role value at the given index.
@@ -95,9 +82,18 @@ public:
      * @sa Roles, QAbstractItemModel::roleNames()
      */
     [[nodiscard]] QHash<int, QByteArray> roleNames() const override;
-
     static QHash<int, QByteArray> roleNamesStatic();
 
+    /**
+     * @brief The Matrix event ID of the message.
+     */
+    Q_INVOKABLE QString eventId() const;
+
+    /**
+     * @brief The author of the message.
+     */
+    Q_INVOKABLE NeochatRoomMember *author() const;
+
     /**
      * @brief Close the link preview at the given index.
      *
@@ -105,34 +101,50 @@ public:
      */
     Q_INVOKABLE void closeLinkPreview(int row);
 
-    /**
-     * @brief Returns the thread model for the given thread root event ID.
-     *
-     * A model is created is one doesn't exist. Will return nullptr if threadRootId
-     * is empty.
-     */
-    Q_INVOKABLE ThreadModel *modelForThread(const QString &threadRootId);
-
-    static void setThreadsEnabled(bool enableThreads);
-
 Q_SIGNALS:
-    void showAuthorChanged();
-    void eventUpdated();
+    void authorChanged();
 
-    void threadsEnabledChanged();
+    /**
+     * @brief Emit whenever new components are added.
+     */
+    void componentsUpdated();
 
-private:
+    /**
+     * @brief Emit whenever itinerary model is updated.
+     */
+    void itineraryUpdated();
+
+protected:
     QPointer<NeoChatRoom> m_room;
     QString m_eventId;
-    QString senderId() const;
-    NeochatRoomMember *senderObject() const;
 
-    MessageState m_currentState = Unknown;
-    bool m_isReply;
+    /**
+     * @brief QDateTime for the message.
+     *
+     * The default implementation returns the current time.
+     */
+    virtual QDateTime time() const;
 
-    void initializeModel();
-    void initializeEvent();
-    void getEvent();
+    /**
+     * @brief Time for the message as a string in the from "hh:mm".
+     *
+     * The default implementation returns the current time.
+     */
+    virtual QString timeString() const;
+
+    /**
+     * @brief The author of the message.
+     *
+     * The default implementation returns the local user.
+     */
+    virtual QString authorId() const;
+
+    /**
+     * @brief Thread root ID for the message if in a thread.
+     *
+     * The default implementation returns an empty string.
+     */
+    virtual QString threadRootId() const;
 
     using ComponentIt = QList<MessageComponent>::iterator;
 
@@ -141,14 +153,61 @@ private:
     void forEachComponentOfType(MessageComponentType::Type type, std::function<ComponentIt(ComponentIt)> function);
     void forEachComponentOfType(QList<MessageComponentType::Type> types, std::function<ComponentIt(ComponentIt)> function);
 
+    QPointer<MessageContentModel> m_replyModel;
+    QPointer<ReactionModel> m_reactionModel = nullptr;
+    QPointer<ItineraryModel> m_itineraryModel = nullptr;
+    bool m_emptyItinerary = false;
+
+private:
+    void initializeModel();
+
     std::function<ComponentIt(const ComponentIt &)> m_fileInfoFunction = [this](ComponentIt it) {
         Q_EMIT dataChanged(index(it - m_components.begin()), index(it - m_components.begin()), {MessageContentModel::FileTransferInfoRole});
         return ++it;
     };
-    std::function<ComponentIt(const ComponentIt &)> m_linkPreviewFunction = [this](ComponentIt it) {
+    std::function<ComponentIt(const ComponentIt &)> m_fileFunction = [this](ComponentIt it) {
+        if (m_itineraryModel && m_itineraryModel->rowCount() > 0) {
+            beginInsertRows({}, std::distance(m_components.begin(), it) + 1, std::distance(m_components.begin(), it) + 1);
+            it = m_components.insert(it + 1, MessageComponent{MessageComponentType::Itinerary, QString(), {}});
+            endInsertRows();
+            return it;
+        } else if (m_emptyItinerary) {
+            auto fileTransferInfo = m_room->cachedFileTransferInfo(m_eventId);
+#ifndef Q_OS_ANDROID
+            const QMimeType mimeType = FileType::instance().mimeTypeForFile(fileTransferInfo.localPath.toString());
+            if (mimeType.inherits(u"text/plain"_s)) {
+                KSyntaxHighlighting::Repository repository;
+                KSyntaxHighlighting::Definition definitionForFile = repository.definitionForFileName(fileTransferInfo.localPath.toString());
+                if (!definitionForFile.isValid()) {
+                    definitionForFile = repository.definitionForMimeType(mimeType.name());
+                }
+
+                QFile file(fileTransferInfo.localPath.path());
+                file.open(QIODevice::ReadOnly);
+                beginInsertRows({}, std::distance(m_components.begin(), it) + 1, std::distance(m_components.begin(), it) + 1);
+                it = m_components.insert(it + 1, MessageComponent{MessageComponentType::Code,  QString::fromStdString(file.readAll().toStdString()), {{u"class"_s, definitionForFile.name()}}});
+                endInsertRows();
+                return it;
+            }
+#endif
+
+            if (FileType::instance().fileHasImage(fileTransferInfo.localPath)) {
+                QImageReader reader(fileTransferInfo.localPath.path());
+                beginInsertRows({}, std::distance(m_components.begin(), it) + 1, std::distance(m_components.begin(), it) + 1);
+                it = m_components.insert(it + 1, MessageComponent{MessageComponentType::Pdf, QString(), {{u"size"_s, reader.size()}}});
+                endInsertRows();
+            }
+        }
+        return ++it;
+    };
+    std::function<ComponentIt(const ComponentIt &)> m_linkPreviewAddFunction = [this](ComponentIt it) {
+        if (!m_room->urlPreviewEnabled()) {
+            return it;
+        }
+
         bool previewAdded = false;
-        if (LinkPreviewer::hasPreviewableLinks(it->content)) {
-            const auto links = LinkPreviewer::linkPreviews(it->content);
+        if (LinkPreviewer::hasPreviewableLinks(it->display)) {
+            const auto links = LinkPreviewer::linkPreviews(it->display);
             for (qsizetype j = 0; j < links.size(); ++j) {
                 const auto linkPreview = linkPreviewComponent(links[j]);
                 if (!m_removedLinkPreviews.contains(links[j]) && !linkPreview.isEmpty()) {
@@ -161,26 +220,16 @@ private:
         }
         return previewAdded ? it : ++it;
     };
-
-    void resetModel();
-    void resetContent(bool isEditing = false, bool isThreading = false);
-    QList<MessageComponent> messageContentComponents(bool isEditing = false, bool isThreading = false);
-
-    QPointer<MessageContentModel> m_replyModel;
-    void updateReplyModel();
-
-    ReactionModel *m_reactionModel = nullptr;
-    ItineraryModel *m_itineraryModel = nullptr;
-
-    QList<MessageComponent> componentsForType(MessageComponentType::Type type);
-    MessageComponent linkPreviewComponent(const QUrl &link);
+    std::function<ComponentIt(const ComponentIt &)> m_linkPreviewRemoveFunction = [this](ComponentIt it) {
+        if (m_room->urlPreviewEnabled()) {
+            return it;
+        }
+        beginRemoveRows({}, std::distance(m_components.begin(), it), std::distance(m_components.begin(), it));
+        it = m_components.erase(it);
+        endRemoveRows();
+        return it;
+    };
 
     QList<QUrl> m_removedLinkPreviews;
-
-    void updateItineraryModel();
-    bool m_emptyItinerary = false;
-
-    void updateReactionModel();
-
-    static bool m_threadsEnabled;
+    MessageComponent linkPreviewComponent(const QUrl &link);
 };