refactor(wayland): seperate cmake files for modularity

src/core/reload.hpp

@@ -0,0 +1,111 @@
+#pragma once
+
+#include <qobject.h>
+#include <qqmlcomponent.h>
+#include <qqmlintegration.h>
+#include <qqmllist.h>
+#include <qqmlparserstatus.h>
+#include <qtmetamacros.h>
+
+///! The base class of all types that can be reloaded.
+/// Reloadables will attempt to take specific state from previous config revisions if possible.
+/// Some examples are [ProxyWindowBase] and [PersistentProperties]
+///
+/// [ProxyWindowBase]: ../proxywindowbase
+/// [PersistentProperties]: ../persistentproperties
+class Reloadable: public QObject, public QQmlParserStatus {
+	Q_OBJECT;
+	Q_INTERFACES(QQmlParserStatus);
+	/// An additional identifier that can be used to try to match a reloadable object to its
+	/// previous state.
+	///
+	/// Simply keeping a stable identifier across config versions (saves) is
+	/// enough to help the reloader figure out which object in the old revision corrosponds to
+	/// this object in the current revision, and facilitate smoother reloading.
+	///
+	/// Note that identifiers are scoped, and will try to do the right thing in context.
+	/// For example if you have a `Variants` wrapping an object with an identified element inside,
+	/// a scope is created at the variant level.
+	///
+	/// ```qml
+	/// Variants {
+	///   // multiple variants of the same object tree
+	///   variants: [ { foo: 1 }, { foo: 2 } ]
+	///
+	///   // any non `Reloadable` object
+	///   QtObject {
+	///     FloatingWindow {
+	///       // this FloatingWindow will now be matched to the same one in the previous
+	///       // widget tree for its variant. "myFloatingWindow" refers to both the variant in
+	///       // `foo: 1` and `foo: 2` for each tree.
+	///       reloadableId: "myFloatingWindow"
+	///
+	///       // ...
+	///     }
+	///   }
+	/// }
+	/// ```
+	Q_PROPERTY(QString reloadableId MEMBER mReloadableId);
+	QML_ELEMENT;
+	QML_UNCREATABLE(
+	    "Reloadable is the base class of reloadable types and cannot be created on its own."
+	);
+
+public:
+	explicit Reloadable(QObject* parent = nullptr): QObject(parent) {}
+
+	// Called unconditionally in the reload phase, with nullptr if no source could be determined.
+	// If non null the old instance may or may not be of the same type, and should be checked
+	// by `onReload`.
+	virtual void onReload(QObject* oldInstance) = 0;
+
+	// TODO: onReload runs after initialization for reloadable objects created late
+	void classBegin() override {}
+	void componentComplete() override {}
+
+	// Reload objects in the parent->child graph recursively.
+	static void reloadRecursive(QObject* newObj, QObject* oldRoot);
+	// Same as above but does not reload the passed object, only its children.
+	static void reloadChildrenRecursive(QObject* newRoot, QObject* oldRoot);
+
+	QString mReloadableId;
+
+private:
+	static QObject* getChildByReloadId(QObject* parent, const QString& reloadId);
+};
+
+///! Basic type that propagates reloads to child items in order.
+/// Convenience type equivalent to setting `reloadableId` on properties in a
+/// QtObject instance.
+///
+/// Note that this does not work for visible `Item`s (all widgets).
+///
+/// ```qml
+/// ShellRoot {
+///   Variants {
+///     variants: ...
+///
+///     ReloadPropagator {
+///       // everything in here behaves the same as if it was defined
+///       // directly in `Variants` reload-wise.
+///     }
+///   }
+/// }
+class ReloadPropagator: public Reloadable {
+	Q_OBJECT;
+	Q_PROPERTY(QQmlListProperty<QObject> children READ data);
+	Q_CLASSINFO("DefaultProperty", "children");
+	QML_ELEMENT;
+
+public:
+	explicit ReloadPropagator(QObject* parent = nullptr): Reloadable(parent) {}
+
+	void onReload(QObject* oldInstance) override;
+
+	QQmlListProperty<QObject> data();
+
+private:
+	static void appendComponent(QQmlListProperty<QObject>* list, QObject* obj);
+
+	QList<QObject*> mChildren;
+};