core/window: add startSystemMove, startSystemResize, maximize, and fullscreen to FloatingWindow

Author: bbedward

src/window/floatingwindow.cpp

@@ -5,6 +5,7 @@
 #include <qqmllist.h>
 #include <qtmetamacros.h>
 #include <qtypes.h>
+#include <qwindow.h>
 
 #include "proxywindow.hpp"
 #include "windowinterface.hpp"
@@ -55,6 +56,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, &ProxyWindowBase::windowVisibilityChanged, this, &FloatingWindowInterface::onVisibilityChanged);
 	// clang-format on
 }
 
@@ -66,3 +68,52 @@ void FloatingWindowInterface::onReload(QObject* oldInstance) {
 }
 
 ProxyWindowBase* FloatingWindowInterface::proxyWindow() const { return this->window; }
+
+void FloatingWindowInterface::onVisibilityChanged() {
+	auto* qw = this->window->backingWindow();
+	auto visibility = qw ? qw->visibility() : QWindow::Hidden;
+
+	auto maximized = visibility == QWindow::Maximized;
+	auto fullscreen = visibility == QWindow::FullScreen;
+
+	if (maximized != this->mMaximized) {
+		this->mMaximized = maximized;
+		emit this->maximizedChanged();
+	}
+
+	if (fullscreen != this->mFullscreen) {
+		this->mFullscreen = fullscreen;
+		emit this->fullscreenChanged();
+	}
+}
+
+bool FloatingWindowInterface::maximized() const { return this->mMaximized; }
+bool FloatingWindowInterface::fullscreen() const { return this->mFullscreen; }
+
+bool FloatingWindowInterface::startSystemMove() const {
+	auto* qw = this->window->backingWindow();
+	if (!qw) return false;
+	return qw->startSystemMove();
+}
+
+bool FloatingWindowInterface::startSystemResize(Qt::Edges edges) const {
+	auto* qw = this->window->backingWindow();
+	if (!qw) return false;
+	return qw->startSystemResize(edges);
+}
+
+void FloatingWindowInterface::showNormal() const {
+	if (auto* qw = this->window->backingWindow()) qw->showNormal();
+}
+
+void FloatingWindowInterface::showMaximized() const {
+	if (auto* qw = this->window->backingWindow()) qw->showMaximized();
+}
+
+void FloatingWindowInterface::showMinimized() const {
+	if (auto* qw = this->window->backingWindow()) qw->showMinimized();
+}
+
+void FloatingWindowInterface::showFullScreen() const {
+	if (auto* qw = this->window->backingWindow()) qw->showFullScreen();
+}

src/window/floatingwindow.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <qnamespace.h>
 #include <qobject.h>
 #include <qproperty.h>
 #include <qsize.h>
@@ -68,6 +69,10 @@ 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);
+	/// Whether the window is currently maximized.
+	Q_PROPERTY(bool maximized READ maximized NOTIFY maximizedChanged);
+	/// Whether the window is currently fullscreen.
+	Q_PROPERTY(bool fullscreen READ fullscreen NOTIFY fullscreenChanged);
 	// clang-format on
 	QML_NAMED_ELEMENT(FloatingWindow);
 
@@ -78,15 +83,39 @@ class FloatingWindowInterface: public WindowInterface {
 
 	[[nodiscard]] ProxyWindowBase* proxyWindow() const override;
 
-	QBindable<QSize> bindableMinimumSize() { return &this->window->bMinimumSize; }
-	QBindable<QSize> bindableMaximumSize() { return &this->window->bMaximumSize; }
-	QBindable<QString> bindableTitle() { return &this->window->bTitle; }
+	[[nodiscard]] QBindable<QSize> bindableMinimumSize() { return &this->window->bMinimumSize; }
+	[[nodiscard]] QBindable<QSize> bindableMaximumSize() { return &this->window->bMaximumSize; }
+	[[nodiscard]] QBindable<QString> bindableTitle() { return &this->window->bTitle; }
+
+	[[nodiscard]] bool maximized() const;
+	[[nodiscard]] bool fullscreen() const;
+
+	/// Start a system move operation. Must be called during a pointer press/drag.
+	Q_INVOKABLE [[nodiscard]] bool startSystemMove() const;
+	/// Start a system resize operation. Must be called during a pointer press/drag.
+	Q_INVOKABLE [[nodiscard]] bool startSystemResize(Qt::Edges edges) const;
+
+	/// Show the window in normal (restored) state.
+	Q_INVOKABLE void showNormal() const;
+	/// Show the window maximized.
+	Q_INVOKABLE void showMaximized() const;
+	/// Show the window minimized.
+	Q_INVOKABLE void showMinimized() const;
+	/// Show the window fullscreen.
+	Q_INVOKABLE void showFullScreen() const;
 
 signals:
 	void minimumSizeChanged();
 	void maximumSizeChanged();
 	void titleChanged();
+	void maximizedChanged();
+	void fullscreenChanged();
+
+private slots:
+	void onVisibilityChanged();
 
 private:
 	ProxyFloatingWindow* window;
+	bool mMaximized = false;
+	bool mFullscreen = false;
 };

src/window/proxywindow.cpp

@@ -248,6 +248,7 @@ void ProxyWindowBase::onVisibleChanged() {
 	}
 
 	emit this->visibleChanged();
+	emit this->windowVisibilityChanged();
 }
 
 bool ProxyWindowBase::deleteOnInvisible() const { return false; }

src/window/proxywindow.hpp

@@ -147,6 +147,7 @@ class ProxyWindowBase: public Reloadable {
 	void windowDestroyed();
 	void visibleChanged();
 	void backerVisibilityChanged();
+	void windowVisibilityChanged();
 	void xChanged();
 	void yChanged();
 	void implicitWidthChanged();