feat: move synced properties to bindables

- Prefer bindables over connections for synced properties
- Remove lambdas from ready and disappeared signal connections
- Add namespaces to Q_PROPERTY definitions
- Remove Network.wifi.defaultDevice (easy to add in userspace)
- Add all devices to a ListView in network.qml

Author: cpwrs

src/network/device.cpp

@@ -13,36 +13,12 @@ QS_LOGGING_CATEGORY(logNetworkDevice, "quickshell.network.device", QtWarningMsg)
 
 NetworkDevice::NetworkDevice(QObject* parent): QObject(parent) {};
 
-void NetworkDevice::setName(const QString& name) {
-	if (name == this->mName) return;
-	this->mName = name;
-	emit this->nameChanged();
-}
-
-void NetworkDevice::setAddress(const QString& address) {
-	if (address == this->mAddress) return;
-	this->mAddress = address;
-	emit this->addressChanged();
-}
-
-void NetworkDevice::setState(NetworkConnectionState::Enum state) {
-	if (state == this->mState) return;
-	this->mState = state;
-	emit this->stateChanged();
-}
-
-void NetworkDevice::setNmState(NMDeviceState::Enum nmState) {
-	if (nmState == this->mNmState) return;
-	this->mNmState = nmState;
-	emit this->nmStateChanged();
-}
-
 void NetworkDevice::disconnect() {
-	if (this->mState == NetworkConnectionState::Disconnected) {
+	if (this->bState == NetworkConnectionState::Disconnected) {
 		qCCritical(logNetworkDevice) << "Device" << this << "is already disconnected";
 		return;
 	}
-	if (this->mState == NetworkConnectionState::Disconnecting) {
+	if (this->bState == NetworkConnectionState::Disconnecting) {
 		qCCritical(logNetworkDevice) << "Device" << this << "is already disconnecting";
 		return;
 	}

src/network/device.hpp

@@ -32,15 +32,16 @@ class NetworkDevice: public QObject {
 	Q_OBJECT;
 	QML_ELEMENT;
 	QML_UNCREATABLE("Devices can only be acquired through Network");
-
+	// clang-format off
 	/// The name of the device's control interface.
-	Q_PROPERTY(QString name READ name NOTIFY nameChanged);
+	Q_PROPERTY(QString name READ name NOTIFY nameChanged BINDABLE bindableName);
 	/// The hardware address of the device in the XX:XX:XX:XX:XX:XX format.
-	Q_PROPERTY(QString address READ address NOTIFY addressChanged);
+	Q_PROPERTY(QString address READ address NOTIFY addressChanged BINDABLE bindableAddress);
 	/// Connection state of the device.
-	Q_PROPERTY(NetworkConnectionState::Enum state READ state NOTIFY stateChanged);
+	Q_PROPERTY(qs::network::NetworkConnectionState::Enum state READ state NOTIFY stateChanged BINDABLE bindableState);
 	/// A more specific device state when the backend is NetworkManager.
-	Q_PROPERTY(NMDeviceState::Enum nmState READ nmState NOTIFY nmStateChanged);
+	Q_PROPERTY(qs::network::NMDeviceState::Enum nmState READ nmState NOTIFY nmStateChanged BINDABLE bindableNmState);
+	// clang-format on
 
 signals:
 	void nameChanged();
@@ -49,28 +50,28 @@ class NetworkDevice: public QObject {
 	void nmStateChanged();
 	void requestDisconnect();
 
-public slots:
-	void setName(const QString& name);
-	void setAddress(const QString& address);
-	void setState(NetworkConnectionState::Enum state);
-	void setNmState(NMDeviceState::Enum state);
-
 public:
 	explicit NetworkDevice(QObject* parent = nullptr);
 
-	[[nodiscard]] QString name() const { return this->mName; };
-	[[nodiscard]] QString address() const { return this->mAddress; };
-	[[nodiscard]] NetworkConnectionState::Enum state() const { return this->mState; };
-	[[nodiscard]] NMDeviceState::Enum nmState() const { return this->mNmState; };
-
 	/// Disconnects the device and prevents it from automatically activating further connections.
 	Q_INVOKABLE void disconnect();
 
+	[[nodiscard]] QString name() const { return this->bName; };
+	[[nodiscard]] QString address() const { return this->bAddress; };
+	[[nodiscard]] NetworkConnectionState::Enum state() const { return this->bState; };
+	[[nodiscard]] NMDeviceState::Enum nmState() const { return this->bNmState; };
+	QBindable<QString> bindableName() { return &this->bName; };
+	QBindable<QString> bindableAddress() { return &this->bAddress; };
+	QBindable<NetworkConnectionState::Enum> bindableState() { return &this->bState; };
+	QBindable<NMDeviceState::Enum> bindableNmState() { return &this->bNmState; };
+
 private:
-	QString mName;
-	QString mAddress;
-	NetworkConnectionState::Enum mState = NetworkConnectionState::Unknown;
-	NMDeviceState::Enum mNmState = NMDeviceState::Unknown;
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, QString, bName, &NetworkDevice::nameChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, QString, bAddress, &NetworkDevice::addressChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, NetworkConnectionState::Enum, bState, &NetworkDevice::stateChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, NMDeviceState::Enum, bNmState, &NetworkDevice::nmStateChanged);
+	// clang-format on
 };
 
 } // namespace qs::network

src/network/network.cpp

@@ -1,7 +1,7 @@
 #include "network.hpp"
 
-#include <qloggingcategory.h>
 #include <qlogging.h>
+#include <qloggingcategory.h>
 
 #include "../core/logcat.hpp"
 #include "nm/backend.hpp"
@@ -19,8 +19,8 @@ Network::Network(QObject* parent): QObject(parent), mWifi(new Wifi(this)) {
 		// clang-format off
 		QObject::connect(nm, &NetworkManager::wifiDeviceAdded, this->wifi(), &Wifi::onDeviceAdded);
 		QObject::connect(nm, &NetworkManager::wifiDeviceRemoved, this->wifi(), &Wifi::onDeviceRemoved);
-		QObject::connect(nm, &NetworkManager::wifiEnabledChanged, this->wifi(), &Wifi::onEnabledSet);
-		QObject::connect(nm, &NetworkManager::wifiHardwareEnabledChanged, this->wifi(), &Wifi::onHardwareEnabledSet);
+		this->wifi()->bindableEnabled().setBinding([nm]() { return nm->wifiEnabled(); });
+		this->wifi()->bindableHardwareEnabled().setBinding([nm]() { return nm->wifiHardwareEnabled(); });
 		QObject::connect(this->wifi(), &Wifi::requestSetEnabled, nm, &NetworkManager::setWifiEnabled);
 		// clang-format on
 		this->mBackend = nm;

src/network/network.hpp

@@ -49,8 +49,8 @@ class Network: public QObject {
 public:
 	explicit Network(QObject* parent = nullptr);
 
-	[[nodiscard]] Wifi* wifi() { return this->mWifi; };
-	[[nodiscard]] NetworkBackendType::Enum backend() { return this->mBackendType; };
+	[[nodiscard]] Wifi* wifi() const { return this->mWifi; };
+	[[nodiscard]] NetworkBackendType::Enum backend() const { return this->mBackendType; };
 
 private:
 	Wifi* mWifi;

src/network/nm/backend.cpp

@@ -143,12 +143,17 @@ void NetworkManager::registerWifiDevice(const QString& path) {
 	wireless->setParent(device);
 	this->mDeviceHash.insert(path, device);
 
+	device->bindableName().setBinding([wireless]() { return wireless->interface(); });
+	device->bindableAddress().setBinding([wireless]() { return wireless->hwAddress(); });
+	device->bindableNmState().setBinding([wireless]() { return wireless->state(); });
+	device->bindableState().setBinding([wireless]() {
+		return qs::network::NetworkManager::toNetworkDeviceState(wireless->state());
+	});
+	device->bindableScanning().setBinding([wireless]() {
+		(void)wireless->lastScan();
+		return false;
+	});
 	// clang-format off
-	QObject::connect(wireless, &NMWirelessDevice::interfaceChanged, device, &WifiDevice::setName);
-	QObject::connect(wireless, &NMWirelessDevice::hwAddressChanged, device, &WifiDevice::setAddress);
-	QObject::connect(wireless, &NMWirelessDevice::stateChanged, device, &WifiDevice::setNmState);
-	QObject::connect(wireless, &NMWirelessDevice::stateChanged, device, [device](NMDeviceState::Enum state) { device->setState(qs::network::NetworkManager::toNetworkDeviceState(state));});
-	QObject::connect(wireless, &NMWirelessDevice::lastScanChanged, device, &WifiDevice::scanComplete);
 	QObject::connect(wireless, &NMWirelessDevice::addAndActivateConnection, this, &NetworkManager::addAndActivateConnection);
 	QObject::connect(wireless, &NMWirelessDevice::activateConnection, this, &NetworkManager::activateConnection);
 	QObject::connect(wireless, &NMWirelessDevice::wifiNetworkAdded, device, &WifiDevice::networkAdded);

src/network/nm/backend.hpp

@@ -26,6 +26,8 @@ class NetworkManager: public NetworkBackend {
 public:
 	explicit NetworkManager(QObject* parent = nullptr);
 	[[nodiscard]] bool isAvailable() const override;
+	[[nodiscard]] bool wifiEnabled() const { return this->bWifiEnabled; };
+	[[nodiscard]] bool wifiHardwareEnabled() const { return this->bWifiHardwareEnabled; };
 
 public slots:
 	void setWifiEnabled(bool enabled);

src/network/nm/wireless.cpp

@@ -59,33 +59,13 @@ void NMWirelessNetwork::updateReferenceConnection() {
 	}
 }
 
-void NMWirelessNetwork::setActiveApPath(const QDBusObjectPath& path) {
-	if (this->mActiveApPath == path) return;
-	this->mActiveApPath = path;
-}
-
-void NMWirelessNetwork::setState(NMConnectionState::Enum state) {
-	if (this->bState == state) return;
-	this->bState = state;
-}
-
-void NMWirelessNetwork::setReason(NMConnectionStateReason::Enum reason) {
-	if (this->bReason == reason) return;
-	this->bReason = reason;
-};
-
-void NMWirelessNetwork::setCaps(NMWirelessCapabilities::Enum caps) {
-	if (this->mCaps == caps) return;
-	this->mCaps = caps;
-}
-
 void NMWirelessNetwork::updateReferenceAp() {
 	quint8 selectedStrength = 0;
 	NMAccessPoint* selectedAp = nullptr;
 
 	for (auto* ap: this->mAccessPoints.values()) {
 		// Always prefer the active AP if found.
-		if (ap->path() == this->mActiveApPath.path()) {
+		if (ap->path() == this->bActiveApPath) {
 			selectedStrength = ap->signalStrength();
 			selectedAp = ap;
 			break;
@@ -108,7 +88,7 @@ void NMWirelessNetwork::updateReferenceAp() {
 		// Reference AP is used for security when there's no connection settings.
 		if (this->mReferenceConn) return;
 		auto security = findBestWirelessSecurity(
-		    this->mCaps,
+		    this->bCaps,
 		    this->mReferenceAp->mode() == NM80211Mode::Adhoc,
 		    this->mReferenceAp->flags(),
 		    this->mReferenceAp->wpaFlags(),
@@ -123,12 +103,13 @@ void NMWirelessNetwork::addAccessPoint(NMAccessPoint* ap) {
 	this->mAccessPoints.insert(ap->path(), ap);
 	// clang-format off
 	QObject::connect(ap, &NMAccessPoint::signalStrengthChanged, this, &NMWirelessNetwork::updateReferenceAp);
-	QObject::connect(ap, &NMAccessPoint::disappeared, this, [this, ap] { this->removeAccessPoint(ap); });
+	QObject::connect(ap, &NMAccessPoint::disappeared, this, &NMWirelessNetwork::removeAccessPoint);
 	// clang-format on
 	this->updateReferenceAp();
 };
 
-void NMWirelessNetwork::removeAccessPoint(NMAccessPoint* ap) {
+void NMWirelessNetwork::removeAccessPoint() {
+	auto* ap = qobject_cast<NMAccessPoint*>(sender());
 	if (this->mAccessPoints.take(ap->path())) {
 		if (this->mAccessPoints.isEmpty()) {
 			emit this->disappeared();
@@ -143,13 +124,14 @@ void NMWirelessNetwork::addConnectionSettings(NMConnectionSettings* conn) {
 	if (this->mConnections.contains(conn->path())) return;
 	this->mConnections.insert(conn->path(), conn);
 	// clang-format off
-	QObject::connect(conn, &NMConnectionSettings::disappeared, this, [this, conn]() { this->removeConnectionSettings(conn); });
+	QObject::connect(conn, &NMConnectionSettings::disappeared, this, &NMWirelessNetwork::removeConnectionSettings);
 	// clang-format on
 	this->updateReferenceConnection();
 	this->bKnown = true;
 };
 
-void NMWirelessNetwork::removeConnectionSettings(NMConnectionSettings* conn) {
+void NMWirelessNetwork::removeConnectionSettings() {
+	auto* conn = qobject_cast<NMConnectionSettings*>(sender());
 	if (this->mConnections.take(conn->path())) {
 		QObject::disconnect(conn, nullptr, this, nullptr);
 		this->updateReferenceConnection();
@@ -161,18 +143,16 @@ void NMWirelessNetwork::removeConnectionSettings(NMConnectionSettings* conn) {
 
 void NMWirelessNetwork::addActiveConnection(NMActiveConnection* active) {
 	if (this->mActiveConnection) return;
-
-	this->bState = active->state();
-	this->bReason = active->stateReason();
 	this->mActiveConnection = active;
+	this->bState.setBinding([active]() { return active->state(); });
+	this->bReason.setBinding([active]() { return active->stateReason(); });
 	// clang-format off
-	QObject::connect(active, &NMActiveConnection::stateChanged, this, &NMWirelessNetwork::setState);
-	QObject::connect(active, &NMActiveConnection::stateReasonChanged, this, &NMWirelessNetwork::setReason);
-	QObject::connect(active, &NMActiveConnection::disappeared, this, [this, active] { this->removeActiveConnection(active); });
+	QObject::connect(active, &NMActiveConnection::disappeared, this, &NMWirelessNetwork::removeActiveConnection);
 	// clang-format on
 };
 
-void NMWirelessNetwork::removeActiveConnection(NMActiveConnection* active) {
+void NMWirelessNetwork::removeActiveConnection() {
+	auto* active = qobject_cast<NMActiveConnection*>(sender());
 	if (this->mActiveConnection && this->mActiveConnection == active) {
 		QObject::disconnect(active, nullptr, this, nullptr);
 		this->bState = NMConnectionState::Deactivated;
@@ -281,25 +261,15 @@ void NMWirelessDevice::registerAccessPoint(const QString& path) {
 NMWirelessNetwork* NMWirelessDevice::registerNetwork(const QString& ssid) {
 	// clang-format off
 	auto* backend = new NMWirelessNetwork(ssid, this);
-	backend->setActiveApPath(this->activeApPath());
-	backend->setCaps(this->capabilities());
-	QObject::connect(this, &NMWirelessDevice::activeAccessPointChanged, backend, &NMWirelessNetwork::setActiveApPath);
-	QObject::connect(this, &NMWirelessDevice::capabilitiesChanged, backend, &NMWirelessNetwork::setCaps);
+	backend->bindableActiveApPath().setBinding([this]() { return this->activeApPath().path(); });
+	backend->bindableCapabilities().setBinding([this]() { return this->capabilities(); });
 
 	auto* frontend = new WifiNetwork(ssid, this);
-	frontend->setSignalStrength(backend->signalStrength());
-	frontend->setConnected(backend->state() != NMConnectionState::Deactivated);
-	frontend->setKnown(backend->known());
-	frontend->setNmReason(backend->reason());
-	frontend->setNmSecurity(backend->security());
-	QObject::connect(backend, &NMWirelessNetwork::signalStrengthChanged, frontend, &WifiNetwork::setSignalStrength); 
-	QObject::connect(backend, &NMWirelessNetwork::knownChanged, frontend, &WifiNetwork::setKnown); 
-	QObject::connect(backend, &NMWirelessNetwork::reasonChanged, frontend, &WifiNetwork::setNmReason); 
-	QObject::connect(backend, &NMWirelessNetwork::securityChanged, frontend, &WifiNetwork::setNmSecurity);
-	QObject::connect(backend, &NMWirelessNetwork::stateChanged, frontend, 
-			[frontend](NMConnectionState::Enum state) { frontend->setConnected(state != NMConnectionState::Deactivated ); }
-	);
-	// clang-format on
+	frontend->bindableSignalStrength().setBinding([backend]() { return backend->signalStrength(); });
+	frontend->bindableConnected().setBinding([backend]() { return backend->state() != NMConnectionState::Deactivated; });
+	frontend->bindableKnown().setBinding([backend]() { return backend->known(); });
+	frontend->bindableNmReason().setBinding([backend]() { return backend->reason(); });
+	frontend->bindableNmSecurity().setBinding([backend]() { return backend->security(); });
 	QObject::connect(backend, &NMWirelessNetwork::disappeared, this, [this, frontend, backend]() {
 		QObject::disconnect(backend, nullptr, nullptr, nullptr);
 		emit this->wifiNetworkRemoved(frontend);

src/network/nm/wireless.hpp

@@ -44,25 +44,21 @@ class NMWirelessNetwork: public QObject {
 	[[nodiscard]] NMConnectionSettings* referenceConnection() const { return this->mReferenceConn; };
 	[[nodiscard]] QList<NMAccessPoint*> accessPoints() const { return this->mAccessPoints.values(); };
 	[[nodiscard]] QList<NMConnectionSettings*> connections() const { return this->mConnections.values(); };
+	[[nodiscard]] QBindable<QString> bindableActiveApPath() { return &this->bActiveApPath; };
+	[[nodiscard]] QBindable<NMWirelessCapabilities::Enum> bindableCapabilities() { return &this->bCaps; };
 
-public slots:
-	void setActiveApPath(const QDBusObjectPath& path);
-	void setState(NMConnectionState::Enum state);
-	void setReason(NMConnectionStateReason::Enum reason);
-	void setCaps(NMWirelessCapabilities::Enum caps);
-	
 signals:
 	void signalStrengthChanged(quint8 signal);
 	void stateChanged(NMConnectionState::Enum state);
 	void knownChanged(bool known);
 	void reasonChanged(NMConnectionStateReason::Enum reason);
 	void securityChanged(NMWirelessSecurityType::Enum security);
+	void capabilitiesChanged(NMWirelessCapabilities::Enum caps);
+	void activeApPathChanged(QString path);
 	void disappeared();
 
 private:
 	QString mSsid;
-	QDBusObjectPath mActiveApPath;
-	NMWirelessCapabilities::Enum mCaps = NMWirelessCapabilities::None;
 	QHash<QString, NMAccessPoint*> mAccessPoints;
 	QHash<QString, NMConnectionSettings*> mConnections;
 	NMActiveConnection* mActiveConnection = nullptr;
@@ -75,13 +71,15 @@ public slots:
 	Q_OBJECT_BINDABLE_PROPERTY(NMWirelessNetwork, NMConnectionState::Enum, bState, &NMWirelessNetwork::stateChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(NMWirelessNetwork, NMWirelessSecurityType::Enum, bSecurity, &NMWirelessNetwork::securityChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(NMWirelessNetwork, quint8, bSignalStrength, &NMWirelessNetwork::signalStrengthChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(NMWirelessNetwork, NMWirelessCapabilities::Enum, bCaps, &NMWirelessNetwork::capabilitiesChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(NMWirelessNetwork, QString, bActiveApPath, &NMWirelessNetwork::activeApPathChanged);
 	// clang-format on
 
 	void updateReferenceAp();
 	void updateReferenceConnection();
-	void removeAccessPoint(NMAccessPoint* ap);
-	void removeConnectionSettings(NMConnectionSettings* conn);
-	void removeActiveConnection(NMActiveConnection* active);
+	void removeAccessPoint();
+	void removeConnectionSettings();
+	void removeActiveConnection();
 };
 
 // Proxy of a /org/freedesktop/NetworkManager/Device/* object.
@@ -94,7 +92,7 @@ class NMWirelessDevice: public NMDevice {
 	explicit NMWirelessDevice(const QString& path, QObject* parent = nullptr);
 
 	[[nodiscard]] bool isWirelessValid() const;
-	[[nodiscard]] qint64 getLastScan() { return this->bLastScan; };
+	[[nodiscard]] qint64 lastScan() { return this->bLastScan; };
 	[[nodiscard]] NMWirelessCapabilities::Enum capabilities() { return this->bCapabilities; };
 	[[nodiscard]] const QDBusObjectPath& activeApPath() { return this->bActiveAccessPoint; };