fix: screensaver_dbus.cpp and session_lock.cpp linting errors

Author: saltnpepper97

src/dbus/objectmanager.hpp

@@ -34,4 +34,4 @@ class DBusObjectManager: public QObject {
 	DBusObjectManagerInterface* mInterface = nullptr;
 };
 
-} // namespace qs::dbus
+} // namespace qs::dbus

src/dbus/org.freedesktop.ScreenSaver.xml

@@ -1,17 +1,17 @@
 <node>
 	<interface name="org.freedesktop.ScreenSaver">
 		<!-- Get the current lock state -->
-		<method name="getActive">
+		<method name="GetActive">
 			<arg name="active" direction="out" type="b"/>
 		</method>
 
 		<!-- Signal emitted when lock state changes -->
-		<signal name="activeChanged">
+		<signal name="ActiveChanged">
 			<arg name="active" type="b"/>
 		</signal>
 
 		<!-- Get whether the compositor has confirmed the lock (secure state) -->
-		<method name="getSecure">
+		<method name="GetSecure">
 			<arg name="secure" direction="out" type="b"/>
 		</method>
 	</interface>

src/dbus/screensaver_dbus.cpp

@@ -1,15 +1,19 @@
 #include "screensaver_dbus.hpp"
 
-#include <QDBusConnection>
-#include <QDBusError>
-#include <QLoggingCategory>
-#include <QObject>  // emit
-#include <QtGlobal> // QtWarningMsg
+#include <qdbusabstractadaptor.h>
+#include <qdbusconnection.h>
+#include <qdbuserror.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
 
 #include "../core/logcat.hpp"
 
 namespace {
+
 QS_LOGGING_CATEGORY(logDbusScreenSaver, "quickshell.dbus.screensaver", QtWarningMsg);
+
 }
 
 namespace qs::dbus {
@@ -39,7 +43,7 @@ void ScreenSaverAdaptor::setActive(bool active) {
 	if (this->mActive != active) {
 		this->mActive = active;
 		qCDebug(logDbusScreenSaver) << "Lock state changed to:" << active;
-		emit activeChanged(active); // method name fixed
+		emit this->ActiveChanged(active);
 	}
 }
 
@@ -50,13 +54,13 @@ void ScreenSaverAdaptor::setSecure(bool secure) {
 	}
 }
 
