Space Home Page

Add a space homepage with the ability to both create new room and add existing rooms to the space. This uses a tree model for the space hierarchy and will go to any number of levels. The user should only see the add options if they have appropriate permissions.

This MR also combines the create space and room pages and adds a lot of optional functionality for managing space children.

![image](/uploads/1764b0319241ff870dc39b18b39f5d51/image.png)

src/models/spacechildrenmodel.cpp

@@ -0,0 +1,289 @@
+// 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 "spacechildrenmodel.h"
+
+#include <Quotient/connection.h>
+#include <Quotient/jobs/basejob.h>
+#include <Quotient/room.h>
+
+#include "controller.h"
+
+SpaceChildrenModel::SpaceChildrenModel(QObject *parent)
+    : QAbstractItemModel(parent)
+{
+    m_rootItem = new SpaceTreeItem();
+}
+
+SpaceChildrenModel::~SpaceChildrenModel()
+{
+    delete m_rootItem;
+}
+
+NeoChatRoom *SpaceChildrenModel::space() const
+{
+    return m_space;
+}
+
+void SpaceChildrenModel::setSpace(NeoChatRoom *space)
+{
+    if (space == m_space) {
+        return;
+    }
+    // disconnect the new room signal from the old connection in case it is different.
+    if (m_space != nullptr) {
+        disconnect(m_space->connection(), &Quotient::Connection::loadedRoomState, this, nullptr);
+    }
+
+    m_space = space;
+    Q_EMIT spaceChanged();
+
+    for (auto job : m_currentJobs) {
+        if (job) {
+            job->abandon();
+        }
+    }
+    m_currentJobs.clear();
+
+    auto connection = m_space->connection();
+    connect(connection, &Quotient::Connection::loadedRoomState, this, [this](Quotient::Room *room) {
+        if (m_pendingChildren.contains(room->name())) {
+            m_pendingChildren.removeAll(room->name());
+            refreshModel();
+        }
+    });
+    connect(m_space, &Quotient::Room::changed, this, [this]() {
+        refreshModel();
+    });
+
+    refreshModel();
+}
+
+bool SpaceChildrenModel::loading() const
+{
+    return m_loading;
+}
+
+void SpaceChildrenModel::refreshModel()
+{
+    beginResetModel();
+    m_replacedRooms.clear();
+    delete m_rootItem;
+    m_loading = true;
+    Q_EMIT loadingChanged();
+    m_rootItem = new SpaceTreeItem();
+    endResetModel();
+    auto job = m_space->connection()->callApi<Quotient::GetSpaceHierarchyJob>(m_space->id(), Quotient::none, Quotient::none, 1);
+    m_currentJobs.append(job);
+    connect(job, &Quotient::BaseJob::success, this, [this, job]() {
+        insertChildren(job->rooms());
+    });
+}
+
+void SpaceChildrenModel::insertChildren(std::vector<Quotient::GetSpaceHierarchyJob::ChildRoomsChunk> children, const QModelIndex &parent)
+{
+    SpaceTreeItem *parentItem = getItem(parent);
+
+    if (children[0].roomId == m_space->id() || children[0].roomId == parentItem->id()) {
+        children.erase(children.begin());
+    }
+
+    // If this is the first set of children added to the root item then we need to
+    // set it so that we are no longer loading.
+    if (rowCount(QModelIndex()) == 0 && !children.empty()) {
+        m_loading = false;
+        Q_EMIT loadingChanged();
+    }
+
+    beginInsertRows(parent, parentItem->childCount(), parentItem->childCount() + children.size() - 1);
+    for (unsigned long i = 0; i < children.size(); ++i) {
+        if (children[i].roomId == m_space->id() || children[i].roomId == parentItem->id()) {
+            continue;
+        } else {
+            int insertRow = parentItem->childCount();
+            if (const auto room = m_space->connection()->room(children[i].roomId)) {
+                const auto predecessorId = room->predecessorId();
+                if (!predecessorId.isEmpty()) {
+                    m_replacedRooms += predecessorId;
+                }
+                const auto successorId = room->successorId();
+                if (!successorId.isEmpty()) {
+                    m_replacedRooms += successorId;
+                }
+            }
+            parentItem->insertChild(insertRow,
+                                    new SpaceTreeItem(parentItem,
+                                                      children[i].roomId,
+                                                      children[i].name,
+                                                      children[i].canonicalAlias,
+                                                      children[i].topic,
+                                                      children[i].numJoinedMembers,
+                                                      children[i].avatarUrl,
+                                                      children[i].guestCanJoin,
+                                                      children[i].worldReadable,
+                                                      children[i].roomType == QLatin1String("m.space")));
+            if (children[i].childrenState.size() > 0) {
+                auto job = m_space->connection()->callApi<Quotient::GetSpaceHierarchyJob>(children[i].roomId, Quotient::none, Quotient::none, 1);
+                m_currentJobs.append(job);
+                connect(job, &Quotient::BaseJob::success, this, [this, parent, insertRow, job]() {
+                    insertChildren(job->rooms(), index(insertRow, 0, parent));
+                });
+            }
+        }
+    }
+    endInsertRows();
+}
+
+SpaceTreeItem *SpaceChildrenModel::getItem(const QModelIndex &index) const
+{
+    if (index.isValid()) {
+        SpaceTreeItem *item = static_cast<SpaceTreeItem *>(index.internalPointer());
+        if (item) {
+            return item;
+        }
+    }
+    return m_rootItem;
+}
+
+QVariant SpaceChildrenModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid()) {
+        return QVariant();
+    }
+
+    SpaceTreeItem *child = getItem(index);
+    if (role == DisplayNameRole) {
+        auto displayName = child->name();
+        if (!displayName.isEmpty()) {
+            return displayName;
+        }
+
+        displayName = child->canonicalAlias();
+        if (!displayName.isEmpty()) {
+            return displayName;
+        }
+
+        return child->id();
+    }
+    if (role == AvatarUrlRole) {
+        return child->avatarUrl();
+    }
+    if (role == TopicRole) {
+        return child->topic();
+    }
+    if (role == RoomIDRole) {
+        return child->id();
+    }
+    if (role == AliasRole) {
+        return child->canonicalAlias();
+    }
+    if (role == MemberCountRole) {
+        return child->memberCount();
+    }
+    if (role == AllowGuestsRole) {
+        return child->allowGuests();
+    }
+    if (role == WorldReadableRole) {
+        return child->worldReadable();
+    }
+    if (role == IsJoinedRole) {
+        return child->isJoined();
+    }
+    if (role == IsSpaceRole) {
+        return child->isSpace();
+    }
+    if (role == CanAddChildrenRole) {
+        auto connection = Controller::instance().activeConnection();
+        if (const auto room = static_cast<NeoChatRoom *>(connection->room(child->id()))) {
+            return room->canSendState(QLatin1String("m.space.child"));
+        }
+        return false;
+    }
+
+    return {};
+}
+
+QModelIndex SpaceChildrenModel::index(int row, int column, const QModelIndex &parent) const
+{
+    if (!hasIndex(row, column, parent)) {
+        return QModelIndex();
+    }
+
+    SpaceTreeItem *parentItem = getItem(parent);
+    if (!parentItem) {
+        return QModelIndex();
+    }
+
+    SpaceTreeItem *childItem = parentItem->child(row);
+    if (childItem) {
+        return createIndex(row, column, childItem);
+    }
+    return QModelIndex();
+}
+
+QModelIndex SpaceChildrenModel::parent(const QModelIndex &index) const
+{
+    if (!index.isValid()) {
+        return QModelIndex();
+    }
+
+    SpaceTreeItem *childItem = static_cast<SpaceTreeItem *>(index.internalPointer());
+    SpaceTreeItem *parentItem = childItem->parentItem();
+
+    if (parentItem == m_rootItem) {
+        return QModelIndex();
+    }
+
+    return createIndex(parentItem->row(), 0, parentItem);
+}
+
+int SpaceChildrenModel::rowCount(const QModelIndex &parent) const
+{
+    SpaceTreeItem *parentItem;
+    if (parent.column() > 0) {
+        return 0;
+    }
+
+    if (!parent.isValid()) {
+        parentItem = m_rootItem;
+    } else {
+        parentItem = static_cast<SpaceTreeItem *>(parent.internalPointer());
+    }
+
+    return parentItem->childCount();
+}
+
+int SpaceChildrenModel::columnCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent);
+    return 1;
+}
+
+QHash<int, QByteArray> SpaceChildrenModel::roleNames() const
+{
+    QHash<int, QByteArray> roles;
+
+    roles[DisplayNameRole] = "displayName";
+    roles[AvatarUrlRole] = "avatarUrl";
+    roles[TopicRole] = "topic";
+    roles[RoomIDRole] = "roomId";
+    roles[MemberCountRole] = "memberCount";
+    roles[AllowGuestsRole] = "allowGuests";
+    roles[WorldReadableRole] = "worldReadable";
+    roles[IsJoinedRole] = "isJoined";
+    roles[AliasRole] = "alias";
+    roles[IsSpaceRole] = "isSpace";
+    roles[CanAddChildrenRole] = "canAddChildren";
+
+    return roles;
+}
+
+bool SpaceChildrenModel::isRoomReplaced(const QString &roomId) const
+{
+    return m_replacedRooms.contains(roomId);
+}
+
+void SpaceChildrenModel::addPendingChild(const QString &childName)
+{
+    m_pendingChildren += childName;
+}

