arif/bar
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

fix bar crashing on monitor add/remove

Browse Source
This commit is contained in:
Arif Hasanic
2026-02-09 13:49:52 +01:00
parent a90d1c2f6c
commit e1217305a5
30 changed files with 1186 additions and 247 deletions
Download Patch File Download Diff File Expand all files Collapse all files

89
src/app.cpp
View File

@@ -1,27 +1,89 @@
#include "app.hpp"
#include <glibmm/main.h>
#include <sigc++/sigc++.h>
#include <vector>
#include "connection/dbus/mpris.hpp"
#include "connection/dbus/notification.hpp"
#include "services/notificationController.hpp"
#include "services/textureCache.hpp"
#include "widgets/wallpaperWindow.hpp"
App::App() {
this->app = Gtk::Application::create("org.example.mybar");
App::App() : app(Gtk::Application::create("org.example.mybar")) {
this->setupServices();
this->hyprlandService = HyprlandService::getInstance();
this->notificationService = std::make_shared<NotificationService>();
this->mprisController = MprisController::getInstance();
auto notificationController = NotificationController::getInstance();
this->mprisController->signal_mpris_updated().connect(
[notificationController](const MprisPlayer2Message &msg) {
notificationController->showSpotifyNotification(msg);
[this](const MprisPlayer2Message &msg) {
this->notificationController->showSpotifyNotification(msg);
});
this->hyprlandService->signal_monitor_added().connect([this](std::string monitorName) {
spdlog::info("[App] Monitor added: {}", monitorName);
auto tryCreateBar = [this](const std::string &name) -> bool {
if (bars.find(name) != bars.end()) {
return true;
}
auto display = Gdk::Display::get_default();
if (!display) {
return false;
}
auto monitors = display->get_monitors();
for (guint i = 0; i < monitors->get_n_items(); ++i) {
auto monitor = std::dynamic_pointer_cast<Gdk::Monitor>(
monitors->get_object(i));
if (monitor && monitor->get_connector() == name) {
auto bar = std::make_shared<Bar>(monitor->gobj());
bar->set_application(app);
bar->show();
std::string connectorName = monitor->get_connector();
bar->addLeftWidget(hyprlandService->getWorkspaceIndicatorsForMonitor(connectorName));
hyprlandService->addBar(bar, connectorName);
BarMonitorPair barMonitorPair{.bar = bar, .window = monitor};
bars[connectorName] = barMonitorPair;
if (this->notificationController) {
this->notificationController->addMonitor(monitor);
}
return true;
}
}
return false;
};
if (tryCreateBar(monitorName)) {
return;
}
auto attempts = std::make_shared<int>(0);
Glib::signal_timeout().connect(
[monitorName, attempts, tryCreateBar]() -> bool {
if (*attempts >= 10) {
spdlog::warn("[App] Monitor {} not ready after retries", monitorName);
return false;
}
(*attempts)++;
return !tryCreateBar(monitorName);
},
200);
});
this->hyprlandService->signal_monitor_removed().connect([this](std::string monitorName) {
spdlog::info("[App] Monitor removed: {}", monitorName);
auto bar = bars[monitorName].bar;
if (bar) {
bar->close();
}
bars.erase(monitorName);
});
app->signal_activate().connect([&]() {
auto display = Gdk::Display::get_default();
auto monitors = display->get_monitors();
@@ -40,7 +102,12 @@ App::App() {
bar->addLeftWidget(hyprlandService->getWorkspaceIndicatorsForMonitor(monitorName));
hyprlandService->addBar(bar, monitorName);
bars.push_back(bar);
BarMonitorPair barMonitorPair{.bar = bar, .window = monitor};
bars[monitorName] = barMonitorPair;
if (this->notificationController) {
this->notificationController->addMonitor(monitor);
}
}
}
});

8
src/bar/bar.cpp
View File

@@ -6,6 +6,7 @@
#include <gtkmm/window.h>
#include "components/button/textButton.hpp"
#include "connection/dbus/bluetooth.hpp"
#include "helpers/system.hpp"
#include "widgets/date.hpp"
#include "widgets/spacer.hpp"
@@ -13,10 +14,12 @@
#include "glibmm/main.h"
#include "gtk/gtk.h"
#include "sigc++/functors/mem_fun.h"
Bar::Bar(GdkMonitor *monitor) {
set_name("bar-window");
add_css_class("bar");
auto bluetooh = BluetoothController::getInstance();
gtk_layer_init_for_window(this->gobj());
@@ -32,6 +35,7 @@ Bar::Bar(GdkMonitor *monitor) {
gtk_layer_auto_exclusive_zone_enable(this->gobj());
set_child(main_box);
set_valign(Gtk::Align::CENTER);
this->volumeWidget = std::make_shared<VolumeWidget>();
this->trayWidget = std::make_shared<TrayWidget>();
@@ -43,7 +47,7 @@ Bar::Bar(GdkMonitor *monitor) {
date.onUpdate();
Glib::signal_timeout().connect(sigc::mem_fun(clock, &Clock::onUpdate), 1000);
Glib::signal_timeout().connect(sigc::mem_fun(date, &Date::onUpdate), 1000);
Glib::signal_timeout().connect(sigc::mem_fun(date, &Date::onUpdate), 1000);
}
void Bar::setup_ui() {

2
src/components/button/iconButton.cpp
View File

@@ -2,7 +2,7 @@
IconButton::IconButton(Icon::Type icon, std::string fontFamilyCss) : TextButton(Icon::toString(icon)) {
this->get_style_context()->add_class(fontFamilyCss);
this->add_css_class("icon-button");
this->get_style_context()->add_class("icon-button");
}
void IconButton::setIcon(Icon::Type icon) {

12
src/components/popover.cpp
View File

@@ -7,14 +7,18 @@ Popover::Popover(Icon::Type icon, std::string name) : IconButton(icon) {
set_name(name);
this->add_css_class("material-icons");
popover = std::make_unique<Gtk::Popover>();
popover->set_parent(*this);
popover->set_autohide(true);
}
Popover::~Popover() = default;
Popover::~Popover() {
if (popover) {
popover->popdown();
popover->unparent();
}
};
void Popover::on_toggle_window() {
if (popover->get_visible()) {
@@ -22,4 +26,4 @@ void Popover::on_toggle_window() {
} else {
popover->popup();
}
}
}

448
src/connection/dbus/bluetooth.cpp Normal file
View File

@@ -0,0 +1,448 @@
#include "connection/dbus/bluetooth.hpp"
#include <spdlog/spdlog.h>
// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
BluetoothController::BluetoothController() {
connect_system_async(sigc::mem_fun(*this, &BluetoothController::onBusConnected));
}
// ---------------------------------------------------------------------------
// Signal accessors
// ---------------------------------------------------------------------------
sigc::signal<void(bool)> &BluetoothController::signalPoweredChanged() { return m_powered_signal; }
sigc::signal<void(bool)> &BluetoothController::signalDiscoveringChanged() { return m_discovering_signal; }
sigc::signal<void(const BluetoothDevice &)> &BluetoothController::signalDeviceAdded() { return m_device_added_signal; }
sigc::signal<void(const std::string &)> &BluetoothController::signalDeviceRemoved() { return m_device_removed_signal; }
sigc::signal<void(const BluetoothDevice &)> &BluetoothController::signalDeviceChanged() { return m_device_changed_signal; }
// ---------------------------------------------------------------------------
// Queries
// ---------------------------------------------------------------------------
bool BluetoothController::isPowered() const { return m_powered; }
bool BluetoothController::isDiscovering() const { return m_discovering; }
std::vector<BluetoothDevice> BluetoothController::getDevices() const {
std::vector<BluetoothDevice> result;
result.reserve(m_devices.size());
for (const auto &[_, device] : m_devices) {
result.push_back(device);
}
return result;
}
std::vector<BluetoothDevice> BluetoothController::getPairedDevices() const {
std::vector<BluetoothDevice> result;
for (const auto &[_, device] : m_devices) {
if (device.paired) {
result.push_back(device);
}
}
return result;
}
// ---------------------------------------------------------------------------
// Adapter control
// ---------------------------------------------------------------------------
void BluetoothController::setPowered(bool powered) {
spdlog::info("Bluetooth: setting powered to {}", powered);
setDbusProperty(m_adapter_path, "org.bluez.Adapter1", "Powered",
Glib::Variant<bool>::create(powered));
}
void BluetoothController::startDiscovery() {
spdlog::info("Bluetooth: starting discovery");
if (m_adapter_proxy) {
m_adapter_proxy->call("StartDiscovery");
}
}
void BluetoothController::stopDiscovery() {
spdlog::info("Bluetooth: stopping discovery");
if (m_adapter_proxy) {
m_adapter_proxy->call("StopDiscovery");
}
}
// ---------------------------------------------------------------------------
// Device actions
// ---------------------------------------------------------------------------
void BluetoothController::pairDevice(const std::string &object_path) {
spdlog::info("Bluetooth: pairing device {}", object_path);
auto it = m_device_proxies.find(object_path);
if (it != m_device_proxies.end() && it->second) {
it->second->call("Pair");
}
}
void BluetoothController::unpairDevice(const std::string &object_path) {
spdlog::info("Bluetooth: unpairing device {}", object_path);
if (!m_adapter_proxy) return;
auto params = Glib::VariantContainerBase::create_tuple(
Glib::Variant<Glib::DBusObjectPathString>::create(object_path));
m_adapter_proxy->call("RemoveDevice", params);
}
void BluetoothController::connectDevice(const std::string &object_path) {
spdlog::info("Bluetooth: connecting device {}", object_path);
auto it = m_device_proxies.find(object_path);
if (it != m_device_proxies.end() && it->second) {
it->second->call("Connect");
}
}
void BluetoothController::disconnectDevice(const std::string &object_path) {
spdlog::info("Bluetooth: disconnecting device {}", object_path);
auto it = m_device_proxies.find(object_path);
if (it != m_device_proxies.end() && it->second) {
it->second->call("Disconnect");
}
}
void BluetoothController::trustDevice(const std::string &object_path, bool trusted) {
spdlog::info("Bluetooth: setting trusted={} for device {}", trusted, object_path);
setDbusProperty(object_path, "org.bluez.Device1", "Trusted",
Glib::Variant<bool>::create(trusted));
}
// ---------------------------------------------------------------------------
// Bus connection
// ---------------------------------------------------------------------------
void BluetoothController::onBusConnected(const Glib::RefPtr<Gio::AsyncResult> &result) {
if (!result) {
spdlog::error("Bluetooth: null async result");
return;
}
try {
connection = Gio::DBus::Connection::get_finish(result);
m_object_manager_proxy = Gio::DBus::Proxy::create_sync(
connection,
"org.bluez",
"/",
"org.freedesktop.DBus.ObjectManager");
if (m_object_manager_proxy) {
m_object_manager_proxy->signal_signal().connect(
sigc::mem_fun(*this, &BluetoothController::onObjectManagerSignal));
enumerateObjects();
}
} catch (const Glib::Error &ex) {
spdlog::error("Bluetooth DBus Connection Error: {}", ex.what());
}
}
// ---------------------------------------------------------------------------
// Enumerate existing BlueZ objects
// ---------------------------------------------------------------------------
void BluetoothController::enumerateObjects() {
if (!m_object_manager_proxy) return;
try {
auto result = m_object_manager_proxy->call_sync("GetManagedObjects");
auto objects = Glib::VariantBase::cast_dynamic<Glib::VariantContainerBase>(
result.get_child(0));
for (gsize i = 0; i < objects.get_n_children(); i++) {
auto entry = Glib::VariantBase::cast_dynamic<Glib::VariantContainerBase>(
objects.get_child(i));
auto path = static_cast<std::string>(
Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::DBusObjectPathString>>(
entry.get_child(0))
.get());
parseInterfaces(path, entry.get_child(1));
}
} catch (const Glib::Error &ex) {
spdlog::error("Bluetooth: Error enumerating objects: {}", ex.what());
}
}
// ---------------------------------------------------------------------------
// Parse an interfaces-and-properties dict a{sa{sv}}
// ---------------------------------------------------------------------------
void BluetoothController::parseInterfaces(const std::string &object_path,
const Glib::VariantBase &interfaces_var) {
auto ifaces = Glib::VariantBase::cast_dynamic<Glib::VariantContainerBase>(interfaces_var);
for (gsize i = 0; i < ifaces.get_n_children(); i++) {
auto entry = Glib::VariantBase::cast_dynamic<Glib::VariantContainerBase>(
ifaces.get_child(i));
auto iface_name = static_cast<std::string>(
Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::ustring>>(
entry.get_child(0))
.get());
if (iface_name != "org.bluez.Device1" && iface_name != "org.bluez.Adapter1") {
continue;
}
auto props = Glib::VariantBase::cast_dynamic<Glib::Variant<PropertiesMap>>(
entry.get_child(1))
.get();
if (iface_name == "org.bluez.Device1") {
addDevice(object_path, props);
} else {
setupAdapter(object_path, props);
}
}
}
// ---------------------------------------------------------------------------
// ObjectManager signal handler (InterfacesAdded / InterfacesRemoved)
// ---------------------------------------------------------------------------
void BluetoothController::onObjectManagerSignal(
const Glib::ustring &,
const Glib::ustring &signal_name,
const Glib::VariantContainerBase &parameters) {
if (signal_name == "InterfacesAdded") {
// signature: (oa{sa{sv}})
auto path = static_cast<std::string>(
Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::DBusObjectPathString>>(
parameters.get_child(0))
.get());
parseInterfaces(path, parameters.get_child(1));
} else if (signal_name == "InterfacesRemoved") {
// signature: (oas)
auto path = static_cast<std::string>(
Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::DBusObjectPathString>>(
parameters.get_child(0))
.get());
auto ifaces = Glib::VariantBase::cast_dynamic<
Glib::Variant<std::vector<Glib::ustring>>>(parameters.get_child(1)).get();
for (const auto &iface : ifaces) {
if (iface == "org.bluez.Device1") {
removeDevice(path);
} else if (iface == "org.bluez.Adapter1" && path == m_adapter_path) {
m_adapter_proxy.reset();
m_adapter_path.clear();
m_powered = false;
m_discovering = false;
m_powered_signal.emit(false);
m_discovering_signal.emit(false);
spdlog::info("Bluetooth adapter removed");
}
}
}
}
// ---------------------------------------------------------------------------
// Adapter
// ---------------------------------------------------------------------------
void BluetoothController::setupAdapter(const std::string &path,
const PropertiesMap &properties) {
m_adapter_path = path;
spdlog::info("Bluetooth adapter found: {}", path);
auto it = properties.find("Powered");
if (it != properties.end() && it->second.is_of_type(Glib::VariantType("b"))) {
m_powered = Glib::VariantBase::cast_dynamic<Glib::Variant<bool>>(it->second).get();
m_powered_signal.emit(m_powered);
}
it = properties.find("Discovering");
if (it != properties.end() && it->second.is_of_type(Glib::VariantType("b"))) {
m_discovering = Glib::VariantBase::cast_dynamic<Glib::Variant<bool>>(it->second).get();
m_discovering_signal.emit(m_discovering);
}
try {
m_adapter_proxy = Gio::DBus::Proxy::create_sync(
connection, "org.bluez", path, "org.bluez.Adapter1");
if (m_adapter_proxy) {
m_adapter_proxy->signal_properties_changed().connect(
sigc::mem_fun(*this, &BluetoothController::onAdapterPropertiesChanged));
}
} catch (const Glib::Error &ex) {
spdlog::error("Bluetooth: Error creating adapter proxy: {}", ex.what());
}
}
void BluetoothController::onAdapterPropertiesChanged(
const Gio::DBus::Proxy::MapChangedProperties &changed,
const std::vector<Glib::ustring> &) {
auto it = changed.find("Powered");
if (it != changed.end() && it->second.is_of_type(Glib::VariantType("b"))) {
m_powered = Glib::VariantBase::cast_dynamic<Glib::Variant<bool>>(it->second).get();
spdlog::info("Bluetooth powered: {}", m_powered);
m_powered_signal.emit(m_powered);
}
it = changed.find("Discovering");
if (it != changed.end() && it->second.is_of_type(Glib::VariantType("b"))) {
m_discovering = Glib::VariantBase::cast_dynamic<Glib::Variant<bool>>(it->second).get();
spdlog::info("Bluetooth discovering: {}", m_discovering);
m_discovering_signal.emit(m_discovering);
}
}
// ---------------------------------------------------------------------------
// Device management
// ---------------------------------------------------------------------------
void BluetoothController::addDevice(const std::string &path,
const PropertiesMap &properties) {
auto device = parseDeviceProperties(path, properties);
m_devices[path] = device;
spdlog::info("Bluetooth device added: {} ({}) {}", device.name, device.address, device.icon);
try {
auto proxy = Gio::DBus::Proxy::create_sync(
connection, "org.bluez", path, "org.bluez.Device1");
if (proxy) {
proxy->signal_properties_changed().connect(
[this, path](const Gio::DBus::Proxy::MapChangedProperties &changed,
const std::vector<Glib::ustring> &invalidated) {
onDevicePropertiesChanged(path, changed, invalidated);
});
m_device_proxies[path] = proxy;
}
} catch (const Glib::Error &ex) {
spdlog::error("Bluetooth: Error creating device proxy for {}: {}", path, ex.what());
}
m_device_added_signal.emit(device);
}
void BluetoothController::removeDevice(const std::string &path) {
spdlog::info("Bluetooth device removed: {}", path);
m_devices.erase(path);
m_device_proxies.erase(path);
m_device_removed_signal.emit(path);
}
void BluetoothController::onDevicePropertiesChanged(
const std::string &object_path,
const Gio::DBus::Proxy::MapChangedProperties &changed,
const std::vector<Glib::ustring> &) {
auto it = m_devices.find(object_path);
if (it == m_devices.end()) return;
auto &device = it->second;
for (const auto &[key, value] : changed) {
if (key == "Name" && value.is_of_type(Glib::VariantType("s"))) {
device.name = static_cast<std::string>(
Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::ustring>>(value).get());
} else if (key == "Alias" && value.is_of_type(Glib::VariantType("s"))) {
// Only use Alias as fallback if Name is still the MAC address
auto alias = static_cast<std::string>(
Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::ustring>>(value).get());
if (device.name == device.address) {
device.name = alias;
}
} else if (key == "Paired" && value.is_of_type(Glib::VariantType("b"))) {
device.paired = Glib::VariantBase::cast_dynamic<Glib::Variant<bool>>(value).get();
} else if (key == "Connected" && value.is_of_type(Glib::VariantType("b"))) {
device.connected = Glib::VariantBase::cast_dynamic<Glib::Variant<bool>>(value).get();
} else if (key == "Trusted" && value.is_of_type(Glib::VariantType("b"))) {
device.trusted = Glib::VariantBase::cast_dynamic<Glib::Variant<bool>>(value).get();
} else if (key == "RSSI" && value.is_of_type(Glib::VariantType("n"))) {
device.rssi = Glib::VariantBase::cast_dynamic<Glib::Variant<gint16>>(value).get();
} else if (key == "Icon" && value.is_of_type(Glib::VariantType("s"))) {
device.icon = static_cast<std::string>(
Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::ustring>>(value).get());
}
}
m_device_changed_signal.emit(device);
}
// ---------------------------------------------------------------------------
// Property parsing helper
// ---------------------------------------------------------------------------
BluetoothDevice BluetoothController::parseDeviceProperties(
const std::string &path,
const PropertiesMap &properties) {
BluetoothDevice device;
device.object_path = path;
auto getString = [&](const Glib::ustring &key) -> std::string {
auto it = properties.find(key);
if (it != properties.end() && it->second.is_of_type(Glib::VariantType("s"))) {
return static_cast<std::string>(
Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::ustring>>(it->second).get());
}
return "";
};
auto getBool = [&](const Glib::ustring &key) -> bool {
auto it = properties.find(key);
if (it != properties.end() && it->second.is_of_type(Glib::VariantType("b"))) {
return Glib::VariantBase::cast_dynamic<Glib::Variant<bool>>(it->second).get();
}
return false;
};
device.address = getString("Address");
device.name = getString("Name");
if (device.name.empty()) device.name = getString("Alias");
if (device.name.empty()) device.name = device.address;
device.icon = getString("Icon");
device.paired = getBool("Paired");
device.connected = getBool("Connected");
device.trusted = getBool("Trusted");
auto rssi_it = properties.find("RSSI");
if (rssi_it != properties.end() && rssi_it->second.is_of_type(Glib::VariantType("n"))) {
device.rssi = Glib::VariantBase::cast_dynamic<Glib::Variant<gint16>>(rssi_it->second).get();
}
return device;
}
// ---------------------------------------------------------------------------
// D-Bus property setter (calls org.freedesktop.DBus.Properties.Set)
// ---------------------------------------------------------------------------
void BluetoothController::setDbusProperty(const std::string &object_path,
const std::string &interface,
const std::string &property,
const Glib::VariantBase &value) {
if (!connection || object_path.empty()) return;
try {
auto props_proxy = Gio::DBus::Proxy::create_sync(
connection, "org.bluez", object_path, "org.freedesktop.DBus.Properties");
auto wrapped = Glib::Variant<Glib::VariantBase>::create(value);
auto params = Glib::VariantContainerBase::create_tuple({
Glib::Variant<Glib::ustring>::create(interface),
Glib::Variant<Glib::ustring>::create(property),
wrapped});
props_proxy->call_sync("Set", params);
} catch (const Glib::Error &ex) {
spdlog::error("Error setting {}.{}: {}", interface, property, ex.what());
}
}

34
src/connection/dbus/mpris.cpp
View File

@@ -10,7 +10,10 @@
#include "giomm/dbusproxy.h"
std::shared_ptr<MprisController> MprisController::getInstance() {
static std::shared_ptr<MprisController> instance = std::shared_ptr<MprisController>(new MprisController());
static std::shared_ptr<MprisController> instance;
if (!instance) {
instance = std::shared_ptr<MprisController>(new MprisController());
}
return instance;
}
@@ -18,7 +21,7 @@ std::shared_ptr<MprisController> MprisController::createForPlayer(const std::str
return std::shared_ptr<MprisController>(new MprisController(bus_name));
}
MprisController::MprisController() {
MprisController::MprisController() : m_player_bus_name() {
connect_session_async(sigc::mem_fun(*this, &MprisController::on_bus_connected));
}
@@ -63,6 +66,33 @@ void MprisController::on_bus_connected(const Glib::RefPtr<Gio::AsyncResult> &res
try {
connection = Gio::DBus::Connection::get_finish(result);
// Per-player instances only need to create their own player proxy,
// not monitor all players on the bus.
if (!m_player_bus_name.empty()) {
if (!m_proxy) {
try {
m_proxy = Gio::DBus::Proxy::create_sync(
connection,
m_player_bus_name,
"/org/mpris/MediaPlayer2",
"org.mpris.MediaPlayer2.Player");
if (m_proxy) {
m_proxy->signal_properties_changed().connect(
sigc::mem_fun(*this, &MprisController::on_properties_changed));
signalNotification();
emit_cached_playback_status();
emit_cached_position();
emit_cached_can_seek();
}
} catch (const Glib::Error &ex) {
spdlog::error("DBus Connection Error for player {}: {}", m_player_bus_name, ex.what());
}
}
return;
}
// Singleton instance: monitor all MPRIS players on the bus.
if (!m_dbus_proxy) {
m_dbus_proxy = Gio::DBus::Proxy::create_sync(
connection,

178
src/services/hyprland.cpp
View File

@@ -1,5 +1,6 @@
#include "services/hyprland.hpp"
#include <algorithm>
#include <cstring>
#include <glib-unix.h>
#include <glib.h>
@@ -17,6 +18,9 @@
#include "spdlog/spdlog.h"
HyprlandService::HyprlandService() {
if (instance) {
throw std::runtime_error("HyprlandService instance already exists");
}
init();
this->bindHyprlandSocket();
}
@@ -84,6 +88,9 @@ void HyprlandService::init() {
}
void HyprlandService::bindHyprlandSocket() {
if (socketFd != -1) {
return;
}
std::string socketPath = HyprSocketHelper::getHyprlandSocketPath();
socketFd = socket(AF_UNIX, SOCK_STREAM, 0);
@@ -106,22 +113,25 @@ void HyprlandService::bindHyprlandSocket() {
}
auto socket_conditions = static_cast<GIOCondition>(G_IO_IN | G_IO_HUP | G_IO_ERR); // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
GSource *source = g_unix_fd_source_new(socketFd, socket_conditions);
g_unix_fd_add(
socketFd,
socket_conditions,
[](gint fd, GIOCondition condition, gpointer user_data) -> gboolean {
auto *self = static_cast<HyprlandService *>(user_data);
if (condition & (G_IO_HUP | G_IO_ERR)) {
spdlog::error("[Hyprland] Socket read error or connection closed");
close(fd);
self->socketFd = -1;
return FALSE;
}
auto onSocketEvent = [](gint fd, GIOCondition, gpointer user_data) -> gboolean {
HyprlandService *self = static_cast<HyprlandService *>(user_data);
auto messages = SocketHelper::parseSocketMessage(fd, ">>");
for (const auto &message : messages) {
self->handleSocketMessage(message);
}
return G_SOURCE_CONTINUE;
};
g_source_set_callback(source, reinterpret_cast<GSourceFunc>(reinterpret_cast<void *>(+onSocketEvent)), this, nullptr);
g_source_attach(source, g_main_context_default());
g_source_unref(source);
auto messages = SocketHelper::parseSocketMessage(fd, ">>");
for (const auto &message : messages) {
self->handleSocketMessage(message);
}
return TRUE;
},
this);
}
void HyprlandService::onWorkspaceChanged(int workspaceId) {
@@ -160,20 +170,6 @@ void HyprlandService::onFocusedMonitorChanged(std::string monitorData) {
}
}
void HyprlandService::onMonitorRemoved(std::string monitorName) {
auto monitorPtr = this->monitors[monitorName];
for (const auto &[wsId, wsPtr] : monitorPtr->monitorWorkspaces) {
this->workspaces.erase(wsId);
}
monitorPtr->monitorWorkspaces.clear();
monitorPtr->bar->close();
monitorPtr->bar = nullptr;
this->monitors.erase(monitorName);
}
void HyprlandService::onMoveWindow(std::string windowData) {
auto parts = StringHelper::split(windowData, ',');
std::string addr = "0x" + parts[0];
@@ -270,6 +266,10 @@ void HyprlandService::handleSocketMessage(SocketHelper::SocketMessage message) {
this->onActiveWindowChanged(eventData);
break;
}
case MONITOR_ADDED: {
this->onMonitorAdded(eventData);
break;
}
case MONITOR_REMOVED: {
this->onMonitorRemoved(eventData);
break;
@@ -280,6 +280,108 @@ void HyprlandService::handleSocketMessage(SocketHelper::SocketMessage message) {
}
}
}
void HyprlandService::onMonitorAdded(std::string monitorName) {
spdlog::info("[Hyprland] Monitor added: {}", monitorName);
auto monitorDataJson = HyprctlHelper::getMonitorData();
auto monitorIt = std::ranges::find_if(monitorDataJson,
[&monitorName](const auto &item) {
return item.contains("name") && item["name"] == monitorName;
});
if (monitorIt == monitorDataJson.end()) {
spdlog::warn("[Hyprland] Monitor data not found for {}", monitorName);
return;
}
auto monitorPtr = std::make_shared<Monitor>();
monitorPtr->id = (*monitorIt)["id"];
monitorPtr->name = monitorName;
monitorPtr->activeWorkspaceId = (*monitorIt)["activeWorkspace"]["id"];
monitorPtr->focused = (*monitorIt)["focused"];
this->monitors[monitorName] = monitorPtr;
auto onClick = sigc::mem_fun(*this, &HyprlandService::switchToWorkspace);
for (int i = 1; i <= NUM_WORKSPACES; i++) {
auto state = std::make_shared<WorkspaceData>();
int workspaceId = i + (NUM_WORKSPACES * monitorPtr->id);
state->id = workspaceId;
state->monitorName = monitorName;
auto view = std::make_shared<WorkspaceIndicator>(workspaceId, std::to_string(i), onClick);
auto workSpace = std::make_shared<Workspace>();
workSpace->state = state;
workSpace->view = view;
monitorPtr->monitorWorkspaces[workspaceId] = workSpace;
this->workspaces[workspaceId] = workSpace;
}
auto workspaceDataJson = HyprctlHelper::getWorkspaceData();
for (const auto &workspace : workspaceDataJson) {
if (!workspace.contains("monitor") || workspace["monitor"].get<std::string>() != monitorName) {
continue;
}
auto workspacePtr = workspaces[workspace["id"].get<int>()];
auto state = workspacePtr->state;
state->id = workspace["id"].get<int>();
state->monitorName = workspace["monitor"].get<std::string>();
refreshIndicator(workspacePtr);
}
auto clientsDataJson = HyprctlHelper::getClientData();
for (const auto &client : clientsDataJson) {
auto address = client["address"].get<std::string>();
if (this->clients.find(address) != this->clients.end()) {
continue;
}
int workspaceId = client["workspace"]["id"].get<int>();
auto workspaceIt = workspaces.find(workspaceId);
if (workspaceIt == workspaces.end()) {
continue;
}
if (workspaceIt->second->state->monitorName != monitorName) {
continue;
}
auto clientPtr = std::make_shared<Client>();
clientPtr->address = address;
clientPtr->workspaceId = workspaceId;
clientPtr->title = client["title"].get<std::string>();
this->clients[clientPtr->address] = clientPtr;
workspaceIt->second->state->clients[clientPtr->address] = clientPtr;
if (client.contains("urgent") && client["urgent"].get<bool>()) {
workspaceIt->second->state->urgentClients.insert(clientPtr->address);
}
refreshIndicator(workspaceIt->second);
}
m_signal_monitor_added.emit(monitorName);
}
void HyprlandService::onMonitorRemoved(std::string monitorName) {
spdlog::info("[Hyprland] Monitor removed: {}", monitorName);
auto monitorIt = monitors.find(monitorName);
if (monitorIt == monitors.end()) {
return;
}
auto monitorPtr = monitorIt->second;
for (const auto &[workspaceId, workspacePtr] : monitorPtr->monitorWorkspaces) {
for (const auto &[clientAddr, _] : workspacePtr->state->clients) {
clients.erase(clientAddr);
}
workspaces.erase(workspaceId);
}
this->monitors.erase(monitorIt);
m_signal_monitor_removed.emit(monitorName);
}
void HyprlandService::onUrgent(std::string windowAddress) {
std::string addr = "0x" + windowAddress;
if (this->clients.find(addr) == this->clients.end()) {
@@ -312,7 +414,11 @@ void HyprlandService::onActiveWindowChanged(std::string windowAddress) {
std::shared_ptr<Gtk::Box> HyprlandService::getWorkspaceIndicatorsForMonitor(std::string monitorName) {
auto box = std::make_shared<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
auto monitor = monitors[monitorName];
auto monitorIt = monitors.find(monitorName);
if (monitorIt == monitors.end()) {
return box;
}
auto monitor = monitorIt->second;
for (const auto &[wsId, wsPair] : monitor->monitorWorkspaces) {
box->append((Gtk::Box &)*wsPair->view);
@@ -329,7 +435,11 @@ void HyprlandService::refreshIndicator(std::shared_ptr<Workspace> workspace) {
auto view = workspace->view;
auto state = workspace->state;
auto monitorsPtr = monitors[state->monitorName];
auto monitorIt = monitors.find(state->monitorName);
if (monitorIt == monitors.end()) {
return;
}
auto monitorsPtr = monitorIt->second;
bool isUrgent = !state->urgentClients.empty();
bool isEmpty = state->clients.empty();
@@ -350,5 +460,9 @@ void HyprlandService::refreshIndicator(std::shared_ptr<Workspace> workspace) {
}
void HyprlandService::addBar(std::shared_ptr<Bar> bar, std::string monitorName) {
this->monitors[monitorName]->bar = bar;
auto monitorIt = monitors.find(monitorName);
if (monitorIt == monitors.end()) {
return;
}
monitorIt->second->bar = bar;
}

22
src/services/notificationController.cpp
View File

@@ -12,8 +12,6 @@
#include "gdkmm/display.h"
#include "sigc++/adaptors/bind.h"
std::shared_ptr<NotificationController> NotificationController::instance = nullptr;
NotificationController::NotificationController() {
if (NotificationController::instance) {
throw std::runtime_error("use getInstance()!");
@@ -32,8 +30,8 @@ NotificationController::NotificationController() {
for (guint i = 0; i < monitors->get_n_items(); ++i) {
auto monitor = std::dynamic_pointer_cast<Gdk::Monitor>(
monitors->get_object(i));
this->activeMonitors.push_back(monitor);
auto name = monitor->get_connector();
this->activeMonitors[name] = monitor;
}
}
@@ -41,7 +39,7 @@ void NotificationController::showNotificationOnAllMonitors(NotifyMessage notify)
uint64_t id = this->globalNotificationId++;
std::vector<std::shared_ptr<BaseNotification>> notifications;
for (const auto &monitor : this->activeMonitors) {
for (const auto &[name, monitor] : this->activeMonitors) {
auto notification = std::make_shared<NotificationWindow>(id, monitor, notify);
notifications.push_back(notification);
@@ -74,7 +72,7 @@ void NotificationController::showCopyNotification(NotifyMessage notify) {
std::vector<std::shared_ptr<BaseNotification>> notifications;
uint64_t id = this->globalNotificationId++;
for (const auto &monitor : this->activeMonitors) {
for (const auto &[name, monitor] : this->activeMonitors) {
auto notification = std::make_shared<CopyNotification>(id, monitor, notify);
notification->show();
@@ -97,7 +95,7 @@ void NotificationController::showSpotifyNotification(MprisPlayer2Message mpris)
std::vector<std::shared_ptr<BaseNotification>> notifications;
uint64_t id = this->globalNotificationId++;
for (const auto &monitor : this->activeMonitors) {
for (const auto &[name, monitor] : this->activeMonitors) {
auto notification = std::make_shared<SpotifyNotification>(id, monitor, mpris);
notification->show();
@@ -153,4 +151,14 @@ void NotificationController::closeNotification(uint64_t notificationId) {
this->activeNotifications.erase(notificationId);
this->hoverCounts.erase(notificationId);
}
void NotificationController::addMonitor(std::shared_ptr<Gdk::Monitor> monitor) {
auto name = monitor->get_connector();
this->activeMonitors[name] = monitor;
}
void NotificationController::removeMonitor(std::shared_ptr<Gdk::Monitor> monitor) {
auto name = monitor->get_connector();
this->activeMonitors.erase(name);
}

81
src/widgets/controlCenter/bluetoothSettings.cpp Normal file
View File

@@ -0,0 +1,81 @@
#include "widgets/controlCenter/bluetoothSettings.hpp"
#include <memory>
void BluetoothSettings::setBluetoothPowered(bool powered) {
this->bluetoothIsPowered = powered;
if (powered) {
powerButton->remove_css_class("power-button-off");
powerButton->add_css_class("power-button-on");
powerButton->set_tooltip_text("Turn Bluetooth Off");
} else {
powerButton->remove_css_class("power-button-on");
powerButton->add_css_class("power-button-off");
powerButton->set_tooltip_text("Turn Bluetooth On");
}
}
void BluetoothSettings::setScanning(bool scanning) {
this->bluetoothIsScanning = scanning;
if (scanning) {
scanButton->add_css_class("power-button-on");
scanButton->remove_css_class("power-button-off");
scanButton->set_tooltip_text("Stop Scanning");
} else {
scanButton->remove_css_class("power-button-on");
scanButton->add_css_class("power-button-off");
scanButton->set_tooltip_text("Start Scanning");
}
}
BluetoothSettings::BluetoothSettings() : bluetoothIsPowered(this->bluetoothController->isPowered()) {
set_orientation(Gtk::Orientation::VERTICAL);
set_spacing(12);
auto devices = this->bluetoothController->getDevices();
powerButton->add_css_class("power-button");
setBluetoothPowered(bluetoothIsPowered);
powerButton->set_tooltip_text(bluetoothIsPowered ? "Turn Bluetooth Off" : "Turn Bluetooth On");
powerButton->signal_clicked().connect([this]() {
bluetoothIsPowered = !bluetoothIsPowered;
this->bluetoothController->setPowered(bluetoothIsPowered);
});
append(*powerButton);
this->bluetoothController->signalPoweredChanged().connect([this](bool powered) {
bluetoothIsPowered = powered;
setBluetoothPowered(powered);
});
for (const auto &device : devices) {
auto row = std::make_shared<BluetoothSettingsRow>(device);
deviceRows[device.object_path] = row;
append(*row);
}
bluetoothController->signalDeviceAdded().connect([this](const BluetoothDevice &device) {
auto row = std::make_shared<BluetoothSettingsRow>(device);
deviceRows[device.object_path] = row;
append(*row);
});
bluetoothController->signalDeviceRemoved().connect([this](const std::string &object_path) {
auto it = deviceRows.find(object_path);
if (it != deviceRows.end()) {
remove(*it->second);
deviceRows.erase(it);
}
});
bluetoothController->signalDeviceChanged().connect([this](const BluetoothDevice &device) {
auto it = deviceRows.find(device.object_path);
if (it != deviceRows.end()) {
it->second->updateDevice(device);
}
});
}

7
src/widgets/controlCenter/controlCenter.cpp
View File

@@ -27,10 +27,12 @@ ControlCenter::ControlCenter(Icon::Type icon, std::string name)
this->mediaTabButton = std::make_unique<TabButton>(Icon::PLAY_CIRCLE);
this->infoTabButton = std::make_unique<TabButton>(Icon::EMPTY_DASHBOARD);
this->timerButton = std::make_unique<TabButton>(Icon::TOKEN);
this->settingsTabButton = std::make_unique<TabButton>(Icon::SETTINGS);
this->tabRow.append(*this->mediaTabButton);
this->tabRow.append(*this->infoTabButton);
this->tabRow.append(*this->timerButton);
this->tabRow.append(*this->settingsTabButton);
this->container.append(this->tabRow);
@@ -41,10 +43,12 @@ ControlCenter::ControlCenter(Icon::Type icon, std::string name)
this->mediaControlWidget = std::make_unique<MediaWidget>();
this->weatherWidget = std::make_unique<WeatherWidget>();
this->timerWidget = std::make_unique<TimerWidget>();
this->settingsWidget = std::make_unique<SettingsWidget>();
this->contentStack.add(*this->mediaControlWidget, "controls", "Controls");
this->contentStack.add(*this->weatherWidget, "info", "Info");
this->contentStack.add(*this->timerWidget, "timer", "Timer");
this->contentStack.add(*this->settingsWidget, "settings", "Settings");
this->contentStack.set_visible_child("controls");
this->setActiveTab("controls");
@@ -63,6 +67,9 @@ ControlCenter::ControlCenter(Icon::Type icon, std::string name)
this->setActiveTab("timer");
});
this->settingsTabButton->signal_clicked().connect([this]() {
this->setActiveTab("settings");
});
}
void ControlCenter::setActiveTab(const std::string &tab_name) {

8
src/widgets/controlCenter/settings.cpp Normal file
View File

@@ -0,0 +1,8 @@
#include "widgets/controlCenter/settings.hpp"
SettingsWidget::SettingsWidget() {
set_orientation(Gtk::Orientation::VERTICAL);
set_spacing(12);
this->append(this->bluetoothSettings);
}

23
src/widgets/controlCenter/timer.cpp
View File

@@ -15,19 +15,19 @@ TimerWidget::TimerWidget() {
set_orientation(Gtk::Orientation::VERTICAL);
set_spacing(6);
this->timerService->getSignalTimerSet().connect([this](const std::string &duration, uint64_t timerId) {
this->timerSetConnection = this->timerService->getSignalTimerSet().connect([this](const std::string &duration, uint64_t timerId) {
this->addTimer(duration, timerId);
});
this->timerService->getSignalTimerCancelled().connect([this](uint64_t timerId) {
this->timerCancelledConnection = this->timerService->getSignalTimerCancelled().connect([this](uint64_t timerId) {
this->removeTimer(timerId);
});
this->timerService->getSignalTimerExpired().connect([this](uint64_t timerId) {
this->timerExpiredConnection = this->timerService->getSignalTimerExpired().connect([this](uint64_t timerId) {
this->activateTimer(timerId);
});
this->timerService->tickSignal.connect([this]() {
this->tickConnection = this->timerService->tickSignal.connect([this]() {
for (auto &[id, timer] : activeTimers) {
timer->tickDown();
}
@@ -101,6 +101,21 @@ TimerWidget::TimerWidget() {
append(*entry);
}
TimerWidget::~TimerWidget() {
if (this->timerSetConnection.connected()) {
this->timerSetConnection.disconnect();
}
if (this->timerCancelledConnection.connected()) {
this->timerCancelledConnection.disconnect();
}
if (this->timerExpiredConnection.connected()) {
this->timerExpiredConnection.disconnect();
}
if (this->tickConnection.connected()) {
this->tickConnection.disconnect();
}
};
void TimerWidget::addTimer(const std::string &duration, uint64_t timerId) {
std::unique_ptr<Timer> timer = std::make_unique<Timer>(duration, timerId);

1
src/widgets/tray.cpp
View File

@@ -266,6 +266,7 @@ void TrayIconWidget::update(const TrayService::Item &item) {
picture.set_visible(true);
image.set_visible(false);
} else if (!item.iconName.empty()) {
spdlog::info("App {} requesting icon name: {}", id, item.iconName); // Add this
image.set_from_icon_name(item.iconName);
image.set_pixel_size(20);
image.set_visible(true);

89
src/widgets/wallpaperWindow.cpp
View File

@@ -1,89 +0,0 @@
#include "widgets/wallpaperWindow.hpp"
#include <cstdlib>
#include <filesystem>
#include <gdk/gdk.h>
#include <spdlog/spdlog.h>
#include "giomm/file.h"
WallpaperWindow::WallpaperWindow(GdkMonitor *monitor, const std::string &imagePath) {
set_name("wallpaper-window");
set_resizable(false);
set_focusable(false);
gtk_layer_init_for_window(gobj());
if (monitor) {
gtk_layer_set_monitor(gobj(), monitor);
}
gtk_layer_set_layer(gobj(), GTK_LAYER_SHELL_LAYER_BACKGROUND);
gtk_layer_set_anchor(gobj(), GTK_LAYER_SHELL_EDGE_TOP, true);
gtk_layer_set_anchor(gobj(), GTK_LAYER_SHELL_EDGE_BOTTOM, true);
gtk_layer_set_anchor(gobj(), GTK_LAYER_SHELL_EDGE_LEFT, true);
gtk_layer_set_anchor(gobj(), GTK_LAYER_SHELL_EDGE_RIGHT, true);
gtk_layer_set_exclusive_zone(gobj(), 0);
gtk_layer_set_keyboard_mode(gobj(), GTK_LAYER_SHELL_KEYBOARD_MODE_NONE);
picture.set_hexpand(true);
picture.set_vexpand(true);
picture.set_halign(Gtk::Align::FILL);
picture.set_valign(Gtk::Align::FILL);
picture.set_can_shrink(true);
picture.set_content_fit(Gtk::ContentFit::COVER);
if (monitor) {
GdkRectangle geom{};
gdk_monitor_get_geometry(monitor, &geom);
set_default_size(geom.width, geom.height);
set_size_request(geom.width, geom.height);
picture.set_size_request(geom.width, geom.height);
}
auto resolved_path = expand_user_path(imagePath);
if (auto texture = load_texture(resolved_path)) {
picture.set_paintable(texture);
} else {
spdlog::warn("Wallpaper image failed to load: {}", resolved_path);
}
set_child(picture);
}
std::string WallpaperWindow::expand_user_path(const std::string &path) {
if (path.rfind("~/", 0) != 0) {
return path;
}
const char *home = std::getenv("HOME");
if (!home || !*home) {
return path;
}
return std::filesystem::path(home) / path.substr(2);
}
Glib::RefPtr<Gdk::Texture> WallpaperWindow::load_texture(const std::string &path) {
if (path.empty()) {
spdlog::warn("Wallpaper image path is empty");
return {};
}
if (!std::filesystem::exists(path)) {
spdlog::warn("Wallpaper image not found at path: {}", path);
return {};
}
try {
auto file = Gio::File::create_for_path(path);
return Gdk::Texture::create_from_file(file);
} catch (const std::exception &ex) {
spdlog::warn("Failed to load wallpaper image {}: {}", path, ex.what());
return {};
} catch (...) {
spdlog::warn("Failed to load wallpaper image {}: unknown error", path);
return {};
}
}