-bool ScreenSaverAdaptor::getActive() const { // method name fixed
-	qCDebug(logDbusScreenSaver) << "getActive called, returning:" << this->mActive;
+bool ScreenSaverAdaptor::GetActive() const {
+	qCDebug(logDbusScreenSaver) << "GetActive called, returning:" << this->mActive;
 	return this->mActive;
 }
 
-bool ScreenSaverAdaptor::getSecure() const { // method name fixed
-	qCDebug(logDbusScreenSaver) << "getSecure called, returning:" << this->mSecure;
+bool ScreenSaverAdaptor::GetSecure() const {
+	qCDebug(logDbusScreenSaver) << "GetSecure called, returning:" << this->mSecure;
 	return this->mSecure;
 }
 

src/dbus/screensaver_dbus.hpp

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <QDBusAbstractAdaptor>
-#include <QObject>
-#include <QtGlobal> // QtWarningMsg
+#include <qdbusabstractadaptor.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
 
 namespace qs::dbus {
 
 class ScreenSaverAdaptor: public QDBusAbstractAdaptor {
-	Q_OBJECT
+	Q_OBJECT;
 	Q_CLASSINFO("D-Bus Interface", "org.freedesktop.ScreenSaver")
 
 public:
@@ -19,11 +19,11 @@ class ScreenSaverAdaptor: public QDBusAbstractAdaptor {
 	void setSecure(bool secure);
 
 public slots:
-	[[nodiscard]] bool getActive() const;
-	[[nodiscard]] bool getSecure() const;
+	[[nodiscard]] bool GetActive() const; // NOLINT(readability-identifier-naming)
+	[[nodiscard]] bool GetSecure() const; // NOLINT(readability-identifier-naming)
 
 signals:
-	void activeChanged(bool active);
+	void ActiveChanged(bool active); // NOLINT(readability-identifier-naming)
 
 private:
 	bool mActive = false;

src/wayland/session_lock/CMakeLists.txt

@@ -6,6 +6,7 @@ qt_add_library(quickshell-wayland-sessionlock STATIC
 	session_lock.cpp
 )
 wl_proto(wlp-session-lock ext-session-lock-v1 "${WAYLAND_PROTOCOLS}/staging/ext-session-lock")
+target_include_directories(quickshell-wayland-sessionlock PRIVATE ${CMAKE_SOURCE_DIR}/src)
 target_link_libraries(quickshell-wayland-sessionlock PRIVATE
 	Qt::Quick Qt::WaylandClient Qt::WaylandClientPrivate Qt::DBus wayland-client
 	wlp-session-lock

src/wayland/session_lock/session_lock.cpp

@@ -3,25 +3,32 @@
 #include <private/qwaylanddisplay_p.h>
 #include <qlogging.h>
 #include <qobject.h>
+#include <qtmetamacros.h>
 #include <qwindow.h>
 
 #include "../../dbus/screensaver_dbus.hpp"
 #include "lock.hpp"
 #include "manager.hpp"
 #include "shell_integration.hpp"
 #include "surface.hpp"
+
 namespace {
+
 QSWaylandSessionLockManager* manager() {
 	static QSWaylandSessionLockManager* manager = nullptr; // NOLINT
 	if (manager == nullptr) {
 		manager = new QSWaylandSessionLockManager();
 	}
 	return manager;
 }
+
 } // namespace
+
 bool SessionLockManager::lockAvailable() { return manager()->isActive(); }
+
 bool SessionLockManager::lock() {
 	if (this->isLocked() || SessionLockManager::sessionLocked()) return false;
+
 	this->mLock = manager()->acquireLock();
 	this->mLock->setParent(this);
 
@@ -39,30 +46,40 @@ bool SessionLockManager::lock() {
 		this->mDbusAdaptor->setSecure(true);
 		emit this->locked();
 	});
+
 	QObject::connect(this->mLock, &QSWaylandSessionLock::unlocked, this, [this]() {
 		this->mDbusAdaptor->setActive(false);
 		this->mDbusAdaptor->setSecure(false);
 		emit this->unlocked();
 	});
 	// clang-format on
+
 	return true;
 }
+
 bool SessionLockManager::unlock() {
 	if (!this->isLocked()) return false;
+
 	this->mLock->unlock();
 	auto* lock = this->mLock;
 	this->mLock = nullptr;
 	delete lock;
+
 	return true;
 }
+
 bool SessionLockManager::isLocked() const { return this->mLock != nullptr; }
+
 bool SessionLockManager::sessionLocked() { return manager()->isLocked(); }
+
 bool SessionLockManager::isSecure() { return manager()->isSecure(); }
+
 LockWindowExtension::~LockWindowExtension() {
 	if (this->surface != nullptr) {
 		this->surface->setExtension(nullptr);
 	}
 }
+
 LockWindowExtension* LockWindowExtension::get(QWindow* window) {
 	auto v = window->property("sessionlock_ext");
 	if (v.canConvert<LockWindowExtension*>()) {
@@ -71,24 +88,30 @@ LockWindowExtension* LockWindowExtension::get(QWindow* window) {
 		return nullptr;
 	}
 }
+
 bool LockWindowExtension::isAttached() const { return this->surface != nullptr; }
+
 bool LockWindowExtension::attach(QWindow* window, SessionLockManager* manager) {
 	if (this->surface != nullptr)
 		qFatal() << "Cannot change the attached window of a LockWindowExtension";
+
 	auto* current = LockWindowExtension::get(window);
 	QtWaylandClient::QWaylandWindow* waylandWindow = nullptr;
+
 	if (current != nullptr) {
 		current->surface->setExtension(this);
 	} else {
 		// Qt appears to be resetting the window's screen on creation on some systems. This works around it.
 		auto* screen = window->screen();
 		window->create();
 		window->setScreen(screen);
+
 		waylandWindow = dynamic_cast<QtWaylandClient::QWaylandWindow*>(window->handle());
 		if (waylandWindow == nullptr) {
 			qWarning() << window << "is not a wayland window. Cannot create lock surface.";
 			return false;
 		}
+
 		static QSWaylandSessionLockIntegration* lockIntegration = nullptr; // NOLINT
 		if (lockIntegration == nullptr) {
 			lockIntegration = new QSWaylandSessionLockIntegration();
@@ -98,17 +121,23 @@ bool LockWindowExtension::attach(QWindow* window, SessionLockManager* manager) {
 				qWarning() << "Failed to initialize lockscreen integration";
 			}
 		}
+
 		waylandWindow->setShellIntegration(lockIntegration);
 	}
+
 	this->setParent(window);
 	window->setProperty("sessionlock_ext", QVariant::fromValue(this));
+
 	this->lock = manager->mLock;
+
 	if (waylandWindow != nullptr) {
 		this->surface = new QSWaylandSessionLockSurface(waylandWindow);
 		if (this->immediatelyVisible) this->surface->setVisible();
 	}
+
 	return true;
 }
+
 void LockWindowExtension::setVisible() {
 	if (this->surface == nullptr) this->immediatelyVisible = true;
 	else this->surface->setVisible();

src/wayland/session_lock/session_lock.hpp

@@ -14,7 +14,7 @@ class ScreenSaverAdaptor;
 }
 
 class SessionLockManager: public QObject {
-	Q_OBJECT;
+	Q_OBJECT
 
 public:
 	explicit SessionLockManager(QObject* parent = nullptr): QObject(parent) {}
@@ -30,11 +30,10 @@ class SessionLockManager: public QObject {
 	bool unlock();
 
 	[[nodiscard]] bool isLocked() const;
-
 	static bool sessionLocked();
 	static bool isSecure();
 
-signals:
+Q_SIGNALS:
 	// This signal is sent once the compositor considers the session to be fully locked.
 	// This corrosponds to the ext_session_lock_v1::locked event.
 	void locked();
@@ -58,7 +57,7 @@ class SessionLockManager: public QObject {
 };
 
 class LockWindowExtension: public QObject {
-	Q_OBJECT;
+	Q_OBJECT
 
 public:
 	explicit LockWindowExtension(QObject* parent = nullptr): QObject(parent) {}
@@ -78,7 +77,7 @@ class LockWindowExtension: public QObject {
 
 	static LockWindowExtension* get(QWindow* window);
 
-signals:
+Q_SIGNALS:
 	// This signal is sent once the compositor considers the session to be fully locked.
 	// See SessionLockManager::locked for details.
 	void locked();