core/window: add parentWindow property to FloatingWindow

Author: bbedward

src/window/floatingwindow.cpp

@@ -2,7 +2,7 @@
 
 #include <qobject.h>
 #include <qqmlengine.h>
-#include <qqmllist.h>
+#include <qqmlinfo.h>
 #include <qtmetamacros.h>
 #include <qtypes.h>
 
@@ -15,6 +15,9 @@ void ProxyFloatingWindow::connectWindow() {
 	this->window->setTitle(this->bTitle);
 	this->window->setMinimumSize(this->bMinimumSize);
 	this->window->setMaximumSize(this->bMaximumSize);
+
+	// Apply transient parent now that our backing window exists
+	this->updateTransientParent();
 }
 
 void ProxyFloatingWindow::trySetWidth(qint32 implicitWidth) {
@@ -44,6 +47,65 @@ void ProxyFloatingWindow::onMaximumSizeChanged() {
 	emit this->maximumSizeChanged();
 }
 
+QObject* ProxyFloatingWindow::parentWindow() const { return this->mParentWindow; }
+
+void ProxyFloatingWindow::setParentWindow(QObject* window) {
+	if (window == this->mParentWindow) return;
+
+	if (this->mParentWindow) {
+		QObject::disconnect(this->mParentWindow, nullptr, this, nullptr);
+		QObject::disconnect(this->mParentProxyWindow, nullptr, this, nullptr);
+	}
+
+	if (window) {
+		if (auto* proxy = qobject_cast<ProxyWindowBase*>(window)) {
+			this->mParentProxyWindow = proxy;
+		} else if (auto* interface = qobject_cast<WindowInterface*>(window)) {
+			this->mParentProxyWindow = interface->proxyWindow();
+		} else {
+			qmlWarning(this) << "parentWindow must be a quickshell window.";
+			return;
+		}
+
+		this->mParentWindow = window;
+		QObject::connect(
+		    this->mParentWindow,
+		    &QObject::destroyed,
+		    this,
+		    &ProxyFloatingWindow::onParentDestroyed
+		);
+
+		QObject::connect(
+		    this->mParentProxyWindow,
+		    &ProxyWindowBase::backingWindowChanged,
+		    this,
+		    &ProxyFloatingWindow::updateTransientParent
+		);
+	} else {
+		this->mParentWindow = nullptr;
+		this->mParentProxyWindow = nullptr;
+	}
+
+	this->updateTransientParent();
+	emit this->parentWindowChanged();
+}
+
+void ProxyFloatingWindow::onParentDestroyed() {
+	this->mParentWindow = nullptr;
+	this->mParentProxyWindow = nullptr;
+	this->updateTransientParent();
+	emit this->parentWindowChanged();
+}
+
+void ProxyFloatingWindow::updateTransientParent() {
+	if (!this->window) return;
+
+	auto* parentBacking =
+	    this->mParentProxyWindow ? this->mParentProxyWindow->backingWindow() : nullptr;
+
+	this->window->setTransientParent(parentBacking);
+}
+
 // FloatingWindowInterface
 
 FloatingWindowInterface::FloatingWindowInterface(QObject* parent)
@@ -55,6 +117,7 @@ FloatingWindowInterface::FloatingWindowInterface(QObject* parent)
 	QObject::connect(this->window, &ProxyFloatingWindow::titleChanged, this, &FloatingWindowInterface::titleChanged);
 	QObject::connect(this->window, &ProxyFloatingWindow::minimumSizeChanged, this, &FloatingWindowInterface::minimumSizeChanged);
 	QObject::connect(this->window, &ProxyFloatingWindow::maximumSizeChanged, this, &FloatingWindowInterface::maximumSizeChanged);
+	QObject::connect(this->window, &ProxyFloatingWindow::parentWindowChanged, this, &FloatingWindowInterface::parentWindowChanged);
 	// clang-format on
 }
 
@@ -66,3 +129,9 @@ void FloatingWindowInterface::onReload(QObject* oldInstance) {
 }
 
 ProxyWindowBase* FloatingWindowInterface::proxyWindow() const { return this->window; }