src/models/spacechildrenmodel.h

@@ -0,0 +1,139 @@
+// 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
+
+#pragma once
+
+#include <QAbstractItemModel>
+#include <QQmlEngine>
+
+#include <Quotient/csapi/space_hierarchy.h>
+#include <qtmetamacros.h>
+
+#include "neochatroom.h"
+#include "spacetreeitem.h"
+
+/**
+ * @class SpaceChildrenModel
+ *
+ * Create a model that contains a list of the child rooms for any given space id.
+ */
+class SpaceChildrenModel : public QAbstractItemModel
+{
+    Q_OBJECT
+    QML_ELEMENT
+
+    /**
+     * @brief The current space that the hierarchy is being generated for.
+     */
+    Q_PROPERTY(NeoChatRoom *space READ space WRITE setSpace NOTIFY spaceChanged)
+
+    /**
+     * @brief Whether the model is loading the initial set of children.
+     */
+    Q_PROPERTY(bool loading READ loading NOTIFY loadingChanged)
+
+public:
+    enum Roles {
+        DisplayNameRole = Qt::DisplayRole,
+        AvatarUrlRole,
+        TopicRole,
+        RoomIDRole,
+        AliasRole,
+        MemberCountRole,
+        AllowGuestsRole,
+        WorldReadableRole,
+        IsJoinedRole,
+        IsSpaceRole,
+        CanAddChildrenRole,
+    };
+
+    explicit SpaceChildrenModel(QObject *parent = nullptr);
+    ~SpaceChildrenModel();
+
+    NeoChatRoom *space() const;
+    void setSpace(NeoChatRoom *space);
+
+    bool loading() const;
+
+    /**
+     * @brief Get the given role value at the given index.
+     *
+     * @sa QAbstractItemModel::data
+     */
+    QVariant data(const QModelIndex &index, int role = DisplayNameRole) const override;
+
+    /**
+     * @brief Returns the index of the item in the model specified by the given row, column and parent index.
+     *
+     * @sa QAbstractItemModel::index
+     */
+    QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override;
+
+    /**
+     * @brief Returns the parent of the model item with the given index.
+     *
+     * If the item has no parent, an invalid QModelIndex is returned.
+     *
+     * @sa QAbstractItemModel::parent
+     */
+    QModelIndex parent(const QModelIndex &index) const override;
+
+    /**
+     * @brief Number of rows in the model.
+     *
+     * @sa QAbstractItemModel::rowCount
+     */
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+
+    /**
+     * @brief Number of columns in the model.
+     *
+     * @sa QAbstractItemModel::columnCount
+     */
+    int columnCount(const QModelIndex &parent = QModelIndex()) const override;
+
+    /**
+     * @brief Returns a mapping from Role enum values to role names.
+     *
+     * @sa Roles, QAbstractItemModel::roleNames()
+     */
+    QHash<int, QByteArray> roleNames() const override;
+
+    /**
+     * @brief Whether the room has been replaced.
+     *
+     * @note This information is only available if the local user is either a member
+     *       of the replaced room or is a member of the successor room as currently
+     *       there is no other way to obtain the required information.
+     */
+    bool isRoomReplaced(const QString &roomId) const;
+
+    /**
+     * @brief Add the name of new child room that is expected to be added soon.
+     *
+     * A pending child is one where Quotient::Connection::createRoom has been called
+     * but the room hasn't synced with the server yet. This list is used to check
+     * whether a new room loading should trigger a refresh of the model, as we only
+     * want to trigger a refresh if the loading room is part of this space.
+     */
+    Q_INVOKABLE void addPendingChild(const QString &childName);
+
+Q_SIGNALS:
+    void spaceChanged();
+    void loadingChanged();
+
+private:
+    NeoChatRoom *m_space = nullptr;
+    SpaceTreeItem *m_rootItem;
+
+    bool m_loading = false;
+    QList<QPointer<Quotient::GetSpaceHierarchyJob>> m_currentJobs;
+    QList<QString> m_pendingChildren;
+
+    QList<QString> m_replacedRooms;
+
+    SpaceTreeItem *getItem(const QModelIndex &index) const;
+
+    void refreshModel();
+    void insertChildren(std::vector<Quotient::GetSpaceHierarchyJob::ChildRoomsChunk> children, const QModelIndex &parent = QModelIndex());
+};

