GIT_SILENT Update Appstream for new release

(cherry picked from commit b009b9aac0)

.flatpak-manifest.json

@@ -2,7 +2,7 @@
     "id": "org.kde.neochat",
     "branch": "master",
     "runtime": "org.kde.Platform",
-    "runtime-version": "6.9",
+    "runtime-version": "6.10",
     "sdk": "org.kde.Sdk",
     "command": "neochat",
     "tags": [
@@ -31,19 +31,6 @@
         "/share/ndk-modules"
     ],
     "modules": [
-        {
-            "name": "kirigamiaddons",
-            "config-opts": [
-                "-DBUILD_TESTING=OFF"
-            ],
-            "buildsystem": "cmake-ninja",
-            "sources": [
-                {
-                    "type": "git",
-                    "url": "https://invent.kde.org/libraries/kirigami-addons.git"
-                }
-            ]
-        },
         {
             "name": "opencv",
             "config-opts": [
@@ -78,6 +65,7 @@
             "name": "olm",
             "buildsystem": "cmake-ninja",
             "config-opts": [
+                "-DCMAKE_POLICY_VERSION_MINIMUM=3.5",
                 "-DOLM_TESTS=OFF"
             ],
             "sources": [
@@ -184,8 +172,8 @@
             "sources": [
                 {
                     "type": "archive",
-                    "url": "https://download.kde.org/stable/release-service/25.08.0/src/kunifiedpush-25.08.0.tar.xz",
-                    "sha256": "846db6ffc7d93f6afea7ce0d5a9f10b52792157ceb593856542279f4197f3518",
+                    "url": "https://download.kde.org/stable/release-service/25.08.3/src/kunifiedpush-25.08.3.tar.xz",
+                    "sha256": "e8c924438d5359f0fa0930ab35111012076e3a0ff4e959d6929595571383320a",
                     "x-checker-data": {
                         "type": "anitya",
                         "project-id": 8763,

.gitlab-ci.yml

@@ -12,7 +12,7 @@ include:
       - /gitlab-templates/linux-qt6.yml
       - /gitlab-templates/linux-qt6-next.yml
       - /gitlab-templates/windows-qt6.yml
-      - /gitlab-templates/freebsd-qt6.yml
+      # - /gitlab-templates/freebsd-qt6.yml
       - /gitlab-templates/flatpak.yml
       - /gitlab-templates/snap-snapcraft-lxd.yml
       - /gitlab-templates/craft-android-qt6-apks.yml

.kde-ci.yml

@@ -10,6 +10,7 @@ Dependencies:
       'frameworks/ki18n': '@latest-kf6'
       'frameworks/kconfig': '@latest-kf6'
       'frameworks/syntax-highlighting': '@latest-kf6'
+      'frameworks/kiconthemes': '@latest-kf6'
       'frameworks/kitemmodels': '@latest-kf6'
       'frameworks/kquickcharts': '@latest-kf6'
       'frameworks/knotifications': '@latest-kf6'
@@ -27,7 +28,6 @@ Dependencies:
       'frameworks/qqc2-desktop-style': '@latest-kf6'
       'frameworks/kio': '@latest-kf6'
       'frameworks/kwindowsystem': '@latest-kf6'
-      'frameworks/kstatusnotifieritem': '@latest-kf6'
   - 'on': ['Linux', 'FreeBSD']
     'require':
       'frameworks/kdbusaddons': '@latest-kf6'
@@ -42,3 +42,4 @@ Options:
   per-test-timeout: 90
   require-passing-tests-on: ['Linux', 'Android', 'FreeBSD', 'Windows']
   run-qmllint: True
+  enable-lsan: True

CMakeLists.txt

@@ -7,9 +7,9 @@
 cmake_minimum_required(VERSION 3.16)
 
 # KDE Applications version, managed by release script.
-set(RELEASE_SERVICE_VERSION_MAJOR "25")
-set(RELEASE_SERVICE_VERSION_MINOR "11")
-set(RELEASE_SERVICE_VERSION_MICRO "90")
+set(RELEASE_SERVICE_VERSION_MAJOR "26")
+set(RELEASE_SERVICE_VERSION_MINOR "03")
+set(RELEASE_SERVICE_VERSION_MICRO "70")
 set(RELEASE_SERVICE_VERSION "${RELEASE_SERVICE_VERSION_MAJOR}.${RELEASE_SERVICE_VERSION_MINOR}.${RELEASE_SERVICE_VERSION_MICRO}")
 
 project(NeoChat VERSION ${RELEASE_SERVICE_VERSION})
@@ -46,10 +46,6 @@ if (NOT ANDROID)
     include(KDEClangFormat)
 endif()
 
-if(NEOCHAT_FLATPAK)
-    include(cmake/Flatpak.cmake)
-endif()
-
 set(QUOTIENT_FORCE_NAMESPACED_INCLUDES TRUE)
 
 ecm_set_disabled_deprecation_versions(Qt 6.9.0 KF 6.17.0)
@@ -69,7 +65,7 @@ if (QT_KNOWN_POLICY_QTP0004)
 qt_policy(SET QTP0004 NEW)
 endif ()
 
-find_package(KF6 ${KF_MIN_VERSION} COMPONENTS Kirigami I18n Notifications Config CoreAddons Sonnet ItemModels ColorScheme)
+find_package(KF6 ${KF_MIN_VERSION} COMPONENTS Kirigami I18n Notifications Config CoreAddons Sonnet ItemModels ColorScheme IconThemes)
 set_package_properties(KF6 PROPERTIES
     TYPE REQUIRED
     PURPOSE "Basic application components"
@@ -92,7 +88,7 @@ if(ANDROID)
     )
 else()
     find_package(Qt6 ${QT_MIN_VERSION} COMPONENTS Widgets)
-    find_package(KF6 ${KF_MIN_VERSION} REQUIRED COMPONENTS QQC2DesktopStyle KIO WindowSystem StatusNotifierItem)
+    find_package(KF6 ${KF_MIN_VERSION} REQUIRED COMPONENTS QQC2DesktopStyle KIO WindowSystem)
     find_package(KF6SyntaxHighlighting ${KF_MIN_VERSION} REQUIRED)
     set_package_properties(KF6QQC2DesktopStyle PROPERTIES
         TYPE RUNTIME
@@ -110,7 +106,7 @@ if (NOT ANDROID AND NOT WIN32 AND NOT APPLE AND NOT HAIKU)
     find_package(KF6DBusAddons ${KF_MIN_VERSION} REQUIRED)
 endif()
 
-find_package(QuotientQt6 0.9.3)
+find_package(QuotientQt6 0.9.5)
 set_package_properties(QuotientQt6 PROPERTIES
     TYPE REQUIRED
     DESCRIPTION "Qt wrapper around Matrix API"
@@ -182,7 +178,7 @@ add_definitions(-DQT_NO_FOREACH)
 add_subdirectory(src)
 
 if (BUILD_TESTING)
-    find_package(Qt6 ${QT_MIN_VERSION} NO_MODULE COMPONENTS Test HttpServer)
+    find_package(Qt6 ${QT_MIN_VERSION} NO_MODULE COMPONENTS Test HttpServer QuickTest)
     add_subdirectory(autotests)
     # add_subdirectory(appiumtests)
     if (NOT ANDROID)

README.md

@@ -25,15 +25,10 @@ Qt-based SDK for the [Matrix Protocol](https://spec.matrix.org/).
 
 ## Features
 
-NeoChat aims to be a fully featured application for the Matrix specification. As such most parts of the current specification are supported, with the notable exceptions
-of VoIP, threads, and some aspects of End-to-End Encryption. There are a few other smaller omissions due to the fact that the Matrix spec is constantly
+NeoChat aims to be a fully featured application for the Matrix specification. As such, most parts of the current specification are supported, with the notable exceptions
+of VoIP, threads, and some aspects of End-to-End Encryption. There are a few other smaller omissions due to the Matrix spec constantly
 evolving, but the aim remains to provide eventual support for the entire spec.
 
-Due to the nature of the Matrix specification development NeoChat also supports numerous unstable features. Currently these are:
-- Polls - MSC3381
-- Sticker Packs - MSC2545
-- Location Events - MSC3488
-
 ## Get it
 
 Details where to find stable releases for NeoChat can be found on its [homepage](https://apps.kde.org/neochat).
@@ -48,12 +43,12 @@ The best way to build KDE apps during development is to use `kdesrc-build`. The
 the KDE community website's get involved section under [development](https://community.kde.org/Get_Involved/development). This
 is primarily aimed at Linux development.
 
-For Windows and Android [Craft](https://invent.kde.org/packaging/craft) is the primary choice. There are guides for setting up
+For Windows and Android, [Craft](https://invent.kde.org/packaging/craft) is the primary choice. There are guides for setting up
 development environments for [Windows](https://community.kde.org/Get_Involved/development/Windows) and [Android](https://develop.kde.org/docs/packaging/android/building_applications/).
 
 ## Running
 
-Just start the executable in your preferred way - either from the build directory or from the installed location.
+Start the executable in your preferred way – either from the build directory or from the installed location.
 
 ## Tests
 
@@ -66,12 +61,12 @@ be complete.
 
 ![coverage](https://invent.kde.org/network/neochat/badges/master/pipeline.svg)
 
-Currently the number of tests is limited, but growing. If anyone wants to help improve this, those
+Currently, the number of tests is limited but growing. If anyone wants to help improve this, those
 contributions would be especially welcome.
 
 ## Contributing
 
-As is the case throughout the KDE ecosystem contributions are welcome from all. The code base is managed in the
+As is the case throughout the KDE ecosystem, contributions are welcome from all. The code base is managed in the
 [NeoChat repository](https://invent.kde.org/network/neochat) of the KDE Gitlab instance.
 
 - [Code of Conduct](https://kde.org/code-of-conduct)
@@ -86,7 +81,7 @@ The best place to reach the maintainers is on the KDE Matrix instance in the Neo
 
 ## Acknowledgement
 
-NeoChat utilizes [libQuotient](https://github.com/quotient-im/libQuotient/) as its Matrix SDK.
+NeoChat uses [libQuotient](https://github.com/quotient-im/libQuotient/) as its Matrix SDK.
 
 NeoChat is a fork of [Spectral](https://gitlab.com/spectral-im/spectral/).
 

autotests/CMakeLists.txt

@@ -11,7 +11,7 @@ add_definitions(-DDATA_DIR="${CMAKE_CURRENT_SOURCE_DIR}/data" )
 
 ecm_add_test(
     neochatroomtest.cpp
-    LINK_LIBRARIES neochat Qt::Test
+    LINK_LIBRARIES neochat Qt::Test Qt::HttpServer neochat_server
     TEST_NAME neochatroomtest
 )
 
@@ -41,16 +41,10 @@ ecm_add_test(
 
 ecm_add_test(
     chatbarcachetest.cpp
-    LINK_LIBRARIES neochat Qt::Test
+    LINK_LIBRARIES neochat Qt::Test Qt::HttpServer neochat_server
     TEST_NAME chatbarcachetest
 )
 
-ecm_add_test(
-    chatdocumenthandlertest.cpp
-    LINK_LIBRARIES neochat Qt::Test
-    TEST_NAME chatdocumenthandlertest
-)
-
 ecm_add_test(
     timelinemessagemodeltest.cpp
     LINK_LIBRARIES neochat Qt::Test
@@ -104,3 +98,51 @@ ecm_add_test(
     LINK_LIBRARIES neochat Qt::Test neochat_server
     TEST_NAME roommanagertest
 )
+
+ecm_add_test(
+    modeltest.cpp
+    LINK_LIBRARIES neochat Qt::Test neochat_server Devtools
+    TEST_NAME modeltest
+)
+
+ecm_add_test(
+    blockcachetest.cpp
+    LINK_LIBRARIES neochat Qt::Test
+    TEST_NAME blockcachetest
+)
+
+macro(add_qml_tests)
+    if (WIN32)
+        set(_extra_args -platform offscreen)
+    endif()
+
+    foreach(test ${ARGV})
+        add_test(NAME ${test}
+                COMMAND qmltest
+                ${_extra_args}
+                -input ${test}
+                WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        )
+    endforeach()
+endmacro()
+
+add_executable(qmltest qmltest.cpp
+    chatkeyhelpertesthelper.h
+    chatmarkdownhelpertestwrapper.h
+    chattextitemhelpertesthelper.h
+)
+qt_add_qml_module(qmltest URI NeoChatTestUtils)
+
+target_link_libraries(qmltest
+    PRIVATE
+    Qt6::Qml
+    Qt6::QuickTest
+    LibNeoChat
+    LibNeoChatplugin
+)
+
+add_qml_tests(
+    chattextitemhelpertest.qml
+    chatmarkdownhelpertest.qml
+    chatkeyhelpertest.qml
+)

autotests/actionstest.cpp

@@ -7,7 +7,9 @@
 #include <QVariantList>
 
 #include "accountmanager.h"
+#include "blockcache.h"
 #include "chatbarcache.h"
+#include "enums/messagecomponenttype.h"
 #include "models/actionsmodel.h"
 
 #include "server.h"
@@ -63,7 +65,7 @@ void ActionsTest::testActions_data()
     QTest::addColumn<std::optional<QString>>("resultText");
     QTest::addColumn<std::optional<Quotient::RoomMessageEvent::MsgType>>("type");
 
-    QTest::newRow("shrug") << u"/shrug Hello"_s << std::make_optional(u"¯\\\\_(ツ)_/¯ Hello"_s)
+    QTest::newRow("shrug") << u"/shrug Hello"_s << std::make_optional(u"¯\\\\\\_(ツ)\\_/¯ Hello"_s)
                            << std::make_optional(Quotient::RoomMessageEvent::MsgType::Text);
     QTest::newRow("lenny") << u"/lenny Hello"_s << std::make_optional(u"( ͡° ͜ʖ ͡°) Hello"_s) << std::make_optional(Quotient::RoomMessageEvent::MsgType::Text);
     QTest::newRow("tableflip") << u"/tableflip Hello"_s << std::make_optional(u"(╯°□°）╯︵ ┻━┻ Hello"_s)
@@ -88,8 +90,8 @@ void ActionsTest::testActions()
     QFETCH(std::optional<QString>, resultText);
     QFETCH(std::optional<Quotient::RoomMessageEvent::MsgType>, type);
 
-    auto cache = new ChatBarCache();
-    cache->setText(command);
+    auto cache = new ChatBarCache(room);
+    cache->cache() += Block::CacheItem{.type = MessageComponentType::Text, .content = QTextDocumentFragment::fromMarkdown(command)};
     auto result = ActionsModel::handleAction(room, cache);
     QCOMPARE(resultText, std::get<std::optional<QString>>(result));
     QCOMPARE(type, std::get<std::optional<Quotient::RoomMessageEvent::MsgType>>(result));

autotests/blockcachetest.cpp

@@ -0,0 +1,52 @@
+// SPDX-FileCopyrightText: 2026 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 <QObject>
+#include <QTest>
+
+#include "blockcache.h"
+
+#include "enums/messagecomponenttype.h"
+
+using namespace Block;
+
+class BlockCacheTest : public QObject
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    void toStringTest_data();
+    void toStringTest();
+};
+
+void BlockCacheTest::toStringTest_data()
+{
+    QTest::addColumn<QString>("inputString");
+    QTest::addColumn<MessageComponentType::Type>("itemType");
+    QTest::addColumn<QString>("outputstring");
+
+    QTest::newRow("plainText") << u"test string"_s << MessageComponentType::Text << u"test string"_s;
+    QTest::newRow("list") << u"- list 1\n- list 2\n- list 3\n"_s << MessageComponentType::Text << u"- list 1\n- list 2\n- list 3"_s;
+    QTest::newRow("code") << u"for (some code) {\n\n    do something\n\n}"_s << MessageComponentType::Code
+                          << u"```\nfor (some code) {\n    do something\n}\n```"_s;
+    QTest::newRow("quote") << u"\"this is a quote\""_s << MessageComponentType::Quote << u"> this is a quote"_s;
+    QTest::newRow("heading") << u"# heading\n\nnext line"_s << MessageComponentType::Text << u"# heading\n\nnext line"_s;
+}
+
+void BlockCacheTest::toStringTest()
+{
+    QFETCH(QString, inputString);
+    QFETCH(MessageComponentType::Type, itemType);
+    QFETCH(QString, outputstring);
+
+    Cache cache;
+    cache += CacheItem{
+        .type = itemType,
+        .content = QTextDocumentFragment::fromMarkdown(inputString),
+    };
+
+    QCOMPARE(cache.toString(), outputstring);
+}
+
+QTEST_MAIN(BlockCacheTest)
+#include "blockcachetest.moc"

autotests/chatbarcachetest.cpp

@@ -11,9 +11,14 @@
 #include <Quotient/syncdata.h>
 #include <qtestcase.h>
 
+#include <KLocalizedString>
+
+#include "accountmanager.h"
+#include "blockcache.h"
 #include "chatbarcache.h"
 #include "neochatroom.h"
 
+#include "server.h"
 #include "testutils.h"
 
 using namespace Quotient;
@@ -24,14 +29,14 @@ class ChatBarCacheTest : public QObject
 
 private:
     Connection *connection = nullptr;
-    TestUtils::TestRoom *room = nullptr;
+    NeoChatRoom *room = nullptr;
+    Server server;
+    QString eventId;
 
 private Q_SLOTS:
     void initTestCase();
 
     void empty();
-    void noRoom();
-    void badParent();
     void reply();
     void replyMissingUser();
     void edit();
@@ -40,15 +45,38 @@ private Q_SLOTS:
 
 void ChatBarCacheTest::initTestCase()
 {
-    connection = Connection::makeMockConnection(u"@bob:kde.org"_s);
-    room = new TestUtils::TestRoom(connection, u"#myroom:kde.org"_s, "test-min-sync.json"_L1);
+    Connection::setRoomType<NeoChatRoom>();
+    server.start();
+    KLocalizedString::setApplicationDomain(QByteArrayLiteral("neochat"));
+    auto accountManager = new AccountManager(true, this);
+    QSignalSpy spy(accountManager, &AccountManager::connectionAdded);
+    connection = dynamic_cast<NeoChatConnection *>(accountManager->accounts()->front());
+
+    const auto roomId = server.createRoom(u"@user:localhost:1234"_s);
+    eventId = server.sendEvent(roomId,
+                               u"m.room.message"_s,
+                               QJsonObject{
+                                   {u"body"_s, u"foo"_s},
+                                   {u"msgtype"_s, u"m.text"_s},
+                               });
+
+    QSignalSpy syncSpy(connection, &Connection::syncDone);
+    // We need to wait for two syncs, as the next one won't have the changes yet
+    QVERIFY(syncSpy.wait());
+    QVERIFY(syncSpy.wait());
+    room = dynamic_cast<NeoChatRoom *>(connection->room(roomId));
+    QVERIFY(room);
+
+    server.joinUser(room->id(), u"@foo:server.com"_s);
+    QVERIFY(syncSpy.wait());
+    QVERIFY(syncSpy.wait());
 }
 
 void ChatBarCacheTest::empty()
 {
     QScopedPointer<ChatBarCache> chatBarCache(new ChatBarCache(room));
 
-    QCOMPARE(chatBarCache->text(), QString());
+    QCOMPARE(chatBarCache->cache().toString(), QString());
     QCOMPARE(chatBarCache->isReplying(), false);
     QCOMPARE(chatBarCache->replyId(), QString());
     QCOMPARE(chatBarCache->isEditing(), false);
@@ -58,51 +86,20 @@ void ChatBarCacheTest::empty()
     QCOMPARE(chatBarCache->attachmentPath(), QString());
 }
 
-void ChatBarCacheTest::noRoom()
-{
-    QScopedPointer<ChatBarCache> chatBarCache(new ChatBarCache());
-    chatBarCache->setReplyId(u"$153456789:example.org"_s);
-
-    // These should return empty even though a reply ID has been set because the
-    // ChatBarCache has no parent.
-
-    QTest::ignoreMessage(QtWarningMsg, "ChatBarCache created with no parent, a NeoChatRoom must be set as the parent on creation.");
-    QCOMPARE(chatBarCache->relationAuthor(), Quotient::RoomMember());
-
-    QTest::ignoreMessage(QtWarningMsg, "ChatBarCache created with no parent, a NeoChatRoom must be set as the parent on creation.");
-    QCOMPARE(chatBarCache->relationMessage(), QString());
-}
-
-void ChatBarCacheTest::badParent()
-{
-    QScopedPointer<QObject> badParent(new QObject());
-    QScopedPointer<ChatBarCache> chatBarCache(new ChatBarCache(badParent.get()));
-    chatBarCache->setReplyId(u"$153456789:example.org"_s);
-
-    // These should return empty even though a reply ID has been set because the
-    // ChatBarCache has no parent.
-
-    QTest::ignoreMessage(QtWarningMsg, "ChatBarCache created with incorrect parent, a NeoChatRoom must be set as the parent on creation.");
-    QCOMPARE(chatBarCache->relationAuthor(), Quotient::RoomMember());
-
-    QTest::ignoreMessage(QtWarningMsg, "ChatBarCache created with incorrect parent, a NeoChatRoom must be set as the parent on creation.");
-    QCOMPARE(chatBarCache->relationMessage(), QString());
-}
-
 void ChatBarCacheTest::reply()
 {
     QScopedPointer<ChatBarCache> chatBarCache(new ChatBarCache(room));
-    chatBarCache->setText(u"some text"_s);
+    chatBarCache->cache() += Block::CacheItem{.type = MessageComponentType::Text, .content = QTextDocumentFragment::fromMarkdown(u"some text"_s)};
     chatBarCache->setAttachmentPath(u"some/path"_s);
-    chatBarCache->setReplyId(u"$153456789:example.org"_s);
+    chatBarCache->setReplyId(eventId);
 
-    QCOMPARE(chatBarCache->text(), u"some text"_s);
+    QCOMPARE(chatBarCache->cache().toString(), u"some text"_s);
     QCOMPARE(chatBarCache->isReplying(), true);
-    QCOMPARE(chatBarCache->replyId(), u"$153456789:example.org"_s);
+    QCOMPARE(chatBarCache->replyId(), eventId);
     QCOMPARE(chatBarCache->isEditing(), false);
     QCOMPARE(chatBarCache->editId(), QString());
-    QCOMPARE(chatBarCache->relationAuthor(), room->member(u"@example:example.org"_s));
-    QCOMPARE(chatBarCache->relationMessage(), u"This is an example\ntext message"_s);
+    QCOMPARE(chatBarCache->relationAuthor(), room->member(u"@foo:server.com"_s));
+    QCOMPARE(chatBarCache->relationMessage(), u"foo"_s);
     QCOMPARE(chatBarCache->attachmentPath(), QString());
     QCOMPARE(chatBarCache->relationAuthorIsPresent(), true);
 }
@@ -110,24 +107,28 @@ void ChatBarCacheTest::reply()
 void ChatBarCacheTest::replyMissingUser()
 {
     QScopedPointer<ChatBarCache> chatBarCache(new ChatBarCache(room));
-    chatBarCache->setText(u"some text"_s);
+    chatBarCache->cache() += Block::CacheItem{.type = MessageComponentType::Text, .content = QTextDocumentFragment::fromMarkdown(u"some text"_s)};
     chatBarCache->setAttachmentPath(u"some/path"_s);
-    chatBarCache->setReplyId(u"$153456789:example.org"_s);
+    chatBarCache->setReplyId(eventId);
 
-    QCOMPARE(chatBarCache->text(), u"some text"_s);
+    QCOMPARE(chatBarCache->cache().toString(), u"some text"_s);
     QCOMPARE(chatBarCache->isReplying(), true);
-    QCOMPARE(chatBarCache->replyId(), u"$153456789:example.org"_s);
+    QCOMPARE(chatBarCache->replyId(), eventId);
     QCOMPARE(chatBarCache->isEditing(), false);
     QCOMPARE(chatBarCache->editId(), QString());
-    QCOMPARE(chatBarCache->relationAuthor(), room->member(u"@example:example.org"_s));
-    QCOMPARE(chatBarCache->relationMessage(), u"This is an example\ntext message"_s);
+    QCOMPARE(chatBarCache->relationAuthor(), room->member(u"@foo:server.com"_s));
+    QCOMPARE(chatBarCache->relationMessage(), u"foo"_s);
     QCOMPARE(chatBarCache->attachmentPath(), QString());
     QCOMPARE(chatBarCache->relationAuthorIsPresent(), true);
 
     QSignalSpy relationAuthorIsPresentSpy(chatBarCache.get(), &ChatBarCache::relationAuthorIsPresentChanged);
 
     // sync again, which will simulate the reply user leaving the room
-    room->syncNewEvents(u"test-min-sync-extra-sync.json"_s);
+
+    QSignalSpy syncSpy(connection, &Connection::syncDone);
+    server.sendStateEvent(room->id(), u"m.room.member"_s, u"@foo:server.com"_s, {{u"membership"_s, u"leave"_s}});
+    QVERIFY(syncSpy.wait());
+    QVERIFY(syncSpy.wait());
 
     QTRY_COMPARE(relationAuthorIsPresentSpy.count(), 1);
     QCOMPARE(chatBarCache->relationAuthorIsPresent(), false);
@@ -137,32 +138,32 @@ void ChatBarCacheTest::edit()
 {
     QScopedPointer<ChatBarCache> chatBarCache(new ChatBarCache(room));
 
-    chatBarCache->setText(u"some text"_s);
+    chatBarCache->cache() += Block::CacheItem{.type = MessageComponentType::Text, .content = QTextDocumentFragment::fromMarkdown(u"some text"_s)};
     chatBarCache->setAttachmentPath(u"some/path"_s);
-    connect(chatBarCache.get(), &ChatBarCache::relationIdChanged, this, [](const QString &oldEventId, const QString &newEventId) {
+    connect(chatBarCache.get(), &ChatBarCache::relationIdChanged, this, [this](const QString &oldEventId, const QString &newEventId) {
         QCOMPARE(oldEventId, QString());
-        QCOMPARE(newEventId, QString(u"$153456789:example.org"_s));
+        QCOMPARE(newEventId, eventId);
     });
-    chatBarCache->setEditId(u"$153456789:example.org"_s);
+    chatBarCache->setEditId(eventId);
 
-    QCOMPARE(chatBarCache->text(), u"some text"_s);
+    QCOMPARE(chatBarCache->cache().toString(), u"some text"_s);
     QCOMPARE(chatBarCache->isReplying(), false);
     QCOMPARE(chatBarCache->replyId(), QString());
     QCOMPARE(chatBarCache->isEditing(), true);
-    QCOMPARE(chatBarCache->editId(), u"$153456789:example.org"_s);
-    QCOMPARE(chatBarCache->relationAuthor(), room->member(u"@example:example.org"_s));
-    QCOMPARE(chatBarCache->relationMessage(), u"This is an example\ntext message"_s);
+    QCOMPARE(chatBarCache->editId(), eventId);
+    QCOMPARE(chatBarCache->relationAuthor(), room->member(u"@foo:server.com"_s));
+    QCOMPARE(chatBarCache->relationMessage(), u"foo"_s);
     QCOMPARE(chatBarCache->attachmentPath(), QString());
 }
 
 void ChatBarCacheTest::attachment()
 {
     QScopedPointer<ChatBarCache> chatBarCache(new ChatBarCache(room));
-    chatBarCache->setText(u"some text"_s);
-    chatBarCache->setEditId(u"$153456789:example.org"_s);
+    chatBarCache->cache() += Block::CacheItem{.type = MessageComponentType::Text, .content = QTextDocumentFragment::fromMarkdown(u"some text"_s)};
+    chatBarCache->setEditId(eventId);
     chatBarCache->setAttachmentPath(u"some/path"_s);
 
-    QCOMPARE(chatBarCache->text(), u"some text"_s);
+    QCOMPARE(chatBarCache->cache().toString(), u"some text"_s);
     QCOMPARE(chatBarCache->isReplying(), false);
     QCOMPARE(chatBarCache->replyId(), QString());
     QCOMPARE(chatBarCache->isEditing(), false);

autotests/chatdocumenthandlertest.cpp

@@ -1,36 +0,0 @@
-// SPDX-FileCopyrightText: 2023 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 <QObject>
-#include <QTest>
-
-#include "chatdocumenthandler.h"
-#include "neochatconfig.h"
-
-class ChatDocumentHandlerTest : public QObject
-{
-    Q_OBJECT
-
-private:
-    ChatDocumentHandler emptyHandler;
-
-private Q_SLOTS:
-    void initTestCase();
-
-    void nullComplete();
-};
-
-void ChatDocumentHandlerTest::initTestCase()
-{
-    // HACK: this is to stop KStatusNotifierItem SEGFAULTING on cleanup.
-    NeoChatConfig::self()->setSystemTray(false);
-}
-
-void ChatDocumentHandlerTest::nullComplete()
-{
-    QTest::ignoreMessage(QtWarningMsg, "complete called with m_document set to nullptr.");
-    emptyHandler.complete(0);
-}
-
-QTEST_MAIN(ChatDocumentHandlerTest)
-#include "chatdocumenthandlertest.moc"

autotests/chatkeyhelpertest.qml

@@ -0,0 +1,88 @@
+// SPDX-FileCopyrightText: 2026 James Graham <james.h.graham@protonmail.com>
+// SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
+
+import QtQuick
+import QtTest
+
+import org.kde.neochat.libneochat
+
+import NeoChatTestUtils
+
+TestCase {
+    name: "ChatKeyHelperTest"
+
+    TextEdit {
+        id: textEdit
+
+        Keys.onPressed: (event) => {
+            event.accepted = testHelper.keyHelper.handleKey(event.key, event.modifiers);
+        }
+    }
+
+    ChatTextItemHelper {
+        id: textItemHelper
+
+        textItem: textEdit
+    }
+
+    ChatKeyHelperTestHelper {
+        id: testHelper
+
+        textItem: textItemHelper
+    }
+
+    SignalSpy {
+        id: spyUp
+        target: testHelper.keyHelper
+        signalName: "unhandledUp"
+    }
+
+    SignalSpy {
+        id: spyDown
+        target: testHelper.keyHelper
+        signalName: "unhandledDown"
+    }
+
+    SignalSpy {
+        id: spyDelete
+        target: testHelper.keyHelper
+        signalName: "unhandledDelete"
+    }
+
+    SignalSpy {
+        id: spyBackSpace
+        target: testHelper.keyHelper
+        signalName: "unhandledBackspace"
+    }
+
+    function init(): void {
+        textEdit.clear();
+        spyUp.clear();
+        spyDown.clear();
+        spyDelete.clear();
+        spyBackSpace.clear();
+        textEdit.forceActiveFocus();
+    }
+
+    function cleanupTestCase(): void {
+        testHelper.textItem = null;
+        textItemHelper.textItem = null;
+    }
+
+    function test_upDown(): void {
+        textEdit.insert(0, "line 1\nline 2\nline 3")
+        textEdit.cursorPosition = 0;
+        keyClick(Qt.Key_Up);
+        compare(spyUp.count, 1);
+        compare(spyDown.count, 0);
+        keyClick(Qt.Key_Down);
+        compare(spyUp.count, 1);
+        compare(spyDown.count, 0);
+        keyClick(Qt.Key_Down);
+        compare(spyUp.count, 1);
+        compare(spyDown.count, 0);
+        keyClick(Qt.Key_Down);
+        compare(spyUp.count, 1);
+        compare(spyDown.count, 1);
+    }
+}

autotests/chatkeyhelpertesthelper.h

@@ -0,0 +1,54 @@
+// SPDX-FileCopyrightText: 2025 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 <QObject>
+#include <QQuickItem>
+#include <QQuickTextDocument>
+#include <QTextCursor>
+#include <QTextDocumentFragment>
+
+#include "chatkeyhelper.h"
+#include "chattextitemhelper.h"
+
+class ChatKeyHelperTestHelper : public QObject
+{
+    Q_OBJECT
+    QML_ELEMENT
+
+    Q_PROPERTY(ChatTextItemHelper *textItem READ textItem WRITE setTextItem NOTIFY textItemChanged)
+
+    Q_PROPERTY(ChatKeyHelper *keyHelper READ keyHelper CONSTANT)
+
+public:
+    explicit ChatKeyHelperTestHelper(QObject *parent = nullptr)
+        : QObject(parent)
+        , m_keyHelper(new ChatKeyHelper(this))
+    {
+    }
+
+    ChatTextItemHelper *textItem() const
+    {
+        return m_keyHelper->textItem();
+    }
+    void setTextItem(ChatTextItemHelper *textItem)
+    {
+        if (textItem == m_keyHelper->textItem()) {
+            return;
+        }
+        m_keyHelper->setTextItem(textItem);
+        Q_EMIT textItemChanged();
+    }
+
+    ChatKeyHelper *keyHelper() const
+    {
+        return m_keyHelper;
+    }
+
+Q_SIGNALS:
+    void textItemChanged();
+
+private:
+    QPointer<ChatKeyHelper> m_keyHelper;
+};

autotests/chatmarkdownhelpertest.qml

@@ -0,0 +1,173 @@
+// SPDX-FileCopyrightText: 2026 James Graham <james.h.graham@protonmail.com>
+// SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
+
+import QtQuick
+import QtTest
+
+import org.kde.neochat.libneochat
+
+import NeoChatTestUtils
+
+TestCase {
+    name: "ChatMarkdownHelperTest"
+
+    TextEdit {
+        id: textEdit
+
+        textFormat: TextEdit.RichText
+    }
+
+    TextEdit {
+        id: textEdit2
+    }
+
+    ChatMarkdownHelperTestWrapper {
+        id: chatMarkdownHelper
+
+        textItem: textEdit
+    }
+
+    SignalSpy {
+        id: spyItem
+        target: chatMarkdownHelper
+        signalName: "textItemChanged"
+    }
+
+    SignalSpy {
+        id: spyUnhandledFormat
+        target: chatMarkdownHelper
+        signalName: "unhandledBlockFormat"
+    }
+
+    function initTestCase(): void {
+        textEdit.forceActiveFocus();
+    }
+
+    function cleanup(): void {
+        chatMarkdownHelper.clear();
+        compare(chatMarkdownHelper.checkText(""), true);
+        compare(chatMarkdownHelper.checkFormats([]), true);
+        compare(textEdit.cursorPosition, 0);
+    }
+
+    function test_item(): void {
+        spyItem.clear();
+        compare(chatMarkdownHelper.textItem, textEdit);
+        chatMarkdownHelper.textItem = textEdit2;
+        compare(chatMarkdownHelper.textItem, textEdit2);
+        chatMarkdownHelper.textItem = textEdit;
+        compare(chatMarkdownHelper.textItem, textEdit);
+    }
+
+    function test_textFormat_data() {
+        return [
+            {tag: "bold", input: "**b** ", outText: ["*", "**", "b", "b*", "b**", "b "], outFormats: [[], [], [RichFormat.Bold], [RichFormat.Bold], [RichFormat.Bold], []], unhandled: 0},
+            {tag: "italic", input: "*i* ", outText: ["*", "i", "i*", "i "], outFormats: [[], [RichFormat.Italic], [RichFormat.Italic], []], unhandled: 0},
+            {tag: "heading 1", input: "# h", outText: ["#", "# ", "h"], outFormats: [[], [], [RichFormat.Bold, RichFormat.Heading1]], unhandled: 0},
+            {tag: "heading 2", input: "## h", outText: ["#", "##", "## ", "h"], outFormats: [[], [], [], [RichFormat.Bold, RichFormat.Heading2]], unhandled: 0},
+            {tag: "heading 3", input: "### h", outText: ["#", "##", "###", "### ", "h"], outFormats: [[], [], [], [], [RichFormat.Bold, RichFormat.Heading3]], unhandled: 0},
+            {tag: "heading 4", input: "#### h", outText: ["#", "##", "###", "####", "#### ", "h"], outFormats: [[], [], [], [], [], [RichFormat.Bold, RichFormat.Heading4]], unhandled: 0},
+            {tag: "heading 5", input: "##### h", outText: ["#", "##", "###", "####", "#####", "##### ", "h"], outFormats: [[], [], [], [], [], [], [RichFormat.Bold, RichFormat.Heading5]], unhandled: 0},
+            {tag: "heading 6", input: "###### h", outText: ["#", "##", "###", "####", "#####", "######", "###### ", "h"], outFormats: [[], [], [], [], [], [] ,[], [RichFormat.Bold, RichFormat.Heading6]], unhandled: 0},
+            {tag: "quote", input: "> q", outText: [">", "> ", "q"], outFormats: [[], [], []], unhandled: 1},
+            {tag: "quote - no space", input: ">q", outText: [">", "q"], outFormats: [[], [], []], unhandled: 1},
+            {tag: "unorderedlist 1", input: "* l", outText: ["*", "* ", "l"], outFormats: [[], [], [RichFormat.UnorderedList]], unhandled: 0},
+            {tag: "unorderedlist 2", input: "- l", outText: ["-", "- ", "l"], outFormats: [[], [], [RichFormat.UnorderedList]], unhandled: 0},
+            {tag: "orderedlist 1", input: "1. l", outText: ["1", "1.", "1. ", "l"], outFormats: [[], [], [], [RichFormat.OrderedList]], unhandled: 0},
+            {tag: "orderedlist 2", input: "1) l", outText: ["1", "1)", "1) ", "l"], outFormats: [[], [], [], [RichFormat.OrderedList]], unhandled: 0},
+            {tag: "inline code", input: "`c` ", outText: ["`", "c", "c`", "c "], outFormats: [[], [RichFormat.InlineCode], [RichFormat.InlineCode], []], unhandled: 0},
+            {tag: "code", input: "``` ", outText: ["`", "``", "```", " "], outFormats: [[], [], [], []], unhandled: 1},
+            {tag: "strikethrough", input: "~~s~~ ", outText: ["~", "~~", "s", "s~", "s~~", "s "], outFormats: [[], [], [RichFormat.Strikethrough], [RichFormat.Strikethrough], [RichFormat.Strikethrough], []], unhandled: 0},
+            {tag: "underline", input: "_u_ ", outText: ["_", "u", "u_", "u "], outFormats: [[], [RichFormat.Underline], [RichFormat.Underline], []], unhandled: 0},
+            {tag: "multiple closable", input: "***_~~t~~_*** ", outText: ["*", "**", "*", "_", "~", "~~", "t", "t~", "t~~", "t_", "t*", "t**", "t*", "t "], outFormats: [[], [], [RichFormat.Bold], [RichFormat.Bold, RichFormat.Italic], [RichFormat.Bold, RichFormat.Italic, RichFormat.Underline], [RichFormat.Bold, RichFormat.Italic, RichFormat.Underline], [RichFormat.Bold, RichFormat.Italic, RichFormat.Underline, RichFormat.Strikethrough], [RichFormat.Bold, RichFormat.Italic, RichFormat.Underline, RichFormat.Strikethrough], [RichFormat.Bold, RichFormat.Italic, RichFormat.Underline, RichFormat.Strikethrough], [RichFormat.Bold, RichFormat.Italic, RichFormat.Underline], [RichFormat.Bold, RichFormat.Italic], [RichFormat.Bold, RichFormat.Italic], [RichFormat.Italic], []], unhandled: 0},
+            {tag: "nonclosable closable", input: "* **b** ", outText: ["*", "* ", "*", "**", "b", "b*", "b**", "b "], outFormats: [[], [], [RichFormat.UnorderedList], [RichFormat.UnorderedList], [RichFormat.Bold, RichFormat.UnorderedList], [RichFormat.Bold, RichFormat.UnorderedList], [RichFormat.Bold, RichFormat.UnorderedList], [RichFormat.UnorderedList]], unhandled: 0},
+            {tag: "not at line start", input: " 1) ", outText: [" ", " 1", " 1)", " 1) "], outFormats: [[], [], [], []], unhandled: 0},
+        ]
+    }
+
+    function test_textFormat(data): void {
+        spyUnhandledFormat.clear();
+        compare(spyUnhandledFormat.count, 0);
+
+        for (let i = 0; i < data.input.length; i++) {
+            keyClick(data.input[i]);
+            compare(chatMarkdownHelper.checkText(data.outText[i]), true);
+            compare(chatMarkdownHelper.checkFormats(data.outFormats[i]), true);
+        }
+
+        compare(spyUnhandledFormat.count, data.unhandled);
+    }
+
+    function test_backspace(): void {
+        keyClick("*");
+        compare(chatMarkdownHelper.checkText("*"), true);
+        compare(chatMarkdownHelper.checkFormats([]), true);
+        keyClick("*");
+        compare(chatMarkdownHelper.checkText("**"), true);
+        compare(chatMarkdownHelper.checkFormats([]), true);
+        keyClick("b");
+        compare(chatMarkdownHelper.checkText("b"), true);
+        compare(chatMarkdownHelper.checkFormats([RichFormat.Bold]), true);
+        keyClick("o");
+        compare(chatMarkdownHelper.checkText("bo"), true);
+        compare(chatMarkdownHelper.checkFormats([RichFormat.Bold]), true);
+        keyClick("l");
+        compare(chatMarkdownHelper.checkText("bol"), true);
+        compare(chatMarkdownHelper.checkFormats([RichFormat.Bold]), true);
+        keyClick("d");
+        compare(chatMarkdownHelper.checkText("bold"), true);
+        compare(chatMarkdownHelper.checkFormats([RichFormat.Bold]), true);
+        keyClick(Qt.Key_Backspace);
+        compare(chatMarkdownHelper.checkText("bol"), true);
+        compare(chatMarkdownHelper.checkFormats([RichFormat.Bold]), true);
+        keyClick(Qt.Key_Backspace);
+        compare(chatMarkdownHelper.checkText("bo"), true);
+        compare(chatMarkdownHelper.checkFormats([RichFormat.Bold]), true);
+        keyClick("*");
+        compare(chatMarkdownHelper.checkText("bo*"), true);
+        compare(chatMarkdownHelper.checkFormats([RichFormat.Bold]), true);
+        keyClick("*");
+        compare(chatMarkdownHelper.checkText("bo**"), true);
+        compare(chatMarkdownHelper.checkFormats([RichFormat.Bold]), true);
+        keyClick(" ");
+        compare(chatMarkdownHelper.checkText("bo "), true);
+        compare(chatMarkdownHelper.checkFormats([]), true);
+    }
+
+    function test_cursorMove(): void {
+        keyClick("t");
+        keyClick("e");
+        keyClick("s");
+        keyClick("t");
+        compare(chatMarkdownHelper.checkText("test"), true);
+        compare(chatMarkdownHelper.checkFormats([]), true);
+        keyClick("*");
+        keyClick("*");
+        keyClick("b");
+        compare(chatMarkdownHelper.checkText("testb"), true);
+        compare(chatMarkdownHelper.checkFormats([RichFormat.Bold]), true);
+        textEdit.cursorPosition = 2;
+        keyClick("*");
+        keyClick("*");
+        keyClick("b");
+        compare(chatMarkdownHelper.checkText("tebstb"), true);
+        compare(chatMarkdownHelper.checkFormats([]), true);
+    }
+
+    function test_insertText(): void {
+        textEdit.insert(0, "test");
+        compare(chatMarkdownHelper.checkText("test"), true);
+        compare(chatMarkdownHelper.checkFormats([]), true);
+        textEdit.insert(4, "**b");
+        compare(chatMarkdownHelper.checkText("test**b"), true);
+        compare(chatMarkdownHelper.checkFormats([]), true);
+
+        textEdit.clear();
+        textEdit.insert(0, "test");
+        compare(chatMarkdownHelper.checkText("test"), true);
+        compare(chatMarkdownHelper.checkFormats([]), true);
+        textEdit.insert(2, "**b");
+        compare(chatMarkdownHelper.checkText("te**bst"), true);
+        compare(chatMarkdownHelper.checkFormats([]), true);
+    }
+}

autotests/chatmarkdownhelpertestwrapper.h

@@ -0,0 +1,82 @@
+// SPDX-FileCopyrightText: 2025 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 <QObject>
+#include <QQuickItem>
+#include <QTextCursor>
+
+#include "chatmarkdownhelper.h"
+#include "chattextitemhelper.h"
+#include "enums/richformat.h"
+
+class ChatMarkdownHelperTestWrapper : public QObject
+{
+    Q_OBJECT
+    QML_ELEMENT
+
+    /**
+     * @brief The QML text Item the ChatMerkdownHelper is handling.
+     */
+    Q_PROPERTY(QQuickItem *textItem READ textItem WRITE setTextItem NOTIFY textItemChanged)
+
+public:
+    explicit ChatMarkdownHelperTestWrapper(QObject *parent = nullptr)
+        : QObject(parent)
+        , m_chatMarkdownHelper(new ChatMarkdownHelper(this))
+        , m_textItem(new ChatTextItemHelper(this))
+    {
+        m_chatMarkdownHelper->setTextItem(m_textItem);
+
+        connect(m_chatMarkdownHelper, &ChatMarkdownHelper::textItemChanged, this, &ChatMarkdownHelperTestWrapper::textItemChanged);
+        connect(m_chatMarkdownHelper, &ChatMarkdownHelper::unhandledBlockFormat, this, &ChatMarkdownHelperTestWrapper::unhandledBlockFormat);
+    }
+
+    QQuickItem *textItem() const
+    {
+        return m_textItem->textItem();
+    }
+    void setTextItem(QQuickItem *textItem)
+    {
+        m_textItem->setTextItem(textItem);
+    }
+
+    Q_INVOKABLE bool checkText(const QString &text)
+    {
+        const auto doc = m_textItem->document();
+        if (!doc) {
+            return false;
+        }
+        return text == doc->toPlainText();
+    }
+
+    Q_INVOKABLE bool checkFormats(QList<RichFormat::Format> formats)
+    {
+        const auto cursor = m_textItem->textCursor();
+        if (cursor.isNull()) {
+            return false;
+        }
+        return RichFormat::formatsAtCursor(cursor) == formats;
+    }
+
+    Q_INVOKABLE void clear()
+    {
+        auto cursor = m_textItem->textCursor();
+        if (cursor.isNull()) {
+            return;
+        }
+        cursor.select(QTextCursor::Document);
+        cursor.removeSelectedText();
+        cursor.setBlockCharFormat(RichFormat::charFormatForFormat(RichFormat::Paragraph));
+        cursor.setBlockFormat(RichFormat::blockFormatForFormat(RichFormat::Paragraph));
+    }
+
+Q_SIGNALS:
+    void textItemChanged();
+    void unhandledBlockFormat(RichFormat::Format format);
+
+private:
+    QPointer<ChatMarkdownHelper> m_chatMarkdownHelper;
+    QPointer<ChatTextItemHelper> m_textItem;
+};

autotests/chattextitemhelpertest.qml

@@ -0,0 +1,301 @@
+// SPDX-FileCopyrightText: 2026 James Graham <james.h.graham@protonmail.com>
+// SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
+
+import QtQuick
+import QtTest
+
+import org.kde.neochat.libneochat
+
+import NeoChatTestUtils
+
+TestCase {
+    name: "ChatTextItemHelperTest"
+
+    TextEdit {
+        id: textEdit
+    }
+
+    TextEdit {
+        id: textEdit2
+    }
+
+    ChatTextItemHelper {
+        id: textItemHelper
+
+        textItem: textEdit
+    }
+
+    ChatTextItemHelperTestHelper {
+        id: testHelper
+
+        textItem: textItemHelper
+    }
+
+    SignalSpy {
+        id: spyItem
+        target: textItemHelper
+        signalName: "textItemChanged"
+    }
+
+    SignalSpy {
+        id: spyContentsChanged
+        target: textItemHelper
+        signalName: "contentsChanged"
+    }
+
+    SignalSpy {
+        id: spyContentsChange
+        target: textItemHelper
+        signalName: "contentsChange"
+    }
+
+    SignalSpy {
+        id: spyCursor
+        target: textItemHelper
+        signalName: "cursorPositionChanged"
+    }
+
+    function init(): void {
+        testHelper.setFixedChars("", "");
+        textEdit.clear();
+        textEdit2.clear();
+        spyItem.clear();
+        spyContentsChange.clear();
+        spyContentsChanged.clear();
+        spyCursor.clear();
+    }
+
+    function cleanupTestCase(): void {
+        testHelper.textItem = null;
+        textItemHelper.textItem = null;
+    }
+
+    function test_item(): void {
+        compare(textItemHelper.textItem, textEdit);
+        compare(spyItem.count, 0);
+        textItemHelper.textItem = textEdit2;
+        compare(textItemHelper.textItem, textEdit2);
+        compare(spyItem.count, 1);
+        textItemHelper.textItem = textEdit;
+        compare(textItemHelper.textItem, textEdit);
+        compare(spyItem.count, 2);
+    }
+
+    function test_fixedChars(): void {
+        textEdit.forceActiveFocus();
+        testHelper.setFixedChars("1", "2");
+        compare(textEdit.text, "12");
+        compare(textEdit.cursorPosition, 1);
+        compare(spyCursor.count, 0);
+        keyClick("b");
+        compare(textEdit.text, "1b2");
+        compare(textEdit.cursorPosition, 2);
+        compare(spyCursor.count, 1);
+        keyClick(Qt.Key_Left);
+        compare(textEdit.text, "1b2");
+        compare(textEdit.cursorPosition, 1);
+        compare(spyCursor.count, 2);
+        keyClick(Qt.Key_Left);
+        compare(textEdit.text, "1b2");
+        compare(textEdit.cursorPosition, 1);
+        compare(spyCursor.count, 3);
+        keyClick(Qt.Key_Right);
+        compare(textEdit.text, "1b2");
+        compare(textEdit.cursorPosition, 2);
+        compare(spyCursor.count, 4);
+        keyClick(Qt.Key_Right);
+        compare(textEdit.text, "1b2");
+        compare(textEdit.cursorPosition, 2);
+        compare(spyCursor.count, 5);
+    }
+
+    function test_document(): void {
+        // We can't get to the QTextDocument from QML so we have to use a helper function.
+        compare(testHelper.compareDocuments(textEdit.textDocument), true);
+
+        textEdit.insert(0, "test text");
+        compare(testHelper.lineCount(), 1);
+        textEdit.insert(textEdit.text.length, "\ntest text");
+        compare(testHelper.lineCount(), 2);
+        textEdit.clear()
+        compare(textEdit.text.length, 0);
+    }
+
+    function test_takeFirstBlock(): void {
+        textEdit.insert(0, "test text");
+        compare(testHelper.firstBlockText(), "test text");
+        compare(textEdit.text.length, 0);
+        textEdit.insert(0, "test text\nmore test text");
+        compare(testHelper.firstBlockText(), "test text");
+        compare(textEdit.text, "more test text");
+        compare(testHelper.firstBlockText(), "more test text");
+        compare(textEdit.text, "");
+        compare(textEdit.text.length, 0);
+    }
+
+    function test_fillFragments(): void {
+        textEdit.insert(0, "before fragment\nmid fragment\nafter fragment");
+        compare(testHelper.checkFragments("before fragment\nmid fragment", "after fragment", ""), true);
+        textEdit.clear();
+        textEdit.insert(0, "before fragment\nmid fragment\nafter fragment");
+        textEdit.cursorPosition = 16;
+        compare(testHelper.checkFragments("before fragment", "mid fragment", "after fragment"), true);
+        textEdit.clear();
+        textEdit.insert(0, "before fragment\nmid fragment\nafter fragment");
+        textEdit.cursorPosition = 29;
+        compare(testHelper.checkFragments("before fragment\nmid fragment", "after fragment", ""), true);
+        textEdit.clear();
+    }
+
+    function test_insertFragment(): void {
+        testHelper.insertFragment("test text");
+        compare(textEdit.text, "test text");
+        compare(textEdit.cursorPosition, 9);
+        testHelper.insertFragment("beginning ", 1);
+        compare(textEdit.text, "beginning test text");
+        compare(textEdit.cursorPosition, 10);
+        testHelper.insertFragment(" end", 2);
+        compare(textEdit.text, "beginning test text end");
+        compare(textEdit.cursorPosition, 23);
+        textEdit.clear();
+
+        testHelper.insertFragment("test text", 0, true);
+        compare(textEdit.text, "test text");
+        compare(textEdit.cursorPosition, 0);
+    }
+
+    function test_cursor(): void {
+        // We can't get to the QTextCursor from QML so we have to use a helper function.
+        compare(testHelper.compareCursor(textEdit.cursorPosition, textEdit.selectionStart, textEdit.selectionEnd), true);
+        compare(textEdit.cursorPosition, testHelper.cursorPosition());
+        // Check we get the appropriate content and cursor change signals when inserting text.
+        textEdit.insert(0, "test text")
+        compare(spyContentsChange.count, 1);
+        compare(spyContentsChange.signalArguments[0][0], 0);
+        compare(spyContentsChange.signalArguments[0][1], 0);
+        compare(spyContentsChange.signalArguments[0][2], 9);
+        compare(spyContentsChanged.count, 1);
+        compare(spyCursor.count, 1);
+        compare(spyCursor.signalArguments[0][0], true);
+        compare(testHelper.compareCursor(textEdit.cursorPosition, textEdit.selectionStart, textEdit.selectionEnd), true);
+        compare(textEdit.cursorPosition, testHelper.cursorPosition());
+        // Check we get only get a cursor change signal when moving the cursor.
+        textEdit.cursorPosition = 4;
+        compare(spyContentsChanged.count, 1);
+        compare(spyCursor.count, 2);
+        compare(spyCursor.signalArguments[1][0], false);
+        textEdit.selectAll();
+        compare(spyContentsChanged.count, 1);
+        compare(spyCursor.count, 2);
+        compare(testHelper.compareCursor(textEdit.cursorPosition, textEdit.selectionStart, textEdit.selectionEnd), true);
+        compare(textEdit.cursorPosition, testHelper.cursorPosition());
+        // Check we get the appropriate content and cursor change signals when removing text.
+        textEdit.clear();
+        compare(spyContentsChange.count, 2);
+        compare(spyContentsChange.signalArguments[1][0], 0);
+        compare(spyContentsChange.signalArguments[1][1], 9);
+        compare(spyContentsChange.signalArguments[1][2], 0);
+        compare(spyContentsChanged.count, 2);
+        compare(spyCursor.count, 3);
+        compare(spyCursor.signalArguments[2][0], true);
+    }
+
+    function test_setCursor(): void {
+        textEdit.insert(0, "test text");
+        compare(textEdit.cursorPosition, 9);
+        compare(spyCursor.count, 1);
+        testHelper.setCursorPosition(5);
+        compare(textEdit.cursorPosition, 5);
+        compare(spyCursor.count, 2);
+        testHelper.setCursorPosition(1);
+        compare(textEdit.cursorPosition, 1);
+        compare(spyCursor.count, 3);
+
+        textEdit.cursorVisible = false;
+        compare(textEdit.cursorVisible, false);
+        testHelper.setCursorVisible(true);
+        compare(textEdit.cursorVisible, true);
+        testHelper.setCursorVisible(false);
+        compare(textEdit.cursorVisible, false);
+    }
+
+    function test_setCursorFromTextItem(): void {
+        textEdit.insert(0, "line 1\nline 2");
+        textEdit2.insert(0, "line 1\nline 2");
+        testHelper.setCursorFromTextItem(textEdit2, false, 0);
+        compare(textEdit.cursorPosition, 7);
+        testHelper.setCursorFromTextItem(textEdit2, true, 7);
+        compare(textEdit.cursorPosition, 0);
+        testHelper.setCursorFromTextItem(textEdit2, false, 1);
+        compare(textEdit.cursorPosition, 8);
+        testHelper.setCursorFromTextItem(textEdit2, true, 8);
+        compare(textEdit.cursorPosition, 1);
+
+        testHelper.setFixedChars("1", "2");
+        testHelper.setCursorFromTextItem(textEdit2, false, 0);
+        compare(textEdit.cursorPosition, 8);
+        testHelper.setCursorFromTextItem(textEdit2, true, 7);
+        compare(textEdit.cursorPosition, 1);
+    }
+
+    function test_mergeFormat(): void {
+        textEdit.insert(0, "lots of text");
+        testHelper.setCursorPosition(0);
+        testHelper.mergeFormatOnCursor(RichFormat.Bold);
+        compare(testHelper.checkFormatsAtCursor([RichFormat.Bold]), true);
+        testHelper.mergeFormatOnCursor(RichFormat.Italic);
+        compare(testHelper.checkFormatsAtCursor([RichFormat.Bold, RichFormat.Italic]), true);
+        testHelper.setCursorPosition(6);
+        compare(testHelper.checkFormatsAtCursor([]), true);
+        testHelper.mergeFormatOnCursor(RichFormat.Underline);
+        compare(testHelper.checkFormatsAtCursor([RichFormat.Underline]), true);
+        testHelper.setCursorPosition(9);
+        compare(testHelper.checkFormatsAtCursor([]), true);
+        testHelper.mergeFormatOnCursor(RichFormat.Strikethrough);
+        compare(testHelper.checkFormatsAtCursor([RichFormat.Strikethrough]), true);
+        textEdit.clear();
+
+        textEdit.insert(0, "heading");
+        testHelper.mergeFormatOnCursor(RichFormat.Heading1);
+        compare(testHelper.checkFormatsAtCursor([RichFormat.Bold, RichFormat.Heading1]), true);
+        testHelper.mergeFormatOnCursor(RichFormat.Heading2);
+        compare(testHelper.checkFormatsAtCursor([RichFormat.Bold, RichFormat.Heading2]), true);
+        testHelper.mergeFormatOnCursor(RichFormat.Paragraph);
+        compare(testHelper.checkFormatsAtCursor([]), true);
+        textEdit.clear();
+
+        textEdit.insert(0, "text");
+        testHelper.mergeFormatOnCursor(RichFormat.UnorderedList);
+        compare(testHelper.checkFormatsAtCursor([RichFormat.UnorderedList]), true);
+        compare(testHelper.markdownText(), "- text");
+        testHelper.mergeFormatOnCursor(RichFormat.OrderedList);
+        compare(testHelper.checkFormatsAtCursor([RichFormat.OrderedList]), true);
+        compare(testHelper.markdownText(), "1.  text");
+        textEdit.clear();
+    }
+
+    function test_list(): void {
+        compare(testHelper.canIndentListMoreAtCursor(), true);
+        testHelper.indentListMoreAtCursor();
+        compare(testHelper.canIndentListMoreAtCursor(), true);
+        testHelper.indentListMoreAtCursor();
+        compare(testHelper.canIndentListMoreAtCursor(), true);
+        testHelper.indentListMoreAtCursor();
+        compare(testHelper.canIndentListMoreAtCursor(), false);
+
+        compare(testHelper.canIndentListLessAtCursor(), true);
+        testHelper.indentListLessAtCursor();
+        compare(testHelper.canIndentListLessAtCursor(), true);
+        testHelper.indentListLessAtCursor();
+        compare(testHelper.canIndentListLessAtCursor(), true);
+        testHelper.indentListLessAtCursor();
+        compare(testHelper.canIndentListLessAtCursor(), false);
+    }
+
+    function test_forceActiveFocus(): void {
+        textEdit2.forceActiveFocus();
+        compare(textEdit.activeFocus, false);
+        testHelper.forceActiveFocus();
+        compare(textEdit.activeFocus, true);
+    }
+}

autotests/chattextitemhelpertesthelper.h

@@ -0,0 +1,218 @@
+// SPDX-FileCopyrightText: 2025 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 <QObject>
+#include <QQuickItem>
+#include <QQuickTextDocument>
+#include <QTextCursor>
+#include <QTextDocumentFragment>
+
+#include "chattextitemhelper.h"
+
+class ChatTextItemHelperTestHelper : public QObject
+{
+    Q_OBJECT
+    QML_ELEMENT
+
+    /**
+     * @brief The QML text Item the TextItemHelper is handling.
+     */
+    Q_PROPERTY(ChatTextItemHelper *textItem READ textItem WRITE setTextItem NOTIFY textItemChanged)
+
+public:
+    explicit ChatTextItemHelperTestHelper(QObject *parent = nullptr)
+        : QObject(parent)
+    {
+    }
+
+    ChatTextItemHelper *textItem() const
+    {
+        return m_textItem;
+    }
+    void setTextItem(ChatTextItemHelper *textItem)
+    {
+        if (textItem == m_textItem) {
+            return;
+        }
+        m_textItem = textItem;
+        Q_EMIT textItemChanged();
+    }
+
+    Q_INVOKABLE void setFixedChars(const QString &startChars, const QString &endChars)
+    {
+        if (!m_textItem) {
+            return;
+        }
+        m_textItem->setFixedChars(startChars, endChars);
+    }
+
+    Q_INVOKABLE bool compareDocuments(QQuickTextDocument *document)
+    {
+        if (!m_textItem) {
+            return false;
+        }
+        return document->textDocument() == m_textItem->document();
+    }
+
+    Q_INVOKABLE int lineCount()
+    {
+        if (!m_textItem) {
+            return -1;
+        }
+        return m_textItem->lineCount();
+    }
+
+    Q_INVOKABLE QString firstBlockText()
+    {
+        if (!m_textItem) {
+            return {};
+        }
+        return m_textItem->takeFirstBlock().toPlainText();
+    }
+
+    Q_INVOKABLE bool checkFragments(const QString &before, const QString &mid, const QString &after)
+    {
+        if (!m_textItem) {
+            return false;
+        }
+
+        bool hasBefore = false;
+        QTextDocumentFragment midFragment;
+        std::optional<QTextDocumentFragment> afterFragment = std::nullopt;
+        m_textItem->fillFragments(hasBefore, midFragment, afterFragment);
+
+        return hasBefore && m_textItem->document()->toPlainText() == before && midFragment.toPlainText() == mid && after.isEmpty()
+            ? !afterFragment
+            : afterFragment->toPlainText() == after;
+    }
+
+    Q_INVOKABLE void insertFragment(const QString &text, ChatTextItemHelper::InsertPosition position = ChatTextItemHelper::Cursor, bool keepPosition = false)
+    {
+        if (!m_textItem) {
+            return;
+        }
+        const auto fragment = QTextDocumentFragment::fromPlainText(text);
+        m_textItem->insertFragment(fragment, position, keepPosition);
+    }
+
+    Q_INVOKABLE bool compareCursor(int cursorPosition, int selectionStart, int selectionEnd)
+    {
+        if (!m_textItem) {
+            return false;
+        }
+        const auto cursor = m_textItem->textCursor();
+        if (cursor.isNull()) {
+            return false;
+        }
+        const auto posSame = cursor.position() == cursorPosition;
+        const auto startSame = cursor.selectionStart() == selectionStart;
+        const auto endSame = cursor.selectionEnd() == selectionEnd;
+        return posSame && startSame && endSame;
+    }
+
+    Q_INVOKABLE int cursorPosition() const
+    {
+        if (!m_textItem) {
+            return -1;
+        }
+        return *m_textItem->cursorPosition();
+    }
+
+    Q_INVOKABLE void setCursorPosition(int pos)
+    {
+        if (!m_textItem) {
+            return;
+        }
+        m_textItem->setCursorPosition(pos);
+    }
+
+    Q_INVOKABLE void setCursorVisible(bool visible)
+    {
+        if (!m_textItem) {
+            return;
+        }
+        m_textItem->setCursorVisible(visible);
+    }
+
+    Q_INVOKABLE void setCursorFromTextItem(QQuickItem *item, bool infront, int cursorPos)
+    {
+        if (!m_textItem) {
+            return;
+        }
+        const auto textItem = new ChatTextItemHelper(this);
+        textItem->setTextItem(item);
+        textItem->setCursorPosition(cursorPos);
+        m_textItem->setCursorFromTextItem(textItem, infront);
+        textItem->deleteLater();
+    }
+
+    Q_INVOKABLE void mergeFormatOnCursor(RichFormat::Format format)
+    {
+        if (!m_textItem) {
+            return;
+        }
+        m_textItem->mergeFormatOnCursor(format);
+    }
+
+    Q_INVOKABLE bool checkFormatsAtCursor(QList<RichFormat::Format> formats)
+    {
+        const auto cursor = m_textItem->textCursor();
+        if (cursor.isNull()) {
+            return false;
+        }
+        return RichFormat::formatsAtCursor(cursor) == formats;
+    }
+
+    Q_INVOKABLE bool canIndentListMoreAtCursor() const
+    {
+        if (!m_textItem) {
+            return false;
+        }
+        return m_textItem->canIndentListMoreAtCursor();
+    }
+    Q_INVOKABLE bool canIndentListLessAtCursor() const
+    {
+        if (!m_textItem) {
+            return false;
+        }
+        return m_textItem->canIndentListLessAtCursor();
+    }
+    Q_INVOKABLE void indentListMoreAtCursor()
+    {
+        if (!m_textItem) {
+            return;
+        }
+        m_textItem->indentListMoreAtCursor();
+    }
+    Q_INVOKABLE void indentListLessAtCursor()
+    {
+        if (!m_textItem) {
+            return;
+        }
+        m_textItem->indentListLessAtCursor();
+    }
+
+    Q_INVOKABLE void forceActiveFocus() const
+    {
+        if (!m_textItem) {
+            return;
+        }
+        m_textItem->forceActiveFocus();
+    }
+
+    Q_INVOKABLE QString markdownText() const
+    {
+        if (!m_textItem) {
+            return {};
+        }
+        return m_textItem->markdownText();
+    }
+
+Q_SIGNALS:
+    void textItemChanged();
+
+private:
+    QPointer<ChatTextItemHelper> m_textItem;
+};

autotests/data/test-min-sync-extra-sync.json

@@ -1,20 +0,0 @@
-{
-  "state": {
-    "events": [
-      {
-        "content": {
-          "membership": "leave"
-        },
-        "event_id": "$1432735824666PhrSA:example.org",
-        "origin_server_ts": 1432735824666,
-        "room_id": "!jEsUZKDJdhlrceRyVU:example.org",
-        "sender": "@example:example.org",
-        "state_key": "@example:example.org",
-        "type": "m.room.member",
-        "unsigned": {
-          "replaces_state": "$143273582443PhrSn:example.org"
-        }
-      }
-    ]
-  }
-}

autotests/eventhandlertest.cpp

@@ -40,7 +40,6 @@ private Q_SLOTS:
     void nullSingleLineDisplayName();
     void time();
     void nullTime();
-    void timeString();
     void highlighted();
     void nullHighlighted();
     void hidden();
@@ -100,12 +99,12 @@ void EventHandlerTest::time()
 {
     const auto event = room->messageEvents().at(0).get();
 
-    QCOMPARE(EventHandler::time(room, event), QDateTime::fromMSecsSinceEpoch(1432735824654, QTimeZone(QTimeZone::UTC)));
+    QCOMPARE(EventHandler::dateTime(room, event), QDateTime::fromMSecsSinceEpoch(1432735824654, QTimeZone(QTimeZone::UTC)));
 
     const auto txID = room->postJson("m.room.message"_L1, event->fullJson());
     QCOMPARE(room->pendingEvents().size(), 1);
     const auto pendingIt = room->findPendingEvent(txID);
-    QCOMPARE(EventHandler::time(room, pendingIt->event(), true), pendingIt->lastUpdated());
+    QCOMPARE(EventHandler::dateTime(room, pendingIt->event(), true), pendingIt->lastUpdated());
 
     room->discardMessage(txID);
     QCOMPARE(room->pendingEvents().size(), 0);
@@ -114,40 +113,10 @@ void EventHandlerTest::time()
 void EventHandlerTest::nullTime()
 {
     QTest::ignoreMessage(QtWarningMsg, "time called with room set to nullptr.");
-    QCOMPARE(EventHandler::time(nullptr, nullptr), QDateTime());
+    QCOMPARE(EventHandler::dateTime(nullptr, nullptr), QDateTime());
 
     QTest::ignoreMessage(QtWarningMsg, "time called with event set to nullptr.");
-    QCOMPARE(EventHandler::time(room, nullptr), QDateTime());
-}
-
-void EventHandlerTest::timeString()
-{
-    const auto event = room->messageEvents().at(0).get();
-
-    KFormat format;
-
-    QCOMPARE(EventHandler::timeString(room, event, false),
-             QLocale().toString(QDateTime::fromMSecsSinceEpoch(1432735824654, QTimeZone(QTimeZone::UTC)).toLocalTime().time(), QLocale::ShortFormat));
-    QCOMPARE(EventHandler::timeString(room, event, true),
-             format.formatRelativeDate(QDateTime::fromMSecsSinceEpoch(1432735824654, QTimeZone(QTimeZone::UTC)).toLocalTime().date(), QLocale::ShortFormat));
-    QCOMPARE(EventHandler::timeString(room, event, u"hh:mm"_s),
-             QDateTime::fromMSecsSinceEpoch(1432735824654, QTimeZone(QTimeZone::LocalTime)).toString(u"hh:mm"_s));
-
-    const auto txID = room->postJson("m.room.message"_L1, event->fullJson());
-    QCOMPARE(room->pendingEvents().size(), 1);
-    const auto pendingIt = room->findPendingEvent(txID);
-
-    QCOMPARE(EventHandler::timeString(room, pendingIt->event(), false, QLocale::ShortFormat, true),
-             QLocale().toString(pendingIt->lastUpdated().toLocalTime().time(), QLocale::ShortFormat));
-    QCOMPARE(EventHandler::timeString(room, pendingIt->event(), true, QLocale::ShortFormat, true),
-             format.formatRelativeDate(pendingIt->lastUpdated().toLocalTime().date(), QLocale::ShortFormat));
-    QCOMPARE(EventHandler::timeString(room, pendingIt->event(), false, QLocale::LongFormat, true),
-             QLocale().toString(pendingIt->lastUpdated().toLocalTime().time(), QLocale::LongFormat));
-    QCOMPARE(EventHandler::timeString(room, pendingIt->event(), true, QLocale::LongFormat, true),
-             format.formatRelativeDate(pendingIt->lastUpdated().toLocalTime().date(), QLocale::LongFormat));
-
-    room->discardMessage(txID);
-    QCOMPARE(room->pendingEvents().size(), 0);
+    QCOMPARE(EventHandler::dateTime(room, nullptr), QDateTime());
 }
 
 void EventHandlerTest::highlighted()

autotests/linkpreviewertest.cpp

@@ -19,13 +19,7 @@ class LinkPreviewerTest : public QObject
 {
     Q_OBJECT
 
-private:
-    Connection *connection = nullptr;
-    TestUtils::TestRoom *room = nullptr;
-
 private Q_SLOTS:
-    void initTestCase();
-
     void linkPreviewsMatch_data();
     void linkPreviewsMatch();
 
@@ -36,12 +30,6 @@ private Q_SLOTS:
     void linkPreviewsReject();
 };
 
-void LinkPreviewerTest::initTestCase()
-{
-    connection = Connection::makeMockConnection(u"@bob:example.org"_s);
-    room = new TestUtils::TestRoom(connection, u"!test:example.org"_s);
-}
-
 void LinkPreviewerTest::linkPreviewsMatch_data()
 {
     QTest::addColumn<QString>("inputString");

autotests/modeltest.cpp

@@ -0,0 +1,621 @@
+// SPDX-FileCopyrightText: 2025 Tobias Fella <tobias.fella@kde.org>
+// SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
+
+#include <QAbstractItemModelTester>
+#include <QObject>
+#include <QSignalSpy>
+#include <QTest>
+#include <QVariantList>
+
+#include <Quotient/connection.h>
+
+#include "accountmanager.h"
+#include "contentprovider.h"
+#include "enums/powerlevel.h"
+#include "enums/roomsortparameter.h"
+#include "models/accountemoticonmodel.h"
+#include "models/actionsmodel.h"
+#include "models/commonroomsmodel.h"
+#include "models/completionmodel.h"
+#include "models/completionproxymodel.h"
+#include "models/customemojimodel.h"
+#include "models/devicesmodel.h"
+#include "models/devicesproxymodel.h"
+#include "models/emojimodel.h"
+#include "models/emoticonfiltermodel.h"
+#include "models/eventmessagecontentmodel.h"
+#include "models/imagepacksmodel.h"
+#include "models/linemodel.h"
+#include "models/livelocationsmodel.h"
+#include "models/locationsmodel.h"
+#include "models/messagecontentfiltermodel.h"
+#include "models/messagecontentmodel.h"
+#include "models/notificationsmodel.h"
+#include "models/permissionsmodel.h"
+#include "models/pinnedmessagemodel.h"
+#include "models/pollanswermodel.h"
+#include "models/publicroomlistmodel.h"
+#include "models/pushrulemodel.h"
+#include "models/readmarkermodel.h"
+#include "models/roomsortparametermodel.h"
+#include "models/searchmodel.h"
+#include "models/serverlistmodel.h"
+#include "models/spacechildrenmodel.h"
+#include "models/spacechildsortfiltermodel.h"
+#include "models/statefiltermodel.h"
+#include "models/statekeysmodel.h"
+#include "models/statemodel.h"
+#include "models/stickermodel.h"
+#include "models/threadmodel.h"
+#include "models/threepidmodel.h"
+#include "models/userdirectorylistmodel.h"
+#include "models/userfiltermodel.h"
+#include "models/webshortcutmodel.h"
+#include "neochatroom.h"
+#include "pollhandler.h"
+#include "roommanager.h"
+#include "server.h"
+
+using namespace Quotient;
+
+// TODO: Add data to all models as relevant.
+
+// Performs basic tests on all models in NeoChat
+// When adding a new test, create the model first, then the tester, then initialize the model (e.g., setConnection and setRoom).
+// That way, the models are also tested for whether they can handle having no connection etc.
+class ModelTest : public QObject
+{
+    Q_OBJECT
+
+private:
+    NeoChatConnection *connection = nullptr;
+    NeoChatRoom *room = nullptr;
+
+    QString eventId;
+
+    Server server;
+
+private Q_SLOTS:
+    void initTestCase();
+    void testRoomTreeModel();
+    void testMessageContentModel();
+    void testEventMessageContentModel();
+    void testThreadModel();
+    void testThreadFetchModel();
+    void testThreadChatBarModel();
+    void testReactionModel();
+    void testPollAnswerModel();
+    void testLineModel();
+    void testSpaceChildrenModel();
+    void testItineraryModel();
+    void testPublicRoomListModel();
+    void testMessageFilterModel();
+    void testThreePIdModel();
+    void testMediaMessageFilterModel();
+    void testWebshortcutModel();
+    void testTimelineMessageModel();
+    void testReadMarkerModel();
+    void testSearchModel();
+    void testStateModel();
+    void testTimelineModel();
+    void testStateKeysModel();
+    void testPinnedMessageModel();
+    void testUserListModel();
+    void testStickerModel();
+    void testPowerLevelModel();
+    void testImagePacksModel();
+    void testCompletionModel();
+    void testRoomListModel();
+    void testCommonRoomsModel();
+    void testNotificationsModel();
+    void testLocationsModel();
+    void testServerListModel();
+    void testEmojiModel();
+    void testCustomEmojiModel();
+    void testPushRuleModel();
+    void testActionsModel();
+    void testDevicesModel();
+    void testUserDirectoryListModel();
+    void testAccountEmoticonModel();
+    void testPermissionsModel();
+    void testLiveLocationsModel();
+    void testRoomSortParameterModel();
+    void testSortFilterRoomTreeModel();
+    void testSortFilterSpaceListModel();
+    void testSortFilterRoomListModel();
+    void testSpaceChildSortFilterModel();
+    void testStateFilterModel();
+    void testMessageContentFilterModel();
+    void testUserFilterModel();
+    void testEmoticonFilterModel();
+    void testDevicesProxyModel();
+    void testCompletionProxyModel();
+};
+
+void ModelTest::initTestCase()
+{
+    Connection::setRoomType<NeoChatRoom>();
+    server.start();
+    KLocalizedString::setApplicationDomain(QByteArrayLiteral("neochat"));
+    auto accountManager = new AccountManager(true, this);
+    QSignalSpy spy(accountManager, &AccountManager::connectionAdded);
+    connection = dynamic_cast<NeoChatConnection *>(accountManager->accounts()->front());
+    const auto roomId = server.createRoom(u"@user:localhost:1234"_s);
+    eventId = server.sendEvent(roomId,
+                               u"m.room.message"_s,
+                               QJsonObject{
+                                   {u"body"_s, u"foo"_s},
+                                   {u"msgtype"_s, u"m.text"_s},
+                               });
+
+    server.sendEvent(roomId,
+                     u"m.room.message"_s,
+                     QJsonObject{
+                         {u"body"_s, u"asdf"_s},
+                         {u"m.relates_to"_s,
+                          QJsonObject{
+                              {u"event_id"_s, u"$GEucSt3TfVl6DVpKEyeOlRsXzjLv2ZCVgSQuQclFg1o"_s},
+                              {u"is_falling_back"_s, true},
+                              {u"m.in_reply_to"_s, QJsonObject{{u"event_id"_s, u"$GEucSt3TfVl6DVpKEyeOlRsXzjLv2ZCVgSQuQclFg1o"_s}}},
+                              {u"rel_type"_s, u"m.thread"_s},
+                          }},
+                         {u"msgtype"_s, u"m.text"_s},
+                     });
+
+    QSignalSpy syncSpy(connection, &Connection::syncDone);
+    // We need to wait for two syncs, as the next one won't have the changes yet
+    QVERIFY(syncSpy.wait());
+    QVERIFY(syncSpy.wait());
+    room = dynamic_cast<NeoChatRoom *>(connection->room(roomId));
+    QVERIFY(room);
+}
+
+void ModelTest::testRoomTreeModel()
+{
+    auto roomTreeModel = new RoomTreeModel(this);
+    auto tester = new QAbstractItemModelTester(roomTreeModel, roomTreeModel);
+    tester->setUseFetchMore(true);
+    roomTreeModel->setConnection(connection);
+}
+
+void ModelTest::testMessageContentModel()
+{
+    auto contentModel = std::make_unique<MessageContentModel>(room, eventId);
+    auto tester = new QAbstractItemModelTester(contentModel.get(), contentModel.get());
+    tester->setUseFetchMore(true);
+}
+
+void ModelTest::testEventMessageContentModel()
+{
+    auto model = std::make_unique<EventMessageContentModel>(room, eventId);
+    auto tester = new QAbstractItemModelTester(model.get(), model.get());
+    tester->setUseFetchMore(true);
+}
+
+void ModelTest::testThreadModel()
+{
+    auto model = std::make_unique<ThreadModel>(eventId, room);
+    auto tester = new QAbstractItemModelTester(model.get(), model.get());
+    tester->setUseFetchMore(true);
+}
+
+void ModelTest::testThreadFetchModel()
+{
+    auto threadModel = std::make_unique<ThreadModel>(eventId, room);
+    auto model = new ThreadFetchModel(threadModel.get());
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+}
+
+void ModelTest::testThreadChatBarModel()
+{
+    auto threadModel = std::make_unique<ThreadModel>(eventId, room);
+    auto model = new ThreadChatBarModel(threadModel.get(), room);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+}
+
+void ModelTest::testReactionModel()
+{
+    auto messageContentModel = std::make_unique<MessageContentModel>(room);
+    auto model = new ReactionModel(messageContentModel.get(), eventId, room);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+}
+
+void ModelTest::testPollAnswerModel()
+{
+    auto handler = std::make_unique<PollHandler>(room, eventId);
+    auto model = new PollAnswerModel(handler.get());
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+}
+
+void ModelTest::testLineModel()
+{
+    auto model = new LineModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    auto document = new QTextDocument(this);
+    model->setDocument(document);
+    document->setPlainText(u"foo\nbar\n\nbaz"_s);
+}
+
+void ModelTest::testSpaceChildrenModel()
+{
+    auto model = new SpaceChildrenModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setSpace(room);
+}
+
+void ModelTest::testItineraryModel()
+{
+    auto model = new ItineraryModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+}
+
+void ModelTest::testPublicRoomListModel()
+{
+    auto model = new PublicRoomListModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setConnection(connection);
+}
+
+void ModelTest::testMessageFilterModel()
+{
+    auto timelineModel = new TimelineModel(this);
+    auto model = new MessageFilterModel(this, timelineModel);
+    auto tester = new QAbstractItemModelTester(model, model);
+    timelineModel->setRoom(room);
+    tester->setUseFetchMore(true);
+}
+
+void ModelTest::testThreePIdModel()
+{
+    auto model = new ThreePIdModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setConnection(connection);
+}
+
+void ModelTest::testMediaMessageFilterModel()
+{
+    auto timelineModel = new TimelineModel(this);
+    auto messageFilterModel = new MessageFilterModel(this, timelineModel);
+    auto model = new MediaMessageFilterModel(this, messageFilterModel);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    timelineModel->setRoom(room);
+}
+
+void ModelTest::testWebshortcutModel()
+{
+    auto model = new WebShortcutModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setSelectedText(u"Foo"_s);
+}
+
+void ModelTest::testTimelineMessageModel()
+{
+    auto model = new TimelineMessageModel();
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setRoom(room);
+}
+
+void ModelTest::testReadMarkerModel()
+{
+    auto model = std::make_unique<ReadMarkerModel>(eventId, room);
+    auto tester = new QAbstractItemModelTester(model.get(), model.get());
+    tester->setUseFetchMore(true);
+}
+
+void ModelTest::testSearchModel()
+{
+    auto model = new SearchModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setSearchText(u"foo"_s);
+    model->setRoom(room);
+}
+
+void ModelTest::testStateModel()
+{
+    auto model = new StateModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setRoom(room);
+}
+
+void ModelTest::testTimelineModel()
+{
+    auto model = new TimelineModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setRoom(room);
+}
+
+void ModelTest::testStateKeysModel()
+{
+    auto model = new StateKeysModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setEventType(u"m.room.member"_s);
+    model->setRoom(room);
+}
+
+void ModelTest::testPinnedMessageModel()
+{
+    auto model = new PinnedMessageModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setRoom(room);
+}
+
+void ModelTest::testUserListModel()
+{
+    auto model = new UserListModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setRoom(room);
+}
+
+void ModelTest::testStickerModel()
+{
+    auto model = new StickerModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setPackIndex(0);
+    model->setRoom(room);
+    auto imagePacksModel = new ImagePacksModel(this);
+    model->setModel(imagePacksModel);
+    imagePacksModel->setRoom(room);
+    imagePacksModel->setShowEmoticons(true);
+    imagePacksModel->setShowStickers(true);
+}
+
+void ModelTest::testPowerLevelModel()
+{
+    auto model = new PowerLevelModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+}
+
+void ModelTest::testImagePacksModel()
+{
+    auto model = new ImagePacksModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setRoom(room);
+    model->setShowEmoticons(true);
+    model->setShowStickers(true);
+}
+
+void ModelTest::testCompletionModel()
+{
+    auto model = new CompletionModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setAutoCompletionType(CompletionModel::Room);
+    auto roomListModel = new RoomListModel(this);
+    roomListModel->setConnection(connection);
+    model->setRoomListModel(roomListModel);
+}
+
+void ModelTest::testRoomListModel()
+{
+    auto model = new RoomListModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setConnection(connection);
+}
+
+void ModelTest::testCommonRoomsModel()
+{
+    auto model = new CommonRoomsModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setConnection(connection);
+    model->setUserId(u"@user:example.com"_s);
+}
+
+void ModelTest::testNotificationsModel()
+{
+    auto model = new NotificationsModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setConnection(connection);
+}
+
+void ModelTest::testLocationsModel()
+{
+    auto model = new LocationsModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setRoom(room);
+}
+
+void ModelTest::testServerListModel()
+{
+    auto model = new ServerListModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setConnection(connection);
+}
+
+void ModelTest::testEmojiModel()
+{
+    auto tester = new QAbstractItemModelTester(&EmojiModel::instance(), &EmojiModel::instance());
+    tester->setUseFetchMore(true);
+}
+
+void ModelTest::testCustomEmojiModel()
+{
+    auto tester = new QAbstractItemModelTester(&CustomEmojiModel::instance(), &CustomEmojiModel::instance());
+    tester->setUseFetchMore(true);
+    CustomEmojiModel::instance().setConnection(connection);
+}
+
+void ModelTest::testPushRuleModel()
+{
+    auto model = new PushRuleModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setConnection(connection);
+}
+
+void ModelTest::testActionsModel()
+{
+    auto tester = new QAbstractItemModelTester(&ActionsModel::instance(), &ActionsModel::instance());
+    tester->setUseFetchMore(true);
+}
+
+void ModelTest::testDevicesModel()
+{
+    auto model = new DevicesModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setConnection(connection);
+}
+
+void ModelTest::testUserDirectoryListModel()
+{
+    auto model = new UserDirectoryListModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setConnection(connection);
+    model->setSearchText(u"foo"_s);
+}
+
+void ModelTest::testAccountEmoticonModel()
+{
+    auto model = new AccountEmoticonModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setConnection(connection);
+}
+
+void ModelTest::testPermissionsModel()
+{
+    auto model = new PermissionsModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setRoom(room);
+}
+
+void ModelTest::testLiveLocationsModel()
+{
+    auto model = new LiveLocationsModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setRoom(room);
+}
+
+void ModelTest::testRoomSortParameterModel()
+{
+    auto model = new RoomSortParameterModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+}
+
+void ModelTest::testSortFilterRoomTreeModel()
+{
+    auto sourceModel = new RoomTreeModel(this);
+    auto model = new SortFilterRoomTreeModel(sourceModel, sourceModel);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    sourceModel->setConnection(connection);
+}
+
+void ModelTest::testSortFilterSpaceListModel()
+{
+    auto sourceModel = new RoomListModel(this);
+    auto model = new SortFilterSpaceListModel(sourceModel, sourceModel);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    sourceModel->setConnection(connection);
+}
+
+void ModelTest::testSortFilterRoomListModel()
+{
+    auto sourceModel = new RoomListModel(this);
+    auto model = new SortFilterRoomListModel(sourceModel, sourceModel);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    sourceModel->setConnection(connection);
+}
+
+void ModelTest::testSpaceChildSortFilterModel()
+{
+    auto model = new SpaceChildSortFilterModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    auto spaceChildrenModel = new SpaceChildrenModel(this);
+    model->setSourceModel(spaceChildrenModel);
+    spaceChildrenModel->setSpace(nullptr);
+}
+
+void ModelTest::testStateFilterModel()
+{
+    auto model = new StateFilterModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    auto stateModel = new StateModel(this);
+    model->setSourceModel(stateModel);
+    stateModel->setRoom(room);
+}
+
+void ModelTest::testMessageContentFilterModel()
+{
+    auto model = new MessageContentFilterModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setSourceModel(ContentProvider::self().contentModelForEvent(room, eventId));
+}
+
+void ModelTest::testUserFilterModel()
+{
+    auto model = new UserFilterModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    auto userListModel = new UserListModel(this);
+    model->setSourceModel(userListModel);
+    userListModel->setRoom(room);
+}
+
+void ModelTest::testEmoticonFilterModel()
+{
+    auto model = new EmoticonFilterModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    auto accountEmoticonModel = new AccountEmoticonModel(this);
+    model->setSourceModel(accountEmoticonModel);
+    model->setShowEmojis(true);
+    model->setShowStickers(true);
+    accountEmoticonModel->setConnection(connection);
+}
+
+void ModelTest::testDevicesProxyModel()
+{
+    auto model = new DevicesProxyModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    auto devicesModel = new DevicesModel(this);
+    model->setSourceModel(devicesModel);
+    devicesModel->setConnection(dynamic_cast<NeoChatConnection *>(connection));
+}
+
+void ModelTest::testCompletionProxyModel()
+{
+    auto model = new CompletionProxyModel(this);
+    auto tester = new QAbstractItemModelTester(model, model);
+    tester->setUseFetchMore(true);
+    model->setSourceModel(&EmojiModel::instance());
+}
+
+QTEST_MAIN(ModelTest)
+#include "modeltest.moc"

autotests/neochatroomtest.cpp

@@ -9,6 +9,10 @@
 #include <Quotient/quotient_common.h>
 #include <Quotient/syncdata.h>
 
+#include <KLocalizedString>
+
+#include "accountmanager.h"
+#include "server.h"
 #include "testutils.h"
 
 using namespace Quotient;
@@ -18,7 +22,8 @@ class NeoChatRoomTest : public QObject {
 
 private:
     Connection *connection = nullptr;
-    TestUtils::TestRoom *room = nullptr;
+    NeoChatRoom *room = nullptr;
+    Server server;
 
 private Q_SLOTS:
     void initTestCase();
@@ -27,8 +32,27 @@ private Q_SLOTS:
 
 void NeoChatRoomTest::initTestCase()
 {
-    connection = Connection::makeMockConnection(u"@bob:kde.org"_s);
-    room = new TestUtils::TestRoom(connection, u"#myroom:kde.org"_s, u"test-min-sync.json"_s);
+    Connection::setRoomType<NeoChatRoom>();
+    server.start();
+    KLocalizedString::setApplicationDomain(QByteArrayLiteral("neochat"));
+    auto accountManager = new AccountManager(true, this);
+    QSignalSpy spy(accountManager, &AccountManager::connectionAdded);
+    connection = dynamic_cast<NeoChatConnection *>(accountManager->accounts()->front());
+
+    const auto roomId = server.createRoom(u"@user:localhost:1234"_s);
+    server.sendEvent(roomId,
+                     u"m.room.message"_s,
+                     QJsonObject{
+                         {u"body"_s, u"foo"_s},
+                         {u"msgtype"_s, u"m.text"_s},
+                     });
+
+    QSignalSpy syncSpy(connection, &Connection::syncDone);
+    // We need to wait for two syncs, as the next one won't have the changes yet
+    QVERIFY(syncSpy.wait());
+    QVERIFY(syncSpy.wait());
+    room = dynamic_cast<NeoChatRoom *>(connection->room(roomId));
+    QVERIFY(room);
 }
 
 void NeoChatRoomTest::eventTest()

autotests/qmltest.cpp

@@ -0,0 +1,9 @@
+/*
+ *  SPDX-FileCopyrightText: 2020 Arjen Hiemstra <ahiemstra@heimr.nl>
+ *
+ *  SPDX-License-Identifier: LGPL-2.0-or-later
+ */
+
+#include <quicktest.h>
+
+QUICK_TEST_MAIN(NeoChat)

autotests/server.cpp

@@ -121,13 +121,13 @@ void Server::start()
     QFile key(QStringLiteral(DATA_DIR) + u"/localhost.key"_s);
     void(key.open(QFile::ReadOnly));
     config.setPrivateKey(QSslKey(&key, QSsl::Rsa));
-    config.setLocalCertificate(QSslCertificate::fromPath(QStringLiteral(DATA_DIR) + u"/localhost.crt"_s).front());
+    config.setLocalCertificate(QSslCertificate::fromPath(QStringLiteral(DATA_DIR) + u"/localhost.crt"_s).constFirst());
     m_sslServer.setSslConfiguration(config);
     if (!m_sslServer.listen(QHostAddress::LocalHost, 1234) || !m_server.bind(&m_sslServer)) {
         qFatal() << "Server failed to listen on a port.";
         return;
     } else {
-        qWarning() << "Server listening";
+        qInfo() << "Server listening";
     }
 }
 
@@ -203,12 +203,32 @@ QString Server::sendEvent(const QString &roomId, const QString &eventType, const
     return eventId;
 }
 
+QString Server::sendStateEvent(const QString &roomId, const QString &eventType, const QString &stateKey, const QJsonObject &content)
+{
+    Changes changes;
+    const auto eventId = generateEventId();
+    const auto json = QJsonObject{{u"type"_s, eventType},
+                                  {u"content"_s, content},
+                                  {u"sender"_s, u"@foo:server.com"_s},
+                                  {u"event_id"_s, eventId},
+                                  {u"origin_server_ts"_s, QDateTime::currentMSecsSinceEpoch()},
+                                  {u"room_id"_s, roomId},
+                                  {u"state_key"_s, stateKey}};
+    changes.events += Changes::Event{
+        .fullJson = json,
+    };
+    changes.stateEvents += Changes::Event{.fullJson = json};
+    m_state += changes;
+    return eventId;
+}
+
 void Server::sync(const QHttpServerRequest &request, QHttpServerResponder &responder)
 {
     QJsonObject joinRooms;
     auto token = request.query().queryItemValue(u"since"_s).toInt();
 
-    for (const auto &change : m_state.mid(token)) {
+    const auto changes = m_state.mid(token);
+    for (const auto &change : changes) {
         for (const auto &newRoom : change.newRooms) {
             QJsonArray stateEvents;
             stateEvents += QJsonObject{
@@ -253,7 +273,7 @@ void Server::sync(const QHttpServerRequest &request, QHttpServerResponder &respo
         }
     }
 
-    for (const auto &change : m_state.mid(token)) {
+    for (const auto &change : changes) {
         for (const auto &invitation : change.invitations) {
             // TODO: The invitation could be for a room we haven't joined yet. Shouldn't be necessary for now, though.
             auto stateEvents = joinRooms[invitation.roomId][u"state"_s][u"events"_s].toArray();
@@ -280,7 +300,7 @@ void Server::sync(const QHttpServerRequest &request, QHttpServerResponder &respo
         }
     }
 
-    for (const auto &change : m_state.mid(token)) {
+    for (const auto &change : changes) {
         for (const auto &ban : change.bans) {
             // TODO: The ban could be for a room we haven't joined yet. Shouldn't be necessary for now, though.
             auto stateEvents = joinRooms[ban.roomId][u"state"_s][u"events"_s].toArray();
@@ -307,7 +327,7 @@ void Server::sync(const QHttpServerRequest &request, QHttpServerResponder &respo
         }
     }
 
-    for (const auto &change : m_state.mid(token)) {
+    for (const auto &change : changes) {
         for (const auto &join : change.joins) {
             // TODO: The join could be for a room we haven't joined yet. Shouldn't be necessary for now, though.
             auto stateEvents = joinRooms[join.roomId][u"state"_s][u"events"_s].toArray();
@@ -334,7 +354,19 @@ void Server::sync(const QHttpServerRequest &request, QHttpServerResponder &respo
         }
     }
 
-    for (const auto &change : m_state.mid(token)) {
+    for (const auto &change : changes) {
+        for (const auto &state : change.stateEvents) {
+            const auto &roomId = state.fullJson[u"room_id"_s].toString();
+            // TODO: The join could be for a room we haven't joined yet. Shouldn't be necessary for now, though.
+            auto stateEvents = joinRooms[roomId][u"state"_s][u"events"_s].toArray();
+            stateEvents.append(state.fullJson);
+            auto room = joinRooms[roomId].toObject();
+            room[u"state"_s] = QJsonObject{{u"events"_s, stateEvents}};
+            joinRooms[roomId] = room;
+        }
+    }
+
+    for (const auto &change : changes) {
         for (const auto &event : change.events) {
             // TODO the room might be in a different join state.
             auto timeline = joinRooms[event.fullJson[u"room_id"_s].toString()][u"timeline"_s][u"events"_s].toArray();
@@ -366,6 +398,5 @@ void Server::sync(const QHttpServerRequest &request, QHttpServerResponder &respo
         syncData[u"rooms"_s] = rooms;
     }
 
-    qWarning() << syncData;
     responder.write(QJsonDocument(syncData), QHttpServerResponder::StatusCode::Ok);
 }

autotests/server.h

@@ -35,6 +35,7 @@ struct Changes {
         QJsonObject fullJson;
     };
     QList<Event> events;
+    QList<Event> stateEvents;
 };
 
 struct RoomData {
@@ -67,6 +68,7 @@ public:
      */
     QString createServerNoticesRoom(const QString &matrixId);
     QString sendEvent(const QString &roomId, const QString &eventType, const QJsonObject &content);
+    QString sendStateEvent(const QString &roomId, const QString &eventType, const QString &stateKey, const QJsonObject &content);
 
 private:
     QHttpServer m_server;

autotests/timelinemessagemodeltest.cpp

@@ -208,7 +208,7 @@ void TimelineMessageModelTest::idToRow()
     auto room = new TestUtils::TestRoom(connection, u"#myroom:kde.org"_s, u"test-min-sync.json"_s);
     model->setRoom(room);
 
-    QCOMPARE(model->indexforEventId(u"$153456789:example.org"_s).row(), 0);
+    QCOMPARE(model->indexForEventId(u"$153456789:example.org"_s).row(), 0);
 }
 
 void TimelineMessageModelTest::cleanup()

autotests/windowcontrollertest.cpp

@@ -73,6 +73,16 @@ void WindowControllerTest::toggle()
     instance.toggleWindow();
     QCOMPARE(window.windowState(), Qt::WindowNoState);
     QCOMPARE(window.isVisible(), false);
+
+    // make sure we restore maximized state when toggling
+    instance.toggleWindow();
+    window.setVisibility(QWindow::Maximized);
+    QCOMPARE(window.windowState(), Qt::WindowMaximized);
+    instance.toggleWindow();
+    QCOMPARE(window.isVisible(), false);
+    instance.toggleWindow();
+    QCOMPARE(window.windowState(), Qt::WindowMaximized);
+    QCOMPARE(window.isVisible(), true);
 }
 
 QTEST_MAIN(WindowControllerTest)

cmake/Flatpak.cmake

@@ -1,14 +0,0 @@
-# SPDX-FileCopyrightText: 2020 Carl Schwan <carl@carlschwan.eu>
-# SPDX-License-Identifier: BSD-2-Clause
-
-include(GNUInstallDirs)
-
-# Include FontConfig config which uses the Emoji One font from the
-# KDE Flatpak SDK.
-install(
-    FILES
-        ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Flatpak/99-noto-mono-color-emoji.conf
-    DESTINATION
-        ${CMAKE_INSTALL_SYSCONFDIR}/fonts/local.conf
-)
-

cmake/Flatpak/99-noto-mono-color-emoji.conf

@@ -1,23 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE fontconfig SYSTEM "fonts.dtd">
-<fontconfig>
-  <alias>
-    <family>serif</family>
-    <prefer>
-      <family>Noto Color Emoji</family>
-    </prefer>
-  </alias>
-  <alias>
-    <family>sans-serif</family>
-    <prefer>
-      <family>Noto Color Emoji</family>
-    </prefer>
-  </alias>
-  <alias>
-    <family>monospace</family>
-    <prefer>
-      <family>Noto Color Emoji</family>
-    </prefer>
-  </alias>
-</fontconfig>
-

org.kde.neochat.desktop

@@ -108,6 +108,7 @@ Comment[ia]=Conversation en ditecto sur Matrix
 Comment[it]= su Matrix
 Comment[ka]=ჩატი Matrix-ზე
 Comment[ko]=Matrix에서 대화하기
+Comment[lt]=Pokalbiai per Matrix
 Comment[lv]=Tērzējiet „Matrix“ tīklā
 Comment[nl]=Chat op Matrix
 Comment[pl]=Rozmawiaj na Matriksie

po/pt_BR/docs/neochat/man-neochat.1.docbook

@@ -0,0 +1,122 @@
+<?xml version="1.0" ?>
+<!DOCTYPE refentry PUBLIC "-//KDE//DTD DocBook XML V4.5-Based Variant V1.1//EN" "dtd/kdedbx45.dtd" [
+<!ENTITY % Brazilian-Portuguese "INCLUDE">
+]>
+<!--
+SPDX-FileCopyrightText: 2022 Carl Schwan <carl@carlschwan.eu>
+SPDX-License-Identifier: CC-BY-SA-4.0
+-->
+
+<refentry lang="&language;">
+<refentryinfo>
+<title
+>Manual do Usuário do NeoChat</title>
+<author
+><firstname
+>Carl</firstname
+><surname
+>Schwan</surname
+> <contrib
+>NeoChat man page.</contrib
+> <email
+>carl@carlschwan.eu</email
+></author>
+<date
+>01/11/2022</date>
+<releaseinfo
+>22.09</releaseinfo>
+<productname
+>NeoChat</productname>
+</refentryinfo>
+
+<refmeta>
+  <refentrytitle>
+    <command
+>neochat</command>
+  </refentrytitle>
+  <manvolnum
+>1</manvolnum>
+</refmeta>
+
+<refnamediv>
+  <refname
+>neochat</refname>
+  <refpurpose
+>Cliente para interação com o protocolo de mensagens Matrix.</refpurpose>
+  </refnamediv>
+  <!-- body begins here -->
+  <refsynopsisdiv id='synopsis'>
+  <cmdsynopsis
+><command
+>neochat</command
+> <arg choice="opt"
+><replaceable
+>URI</replaceable
+></arg
+> </cmdsynopsis>
+</refsynopsisdiv>
+
+
+<refsect1 id="description">
+  <title
+>Descrição</title>
+  <para
+>O <command
+>neochat</command
+> é um aplicativo de bate-papo para o protocolo Matrix. Ele funciona tanto em computadores quanto em dispositivos móveis. </para>
+</refsect1>
+
+<refsect1 id="options"
+><title
+>Opções</title>
+<variablelist>
+  <varlistentry>
+  <term
+><option
+>URI</option
+></term>
+  <listitem>
+    <para
+>O URI da matriz para um usuário ou uma sala. Por exemplo, matrix:u/usuário:exemplo.org e matrix:r/root:exemplo.org. Isso fará com que o NeoChat tente abrir a sala ou conversa especificada. </para>
+  </listitem>
+  </varlistentry>
+</variablelist>
+</refsect1>
+
+<refsect1 id="bug">
+  <title
+>Relatar bugs</title>
+  <para
+>Você pode reportar erros e solicitar novas funcionalidades em <ulink url="https://bugs.kde.org/enter_bug.cgi?product=NeoChat&amp;component=General"
+>https://bugs.kde.org/enter_bug.cgi?product=NeoChat&amp;component=General</ulink
+></para>
+</refsect1>
+
+<refsect1>
+  <title
+>Veja também</title>
+  <simplelist>
+    <member
+>Lista de perguntas frequentes sobre o Matrix <ulink url="https://matrix.org/faq/"
+>https://matrix.org/faq/</ulink
+> </member>
+    <member
+>kf5options(7)</member>
+    <member
+>qt5options(7)</member>
+  </simplelist>
+</refsect1>
+
+<refsect1 id="copyright"
+><title
+>Direitos autorais</title>
+<para
+>Direitos autorais &copy; 2020-2022 Tobias Fella </para>
+<para
+>Direitos autorais &copy; 2020-2022 Carl Schwan </para>
+<para
+>Licença: GNU General Public Versão 3 ou posterior <ulink url="https://www.gnu.org/licenses/gpl-3.0.html"
+>https://www.gnu.org/licenses/gpl-3.0.html</ulink
+>&gt;</para>
+</refsect1>
+</refentry>

po/tr/docs/neochat/man-neochat.1.docbook

@@ -22,7 +22,7 @@ SPDX-License-Identifier: CC-BY-SA-4.0
 >carl@carlschwan.eu</email
 ></author>
 <date
->2022-11-01</date>
+>2022‒11‒01</date>
 <releaseinfo
 >22.09</releaseinfo>
 <productname
@@ -111,9 +111,9 @@ SPDX-License-Identifier: CC-BY-SA-4.0
 ><title
 >Telif Hakkı</title>
 <para
->Telif hakkı &copy; 2020-2022 Tobias Fella </para>
+>Telif hakkı &copy; 2020–2022 Tobias Fella </para>
 <para
->Telif hakkı &copy; 2020-2022 Carl Schwan </para>
+>Telif hakkı &copy; 2020–2022 Carl Schwan </para>
 <para
 >Lisans: GNU Genel Kamu Lisansa, 3. sürüm veya sonrası &lt;<ulink url="https://www.gnu.org/licenses/gpl-3.0.html"
 >https://www.gnu.org/licenses/gpl-3.0.html</ulink

src/app/CMakeLists.txt

@@ -3,7 +3,7 @@
 # SPDX-FileCopyrightText: 2020-2021 Tobias Fella <tobias.fella@kde.org>
 # SPDX-License-Identifier: BSD-2-Clause
 
-add_library(neochat STATIC
+qt_add_library(neochat STATIC
     controller.cpp
     controller.h
     roommanager.cpp
@@ -35,6 +35,10 @@ add_library(neochat STATIC
     models/commonroomsmodel.h
     texttospeechhelper.h
     texttospeechhelper.cpp
+    models/limitermodel.cpp
+    models/limitermodel.h
+    supportcontroller.cpp
+    supportcontroller.h
 )
 
 set_source_files_properties(qml/OsmLocationPlugin.qml PROPERTIES
@@ -66,7 +70,6 @@ ecm_add_qml_module(neochat URI org.kde.neochat GENERATE_PLUGIN_SOURCE
         qml/AttachmentPane.qml
         qml/QuickFormatBar.qml
         qml/UserDetailDialog.qml
-        qml/OpenFileDialog.qml
         qml/KeyVerificationDialog.qml
         qml/ConfirmLogoutDialog.qml
         qml/VerificationMessage.qml
@@ -75,7 +78,6 @@ ecm_add_qml_module(neochat URI org.kde.neochat GENERATE_PLUGIN_SOURCE
         qml/EmojiSas.qml
         qml/VerificationCanceled.qml
         qml/MessageSourceSheet.qml
-        qml/LocationChooser.qml
         qml/InvitationView.qml
         qml/AvatarTabButton.qml
         qml/OsmLocationPlugin.qml
@@ -101,9 +103,10 @@ ecm_add_qml_module(neochat URI org.kde.neochat GENERATE_PLUGIN_SOURCE
         qml/HoverLinkIndicator.qml
         qml/AvatarNotification.qml
         qml/ReasonDialog.qml
-        qml/NewPollDialog.qml
         qml/UserMenu.qml
         qml/MeetingDialog.qml
+        qml/SeenByDialog.qml
+        qml/SupportDialog.qml
     DEPENDENCIES
         QtCore
         QtQuick
@@ -140,10 +143,17 @@ if(WIN32)
     set_target_properties(neochat PROPERTIES OUTPUT_NAME "neochatlib")
 endif()
 
-add_executable(neochat-app
+qt_add_executable(neochat-app
     main.cpp
 )
 
+if(ANDROID)
+    set_target_properties(neochat-app PROPERTIES
+        OUTPUT_NAME "neochat-app"
+        PREFIX "lib"
+    )
+endif()
+
 if(TARGET Qt::WebView)
     target_link_libraries(neochat-app PUBLIC Qt::WebView)
     target_compile_definitions(neochat-app PUBLIC -DHAVE_WEBVIEW)
@@ -153,6 +163,7 @@ target_include_directories(neochat-app PRIVATE ${CMAKE_BINARY_DIR})
 
 target_link_libraries(neochat-app PRIVATE
     neochat
+    KF6::IconThemes
 )
 
 ecm_add_app_icon(NEOCHAT_ICON ICONS ${CMAKE_SOURCE_DIR}/128-logo.png)
@@ -160,12 +171,7 @@ ecm_add_app_icon(NEOCHAT_ICON ICONS ${CMAKE_SOURCE_DIR}/128-logo.png)
 target_sources(neochat-app PRIVATE ${NEOCHAT_ICON})
 
 if(NOT ANDROID)
-    if (NOT WIN32 AND NOT APPLE)
-        target_sources(neochat PRIVATE trayicon_sni.cpp trayicon_sni.h)
-        target_link_libraries(neochat PRIVATE KF6::StatusNotifierItem)
-    else()
-        target_sources(neochat PRIVATE trayicon.cpp trayicon.h)
-    endif()
+    target_sources(neochat PRIVATE trayicon.cpp trayicon.h)
     target_link_libraries(neochat PUBLIC KF6::WindowSystem)
     target_compile_definitions(neochat PUBLIC -DHAVE_WINDOWSYSTEM)
 endif()
@@ -183,7 +189,7 @@ else()
 endif()
 
 target_include_directories(neochat PRIVATE ${CMAKE_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/models)
-target_link_libraries(neochat PRIVATE Loginplugin Roomsplugin RoomInfoplugin MessageContentplugin Timelineplugin Spacesplugin Chatbarplugin Settingsplugin Devtoolsplugin)
+target_link_libraries(neochat PRIVATE neochatplugin Loginplugin Roomsplugin RoomInfoplugin MessageContentplugin Timelineplugin Spacesplugin Chatbarplugin Settingsplugin Devtoolsplugin)
 target_link_libraries(neochat PUBLIC
     LibNeoChat
     Timeline
@@ -352,7 +358,8 @@ endif()
 install(TARGETS neochat-app ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})
 
 if (NOT ANDROID AND NOT WIN32 AND NOT APPLE)
-    install(FILES plasma-runner-neochat.desktop DESTINATION ${KDE_INSTALL_DATAROOTDIR}/krunner/dbusplugins)
+    # krunner plugin must be the same as the app id for flatpak to export it
+    install(FILES plasma-runner-neochat.desktop DESTINATION ${KDE_INSTALL_DATAROOTDIR}/krunner/dbusplugins RENAME org.kde.neochat.desktop)
 endif()
 
 if (APPLE)

src/app/controller.cpp

@@ -29,10 +29,8 @@
 #include "proxycontroller.h"
 #include "roommanager.h"
 
-#if defined(Q_OS_WIN) || defined(Q_OS_MAC)
+#if !defined(Q_OS_ANDROID)
 #include "trayicon.h"
-#elif !defined(Q_OS_ANDROID)
-#include "trayicon_sni.h"
 #endif
 
 #ifdef HAVE_KUNIFIEDPUSH
@@ -246,7 +244,10 @@ void Controller::initActiveConnection(NeoChatConnection *oldConnection, NeoChatC
     if (newConnection) {
         connect(newConnection, &NeoChatConnection::errorOccured, this, &Controller::errorOccured);
         connect(newConnection, &NeoChatConnection::badgeNotificationCountChanged, this, &Controller::updateBadgeNotificationCount);
+
+        // Refresh and update manually, in case we init too late for the badge count to actually change.
         newConnection->refreshBadgeNotificationCount();
+        updateBadgeNotificationCount(newConnection->badgeNotificationCount());
     }
     Q_EMIT activeConnectionChanged(newConnection);
 }

src/app/main.cpp

@@ -33,6 +33,7 @@
 #include <KWindowSystem>
 #endif
 
+#include <KIconTheme>
 #include <KLocalizedQmlContext>
 #include <KLocalizedString>
 #include <KirigamiApp>
@@ -102,6 +103,10 @@ int main(int argc, char *argv[])
 {
     QNetworkProxyFactory::setUseSystemConfiguration(true);
 
+    // We currently need to do this ourselves,
+    // KirigamiApp currently called this after constructing the app which breaks icons on Windows.
+    KIconTheme::initTheme();
+
 #ifdef HAVE_WEBVIEW
     QtWebView::initialize();
     QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts);
@@ -161,12 +166,6 @@ int main(int argc, char *argv[])
     Connection::setEncryptionDefault(true);
     Connection::setDirectChatEncryptionDefault(true);
 
-#ifdef NEOCHAT_FLATPAK
-    // Copy over the included FontConfig configuration to the
-    // app's config dir:
-    QFile::copy(u"/app/etc/fonts/conf.d/99-noto-mono-color-emoji.conf"_s, u"/var/config/fontconfig/conf.d/99-noto-mono-color-emoji.conf"_s);
-#endif
-
     ColorSchemer colorScheme;
 
     QCommandLineParser parser;

src/app/models/commonroomsmodel.cpp

@@ -5,6 +5,7 @@
 #include "jobs/neochatgetcommonroomsjob.h"
 
 #include <QGuiApplication>
+#include <Quotient/room.h>
 
 using namespace Quotient;
 
@@ -39,8 +40,22 @@ void CommonRoomsModel::setUserId(const QString &userId)
 
 QVariant CommonRoomsModel::data(const QModelIndex &index, int roleName) const
 {
-    Q_UNUSED(index)
-    Q_UNUSED(roleName)
+    auto roomId = m_commonRooms[index.row()];
+    auto room = connection()->room(roomId);
+    if (!room) {
+        return {};
+    }
+
+    switch (roleName) {
+    case Qt::DisplayRole:
+    case RoomNameRole:
+        return room->displayName();
+    case RoomAvatarRole:
+        return room->avatarUrl();
+    case RoomIdRole:
+        return roomId;
+    }
+
     return {};
 }
 
@@ -50,6 +65,20 @@ int CommonRoomsModel::rowCount(const QModelIndex &parent) const
     return m_commonRooms.size();
 }
 
+QHash<int, QByteArray> CommonRoomsModel::roleNames() const
+{
+    return {
+        {RoomIdRole, "roomId"},
+        {RoomNameRole, "roomName"},
+        {RoomAvatarRole, "roomAvatar"},
+    };
+}
+
+bool CommonRoomsModel::loading() const
+{
+    return m_loading;
+}
+
 void CommonRoomsModel::reload()
 {
     if (!m_connection || m_userId.isEmpty()) {
@@ -65,15 +94,26 @@ void CommonRoomsModel::reload()
         return;
     }
 
-    m_connection->callApi<NeochatGetCommonRoomsJob>(m_userId).then([this](const auto job) {
-        const auto &replyData = job->jsonData();
-        beginResetModel();
-        for (const auto &roomId : replyData[u"joined"_s].toArray()) {
-            m_commonRooms.push_back(roomId.toString());
-        }
-        endResetModel();
-        Q_EMIT countChanged();
-    });
+    m_loading = true;
+    Q_EMIT loadingChanged();
+
+    m_connection->callApi<NeochatGetCommonRoomsJob>(m_userId)
+        .then([this](const auto job) {
+            const auto &replyData = job->jsonData();
+            beginResetModel();
+            for (const auto &roomId : replyData[u"joined"_s].toArray()) {
+                m_commonRooms.push_back(roomId.toString());
+            }
+            endResetModel();
+            Q_EMIT countChanged();
+
+            m_loading = false;
+            Q_EMIT loadingChanged();
+        })
+        .onFailure([this] {
+            m_loading = false;
+            Q_EMIT loadingChanged();
+        });
 }
 
 #include "moc_commonroomsmodel.cpp"

src/app/models/commonroomsmodel.h

@@ -21,10 +21,13 @@ class CommonRoomsModel : public QAbstractListModel
     Q_PROPERTY(NeoChatConnection *connection WRITE setConnection READ connection NOTIFY connectionChanged REQUIRED)
     Q_PROPERTY(QString userId WRITE setUserId READ userId NOTIFY userIdChanged REQUIRED)
     Q_PROPERTY(int count READ rowCount NOTIFY countChanged)
+    Q_PROPERTY(bool loading READ loading NOTIFY loadingChanged)
 
 public:
     enum Roles {
-        RoomIdRole = Qt::DisplayRole,
+        RoomIdRole = Qt::UserRole,
+        RoomNameRole,
+        RoomAvatarRole,
     };
     Q_ENUM(Roles)
 
@@ -39,10 +42,15 @@ public:
     [[nodiscard]] QVariant data(const QModelIndex &index, int roleName) const override;
     [[nodiscard]] Q_INVOKABLE int rowCount(const QModelIndex &parent = {}) const override;
 
+    QHash<int, QByteArray> roleNames() const override;
+
+    bool loading() const;
+
 Q_SIGNALS:
     void connectionChanged();
     void userIdChanged();
     void countChanged();
+    void loadingChanged();
 
 private:
     void reload();
@@ -50,4 +58,5 @@ private:
     QPointer<NeoChatConnection> m_connection;
     QString m_userId;
     QList<QString> m_commonRooms;
+    bool m_loading = false;
 };

src/app/models/limitermodel.cpp

@@ -0,0 +1,41 @@
+// SPDX-FileCopyrightText: 2024 Joshua Goins <josh@redstrate.com>
+// SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
+
+#include "models/limitermodel.h"
+
+LimiterModel::LimiterModel(QObject *parent)
+    : QSortFilterProxyModel(parent)
+{
+    connect(this, &QSortFilterProxyModel::rowsInserted, this, &LimiterModel::extraCountChanged);
+    connect(this, &QSortFilterProxyModel::rowsRemoved, this, &LimiterModel::extraCountChanged);
+    connect(this, &QSortFilterProxyModel::modelReset, this, &LimiterModel::extraCountChanged);
+}
+
+int LimiterModel::maximumCount() const
+{
+    return m_maximumCount;
+}
+
+void LimiterModel::setMaximumCount(int maximumCount)
+{
+    if (m_maximumCount != maximumCount) {
+        m_maximumCount = maximumCount;
+        Q_EMIT maximumCountChanged();
+    }
+}
+
+int LimiterModel::extraCount() const
+{
+    if (sourceModel()) {
+        return std::max(sourceModel()->rowCount() - maximumCount(), 0);
+    }
+    return 0;
+}
+
+bool LimiterModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
+{
+    Q_UNUSED(source_parent)
+    return source_row < maximumCount();
+}
+
+#include "moc_limitermodel.cpp"

src/app/models/limitermodel.h

@@ -0,0 +1,41 @@
+// SPDX-FileCopyrightText: 2024 Joshua Goins <josh@redstrate.com>
+// SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
+
+#pragma once
+
+#include <QQmlEngine>
+#include <QSortFilterProxyModel>
+
+/**
+ * @class LimiterModel
+ *
+ * @brief Takes a source QAbstractItemModel model and only displays a desired maximum amount.
+ *
+ * Also gives you the remaining (filtered out) items, useful for sticking in a label or somesuch.
+ */
+class LimiterModel : public QSortFilterProxyModel
+{
+    Q_OBJECT
+    QML_ELEMENT
+
+    Q_PROPERTY(int maximumCount READ maximumCount WRITE setMaximumCount NOTIFY maximumCountChanged)
+    Q_PROPERTY(int extraCount READ extraCount NOTIFY extraCountChanged)
+
+public:
+    explicit LimiterModel(QObject *parent = nullptr);
+
+    [[nodiscard]] int maximumCount() const;
+    void setMaximumCount(int maximumCount);
+
+    [[nodiscard]] int extraCount() const;
+
+Q_SIGNALS:
+    void maximumCountChanged();
+    void extraCountChanged();
+
+protected:
+    bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const override;
+
+private:
+    int m_maximumCount = 0;
+};

src/app/models/notificationsmodel.cpp

@@ -92,7 +92,9 @@ void NotificationsModel::setConnection(NeoChatConnection *connection)
 
 void NotificationsModel::loadData()
 {
-    Q_ASSERT(m_connection);
+    if (!m_connection) {
+        return;
+    }
     if (m_job || (m_notifications.size() && m_nextToken.isEmpty())) {
         return;
     }

src/app/neochat.notifyrc

@@ -287,6 +287,7 @@ Name[ia]=Comparti
 Name[it]=Condivisione
 Name[ka]=გაზიარება
 Name[ko]=공유
+Name[lt]=Bendrinti
 Name[lv]=Kopīgot
 Name[nl]=Gedeelde
 Name[nn]=Del
@@ -322,6 +323,7 @@ Comment[ia]=Le exito de compartir un pecietta de contento
 Comment[it]=Il risultato della condivisione di un contenuto
 Comment[ka]=შემცველობის ნაწილის გაზიარების შედეგი
 Comment[ko]=콘텐츠 공유 결과
+Comment[lt]=Turinio dalies bendrinimo rezultatas
 Comment[lv]=Satura kopīgošanas rezultāts
 Comment[nl]=Het resultaat van het delen van een stukje inhoud
 Comment[nn]=Resultatet av deling av innhald

src/app/neochatconfig.kcfg

@@ -207,14 +207,6 @@
     </entry>
   </group>
   <group name="FeatureFlags">
-    <entry name="Threads" type="bool">
-      <label>Enable threads</label>
-      <default>false</default>
-    </entry>
-    <entry name="SecretBackup" type="bool">
-      <label>Enable secret backup</label>
-      <default>false</default>
-    </entry>
     <entry name="Phone3PId" type="bool">
       <label>Enable add phone numbers as 3PIDs</label>
       <default>false</default>

src/app/notificationsmanager.cpp

@@ -38,7 +38,7 @@ NotificationsManager::NotificationsManager(QObject *parent)
 {
 }
 
-void NotificationsManager::handleNotifications(QPointer<NeoChatConnection> connection)
+void NotificationsManager::handleNotifications(const QPointer<NeoChatConnection> &connection)
 {
     if (KNotificationPermission::checkPermission() == Qt::PermissionStatus::Granted) {
         startNotificationJob(connection);
@@ -68,7 +68,7 @@ void NotificationsManager::startNotificationJob(QPointer<NeoChatConnection> conn
     }
 }
 
-void NotificationsManager::processNotificationJob(QPointer<NeoChatConnection> connection, Quotient::GetNotificationsJob *job, bool initialization)
+void NotificationsManager::processNotificationJob(const QPointer<NeoChatConnection> &connection, const GetNotificationsJob *job, const bool initialization)
 {
     if (!job || !connection || !connection->isLoggedIn()) {
         return;
@@ -82,8 +82,7 @@ void NotificationsManager::processNotificationJob(QPointer<NeoChatConnection> co
             if (!m_initialTimestamp.contains(connectionId)) {
                 m_initialTimestamp[connectionId] = notification["ts"_L1].toVariant().toLongLong();
             } else {
-                qint64 timestamp = notification["ts"_L1].toVariant().toLongLong();
-                if (timestamp > m_initialTimestamp[connectionId]) {
+                if (const auto timestamp = notification["ts"_L1].toVariant().toLongLong(); timestamp > m_initialTimestamp[connectionId]) {
                     m_initialTimestamp[connectionId] = timestamp;
                 }
             }
@@ -160,29 +159,29 @@ void NotificationsManager::processNotificationJob(QPointer<NeoChatConnection> co
     }
 }
 
-bool NotificationsManager::shouldPostNotification(QPointer<NeoChatConnection> connection, const QJsonValue &notification)
+bool NotificationsManager::shouldPostNotification(const QPointer<NeoChatConnection> &connection, const QJsonValue &notification)
 {
     if (connection == nullptr || !connection->isLoggedIn()) {
         return false;
     }
 
-    auto room = connection->room(notification["room_id"_L1].toString());
+    const auto room = connection->room(notification["room_id"_L1].toString());
     if (room == nullptr) {
         return false;
     }
 
-    // If the room is the current room and the application is active the notification
+    // If the room is the current room and the application is active, the notification
     // should not be shown.
-    // This is setup so that if the application is inactive the notification will
+    // This is set up so that if the application is inactive, the notification will
     // always be posted, even if the room is the current room.
-    bool isCurrentRoom = RoomManager::instance().currentRoom() && room->id() == RoomManager::instance().currentRoom()->id();
-    if (isCurrentRoom && QGuiApplication::applicationState() == Qt::ApplicationActive) {
+    if (RoomManager::instance().currentRoom() && room->id() == RoomManager::instance().currentRoom()->id()
+        && QGuiApplication::applicationState() == Qt::ApplicationActive) {
         return false;
     }
 
-    // If the notification timestamp is earlier than the initial timestamp assume
+    // If the notification timestamp is earlier than the initial timestamp, assume
     // the notification is old and shouldn't be posted.
-    qint64 timestamp = notification["ts"_L1].toDouble();
+    const auto timestamp = notification["ts"_L1].toDouble();
     if (timestamp < m_initialTimestamp[connection->user()->id()]) {
         return false;
     }
@@ -199,7 +198,7 @@ void NotificationsManager::postNotification(NeoChatRoom *room,
                                             const QString &text,
                                             const QImage &icon,
                                             const QString &replyEventId,
-                                            bool canReply,
+                                            const bool canReply,
                                             qint64 timestamp)
 {
     const QString roomId = room->id();
@@ -216,12 +215,12 @@ void NotificationsManager::postNotification(NeoChatRoom *room,
         }
     });
 
+    notification->setTitle(room->displayName());
+
     QString entry;
-    if (sender == room->displayName()) {
-        notification->setTitle(sender);
+    if (room->isDirectChat()) {
         entry = text.toHtmlEscaped();
     } else {
-        notification->setTitle(room->displayName());
         entry = i18n("%1: %2", sender, text.toHtmlEscaped());
     }
 
@@ -253,7 +252,9 @@ void NotificationsManager::postNotification(NeoChatRoom *room,
         notification->setReplyAction(std::move(replyAction));
     }
 
-    notification->setHint(u"x-kde-origin-name"_s, room->localMember().id());
+    if (Controller::instance().accounts()->rowCount() > 1) {
+        notification->setHint(u"x-kde-origin-name"_s, room->localMember().id());
+    }
     notification->sendEvent();
 }
 
@@ -269,10 +270,8 @@ void NotificationsManager::postInviteNotification(NeoChatRoom *rawRoom)
     if (NeoChatConfig::rejectUnknownInvites()) {
         auto job = room->connection()->callApi<NeochatGetCommonRoomsJob>(roomMemberEvent->senderId());
         connect(job, &BaseJob::result, this, [this, job, room] {
-            QJsonObject replyData = job->jsonData();
-            if (replyData.contains(u"joined"_s)) {
-                const bool inAnyOfOurRooms = !replyData["joined"_L1].toArray().isEmpty();
-                if (inAnyOfOurRooms) {
+            if (QJsonObject replyData = job->jsonData(); replyData.contains(u"joined"_s)) {
+                if (!replyData["joined"_L1].toArray().isEmpty()) {
                     doPostInviteNotification(room);
                 } else {
                     room->forget();
@@ -284,7 +283,7 @@ void NotificationsManager::postInviteNotification(NeoChatRoom *rawRoom)
     }
 }
 
-void NotificationsManager::doPostInviteNotification(QPointer<NeoChatRoom> room)
+void NotificationsManager::doPostInviteNotification(const QPointer<NeoChatRoom> &room)
 {
     const auto roomMemberEvent = room->currentState().get<RoomMemberEvent>(room->localMember().id());
     if (roomMemberEvent == nullptr) {
@@ -293,18 +292,18 @@ void NotificationsManager::doPostInviteNotification(QPointer<NeoChatRoom> room)
     const auto sender = room->member(roomMemberEvent->senderId());
 
     QImage avatar_image;
-    if (roomMemberEvent && !room->member(roomMemberEvent->senderId()).avatarUrl().isEmpty()) {
+    if (!room->member(roomMemberEvent->senderId()).avatarUrl().isEmpty()) {
         avatar_image = room->member(roomMemberEvent->senderId()).avatar(128, 128, {});
     } else {
         qWarning() << "using this room's avatar";
         avatar_image = room->avatar(128);
     }
 
-    KNotification *notification = new KNotification(u"invite"_s);
+    const auto notification = new KNotification(u"invite"_s);
     notification->setText(i18n("%1 invited you to a room", sender.htmlSafeDisplayName()));
     notification->setTitle(room->displayName());
     notification->setPixmap(createNotificationImage(avatar_image, nullptr));
-    auto defaultAction = notification->addDefaultAction(i18n("Open this invitation in NeoChat"));
+    const auto defaultAction = notification->addDefaultAction(i18n("Open this invitation in NeoChat"));
     connect(defaultAction, &KNotificationAction::activated, this, [notification, room]() {
         if (!room) {
             return;
@@ -347,7 +346,9 @@ void NotificationsManager::doPostInviteNotification(QPointer<NeoChatRoom> room)
         m_invitations.remove(room->id());
     });
 
-    notification->setHint(u"x-kde-origin-name"_s, room->localMember().id());
+    if (Controller::instance().accounts()->rowCount() > 1) {
+        notification->setHint(u"x-kde-origin-name"_s, room->localMember().id());
+    }
 
     notification->sendEvent();
 }
@@ -363,11 +364,9 @@ void NotificationsManager::postPushNotification(const QByteArray &message)
 {
     const auto json = QJsonDocument::fromJson(message).object();
 
-    const auto type = json["notification"_L1]["type"_L1].toString();
-
     // the only two types of push notifications we support right now
-    if (type == u"m.room.message"_s || type == u"m.room.encrypted"_s) {
-        auto notification = new KNotification("message"_L1);
+    if (const auto type = json["notification"_L1]["type"_L1].toString(); type == u"m.room.message"_s || type == u"m.room.encrypted"_s) {
+        const auto notification = new KNotification("message"_L1);
 
         const auto sender = json["notification"_L1]["sender_display_name"_L1].toString();
         const auto roomName = json["notification"_L1]["room_name"_L1].toString();
@@ -387,13 +386,13 @@ void NotificationsManager::postPushNotification(const QByteArray &message)
         }
 
 #ifdef HAVE_KIO
-        auto openAction = notification->addAction(i18n("Open NeoChat"));
+        const auto openAction = notification->addAction(i18n("Open NeoChat"));
         connect(openAction, &KNotificationAction::activated, notification, [=]() {
             QString properId = roomId;
             properId = properId.replace(u"#"_s, QString());
             properId = properId.replace(u"!"_s, QString());
 
-            auto *job = new KIO::ApplicationLauncherJob(KService::serviceByDesktopName(u"org.kde.neochat"_s));
+            const auto job = new KIO::ApplicationLauncherJob(KService::serviceByDesktopName(u"org.kde.neochat"_s));
             job->setUrls({QUrl::fromUserInput(u"matrix:r/%1"_s.arg(properId))});
             job->start();
         });
@@ -424,13 +423,12 @@ QPixmap NotificationsManager::createNotificationImage(const QImage &icon, NeoCha
     painter.setBrush(Qt::white);
     painter.drawRoundedRect(imageRect, imageRect.width(), imageRect.height());
 
-    QBrush brush(icon.scaledToHeight(biggestDimension));
+    const QBrush brush(icon.scaledToHeight(biggestDimension));
     painter.setBrush(brush);
     painter.drawRoundedRect(imageRect, imageRect.width(), imageRect.height());
 
-    if (room != nullptr) {
-        const QImage roomAvatar = room->avatar(imageRect.width(), imageRect.height());
-        if (!roomAvatar.isNull() && icon != roomAvatar) {
+    if (room) {
+        if (const auto roomAvatar = room->avatar(imageRect.width(), imageRect.height()); !roomAvatar.isNull() && icon != roomAvatar) {
             const QRect lowerQuarter{imageRect.center(), imageRect.size() / 2};
 
             painter.setBrush(Qt::white);

src/app/notificationsmanager.h

@@ -58,7 +58,7 @@ public:
     /**
      * @brief Handle the notifications for the given connection.
      */
-    void handleNotifications(QPointer<NeoChatConnection> connection);
+    void handleNotifications(const QPointer<NeoChatConnection> &connection);
 
 private:
     QHash<QString, qint64> m_initialTimestamp;
@@ -67,8 +67,8 @@ private:
     QStringList m_connActiveJob;
     void startNotificationJob(QPointer<NeoChatConnection> connection);
 
-    QPixmap createNotificationImage(const QImage &icon, NeoChatRoom *room);
-    bool shouldPostNotification(QPointer<NeoChatConnection> connection, const QJsonValue &notification);
+    static QPixmap createNotificationImage(const QImage &icon, NeoChatRoom *room);
+    bool shouldPostNotification(const QPointer<NeoChatConnection> &connection, const QJsonValue &notification);
     void postNotification(NeoChatRoom *room,
                           const QString &sender,
                           const QString &text,
@@ -77,7 +77,7 @@ private:
                           bool canReply,
                           qint64 timestamp);
 
-    void doPostInviteNotification(QPointer<NeoChatRoom> room);
+    void doPostInviteNotification(const QPointer<NeoChatRoom> &room);
 
     QHash<QString, std::pair<qint64, KNotification *>> m_notifications;
     QHash<QString, QPointer<KNotification>> m_invitations;
@@ -85,5 +85,5 @@ private:
     bool permissionAsked = false;
 
 private Q_SLOTS:
-    void processNotificationJob(QPointer<NeoChatConnection> connection, Quotient::GetNotificationsJob *job, bool initialization);
+    void processNotificationJob(const QPointer<NeoChatConnection> &connection, const Quotient::GetNotificationsJob *job, bool initialization);
 };

src/app/qml/AccountMenu.qml

@@ -5,6 +5,7 @@ pragma ComponentBehavior: Bound
 
 import QtQuick
 import QtQuick.Controls as QQC2
+import QtMultimedia
 
 import org.kde.kirigami as Kirigami
 import org.kde.kirigamiaddons.components as KirigamiComponents
@@ -18,27 +19,25 @@ KirigamiComponents.ConvergentContextMenu {
     required property NeoChatConnection connection
     required property Kirigami.ApplicationWindow window
 
-    Kirigami.Action {
-        text: i18nc("@action:button", "Show QR Code")
-        icon.name: "view-barcode-qr-symbolic"
-        onTriggered: {
-            (Qt.createComponent('org.kde.neochat', 'QrCodeMaximizeComponent').createObject(QQC2.Overlay.overlay, {
-                text: "https://matrix.to/#/" + root.connection.localUser.id,
-                title: root.connection.localUser.displayName,
-                subtitle: root.connection.localUser.id,
-                // Note: User::avatarUrl does not set user_id, and thus cannot be used directly here. Hence the makeMediaUrl.
-                avatarSource: root.connection.localUser.avatarUrl.toString().length > 0 ? root.connection.makeMediaUrl(root.connection.localUser.avatarUrl) : ""
-            }) as QrCodeMaximizeComponent).open();
-        }
+    data: MediaDevices {
+        id: devices
     }
 
     Kirigami.Action {
-        text: i18nc("@action:inmenu", "Switch Account")
-        icon.name: "system-switch-user"
-        shortcut: "Ctrl+U"
-        onTriggered: (Qt.createComponent("org.kde.neochat", "AccountSwitchDialog").createObject(QQC2.Overlay.overlay, {
+        text: i18nc("@action:button", "Open Profile")
+        icon.name: "im-user-symbolic"
+        onTriggered: RoomManager.resolveResource(root.connection.localUserId, "qr") // Use "qr" action to make sure a room isn't passed, see RoomManager::visitUser
+    }
+
+    Kirigami.Action {
+        text: i18nc("@action:inmenu", "Scan a QR Code")
+        icon.name: "document-scan-symbolic"
+        visible: devices.videoInputs.length > 0
+        onTriggered: (root.Kirigami.PageStack.pageStack as Kirigami.PageRow).pushDialogLayer(Qt.createComponent("org.kde.neochat", "QrScannerPage"), {
             connection: root.connection
-        }) as Kirigami.Dialog).open();
+        }, {
+            title: i18nc("@title", "Scan a QR Code")
+        })
     }
 
     Kirigami.Action {
@@ -55,14 +54,6 @@ KirigamiComponents.ConvergentContextMenu {
         }
     }
 
-    Kirigami.Action {
-        text: i18nc("@action:inmenu", "Devices")
-        icon.name: "computer-symbolic"
-        onTriggered: {
-            NeoChatSettingsView.open('devices');
-        }
-    }
-
     Kirigami.Action {
         text: i18nc("@action:inmenu", "Open Developer Tools")
         icon.name: "tools"
@@ -76,15 +67,6 @@ KirigamiComponents.ConvergentContextMenu {
         })
     }
 
-    Kirigami.Action {
-        text: i18nc("@action:inmenu", "Open Secret Backup")
-        icon.name: "unlock"
-        visible: NeoChatConfig.secretBackup
-        onTriggered: root.window.pageStack.pushDialogLayer(Qt.createComponent('org.kde.neochat', 'UnlockSSSSDialog'), {}, {
-            title: i18nc("@title:window", "Open Key Backup")
-        })
-    }
-
     Kirigami.Action {
         text: i18nc("@action:inmenu", "Verify This Device")
         icon.name: "security-low"
@@ -104,10 +86,25 @@ KirigamiComponents.ConvergentContextMenu {
     }
 
     Kirigami.Action {
-        text: i18nc("@action:inmenu", "Logout…")
-        icon.name: "im-kick-user"
-        onTriggered: (Qt.createComponent("org.kde.neochat", "ConfirmLogoutDialog").createObject(QQC2.Overlay.overlay, {
+        text: i18nc("@action:inmenu Open support dialog", "Support")
+        icon.name: "help-contents-symbolic"
+        onTriggered: {
+            (Qt.createComponent("org.kde.neochat", "SupportDialog").createObject(QQC2.Overlay.overlay, {
+                connection: root.connection,
+            }) as SupportDialog).open();
+        }
+    }
+
+    Kirigami.Action {
+        separator: true
+    }
+
+    Kirigami.Action {
+        text: i18nc("@action:inmenu", "Switch Account")
+        icon.name: "system-switch-user"
+        shortcut: "Ctrl+U"
+        onTriggered: (Qt.createComponent("org.kde.neochat", "AccountSwitchDialog").createObject(QQC2.Overlay.overlay, {
             connection: root.connection
-        }) as Kirigami.Dialog).open()
+        }) as Kirigami.Dialog).open();
     }
 }

src/app/qml/AccountSwitchDialog.qml

@@ -61,10 +61,10 @@ Kirigami.Dialog {
             }
 
             onClicked: {
+                root.close();
                 ((root.QQC2.ApplicationWindow.window as Kirigami.ApplicationWindow).pageStack as Kirigami.PageRow).pushDialogLayer(Qt.createComponent('org.kde.neochat.login', 'WelcomePage'), {}, {
                     title: i18nc("@title:window", "Login")
                 });
-                root.close();
             }
             Keys.onUpPressed: {
                 accountView.currentIndex = accountView.count - 1;

src/app/qml/AvatarTabButton.qml

@@ -21,6 +21,7 @@ Delegates.RoundedItemDelegate {
     signal contextMenuRequested
     signal selected
 
+    activeFocusOnTab: true
     padding: Kirigami.Units.largeSpacing
 
     QQC2.ToolTip.visible: hovered

src/app/qml/ChooseRoomDialog.qml

@@ -4,9 +4,6 @@
 pragma ComponentBehavior: Bound
 
 import QtQuick
-import QtQuick.Controls
-
-import org.kde.kirigami as Kirigami
 
 import org.kde.neochat
 

src/app/qml/CodeMaximizeComponent.qml

@@ -20,9 +20,9 @@ Components.AbstractMaximizeComponent {
     property NeochatRoomMember author
 
     /**
-     * @brief The timestamp of the message.
+     * @brief The timestamp of the event as a neoChatDateTime.
      */
-    property var time
+    required property neoChatDateTime dateTime
 
     /**
      * @brief The code text to show.
@@ -64,7 +64,7 @@ Components.AbstractMaximizeComponent {
             }
             QQC2.Label {
                 id: dateTimeLabel
-                text: root.time.toLocaleString(Qt.locale(), Locale.ShortFormat)
+                text: root.dateTime.relativeDateTime
                 color: Kirigami.Theme.disabledTextColor
                 elide: Text.ElideRight
             }
@@ -79,7 +79,7 @@ Components.AbstractMaximizeComponent {
         QQC2.ScrollBar.horizontal.policy: QQC2.ScrollBar.AlwaysOff
 
         QQC2.TextArea {
-            id: codeText
+            id: codeTextEdit
             topPadding: Kirigami.Units.smallSpacing
             bottomPadding: Kirigami.Units.smallSpacing
             leftPadding: lineNumberColumn.width + lineNumberColumn.anchors.leftMargin + Kirigami.Units.smallSpacing * 2
@@ -100,15 +100,15 @@ Components.AbstractMaximizeComponent {
 
             SyntaxHighlighter {
                 property string definitionName: Repository.definitionForName(root.language).name
-                textEdit: definitionName == "None" ? null : codeText
+                textEdit: definitionName == "None" ? null : codeTextEdit
                 definition: definitionName
             }
             ColumnLayout {
                 id: lineNumberColumn
                 anchors {
-                    top: codeText.top
-                    topMargin: codeText.topPadding + 1
-                    left: codeText.left
+                    top: codeTextEdit.top
+                    topMargin: codeTextEdit.topPadding + 1
+                    left: codeTextEdit.left
                     leftMargin: Kirigami.Units.smallSpacing
                 }
                 spacing: 0
@@ -116,7 +116,7 @@ Components.AbstractMaximizeComponent {
                     id: repeater
                     model: LineModel {
                         id: lineModel
-                        document: codeText.textDocument
+                        Component.onCompleted: setDocument(codeTextEdit.textDocument)
                     }
                     delegate: QQC2.Label {
                         id: label
@@ -150,4 +150,6 @@ Components.AbstractMaximizeComponent {
             color: Kirigami.Theme.backgroundColor
         }
     }
+
+    onOpened: forceActiveFocus()
 }

src/app/qml/CollapsedRoomDelegate.qml

@@ -3,8 +3,6 @@
 
 import QtQuick
 import QtQuick.Controls as QQC2
-import QtQuick.Layouts
-import QtQml.Models
 
 import org.kde.kirigami as Kirigami
 import org.kde.kirigamiaddons.labs.components as KirigamiComponents

src/app/qml/ConfirmLeaveDialog.qml

@@ -13,22 +13,21 @@ Kirigami.PromptDialog {
 
     required property NeoChatRoom room
 
-    title: i18nc("@title:dialog", "Confirm Leaving Room")
+    title: root.room.isSpace ? i18nc("@title:dialog", "Confirm Leaving Space") : i18nc("@title:dialog", "Confirm Leaving Room")
     subtitle: root.room ? i18nc("Do you really want to leave <room name>?", "Do you really want to leave %1?", root.room.displayNameForHtml) : ""
     dialogType: Kirigami.PromptDialog.Warning
+    standardButtons: QQC2.Dialog.Cancel
 
-    onRejected: {
-        root.close();
-    }
+    onAccepted: root.room.forget()
 
     footer: QQC2.DialogButtonBox {
-        standardButtons: QQC2.Dialog.Cancel
-
         QQC2.Button {
-            text: i18nc("@action:button", "Leave Room")
-            QQC2.DialogButtonBox.buttonRole: QQC2.DialogButtonBox.AcceptRole
+            text: i18nc("@action:button Leave this room/space", "Leave")
             icon.name: "arrow-left-symbolic"
-            onClicked: root.room.forget();
+
+            onClicked: root.accept()
+
+            QQC2.DialogButtonBox.buttonRole: QQC2.DialogButtonBox.AcceptRole
         }
     }
 }

src/app/qml/ConfirmLogoutDialog.qml

@@ -15,22 +15,16 @@ Kirigami.PromptDialog {
     title: i18nc("@title:dialog", "Sign out")
     subtitle: i18n("Are you sure you want to sign out?")
     dialogType: Kirigami.PromptDialog.Warning
+    standardButtons: QQC2.Dialog.Cancel
 
-    onRejected: {
-        root.close();
-    }
+    onAccepted: root.connection.logout(true)
 
     footer: QQC2.DialogButtonBox {
-        standardButtons: QQC2.Dialog.Cancel
-
         QQC2.Button {
             text: i18nc("@action:button", "Sign out")
+            onClicked: root.accept()
+
             QQC2.DialogButtonBox.buttonRole: QQC2.DialogButtonBox.AcceptRole
-            onClicked: {
-                root.connection.logout(true);
-                root.close();
-                root.accepted();
-            }
         }
     }
 }

src/app/qml/ConfirmUrlDialog.qml

@@ -17,12 +17,5 @@ Kirigami.PromptDialog {
 
     standardButtons: QQC2.DialogButtonBox.Open | QQC2.DialogButtonBox.Cancel
 
-    onAccepted: {
-        Qt.openUrlExternally(root.link);
-        root.close();
-    }
-
-    onRejected: {
-        root.close();
-    }
+    onAccepted: Qt.openUrlExternally(root.link)
 }