core/log: track default logging categories

Fixes a bug in fb37be7 which ignored default logging categories due to
skipping QLoggingRegistry's filter.

Author: outfoxxed

src/bluetooth/adapter.cpp

@@ -12,13 +12,14 @@
 #include <qstringliteral.h>
 #include <qtypes.h>
 
+#include "../core/logcat.hpp"
 #include "../dbus/properties.hpp"
 #include "dbus_adapter.h"
 
 namespace qs::bluetooth {
 
 namespace {
-Q_LOGGING_CATEGORY(logAdapter, "quickshell.bluetooth.adapter", QtWarningMsg);
+QS_LOGGING_CATEGORY(logAdapter, "quickshell.bluetooth.adapter", QtWarningMsg);
 }
 
 QString BluetoothAdapterState::toString(BluetoothAdapterState::Enum state) {

src/bluetooth/bluez.cpp

@@ -8,6 +8,7 @@
 #include <qobject.h>
 #include <qtmetamacros.h>
 
+#include "../core/logcat.hpp"
 #include "../dbus/dbus_objectmanager_types.hpp"
 #include "../dbus/objectmanager.hpp"
 #include "adapter.hpp"
@@ -16,7 +17,7 @@
 namespace qs::bluetooth {
 
 namespace {
-Q_LOGGING_CATEGORY(logBluetooth, "quickshell.bluetooth", QtWarningMsg);
+QS_LOGGING_CATEGORY(logBluetooth, "quickshell.bluetooth", QtWarningMsg);
 }
 
 Bluez* Bluez::instance() {
@@ -156,7 +157,12 @@ void Bluez::onInterfacesRemoved(const QDBusObjectPath& path, const QStringList&
 }
 
 BluezQml::BluezQml() {
-	QObject::connect(Bluez::instance(), &Bluez::defaultAdapterChanged, this, &BluezQml::defaultAdapterChanged);
+	QObject::connect(
+	    Bluez::instance(),
+	    &Bluez::defaultAdapterChanged,
+	    this,
+	    &BluezQml::defaultAdapterChanged
+	);
 }
 
 } // namespace qs::bluetooth

src/bluetooth/bluez.hpp

@@ -50,13 +50,21 @@ private slots:
 	ObjectModel<BluetoothDevice> mDevices {this};
 
 public:
-	Q_OBJECT_BINDABLE_PROPERTY(Bluez, BluetoothAdapter*, bDefaultAdapter, &Bluez::defaultAdapterChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(
+	    Bluez,
+	    BluetoothAdapter*,
+	    bDefaultAdapter,
+	    &Bluez::defaultAdapterChanged
+	);
 };
 
 ///! Bluetooth manager
 /// Provides access to bluetooth devices and adapters.
 class BluezQml: public QObject {
 	Q_OBJECT;
+	QML_NAMED_ELEMENT(Bluetooth);
+	QML_SINGLETON;
+	// clang-format off
 	/// The default bluetooth adapter. Usually there is only one.
 	Q_PROPERTY(BluetoothAdapter* defaultAdapter READ default NOTIFY defaultAdapterChanged BINDABLE bindableDefaultAdapter);
 	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::bluetooth::BluetoothAdapter>*);
@@ -66,8 +74,7 @@ class BluezQml: public QObject {
 	/// A list of all connected bluetooth devices across all adapters.
 	/// See @@BluetoothAdapter.devices for the devices connected to a single adapter.
 	Q_PROPERTY(UntypedObjectModel* devices READ devices CONSTANT);
-	QML_NAMED_ELEMENT(Bluetooth);
-	QML_SINGLETON;
+	// clang-format on
 
 signals:
 	void defaultAdapterChanged();

src/bluetooth/device.cpp

@@ -12,6 +12,7 @@
 #include <qtmetamacros.h>
 #include <qtypes.h>
 
+#include "../core/logcat.hpp"
 #include "../dbus/properties.hpp"
 #include "adapter.hpp"
 #include "bluez.hpp"
@@ -20,7 +21,7 @@
 namespace qs::bluetooth {
 
 namespace {
-Q_LOGGING_CATEGORY(logDevice, "quickshell.bluetooth.device", QtWarningMsg);
+QS_LOGGING_CATEGORY(logDevice, "quickshell.bluetooth.device", QtWarningMsg);
 }
 
 QString BluetoothDeviceState::toString(BluetoothDeviceState::Enum state) {

src/core/colorquantizer.cpp

@@ -18,8 +18,10 @@
 #include <qtmetamacros.h>
 #include <qtypes.h>
 
+#include "logcat.hpp"
+
 namespace {
-Q_LOGGING_CATEGORY(logColorQuantizer, "quickshell.colorquantizer", QtWarningMsg);
+QS_LOGGING_CATEGORY(logColorQuantizer, "quickshell.colorquantizer", QtWarningMsg);
 }
 
 ColorQuantizerOperation::ColorQuantizerOperation(QUrl* source, qreal depth, qreal rescaleSize)

src/core/desktopentry.cpp

@@ -17,10 +17,11 @@
 #include <ranges>
 
 #include "common.hpp"
+#include "logcat.hpp"
 #include "model.hpp"
 
 namespace {
-Q_LOGGING_CATEGORY(logDesktopEntry, "quickshell.desktopentry", QtWarningMsg);
+QS_LOGGING_CATEGORY(logDesktopEntry, "quickshell.desktopentry", QtWarningMsg);
 }
 
 struct Locale {

src/core/generation.cpp

@@ -21,13 +21,14 @@
 #include "iconimageprovider.hpp"
 #include "imageprovider.hpp"
 #include "incubator.hpp"
+#include "logcat.hpp"
 #include "plugin.hpp"
 #include "qsintercept.hpp"
 #include "reload.hpp"
 #include "scan.hpp"
 
 namespace {
-Q_LOGGING_CATEGORY(logScene, "scene");
+QS_LOGGING_CATEGORY(logScene, "scene");
 }
 
 static QHash<const QQmlEngine*, EngineGeneration*> g_generations; // NOLINT

src/core/incubator.cpp

@@ -1,11 +1,12 @@
 #include "incubator.hpp"
 
 #include <qlogging.h>
-#include <qloggingcategory.h>
 #include <qqmlincubator.h>
 #include <qtmetamacros.h>
 
-Q_LOGGING_CATEGORY(logIncubator, "quickshell.incubator", QtWarningMsg);
+#include "logcat.hpp"
+
+QS_LOGGING_CATEGORY(logIncubator, "quickshell.incubator", QtWarningMsg);
 
 void QsQmlIncubator::statusChanged(QQmlIncubator::Status status) {
 	switch (status) {

src/core/incubator.hpp

@@ -1,11 +1,12 @@
 #pragma once
 
-#include <qloggingcategory.h>
 #include <qobject.h>
 #include <qqmlincubator.h>
 #include <qtmetamacros.h>
 
-Q_DECLARE_LOGGING_CATEGORY(logIncubator);
+#include "logcat.hpp"
+
+QS_DECLARE_LOGGING_CATEGORY(logIncubator);
 
 class QsQmlIncubator
     : public QObject

src/core/logcat.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <qlogging.h>
+#include <qloggingcategory.h>
+
+namespace qs::log {
+void initLogCategoryLevel(const char* name, QtMsgType defaultLevel = QtDebugMsg);
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define QS_DECLARE_LOGGING_CATEGORY(name)                                                          \
+	namespace qslogcat {                                                                             \
+	Q_DECLARE_LOGGING_CATEGORY(name);                                                                \
+	}                                                                                                \
+	const QLoggingCategory& name()
+
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define QS_LOGGING_CATEGORY(name, category, ...)                                                   \
+	namespace qslogcat {                                                                             \
+	Q_LOGGING_CATEGORY(name, category __VA_OPT__(, __VA_ARGS__));                                    \
+	}                                                                                                \
+	const QLoggingCategory& name() {                                                                 \
+		static auto* init = []() {                                                                     \
+			qs::log::initLogCategoryLevel(category __VA_OPT__(, __VA_ARGS__));                           \
+			return &qslogcat::name;                                                                      \
+		}();                                                                                           \
+		return (init) ();                                                                              \
+	}