src/models/spacechildsortfiltermodel.cpp

@@ -0,0 +1,46 @@
+// 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 "spacechildsortfiltermodel.h"
+
+#include "spacechildrenmodel.h"
+
+SpaceChildSortFilterModel::SpaceChildSortFilterModel(QObject *parent)
+    : QSortFilterProxyModel(parent)
+{
+    setRecursiveFilteringEnabled(true);
+    sort(0);
+}
+
+void SpaceChildSortFilterModel::setFilterText(const QString &filterText)
+{
+    m_filterText = filterText;
+    Q_EMIT filterTextChanged();
+    invalidateFilter();
+}
+
+QString SpaceChildSortFilterModel::filterText() const
+{
+    return m_filterText;
+}
+
+bool SpaceChildSortFilterModel::lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const
+{
+    if (!source_left.data(SpaceChildrenModel::IsSpaceRole).toBool() && source_right.data(SpaceChildrenModel::IsSpaceRole).toBool()) {
+        return false;
+    }
+    return true;
+}
+
+bool SpaceChildSortFilterModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
+{
+    QModelIndex index = sourceModel()->index(sourceRow, 0, sourceParent);
+    if (auto sourceModel = static_cast<SpaceChildrenModel *>(this->sourceModel())) {
+        bool isReplaced = sourceModel->isRoomReplaced(index.data(SpaceChildrenModel::RoomIDRole).toString());
+        bool acceptRoom = index.data(SpaceChildrenModel::DisplayNameRole).toString().contains(m_filterText, Qt::CaseInsensitive);
+        return !isReplaced && acceptRoom;
+    }
+    return true;
+}
+
+#include "moc_spacechildsortfiltermodel.cpp"

