core/window: add fullscreen and maximize

Author: bbedward

src/window/proxywindow.cpp

@@ -248,6 +248,7 @@ void ProxyWindowBase::onVisibleChanged() {
 	}
 
 	emit this->visibleChanged();
+	emit this->windowVisibilityChanged();
 }
 
 bool ProxyWindowBase::deleteOnInvisible() const { return false; }
@@ -545,6 +546,12 @@ ProxyWindowBase::mapFromItem(QQuickItem* item, qreal x, qreal y, qreal width, qr
 }
 
 ProxyWindowAttached::ProxyWindowAttached(QQuickItem* parent): QsWindowAttached(parent) {
+	this->bMaximized.setBinding([this]() { return this->bVisibility.value() == QWindow::Maximized; });
+
+	this->bFullscreen.setBinding([this]() {
+		return this->bVisibility.value() == QWindow::FullScreen;
+	});
+
 	this->updateWindow();
 }
 
@@ -567,12 +574,30 @@ void ProxyWindowAttached::updateWindow() {
 
 void ProxyWindowAttached::setWindow(ProxyWindowBase* window) {
 	if (window == this->mWindow) return;
+
+	if (this->mWindow) {
+		QObject::disconnect(this->mWindow, nullptr, this, nullptr);
+	}
+
 	this->mWindow = window;
+
+	if (this->mWindow) {
+		// clang-format off
+		QObject::connect(this->mWindow, &ProxyWindowBase::windowVisibilityChanged, this, &ProxyWindowAttached::onVisibilityChanged);
+		// clang-format on
+		this->onVisibilityChanged();
+	}
+
 	auto* parentInterface = window ? qobject_cast<WindowInterface*>(window->parent()) : nullptr;
 	this->mWindowInterface = parentInterface ? static_cast<QObject*>(parentInterface) : window;
 	emit this->windowChanged();
 }
 
+void ProxyWindowAttached::onVisibilityChanged() {
+	auto* qw = this->mWindow ? this->mWindow->backingWindow() : nullptr;
+	this->bVisibility = qw ? qw->visibility() : QWindow::Hidden;
+}
+
 bool ProxiedWindow::event(QEvent* event) {
 	if (event->type() == QEvent::DevicePixelRatioChange) {
 		emit this->devicePixelRatioChanged();

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();
@@ -221,13 +222,27 @@ class ProxyWindowAttached: public QsWindowAttached {
 	[[nodiscard]] ProxyWindowBase* proxyWindow() const override;
 	[[nodiscard]] QQuickItem* contentItem() const override;
 
+	[[nodiscard]] bool maximized() const override { return this->bMaximized; }
+	[[nodiscard]] bool fullscreen() const override { return this->bFullscreen; }
+	[[nodiscard]] QBindable<bool> bindableMaximized() override { return &this->bMaximized; }
+	[[nodiscard]] QBindable<bool> bindableFullscreen() override { return &this->bFullscreen; }
+
 protected:
 	void updateWindow() override;
 
+private slots:
+	void onVisibilityChanged();
+
 private:
 	ProxyWindowBase* mWindow = nullptr;
 	QObject* mWindowInterface = nullptr;
 
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY(ProxyWindowAttached, QWindow::Visibility, bVisibility);
+	Q_OBJECT_BINDABLE_PROPERTY(ProxyWindowAttached, bool, bMaximized, &ProxyWindowAttached::maximizedChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(ProxyWindowAttached, bool, bFullscreen, &ProxyWindowAttached::fullscreenChanged);
+	// clang-format on
+
 	void setWindow(ProxyWindowBase* window);
 };
 

src/window/windowinterface.cpp

@@ -9,6 +9,7 @@
 #include <qquickitem.h>
 #include <qrect.h>
 #include <qtypes.h>
+#include <qwindow.h>
 
 #include "../core/qmlscreen.hpp"
 #include "../core/region.hpp"
@@ -122,6 +123,46 @@ bool QsWindowAttached::startSystemResize(Qt::Edges edges) const {
 	return qw->startSystemResize(edges);
 }
 
+void QsWindowAttached::showNormal() const {
+	auto* pw = this->proxyWindow();
+	if (!pw) {
+		qCritical() << "Cannot call showNormal before item is a member of a window.";
+		return;
+	}
+
+	if (auto* qw = pw->backingWindow()) qw->showNormal();
+}
+
+void QsWindowAttached::showMaximized() const {
+	auto* pw = this->proxyWindow();
+	if (!pw) {
+		qCritical() << "Cannot call showMaximized before item is a member of a window.";
+		return;
+	}
+
+	if (auto* qw = pw->backingWindow()) qw->showMaximized();
+}
+
+void QsWindowAttached::showMinimized() const {
+	auto* pw = this->proxyWindow();
+	if (!pw) {
+		qCritical() << "Cannot call showMinimized before item is a member of a window.";
+		return;
+	}
+
+	if (auto* qw = pw->backingWindow()) qw->showMinimized();
+}
+
+void QsWindowAttached::showFullScreen() const {
+	auto* pw = this->proxyWindow();
+	if (!pw) {
+		qCritical() << "Cannot call showFullScreen before item is a member of a window.";
+		return;
+	}
+
+	if (auto* qw = pw->backingWindow()) qw->showFullScreen();
+}
+
 // clang-format off
 QQuickItem* WindowInterface::contentItem() const { return this->proxyWindow()->contentItem(); }
 

src/window/windowinterface.hpp

@@ -2,6 +2,7 @@
 
 #include <qcolor.h>
 #include <qobject.h>
+#include <qproperty.h>
 #include <qqmlintegration.h>
 #include <qqmllist.h>
 #include <qquickitem.h>
@@ -267,13 +268,22 @@ class QsWindowAttached: public QObject {
 	Q_OBJECT;
 	Q_PROPERTY(QObject* window READ window NOTIFY windowChanged);
 	Q_PROPERTY(QQuickItem* contentItem READ contentItem NOTIFY windowChanged);
+	/// Whether the window is currently maximized.
+	Q_PROPERTY(bool maximized READ maximized NOTIFY maximizedChanged BINDABLE bindableMaximized);
+	/// Whether the window is currently fullscreen.
+	Q_PROPERTY(bool fullscreen READ fullscreen NOTIFY fullscreenChanged BINDABLE bindableFullscreen);
 	QML_ANONYMOUS;
 
 public:
 	[[nodiscard]] virtual QObject* window() const = 0;
 	[[nodiscard]] virtual ProxyWindowBase* proxyWindow() const = 0;
 	[[nodiscard]] virtual QQuickItem* contentItem() const = 0;
 
+	[[nodiscard]] virtual bool maximized() const = 0;
+	[[nodiscard]] virtual bool fullscreen() const = 0;
+	[[nodiscard]] virtual QBindable<bool> bindableMaximized() = 0;
+	[[nodiscard]] virtual QBindable<bool> bindableFullscreen() = 0;
+
 	Q_INVOKABLE [[nodiscard]] QPointF itemPosition(QQuickItem* item) const;
 	Q_INVOKABLE [[nodiscard]] QRectF itemRect(QQuickItem* item) const;
 	Q_INVOKABLE [[nodiscard]] QPointF mapFromItem(QQuickItem* item, QPointF point) const;
@@ -288,8 +298,19 @@ class QsWindowAttached: public QObject {
 	/// 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 windowChanged();
+	void maximizedChanged();
+	void fullscreenChanged();
 
 protected slots:
 	virtual void updateWindow() = 0;