Move the qt models to their own folder

Felt like the src folder was getting a bit crowded so move all the models to a folder named models.

src/models/actionsmodel.cpp

@@ -0,0 +1,559 @@
+// SPDX-FileCopyrightText: 2022 Tobias Fella <fella@posteo.de>
+// SPDX-License-Identifier: LGPL-2.0-or-later
+
+#include "actionsmodel.h"
+
+#include "controller.h"
+#include "neochatroom.h"
+#include "neochatuser.h"
+#include "roommanager.h"
+#include <events/roommemberevent.h>
+#include <events/roompowerlevelsevent.h>
+
+#include <KLocalizedString>
+
+using Action = ActionsModel::Action;
+using namespace Quotient;
+
+QStringList rainbowColors{"#ff2b00", "#ff5500", "#ff8000", "#ffaa00", "#ffd500", "#ffff00", "#d4ff00", "#aaff00", "#80ff00", "#55ff00", "#2bff00", "#00ff00",
+                          "#00ff2b", "#00ff55", "#00ff80", "#00ffaa", "#00ffd5", "#00ffff", "#00d4ff", "#00aaff", "#007fff", "#0055ff", "#002bff", "#0000ff",
+                          "#2a00ff", "#5500ff", "#7f00ff", "#aa00ff", "#d400ff", "#ff00ff", "#ff00d4", "#ff00aa", "#ff0080", "#ff0055", "#ff002b", "#ff0000"};
+
+QVector<ActionsModel::Action> actions{
+    Action{
+        QStringLiteral("shrug"),
+        [](const QString &message, NeoChatRoom *) {
+            return QStringLiteral("¯\\\\_(ツ)_/¯ %1").arg(message);
+        },
+        true,
+        std::nullopt,
+        kli18n("<message>"),
+        kli18n("Prepends ¯\\_(ツ)_/¯ to a plain-text message"),
+    },
+    Action{
+        QStringLiteral("lenny"),
+        [](const QString &message, NeoChatRoom *) {
+            return QStringLiteral("( ͡° ͜ʖ ͡°) %1").arg(message);
+        },
+        true,
+        std::nullopt,
+        kli18n("<message>"),
+        kli18n("Prepends ( ͡° ͜ʖ ͡°) to a plain-text message"),
+    },
+    Action{
+        QStringLiteral("tableflip"),
+        [](const QString &message, NeoChatRoom *) {
+            return QStringLiteral("(╯°□°）╯︵ ┻━┻ %1").arg(message);
+        },
+        true,
+        std::nullopt,
+        kli18n("<message>"),
+        kli18n("Prepends (╯°□°）╯︵ ┻━┻ to a plain-text message"),
+    },
+    Action{
+        QStringLiteral("unflip"),
+        [](const QString &message, NeoChatRoom *) {
+            return QStringLiteral("┬──┬ ノ( ゜-゜ノ) %1").arg(message);
+        },
+        true,
+        std::nullopt,
+        kli18n("<message>"),
+        kli18n("Prepends ┬──┬ ノ( ゜-゜ノ) to a plain-text message"),
+    },
+    Action{
+        QStringLiteral("rainbow"),
+        [](const QString &text, NeoChatRoom *room) {
+            QString rainbowText;
+            for (int i = 0; i < text.length(); i++) {
+                rainbowText += QStringLiteral("<font color='%2'>%3</font>").arg(rainbowColors[i % rainbowColors.length()], text.at(i));
+            }
+            // Ideally, we would just return rainbowText and let that do the rest, but the colors don't survive markdownToHTML.
+            room->postMessage(QStringLiteral("/rainbow %1").arg(text),
+                              rainbowText,
+                              RoomMessageEvent::MsgType::Text,
+                              room->chatBoxReplyId(),
+                              room->chatBoxEditId());
+            return QString();
+        },
+        false,
+        std::nullopt,
+        kli18n("<message>"),
+        kli18n("Sends the given message colored as a rainbow"),
+    },
+    Action{
+        QStringLiteral("rainbowme"),
+        [](const QString &text, NeoChatRoom *room) {
+            QString rainbowText;
+            for (int i = 0; i < text.length(); i++) {
+                rainbowText += QStringLiteral("<font color='%2'>%3</font>").arg(rainbowColors[i % rainbowColors.length()], text.at(i));
+            }
+            // Ideally, we would just return rainbowText and let that do the rest, but the colors don't survive markdownToHTML.
+            room->postMessage(QStringLiteral("/rainbow %1").arg(text),
+                              rainbowText,
+                              RoomMessageEvent::MsgType::Emote,
+                              room->chatBoxReplyId(),
+                              room->chatBoxEditId());
+            return QString();
+        },
+        false,
+        std::nullopt,
+        kli18n("<message>"),
+        kli18n("Sends the given emote colored as a rainbow"),
+    },
+    Action{
+        QStringLiteral("plain"),
+        [](const QString &text, NeoChatRoom *room) {
+            room->postMessage(text, text.toHtmlEscaped(), RoomMessageEvent::MsgType::Text, {}, {});
+            return QString();
+        },
+        false,
+        std::nullopt,
+        kli18n("<message>"),
+        kli18n("Sends the given message as plain text"),
+    },
+    Action{
+        QStringLiteral("spoiler"),
+        [](const QString &text, NeoChatRoom *room) {
+            // Ideally, we would just return rainbowText and let that do the rest, but the colors don't survive markdownToHTML.
+            room->postMessage(QStringLiteral("/rainbow %1").arg(text),
+                              QStringLiteral("<span data-mx-spoiler>%1</span>").arg(text),
+                              RoomMessageEvent::MsgType::Text,
+                              room->chatBoxReplyId(),
+                              room->chatBoxEditId());
+            return QString();
+        },
+        false,
+        std::nullopt,
+        kli18n("<message>"),
+        kli18n("Sends the given message as a spoiler"),
+    },
+    Action{
+        QStringLiteral("me"),
+        [](const QString &text, NeoChatRoom *) {
+            return text;
+        },
+        true,
+        RoomMessageEvent::MsgType::Emote,
+        kli18n("<message>"),
+        kli18n("Sends the given emote"),
+    },
+    Action{
+        QStringLiteral("notice"),
+        [](const QString &text, NeoChatRoom *) {
+            return text;
+        },
+        true,
+        RoomMessageEvent::MsgType::Notice,
+        kli18n("<message>"),
+        kli18n("Sends the given message as a notice"),
+    },
+    Action{
+        QStringLiteral("invite"),
+        [](const QString &text, NeoChatRoom *room) {
+            static const QRegularExpression mxidRegex(
+                QStringLiteral(R"((^|[][[:space:](){}`'";])([!#@][-a-z0-9_=#/.]{1,252}:\w(?:\w|\.|-)*\.\w+(?::\d{1,5})?))"));
+            auto regexMatch = mxidRegex.match(text);
+            if (!regexMatch.hasMatch()) {
+                Q_EMIT room->showMessage(NeoChatRoom::Error, i18nc("'<text>' does not look like a matrix id.", "'%1' does not look like a matrix id.", text));
+                return QString();
+            }
+#ifdef QUOTIENT_07
+            const RoomMemberEvent *roomMemberEvent = room->currentState().get<RoomMemberEvent>(text);
+            if (roomMemberEvent && roomMemberEvent->membership() == Membership::Invite) {
+                Q_EMIT room->showMessage(NeoChatRoom::Info, i18nc("<user> is already invited to this room.", "%1 is already invited to this room.", text));
+                return QString();
+            }
+            if (roomMemberEvent && roomMemberEvent->membership() == Membership::Ban) {
+                Q_EMIT room->showMessage(NeoChatRoom::Info, i18nc("<user> is banned from this room.", "%1 is banned from this room.", text));
+                return QString();
+            }
+#endif
+            if (room->localUser()->id() == text) {
+                Q_EMIT room->showMessage(NeoChatRoom::Positive, i18n("You are already in this room."));
+                return QString();
+            }
+            if (room->users().contains(room->user(text))) {
+                Q_EMIT room->showMessage(NeoChatRoom::Info, i18nc("<user> is already in this room.", "%1 is already in this room.", text));
+                return QString();
+            }
+            room->inviteToRoom(text);
+            Q_EMIT room->showMessage(NeoChatRoom::Positive, i18nc("<username> was invited into this room", "%1 was invited into this room", text));
+            return QString();
+        },
+        false,
+        std::nullopt,
+        kli18n("<user id>"),
+        kli18n("Invites the user to this room"),
+    },
+    Action{
+        QStringLiteral("join"),
+        [](const QString &text, NeoChatRoom *room) {
+            QRegularExpression roomRegex(QStringLiteral(R"(^[#!][^:]+:\w(?:\w|\.|-)*\.\w+(?::\d{1,5})?)"));
+            auto regexMatch = roomRegex.match(text);
+            if (!regexMatch.hasMatch()) {
+                Q_EMIT room->showMessage(NeoChatRoom::Error,
+                                         i18nc("'<text>' does not look like a room id or alias.", "'%1' does not look like a room id or alias.", text));
+                return QString();
+            }
+            auto targetRoom = text.startsWith(QLatin1Char('!')) ? room->connection()->room(text) : room->connection()->roomByAlias(text);
+            if (targetRoom) {
+                RoomManager::instance().enterRoom(dynamic_cast<NeoChatRoom *>(targetRoom));
+                return QString();
+            }
+            Q_EMIT room->showMessage(NeoChatRoom::Info, i18nc("Joining room <roomname>.", "Joining room %1.", text));
+            Controller::instance().joinRoom(text);
+            return QString();
+        },
+        false,
+        std::nullopt,
+        kli18n("<room alias or id>"),
+        kli18n("Joins the given room"),
+    },
+    Action{
+        QStringLiteral("j"),
+        [](const QString &text, NeoChatRoom *room) {
+            QRegularExpression roomRegex(QStringLiteral(R"(^[#!][^:]+:\w(?:\w|\.|-)*\.\w+(?::\d{1,5})?)"));
+            auto regexMatch = roomRegex.match(text);
+            if (!regexMatch.hasMatch()) {
+                Q_EMIT room->showMessage(NeoChatRoom::Error,
+                                         i18nc("'<text>' does not look like a room id or alias.", "'%1' does not look like a room id or alias.", text));
+                return QString();
+            }
+            if (Controller::instance().activeConnection()->room(text) || Controller::instance().activeConnection()->roomByAlias(text)) {
+                Q_EMIT room->showMessage(NeoChatRoom::Info, i18nc("You are already in room <roomname>.", "You are already in room %1.", text));
+                return QString();
+            }
+            Q_EMIT room->showMessage(NeoChatRoom::Info, i18nc("Joining room <roomname>.", "Joining room %1.", text));
+            Controller::instance().joinRoom(text);
+            return QString();
+        },
+        false,
+        std::nullopt,
+        kli18n("<room alias or id>"),
+        kli18n("Joins the given room"),
+    },
+    Action{
+        QStringLiteral("part"),
+        [](const QString &text, NeoChatRoom *room) {
+            if (text.isEmpty()) {
+                Q_EMIT room->showMessage(NeoChatRoom::Info, i18n("Leaving this room."));
+                room->connection()->leaveRoom(room);
+            } else {
+                QRegularExpression roomRegex(QStringLiteral(R"(^[#!][^:]+:\w(?:\w|\.|-)*\.\w+(?::\d{1,5})?)"));
+                auto regexMatch = roomRegex.match(text);
+                if (!regexMatch.hasMatch()) {
+                    Q_EMIT room->showMessage(NeoChatRoom::Error,
+                                             i18nc("'<text>' does not look like a room id or alias.", "'%1' does not look like a room id or alias.", text));
+                    return QString();
+                }
+                auto leaving = room->connection()->room(text);
+                if (!leaving) {
+                    leaving = room->connection()->roomByAlias(text);
+                }
+                if (leaving) {
+                    Q_EMIT room->showMessage(NeoChatRoom::Info, i18nc("Leaving room <roomname>.", "Leaving room %1.", text));
+                    room->connection()->leaveRoom(leaving);
+                } else {
+                    Q_EMIT room->showMessage(NeoChatRoom::Info, i18nc("Room <roomname> not found", "Room %1 not found.", text));
+                }
+            }
+            return QString();
+        },
+        false,
+        std::nullopt,
+        kli18n("[<room alias or id>]"),
+        kli18n("Leaves the given room or this room, if there is none given"),
+    },
+    Action{
+        QStringLiteral("leave"),
+        [](const QString &text, NeoChatRoom *room) {
+            if (text.isEmpty()) {
+                Q_EMIT room->showMessage(NeoChatRoom::Info, i18n("Leaving this room."));
+                room->connection()->leaveRoom(room);
+            } else {
+                QRegularExpression roomRegex(QStringLiteral(R"(^[#!][^:]+:\w(?:\w|\.|-)*\.\w+(?::\d{1,5})?)"));
+                auto regexMatch = roomRegex.match(text);
+                if (!regexMatch.hasMatch()) {
+                    Q_EMIT room->showMessage(NeoChatRoom::Error,
+                                             i18nc("'<text>' does not look like a room id or alias.", "'%1' does not look like a room id or alias.", text));
+                    return QString();
+                }
+                auto leaving = room->connection()->room(text);
+                if (!leaving) {
+                    leaving = room->connection()->roomByAlias(text);
+                }
+                if (leaving) {
+                    Q_EMIT room->showMessage(NeoChatRoom::Info, i18nc("Leaving room <roomname>.", "Leaving room %1.", text));
+                    room->connection()->leaveRoom(leaving);
+                } else {
+                    Q_EMIT room->showMessage(NeoChatRoom::Info, i18nc("Room <roomname> not found", "Room %1 not found.", text));
+                }
+            }
+            return QString();
+        },
+        false,
+        std::nullopt,
+        kli18n("[<room alias or id>]"),
+        kli18n("Leaves the given room or this room, if there is none given"),
+    },
+    Action{
+        QStringLiteral("nick"),
+        [](const QString &text, NeoChatRoom *room) {
+            if (text.isEmpty()) {
+                Q_EMIT room->showMessage(NeoChatRoom::Error, i18n("No new nickname provided, no changes will happen."));
+            } else {
+                room->connection()->user()->rename(text);
+            }
+            return QString();
+        },
+        false,
+        std::nullopt,
+        kli18n("<display name>"),
+        kli18n("Changes your global display name"),
+    },
+    Action{
+        QStringLiteral("roomnick"),
+        [](const QString &text, NeoChatRoom *room) {
+            if (text.isEmpty()) {
+                Q_EMIT room->showMessage(NeoChatRoom::Error, i18n("No new nickname provided, no changes will happen."));
+            } else {
+                room->connection()->user()->rename(text, room);
+            }
+            return QString();
+        },
+        false,
+        std::nullopt,
+        kli18n("<display name>"),
+        kli18n("Changes your display name in this room"),
+    },
+    Action{
+        QStringLiteral("ignore"),
+        [](const QString &text, NeoChatRoom *room) {
+            static const QRegularExpression mxidRegex(
+                QStringLiteral(R"((^|[][[:space:](){}`'";])([!#@][-a-z0-9_=#/.]{1,252}:\w(?:\w|\.|-)*\.\w+(?::\d{1,5})?))"));
+            auto regexMatch = mxidRegex.match(text);
+            if (!regexMatch.hasMatch()) {
+                Q_EMIT room->showMessage(NeoChatRoom::Error, i18nc("'<text>' does not look like a matrix id.", "'%1' does not look like a matrix id.", text));
+                return QString();
+            }
+            auto user = room->connection()->users()[text];
+            if (room->connection()->ignoredUsers().contains(user->id())) {
+                Q_EMIT room->showMessage(NeoChatRoom::Info, i18nc("<username> is already ignored.", "%1 is already ignored.", text));
+                return QString();
+            }
+            if (user) {
+                room->connection()->addToIgnoredUsers(user);
+                Q_EMIT room->showMessage(NeoChatRoom::Positive, i18nc("<username> is now ignored", "%1 is now ignored.", text));
+            } else {
+                Q_EMIT room->showMessage(NeoChatRoom::Error, i18nc("<username> is not a known user", "%1 is not a known user.", text));
+            }
+            return QString();
+        },
+        false,
+        std::nullopt,
+        kli18n("<user id>"),
+        kli18n("Ignores the given user"),
+    },
+    Action{
+        QStringLiteral("unignore"),
+        [](const QString &text, NeoChatRoom *room) {
+            static const QRegularExpression mxidRegex(
+                QStringLiteral(R"((^|[][[:space:](){}`'";])([!#@][-a-z0-9_=#/.]{1,252}:\w(?:\w|\.|-)*\.\w+(?::\d{1,5})?))"));
+            auto regexMatch = mxidRegex.match(text);
+            if (!regexMatch.hasMatch()) {
+                Q_EMIT room->showMessage(NeoChatRoom::Error, i18nc("'<text>' does not look like a matrix id.", "'%1' does not look like a matrix id.", text));
+                return QString();
+            }
+            auto user = room->connection()->users()[text];
+            if (user) {
+                if (!room->connection()->ignoredUsers().contains(user->id())) {
+                    Q_EMIT room->showMessage(NeoChatRoom::Info, i18nc("<username> is not ignored.", "%1 is not ignored.", text));
+                    return QString();
+                }
+                room->connection()->removeFromIgnoredUsers(user);
+                Q_EMIT room->showMessage(NeoChatRoom::Positive, i18nc("<username> is no longer ignored.", "%1 is no longer ignored.", text));
+            } else {
+                Q_EMIT room->showMessage(NeoChatRoom::Error, i18nc("<username> is not a known user", "%1 is not a known user.", text));
+            }
+            return QString();
+        },
+        false,
+        std::nullopt,
+        kli18n("<user id>"),
+        kli18n("Unignores the given user"),
+    },
+    Action{
+        QStringLiteral("react"),
+        [](const QString &text, NeoChatRoom *room) {
+            QString replyEventId = room->chatBoxReplyId();
+            if (replyEventId.isEmpty()) {
+                for (auto it = room->messageEvents().crbegin(); it != room->messageEvents().crend(); it++) {
+                    const auto &evt = **it;
+                    if (const auto event = eventCast<const RoomMessageEvent>(&evt)) {
+                        room->toggleReaction(event->id(), text);
+                        return QString();
+                    }
+                }
+            }
+            room->toggleReaction(replyEventId, text);
+            return QString();
+        },
+        false,
+        std::nullopt,
+        kli18n("<reaction text>"),
+        kli18n("React to the message with the given text"),
+    },
+    Action{
+        QStringLiteral("ban"),
+        [](const QString &text, NeoChatRoom *room) {
+            auto parts = text.split(QLatin1String(" "));
+            static const QRegularExpression mxidRegex(
+                QStringLiteral(R"((^|[][[:space:](){}`'";])([!#@][-a-z0-9_=#/.]{1,252}:\w(?:\w|\.|-)*\.\w+(?::\d{1,5})?))"));
+            auto regexMatch = mxidRegex.match(parts[0]);
+            if (!regexMatch.hasMatch()) {
+                Q_EMIT room->showMessage(NeoChatRoom::Error, i18nc("'<text>' does not look like a matrix id.", "'%1' does not look like a matrix id.", text));
+                return QString();
+            }
+#ifdef QUOTIENT_07
+            auto state = room->currentState().get<RoomMemberEvent>(parts[0]);
+            if (state && state->membership() == Membership::Ban) {
+                Q_EMIT room->showMessage(NeoChatRoom::Info, i18nc("<user> is already banned from this room.", "%1 is already banned from this room.", text));
+                return QString();
+            }
+#endif
+            auto plEvent = room->getCurrentState<RoomPowerLevelsEvent>();
+            if (plEvent->ban() > plEvent->powerLevelForUser(room->localUser()->id())) {
+                Q_EMIT room->showMessage(NeoChatRoom::Error, i18n("You are not allowed to ban users from this room."));
+                return QString();
+            }
+            if (plEvent->powerLevelForUser(room->localUser()->id()) <= plEvent->powerLevelForUser(parts[0])) {
+                Q_EMIT room->showMessage(
+                    NeoChatRoom::Error,
+                    i18nc("You are not allowed to ban <username> from this room.", "You are not allowed to ban %1 from this room.", parts[0]));
+                return QString();
+            }
+            room->ban(parts[0], parts.size() > 1 ? parts.mid(1).join(" ") : QString());
+            Q_EMIT room->showMessage(NeoChatRoom::Positive, i18nc("<username> was banned from this room.", "%1 was banned from this room.", parts[0]));
+            return QString();
+        },
+        false,
+        std::nullopt,
+        kli18n("<user id> [<reason>]"),
+        kli18n("Bans the given user"),
+    },
+    Action{
+        QStringLiteral("unban"),
+        [](const QString &text, NeoChatRoom *room) {
+            static const QRegularExpression mxidRegex(
+                QStringLiteral(R"((^|[][[:space:](){}`'";])([!#@][-a-z0-9_=#/.]{1,252}:\w(?:\w|\.|-)*\.\w+(?::\d{1,5})?))"));
+            auto regexMatch = mxidRegex.match(text);
+            if (!regexMatch.hasMatch()) {
+                Q_EMIT room->showMessage(NeoChatRoom::Error, i18nc("'<text>' does not look like a matrix id.", "'%1' does not look like a matrix id.", text));
+                return QString();
+            }
+            auto plEvent = room->getCurrentState<RoomPowerLevelsEvent>();
+            if (plEvent->ban() > plEvent->powerLevelForUser(room->localUser()->id())) {
+                Q_EMIT room->showMessage(NeoChatRoom::Error, i18n("You are not allowed to unban users from this room."));
+                return QString();
+            }
+#ifdef QUOTIENT_07
+            auto state = room->currentState().get<RoomMemberEvent>(text);
+            if (state && state->membership() != Membership::Ban) {
+                Q_EMIT room->showMessage(NeoChatRoom::Info, i18nc("<user> is not banned from this room.", "%1 is not banned from this room.", text));
+                return QString();
+            }
+#endif
+            room->unban(text);
+            Q_EMIT room->showMessage(NeoChatRoom::Positive, i18nc("<username> was unbanned from this room.", "%1 was unbanned from this room.", text));
+
+            return QString();
+        },
+        false,
+        std::nullopt,
+        kli18n("<user id>"),
+        kli18n("Removes the ban of the given user"),
+    },
+    Action{
+        QStringLiteral("kick"),
+        [](const QString &text, NeoChatRoom *room) {
+            auto parts = text.split(QLatin1String(" "));
+            static const QRegularExpression mxidRegex(
+                QStringLiteral(R"((^|[][[:space:](){}`'";])([!#@][-a-z0-9_=#/.]{1,252}:\w(?:\w|\.|-)*\.\w+(?::\d{1,5})?))"));
+            auto regexMatch = mxidRegex.match(parts[0]);
+            if (!regexMatch.hasMatch()) {
+                Q_EMIT room->showMessage(NeoChatRoom::Error,
+                                         i18nc("'<text>' does not look like a matrix id.", "'%1' does not look like a matrix id.", parts[0]));
+                return QString();
+            }
+            if (parts[0] == room->localUser()->id()) {
+                Q_EMIT room->showMessage(NeoChatRoom::Error, i18n("You cannot kick yourself from the room."));
+                return QString();
+            }
+#ifdef QUOTIENT_07
+            if (!room->isMember(parts[0])) {
+                Q_EMIT room->showMessage(NeoChatRoom::Error, i18nc("<username> is not in this room", "%1 is not in this room.", parts[0]));
+                return QString();
+            }
+#endif
+            auto plEvent = room->getCurrentState<RoomPowerLevelsEvent>();
+            auto kick = plEvent->kick();
+            if (plEvent->powerLevelForUser(room->localUser()->id()) < kick) {
+                Q_EMIT room->showMessage(NeoChatRoom::Error, i18n("You are not allowed to kick users from this room."));
+                return QString();
+            }
+            if (plEvent->powerLevelForUser(room->localUser()->id()) <= plEvent->powerLevelForUser(parts[0])) {
+                Q_EMIT room->showMessage(
+                    NeoChatRoom::Error,
+                    i18nc("You are not allowed to kick <username> from this room", "You are not allowed to kick %1 from this room.", parts[0]));
+                return QString();
+            }
+            room->kickMember(parts[0], parts.size() > 1 ? parts.mid(1).join(" ") : QString());
+            Q_EMIT room->showMessage(NeoChatRoom::Positive, i18nc("<username> was kicked from this room.", "%1 was kicked from this room.", parts[0]));
+            return QString();
+        },
+        false,
+        std::nullopt,
+        kli18n("<user id> [<reason>]"),
+        kli18n("Removes the user from the room"),
+    },
+};
+
+int ActionsModel::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent);
+    return actions.size();
+}
+
+QVariant ActionsModel::data(const QModelIndex &index, int role) const
+{
+    if (index.row() < 0 || index.row() >= actions.size()) {
+        return {};
+    }
+    if (role == Prefix) {
+        return actions[index.row()].prefix;
+    }
+    if (role == Description) {
+        return actions[index.row()].description.toString();
+    }
+    if (role == CompletionType) {
+        return QStringLiteral("action");
+    }
+    if (role == Parameters) {
+        return actions[index.row()].parameters.toString();
+    }
+    return {};
+}
+
+QHash<int, QByteArray> ActionsModel::roleNames() const
+{
+    return {
+        {Prefix, "prefix"},
+        {Description, "description"},
+        {CompletionType, "completionType"},
+    };
+}
+
+QVector<Action> &ActionsModel::allActions() const
+{
+    return actions;
+}

src/models/actionsmodel.h

@@ -0,0 +1,49 @@
+// SPDX-FileCopyrightText: 2022 Tobias Fella <fella@posteo.de>
+// SPDX-License-Identifier: LGPL-2.0-or-later
+
+#pragma once
+
+#include <KLazyLocalizedString>
+#include <QAbstractListModel>
+#include <events/roommessageevent.h>
+
+class NeoChatRoom;
+
+class ActionsModel : public QAbstractListModel
+{
+public:
+    struct Action {
+        // The prefix, without '/' and space after the word
+        QString prefix;
+        std::function<QString(const QString &, NeoChatRoom *)> handle;
+        // If this is true, this action transforms a message to a different message and it will be sent.
+        // If this is false, this message does some action on the client and should not be sent as a message.
+        bool messageAction;
+        // If this action changes the message type, this is the new message type. Otherwise it's nullopt
+        std::optional<Quotient::RoomMessageEvent::MsgType> messageType = std::nullopt;
+        KLazyLocalizedString parameters;
+        KLazyLocalizedString description;
+    };
+    static ActionsModel &instance()
+    {
+        static ActionsModel _instance;
+        return _instance;
+    }
+
+    enum Roles {
+        Prefix = Qt::DisplayRole,
+        Description,
+        CompletionType,
+        Parameters,
+    };
+    Q_ENUM(Roles);
+
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+    QHash<int, QByteArray> roleNames() const override;
+
+    QVector<Action> &allActions() const;
+
+private:
+    ActionsModel() = default;
+};

src/models/collapsestateproxymodel.cpp

@@ -0,0 +1,85 @@
+// SPDX-FileCopyrightText: 2022 Tobias Fella <fella@posteo.de>
+// SPDX-License-Identifier: LGPL-2.0-or-later
+
+#include "collapsestateproxymodel.h"
+
+#include <KLocalizedString>
+
+bool CollapseStateProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
+{
+    Q_UNUSED(source_parent);
+    return sourceModel()->data(sourceModel()->index(source_row, 0), MessageEventModel::EventTypeRole)
+        != MessageEventModel::DelegateType::State // If this is not a state, show it
+        || sourceModel()->data(sourceModel()->index(source_row + 1, 0), MessageEventModel::EventTypeRole)
+        != MessageEventModel::DelegateType::State // If this is the first state in a block, show it. TODO hidden events?
+        || sourceModel()->data(sourceModel()->index(source_row, 0), MessageEventModel::ShowSectionRole).toBool() // If it's a new day, show it
+        || sourceModel()->data(sourceModel()->index(source_row, 0), MessageEventModel::EventResolvedTypeRole)
+        != sourceModel()->data(sourceModel()->index(source_row + 1, 0),
+                               MessageEventModel::EventResolvedTypeRole) // Also show it if it's of a different type than the one before TODO improve in
+        || sourceModel()->data(sourceModel()->index(source_row, 0), MessageEventModel::AuthorIdRole)
+        != sourceModel()->data(sourceModel()->index(source_row + 1, 0), MessageEventModel::AuthorIdRole); // Also show it if it's a different author
+}
+
+QVariant CollapseStateProxyModel::data(const QModelIndex &index, int role) const
+{
+    if (role == AggregateDisplayRole) {
+        return aggregateEventToString(mapToSource(index).row());
+    }
+    return sourceModel()->data(mapToSource(index), role);
+}
+
+QHash<int, QByteArray> CollapseStateProxyModel::roleNames() const
+{
+    auto roles = sourceModel()->roleNames();
+    roles[AggregateDisplayRole] = "aggregateDisplay";
+    return roles;
+}
+
+QString CollapseStateProxyModel::aggregateEventToString(int sourceRow) const
+{
+    QStringList parts;
+    for (int i = sourceRow; i >= 0; i--) {
+        parts += sourceModel()->data(sourceModel()->index(i, 0), Qt::DisplayRole).toString();
+        if (sourceModel()->data(sourceModel()->index(i, 0), MessageEventModel::EventTypeRole)
+                != MessageEventModel::DelegateType::State // If it's not a state event
+            || (i > 0
+                && sourceModel()->data(sourceModel()->index(i, 0), MessageEventModel::EventResolvedTypeRole)
+                    != sourceModel()->data(sourceModel()->index(i - 1, 0), MessageEventModel::EventResolvedTypeRole)) // or of a different type
+            || (i > 0
+                && sourceModel()->data(sourceModel()->index(i, 0), MessageEventModel::AuthorIdRole)
+                    != sourceModel()->data(sourceModel()->index(i - 1, 0), MessageEventModel::AuthorIdRole)) // or by a different author
+            || sourceModel()->data(sourceModel()->index(i - 1, 0), MessageEventModel::ShowSectionRole).toBool() // or the section needs to be visible
+        ) {
+            break;
+        }
+    }
+    if (!parts.isEmpty()) {
+        QStringList chunks;
+        while (!parts.isEmpty()) {
+            chunks += QString();
+            int count = 1;
+            auto part = parts.takeFirst();
+            chunks.last() += part;
+            while (!parts.isEmpty() && parts.first() == part) {
+                parts.removeFirst();
+                count++;
+            }
+            if (count > 1) {
+                chunks.last() += i18ncp("[user did something] n times", " %1 time", " %1 times", count);
+            }
+        }
+        QString text = chunks.takeFirst();
+
+        if (chunks.size() > 0) {
+            while (chunks.size() > 1) {
+                text += i18nc("[action 1], [action 2 and action 3]", ", ");
+                text += chunks.takeFirst();
+            }
+            text += i18nc("[action 1, action 2] and [action 3]", " and ");
+            text += chunks.takeFirst();
+        }
+        return text;
+    } else {
+        return {};
+    }
+}

src/models/collapsestateproxymodel.h

@@ -0,0 +1,21 @@
+// SPDX-FileCopyrightText: 2022 Tobias Fella <fella@posteo.de>
+// SPDX-License-Identifier: LGPL-2.0-or-later
+
+#pragma once
+
+#include "messageeventmodel.h"
+#include <QSortFilterProxyModel>
+
+class CollapseStateProxyModel : public QSortFilterProxyModel
+{
+    Q_OBJECT
+public:
+    enum Roles {
+        AggregateDisplayRole = MessageEventModel::LastRole + 1,
+    };
+    [[nodiscard]] bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const override;
+    [[nodiscard]] QHash<int, QByteArray> roleNames() const override;
+    [[nodiscard]] QVariant data(const QModelIndex &idx, int role = Qt::DisplayRole) const override;
+
+    [[nodiscard]] QString aggregateEventToString(int row) const;
+};

src/models/completionmodel.cpp

@@ -0,0 +1,196 @@
+// SPDX-FileCopyrightText: 2022 Tobias Fella <fella@posteo.de>
+// SPDX-License-Identifier: LGPL-2.0-or-later
+
+#include "completionmodel.h"
+#include <QDebug>
+
+#include "actionsmodel.h"
+#include "chatdocumenthandler.h"
+#include "completionproxymodel.h"
+#include "customemojimodel.h"
+#include "emojimodel.h"
+#include "neochatroom.h"
+#include "userlistmodel.h"
+
+CompletionModel::CompletionModel(QObject *parent)
+    : QAbstractListModel(parent)
+    , m_filterModel(new CompletionProxyModel())
+    , m_userListModel(new UserListModel(this))
+    , m_emojiModel(new KConcatenateRowsProxyModel(this))
+{
+    connect(this, &CompletionModel::textChanged, this, &CompletionModel::updateCompletion);
+    connect(this, &CompletionModel::roomChanged, this, [this]() {
+        m_userListModel->setRoom(m_room);
+    });
+    m_emojiModel->addSourceModel(&CustomEmojiModel::instance());
+    m_emojiModel->addSourceModel(&EmojiModel::instance());
+}
+
+QString CompletionModel::text() const
+{
+    return m_text;
+}
+
+void CompletionModel::setText(const QString &text, const QString &fullText)
+{
+    m_text = text;
+    m_fullText = fullText;
+    Q_EMIT textChanged();
+}
+
+int CompletionModel::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent);
+    if (m_autoCompletionType == None) {
+        return 0;
+    }
+    return m_filterModel->rowCount();
+}
+
+QVariant CompletionModel::data(const QModelIndex &index, int role) const
+{
+    if (index.row() < 0 || index.row() >= m_filterModel->rowCount()) {
+        return {};
+    }
+    auto filterIndex = m_filterModel->index(index.row(), 0);
+    if (m_autoCompletionType == User) {
+        if (role == Text) {
+            return m_filterModel->data(filterIndex, UserListModel::NameRole);
+        }
+        if (role == Subtitle) {
+            return m_filterModel->data(filterIndex, UserListModel::UserIdRole);
+        }
+        if (role == Icon) {
+            return m_filterModel->data(filterIndex, UserListModel::AvatarRole);
+        }
+    }
+
+    if (m_autoCompletionType == Command) {
+        if (role == Text) {
+            return m_filterModel->data(filterIndex, ActionsModel::Prefix).toString() + QStringLiteral(" ")
+                + m_filterModel->data(filterIndex, ActionsModel::Parameters).toString();
+        }
+        if (role == Subtitle) {
+            return m_filterModel->data(filterIndex, ActionsModel::Description);
+        }
+        if (role == Icon) {
+            return QStringLiteral("invalid");
+        }
+        if (role == ReplacedText) {
+            return m_filterModel->data(filterIndex, ActionsModel::Prefix);
+        }
+    }
+    if (m_autoCompletionType == Room) {
+        if (role == Text) {
+            return m_filterModel->data(filterIndex, RoomListModel::DisplayNameRole);
+        }
+        if (role == Subtitle) {
+            return m_filterModel->data(filterIndex, RoomListModel::CanonicalAliasRole);
+        }
+        if (role == Icon) {
+            return m_filterModel->data(filterIndex, RoomListModel::AvatarRole);
+        }
+    }
+    if (m_autoCompletionType == Emoji) {
+        if (role == Text) {
+            return m_filterModel->data(filterIndex, CustomEmojiModel::DisplayRole);
+        }
+        if (role == Icon) {
+            return m_filterModel->data(filterIndex, CustomEmojiModel::MxcUrl);
+        }
+        if (role == ReplacedText) {
+            return m_filterModel->data(filterIndex, CustomEmojiModel::ReplacedTextRole);
+        }
+        if (role == Subtitle) {
+            return m_filterModel->data(filterIndex, EmojiModel::DescriptionRole);
+        }
+    }
+
+    return {};
+}
+
+QHash<int, QByteArray> CompletionModel::roleNames() const
+{
+    return {
+        {Text, "text"},
+        {Subtitle, "subtitle"},
+        {Icon, "icon"},
+        {ReplacedText, "replacedText"},
+    };
+}
+
+void CompletionModel::updateCompletion()
+{
+    if (text().startsWith(QLatin1Char('@'))) {
+        m_filterModel->setSourceModel(m_userListModel);
+        m_filterModel->setFilterRole(UserListModel::UserIdRole);
+        m_filterModel->setSecondaryFilterRole(UserListModel::NameRole);
+        m_filterModel->setFullText(m_fullText);
+        m_filterModel->setFilterText(m_text);
+        m_autoCompletionType = User;
+        m_filterModel->invalidate();
+    } else if (text().startsWith(QLatin1Char('/'))) {
+        m_filterModel->setSourceModel(&ActionsModel::instance());
+        m_filterModel->setFilterRole(ActionsModel::Prefix);
+        m_filterModel->setSecondaryFilterRole(-1);
+        m_filterModel->setFullText(m_fullText);
+        m_filterModel->setFilterText(m_text.mid(1));
+        m_autoCompletionType = Command;
+        m_filterModel->invalidate();
+    } else if (text().startsWith(QLatin1Char('#'))) {
+        m_autoCompletionType = Room;
+        m_filterModel->setSourceModel(m_roomListModel);
+        m_filterModel->setFilterRole(RoomListModel::CanonicalAliasRole);
+        m_filterModel->setSecondaryFilterRole(RoomListModel::DisplayNameRole);
+        m_filterModel->setFullText(m_fullText);
+        m_filterModel->setFilterText(m_text);
+        m_filterModel->invalidate();
+    } else if (text().startsWith(QLatin1Char(':'))
+               && (m_fullText.indexOf(QLatin1Char(':'), 1) == -1
+                   || (m_fullText.indexOf(QLatin1Char(' ')) != -1 && m_fullText.indexOf(QLatin1Char(':'), 1) > m_fullText.indexOf(QLatin1Char(' '), 1)))) {
+        m_filterModel->setSourceModel(m_emojiModel);
+        m_autoCompletionType = Emoji;
+        m_filterModel->setFilterRole(CustomEmojiModel::Name);
+        m_filterModel->setSecondaryFilterRole(EmojiModel::DescriptionRole);
+        m_filterModel->setFullText(m_fullText);
+        m_filterModel->setFilterText(m_text);
+        m_filterModel->invalidate();
+    } else {
+        m_autoCompletionType = None;
+    }
+    beginResetModel();
+    endResetModel();
+}
+
+NeoChatRoom *CompletionModel::room() const
+{
+    return m_room;
+}
+
+void CompletionModel::setRoom(NeoChatRoom *room)
+{
+    m_room = room;
+    Q_EMIT roomChanged();
+}
+
+CompletionModel::AutoCompletionType CompletionModel::autoCompletionType() const
+{
+    return m_autoCompletionType;
+}
+
+void CompletionModel::setAutoCompletionType(AutoCompletionType autoCompletionType)
+{
+    m_autoCompletionType = autoCompletionType;
+    Q_EMIT autoCompletionTypeChanged();
+}
+
+RoomListModel *CompletionModel::roomListModel() const
+{
+    return m_roomListModel;
+}
+
+void CompletionModel::setRoomListModel(RoomListModel *roomListModel)
+{
+    m_roomListModel = roomListModel;
+    Q_EMIT roomListModelChanged();
+}

src/models/completionmodel.h

@@ -0,0 +1,80 @@
+// SPDX-FileCopyrightText: 2022 Tobias Fella <fella@posteo.de>
+// SPDX-License-Identifier: LGPL-2.0-or-later
+
+#pragma once
+
+#include <QSortFilterProxyModel>
+
+#include <KConcatenateRowsProxyModel>
+
+#include "roomlistmodel.h"
+
+class CompletionProxyModel;
+class UserListModel;
+class NeoChatRoom;
+class RoomListModel;
+
+class CompletionModel : public QAbstractListModel
+{
+    Q_OBJECT
+    Q_PROPERTY(QString text READ text NOTIFY textChanged)
+    Q_PROPERTY(NeoChatRoom *room READ room WRITE setRoom NOTIFY roomChanged)
+    Q_PROPERTY(AutoCompletionType autoCompletionType READ autoCompletionType NOTIFY autoCompletionTypeChanged);
+    Q_PROPERTY(RoomListModel *roomListModel READ roomListModel WRITE setRoomListModel NOTIFY roomListModelChanged);
+
+public:
+    enum AutoCompletionType {
+        User,
+        Room,
+        Emoji,
+        Command,
+        None,
+    };
+    Q_ENUM(AutoCompletionType)
+
+    enum Roles {
+        Text = Qt::DisplayRole,
+        Subtitle,
+        Icon,
+        ReplacedText,
+    };
+    Q_ENUM(Roles);
+
+    CompletionModel(QObject *parent = nullptr);
+
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+    QHash<int, QByteArray> roleNames() const override;
+
+    QString text() const;
+    void setText(const QString &text, const QString &fullText);
+    void updateCompletion();
+
+    NeoChatRoom *room() const;
+    void setRoom(NeoChatRoom *room);
+
+    RoomListModel *roomListModel() const;
+    void setRoomListModel(RoomListModel *roomListModel);
+
+    AutoCompletionType autoCompletionType() const;
+
+Q_SIGNALS:
+    void textChanged();
+    void roomChanged();
+    void autoCompletionTypeChanged();
+    void roomListModelChanged();
+
+private:
+    QString m_text;
+    QString m_fullText;
+    CompletionProxyModel *m_filterModel;
+    NeoChatRoom *m_room = nullptr;
+    AutoCompletionType m_autoCompletionType = None;
+
+    void setAutoCompletionType(AutoCompletionType autoCompletionType);
+
+    UserListModel *m_userListModel;
+    RoomListModel *m_roomListModel;
+    KConcatenateRowsProxyModel *m_emojiModel;
+};
+Q_DECLARE_METATYPE(CompletionModel::AutoCompletionType);

src/models/completionproxymodel.cpp

@@ -0,0 +1,64 @@
+// SPDX-FileCopyrightText: 2022 Tobias Fella <fella@posteo.de>
+// SPDX-License-Identifier: LGPL-2.0-or-later
+
+#include "completionproxymodel.h"
+#include <QDebug>
+
+#include "neochatroom.h"
+
+bool CompletionProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
+{
+    Q_UNUSED(sourceParent);
+    if (m_filterText.isEmpty()) {
+        return false;
+    }
+    return (sourceModel()->data(sourceModel()->index(sourceRow, 0), filterRole()).toString().startsWith(m_filterText, Qt::CaseInsensitive)
+            && !m_fullText.startsWith(sourceModel()->data(sourceModel()->index(sourceRow, 0), filterRole()).toString()))
+        || (m_secondaryFilterRole != -1
+            && sourceModel()
+                   ->data(sourceModel()->index(sourceRow, 0), secondaryFilterRole())
+                   .toString()
+#if QT_VERSION > QT_VERSION_CHECK(6, 0, 0)
+                   .startsWith(QStringView(m_filterText).sliced(1), Qt::CaseInsensitive));
+#else
+                   .startsWith(m_filterText.midRef(1), Qt::CaseInsensitive));
+#endif
+}
+
+bool CompletionProxyModel::lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const
+{
+    if (m_secondaryFilterRole == -1)
+        return QSortFilterProxyModel::lessThan(source_left, source_right);
+    bool left_primary = sourceModel()->data(source_left, filterRole()).toString().startsWith(m_filterText, Qt::CaseInsensitive);
+    bool right_primary = sourceModel()->data(source_right, filterRole()).toString().startsWith(m_filterText, Qt::CaseInsensitive);
+    if (left_primary != right_primary)
+        return left_primary;
+    return QSortFilterProxyModel::lessThan(source_left, source_right);
+}
+
+int CompletionProxyModel::secondaryFilterRole() const
+{
+    return m_secondaryFilterRole;
+}
+
+void CompletionProxyModel::setSecondaryFilterRole(int role)
+{
+    m_secondaryFilterRole = role;
+    Q_EMIT secondaryFilterRoleChanged();
+}
+
+QString CompletionProxyModel::filterText() const
+{
+    return m_filterText;
+}
+
+void CompletionProxyModel::setFilterText(const QString &filterText)
+{
+    m_filterText = filterText;
+    Q_EMIT filterTextChanged();
+}
+
+void CompletionProxyModel::setFullText(const QString &fullText)
+{
+    m_fullText = fullText;
+}

src/models/completionproxymodel.h

@@ -0,0 +1,34 @@
+// SPDX-FileCopyrightText: 2022 Tobias Fella <fella@posteo.de>
+// SPDX-License-Identifier: LGPL-2.0-or-later
+
+#pragma once
+
+#include <QSortFilterProxyModel>
+
+class CompletionProxyModel : public QSortFilterProxyModel
+{
+    Q_OBJECT
+    Q_PROPERTY(int secondaryFilterRole READ secondaryFilterRole WRITE setSecondaryFilterRole NOTIFY secondaryFilterRoleChanged)
+    Q_PROPERTY(QString filterText READ filterText WRITE setFilterText NOTIFY filterTextChanged)
+
+public:
+    bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
+    bool lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const override;
+
+    int secondaryFilterRole() const;
+    void setSecondaryFilterRole(int role);
+
+    QString filterText() const;
+    void setFilterText(const QString &filterText);
+
+    void setFullText(const QString &fullText);
+
+Q_SIGNALS:
+    void secondaryFilterRoleChanged();
+    void filterTextChanged();
+
+private:
+    int m_secondaryFilterRole = -1;
+    QString m_filterText;
+    QString m_fullText;
+};

src/models/customemojimodel.cpp

@@ -0,0 +1,196 @@
+// SPDX-FileCopyrightText: 2021 Carson Black <uhhadd@gmail.com>
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "customemojimodel.h"
+#include "controller.h"
+#include "emojimodel.h"
+
+#include <connection.h>
+#include <csapi/account-data.h>
+#include <csapi/content-repo.h>
+
+using namespace Quotient;
+
+#ifdef QUOTIENT_07
+#define running isJobPending
+#else
+#define running isJobRunning
+#endif
+
+void CustomEmojiModel::fetchEmojis()
+{
+    if (!Controller::instance().activeConnection()) {
+        return;
+    }
+
+    const auto &data = Controller::instance().activeConnection()->accountData("im.ponies.user_emotes");
+    if (data == nullptr) {
+        return;
+    }
+    QJsonObject emojis = data->contentJson()["images"].toObject();
+
+    // TODO: Remove with stable migration
+    const auto legacyEmojis = data->contentJson()["emoticons"].toObject();
+    for (const auto &emoji : legacyEmojis.keys()) {
+        if (!emojis.contains(emoji)) {
+            emojis[emoji] = legacyEmojis[emoji];
+        }
+    }
+
+    beginResetModel();
+    m_emojis.clear();
+
+    for (const auto &emoji : emojis.keys()) {
+        const auto &data = emojis[emoji];
+
+        const auto e = emoji.startsWith(":") ? emoji : (QStringLiteral(":") + emoji + QStringLiteral(":"));
+
+        m_emojis << CustomEmoji{e, data.toObject()["url"].toString(), QRegularExpression(e)};
+    }
+
+    endResetModel();
+}
+
+void CustomEmojiModel::addEmoji(const QString &name, const QUrl &location)
+{
+    using namespace Quotient;
+
+    auto job = Controller::instance().activeConnection()->uploadFile(location.toLocalFile());
+
+    if (running(job)) {
+        connect(job, &BaseJob::success, this, [this, name, job] {
+            const auto &data = Controller::instance().activeConnection()->accountData("im.ponies.user_emotes");
+            auto json = data != nullptr ? data->contentJson() : QJsonObject();
+            auto emojiData = json["images"].toObject();
+            emojiData[QStringLiteral("%1").arg(name)] = QJsonObject({
+#ifdef QUOTIENT_07
+                {QStringLiteral("url"), job->contentUri().toString()}
+#else
+          {QStringLiteral("url"), job->contentUri()}
+#endif
+            });
+            json["images"] = emojiData;
+            Controller::instance().activeConnection()->setAccountData("im.ponies.user_emotes", json);
+        });
+    }
+}
+
+void CustomEmojiModel::removeEmoji(const QString &name)
+{
+    using namespace Quotient;
+
+    const auto &data = Controller::instance().activeConnection()->accountData("im.ponies.user_emotes");
+    Q_ASSERT(data);
+    auto json = data->contentJson();
+    const QString _name = name.mid(1).chopped(1);
+    auto emojiData = json["images"].toObject();
+
+    if (emojiData.contains(name)) {
+        emojiData.remove(name);
+        json["images"] = emojiData;
+    }
+    if (emojiData.contains(_name)) {
+        emojiData.remove(_name);
+        json["images"] = emojiData;
+    }
+    emojiData = json["emoticons"].toObject();
+    if (emojiData.contains(name)) {
+        emojiData.remove(name);
+        json["emoticons"] = emojiData;
+    }
+    if (emojiData.contains(_name)) {
+        emojiData.remove(_name);
+        json["emoticons"] = emojiData;
+    }
+    Controller::instance().activeConnection()->setAccountData("im.ponies.user_emotes", json);
+}
+
+CustomEmojiModel::CustomEmojiModel(QObject *parent)
+    : QAbstractListModel(parent)
+{
+    connect(&Controller::instance(), &Controller::activeConnectionChanged, this, [this]() {
+        if (!Controller::instance().activeConnection()) {
+            return;
+        }
+        CustomEmojiModel::fetchEmojis();
+        connect(Controller::instance().activeConnection(), &Connection::accountDataChanged, this, [this](const QString &id) {
+            if (id != QStringLiteral("im.ponies.user_emotes")) {
+                return;
+            }
+            fetchEmojis();
+        });
+    });
+}
+
+QVariant CustomEmojiModel::data(const QModelIndex &idx, int role) const
+{
+    const auto row = idx.row();
+    if (row >= m_emojis.length()) {
+        return QVariant();
+    }
+    const auto &data = m_emojis[row];
+
+    switch (Roles(role)) {
+    case Roles::ModelData:
+        return QVariant::fromValue(Emoji(QStringLiteral("image://mxc/") + data.url.mid(6), data.name, true));
+    case Roles::Name:
+    case Roles::DisplayRole:
+    case Roles::ReplacedTextRole:
+        return data.name;
+    case Roles::ImageURL:
+        return QUrl(QStringLiteral("image://mxc/") + data.url.mid(6));
+    case Roles::MxcUrl:
+        return data.url.mid(6);
+    }
+
+    return QVariant();
+}
+
+int CustomEmojiModel::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent)
+
+    return m_emojis.length();
+}
+
+QHash<int, QByteArray> CustomEmojiModel::roleNames() const
+{
+    return {
+        {Name, "name"},
+        {ImageURL, "imageURL"},
+        {ModelData, "modelData"},
+        {MxcUrl, "mxcUrl"},
+    };
+}
+
+QString CustomEmojiModel::preprocessText(const QString &text)
+{
+    auto parts = text.split("```");
+    bool skip = true;
+    for (auto &part : parts) {
+        skip = !skip;
+        if (skip) {
+            continue;
+        }
+        for (const auto &emoji : std::as_const(m_emojis)) {
+            part.replace(
+                emoji.regexp,
+                QStringLiteral(R"(<img data-mx-emoticon="" src="%1" alt="%2" title="%2" height="32" vertical-align="middle" />)").arg(emoji.url, emoji.name));
+        }
+    }
+    return parts.join("```");
+}
+
+QVariantList CustomEmojiModel::filterModel(const QString &filter)
+{
+    QVariantList results;
+    for (const auto &emoji : std::as_const(m_emojis)) {
+        if (results.length() >= 10)
+            break;
+        if (!emoji.name.contains(filter, Qt::CaseInsensitive))
+            continue;
+
+        results << QVariant::fromValue(Emoji(QStringLiteral("image://mxc/") + emoji.url.mid(6), emoji.name, true));
+    }
+    return results;
+}

src/models/customemojimodel.h

@@ -0,0 +1,57 @@
+// SPDX-FileCopyrightText: 2021 Carson Black <uhhadd@gmail.com>
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <QAbstractListModel>
+#include <QRegularExpression>
+#include <memory>
+
+struct CustomEmoji {
+    QString name; // with :semicolons:
+    QString url; // mxc://
+    QRegularExpression regexp;
+
+    Q_GADGET
+    Q_PROPERTY(QString unicode MEMBER url)
+    Q_PROPERTY(QString name MEMBER name)
+};
+
+class CustomEmojiModel : public QAbstractListModel
+{
+    Q_OBJECT
+
+public:
+    enum Roles {
+        Name = Qt::DisplayRole,
+        ImageURL,
+        ModelData, // for emulating the regular emoji model's usage, otherwise the UI code would get too complicated
+        MxcUrl = 50,
+        DisplayRole = 51,
+        ReplacedTextRole = 52,
+        DescriptionRole = 53, // also invalid, reserved
+    };
+    Q_ENUM(Roles);
+
+    static CustomEmojiModel &instance()
+    {
+        static CustomEmojiModel _instance;
+        return _instance;
+    }
+
+    QVariant data(const QModelIndex &idx, int role = Qt::DisplayRole) const override;
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+
+    QHash<int, QByteArray> roleNames() const override;
+
+    Q_INVOKABLE QString preprocessText(const QString &it);
+    Q_INVOKABLE QVariantList filterModel(const QString &filter);
+    Q_INVOKABLE void addEmoji(const QString &name, const QUrl &location);
+    Q_INVOKABLE void removeEmoji(const QString &name);
+
+private:
+    explicit CustomEmojiModel(QObject *parent = nullptr);
+    QList<CustomEmoji> m_emojis;
+
+    void fetchEmojis();
+};

src/models/customemojimodel_p.h

@@ -0,0 +1,19 @@
+// SPDX-FileCopyrightText: 2021 Carson Black <uhhadd@gmail.com>
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "customemojimodel.h"
+#include <QRegularExpression>
+#include <connection.h>
+
+struct CustomEmoji {
+    QString name; // with :semicolons:
+    QString url; // mxc://
+    QRegularExpression regexp;
+};
+
+struct CustomEmojiModel::Private {
+    Quotient::Connection *conn = nullptr;
+    QList<CustomEmoji> emojies;
+};

src/models/devicesmodel.cpp

@@ -0,0 +1,108 @@
+// SPDX-FileCopyrightText: Tobias Fella <fella@posteo.de>
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "devicesmodel.h"
+
+#include <csapi/device_management.h>
+
+#include "controller.h"
+#include <connection.h>
+#include <user.h>
+
+using namespace Quotient;
+
+DevicesModel::DevicesModel(QObject *parent)
+    : QAbstractListModel(parent)
+{
+    connect(&Controller::instance(), &Controller::activeConnectionChanged, this, [this]() {
+        DevicesModel::fetchDevices();
+        Q_EMIT connectionChanged();
+    });
+
+    fetchDevices();
+}
+
+void DevicesModel::fetchDevices()
+{
+    if (Controller::instance().activeConnection()) {
+        auto job = Controller::instance().activeConnection()->callApi<GetDevicesJob>();
+        connect(job, &BaseJob::success, this, [this, job]() {
+            beginResetModel();
+            m_devices = job->devices();
+            endResetModel();
+        });
+    }
+}
+
+QVariant DevicesModel::data(const QModelIndex &index, int role) const
+{
+    if (index.row() < 0 || index.row() >= rowCount(QModelIndex())) {
+        return {};
+    }
+
+    switch (role) {
+    case Id:
+        return m_devices[index.row()].deviceId;
+    case DisplayName:
+        return m_devices[index.row()].displayName;
+    case LastIp:
+        return m_devices[index.row()].lastSeenIp;
+    case LastTimestamp:
+        if (m_devices[index.row()].lastSeenTs)
+            return *m_devices[index.row()].lastSeenTs;
+    }
+    return {};
+}
+
+int DevicesModel::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent);
+    return m_devices.size();
+}
+
+QHash<int, QByteArray> DevicesModel::roleNames() const
+{
+    return {{Id, "id"}, {DisplayName, "displayName"}, {LastIp, "lastIp"}, {LastTimestamp, "lastTimestamp"}};
+}
+
+void DevicesModel::logout(int index, const QString &password)
+{
+    auto job = Controller::instance().activeConnection()->callApi<NeochatDeleteDeviceJob>(m_devices[index].deviceId);
+
+    connect(job, &BaseJob::result, this, [this, job, password, index] {
+        if (job->error() != 0) {
+            QJsonObject replyData = job->jsonData();
+            QJsonObject authData;
+            authData["session"] = replyData["session"];
+            authData["password"] = password;
+            authData["type"] = "m.login.password";
+            QJsonObject identifier = {{"type", "m.id.user"}, {"user", Controller::instance().activeConnection()->user()->id()}};
+            authData["identifier"] = identifier;
+            auto *innerJob = Controller::instance().activeConnection()->callApi<NeochatDeleteDeviceJob>(m_devices[index].deviceId, authData);
+            connect(innerJob, &BaseJob::success, this, [this, index]() {
+                beginRemoveRows(QModelIndex(), index, index);
+                m_devices.remove(index);
+                endRemoveRows();
+            });
+        }
+    });
+}
+
+void DevicesModel::setName(int index, const QString &name)
+{
+    auto job = Controller::instance().activeConnection()->callApi<UpdateDeviceJob>(m_devices[index].deviceId, name);
+    QString oldName = m_devices[index].displayName;
+    beginResetModel();
+    m_devices[index].displayName = name;
+    endResetModel();
+    connect(job, &BaseJob::failure, this, [this, index, oldName]() {
+        beginResetModel();
+        m_devices[index].displayName = oldName;
+        endResetModel();
+    });
+}
+
+Connection *DevicesModel::connection() const
+{
+    return Controller::instance().activeConnection();
+}

src/models/devicesmodel.h

@@ -0,0 +1,47 @@
+// SPDX-FileCopyrightText: Tobias Fella <fella@posteo.de>
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <QAbstractListModel>
+
+#include <csapi/definitions/client_device.h>
+
+namespace Quotient
+{
+class Connection;
+}
+
+class DevicesModel : public QAbstractListModel
+{
+    Q_OBJECT
+
+    Q_PROPERTY(Quotient::Connection *connection READ connection NOTIFY connectionChanged)
+
+public:
+    enum Roles {
+        Id,
+        DisplayName,
+        LastIp,
+        LastTimestamp,
+    };
+    Q_ENUM(Roles);
+
+    DevicesModel(QObject *parent = nullptr);
+
+    QVariant data(const QModelIndex &index, int role) const override;
+    QHash<int, QByteArray> roleNames() const override;
+    int rowCount(const QModelIndex &parent) const override;
+
+    Q_INVOKABLE void logout(int index, const QString &password);
+    Q_INVOKABLE void setName(int index, const QString &name);
+
+    Quotient::Connection *connection() const;
+
+Q_SIGNALS:
+    void connectionChanged();
+
+private:
+    void fetchDevices();
+    QVector<Quotient::Device> m_devices;
+};

src/models/emojimodel.cpp

@@ -0,0 +1,218 @@
+// SPDX-FileCopyrightText: 2017 Konstantinos Sideris <siderisk@auth.gr>
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <QVariant>
+
+#include "emojimodel.h"
+#include "emojitones.h"
+#include <QDebug>
+
+#include <algorithm>
+
+#include "customemojimodel.h"
+#include <KLocalizedString>
+
+EmojiModel::EmojiModel(QObject *parent)
+    : QAbstractListModel(parent)
+{
+    if (_emojis.isEmpty()) {
+#include "emojis.h"
+    }
+}
+
+int EmojiModel::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent);
+    int total = 0;
+    for (const auto &category : _emojis) {
+        total += category.count();
+    }
+    return total;
+}
+
+QVariant EmojiModel::data(const QModelIndex &index, int role) const
+{
+    auto row = index.row();
+    for (const auto &category : _emojis) {
+        if (row >= category.count()) {
+            row -= category.count();
+            continue;
+        }
+        auto emoji = category[row].value<Emoji>();
+        switch (role) {
+        case ShortNameRole:
+            return QStringLiteral(":%1:").arg(emoji.shortName);
+        case UnicodeRole:
+        case ReplacedTextRole:
+            return emoji.unicode;
+        case InvalidRole:
+            return QStringLiteral("invalid");
+        case DisplayRole:
+            return QStringLiteral("%2   :%1:").arg(emoji.shortName, emoji.unicode);
+        case DescriptionRole:
+            return emoji.description;
+        }
+    }
+    return {};
+}
+
+QHash<int, QByteArray> EmojiModel::roleNames() const
+{
+    return {{ShortNameRole, "shortName"}, {UnicodeRole, "unicode"}};
+}
+
+QVariantList EmojiModel::history() const
+{
+    return m_settings.value("Editor/emojis", QVariantList()).toList();
+}
+
+QVariantList EmojiModel::filterModel(const QString &filter, bool limit)
+{
+    auto emojis = CustomEmojiModel::instance().filterModel(filter);
+    emojis += filterModelNoCustom(filter, limit);
+    return emojis;
+}
+
+QVariantList EmojiModel::filterModelNoCustom(const QString &filter, bool limit)
+{
+    QVariantList result;
+
+    for (const auto &e : _emojis.values()) {
+        for (const auto &variant : e) {
+            const auto &emoji = qvariant_cast<Emoji>(variant);
+            if (emoji.shortName.contains(filter, Qt::CaseInsensitive)) {
+                result.append(variant);
+                if (result.length() > 10 && limit) {
+                    return result;
+                }
+            }
+        }
+    }
+    return result;
+}
+
+void EmojiModel::emojiUsed(const QVariant &modelData)
+{
+    QVariantList list = history();
+
+    auto it = list.begin();
+    while (it != list.end()) {
+        if ((*it).value<Emoji>().unicode == modelData.value<Emoji>().unicode) {
+            it = list.erase(it);
+        } else {
+            it++;
+        }
+    }
+
+    list.push_front(modelData);
+    m_settings.setValue("Editor/emojis", list);
+
+    Q_EMIT historyChanged();
+}
+
+QVariantList EmojiModel::emojis(Category category) const
+{
+    if (category == History) {
+        return history();
+    }
+    if (category == HistoryNoCustom) {
+        QVariantList list;
+        for (const auto &e : history()) {
+            auto emoji = qvariant_cast<Emoji>(e);
+            if (!emoji.isCustom) {
+                list.append(e);
+            }
+        }
+        return list;
+    }
+    if (category == Custom) {
+        return CustomEmojiModel::instance().filterModel({});
+    }
+    return _emojis[category];
+}
+
+QVariantList EmojiModel::tones(const QString &baseEmoji) const
+{
+    if (baseEmoji.endsWith("tone")) {
+        return EmojiTones::_tones.values(baseEmoji.split(":")[0]);
+    }
+    return EmojiTones::_tones.values(baseEmoji);
+}
+
+QHash<EmojiModel::Category, QVariantList> EmojiModel::_emojis;
+
+QVariantList EmojiModel::categories() const
+{
+    return QVariantList{
+        {QVariantMap{
+            {"category", EmojiModel::HistoryNoCustom},
+            {"name", i18nc("Previously used emojis", "History")},
+            {"emoji", QStringLiteral("⌛️")},
+        }},
+        {QVariantMap{
+            {"category", EmojiModel::Smileys},
+            {"name", i18nc("'Smileys' is a category of emoji", "Smileys")},
+            {"emoji", QStringLiteral("😏")},
+        }},
+        {QVariantMap{
+            {"category", EmojiModel::People},
+            {"name", i18nc("'People' is a category of emoji", "People")},
+            {"emoji", QStringLiteral("🙋‍♂️")},
+        }},
+        {QVariantMap{
+            {"category", EmojiModel::Nature},
+            {"name", i18nc("'Nature' is a category of emoji", "Nature")},
+            {"emoji", QStringLiteral("🌲")},
+        }},
+        {QVariantMap{
+            {"category", EmojiModel::Food},
+            {"name", i18nc("'Food' is a category of emoji", "Food")},
+            {"emoji", QStringLiteral("🍛")},
+        }},
+        {QVariantMap{
+            {"category", EmojiModel::Activities},
+            {"name", i18nc("'Activities' is a category of emoji", "Activities")},
+            {"emoji", QStringLiteral("🚁")},
+        }},
+        {QVariantMap{
+            {"category", EmojiModel::Travel},
+            {"name", i18nc("'Travel' is  a category of emoji", "Travel")},
+            {"emoji", QStringLiteral("🚅")},
+        }},
+        {QVariantMap{
+            {"category", EmojiModel::Objects},
+            {"name", i18nc("'Objects' is a category of emoji", "Objects")},
+            {"emoji", QStringLiteral("💡")},
+        }},
+        {QVariantMap{
+            {"category", EmojiModel::Symbols},
+            {"name", i18nc("'Symbols' is a category of emoji", "Symbols")},
+            {"emoji", QStringLiteral("🔣")},
+        }},
+        {QVariantMap{
+            {"category", EmojiModel::Flags},
+            {"name", i18nc("'Flags' is a category of emoji", "Flags")},
+            {"emoji", QStringLiteral("🏁")},
+        }},
+    };
+}
+
+QVariantList EmojiModel::categoriesWithCustom() const
+{
+    auto cats = categories();
+    cats.removeAt(0);
+    cats.insert(0,
+                QVariantMap{
+                    {"category", EmojiModel::History},
+                    {"name", i18nc("Previously used emojis", "History")},
+                    {"emoji", QStringLiteral("⌛️")},
+                });
+    cats.insert(1,
+                QVariantMap{
+                    {"category", EmojiModel::Custom},
+                    {"name", i18nc("'Custom' is a category of emoji", "Custom")},
+                    {"emoji", QStringLiteral("🖼️")},
+                });
+    ;
+    return cats;
+}

src/models/emojimodel.h

@@ -0,0 +1,125 @@
+// SPDX-FileCopyrightText: 2018 Black Hat <bhat@encom.eu.org>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#pragma once
+
+#include <QAbstractListModel>
+#include <QObject>
+#include <QSettings>
+
+struct Emoji {
+    Emoji(QString unicode, QString shortname, bool isCustom = false)
+        : unicode(std::move(unicode))
+        , shortName(std::move(shortname))
+        , isCustom(isCustom)
+    {
+    }
+    Emoji(QString unicode, QString shortname, QString description)
+        : unicode(std::move(unicode))
+        , shortName(std::move(shortname))
+        , description(std::move(description))
+    {
+    }
+    Emoji() = default;
+
+    friend QDataStream &operator<<(QDataStream &arch, const Emoji &object)
+    {
+        arch << object.unicode;
+        arch << object.shortName;
+        return arch;
+    }
+
+    friend QDataStream &operator>>(QDataStream &arch, Emoji &object)
+    {
+        arch >> object.unicode;
+        arch >> object.shortName;
+        object.isCustom = object.unicode.startsWith("image://");
+        return arch;
+    }
+
+    QString unicode;
+    QString shortName;
+    QString description;
+    bool isCustom = false;
+
+    Q_GADGET
+    Q_PROPERTY(QString unicode MEMBER unicode)
+    Q_PROPERTY(QString shortName MEMBER shortName)
+    Q_PROPERTY(QString description MEMBER description)
+    Q_PROPERTY(bool isCustom MEMBER isCustom)
+};
+
+Q_DECLARE_METATYPE(Emoji)
+
+class EmojiModel : public QAbstractListModel
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QVariantList history READ history NOTIFY historyChanged)
+    Q_PROPERTY(QVariantList categories READ categories CONSTANT)
+    Q_PROPERTY(QVariantList categoriesWithCustom READ categoriesWithCustom CONSTANT)
+
+public:
+    static EmojiModel &instance()
+    {
+        static EmojiModel _instance;
+        return _instance;
+    }
+
+    enum RoleNames {
+        ShortNameRole = Qt::DisplayRole,
+        UnicodeRole,
+        InvalidRole = 50,
+        DisplayRole = 51,
+        ReplacedTextRole = 52,
+        DescriptionRole = 53,
+    };
+    Q_ENUM(RoleNames);
+
+    enum Category {
+        Custom,
+        Search,
+        SearchNoCustom,
+        History,
+        HistoryNoCustom,
+        Smileys,
+        People,
+        Nature,
+        Food,
+        Activities,
+        Travel,
+        Objects,
+        Symbols,
+        Flags,
+        Component,
+    };
+    Q_ENUM(Category)
+
+    [[nodiscard]] int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+    [[nodiscard]] QVariant data(const QModelIndex &idx, int role = Qt::DisplayRole) const override;
+    [[nodiscard]] QHash<int, QByteArray> roleNames() const override;
+
+    Q_INVOKABLE QVariantList history() const;
+    Q_INVOKABLE static QVariantList filterModel(const QString &filter, bool limit = true);
+    Q_INVOKABLE static QVariantList filterModelNoCustom(const QString &filter, bool limit = true);
+
+    Q_INVOKABLE QVariantList emojis(Category category) const;
+
+    Q_INVOKABLE QVariantList tones(const QString &baseEmoji) const;
+
+    QVariantList categories() const;
+    QVariantList categoriesWithCustom() const;
+
+Q_SIGNALS:
+    void historyChanged();
+
+public Q_SLOTS:
+    void emojiUsed(const QVariant &modelData);
+
+private:
+    static QHash<Category, QVariantList> _emojis;
+
+    // TODO: Port away from QSettings
+    QSettings m_settings;
+    EmojiModel(QObject *parent = nullptr);
+};