src/models/spacechildsortfiltermodel.h

@@ -0,0 +1,54 @@
+// 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
+
+#pragma once
+
+#include <QQmlEngine>
+#include <QSortFilterProxyModel>
+
+/**
+ * @class SpaceChildSortFilterModel
+ *
+ * This class creates a custom QSortFilterProxyModel for filtering and sorting spaces
+ * in a SpaceChildrenModel.
+ *
+ * @sa SpaceChildrenModel
+ */
+class SpaceChildSortFilterModel : public QSortFilterProxyModel
+{
+    Q_OBJECT
+    QML_ELEMENT
+
+    /**
+     * @brief The text to use to filter room names.
+     */
+    Q_PROPERTY(QString filterText READ filterText READ filterText WRITE setFilterText NOTIFY filterTextChanged)
+
+public:
+    SpaceChildSortFilterModel(QObject *parent = nullptr);
+
+    void setFilterText(const QString &filterText);
+    [[nodiscard]] QString filterText() const;
+
+protected:
+    /**
+     * @brief Returns true if the value of source_left is less than source_right.
+     *
+     * @sa QSortFilterProxyModel::lessThan
+     */
+    bool lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const override;
+
+    /**
+     * @brief Custom filter function checking if an event type has been filtered out.
+     *
+     * The filter rejects a row if the room is known been replaced or if a search
+     * string is set it will only return rooms that match.
+     */
+    bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
+
+Q_SIGNALS:
+    void filterTextChanged();
+
+private:
+    QString m_filterText;
+};

