wip ext-ws

Author: outfoxxed

src/CMakeLists.txt

@@ -11,6 +11,7 @@ add_subdirectory(window)
 add_subdirectory(io)
 add_subdirectory(widgets)
 add_subdirectory(ui)
+add_subdirectory(windowmanager)
 
 if (CRASH_REPORTER)
 	add_subdirectory(crash)

src/wayland/CMakeLists.txt

@@ -113,6 +113,8 @@ if (HYPRLAND)
 	add_subdirectory(hyprland)
 endif()
 
+add_subdirectory(windowmanager)
+
 # widgets for qmenu
 target_link_libraries(quickshell-wayland PRIVATE
 	Qt::Quick Qt::Widgets Qt::WaylandClient Qt::WaylandClientPrivate

src/wayland/windowmanager/CMakeLists.txt

@@ -0,0 +1,20 @@
+qt_add_library(quickshell-wayland-windowsystem STATIC
+	windowmanager.cpp
+	workspace.cpp
+	ext_workspace.cpp
+)
+
+add_library(quickshell-wayland-windowsystem-init OBJECT init.cpp)
+target_link_libraries(quickshell-wayland-windowsystem-init PRIVATE Qt::Quick)
+
+#wl_proto(wlp-ext-foreign-toplevel ext-foreign-toplevel-list-v1 "${WAYLAND_PROTOCOLS}/staging/ext-foreign-toplevel-list")
+wl_proto(wlp-ext-workspace ext-workspace-v1 "${WAYLAND_PROTOCOLS}/staging/ext-workspace")
+
+target_link_libraries(quickshell-wayland-windowsystem PRIVATE
+	Qt::WaylandClient Qt::WaylandClientPrivate wayland-client
+	Qt::Quick # for pch? potentially, check w/ gcc
+
+	wlp-ext-foreign-toplevel wlp-ext-workspace
+)
+
+target_link_libraries(quickshell PRIVATE quickshell-wayland-windowsystem quickshell-wayland-windowsystem-init)

src/wayland/windowmanager/ext_workspace.cpp

@@ -0,0 +1,116 @@
+#include "ext_workspace.hpp"
+
+#include <qloggingcategory.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "qwayland-ext-workspace-v1.h"
+#include "wayland-ext-workspace-v1-client-protocol.h"
+
+namespace qs::wayland::workspace {
+
+namespace {
+Q_LOGGING_CATEGORY(logWorkspace, "quickshell.wm.wayland.workspace");
+}
+
+WorkspaceManager::WorkspaceManager(): QWaylandClientExtensionTemplate(1) { this->initialize(); }
+
+WorkspaceManager* WorkspaceManager::instance() {
+	static auto* instance = new WorkspaceManager();
+	return instance;
+}
+
+void WorkspaceManager::ext_workspace_manager_v1_workspace_group(
+    ::ext_workspace_group_handle_v1* workspaceGroup
+) {
+	// todo
+}
+
+void WorkspaceManager::ext_workspace_manager_v1_workspace(::ext_workspace_handle_v1* workspace) {
+	auto* qws = new Workspace(workspace);
+	qCDebug(logWorkspace) << "Created workspace" << qws;
+	this->mWorkspaces.insert(workspace, qws);
+	emit this->workspaceCreated(qws);
+};
+
+void WorkspaceManager::destroyWorkspace(Workspace* workspace) {
+	this->destroyedWorkspaces.append(workspace);
+	emit this->workspaceDestroyed(workspace);
+}
+
+void WorkspaceManager::ext_workspace_manager_v1_done() {
+	qCDebug(logWorkspace) << "Workspace changes done";
+	emit this->serverCommit();
+
+	for (auto* workspace: this->destroyedWorkspaces) delete workspace;
+	this->destroyedWorkspaces.clear();
+}
+
+void WorkspaceManager::ext_workspace_manager_v1_finished() {
+	// todo
+}
+
+WorkspaceGroup::~WorkspaceGroup() { this->destroy(); }
+void WorkspaceGroup::ext_workspace_group_handle_v1_removed() { delete this; }
+
+Workspace::~Workspace() {
+	if (this->isInitialized()) this->destroy();
+}
+
+void Workspace::ext_workspace_handle_v1_id(const QString& id) {
+	qCDebug(logWorkspace) << "Updated id for" << this << "to" << id;
+	this->id = id;
+}
+
+void Workspace::ext_workspace_handle_v1_name(const QString& name) {
+	qCDebug(logWorkspace) << "Updated name for" << this << "to" << name;
+	this->name = name;
+}
+
+void Workspace::ext_workspace_handle_v1_coordinates(wl_array* coordinates) {
+	this->coordinates.clear();
+
+	auto* data = static_cast<qint32*>(coordinates->data);
+	auto size = static_cast<qsizetype>(coordinates->size / sizeof(qint32));
+
+	for (auto i = 0; i != size; ++i) {
+		this->coordinates.append(data[i]); // NOLINT
+	}
+
+	qCDebug(logWorkspace) << "Updated coordinates for" << this << "to" << this->coordinates;
+}
+
+void Workspace::ext_workspace_handle_v1_state(quint32 state) {
+	this->active = state & QtWayland::ext_workspace_handle_v1::state_active;
+	this->urgent = state & QtWayland::ext_workspace_handle_v1::state_urgent;
+	this->hidden = state & QtWayland::ext_workspace_handle_v1::state_hidden;
+
+	qCDebug(logWorkspace).nospace() << "Updated state for " << this << " to [active: " << this->active
+	                                << ", urgent: " << this->urgent << ", hidden: " << this->hidden
+	                                << ']';
+}
+
+void Workspace::ext_workspace_handle_v1_capabilities(quint32 capabilities) {
+	this->canActivate =
+	    capabilities & QtWayland::ext_workspace_handle_v1::workspace_capabilities_activate;
+	this->canDeactivate =
+	    capabilities & QtWayland::ext_workspace_handle_v1::workspace_capabilities_deactivate;
+	this->canRemove =
+	    capabilities & QtWayland::ext_workspace_handle_v1::workspace_capabilities_remove;
+	this->canAssign =
+	    capabilities & QtWayland::ext_workspace_handle_v1::workspace_capabilities_assign;
+
+	qCDebug(logWorkspace).nospace() << "Updated capabilities for " << this
+	                                << " to [activate: " << this->canActivate
+	                                << ", deactivate: " << this->canDeactivate
+	                                << ", remove: " << this->canRemove
+	                                << ", assign: " << this->canAssign << ']';
+}
+
+void Workspace::ext_workspace_handle_v1_removed() {
+	qCDebug(logWorkspace) << "Destroyed workspace" << this;
+	this->destroy();
+	WorkspaceManager::instance()->destroyWorkspace(this);
+}
+
+} // namespace qs::wayland::workspace

src/wayland/windowmanager/ext_workspace.hpp

@@ -0,0 +1,109 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qlist.h>
+#include <qloggingcategory.h>
+#include <qscreen.h>
+#include <qscreen_platform.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qwayland-ext-workspace-v1.h>
+#include <qwaylandclientextension.h>
+#include <wayland-ext-workspace-v1-client-protocol.h>
+
+namespace qs::wayland::workspace {
+
+class WorkspaceGroup;
+class Workspace;
+
+class WorkspaceManager
+    : public QWaylandClientExtensionTemplate<WorkspaceManager>
+    , public QtWayland::ext_workspace_manager_v1 {
+	Q_OBJECT;
+
+public:
+	static WorkspaceManager* instance();
+
+	[[nodiscard]] QList<Workspace*> workspaces() { return this->mWorkspaces.values(); }
+
+signals:
+	void serverCommit();
+	void workspaceCreated(Workspace* workspace);
+	void workspaceDestroyed(Workspace* workspace);
+
+protected:
+	void ext_workspace_manager_v1_workspace_group(::ext_workspace_group_handle_v1* workspaceGroup
+	) override;
+	void ext_workspace_manager_v1_workspace(::ext_workspace_handle_v1* workspace) override;
+	void ext_workspace_manager_v1_done() override;
+	void ext_workspace_manager_v1_finished() override;
+
+private:
+	WorkspaceManager();
+
+	void destroyWorkspace(Workspace* workspace);
+
+	QHash<::ext_workspace_group_handle_v1*, WorkspaceGroup*> mGroups;
+	QHash<::ext_workspace_handle_v1*, Workspace*> mWorkspaces;
+	QList<Workspace*> destroyedWorkspaces;
+
+	friend class WorkspaceGroup;
+	friend class Workspace;
+};
+
+class WorkspaceGroup: public QtWayland::ext_workspace_group_handle_v1 {
+public:
+	WorkspaceGroup(::ext_workspace_group_handle_v1* handle)
+	    : QtWayland::ext_workspace_group_handle_v1(handle) {}
+	~WorkspaceGroup() override;
+	Q_DISABLE_COPY_MOVE(WorkspaceGroup);
+
+protected:
+	/*void ext_workspace_group_handle_v1_capabilities(uint32_t capabilities) override;
+	void ext_workspace_group_handle_v1_output_enter(::wl_output* output) override;
+	void ext_workspace_group_handle_v1_output_leave(::wl_output* output) override;
+	void ext_workspace_group_handle_v1_workspace_enter(::ext_workspace_handle_v1* workspace) override;
+	void ext_workspace_group_handle_v1_workspace_leave(::ext_workspace_handle_v1* workspace) override;*/
+	void ext_workspace_group_handle_v1_removed() override;
+
+private:
+	QList<QScreen*> screens;
+	QList<wl_output*> pendingScreens;
+};
+
+class Workspace: public QtWayland::ext_workspace_handle_v1 {
+public:
+	Workspace(::ext_workspace_handle_v1* handle): QtWayland::ext_workspace_handle_v1(handle) {}
+	~Workspace() override;
+	Q_DISABLE_COPY_MOVE(Workspace);
+
+	QString id;
+	QString name;
+	QList<qint32> coordinates;
+
+	bool active : 1 = false;
+	bool urgent : 1 = false;
+	bool hidden : 1 = false;
+
+	bool canActivate : 1 = false;
+	bool canDeactivate : 1 = false;
+	bool canRemove : 1 = false;
+	bool canAssign : 1 = false;
+
+protected:
+	void ext_workspace_handle_v1_id(const QString& id) override;
+	void ext_workspace_handle_v1_name(const QString& name) override;
+	void ext_workspace_handle_v1_coordinates(wl_array* coordinates) override;
+	void ext_workspace_handle_v1_state(uint32_t state) override;
+	void ext_workspace_handle_v1_capabilities(uint32_t capabilities) override;
+	void ext_workspace_handle_v1_removed() override;
+
+private:
+	//void enterGroup(WorkspaceGroup* group);
+	//void leaveGroup(WorkspaceGroup* group);
+
+	friend class WorkspaceGroup;
+};
+
+} // namespace qs::wayland::workspace

src/wayland/windowmanager/init.cpp

@@ -0,0 +1,21 @@
+#include <qguiapplication.h>
+
+#include "../../core/plugin.hpp"
+
+namespace qs::wm::wayland {
+void installWmProvider();
+}
+
+namespace {
+
+class WaylandWmPlugin: public QsEnginePlugin {
+	QList<QString> dependencies() override { return {"window"}; }
+
+	bool applies() override { return QGuiApplication::platformName() == "wayland"; }
+
+	void init() override { qs::wm::wayland::installWmProvider(); }
+};
+
+QS_REGISTER_PLUGIN(WaylandWmPlugin);
+
+} // namespace

src/wayland/windowmanager/test/manual/workspaces.qml

@@ -0,0 +1,67 @@
+import QtQuick
+import QtQuick.Controls.Fusion
+import QtQuick.Layouts
+import Quickshell
+import Quickshell.Widgets
+import Quickshell.WindowManager
+
+FloatingWindow {
+	ColumnLayout {
+		Repeater {
+			model: WindowManager.workspaces
+
+			WrapperRectangle {
+				id: delegate
+				required property Workspace modelData;
+				color: modelData.active ? "limegreen" : "gray"
+
+				ColumnLayout {
+					Label { text: delegate.modelData.toString() }
+
+					RowLayout {
+						DisplayCheckBox {
+							text: "Active"
+							checked: delegate.modelData.active
+						}
+
+						DisplayCheckBox {
+							text: "Urgent"
+							checked: delegate.modelData.urgent
+						}
+
+						DisplayCheckBox {
+							text: "Should Display"
+							checked: delegate.modelData.shouldDisplay
+						}
+					}
+
+					RowLayout {
+						Button {
+							text: "Activate"
+							enabled: delegate.modelData.canActivate
+							onClicked: delegate.modelData.activate()
+						}
+
+						Button {
+							text: "Deactivate"
+							enabled: delegate.modelData.canDeactivate
+							onClicked: delegate.modelData.deactivate()
+						}
+
+						Button {
+							text: "Remove"
+							enabled: delegate.modelData.canRemove
+							onClicked: delegate.modelData.remove()
+						}
+					}
+				}
+			}
+		}
+	}
+
+	component DisplayCheckBox: CheckBox {
+		enabled: false
+		palette.disabled.text: palette.active.text
+		palette.disabled.windowText: palette.active.windowText
+	}
+}

src/wayland/windowmanager/windowmanager.cpp

@@ -0,0 +1,14 @@
+#include "windowmanager.hpp"
+
+namespace qs::wm::wayland {
+
+WaylandWindowManager* WaylandWindowManager::instance() {
+	static auto* instance = new WaylandWindowManager();
+	return instance;
+}
+
+void installWmProvider() {
+	qs::wm::WindowManager::setProvider([]() { return WaylandWindowManager::instance(); });
+}
+
+} // namespace qs::wm::wayland

src/wayland/windowmanager/windowmanager.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <qtmetamacros.h>
+
+#include "../../windowmanager/windowmanager.hpp"
+#include "workspace.hpp"
+
+namespace qs::wm::wayland {
+
+class WaylandWindowManager: public WindowManager {
+	Q_OBJECT;
+
+public:
+	static WaylandWindowManager* instance();
+
+	[[nodiscard]] UntypedObjectModel* workspaces() const override {
+		return &WorkspaceManager::instance()->mWorkspaces;
+	}
+};
+
+} // namespace qs::wm::wayland