src/models/keywordnotificationrulemodel.cpp

@@ -0,0 +1,110 @@
+// SPDX-FileCopyrightText: 2022 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 "keywordnotificationrulemodel.h"
+#include "controller.h"
+#include "notificationsmanager.h"
+
+#include <QDebug>
+#include <connection.h>
+#include <converters.h>
+#include <csapi/definitions/push_ruleset.h>
+#include <csapi/pushrules.h>
+#include <jobs/basejob.h>
+
+KeywordNotificationRuleModel::KeywordNotificationRuleModel(QObject *parent)
+    : QAbstractListModel(parent)
+{
+    if (Controller::instance().activeConnection()) {
+        controllerConnectionChanged();
+    }
+    connect(&Controller::instance(), &Controller::activeConnectionChanged, this, &KeywordNotificationRuleModel::controllerConnectionChanged);
+}
+
+void KeywordNotificationRuleModel::controllerConnectionChanged()
+{
+    connect(Controller::instance().activeConnection(), &Quotient::Connection::accountDataChanged, this, &KeywordNotificationRuleModel::updateNotificationRules);
+    updateNotificationRules("m.push_rules");
+}
+
+void KeywordNotificationRuleModel::updateNotificationRules(const QString &type)
+{
+    if (type != "m.push_rules") {
+        return;
+    }
+
+    const QJsonObject ruleDataJson = Controller::instance().activeConnection()->accountDataJson("m.push_rules");
+    const Quotient::PushRuleset ruleData = Quotient::fromJson<Quotient::PushRuleset>(ruleDataJson["global"].toObject());
+    const QVector<Quotient::PushRule> contentRules = ruleData.content;
+
+    beginResetModel();
+    m_notificationRules.clear();
+    for (const auto &i : contentRules) {
+        if (!m_notificationRules.contains(i.ruleId) && i.ruleId[0] != '.') {
+            m_notificationRules.append(i.ruleId);
+        }
+    }
+    endResetModel();
+}
+
+QVariant KeywordNotificationRuleModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid()) {
+        return {};
+    }
+
+    if (index.row() >= m_notificationRules.count()) {
+        qDebug() << "KeywordNotificationRuleModel, something's wrong: index.row() >= m_notificationRules.count()";
+        return {};
+    }
+
+    if (role == NameRole) {
+        return m_notificationRules.at(index.row());
+    }
+
+    return {};
+}
+
+int KeywordNotificationRuleModel::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent)
+
+    return m_notificationRules.count();
+}
+
+void KeywordNotificationRuleModel::addKeyword(const QString &keyword)
+{
+    if (m_notificationRules.count() == 0) {
+        NotificationsManager::instance().initializeKeywordNotificationAction();
+    }
+
+    const QVector<QVariant> actions = NotificationsManager::instance().getKeywordNotificationActions();
+
+    auto job = Controller::instance()
+                   .activeConnection()
+                   ->callApi<Quotient::SetPushRuleJob>("global", "content", keyword, actions, "", "", QVector<Quotient::PushCondition>(), keyword);
+    connect(job, &Quotient::BaseJob::success, this, [this, keyword]() {
+        beginInsertRows(QModelIndex(), m_notificationRules.count(), m_notificationRules.count());
+        m_notificationRules.append(keyword);
+        endInsertRows();
+    });
+}
+
+void KeywordNotificationRuleModel::removeKeywordAtIndex(int index)
+{
+    auto job = Controller::instance().activeConnection()->callApi<Quotient::DeletePushRuleJob>("global", "content", m_notificationRules[index]);
+    connect(job, &Quotient::BaseJob::success, this, [this, index]() {
+        beginRemoveRows(QModelIndex(), index, index);
+        m_notificationRules.removeAt(index);
+        endRemoveRows();
+
+        if (m_notificationRules.count() == 0) {
+            NotificationsManager::instance().deactivateKeywordNotificationAction();
+        }
+    });
+}
+
+QHash<int, QByteArray> KeywordNotificationRuleModel::roleNames() const
+{
+    return {{NameRole, QByteArrayLiteral("name")}};
+}