src/models/spacetreeitem.cpp

@@ -0,0 +1,140 @@
+// 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 "spacetreeitem.h"
+
+#include "controller.h"
+
+SpaceTreeItem::SpaceTreeItem(SpaceTreeItem *parent,
+                             const QString &id,
+                             const QString &name,
+                             const QString &canonicalAlias,
+                             const QString &topic,
+                             int memberCount,
+                             const QUrl &avatarUrl,
+                             bool allowGuests,
+                             bool worldReadable,
+                             bool isSpace)
+    : m_parentItem(parent)
+    , m_id(id)
+    , m_name(name)
+    , m_canonicalAlias(canonicalAlias)
+    , m_topic(topic)
+    , m_memberCount(memberCount)
+    , m_avatarUrl(avatarUrl)
+    , m_allowGuests(allowGuests)
+    , m_worldReadable(worldReadable)
+    , m_isSpace(isSpace)
+{
+}
+
+SpaceTreeItem::~SpaceTreeItem()
+{
+    qDeleteAll(m_children);
+}
+
+SpaceTreeItem *SpaceTreeItem::child(int number)
+{
+    if (number < 0 || number >= m_children.size()) {
+        return nullptr;
+    }
+    return m_children[number];
+}
+
+int SpaceTreeItem::childCount() const
+{
+    return m_children.count();
+}
+
+bool SpaceTreeItem::insertChild(int row, SpaceTreeItem *newChild)
+{
+    if (row < 0 || row > m_children.size()) {
+        return false;
+    }
+    m_children.insert(row, newChild);
+    return true;
+}
+
+bool SpaceTreeItem::removeChild(int row)
+{
+    if (row < 0 || row >= m_children.size()) {
+        return false;
+    }
+    delete m_children.takeAt(row);
+    return true;
+}
+
+int SpaceTreeItem::row() const
+{
+    if (m_parentItem) {
+        return m_parentItem->m_children.indexOf(const_cast<SpaceTreeItem *>(this));
+    }
+    return 0;
+}
+
+SpaceTreeItem *SpaceTreeItem::parentItem()
+{
+    return m_parentItem;
+}
+
+QString SpaceTreeItem::id() const
+{
+    return m_id;
+}
+
+QString SpaceTreeItem::name() const
+{
+    return m_name;
+}
+
+QString SpaceTreeItem::canonicalAlias() const
+{
+    return m_canonicalAlias;
+}
+
+QString SpaceTreeItem::topic() const
+{
+    return m_topic;
+}
+
+int SpaceTreeItem::memberCount() const
+{
+    return m_memberCount;
+}
+
+QUrl SpaceTreeItem::avatarUrl() const
+{
+    if (m_avatarUrl.isEmpty() || m_avatarUrl.scheme() != QLatin1String("mxc")) {
+        return {};
+    }
+    auto connection = Controller::instance().activeConnection();
+    auto url = connection->makeMediaUrl(m_avatarUrl);
+    if (url.scheme() == QLatin1String("mxc")) {
+        return url;
+    }
+    return {};
+}
+
+bool SpaceTreeItem::allowGuests() const
+{
+    return m_allowGuests;
+}
+
+bool SpaceTreeItem::worldReadable() const
+{
+    return m_worldReadable;
+}
+
+bool SpaceTreeItem::isJoined() const
+{
+    auto connection = Controller::instance().activeConnection();
+    if (!connection) {
+        return false;
+    }
+    return connection->room(id(), Quotient::JoinState::Join) != nullptr;
+}
+
+bool SpaceTreeItem::isSpace() const
+{
+    return m_isSpace;
+}

