core/scriptmodel: add expression model for unique lists

Author: outfoxxed

.clang-tidy

@@ -18,6 +18,7 @@ Checks: >
   -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
   -cppcoreguidelines-avoid-do-while,
   -cppcoreguidelines-pro-type-reinterpret-cast,
+  -cppcoreguidelines-pro-type-vararg,
   google-global-names-in-headers,
   google-readability-casting,
   google-runtime-int,

src/core/CMakeLists.txt

@@ -36,6 +36,7 @@ qt_add_library(quickshell-core STATIC
 	instanceinfo.cpp
 	common.cpp
 	iconprovider.cpp
+	scriptmodel.cpp
 )
 
 qt_add_qml_module(quickshell-core

src/core/model.cpp

@@ -2,6 +2,7 @@
 
 #include <qabstractitemmodel.h>
 #include <qhash.h>
+#include <qnamespace.h>
 #include <qobject.h>
 #include <qqmllist.h>
 #include <qtmetamacros.h>
@@ -14,11 +15,13 @@ qint32 UntypedObjectModel::rowCount(const QModelIndex& parent) const {
 }
 
 QVariant UntypedObjectModel::data(const QModelIndex& index, qint32 role) const {
-	if (role != 0) return QVariant();
+	if (role != Qt::UserRole) return QVariant();
 	return QVariant::fromValue(this->valuesList.at(index.row()));
 }
 
-QHash<int, QByteArray> UntypedObjectModel::roleNames() const { return {{0, "modelData"}}; }
+QHash<int, QByteArray> UntypedObjectModel::roleNames() const {
+	return {{Qt::UserRole, "modelData"}};
+}
 
 QQmlListProperty<QObject> UntypedObjectModel::values() {
 	return QQmlListProperty<QObject>(

src/core/scriptmodel.cpp

@@ -0,0 +1,128 @@
+#include "scriptmodel.hpp"
+#include <algorithm>
+#include <iterator>
+
+#include <qabstractitemmodel.h>
+#include <qcontainerfwd.h>
+#include <qlist.h>
+#include <qnamespace.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qvariant.h>
+
+void ScriptModel::updateValuesUnique(const QVariantList& newValues) {
+	this->mValues.reserve(newValues.size());
+
+	auto iter = this->mValues.begin();
+	auto newIter = newValues.begin();
+
+	while (true) {
+		if (newIter == newValues.end()) {
+			if (iter == this->mValues.end()) break;
+
+			auto startIndex = static_cast<qint32>(newValues.length());
+			auto endIndex = static_cast<qint32>(this->mValues.length() - 1);
+
+			this->beginRemoveRows(QModelIndex(), startIndex, endIndex);
+			this->mValues.erase(iter, this->mValues.end());
+			this->endRemoveRows();
+
+			break;
+		} else if (iter == this->mValues.end()) {
+			// Prior branch ensures length is at least 1.
+			auto startIndex = static_cast<qint32>(this->mValues.length());
+			auto endIndex = static_cast<qint32>(newValues.length() - 1);
+
+			this->beginInsertRows(QModelIndex(), startIndex, endIndex);
+			this->mValues.append(newValues.sliced(startIndex));
+			this->endInsertRows();
+
+			break;
+		} else if (*newIter != *iter) {
+			auto oldIter = std::find(iter, this->mValues.end(), *newIter);
+
+			if (oldIter != this->mValues.end()) {
+				if (std::find(newIter, newValues.end(), *iter) == newValues.end()) {
+					// Remove any entries we would otherwise move around that aren't in the new list.
+					auto startIter = iter;
+
+					do {
+						++iter;
+					} while (iter != this->mValues.end()
+					         && std::find(newIter, newValues.end(), *iter) == newValues.end());
+
+					auto index = static_cast<qint32>(std::distance(this->mValues.begin(), iter));
+					auto startIndex = static_cast<qint32>(std::distance(this->mValues.begin(), startIter));
+
+					this->beginRemoveRows(QModelIndex(), startIndex, index - 1);
+					iter = this->mValues.erase(startIter, iter);
+					this->endRemoveRows();
+				} else {
+					// Advance iters to capture a whole move sequence as a single operation if possible.
+					auto oldStartIter = oldIter;
+					do {
+						++oldIter;
+						++newIter;
+					} while (oldIter != this->mValues.end() && newIter != newValues.end()
+					         && *oldIter == *newIter);
+
+					auto index = static_cast<qint32>(std::distance(this->mValues.begin(), iter));
+					auto oldStartIndex =
+					    static_cast<qint32>(std::distance(this->mValues.begin(), oldStartIter));
+					auto oldIndex = static_cast<qint32>(std::distance(this->mValues.begin(), oldIter));
+					auto len = oldIndex - oldStartIndex;
+
+					this->beginMoveRows(QModelIndex(), oldStartIndex, oldIndex - 1, QModelIndex(), index);
+
+					// While it is possible to optimize this further, it is currently not worth the time.
+					for (auto i = 0; i != len; i++) {
+						this->mValues.move(oldStartIndex + i, index + i);
+					}
+
+					iter = this->mValues.begin() + (index + len);
+					this->endMoveRows();
+				}
+			} else {
+				auto startNewIter = newIter;
+
+				do {
+					newIter++;
+				} while (newIter != newValues.end()
+				         && std::find(iter, this->mValues.end(), *newIter) == this->mValues.end());
+
+				auto index = static_cast<qint32>(std::distance(this->mValues.begin(), iter));
+				auto newIndex = static_cast<qint32>(std::distance(newValues.begin(), newIter));
+				auto startNewIndex = static_cast<qint32>(std::distance(newValues.begin(), startNewIter));
+				auto len = newIndex - startNewIndex;
+
+				this->beginInsertRows(QModelIndex(), index, index + len - 1);
+				this->mValues.resizeForOverwrite(this->mValues.length() + len);
+				iter = this->mValues.begin() + index; // invalidated
+				std::move_backward(iter, this->mValues.end() - len, this->mValues.end());
+				iter = std::copy(startNewIter, newIter, iter);
+				this->endInsertRows();
+			}
+		} else {
+			++iter;
+			++newIter;
+		}
+	}
+}
+
+void ScriptModel::setValues(const QVariantList& newValues) {
+	if (newValues == this->mValues) return;
+	this->updateValuesUnique(newValues);
+	emit this->valuesChanged();
+}
+
+qint32 ScriptModel::rowCount(const QModelIndex& parent) const {
+	if (parent != QModelIndex()) return 0;
+	return static_cast<qint32>(this->mValues.length());
+}
+
+QVariant ScriptModel::data(const QModelIndex& index, qint32 role) const {
+	if (role != Qt::UserRole) return QVariant();
+	return this->mValues.at(index.row());
+}
+
+QHash<int, QByteArray> ScriptModel::roleNames() const { return {{Qt::UserRole, "modelData"}}; }

src/core/scriptmodel.hpp

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <qabstractitemmodel.h>
+#include <qcontainerfwd.h>
+#include <qproperty.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+
+///! QML model reflecting a javascript expression
+/// ScriptModel is a QML [Data Model] that generates model operations based on changes
+/// to a javascript expression attached to @@values.
+///
+/// ### When should I use this
+/// ScriptModel should be used when you would otherwise use a javascript expression as a model,
+/// [QAbstractItemModel] is accepted, and the data is likely to change over the lifetime of the program.
+///
+/// When directly using a javascript expression as a model, types like @@QtQuick.Repeater or @@QtQuick.ListView
+/// will destroy all created delegates, and re-create the entire list. In the case of @@QtQuick.ListView this
+/// will also prevent animations from working. If you wrap your expression with ScriptModel, only new items
+/// will be created, and ListView animations will work as expected.
+///
+/// ### Example
+/// ```qml
+/// // Will cause all delegates to be re-created every time filterText changes.
+/// @@QtQuick.Repeater {
+///   model: myList.filter(entry => entry.name.startsWith(filterText))
+///   delegate: // ...
+/// }
+///
+/// // Will add and remove delegates only when required.
+/// @@QtQuick.Repeater {
+///   model: ScriptModel {
+///     values: myList.filter(entry => entry.name.startsWith(filterText))
+///   }
+///
+///   delegate: // ...
+/// }
+/// ```
+class ScriptModel: public QAbstractListModel {
+	Q_OBJECT;
+	/// The list of values to reflect in the model.
+	/// > [!WARNING] ScriptModel currently only works with lists of *unique* values.
+	/// > There must not be any duplicates in the given list, or behavior of the model is undefined.
+	///
+	/// > [!TIP] @@ObjectModel$s supplied by Quickshell types will only contain unique values,
+	/// > and can be used like so:
+	/// >
+	/// > ```qml
+	/// > ScriptModel {
+	/// >   values: DesktopEntries.applications.values.filter(...)
+	/// > }
+	/// > ```
+	/// >
+	/// > Note that we are using @@DesktopEntries.values because it will cause @@ScriptModel.values
+	/// > to receive an update on change.
+	Q_PROPERTY(QVariantList values READ values WRITE setValues NOTIFY valuesChanged);
+	QML_ELEMENT;
+
+public:
+	[[nodiscard]] const QVariantList& values() const { return this->mValues; }
+	void setValues(const QVariantList& newValues);
+
+	[[nodiscard]] qint32 rowCount(const QModelIndex& parent) const override;
+	[[nodiscard]] QVariant data(const QModelIndex& index, qint32 role) const override;
+	[[nodiscard]] QHash<int, QByteArray> roleNames() const override;
+
+signals:
+	void valuesChanged();
+
+private:
+	QVariantList mValues;
+
+	void updateValuesUnique(const QVariantList& newValues);
+};

src/core/test/CMakeLists.txt

@@ -6,3 +6,4 @@ endfunction()
 
 qs_test(transformwatcher transformwatcher.cpp)
 qs_test(ringbuffer ringbuf.cpp)
+qs_test(scriptmodel scriptmodel.cpp)