src/models/keywordnotificationrulemodel.h

@@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: 2022 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 <csapi/definitions/push_rule.h>
+
+#include <QAbstractListModel>
+
+class KeywordNotificationRuleModel : public QAbstractListModel
+{
+    Q_OBJECT
+
+public:
+    enum EventRoles {
+        NameRole = Qt::DisplayRole,
+    };
+
+    KeywordNotificationRuleModel(QObject *parent = nullptr);
+
+    [[nodiscard]] QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+    [[nodiscard]] int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+
+    [[nodiscard]] QHash<int, QByteArray> roleNames() const override;
+
+    Q_INVOKABLE void addKeyword(const QString &keyword);
+    Q_INVOKABLE void removeKeywordAtIndex(int index);
+
+private Q_SLOTS:
+    void controllerConnectionChanged();
+    void updateNotificationRules(const QString &type);
+
+private:
+    QList<QString> m_notificationRules;
+};

src/models/messageeventmodel.h

@@ -0,0 +1,125 @@
+// SPDX-FileCopyrightText: 2018-2019 Black Hat <bhat@encom.eu.org>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#pragma once
+
+#include <QAbstractListModel>
+
+#include "neochatroom.h"
+
+class MessageEventModel : public QAbstractListModel
+{
+    Q_OBJECT
+    Q_PROPERTY(NeoChatRoom *room READ room WRITE setRoom NOTIFY roomChanged)
+
+public:
+    enum DelegateType {
+        Emote,
+        Notice,
+        Image,
+        Audio,
+        Video,
+        File,
+        Message,
+        Sticker,
+        State,
+        Encrypted,
+        ReadMarker,
+        Poll,
+        Other,
+    };
+    Q_ENUM(DelegateType);
+
+    enum EventRoles {
+        EventTypeRole = Qt::UserRole + 1,
+        MessageRole,
+        EventIdRole,
+        TimeRole,
+        SectionRole,
+        AuthorRole,
+        ContentRole,
+        ContentTypeRole,
+        HighlightRole,
+        SpecialMarksRole,
+        LongOperationRole,
+        AnnotationRole,
+        UserMarkerRole,
+        FormattedBodyRole,
+
+        MimeTypeRole,
+        FileMimetypeIcon,
+
+        IsReplyRole,
+        ReplyRole,
+        ReplyIdRole,
+
+        ShowAuthorRole,
+        ShowSectionRole,
+
+        ReactionRole,
+
+        IsEditedRole,
+        SourceRole,
+        MediaUrlRole,
+        // For debugging
+        EventResolvedTypeRole,
+        AuthorIdRole,
+        VerifiedRole,
+        // Sender's displayname, always without the matrix id
+        DisplayNameForInitialsRole,
+        // The displayname for the event's sender; for name change events, the old displayname
+        AuthorDisplayNameRole,
+        IsNameChangeRole,
+        IsAvatarChangeRole,
+        IsRedactedRole,
+        LastRole, // Keep this last
+    };
+    Q_ENUM(EventRoles)
+
+    explicit MessageEventModel(QObject *parent = nullptr);
+    ~MessageEventModel() override;
+
+    [[nodiscard]] NeoChatRoom *room() const
+    {
+        return m_currentRoom;
+    }
+    void setRoom(NeoChatRoom *room);
+
+    [[nodiscard]] int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+    [[nodiscard]] QVariant data(const QModelIndex &idx, int role = Qt::DisplayRole) const override;
+    [[nodiscard]] QHash<int, QByteArray> roleNames() const override;
+
+    Q_INVOKABLE [[nodiscard]] int eventIDToIndex(const QString &eventID) const;
+    Q_INVOKABLE [[nodiscard]] QVariant getLastLocalUserMessageEventId();
+    Q_INVOKABLE [[nodiscard]] QVariant getLatestMessageFromIndex(const int baseline);
+    Q_INVOKABLE void loadReply(const QModelIndex &row);
+
+private Q_SLOTS:
+    int refreshEvent(const QString &eventId);
+    void refreshRow(int row);
+
+private:
+    NeoChatRoom *m_currentRoom = nullptr;
+    QString lastReadEventId;
+    QPersistentModelIndex m_lastReadEventIndex;
+    int rowBelowInserted = -1;
+    bool movingEvent = false;
+
+    [[nodiscard]] int timelineBaseIndex() const;
+    [[nodiscard]] QDateTime makeMessageTimestamp(const Quotient::Room::rev_iter_t &baseIt) const;
+    [[nodiscard]] static QString renderDate(const QDateTime &timestamp);
+
+    bool canFetchMore(const QModelIndex &parent) const override;
+    void fetchMore(const QModelIndex &parent) override;
+
+    void refreshLastUserEvents(int baseTimelineRow);
+    void refreshEventRoles(int row, const QVector<int> &roles = {});
+    int refreshEventRoles(const QString &eventId, const QVector<int> &roles = {});
+    void moveReadMarker(const QString &toEventId);
+
+    std::vector<Quotient::event_ptr_tt<Quotient::RoomEvent>> m_extraEvents;
+
+Q_SIGNALS:
+    void roomChanged();
+    void fancyEffectsReasonFound(const QString &fancyEffect);
+};

