core/window: add minimize, use windowStates

Author: bbedward

src/window/floatingwindow.cpp

@@ -6,7 +6,6 @@
 #include <qqmllist.h>
 #include <qtmetamacros.h>
 #include <qtypes.h>
-#include <qwindow.h>
 
 #include "proxywindow.hpp"
 #include "windowinterface.hpp"
@@ -72,10 +71,16 @@ ProxyWindowBase* FloatingWindowInterface::proxyWindow() const { return this->win
 
 void FloatingWindowInterface::onVisibilityChanged() {
 	auto* qw = this->window->backingWindow();
-	auto visibility = qw ? qw->visibility() : QWindow::Hidden;
+	auto states = qw ? qw->windowStates() : Qt::WindowStates();
 
-	auto maximized = visibility == QWindow::Maximized;
-	auto fullscreen = visibility == QWindow::FullScreen;
+	auto minimized = states.testFlag(Qt::WindowMinimized);
+	auto maximized = states.testFlag(Qt::WindowMaximized);
+	auto fullscreen = states.testFlag(Qt::WindowFullScreen);
+
+	if (minimized != this->mMinimized) {
+		this->mMinimized = minimized;
+		emit this->minimizedChanged();
+	}
 
 	if (maximized != this->mMaximized) {
 		this->mMaximized = maximized;
@@ -88,8 +93,23 @@ void FloatingWindowInterface::onVisibilityChanged() {
 	}
 }
 
-bool FloatingWindowInterface::maximized() const { return this->mMaximized; }
-bool FloatingWindowInterface::fullscreen() const { return this->mFullscreen; }
+bool FloatingWindowInterface::isMinimized() const {
+	auto* qw = this->window->backingWindow();
+	if (!qw) return this->mMinimized;
+	return qw->windowStates().testFlag(Qt::WindowMinimized);
+}
+
+bool FloatingWindowInterface::isMaximized() const {
+	auto* qw = this->window->backingWindow();
+	if (!qw) return this->mMaximized;
+	return qw->windowStates().testFlag(Qt::WindowMaximized);
+}
+
+bool FloatingWindowInterface::isFullscreen() const {
+	auto* qw = this->window->backingWindow();
+	if (!qw) return this->mFullscreen;
+	return qw->windowStates().testFlag(Qt::WindowFullScreen);
+}
 
 bool FloatingWindowInterface::startSystemMove() const {
 	auto* qw = this->window->backingWindow();
@@ -107,14 +127,14 @@ void FloatingWindowInterface::showNormal() const {
 	if (auto* qw = this->window->backingWindow()) qw->showNormal();
 }
 
-void FloatingWindowInterface::showMaximized() const {
+void FloatingWindowInterface::maximize() const {
 	if (auto* qw = this->window->backingWindow()) qw->showMaximized();
 }
 
-void FloatingWindowInterface::showMinimized() const {
+void FloatingWindowInterface::minimize() const {
 	if (auto* qw = this->window->backingWindow()) qw->showMinimized();
 }
 
-void FloatingWindowInterface::showFullScreen() const {
+void FloatingWindowInterface::fullscreen() const {
 	if (auto* qw = this->window->backingWindow()) qw->showFullScreen();
 }

src/window/floatingwindow.hpp

@@ -69,10 +69,12 @@ 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 minimized.
+	Q_PROPERTY(bool minimized READ isMinimized NOTIFY minimizedChanged);
 	/// Whether the window is currently maximized.
-	Q_PROPERTY(bool maximized READ maximized NOTIFY maximizedChanged);
+	Q_PROPERTY(bool maximized READ isMaximized NOTIFY maximizedChanged);
 	/// Whether the window is currently fullscreen.
-	Q_PROPERTY(bool fullscreen READ fullscreen NOTIFY fullscreenChanged);
+	Q_PROPERTY(bool fullscreen READ isFullscreen NOTIFY fullscreenChanged);
 	// clang-format on
 	QML_NAMED_ELEMENT(FloatingWindow);
 
@@ -87,8 +89,9 @@ class FloatingWindowInterface: public WindowInterface {
 	[[nodiscard]] QBindable<QSize> bindableMaximumSize() { return &this->window->bMaximumSize; }
 	[[nodiscard]] QBindable<QString> bindableTitle() { return &this->window->bTitle; }
 
-	[[nodiscard]] bool maximized() const;
-	[[nodiscard]] bool fullscreen() const;
+	[[nodiscard]] bool isMinimized() const;
+	[[nodiscard]] bool isMaximized() const;
+	[[nodiscard]] bool isFullscreen() const;
 
 	/// Start a system move operation. Must be called during a pointer press/drag.
 	Q_INVOKABLE [[nodiscard]] bool startSystemMove() const;
@@ -97,17 +100,18 @@ class FloatingWindowInterface: public WindowInterface {
 
 	/// 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;
+	/// Maximize the window.
+	Q_INVOKABLE void maximize() const;
+	/// Minimize the window.
+	Q_INVOKABLE void minimize() const;
+	/// Fullscreen the window.
+	Q_INVOKABLE void fullscreen() const;
 
 signals:
 	void minimumSizeChanged();
 	void maximumSizeChanged();
 	void titleChanged();
+	void minimizedChanged();
 	void maximizedChanged();
 	void fullscreenChanged();
 
@@ -116,6 +120,7 @@ private slots:
 
 private:
 	ProxyFloatingWindow* window;
+	bool mMinimized = false;
 	bool mMaximized = false;
 	bool mFullscreen = false;
 };