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/logging.cpp

@@ -30,17 +30,18 @@
 #include <sys/sendfile.h>
 
 #include "instanceinfo.hpp"
+#include "logcat.hpp"
 #include "logging_p.hpp"
 #include "logging_qtprivate.cpp" // NOLINT
 #include "paths.hpp"
 #include "ringbuf.hpp"
 
-Q_LOGGING_CATEGORY(logBare, "quickshell.bare");
+QS_LOGGING_CATEGORY(logBare, "quickshell.bare");
 
 namespace qs::log {
 using namespace qt_logging_registry;
 
-Q_LOGGING_CATEGORY(logLogging, "quickshell.logging", QtWarningMsg);
+QS_LOGGING_CATEGORY(logLogging, "quickshell.logging", QtWarningMsg);
 
 bool LogMessage::operator==(const LogMessage& other) const {
 	// note: not including time
@@ -187,10 +188,16 @@ void LogManager::filterCategory(QLoggingCategory* category) {
 	// We don't respect log filters for qs logs because some distros like to ship
 	// default configs that hide everything. QT_LOGGING_RULES is considered via the filter list.
 	if (isQs) {
-		filter.debug = instance->mDefaultLevel == QtDebugMsg;
-		filter.info = instance->mDefaultLevel == QtInfoMsg;
-		filter.warn = instance->mDefaultLevel == QtWarningMsg;
-		filter.critical = instance->mDefaultLevel == QtCriticalMsg;
+		// QtDebugMsg == 0, so default
+		auto defaultLevel = instance->defaultLevels.value(categoryName);
+
+		filter = CategoryFilter();
+		// clang-format off
+		filter.debug = instance->mDefaultLevel == QtDebugMsg || defaultLevel == QtDebugMsg;
+		filter.info = filter.debug || instance->mDefaultLevel == QtInfoMsg || defaultLevel == QtInfoMsg;
+		filter.warn = filter.info || instance->mDefaultLevel == QtWarningMsg || defaultLevel == QtWarningMsg;
+		filter.critical = filter.warn || instance->mDefaultLevel == QtCriticalMsg || defaultLevel == QtCriticalMsg;
+		// clang-format on
 	} else if (instance->lastCategoryFilter) {
 		instance->lastCategoryFilter(category);
 		filter = CategoryFilter(category);
@@ -262,6 +269,10 @@ void LogManager::init(
 	qCDebug(logLogging) << "Logger initialized.";
 }
 
+void initLogCategoryLevel(const char* name, QtMsgType defaultLevel) {
+	LogManager::instance()->defaultLevels.insert(QLatin1StringView(name), defaultLevel);
+}
+
 void LogManager::initFs() {
 	QMetaObject::invokeMethod(
 	    &LogManager::instance()->threadProxy,