src/models/messagefiltermodel.cpp

@@ -0,0 +1,65 @@
+// SPDX-FileCopyrightText: 2021 Nicolas Fella <nicolas.fella@gmx.de>
+// SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
+
+#include "messagefiltermodel.h"
+
+#include "messageeventmodel.h"
+#include "neochatconfig.h"
+
+using namespace Quotient;
+
+MessageFilterModel::MessageFilterModel(QObject *parent)
+    : QSortFilterProxyModel(parent)
+{
+    connect(NeoChatConfig::self(), &NeoChatConfig::ShowLeaveJoinEventChanged, this, [this] {
+        beginResetModel();
+        endResetModel();
+    });
+
+    connect(NeoChatConfig::self(), &NeoChatConfig::ShowRenameChanged, this, [this] {
+        beginResetModel();
+        endResetModel();
+    });
+
+    connect(NeoChatConfig::self(), &NeoChatConfig::ShowAvatarUpdateChanged, this, [this] {
+        beginResetModel();
+        endResetModel();
+    });
+    connect(NeoChatConfig::self(), &NeoChatConfig::ShowDeletedMessagesChanged, this, [this] {
+        beginResetModel();
+        endResetModel();
+    });
+}
+
+bool MessageFilterModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
+{
+    const QModelIndex index = sourceModel()->index(sourceRow, 0, sourceParent);
+
+    const int specialMarks = index.data(MessageEventModel::SpecialMarksRole).toInt();
+    if (index.data(MessageEventModel::IsNameChangeRole).toBool() && !NeoChatConfig::self()->showRename()) {
+        return false;
+    }
+
+    if (index.data(MessageEventModel::IsAvatarChangeRole).toBool() && !NeoChatConfig::self()->showAvatarUpdate()) {
+        return false;
+    }
+    if (index.data(MessageEventModel::IsRedactedRole).toBool() && !NeoChatConfig::self()->showDeletedMessages()) {
+        return false;
+    }
+
+    if (specialMarks == EventStatus::Hidden || specialMarks == EventStatus::Replaced) {
+        return false;
+    }
+
+    const auto eventType = index.data(MessageEventModel::EventTypeRole).toInt();
+
+    if (eventType == MessageEventModel::Other) {
+        return false;
+    }
+
+    if (!NeoChatConfig::self()->showLeaveJoinEvent() && eventType == MessageEventModel::State) {
+        return false;
+    }
+
+    return true;
+}