+
+QObject* FloatingWindowInterface::parentWindow() const { return this->window->parentWindow(); }
+
+void FloatingWindowInterface::setParentWindow(QObject* window) {
+	this->window->setParentWindow(window);
+}

src/window/floatingwindow.hpp

@@ -19,6 +19,9 @@ class ProxyFloatingWindow: public ProxyWindowBase {
 
 	void connectWindow() override;
 
+	[[nodiscard]] QObject* parentWindow() const;
+	void setParentWindow(QObject* window);
+
 	// Setting geometry while the window is visible makes the content item shrink but not the window
 	// which is awful so we disable it for floating windows.
 	void trySetWidth(qint32 implicitWidth) override;
@@ -28,11 +31,19 @@ class ProxyFloatingWindow: public ProxyWindowBase {
 	void minimumSizeChanged();
 	void maximumSizeChanged();
 	void titleChanged();
+	void parentWindowChanged();
+
+private slots:
+	void onParentDestroyed();
 
 private:
 	void onMinimumSizeChanged();
 	void onMaximumSizeChanged();
 	void onTitleChanged();
+	void updateTransientParent();
+
+	QObject* mParentWindow = nullptr;
+	ProxyWindowBase* mParentProxyWindow = nullptr;
 
 public:
 	Q_OBJECT_BINDABLE_PROPERTY(
@@ -68,6 +79,9 @@ class FloatingWindowInterface: public WindowInterface {
 	Q_PROPERTY(QSize minimumSize READ default WRITE default NOTIFY minimumSizeChanged BINDABLE bindableMinimumSize);
 	/// Maximum window size given to the window system.
 	Q_PROPERTY(QSize maximumSize READ default WRITE default NOTIFY maximumSizeChanged BINDABLE bindableMaximumSize);
+	/// The parent window of this window. Setting this makes the window a child of the parent,
+	/// which affects window stacking behavior.
+	Q_PROPERTY(QObject* parentWindow READ parentWindow WRITE setParentWindow NOTIFY parentWindowChanged);
 	// clang-format on
 	QML_NAMED_ELEMENT(FloatingWindow);
 
@@ -82,10 +96,14 @@ class FloatingWindowInterface: public WindowInterface {
 	QBindable<QSize> bindableMaximumSize() { return &this->window->bMaximumSize; }
 	QBindable<QString> bindableTitle() { return &this->window->bTitle; }
 
+	[[nodiscard]] QObject* parentWindow() const;
+	void setParentWindow(QObject* window);
+
 signals:
 	void minimumSizeChanged();
 	void maximumSizeChanged();
 	void titleChanged();
+	void parentWindowChanged();
 
 private:
 	ProxyFloatingWindow* window;

src/window/proxywindow.cpp

@@ -81,6 +81,7 @@ void ProxyWindowBase::onReload(QObject* oldInstance) {
 
 	this->reloadComplete = true;
 
+	emit this->backingWindowChanged();
 	emit this->windowConnected();
 	this->postCompleteWindow();
 
@@ -148,11 +149,16 @@ void ProxyWindowBase::createWindow() {
 	this->ensureQWindow();
 	this->connectWindow();
 	this->completeWindow();
+	emit this->backingWindowChanged();
 	emit this->windowConnected();
 }
 
 void ProxyWindowBase::deleteWindow(bool keepItemOwnership) {
-	if (this->window != nullptr) emit this->windowDestroyed();
+	if (this->window != nullptr) {
+		emit this->windowDestroyed();
+		emit this->backingWindowChanged();
+	}
+
 	if (auto* window = this->disownWindow(keepItemOwnership)) window->deleteLater();
 }
 

src/window/proxywindow.hpp

@@ -145,6 +145,7 @@ class ProxyWindowBase: public Reloadable {
 	void resourcesLost();
 	void windowConnected();
 	void windowDestroyed();
+	void backingWindowChanged();
 	void visibleChanged();
 	void backerVisibilityChanged();
 	void xChanged();