io/fileview: add FileView

Author: outfoxxed

src/core/util.hpp

@@ -1,6 +1,8 @@
 #pragma once
 #include <type_traits>
 
+#include <qtclasshelpermacros.h>
+
 // NOLINTBEGIN
 #define DROP_EMIT(object, func)                                                                    \
 	DropEmitter(object, static_cast<void (*)(typeof(object))>([](typeof(object) o) { o->func(); }))
@@ -72,6 +74,8 @@ class DropEmitter {
 	DECLARE_MEMBER_GET(name);                                                                        \
 	DECLARE_MEMBER_SET(name, setter)
 
+#define DECLARE_MEMBER_SETONLY(class, name, setter, member, signal) DECLARE_MEMBER(cl
+
 #define DECLARE_MEMBER_FULL(class, name, setter, member, signal)                                   \
 	DECLARE_MEMBER(class, name, member, signal);                                                     \
 	DECLARE_MEMBER_GETSET(name, setter)
@@ -123,6 +127,8 @@ public:
 #define DEFINE_MEMBER_GETSET(Class, name, setter)                                                  \
 	DEFINE_MEMBER_GET(Class, name)                                                                   \
 	DEFINE_MEMBER_SET(Class, name, setter)
+
+#define MEMBER_EMIT(name) std::remove_reference_t<decltype(*this)>::M_##name::emitter(this)
 // NOLINTEND
 
 template <typename T>
@@ -154,6 +160,12 @@ class MemberMetadata {
 		} else {
 			if (MemberMetadata::get(obj) == value) return DropEmitter();
 			obj->*member = value;
+			return MemberMetadata::emitter(obj);
+		}
+	}
+
+	static Ret emitter(Class* obj) {
+		if constexpr (signal != nullptr) {
 			return DropEmitter(obj, &MemberMetadata::emitForObject);
 		}
 	}
@@ -170,3 +182,32 @@ class PseudomemberMetadata {
 	using Ref = const Type&;
 	using Ret = std::conditional_t<hasSignal, DropEmitter, void>;
 };
+
+class GuardedEmitBlocker {
+public:
+	explicit GuardedEmitBlocker(bool* var): var(var) { *this->var = true; }
+	~GuardedEmitBlocker() { *this->var = false; }
+	Q_DISABLE_COPY_MOVE(GuardedEmitBlocker);
+
+private:
+	bool* var;
+};
+
+template <auto signal>
+class GuardedEmitter {
+	using Traits = MemberPointerTraits<decltype(signal)>;
+	using Class = Traits::Class;
+
+	bool blocked = false;
+
+public:
+	GuardedEmitter() = default;
+	~GuardedEmitter() = default;
+	Q_DISABLE_COPY_MOVE(GuardedEmitter);
+
+	void call(Class* obj) {
+		if (!this->blocked) (obj->*signal)();
+	}
+
+	GuardedEmitBlocker block() { return GuardedEmitBlocker(&this->blocked); }
+};

src/io/CMakeLists.txt

@@ -1,6 +1,7 @@
 qt_add_library(quickshell-io STATIC
 	datastream.cpp
 	process.cpp
+	fileview.cpp
 )
 
 add_library(quickshell-io-init OBJECT init.cpp)
@@ -9,7 +10,12 @@ if (SOCKETS)
 	target_sources(quickshell-io PRIVATE socket.cpp)
 endif()
 
-qt_add_qml_module(quickshell-io URI Quickshell.Io VERSION 0.1)
+qt_add_qml_module(quickshell-io
+	URI Quickshell.Io
+	VERSION 0.1
+	QML_FILES
+		FileView.qml
+)
 
 target_link_libraries(quickshell-io PRIVATE ${QT_DEPS})
 target_link_libraries(quickshell-io-init PRIVATE ${QT_DEPS})

src/io/FileView.qml

@@ -0,0 +1,48 @@
+import Quickshell.Io
+
+FileViewInternal {
+	property bool preload: this.__preload;
+	property bool blockLoading: this.__blockLoading;
+	property bool blockAllReads: this.__blockAllReads;
+	property string path: this.__path;
+
+	onPreloadChanged: this.__preload = preload;
+	onBlockLoadingChanged: this.__blockLoading = this.blockLoading;
+	onBlockAllReadsChanged: this.__blockAllReads = this.blockAllReads;
+
+	// Unfortunately path can't be kept as an empty string until the file loads
+	// without using QQmlPropertyValueInterceptor which is private. If we lean fully
+	// into using private code in the future, there will be no reason not to do it here.
+
+	onPathChanged: {
+		if (!this.preload) this.__preload = false;
+		this.__path = this.path;
+		if (this.preload) this.__preload = true;
+	}
+
+	// The C++ side can't force bindings to be resolved in a specific order so
+	// its done here. Functions are used to avoid the eager loading aspect of properties.
+
+	// Preload is set as it is below to avoid starting an async read from a preload
+	// if the user wants an initial blocking read.
+
+	function text(): string {
+		if (!this.preload) this.__preload = false;
+		this.__blockLoading = this.blockLoading;
+		this.__blockAllReads = this.blockAllReads;
+		this.__path = this.path;
+		const text = this.__text;
+		if (this.preload) this.__preload = true;
+		return text;
+	}
+
+	function data(): string {
+		if (!this.preload) this.__preload = false;
+		this.__blockLoading = this.blockLoading;
+		this.__blockAllReads = this.blockAllReads;
+		this.__path = this.path;
+		const data = this.__data;
+		if (this.preload) this.__preload = true;
+		return data;
+	}
+}