src/models/messagefiltermodel.h

@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: 2021 Nicolas Fella <nicolas.fella@gmx.de>
+// SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
+
+#pragma once
+
+#include <QSortFilterProxyModel>
+
+class MessageFilterModel : public QSortFilterProxyModel
+{
+    Q_OBJECT
+public:
+    MessageFilterModel(QObject *parent = nullptr);
+    bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
+};

src/models/publicroomlistmodel.cpp

@@ -0,0 +1,247 @@
+// SPDX-FileCopyrightText: 2019-2020 Black Hat <bhat@encom.eu.org>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include "publicroomlistmodel.h"
+
+#include <connection.h>
+
+using namespace Quotient;
+
+PublicRoomListModel::PublicRoomListModel(QObject *parent)
+    : QAbstractListModel(parent)
+{
+}
+
+void PublicRoomListModel::setConnection(Connection *conn)
+{
+    if (m_connection == conn) {
+        return;
+    }
+
+    beginResetModel();
+
+    nextBatch = "";
+    attempted = false;
+    rooms.clear();
+    m_server.clear();
+
+    if (m_connection) {
+        m_connection->disconnect(this);
+    }
+
+    endResetModel();
+
+    m_connection = conn;
+
+    if (job) {
+        job->abandon();
+        job = nullptr;
+    }
+
+    if (m_connection) {
+        next();
+    }
+
+    Q_EMIT connectionChanged();
+    Q_EMIT serverChanged();
+    Q_EMIT hasMoreChanged();
+}
+
+void PublicRoomListModel::setServer(const QString &value)
+{
+    if (m_server == value) {
+        return;
+    }
+
+    m_server = value;
+
+    beginResetModel();
+
+    nextBatch = "";
+    attempted = false;
+    rooms.clear();
+
+    endResetModel();
+
+    if (job) {
+        job->abandon();
+        job = nullptr;
+    }
+
+    if (m_connection) {
+        next();
+    }
+
+    Q_EMIT serverChanged();
+    Q_EMIT hasMoreChanged();
+}
+
+void PublicRoomListModel::setKeyword(const QString &value)
+{
+    if (m_keyword == value) {
+        return;
+    }
+
+    m_keyword = value;
+
+    beginResetModel();
+
+    nextBatch = "";
+    attempted = false;
+    rooms.clear();
+
+    endResetModel();
+
+    if (job) {
+        job->abandon();
+        job = nullptr;
+    }
+
+    if (m_connection) {
+        next();
+    }
+
+    Q_EMIT keywordChanged();
+    Q_EMIT hasMoreChanged();
+}
+
+void PublicRoomListModel::next(int count)
+{
+    if (count < 1) {
+        return;
+    }
+
+    if (job) {
+        qDebug() << "PublicRoomListModel: Other jobs running, ignore";
+
+        return;
+    }
+
+#ifdef QUOTIENT_07
+    job = m_connection->callApi<QueryPublicRoomsJob>(m_server, count, nextBatch, QueryPublicRoomsJob::Filter{m_keyword, {}});
+#else
+    job = m_connection->callApi<QueryPublicRoomsJob>(m_server, count, nextBatch, QueryPublicRoomsJob::Filter{m_keyword});
+#endif
+
+    connect(job, &BaseJob::finished, this, [this] {
+        attempted = true;
+
+        if (job->status() == BaseJob::Success) {
+            nextBatch = job->nextBatch();
+
+            this->beginInsertRows({}, rooms.count(), rooms.count() + job->chunk().count() - 1);
+            rooms.append(job->chunk());
+            this->endInsertRows();
+
+            if (job->nextBatch().isEmpty()) {
+                Q_EMIT hasMoreChanged();
+            }
+        }
+
+        this->job = nullptr;
+    });
+}
+
+QVariant PublicRoomListModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid()) {
+        return QVariant();
+    }
+
+    if (index.row() >= rooms.count()) {
+        qDebug() << "PublicRoomListModel, something's wrong: index.row() >= "
+                    "rooms.count()";
+        return {};
+    }
+    auto room = rooms.at(index.row());
+    if (role == NameRole) {
+        auto displayName = room.name;
+        if (!displayName.isEmpty()) {
+            return displayName;
+        }
+
+        displayName = room.canonicalAlias;
+        if (!displayName.isEmpty()) {
+            return displayName;
+        }
+
+        if (!displayName.isEmpty()) {
+            return displayName;
+        }
+
+        return room.roomId;
+    }
+    if (role == AvatarRole) {
+        auto avatarUrl = room.avatarUrl;
+
+        if (avatarUrl.isEmpty()) {
+            return "";
+        }
+#ifdef QUOTIENT_07
+        return avatarUrl.url().remove(0, 6);
+#else
+        return avatarUrl.remove(0, 6);
+#endif
+    }
+    if (role == TopicRole) {
+        return room.topic;
+    }
+    if (role == RoomIDRole) {
+        return room.roomId;
+    }
+    if (role == AliasRole) {
+        if (!room.canonicalAlias.isEmpty()) {
+            return room.canonicalAlias;
+        }
+        return {};
+    }
+    if (role == MemberCountRole) {
+        return room.numJoinedMembers;
+    }
+    if (role == AllowGuestsRole) {
+        return room.guestCanJoin;
+    }
+    if (role == WorldReadableRole) {
+        return room.worldReadable;
+    }
+    if (role == IsJoinedRole) {
+        if (!m_connection) {
+            return {};
+        }
+
+        return m_connection->room(room.roomId, JoinState::Join) != nullptr;
+    }
+
+    return {};
+}
+
+QHash<int, QByteArray> PublicRoomListModel::roleNames() const
+{
+    QHash<int, QByteArray> roles;
+
+    roles[NameRole] = "name";
+    roles[AvatarRole] = "avatar";
+    roles[TopicRole] = "topic";
+    roles[RoomIDRole] = "roomID";
+    roles[MemberCountRole] = "memberCount";
+    roles[AllowGuestsRole] = "allowGuests";
+    roles[WorldReadableRole] = "worldReadable";
+    roles[IsJoinedRole] = "isJoined";
+    roles[AliasRole] = "alias";
+
+    return roles;
+}
+
+int PublicRoomListModel::rowCount(const QModelIndex &parent) const
+{
+    if (parent.isValid()) {
+        return 0;
+    }
+
+    return rooms.count();
+}
+
+bool PublicRoomListModel::hasMore() const
+{
+    return !(attempted && nextBatch.isEmpty());
+}

src/models/publicroomlistmodel.h

@@ -0,0 +1,83 @@
+// SPDX-FileCopyrightText: 2019 Black Hat <bhat@encom.eu.org>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#pragma once
+
+#include <QAbstractListModel>
+#include <QObject>
+
+#include <csapi/list_public_rooms.h>
+
+namespace Quotient
+{
+class Connection;
+}
+
+class PublicRoomListModel : public QAbstractListModel
+{
+    Q_OBJECT
+    Q_PROPERTY(Quotient::Connection *connection READ connection WRITE setConnection NOTIFY connectionChanged)
+    Q_PROPERTY(QString server READ server WRITE setServer NOTIFY serverChanged)
+    Q_PROPERTY(QString keyword READ keyword WRITE setKeyword NOTIFY keywordChanged)
+    Q_PROPERTY(bool hasMore READ hasMore NOTIFY hasMoreChanged)
+
+public:
+    enum EventRoles {
+        NameRole = Qt::DisplayRole + 1,
+        AvatarRole,
+        TopicRole,
+        RoomIDRole,
+        AliasRole,
+        MemberCountRole,
+        AllowGuestsRole,
+        WorldReadableRole,
+        IsJoinedRole,
+    };
+
+    PublicRoomListModel(QObject *parent = nullptr);
+
+    [[nodiscard]] QVariant data(const QModelIndex &index, int role = NameRole) const override;
+    [[nodiscard]] int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+
+    [[nodiscard]] QHash<int, QByteArray> roleNames() const override;
+
+    [[nodiscard]] Quotient::Connection *connection() const
+    {
+        return m_connection;
+    }
+    void setConnection(Quotient::Connection *conn);
+
+    [[nodiscard]] QString server() const
+    {
+        return m_server;
+    }
+    void setServer(const QString &value);
+
+    [[nodiscard]] QString keyword() const
+    {
+        return m_keyword;
+    }
+    void setKeyword(const QString &value);
+
+    [[nodiscard]] bool hasMore() const;
+
+    Q_INVOKABLE void next(int count = 50);
+
+private:
+    Quotient::Connection *m_connection = nullptr;
+    QString m_server;
+    QString m_keyword;
+
+    bool attempted = false;
+    QString nextBatch;
+
+    QVector<Quotient::PublicRoomsChunk> rooms;
+
+    Quotient::QueryPublicRoomsJob *job = nullptr;
+
+Q_SIGNALS:
+    void connectionChanged();
+    void serverChanged();
+    void keywordChanged();
+    void hasMoreChanged();
+};

src/models/roomlistmodel.cpp

@@ -0,0 +1,534 @@
+// SPDX-FileCopyrightText: 2018-2019 Black Hat <bhat@encom.eu.org>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include "roomlistmodel.h"
+
+#include "neochatconfig.h"
+#include "neochatroom.h"
+#include "roommanager.h"
+#include "user.h"
+
+#include <QDebug>
+#ifndef Q_OS_ANDROID
+#include <QDBusConnection>
+#include <QDBusInterface>
+#include <QDBusMessage>
+#endif
+
+#include <KLocalizedString>
+#include <QGuiApplication>
+#include <utility>
+
+#ifndef QUOTIENT_07
+#include "notificationsmanager.h"
+#include <csapi/notifications.h>
+#endif
+
+using namespace Quotient;
+
+Q_DECLARE_METATYPE(Quotient::JoinState)
+
+#ifndef Q_OS_ANDROID
+bool useUnityCounter()
+{
+    static const auto Result = QDBusInterface("com.canonical.Unity", "/").isValid();
+
+    return Result;
+}
+#endif
+
+RoomListModel::RoomListModel(QObject *parent)
+    : QAbstractListModel(parent)
+{
+    const auto collapsedSections = NeoChatConfig::collapsedSections();
+    for (auto collapsedSection : collapsedSections) {
+        m_categoryVisibility[collapsedSection] = false;
+    }
+
+#ifndef Q_OS_ANDROID
+    connect(this, &RoomListModel::notificationCountChanged, this, [this]() {
+        if (useUnityCounter()) {
+            // copied from Telegram desktop
+            const auto launcherUrl = "application://org.kde.neochat.desktop";
+            // Gnome requires that count is a 64bit integer
+            const qint64 counterSlice = std::min(m_notificationCount, 9999);
+            QVariantMap dbusUnityProperties;
+
+            if (counterSlice > 0) {
+                dbusUnityProperties["count"] = counterSlice;
+                dbusUnityProperties["count-visible"] = true;
+            } else {
+                dbusUnityProperties["count-visible"] = false;
+            }
+
+            auto signal = QDBusMessage::createSignal("/com/canonical/unity/launcherentry/neochat", "com.canonical.Unity.LauncherEntry", "Update");
+
+            signal.setArguments({launcherUrl, dbusUnityProperties});
+
+            QDBusConnection::sessionBus().send(signal);
+        }
+    });
+#endif
+}
+
+RoomListModel::~RoomListModel() = default;
+
+void RoomListModel::setConnection(Connection *connection)
+{
+    if (connection == m_connection) {
+        return;
+    }
+    if (m_connection) {
+        m_connection->disconnect(this);
+    }
+    if (!connection) {
+        qDebug() << "Removing current connection...";
+        m_connection = nullptr;
+        beginResetModel();
+        m_rooms.clear();
+        endResetModel();
+        return;
+    }
+
+    m_connection = connection;
+
+    for (NeoChatRoom *room : std::as_const(m_rooms)) {
+        room->disconnect(this);
+    }
+
+    connect(connection, &Connection::connected, this, &RoomListModel::doResetModel);
+    connect(connection, &Connection::invitedRoom, this, &RoomListModel::updateRoom);
+    connect(connection, &Connection::joinedRoom, this, &RoomListModel::updateRoom);
+    connect(connection, &Connection::leftRoom, this, &RoomListModel::updateRoom);
+    connect(connection, &Connection::aboutToDeleteRoom, this, &RoomListModel::deleteRoom);
+    connect(connection, &Connection::directChatsListChanged, this, [this, connection](Quotient::DirectChatsMap additions, Quotient::DirectChatsMap removals) {
+        auto refreshRooms = [this, &connection](Quotient::DirectChatsMap rooms) {
+            for (const QString &roomID : std::as_const(rooms)) {
+                auto room = connection->room(roomID);
+                if (room) {
+                    refresh(static_cast<NeoChatRoom *>(room));
+                }
+            }
+        };
+
+        refreshRooms(std::move(additions));
+        refreshRooms(std::move(removals));
+    });
+
+    doResetModel();
+
+    Q_EMIT connectionChanged();
+}
+
+void RoomListModel::doResetModel()
+{
+    beginResetModel();
+    m_rooms.clear();
+    const auto rooms = m_connection->allRooms();
+    for (const auto &room : rooms) {
+        doAddRoom(room);
+    }
+    endResetModel();
+    refreshNotificationCount();
+}
+
+NeoChatRoom *RoomListModel::roomAt(int row) const
+{
+    return m_rooms.at(row);
+}
+
+void RoomListModel::doAddRoom(Room *r)
+{
+    if (auto room = static_cast<NeoChatRoom *>(r)) {
+        m_rooms.append(room);
+        connectRoomSignals(room);
+        Q_EMIT roomAdded(room);
+    } else {
+        qCritical() << "Attempt to add nullptr to the room list";
+        Q_ASSERT(false);
+    }
+}
+
+void RoomListModel::connectRoomSignals(NeoChatRoom *room)
+{
+    connect(room, &Room::displaynameChanged, this, [this, room] {
+        refresh(room);
+    });
+    connect(room, &Room::unreadMessagesChanged, this, [this, room] {
+        refresh(room);
+    });
+    connect(room, &Room::notificationCountChanged, this, [this, room] {
+        refresh(room);
+    });
+    connect(room, &Room::avatarChanged, this, [this, room] {
+        refresh(room, {AvatarRole});
+    });
+    connect(room, &Room::tagsChanged, this, [this, room] {
+        refresh(room);
+    });
+    connect(room, &Room::joinStateChanged, this, [this, room] {
+        refresh(room);
+    });
+    connect(room, &Room::addedMessages, this, [this, room] {
+        refresh(room, {LastEventRole, SubtitleTextRole});
+    });
+    connect(room, &Room::pendingEventMerged, this, [this, room] {
+        refresh(room, {LastEventRole, SubtitleTextRole});
+    });
+#ifndef QUOTIENT_07
+    connect(room, &Room::notificationCountChanged, this, &RoomListModel::handleNotifications);
+#endif
+    connect(room, &Room::highlightCountChanged, this, [this, room] {
+        if (room->highlightCount() == 0) {
+            return;
+        }
+        if (room->timelineSize() == 0) {
+            return;
+        }
+        auto *lastEvent = room->lastEvent();
+
+        if (!lastEvent) {
+            return;
+        }
+
+        if (!lastEvent->isStateEvent()) {
+            return;
+        }
+        User *sender = room->user(lastEvent->senderId());
+        if (sender == room->localUser()) {
+            return;
+        }
+        Q_EMIT newHighlight(room->id(), lastEvent->id(), room->displayName(), sender->displayname(), room->eventToString(*lastEvent), room->avatar(128));
+    });
+    connect(room, &Room::notificationCountChanged, this, &RoomListModel::refreshNotificationCount);
+}
+
+#ifndef QUOTIENT_07
+void RoomListModel::handleNotifications()
+{
+    static bool initial = true;
+    static QStringList oldNotifications;
+    auto job = m_connection->callApi<GetNotificationsJob>();
+
+    connect(job, &BaseJob::success, this, [this, job]() {
+        const auto notifications = job->jsonData()["notifications"].toArray();
+        if (initial) {
+            initial = false;
+            for (const auto &n : notifications) {
+                oldNotifications += n.toObject()["event"].toObject()["event_id"].toString();
+            }
+            return;
+        }
+        for (const auto &n : notifications) {
+            const auto notification = n.toObject();
+            if (notification["read"].toBool()) {
+                oldNotifications.removeOne(notification["event"].toObject()["event_id"].toString());
+                continue;
+            }
+            if (oldNotifications.contains(notification["event"].toObject()["event_id"].toString())) {
+                continue;
+            }
+            oldNotifications += notification["event"].toObject()["event_id"].toString();
+            auto room = m_connection->room(notification["room_id"].toString());
+
+            // If room exists, room is NOT active OR the application is NOT active, show notification
+            if (room && !(room->id() == RoomManager::instance().currentRoom()->id() && QGuiApplication::applicationState() == Qt::ApplicationActive)) {
+                // The room might have been deleted (for example rejected invitation).
+                auto sender = room->user(notification["event"].toObject()["sender"].toString());
+
+                QImage avatar_image;
+                if (!sender->avatarUrl(room).isEmpty()) {
+                    avatar_image = sender->avatar(128, room);
+                } else {
+                    avatar_image = room->avatar(128);
+                }
+                NotificationsManager::instance().postNotification(dynamic_cast<NeoChatRoom *>(room),
+                                                                  sender->displayname(room),
+                                                                  notification["event"].toObject()["content"].toObject()["body"].toString(),
+                                                                  avatar_image,
+                                                                  notification["event"].toObject()["event_id"].toString(),
+                                                                  true);
+            }
+        }
+    });
+}
+#endif
+
+void RoomListModel::refreshNotificationCount()
+{
+    int count = 0;
+    for (auto room : std::as_const(m_rooms)) {
+        count += room->notificationCount();
+    }
+    if (m_notificationCount == count) {
+        return;
+    }
+    m_notificationCount = count;
+    Q_EMIT notificationCountChanged();
+}
+
+void RoomListModel::updateRoom(Room *room, Room *prev)
+{
+    // There are two cases when this method is called:
+    // 1. (prev == nullptr) adding a new room to the room list
+    // 2. (prev != nullptr) accepting/rejecting an invitation or inviting to
+    //    the previously left room (in both cases prev has the previous state).
+    if (prev == room) {
+        qCritical() << "RoomListModel::updateRoom: room tried to replace itself";
+        refresh(static_cast<NeoChatRoom *>(room));
+        return;
+    }
+    if (prev && room->id() != prev->id()) {
+        qCritical() << "RoomListModel::updateRoom: attempt to update room" << room->id() << "to" << prev->id();
+        // That doesn't look right but technically we still can do it.
+    }
+    // Ok, we're through with pre-checks, now for the real thing.
+    auto newRoom = static_cast<NeoChatRoom *>(room);
+    const auto it = std::find_if(m_rooms.begin(), m_rooms.end(), [=](const NeoChatRoom *r) {
+        return r == prev || r == newRoom;
+    });
+    if (it != m_rooms.end()) {
+        const int row = it - m_rooms.begin();
+        // There's no guarantee that prev != newRoom
+        if (*it == prev && *it != newRoom) {
+            prev->disconnect(this);
+            m_rooms.replace(row, newRoom);
+            connectRoomSignals(newRoom);
+        }
+        Q_EMIT dataChanged(index(row), index(row));
+    } else {
+        beginInsertRows(QModelIndex(), m_rooms.count(), m_rooms.count());
+        doAddRoom(newRoom);
+        endInsertRows();
+    }
+}
+
+void RoomListModel::deleteRoom(Room *room)
+{
+    qDebug() << "Deleting room" << room->id();
+    const auto it = std::find(m_rooms.begin(), m_rooms.end(), room);
+    if (it == m_rooms.end()) {
+        return; // Already deleted, nothing to do
+    }
+    qDebug() << "Erasing room" << room->id();
+    const int row = it - m_rooms.begin();
+    beginRemoveRows(QModelIndex(), row, row);
+    m_rooms.erase(it);
+    endRemoveRows();
+}
+
+int RoomListModel::rowCount(const QModelIndex &parent) const
+{
+    if (parent.isValid()) {
+        return 0;
+    }
+    return m_rooms.count();
+}
+
+QVariant RoomListModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid()) {
+        return QVariant();
+    }
+
+    if (index.row() >= m_rooms.count()) {
+        qDebug() << "UserListModel: something wrong here...";
+        return QVariant();
+    }
+    NeoChatRoom *room = m_rooms.at(index.row());
+    if (role == NameRole) {
+        return !room->name().isEmpty() ? room->name() : room->displayName();
+    }
+    if (role == DisplayNameRole) {
+        return room->displayName();
+    }
+    if (role == AvatarRole) {
+        return room->avatarMediaId();
+    }
+    if (role == CanonicalAliasRole) {
+        return room->canonicalAlias();
+    }
+    if (role == TopicRole) {
+        return room->topic();
+    }
+    if (role == CategoryRole) {
+        if (room->joinState() == JoinState::Invite) {
+            return NeoChatRoomType::Invited;
+        }
+        if (room->isFavourite()) {
+            return NeoChatRoomType::Favorite;
+        }
+        if (room->isLowPriority()) {
+            return NeoChatRoomType::Deprioritized;
+        }
+        if (room->isDirectChat()) {
+            return NeoChatRoomType::Direct;
+        }
+        const RoomCreateEvent *creationEvent = room->creation();
+        if (!creationEvent) {
+            return NeoChatRoomType::Normal;
+        }
+        QJsonObject contentJson = creationEvent->contentJson();
+        QJsonObject::const_iterator typeIter = contentJson.find("type");
+        if (typeIter != contentJson.end()) {
+            if (typeIter.value().toString() == "m.space") {
+                return NeoChatRoomType::Space;
+            }
+        }
+        return NeoChatRoomType::Normal;
+    }
+    if (role == UnreadCountRole) {
+        return room->unreadCount();
+    }
+    if (role == NotificationCountRole) {
+        return room->notificationCount();
+    }
+    if (role == HighlightCountRole) {
+        return room->highlightCount();
+    }
+    if (role == LastEventRole) {
+        if (room->lastEventIsSpoiler()) {
+            return QString();
+        }
+        return room->lastEventToString();
+    }
+    if (role == LastActiveTimeRole) {
+        return room->lastActiveTime();
+    }
+    if (role == JoinStateRole) {
+        if (!room->successorId().isEmpty()) {
+            return QStringLiteral("upgraded");
+        }
+        return QVariant::fromValue(room->joinState());
+    }
+    if (role == CurrentRoomRole) {
+        return QVariant::fromValue(room);
+    }
+    if (role == CategoryVisibleRole) {
+        return m_categoryVisibility.value(data(index, CategoryRole).toInt(), true);
+    }
+    if (role == SubtitleTextRole) {
+        return room->subtitleText();
+    }
+    if (role == AvatarImageRole) {
+        return room->avatar(128);
+    }
+    if (role == IdRole) {
+        return room->id();
+    }
+    if (role == IsSpaceRole) {
+        return room->isSpace();
+    }
+
+    return QVariant();
+}
+
+void RoomListModel::refresh(NeoChatRoom *room, const QVector<int> &roles)
+{
+    const auto it = std::find(m_rooms.begin(), m_rooms.end(), room);
+    if (it == m_rooms.end()) {
+        qCritical() << "Room" << room->id() << "not found in the room list";
+        return;
+    }
+    const auto idx = index(it - m_rooms.begin());
+    Q_EMIT dataChanged(idx, idx, roles);
+}
+
+QHash<int, QByteArray> RoomListModel::roleNames() const
+{
+    QHash<int, QByteArray> roles;
+    roles[NameRole] = "name";
+    roles[DisplayNameRole] = "displayName";
+    roles[AvatarRole] = "avatar";
+    roles[CanonicalAliasRole] = "canonicalAlias";
+    roles[TopicRole] = "topic";
+    roles[CategoryRole] = "category";
+    roles[UnreadCountRole] = "unreadCount";
+    roles[NotificationCountRole] = "notificationCount";
+    roles[HighlightCountRole] = "highlightCount";
+    roles[LastEventRole] = "lastEvent";
+    roles[LastActiveTimeRole] = "lastActiveTime";
+    roles[JoinStateRole] = "joinState";
+    roles[CurrentRoomRole] = "currentRoom";
+    roles[CategoryVisibleRole] = "categoryVisible";
+    roles[SubtitleTextRole] = "subtitleText";
+    roles[IsSpaceRole] = "isSpace";
+    roles[IdRole] = "id";
+    return roles;
+}
+
+QString RoomListModel::categoryName(int section)
+{
+    switch (section) {
+    case 1:
+        return i18n("Invited");
+    case 2:
+        return i18n("Favorite");
+    case 3:
+        return i18n("Direct Messages");
+    case 4:
+        return i18n("Normal");
+    case 5:
+        return i18n("Low priority");
+    case 6:
+        return i18n("Spaces");
+    default:
+        return "Deadbeef";
+    }
+}
+
+QString RoomListModel::categoryIconName(int section)
+{
+    switch (section) {
+    case 1:
+        return QStringLiteral("user-invisible");
+    case 2:
+        return QStringLiteral("favorite");
+    case 3:
+        return QStringLiteral("dialog-messages");
+    case 4:
+        return QStringLiteral("group");
+    case 5:
+        return QStringLiteral("object-order-lower");
+    case 6:
+        return QStringLiteral("group");
+    default:
+        return QStringLiteral("tools-report-bug");
+    }
+}
+
+void RoomListModel::setCategoryVisible(int category, bool visible)
+{
+    beginResetModel();
+    auto collapsedSections = NeoChatConfig::collapsedSections();
+    if (visible) {
+        collapsedSections.removeAll(category);
+    } else {
+        collapsedSections.push_back(category);
+    }
+    NeoChatConfig::setCollapsedSections(collapsedSections);
+    NeoChatConfig::self()->save();
+
+    m_categoryVisibility[category] = visible;
+    endResetModel();
+}
+
+bool RoomListModel::categoryVisible(int category) const
+{
+    return m_categoryVisibility.value(category, true);
+}
+
+NeoChatRoom *RoomListModel::roomByAliasOrId(const QString &aliasOrId)
+{
+    for (const auto &room : std::as_const(m_rooms)) {
+        if (room->aliases().contains(aliasOrId) || room->id() == aliasOrId) {
+            return room;
+        }
+    }
+    return nullptr;
+}
+
+int RoomListModel::indexForRoom(NeoChatRoom *room) const
+{
+    return m_rooms.indexOf(room);
+}