src/models/spacetreeitem.h

@@ -0,0 +1,136 @@
+// 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 <Quotient/csapi/space_hierarchy.h>
+
+/**
+ * @class SpaceTreeItem
+ *
+ * This class defines an item in the space tree hierarchy model.
+ *
+ * @note This is separate from Quotient::Room and NeoChatRoom because we don't have
+ *       full room information for any room/space the user hasn't joined and we
+ *       don't want to create one for ever possible child in a space as that would
+ *       be expensive.
+ *
+ * @sa Quotient::Room, NeoChatRoom
+ */
+class SpaceTreeItem
+{
+public:
+    explicit SpaceTreeItem(SpaceTreeItem *parent = nullptr,
+                           const QString &id = {},
+                           const QString &name = {},
+                           const QString &canonicalAlias = {},
+                           const QString &topic = {},
+                           int memberCount = {},
+                           const QUrl &avatarUrl = {},
+                           bool allowGuests = {},
+                           bool worldReadable = {},
+                           bool isSpace = {});
+    ~SpaceTreeItem();
+
+    /**
+     * @brief Return the child at the given row number.
+     *
+     * Nullptr is returned if there is no child at the given row number.
+     */
+    SpaceTreeItem *child(int number);
+
+    /**
+     * @brief The number of children this item has.
+     */
+    int childCount() const;
+
+    /**
+     * @brief Insert the given child at the given row number.
+     */
+    bool insertChild(int row, SpaceTreeItem *newChild);
+
+    /**
+     * @brief Remove the child at the given row number.
+     *
+     * @return True if a child was removed, false if the given row isn't valid.
+     */
+    bool removeChild(int row);
+
+    /**
+     * @brief Return this item's parent.
+     */
+    SpaceTreeItem *parentItem();
+
+    /**
+     * @brief Return the row number for this child relative to the parent.
+     *
+     * @return The row value if the child has a parent, 0 otherwise.
+     */
+    int row() const;
+
+    /**
+     * @brief The ID of the room.
+     */
+    QString id() const;
+
+    /**
+     * @brief The name of the room, if any.
+     */
+    QString name() const;
+
+    /**
+     * @brief The canonical alias of the room, if any.
+     */
+    QString canonicalAlias() const;
+
+    /**
+     * @brief The topic of the room, if any.
+     */
+    QString topic() const;
+
+    /**
+     * @brief The number of members joined to the room.
+     */
+    int memberCount() const;
+
+    /**
+     * @brief The URL for the room's avatar, if one is set.
+     *
+     * @return A CS API QUrl.
+     */
+    QUrl avatarUrl() const;
+
+    /**
+     * @brief Whether guest users may join the room and participate in it.
+     *
+     * If they can, they will be subject to ordinary power level rules like any other users.
+     */
+    bool allowGuests() const;
+
+    /**
+     * @brief Whether the room may be viewed by guest users without joining.
+     */
+    bool worldReadable() const;
+
+    /**
+     * @brief Whether the local user is a member of the rooom.
+     */
+    bool isJoined() const;
+
+    /**
+     * @brief Whether the room is a space.
+     */
+    bool isSpace() const;
+
+private:
+    QList<SpaceTreeItem *> m_children;
+    SpaceTreeItem *m_parentItem;
+
+    QString m_id;
+    QString m_name;
+    QString m_canonicalAlias;
+    QString m_topic;
+    int m_memberCount;
+    QUrl m_avatarUrl;
+    bool m_allowGuests;
+    bool m_worldReadable;
+    bool m_isSpace;
+};