src/models/roomlistmodel.h

@@ -0,0 +1,120 @@
+// SPDX-FileCopyrightText: 2018 Black Hat <bhat@encom.eu.org>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#pragma once
+
+#include <events/roomevent.h>
+
+#include <QAbstractListModel>
+
+class NeoChatRoom;
+
+namespace Quotient
+{
+class Connection;
+class Room;
+}
+
+class NeoChatRoomType : public QObject
+{
+    Q_OBJECT
+
+public:
+    enum Types {
+        Invited = 1,
+        Favorite,
+        Direct,
+        Normal,
+        Deprioritized,
+        Space,
+    };
+    Q_ENUM(Types)
+};
+
+class RoomListModel : public QAbstractListModel
+{
+    Q_OBJECT
+    Q_PROPERTY(Quotient::Connection *connection READ connection WRITE setConnection NOTIFY connectionChanged)
+    Q_PROPERTY(int notificationCount READ notificationCount NOTIFY notificationCountChanged)
+
+public:
+    enum EventRoles {
+        NameRole = Qt::UserRole + 1,
+        DisplayNameRole,
+        AvatarRole,
+        CanonicalAliasRole,
+        TopicRole,
+        CategoryRole,
+        UnreadCountRole,
+        NotificationCountRole,
+        HighlightCountRole,
+        LastEventRole,
+        LastActiveTimeRole,
+        JoinStateRole,
+        CurrentRoomRole,
+        CategoryVisibleRole,
+        SubtitleTextRole,
+        AvatarImageRole,
+        IdRole,
+        IsSpaceRole,
+    };
+    Q_ENUM(EventRoles)
+
+    RoomListModel(QObject *parent = nullptr);
+    ~RoomListModel() override;
+
+    [[nodiscard]] Quotient::Connection *connection() const
+    {
+        return m_connection;
+    }
+    void setConnection(Quotient::Connection *connection);
+    void doResetModel();
+
+    Q_INVOKABLE [[nodiscard]] NeoChatRoom *roomAt(int row) const;
+
+    [[nodiscard]] QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+    Q_INVOKABLE [[nodiscard]] int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+
+    [[nodiscard]] QHash<int, QByteArray> roleNames() const override;
+
+    Q_INVOKABLE [[nodiscard]] static QString categoryName(int section);
+    Q_INVOKABLE [[nodiscard]] static QString categoryIconName(int section);
+    Q_INVOKABLE void setCategoryVisible(int category, bool visible);
+    Q_INVOKABLE [[nodiscard]] bool categoryVisible(int category) const;
+    Q_INVOKABLE [[nodiscard]] int indexForRoom(NeoChatRoom *room) const;
+
+    [[nodiscard]] int notificationCount() const
+    {
+        return m_notificationCount;
+    }
+
+    Q_INVOKABLE NeoChatRoom *roomByAliasOrId(const QString &aliasOrId);
+
+private Q_SLOTS:
+    void doAddRoom(Quotient::Room *room);
+    void updateRoom(Quotient::Room *room, Quotient::Room *prev);
+    void deleteRoom(Quotient::Room *room);
+    void refresh(NeoChatRoom *room, const QVector<int> &roles = {});
+    void refreshNotificationCount();
+
+private:
+    Quotient::Connection *m_connection = nullptr;
+    QList<NeoChatRoom *> m_rooms;
+
+    QMap<int, bool> m_categoryVisibility;
+
+    int m_notificationCount = 0;
+    QString m_activeSpaceId = "";
+
+    void connectRoomSignals(NeoChatRoom *room);
+#ifndef QUOTIENT_07
+    void handleNotifications();
+#endif
+
+Q_SIGNALS:
+    void connectionChanged();
+    void notificationCountChanged();
+
+    void roomAdded(NeoChatRoom *_t1);
+    void newHighlight(const QString &_t1, const QString &_t2, const QString &_t3, const QString &_t4, const QString &_t5, const QImage &_t6);
+};

src/models/searchmodel.cpp

@@ -0,0 +1,180 @@
+// SPDX-FileCopyrightText: 2022 Tobias Fella <fella@posteo.de>
+// SPDX-License-Identifier: LGPL-2.0-or-later
+
+#include "searchmodel.h"
+#include "messageeventmodel.h"
+#include "neochatroom.h"
+#include "neochatuser.h"
+#include <KLocalizedString>
+#include <connection.h>
+
+#ifdef QUOTIENT_07
+#include <csapi/search.h>
+#endif
+
+using namespace Quotient;
+
+// TODO search only in the current room
+
+SearchModel::SearchModel(QObject *parent)
+    : QAbstractListModel(parent)
+{
+}
+
+QString SearchModel::searchText() const
+{
+    return m_searchText;
+}
+
+void SearchModel::setSearchText(const QString &searchText)
+{
+    m_searchText = searchText;
+    Q_EMIT searchTextChanged();
+}
+
+void SearchModel::search()
+{
+#ifdef QUOTIENT_07
+    Q_ASSERT(m_connection);
+    setSearching(true);
+    if (m_job) {
+        m_job->abandon();
+        m_job = nullptr;
+    }
+
+    SearchJob::RoomEventsCriteria criteria{
+        m_searchText,
+        {},
+        RoomEventFilter{
+            .rooms = {m_room->id()},
+        },
+        "recent",
+        SearchJob::IncludeEventContext{3, 3, true},
+        false,
+        none,
+    };
+
+    auto job = m_connection->callApi<SearchJob>(SearchJob::Categories{criteria});
+    m_job = job;
+    connect(job, &BaseJob::finished, this, [=] {
+        beginResetModel();
+        m_result = job->searchCategories().roomEvents;
+        endResetModel();
+        setSearching(false);
+        m_job = nullptr;
+        // TODO error handling
+    });
+#endif
+}
+
+Connection *SearchModel::connection() const
+{
+    return m_connection;
+}
+
+void SearchModel::setConnection(Connection *connection)
+{
+    m_connection = connection;
+    Q_EMIT connectionChanged();
+}
+
+QVariant SearchModel::data(const QModelIndex &index, int role) const
+{
+#ifdef QUOTIENT_07
+    auto row = index.row();
+    const auto &event = *m_result->results[row].result;
+    switch (role) {
+    case DisplayRole:
+        return m_room->eventToString(*m_result->results[row].result);
+    case ShowAuthorRole:
+        return true;
+    case AuthorRole:
+        return QVariantMap{
+            {"isLocalUser", event.senderId() == m_room->localUser()->id()},
+            {"id", event.senderId()},
+            {"avatarMediaId", m_connection->user(event.senderId())->avatarMediaId(m_room)},
+            {"avatarUrl", m_connection->user(event.senderId())->avatarUrl(m_room)},
+            {"displayName", m_connection->user(event.senderId())->displayname(m_room)},
+            {"display", m_connection->user(event.senderId())->name()},
+            {"color", dynamic_cast<NeoChatUser *>(m_connection->user(event.senderId()))->color()},
+            {"object", QVariant::fromValue(m_connection->user(event.senderId()))},
+        };
+    case ShowSectionRole:
+        if (row == 0) {
+            return true;
+        }
+        return event.originTimestamp().date() != m_result->results[row - 1].result->originTimestamp().date();
+    case SectionRole:
+        return renderDate(event.originTimestamp());
+    case TimeRole:
+        return event.originTimestamp();
+    }
+    return MessageEventModel::DelegateType::Message;
+#endif
+    return {};
+}
+
+int SearchModel::rowCount(const QModelIndex &parent) const
+{
+#ifdef QUOTIENT_07
+    if (m_result.has_value()) {
+        return m_result->results.size();
+    }
+#endif
+    return 0;
+}
+
+QHash<int, QByteArray> SearchModel::roleNames() const
+{
+    return {
+        {EventTypeRole, "eventType"},
+        {DisplayRole, "display"},
+        {AuthorRole, "author"},
+        {ShowSectionRole, "showSection"},
+        {SectionRole, "section"},
+        {TimeRole, "time"},
+        {ShowAuthorRole, "showAuthor"},
+    };
+}
+
+NeoChatRoom *SearchModel::room() const
+{
+    return m_room;
+}
+
+void SearchModel::setRoom(NeoChatRoom *room)
+{
+    m_room = room;
+    Q_EMIT roomChanged();
+}
+
+// TODO deduplicate with messageeventmodel
+QString renderDate(const QDateTime &timestamp)
+{
+    auto date = timestamp.toLocalTime().date();
+    if (date == QDate::currentDate()) {
+        return i18n("Today");
+    }
+    if (date == QDate::currentDate().addDays(-1)) {
+        return i18n("Yesterday");
+    }
+    if (date == QDate::currentDate().addDays(-2)) {
+        return i18n("The day before yesterday");
+    }
+    if (date > QDate::currentDate().addDays(-7)) {
+        return date.toString("dddd");
+    }
+
+    return QLocale::system().toString(date, QLocale::ShortFormat);
+}
+
+bool SearchModel::searching() const
+{
+    return m_searching;
+}
+
+void SearchModel::setSearching(bool searching)
+{
+    m_searching = searching;
+    Q_EMIT searchingChanged();
+}

src/models/searchmodel.h

@@ -0,0 +1,78 @@
+// SPDX-FileCopyrightText: 2022 Tobias Fella <fella@posteo.de>
+// SPDX-License-Identifier: LGPL-2.0-or-later
+
+#pragma once
+
+#include <QAbstractListModel>
+#include <QString>
+
+#ifdef QUOTIENT_07
+#include <csapi/search.h>
+#endif
+
+namespace Quotient
+{
+class Connection;
+}
+
+class NeoChatRoom;
+
+class SearchModel : public QAbstractListModel
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString searchText READ searchText WRITE setSearchText NOTIFY searchTextChanged)
+    Q_PROPERTY(Quotient::Connection *connection READ connection WRITE setConnection NOTIFY connectionChanged)
+    Q_PROPERTY(NeoChatRoom *room READ room WRITE setRoom NOTIFY roomChanged)
+    Q_PROPERTY(bool searching READ searching NOTIFY searchingChanged)
+
+public:
+    enum Roles {
+        DisplayRole = Qt::DisplayRole,
+        EventTypeRole,
+        ShowAuthorRole,
+        AuthorRole,
+        ShowSectionRole,
+        SectionRole,
+        TimeRole,
+    };
+    Q_ENUM(Roles);
+    SearchModel(QObject *parent = nullptr);
+
+    QString searchText() const;
+    void setSearchText(const QString &searchText);
+
+    Quotient::Connection *connection() const;
+    void setConnection(Quotient::Connection *connection);
+
+    NeoChatRoom *room() const;
+    void setRoom(NeoChatRoom *room);
+
+    Q_INVOKABLE void search();
+
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+    QHash<int, QByteArray> roleNames() const override;
+
+    bool searching() const;
+
+Q_SIGNALS:
+    void searchTextChanged();
+    void connectionChanged();
+    void roomChanged();
+    void searchingChanged();
+
+private:
+    void setSearching(bool searching);
+
+    QString m_searchText;
+    Quotient::Connection *m_connection = nullptr;
+    NeoChatRoom *m_room = nullptr;
+#ifdef QUOTIENT_07
+    Quotient::Omittable<Quotient::SearchJob::ResultRoomEvents> m_result = Quotient::none;
+    Quotient::SearchJob *m_job = nullptr;
+#endif
+    bool m_searching = false;
+};
+
+QString renderDate(const QDateTime &dateTime);

src/models/serverlistmodel.cpp

@@ -0,0 +1,153 @@
+// SPDX-FileCopyrightText: 2022 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 "serverlistmodel.h"
+
+#include "controller.h"
+
+#include <connection.h>
+
+#include <QDebug>
+
+#include <KConfig>
+#include <KConfigGroup>
+
+ServerListModel::ServerListModel(QObject *parent)
+    : QAbstractListModel(parent)
+{
+    KConfig dataResource("data", KConfig::SimpleConfig, QStandardPaths::AppDataLocation);
+    KConfigGroup serverGroup(&dataResource, "Servers");
+
+    QString domain = Controller::instance().activeConnection()->domain();
+
+    // Add the user's homeserver
+    m_servers.append(Server{
+        domain,
+        true,
+        false,
+        false,
+    });
+    // Add matrix.org
+    m_servers.append(Server{
+        QStringLiteral("matrix.org"),
+        false,
+        false,
+        false,
+    });
+    // Add each of the saved custom servers
+    for (const auto &i : serverGroup.keyList()) {
+        m_servers.append(Server{
+            serverGroup.readEntry(i, QString()),
+            false,
+            false,
+            true,
+        });
+    }
+    // Add add server delegate entry
+    m_servers.append(Server{
+        QString(),
+        false,
+        true,
+        false,
+    });
+}
+
+QVariant ServerListModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid()) {
+        return {};
+    }
+
+    if (index.row() >= m_servers.count()) {
+        qDebug() << "ServerListModel, something's wrong: index.row() >= m_notificationRules.count()";
+        return {};
+    }
+
+    if (role == UrlRole) {
+        return m_servers.at(index.row()).url;
+    }
+
+    if (role == IsHomeServerRole) {
+        return m_servers.at(index.row()).isHomeServer;
+    }
+
+    if (role == IsAddServerDelegateRole) {
+        return m_servers.at(index.row()).isAddServerDelegate;
+    }
+
+    if (role == IsDeletableRole) {
+        return m_servers.at(index.row()).isDeletable;
+    }
+
+    return {};
+}
+
+int ServerListModel::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent)
+
+    return m_servers.count();
+}
+
+void ServerListModel::checkServer(const QString &url)
+{
+    KConfig dataResource("data", KConfig::SimpleConfig, QStandardPaths::AppDataLocation);
+    KConfigGroup serverGroup(&dataResource, "Servers");
+
+    if (!serverGroup.hasKey(url)) {
+#ifdef QUOTIENT_07
+        if (Quotient::isJobPending(m_checkServerJob)) {
+#else
+        if (Quotient::isJobRunning(m_checkServerJob)) {
+#endif
+            m_checkServerJob->abandon();
+        }
+
+        m_checkServerJob = Controller::instance().activeConnection()->callApi<Quotient::QueryPublicRoomsJob>(url, 1);
+        connect(m_checkServerJob, &Quotient::BaseJob::success, this, [this, url] {
+            Q_EMIT serverCheckComplete(url, true);
+        });
+    }
+}
+
+void ServerListModel::addServer(const QString &url)
+{
+    KConfig dataResource("data", KConfig::SimpleConfig, QStandardPaths::AppDataLocation);
+    KConfigGroup serverGroup(&dataResource, "Servers");
+
+    if (!serverGroup.hasKey(url)) {
+        Server newServer = Server{
+            url,
+            false,
+            false,
+            true,
+        };
+
+        beginInsertRows(QModelIndex(), m_servers.count() - 1, m_servers.count() - 1);
+        m_servers.insert(rowCount() - 1, newServer);
+        endInsertRows();
+    }
+
+    serverGroup.writeEntry(url, url);
+}
+
+void ServerListModel::removeServerAtIndex(int row)
+{
+    KConfig dataResource("data", KConfig::SimpleConfig, QStandardPaths::AppDataLocation);
+    KConfigGroup serverGroup(&dataResource, "Servers");
+    serverGroup.deleteEntry(data(index(row), UrlRole).toString());
+
+    beginRemoveRows(QModelIndex(), row, row);
+    m_servers.removeAt(row);
+    endRemoveRows();
+}
+
+QHash<int, QByteArray> ServerListModel::roleNames() const
+{
+    return {
+        {UrlRole, QByteArrayLiteral("url")},
+        {IsHomeServerRole, QByteArrayLiteral("isHomeServer")},
+        {IsAddServerDelegateRole, QByteArrayLiteral("isAddServerDelegate")},
+        {IsDeletableRole, QByteArrayLiteral("isDeletable")},
+    };
+}

src/models/serverlistmodel.h

@@ -0,0 +1,47 @@
+// SPDX-FileCopyrightText: 2022 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 <csapi/list_public_rooms.h>
+
+#include <QAbstractListModel>
+#include <QPointer>
+#include <QUrl>
+
+class ServerListModel : public QAbstractListModel
+{
+    Q_OBJECT
+
+public:
+    struct Server {
+        QString url;
+        bool isHomeServer;
+        bool isAddServerDelegate;
+        bool isDeletable;
+    };
+    enum EventRoles {
+        UrlRole = Qt::UserRole + 1,
+        IsHomeServerRole,
+        IsAddServerDelegateRole,
+        IsDeletableRole,
+    };
+
+    ServerListModel(QObject *parent = nullptr);
+
+    [[nodiscard]] QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+    [[nodiscard]] int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+
+    [[nodiscard]] QHash<int, QByteArray> roleNames() const override;
+
+    Q_INVOKABLE void checkServer(const QString &url);
+    Q_INVOKABLE void addServer(const QString &url);
+    Q_INVOKABLE void removeServerAtIndex(int index);
+
+Q_SIGNALS:
+    void serverCheckComplete(QString url, bool valid);
+
+private:
+    QList<Server> m_servers;
+    QPointer<Quotient::QueryPublicRoomsJob> m_checkServerJob = nullptr;
+};

src/models/sortfilterroomlistmodel.cpp

@@ -0,0 +1,104 @@
+// SPDX-FileCopyrightText: 2020 Tobias Fella <fella@posteo.de>
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "sortfilterroomlistmodel.h"
+
+#include "roomlistmodel.h"
+#include "spacehierarchycache.h"
+
+SortFilterRoomListModel::SortFilterRoomListModel(QObject *parent)
+    : QSortFilterProxyModel(parent)
+{
+    sort(0);
+    invalidateFilter();
+    connect(this, &SortFilterRoomListModel::filterTextChanged, this, [this]() {
+        invalidateFilter();
+    });
+}
+
+void SortFilterRoomListModel::setRoomSortOrder(SortFilterRoomListModel::RoomSortOrder sortOrder)
+{
+    m_sortOrder = sortOrder;
+    Q_EMIT roomSortOrderChanged();
+    if (sortOrder == SortFilterRoomListModel::Alphabetical) {
+        setSortRole(RoomListModel::NameRole);
+    } else if (sortOrder == SortFilterRoomListModel::LastActivity) {
+        setSortRole(RoomListModel::LastActiveTimeRole);
+    }
+    invalidate();
+}
+
+SortFilterRoomListModel::RoomSortOrder SortFilterRoomListModel::roomSortOrder() const
+{
+    return m_sortOrder;
+}
+
+bool SortFilterRoomListModel::lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const
+{
+    if (m_sortOrder == SortFilterRoomListModel::LastActivity) {
+        // display favorite rooms always on top
+        const auto categoryLeft = static_cast<NeoChatRoomType::Types>(sourceModel()->data(source_left, RoomListModel::CategoryRole).toInt());
+        const auto categoryRight = static_cast<NeoChatRoomType::Types>(sourceModel()->data(source_right, RoomListModel::CategoryRole).toInt());
+
+        if (categoryLeft == NeoChatRoomType::Types::Favorite && categoryRight == NeoChatRoomType::Types::Favorite) {
+            return sourceModel()->data(source_left, RoomListModel::LastActiveTimeRole).toDateTime()
+                > sourceModel()->data(source_right, RoomListModel::LastActiveTimeRole).toDateTime();
+        }
+        if (categoryLeft == NeoChatRoomType::Types::Favorite) {
+            return true;
+        } else if (categoryRight == NeoChatRoomType::Types::Favorite) {
+            return false;
+        }
+
+        return sourceModel()->data(source_left, RoomListModel::LastActiveTimeRole).toDateTime()
+            > sourceModel()->data(source_right, RoomListModel::LastActiveTimeRole).toDateTime();
+    }
+    if (m_sortOrder != SortFilterRoomListModel::Categories) {
+        return QSortFilterProxyModel::lessThan(source_left, source_right);
+    }
+    if (sourceModel()->data(source_left, RoomListModel::CategoryRole) != sourceModel()->data(source_right, RoomListModel::CategoryRole)) {
+        return sourceModel()->data(source_left, RoomListModel::CategoryRole).toInt() < sourceModel()->data(source_right, RoomListModel::CategoryRole).toInt();
+    }
+    return sourceModel()->data(source_left, RoomListModel::LastActiveTimeRole).toDateTime()
+        > sourceModel()->data(source_right, RoomListModel::LastActiveTimeRole).toDateTime();
+}
+
+void SortFilterRoomListModel::setFilterText(const QString &text)
+{
+    m_filterText = text;
+    Q_EMIT filterTextChanged();
+}
+
+QString SortFilterRoomListModel::filterText() const
+{
+    return m_filterText;
+}
+
+bool SortFilterRoomListModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
+{
+    Q_UNUSED(source_parent);
+
+    bool acceptRoom = sourceModel()->data(sourceModel()->index(source_row, 0), RoomListModel::NameRole).toString().contains(m_filterText, Qt::CaseInsensitive)
+        && sourceModel()->data(sourceModel()->index(source_row, 0), RoomListModel::JoinStateRole).toString() != "upgraded"
+        && sourceModel()->data(sourceModel()->index(source_row, 0), RoomListModel::IsSpaceRole).toBool() == false;
+
+    if (m_activeSpaceId.isEmpty()) {
+        return acceptRoom;
+    } else {
+        const auto &rooms = SpaceHierarchyCache::instance().getRoomListForSpace(m_activeSpaceId, false);
+        return std::find(rooms.begin(), rooms.end(), sourceModel()->data(sourceModel()->index(source_row, 0), RoomListModel::IdRole).toString()) != rooms.end()
+            && acceptRoom;
+    }
+}
+
+QString SortFilterRoomListModel::activeSpaceId() const
+{
+    return m_activeSpaceId;
+}
+
+void SortFilterRoomListModel::setActiveSpaceId(const QString &spaceId)
+{
+    m_activeSpaceId = spaceId;
+    Q_EMIT activeSpaceIdChanged();
+    invalidate();
+}

src/models/sortfilterroomlistmodel.h

@@ -0,0 +1,49 @@
+// SPDX-FileCopyrightText: 2020 Tobias Fella <fella@posteo.de>
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <QSortFilterProxyModel>
+
+class SortFilterRoomListModel : public QSortFilterProxyModel
+{
+    Q_OBJECT
+
+    Q_PROPERTY(RoomSortOrder roomSortOrder READ roomSortOrder WRITE setRoomSortOrder NOTIFY roomSortOrderChanged)
+    Q_PROPERTY(QString filterText READ filterText READ filterText WRITE setFilterText NOTIFY filterTextChanged)
+    Q_PROPERTY(QString activeSpaceId READ activeSpaceId WRITE setActiveSpaceId NOTIFY activeSpaceIdChanged)
+
+public:
+    enum RoomSortOrder {
+        Alphabetical,
+        LastActivity,
+        Categories,
+    };
+    Q_ENUM(RoomSortOrder)
+
+    SortFilterRoomListModel(QObject *parent = nullptr);
+
+    void setRoomSortOrder(RoomSortOrder sortOrder);
+    [[nodiscard]] RoomSortOrder roomSortOrder() const;
+
+    void setFilterText(const QString &text);
+    [[nodiscard]] QString filterText() const;
+
+    [[nodiscard]] bool lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const override;
+
+    QString activeSpaceId() const;
+    void setActiveSpaceId(const QString &spaceId);
+
+protected:
+    [[nodiscard]] bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const override;
+
+Q_SIGNALS:
+    void roomSortOrderChanged();
+    void filterTextChanged();
+    void activeSpaceIdChanged();
+
+private:
+    RoomSortOrder m_sortOrder = Categories;
+    QString m_filterText;
+    QString m_activeSpaceId;
+};

src/models/sortfilterspacelistmodel.cpp

@@ -0,0 +1,28 @@
+// SPDX-FileCopyrightText: 2022 Snehit Sah <hi@snehit.dev>
+// SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
+
+#include "sortfilterspacelistmodel.h"
+
+#include "roomlistmodel.h"
+
+SortFilterSpaceListModel::SortFilterSpaceListModel(QObject *parent)
+    : QSortFilterProxyModel{parent}
+{
+    setSortRole(RoomListModel::IdRole);
+    sort(0);
+    invalidateFilter();
+}
+
+bool SortFilterSpaceListModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
+{
+    Q_UNUSED(source_parent);
+    return sourceModel()->data(sourceModel()->index(source_row, 0), RoomListModel::IsSpaceRole).toBool()
+        && sourceModel()->data(sourceModel()->index(source_row, 0), RoomListModel::JoinStateRole).toString() != "upgraded";
+}
+
+bool SortFilterSpaceListModel::lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const
+{
+    const auto idLeft = sourceModel()->data(source_left, RoomListModel::IdRole).toString();
+    const auto idRight = sourceModel()->data(source_right, RoomListModel::IdRole).toString();
+    return idLeft < idRight;
+}

src/models/sortfilterspacelistmodel.h

@@ -0,0 +1,24 @@
+// SPDX-FileCopyrightText: 2022 Snehit Sah <hi@snehit.dev>
+// SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
+
+#pragma once
+
+#include <QSortFilterProxyModel>
+
+class SortFilterSpaceListModel : public QSortFilterProxyModel
+{
+    Q_OBJECT
+
+public:
+    explicit SortFilterSpaceListModel(QObject *parent = nullptr);
+
+    [[nodiscard]] QString activeSpaceId() const;
+
+    [[nodiscard]] bool lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const override;
+
+Q_SIGNALS:
+    void activeSpaceIdChanged(QString &activeSpaceId);
+
+protected:
+    [[nodiscard]] bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const override;
+};

src/models/statemodel.cpp

@@ -0,0 +1,56 @@
+// SPDX-FileCopyrightText: 2022 Tobias Fella <fella@posteo.de>
+// SPDX-License-Identifier: LGPL-2.0-or-later
+
+#include "statemodel.h"
+
+StateModel::StateModel(QObject *parent)
+    : QAbstractListModel(parent)
+{
+}
+
+QHash<int, QByteArray> StateModel::roleNames() const
+{
+    return {{TypeRole, "type"}, {StateKeyRole, "stateKey"}, {SourceRole, "source"}};
+}
+QVariant StateModel::data(const QModelIndex &index, int role) const
+{
+#ifdef QUOTIENT_07
+    auto row = index.row();
+    switch (role) {
+    case TypeRole:
+        return m_room->currentState().events().keys()[row].first;
+    case StateKeyRole:
+        return m_room->currentState().events().keys()[row].second;
+    case SourceRole:
+        return QJsonDocument(m_room->currentState().events()[m_room->currentState().events().keys()[row]]->fullJson()).toJson();
+    }
+#endif
+    return {};
+}
+
+int StateModel::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent);
+#ifdef QUOTIENT_07
+    return m_room->currentState().events().size();
+#else
+    return 0;
+#endif
+}
+
+NeoChatRoom *StateModel::room() const
+{
+    return m_room;
+}
+
+void StateModel::setRoom(NeoChatRoom *room)
+{
+    m_room = room;
+    Q_EMIT roomChanged();
+    beginResetModel();
+    endResetModel();
+    connect(room, &NeoChatRoom::changed, this, [=] {
+        beginResetModel();
+        endResetModel();
+    });
+}

src/models/statemodel.h

@@ -0,0 +1,37 @@
+// SPDX-FileCopyrightText: 2022 Tobias Fella <fella@posteo.de>
+// SPDX-License-Identifier: LGPL-2.0-or-later
+
+#pragma once
+
+#include <QAbstractListModel>
+
+#include "neochatroom.h"
+
+class StateModel : public QAbstractListModel
+{
+    Q_OBJECT
+
+    Q_PROPERTY(NeoChatRoom *room READ room WRITE setRoom NOTIFY roomChanged)
+
+public:
+    enum Roles {
+        TypeRole,
+        StateKeyRole,
+        SourceRole,
+    };
+    Q_ENUM(Roles);
+
+    StateModel(QObject *parent = nullptr);
+    QHash<int, QByteArray> roleNames() const override;
+    QVariant data(const QModelIndex &index, int role) const override;
+    int rowCount(const QModelIndex &parent) const override;
+
+    NeoChatRoom *room() const;
+    void setRoom(NeoChatRoom *room);
+
+Q_SIGNALS:
+    void roomChanged();
+
+private:
+    NeoChatRoom *m_room = nullptr;
+};

src/models/userdirectorylistmodel.cpp

@@ -0,0 +1,181 @@
+// SPDX-FileCopyrightText: 2019 Black Hat <bhat@encom.eu.org>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include "userdirectorylistmodel.h"
+
+#include <connection.h>
+#include <room.h>
+
+using namespace Quotient;
+
+UserDirectoryListModel::UserDirectoryListModel(QObject *parent)
+    : QAbstractListModel(parent)
+{
+}
+
+void UserDirectoryListModel::setConnection(Connection *conn)
+{
+    if (m_connection == conn) {
+        return;
+    }
+
+    beginResetModel();
+
+    m_limited = false;
+    attempted = false;
+    users.clear();
+
+    if (m_connection) {
+        m_connection->disconnect(this);
+    }
+
+    endResetModel();
+
+    m_connection = conn;
+
+    if (job) {
+        job->abandon();
+        job = nullptr;
+    }
+
+    Q_EMIT connectionChanged();
+    Q_EMIT limitedChanged();
+}
+
+void UserDirectoryListModel::setKeyword(const QString &value)
+{
+    if (m_keyword == value) {
+        return;
+    }
+
+    m_keyword = value;
+
+    m_limited = false;
+    attempted = false;
+
+    if (job) {
+        job->abandon();
+        job = nullptr;
+    }
+
+    Q_EMIT keywordChanged();
+    Q_EMIT limitedChanged();
+}
+
+void UserDirectoryListModel::search(int count)
+{
+    if (count < 1) {
+        return;
+    }
+
+    if (job) {
+        qDebug() << "UserDirectoryListModel: Other jobs running, ignore";
+
+        return;
+    }
+
+    if (attempted) {
+        return;
+    }
+
+    job = m_connection->callApi<SearchUserDirectoryJob>(m_keyword, count);
+
+    connect(job, &BaseJob::finished, this, [this] {
+        attempted = true;
+
+        if (job->status() == BaseJob::Success) {
+            auto users = job->results();
+
+            this->beginResetModel();
+
+            this->users = users;
+            this->m_limited = job->limited();
+
+            this->endResetModel();
+        }
+
+        this->job = nullptr;
+
+        Q_EMIT limitedChanged();
+    });
+}
+
+QVariant UserDirectoryListModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid()) {
+        return QVariant();
+    }
+
+    if (index.row() >= users.count()) {
+        qDebug() << "UserDirectoryListModel, something's wrong: index.row() >= "
+                    "users.count()";
+        return {};
+    }
+    auto user = users.at(index.row());
+    if (role == NameRole) {
+        auto displayName = user.displayName;
+        if (!displayName.isEmpty()) {
+            return displayName;
+        }
+
+        displayName = user.userId;
+        if (!displayName.isEmpty()) {
+            return displayName;
+        }
+
+        return "Unknown User";
+    }
+    if (role == AvatarRole) {
+        auto avatarUrl = user.avatarUrl;
+
+        if (avatarUrl.isEmpty()) {
+            return "";
+        }
+#ifdef QUOTIENT_07
+        return avatarUrl.url().remove(0, 6);
+#else
+        return avatarUrl.remove(0, 6);
+#endif
+    }
+    if (role == UserIDRole) {
+        return user.userId;
+    }
+    if (role == DirectChatsRole) {
+        if (!m_connection) {
+            return {};
+        };
+
+        auto userObj = m_connection->user(user.userId);
+        auto directChats = m_connection->directChats();
+
+        if (userObj && directChats.contains(userObj)) {
+            auto directChatsForUser = directChats.values(userObj);
+            if (!directChatsForUser.isEmpty()) {
+                return QVariant::fromValue(directChatsForUser);
+            }
+        }
+    }
+
+    return {};
+}
+
+QHash<int, QByteArray> UserDirectoryListModel::roleNames() const
+{
+    QHash<int, QByteArray> roles;
+
+    roles[NameRole] = "name";
+    roles[AvatarRole] = "avatar";
+    roles[UserIDRole] = "userID";
+    roles[DirectChatsRole] = "directChats";
+
+    return roles;
+}
+
+int UserDirectoryListModel::rowCount(const QModelIndex &parent) const
+{
+    if (parent.isValid()) {
+        return 0;
+    }
+
+    return users.count();
+}

src/models/userdirectorylistmodel.h

@@ -0,0 +1,72 @@
+// SPDX-FileCopyrightText: 2019 Black Hat <bhat@encom.eu.org>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#pragma once
+
+#include <QAbstractListModel>
+#include <QObject>
+
+#include <csapi/users.h>
+
+namespace Quotient
+{
+class Connection;
+}
+
+class UserDirectoryListModel : public QAbstractListModel
+{
+    Q_OBJECT
+    Q_PROPERTY(Quotient::Connection *connection READ connection WRITE setConnection NOTIFY connectionChanged)
+    Q_PROPERTY(QString keyword READ keyword WRITE setKeyword NOTIFY keywordChanged)
+    Q_PROPERTY(bool limited READ limited NOTIFY limitedChanged)
+
+public:
+    enum EventRoles {
+        NameRole = Qt::DisplayRole + 1,
+        AvatarRole,
+        UserIDRole,
+        DirectChatsRole,
+    };
+
+    UserDirectoryListModel(QObject *parent = nullptr);
+
+    [[nodiscard]] QVariant data(const QModelIndex &index, int role = NameRole) const override;
+    [[nodiscard]] int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+
+    [[nodiscard]] QHash<int, QByteArray> roleNames() const override;
+
+    [[nodiscard]] Quotient::Connection *connection() const
+    {
+        return m_connection;
+    }
+    void setConnection(Quotient::Connection *conn);
+
+    [[nodiscard]] QString keyword() const
+    {
+        return m_keyword;
+    }
+    void setKeyword(const QString &value);
+
+    [[nodiscard]] bool limited() const
+    {
+        return m_limited;
+    }
+
+    Q_INVOKABLE void search(int count = 50);
+
+private:
+    Quotient::Connection *m_connection = nullptr;
+    QString m_keyword;
+    bool m_limited = false;
+
+    bool attempted = false;
+
+    QVector<Quotient::SearchUserDirectoryJob::User> users;
+
+    Quotient::SearchUserDirectoryJob *job = nullptr;
+
+Q_SIGNALS:
+    void connectionChanged();
+    void keywordChanged();
+    void limitedChanged();
+};

src/models/userfiltermodel.cpp

@@ -0,0 +1,28 @@
+// SPDX-FileCopyrightText: 2022 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 "userfiltermodel.h"
+
+#include "userlistmodel.h"
+
+bool UserFilterModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
+{
+    Q_UNUSED(sourceParent);
+    if (m_filterText.length() < 1) {
+        return false;
+    }
+    return sourceModel()->data(sourceModel()->index(sourceRow, 0), UserListModel::NameRole).toString().contains(m_filterText, Qt::CaseInsensitive)
+        || sourceModel()->data(sourceModel()->index(sourceRow, 0), UserListModel::UserIdRole).toString().contains(m_filterText, Qt::CaseInsensitive);
+}
+
+QString UserFilterModel::filterText() const
+{
+    return m_filterText;
+}
+
+void UserFilterModel::setFilterText(const QString &filterText)
+{
+    m_filterText = filterText;
+    Q_EMIT filterTextChanged();
+    invalidateFilter();
+}

src/models/userfiltermodel.h

@@ -0,0 +1,42 @@
+// SPDX-FileCopyrightText: 2022 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 <QSortFilterProxyModel>
+
+/**
+ * @class UserFilterModel
+ *
+ * This class creates a custom QSortFilterProxyModel for filtering a users by either
+ * display name or matrix ID. The filter can accept a full matrix id i.e. example:kde.org
+ * to separate between accounts on different servers with similar names.
+ */
+class UserFilterModel : public QSortFilterProxyModel
+{
+    Q_OBJECT
+
+    /**
+     * @brief This property hold the text of the filter.
+     *
+     * The text is either a desired display name or matrix id.
+     */
+    Q_PROPERTY(QString filterText READ filterText WRITE setFilterText NOTIFY filterTextChanged)
+
+public:
+    /**
+     * @brief Custom filter function checking boith the display name and matrix ID.
+     *
+     * @note The filter cannot be modified and will always use the same filter properties.
+     */
+    bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
+
+    QString filterText() const;
+    void setFilterText(const QString &filterText);
+
+Q_SIGNALS:
+    void filterTextChanged();
+
+private:
+    QString m_filterText;
+};

src/models/userlistmodel.cpp

@@ -0,0 +1,235 @@
+// SPDX-FileCopyrightText: 2018-2020 Black Hat <bhat@encom.eu.org>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include "userlistmodel.h"
+
+#include <connection.h>
+#include <events/roompowerlevelsevent.h>
+
+#include "neochatroom.h"
+#include "neochatuser.h"
+
+using namespace Quotient;
+
+UserListModel::UserListModel(QObject *parent)
+    : QAbstractListModel(parent)
+    , m_currentRoom(nullptr)
+{
+}
+
+void UserListModel::setRoom(NeoChatRoom *room)
+{
+    if (m_currentRoom == room) {
+        return;
+    }
+
+    beginResetModel();
+    if (m_currentRoom) {
+        m_currentRoom->disconnect(this);
+        //    m_currentRoom->connection()->disconnect(this);
+        for (User *user : std::as_const(m_users)) {
+            user->disconnect(this);
+        }
+        m_users.clear();
+    }
+    m_currentRoom = room;
+    if (m_currentRoom) {
+        connect(m_currentRoom, &Room::userAdded, this, &UserListModel::userAdded);
+        connect(m_currentRoom, &Room::userRemoved, this, &UserListModel::userRemoved);
+        connect(m_currentRoom, &Room::memberAboutToRename, this, &UserListModel::userRemoved);
+        connect(m_currentRoom, &Room::memberRenamed, this, &UserListModel::userAdded);
+        connect(m_currentRoom, &Room::changed, this, &UserListModel::refreshAll);
+        {
+            m_users = m_currentRoom->users();
+            std::sort(m_users.begin(), m_users.end(), room->memberSorter());
+        }
+        for (User *user : std::as_const(m_users)) {
+#ifdef QUOTIENT_07
+            connect(user, &User::defaultAvatarChanged, this, [this, user]() {
+                avatarChanged(user, m_currentRoom);
+            });
+#else
+            connect(user, &User::avatarChanged, this, &UserListModel::avatarChanged);
+#endif
+        }
+        connect(m_currentRoom->connection(), &Connection::loggedOut, this, [this]() {
+            setRoom(nullptr);
+        });
+    }
+    endResetModel();
+    Q_EMIT roomChanged();
+}
+
+NeoChatRoom *UserListModel::room() const
+{
+    return m_currentRoom;
+}
+
+Quotient::User *UserListModel::userAt(QModelIndex index) const
+{
+    if (index.row() < 0 || index.row() >= m_users.size()) {
+        return nullptr;
+    }
+    return m_users.at(index.row());
+}
+
+QVariant UserListModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid()) {
+        return QVariant();
+    }
+
+    if (index.row() >= m_users.count()) {
+        return QStringLiteral("DEADBEEF");
+    }
+    auto user = m_users.at(index.row());
+    if (role == NameRole) {
+        return user->displayname(m_currentRoom);
+    }
+    if (role == UserIdRole) {
+        return user->id();
+    }
+    if (role == AvatarRole) {
+        return user->avatarMediaId(m_currentRoom);
+    }
+    if (role == ObjectRole) {
+        return QVariant::fromValue(user);
+    }
+    if (role == PowerLevelRole) {
+        auto pl = m_currentRoom->getCurrentState<RoomPowerLevelsEvent>();
+        return pl->powerLevelForUser(user->id());
+    }
+    if (role == PowerLevelStringRole) {
+#ifdef QUOTIENT_07
+        auto pl = m_currentRoom->currentState().get<RoomPowerLevelsEvent>();
+#else
+        auto pl = m_currentRoom->getCurrentState<RoomPowerLevelsEvent>();
+#endif
+        // User might not in the room yet, in this case pl can be nullptr.
+        // e.g. When invited but user not accepted or denied the invitation.
+        if (!pl) {
+            return QStringLiteral("Not Available");
+        }
+
+        auto userPl = pl->powerLevelForUser(user->id());
+
+        switch (userPl) {
+        case 0:
+            return QStringLiteral("Member");
+        case 50:
+            return QStringLiteral("Moderator");
+        case 100:
+            return QStringLiteral("Admin");
+        default:
+            return QStringLiteral("Custom");
+        }
+    }
+
+    return {};
+}
+
+int UserListModel::rowCount(const QModelIndex &parent) const
+{
+    if (parent.isValid()) {
+        return 0;
+    }
+
+    return m_users.count();
+}
+
+void UserListModel::userAdded(Quotient::User *user)
+{
+    auto pos = findUserPos(user);
+    beginInsertRows(QModelIndex(), pos, pos);
+    m_users.insert(pos, user);
+    endInsertRows();
+#ifdef QUOTIENT_07
+    connect(user, &User::defaultAvatarChanged, this, [this, user]() {
+        avatarChanged(user, m_currentRoom);
+    });
+#else
+    connect(user, &Quotient::User::avatarChanged, this, &UserListModel::avatarChanged);
+#endif
+}
+
+void UserListModel::userRemoved(Quotient::User *user)
+{
+    auto pos = findUserPos(user);
+    if (pos != m_users.size()) {
+        beginRemoveRows(QModelIndex(), pos, pos);
+        m_users.removeAt(pos);
+        endRemoveRows();
+        user->disconnect(this);
+    } else {
+        qWarning() << "Trying to remove a room member not in the user list";
+    }
+}
+
+void UserListModel::refresh(Quotient::User *user, const QVector<int> &roles)
+{
+    auto pos = findUserPos(user);
+    if (pos != m_users.size()) {
+        Q_EMIT dataChanged(index(pos), index(pos), roles);
+    } else {
+        qWarning() << "Trying to access a room member not in the user list";
+    }
+}
+
+void UserListModel::refreshAll()
+{
+    beginResetModel();
+    for (User *user : std::as_const(m_users)) {
+        user->disconnect(this);
+    }
+    m_users.clear();
+
+    {
+        m_users = m_currentRoom->users();
+        std::sort(m_users.begin(), m_users.end(), m_currentRoom->memberSorter());
+    }
+    for (User *user : std::as_const(m_users)) {
+#ifdef QUOTIENT_07
+        connect(user, &User::defaultAvatarChanged, this, [this, user]() {
+            avatarChanged(user, m_currentRoom);
+        });
+#else
+        connect(user, &User::avatarChanged, this, &UserListModel::avatarChanged);
+#endif
+    }
+    connect(m_currentRoom->connection(), &Connection::loggedOut, this, [this]() {
+        setRoom(nullptr);
+    });
+    endResetModel();
+    Q_EMIT usersRefreshed();
+}
+
+void UserListModel::avatarChanged(Quotient::User *user, const Quotient::Room *context)
+{
+    if (context == m_currentRoom) {
+        refresh(user, {AvatarRole});
+    }
+}
+
+int UserListModel::findUserPos(Quotient::User *user) const
+{
+    return findUserPos(m_currentRoom->safeMemberName(user->id()));
+}
+
+int UserListModel::findUserPos(const QString &username) const
+{
+    return m_currentRoom->memberSorter().lowerBoundIndex(m_users, username);
+}
+
+QHash<int, QByteArray> UserListModel::roleNames() const
+{
+    QHash<int, QByteArray> roles;
+
+    roles[NameRole] = "name";
+    roles[UserIdRole] = "userId";
+    roles[AvatarRole] = "avatar";
+    roles[ObjectRole] = "user";
+    roles[PowerLevelRole] = "powerLevel";
+    roles[PowerLevelStringRole] = "powerLevelString";
+
+    return roles;
+}

src/models/userlistmodel.h

@@ -0,0 +1,78 @@
+// SPDX-FileCopyrightText: 2018 Black Hat <bhat@encom.eu.org>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#pragma once
+
+#include <room.h>
+
+#include <QAbstractListModel>
+#include <QObject>
+
+class NeoChatRoom;
+
+namespace Quotient
+{
+class User;
+class Room;
+}
+
+class UserType : public QObject
+{
+    Q_OBJECT
+
+public:
+    enum Types {
+        Owner = 1,
+        Admin,
+        Moderator,
+        Member,
+        Muted,
+        Custom,
+    };
+    Q_ENUM(Types)
+};
+
+class UserListModel : public QAbstractListModel
+{
+    Q_OBJECT
+    Q_PROPERTY(NeoChatRoom *room READ room WRITE setRoom NOTIFY roomChanged)
+public:
+    enum EventRoles {
+        NameRole = Qt::UserRole + 1,
+        UserIdRole,
+        AvatarRole,
+        ObjectRole,
+        PowerLevelRole,
+        PowerLevelStringRole,
+    };
+
+    UserListModel(QObject *parent = nullptr);
+
+    [[nodiscard]] NeoChatRoom *room() const;
+    void setRoom(NeoChatRoom *room);
+
+    [[nodiscard]] Quotient::User *userAt(QModelIndex index) const;
+
+    [[nodiscard]] QVariant data(const QModelIndex &index, int role = NameRole) const override;
+    [[nodiscard]] int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+
+    [[nodiscard]] QHash<int, QByteArray> roleNames() const override;
+
+Q_SIGNALS:
+    void roomChanged();
+    void usersRefreshed();
+
+private Q_SLOTS:
+    void userAdded(Quotient::User *user);
+    void userRemoved(Quotient::User *user);
+    void refresh(Quotient::User *user, const QVector<int> &roles = {});
+    void refreshAll();
+    void avatarChanged(Quotient::User *user, const Quotient::Room *context);
+
+private:
+    NeoChatRoom *m_currentRoom;
+    QList<Quotient::User *> m_users;
+
+    int findUserPos(Quotient::User *user) const;
+    [[nodiscard]] int findUserPos(const QString &username) const;
+};

src/models/webshortcutmodel.cpp

@@ -0,0 +1,131 @@
+// SPDX-FileCopyrightText: 2010 Eike Hein <hein@kde.org>
+// SPDX-FileCopyrightText: 2021 Carl Schwan <carl@carlschwan.eu>
+// SPDX-License-Identifier: LGPL-2.0-or-later
+
+#include "webshortcutmodel.h"
+
+#ifdef HAVE_KIO
+#include <KIO/CommandLauncherJob>
+#include <KUriFilter>
+#endif
+#include <KStringHandler>
+
+struct KWebShortcutModelPrivate {
+    QString selectedText;
+#ifdef HAVE_KIO
+    KUriFilterData filterData;
+#endif
+    QStringList searchProviders;
+};
+
+KWebShortcutModel::KWebShortcutModel(QObject *parent)
+    : QAbstractListModel(parent)
+    , d(new KWebShortcutModelPrivate)
+{
+}
+
+KWebShortcutModel::~KWebShortcutModel()
+{
+}
+
+QString KWebShortcutModel::selectedText() const
+{
+    return d->selectedText;
+}
+
+QString KWebShortcutModel::trunkatedSearchText() const
+{
+    return KStringHandler::rsqueeze(d->selectedText, 21);
+}
+
+bool KWebShortcutModel::enabled() const
+{
+#ifdef HAVE_KIO
+    return true;
+#else
+    return false;
+#endif
+}
+
+void KWebShortcutModel::setSelectedText(const QString &selectedText)
+{
+    if (d->selectedText == selectedText) {
+        return;
+    }
+#ifdef HAVE_KIO
+    beginResetModel();
+    d->selectedText = selectedText;
+
+    if (selectedText.isEmpty()) {
+        endResetModel();
+        return;
+    }
+
+    QString searchText = selectedText;
+    searchText = searchText.replace('\n', ' ').replace('\r', ' ').simplified();
+    if (searchText.isEmpty()) {
+        endResetModel();
+        return;
+    }
+    d->filterData.setData(searchText);
+    d->filterData.setSearchFilteringOptions(KUriFilterData::RetrievePreferredSearchProvidersOnly);
+
+    if (KUriFilter::self()->filterSearchUri(d->filterData, KUriFilter::NormalTextFilter)) {
+        d->searchProviders = d->filterData.preferredSearchProviders();
+    }
+    endResetModel();
+#else
+    d->selectedText = selectedText;
+#endif
+    Q_EMIT selectedTextChanged();
+}
+
+int KWebShortcutModel::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent);
+#ifdef HAVE_KIO
+    if (d->selectedText.count() > 0) {
+        return d->searchProviders.count();
+    }
+#endif
+    return 0;
+}
+
+QVariant KWebShortcutModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid()) {
+        return {};
+    }
+
+#ifdef HAVE_KIO
+    switch (role) {
+    case Qt::DisplayRole:
+        return d->searchProviders[index.row()];
+    case Qt::DecorationRole:
+        return d->filterData.iconNameForPreferredSearchProvider(d->searchProviders[index.row()]);
+    case Qt::EditRole:
+        return d->filterData.queryForPreferredSearchProvider(d->searchProviders[index.row()]);
+    }
+#endif
+    return {};
+}
+
+void KWebShortcutModel::trigger(const QString &data)
+{
+#ifdef HAVE_KIO
+    KUriFilterData filterData(data);
+    if (KUriFilter::self()->filterSearchUri(filterData, KUriFilter::WebShortcutFilter)) {
+        Q_EMIT openUrl(filterData.uri().url());
+    }
+#else
+    Q_UNUSED(data);
+#endif
+}
+
+void KWebShortcutModel::configureWebShortcuts()
+{
+#ifdef HAVE_KIO
+    auto job = new KIO::CommandLauncherJob("kcmshell5", QStringList() << "webshortcuts", this);
+    job->exec();
+#endif
+}

src/models/webshortcutmodel.h

@@ -0,0 +1,68 @@
+// SPDX-FileCopyrightText: 2021 Carl Schwan <carl@carlschwan.eu>
+// SPDX-License-Identifier: LGPL-2.0-or-later
+
+#pragma once
+
+#include <QAbstractListModel>
+#include <memory>
+
+struct KWebShortcutModelPrivate;
+
+//! List model of web shortcuts for a a specified selectedText.
+//!
+//! This can be used as following in your QML code
+//!
+//! ```qml
+//! QQC2.Menu {
+//!     id: webshortcutmenu
+//!     title: i18n("Search for '%1'", webshortcutmodel.trunkatedSearchText)
+//!     property bool isVisible: selectedText && selectedText.length > 0 && webshortcutmodel.enabled
+//!     Component.onCompleted: webshortcutmenu.parent.visible = isVisible
+//!     onIsVisibleChanged: webshortcutmenu.parent.visible = isVisible
+//!     Instantiator {
+//!         model: WebShortcutModel {
+//!             id: webshortcutmodel
+//!             selectedText: loadRoot.selectedText
+//!             onOpenUrl: Qt.openUrlExternally(url)
+//!         }
+//!         delegate: QQC2.MenuItem {
+//!             text: model.display
+//!             icon.name: model.decoration
+//!             onTriggered: webshortcutmodel.trigger(model.edit)
+//!         }
+//!         onObjectAdded: webshortcutmenu.insertItem(0, object)
+//!     }
+//!     QQC2.MenuSeparator {}
+//!     QQC2.MenuItem {
+//!         text: i18n("Configure Web Shortcuts...")
+//!         icon.name: "configure"
+//!         onTriggered: webshortcutmodel.configureWebShortcuts()
+//!     }
+//! }
+//! ```
+class KWebShortcutModel : public QAbstractListModel
+{
+    Q_OBJECT
+    Q_PROPERTY(QString selectedText READ selectedText WRITE setSelectedText NOTIFY selectedTextChanged)
+    Q_PROPERTY(QString trunkatedSearchText READ trunkatedSearchText NOTIFY selectedTextChanged)
+    Q_PROPERTY(bool enabled READ enabled CONSTANT)
+public:
+    explicit KWebShortcutModel(QObject *parent = nullptr);
+    ~KWebShortcutModel();
+
+    QString selectedText() const;
+    void setSelectedText(const QString &selectedText);
+    QString trunkatedSearchText() const;
+    bool enabled() const;
+
+    int rowCount(const QModelIndex &parent) const override;
+    QVariant data(const QModelIndex &index, int role) const override;
+    Q_INVOKABLE void trigger(const QString &data);
+    Q_INVOKABLE void configureWebShortcuts();
+Q_SIGNALS:
+    void selectedTextChanged();
+    void openUrl(const QUrl &url);
+
+private:
+    std::unique_ptr<KWebShortcutModelPrivate> d;
+};