deine cousine

.clang-format

@@ -1 +1,3 @@
 IndentWidth: 4
+ColumnLimit: 0
+AlignConsecutiveAssignments: true

include/bar/bar.hpp

@@ -2,7 +2,7 @@
 
 #include <gtk4-layer-shell/gtk4-layer-shell.h>
 #include <gtkmm.h>
-
+#include "icons.hpp"
 #include "services/hyprland.hpp"
 #include "services/tray.hpp"
 #include "widgets/clock.hpp"
@@ -10,7 +10,6 @@
 #include "widgets/tray.hpp"
 #include "widgets/webWidget.hpp"
 #include "widgets/workspaceIndicator.hpp"
-#include "icons.hpp"
 
 class Bar : public Gtk::Window {
   public:
@@ -26,8 +25,8 @@ class Bar : public Gtk::Window {
   private:
     Clock clock;
     Date date;
-    WebWidget homeAssistant {ICON_HOME, "Home Assistant",
+    WebWidget homeAssistant{ICON_HOME, "Home Assistant",
-                                "https://home.rivercry.com"};
+                            "https://home.rivercry.com"};
     TrayService &trayService;
     HyprlandService &hyprlandService;
     int monitorId;

include/services/hyprland.hpp

@@ -2,30 +2,37 @@
 
 #include <cstddef>
 #include <glibmm.h>
-#include <iostream>
 #include <map>
 #include <sigc++/sigc++.h>
 #include <string>
+#include <vector>
 
 class HyprlandService {
   public:
-    static constexpr int kWorkspaceSlotCount = 5;
+    static constexpr int kWorkspaceSlotCount = 7;
+    const char *kMonitorCommand              = "hyprctl monitors -j";
+    const char *kWorkspaceCommand            = "hyprctl workspaces -j";
+    const char *kClientsCommand              = "hyprctl clients -j";
+
+    struct WindowState {
+        int hyprId = -1;
+    };
 
     struct WorkspaceState {
-        int id = -1;
+        int hyprId    = -1;
-        int hyprId = -1;
+        int monitorId = -1;
-        bool active = false;
+        bool active   = false;
-        bool focused = false;
+        bool focused  = false;
-        bool urgent = false;
+        std::vector<std::string> urgentWindows;
         std::string label;
     };
 
     struct Monitor {
-        std::map<int, WorkspaceState> workspaceStates;
+        std::map<int, WorkspaceState *> workspaceStates;
         std::string name;
-        int x = 0;
+        int x                  = 0;
-        int y = 0;
+        int y                  = 0;
-        int id = -1;
+        int id                 = -1;
         int focusedWorkspaceId = -1;
     };
 
@@ -34,69 +41,32 @@ class HyprlandService {
 
     void start();
     void on_hyprland_event(std::string event, std::string data);
-
     void printMonitor(const Monitor &mon) const;
 
     sigc::signal<void(std::string, std::string)> socketEventSignal;
-    sigc::signal<void(int)> workspaceStateChanged;
+    sigc::signal<void()> workspaceStateChanged;
     sigc::signal<void()> monitorStateChanged;
 
     Monitor *getMonitorById(int id);
-    const Monitor *getMonitorById(int id) const;
     Monitor *getMonitorByIndex(std::size_t index);
-    const Monitor *getMonitorByIndex(std::size_t index) const;
-    // Switch to a workspace slot on a given monitor. If the workspace has an
-    // associated Hyprland workspace id (hyprId >= 0) that id will be used.
-    // Otherwise the slot and monitor name will be used to request creation
-    // / activation via `hyprctl`.
     void switchToWorkspace(int workspaceId);
 
+    std::map<int, WorkspaceState *> getAllWorkspaces() const {
+        return this->workspaces;
+    }
+
   private:
     int fd = -1;
-    std::string buffer;
     std::map<int, Monitor> monitors;
+    std::map<int, WorkspaceState *> workspaces;
+    // persistent buffer for socket reads to handle partial messages
+    std::string socket_buffer;
 
+    std::string get_socket_path();
     bool on_socket_read(Glib::IOCondition condition);
     void parse_message(const std::string &line);
-    std::string get_socket_path();
     void refresh_monitors();
     void refresh_workspaces();
-    void handle_urgent_window(std::string windowAddress);
+    void onUrgentEvent(std::string windowAddress);
+    void onActiveWindowEvent(std::string windowAddress);
 };
-
-inline void HyprlandService::printMonitor(const Monitor &mon) const {
-    std::cout << "=== Monitor Info ===\n";
-    std::cout << "Name: " << mon.name << " (ID: " << mon.id << ")\n";
-    std::cout << "Position: (" << mon.x << ", " << mon.y << ")\n";
-    std::cout << "Focused Workspace ID: " << mon.focusedWorkspaceId << "\n";
-
-    std::cout << "Workspaces:\n";
-
-    if (mon.workspaceStates.empty()) {
-        std::cout << "  (None)\n";
-    } else {
-        for (int slot = 1; slot <= HyprlandService::kWorkspaceSlotCount;
-             ++slot) {
-            const auto it = mon.workspaceStates.find(slot);
-            if (it == mon.workspaceStates.end()) {
-                std::cout << "  - [Slot: " << slot << " | HyprID: n/a]"
-                          << " Label: <none> | Active: No | Focused: No | "
-                             "Urgent: No\n";
-                continue;
-            }
-
-            const WorkspaceState &ws = it->second;
-            std::cout << "  - [Slot: " << ws.id << " | HyprID: "
-                      << (ws.hyprId >= 0 ? std::to_string(ws.hyprId)
-                                         : std::string("n/a"))
-                      << "] "
-                      << "Label: " << (ws.label.empty() ? "<none>" : ws.label)
-                      << " | "
-                      << "Active: " << (ws.active ? "Yes" : "No") << " | "
-                      << "Focused: " << (ws.focused ? "Yes" : "No") << " | "
-                      << "Urgent: " << (ws.urgent ? "Yes" : "No") << "\n";
-        }
-    }
-
-    std::cout << "====================\n";
-}

include/widgets/workspaceIndicator.hpp

@@ -2,6 +2,7 @@
 
 #include <gtkmm/box.h>
 #include <gtkmm/label.h>
+#include <gtkmm/gestureclick.h>
 #include <sigc++/connection.h>
 
 #include "services/hyprland.hpp"
@@ -16,9 +17,11 @@ class WorkspaceIndicator : public Gtk::Box {
     int monitorId;
     sigc::connection workspaceConnection;
     sigc::connection monitorConnection;
+    std::map<int, Gtk::Label *> workspaceLabels;
+      std::map<int, Glib::RefPtr<Gtk::GestureClick>> workspaceGestures;
 
     void rebuild();
-    void on_workspace_update(int monitorId);
+    void on_workspace_update();
     void on_monitor_update();
-    void clear_children();
+    void refreshLabel(Gtk::Label *label, const HyprlandService::WorkspaceState &state);
 };

resources/bar.css

@@ -22,11 +22,19 @@ window {
     border-radius: 5px;
 }
 
+.workspace-pill:hover {
+    background-color: rgba(255, 255, 255, 0.1);
+}
+
 .workspace-pill-focused {
     background-color: #ffffff;
     color: #1e1e1e;
     font-weight: bold;
-    border-bottom: #89b4fa 2px;
+    box-shadow: 0 0 6px rgba(255, 255, 255, 0.8);
+}
+
+.workspace-pill-focused:hover {
+    box-shadow: none;
 }
 
 .workspace-pill-active {
@@ -36,16 +44,30 @@ window {
 .workspace-pill-urgent {
     background-color: #ff5555;
     color: #fff;
+
+    /* base glow (will be animated) */
+    animation: workspace-blink 1s linear infinite;
+}
+
+/* blinking animation for urgent workspaces */
+@keyframes workspace-blink {
+    0% {
+        opacity: 1;
+    }
+
+    50% {
+        opacity: 0.5;
+    }
+
+    100% {
+        opacity: 1;
+    }
 }
 
 .workspace-pill:last-child {
     margin-right: 0;
 }
 
-.workspace-pill:hover {
-    background-color: rgba(255, 255, 255, 0.1);
-}
-
 .minimized {
     background-color: rgba(50, 50, 50, 0.5);
 }
@@ -86,6 +108,6 @@ tooltip {
 }
 
 .icon-label {
-    font-family: "Material Icons, Hack Nerd Font Mono";
+    font-family: "Material Icons, Font Awesome 7 Brands, Hack Nerd Font Mono";
     font-size: 19px;
-}
+}

src/app.cpp

@@ -10,7 +10,7 @@ App::App() {
     this->app = Gtk::Application::create("org.example.mybar");
 
     app->signal_activate().connect([&]() {
-        auto display = Gdk::Display::get_default();
+        auto display  = Gdk::Display::get_default();
         auto monitors = display->get_monitors();
 
         for (guint i = 0; i < monitors->get_n_items(); ++i) {

src/bar/bar.cpp

@@ -1,5 +1,7 @@
 #include "bar/bar.hpp"
+
 #include "gtk/gtk.h"
+
 #include "widgets/date.hpp"
 #include "widgets/spacer.hpp"
 #include "widgets/volumeWidget.hpp"
@@ -30,12 +32,12 @@ Bar::Bar(GdkMonitor *monitor, HyprlandService &hyprlandService,
     gtk_layer_set_anchor(this->gobj(), GTK_LAYER_SHELL_EDGE_TOP, true);
     gtk_layer_set_anchor(this->gobj(), GTK_LAYER_SHELL_EDGE_LEFT, true);
     gtk_layer_set_anchor(this->gobj(), GTK_LAYER_SHELL_EDGE_RIGHT, true);
+    gtk_layer_set_layer(this->gobj(), GTK_LAYER_SHELL_LAYER_TOP);
 
     gtk_layer_auto_exclusive_zone_enable(this->gobj());
 
     set_child(main_box);
 
-
     this->volumeWidget = Gtk::make_managed<VolumeWidget>();
 
     load_css();
@@ -46,13 +48,9 @@ Bar::Bar(GdkMonitor *monitor, HyprlandService &hyprlandService,
     Glib::signal_timeout().connect(sigc::mem_fun(clock, &Clock::onUpdate),
                                    1000);
 
-
     date.onUpdate();
 
-    Glib::signal_timeout().connect(sigc::mem_fun(date, &Date::onUpdate),
+    Glib::signal_timeout().connect(sigc::mem_fun(date, &Date::onUpdate), 1000);
-                                   1000);
-
-    
 }
 
 void Bar::setup_ui() {
@@ -65,15 +63,14 @@ void Bar::setup_ui() {
 
     left_box.set_valign(Gtk::Align::CENTER);
 
-    // Don't expand the center box — keep it centered by alignment
     center_box.set_hexpand(false);
     center_box.set_valign(Gtk::Align::CENTER);
     center_box.set_halign(Gtk::Align::CENTER);
 
     right_box.set_valign(Gtk::Align::CENTER);
 
-    workspaceIndicator =
+    workspaceIndicator = Gtk::make_managed<WorkspaceIndicator>(hyprlandService, monitorId);
-        Gtk::make_managed<WorkspaceIndicator>(hyprlandService, monitorId);
+    
     left_box.append(*workspaceIndicator);
 
     clock.set_name("clock-label");
@@ -83,7 +80,6 @@ void Bar::setup_ui() {
     center_box.append(*(new Spacer()));
     center_box.append(*this->volumeWidget);
 
-
     trayWidget = Gtk::make_managed<TrayWidget>(trayService);
     right_box.append(*trayWidget);
     right_box.append(homeAssistant);
@@ -93,16 +89,16 @@ void Bar::load_css() {
     auto css_provider = Gtk::CssProvider::create();
 
     std::string css_path = "resources/bar.css";
-    const char* home = std::getenv("HOME");
+    const char *home     = std::getenv("HOME");
     if (home) {
-        std::filesystem::path config_path = std::filesystem::path(home) / ".config/bar/bar.css";
+        std::filesystem::path config_path =
+            std::filesystem::path(home) / ".config/bar/bar.css";
         if (std::filesystem::exists(config_path)) {
             css_path = config_path.string();
         }
     }
 
-    const std::string css =
+    const std::string css = SystemHelper::read_file_to_string(css_path);
-        SystemHelper::read_file_to_string(css_path);
     css_provider->load_from_data(css);
 
     Gtk::StyleContext::add_provider_for_display(

src/services/hyprland.cpp

@@ -14,16 +14,6 @@
 
 #include "helpers/systemHelper.hpp"
 
-namespace {
-const char *kMonitorCommand = "hyprctl monitors -j";
-const char *kWorkspaceCommand = "hyprctl workspaces -j";
-const char *kClientsCommand = "hyprctl clients -j";
-
-bool is_workspace_event(const std::string &event) {
-    return event.find("workspace") != std::string::npos;
-}
-} // namespace
-
 HyprlandService::HyprlandService() = default;
 
 HyprlandService::~HyprlandService() {
@@ -31,18 +21,35 @@ HyprlandService::~HyprlandService() {
         close(fd);
         fd = -1;
     }
+
+    // free allocated workspace pointers
+    for (auto &p : this->workspaces) {
+        delete p.second;
+    }
+    this->workspaces.clear();
+    this->monitors.clear();
 }
 
 void HyprlandService::on_hyprland_event(std::string event, std::string data) {
+    
     if (event == "urgent") {
-        handle_urgent_window(data);
+        onUrgentEvent(data);
     }
 
-    if (is_workspace_event(event) || event == "focusedmon" ||
+    if (event == "activewindowv2") {
-        event == "monitoradded" || event == "monitorremoved") {
+        onActiveWindowEvent(data);
-        refresh_monitors();
+    }
+   
+    if (event == "workspace" || event == "movewindow") {
         refresh_workspaces();
     }
+
+    // use for
+    //  event == "focusedmon"
+
+   if (event == "monitoradded" || event == "monitorremoved") {
+        refresh_monitors();
+    }
 }
 
 void HyprlandService::start() {
@@ -79,34 +86,41 @@ void HyprlandService::start() {
             Glib::IOCondition::IO_ERR);
 
     refresh_monitors();
-    refresh_workspaces();
 }
 
 bool HyprlandService::on_socket_read(Glib::IOCondition condition) {
-    const auto error_mask =
+    const auto error_mask = Glib::IOCondition::IO_HUP | Glib::IOCondition::IO_ERR;
-        Glib::IOCondition::IO_HUP | Glib::IOCondition::IO_ERR;
 
     if (static_cast<int>(condition & error_mask) != 0) {
         std::cerr << "[Hyprland] Socket disconnected." << std::endl;
-        close(fd);
+        if (fd != -1) {
-        fd = -1;
+            close(fd);
+            fd = -1;
+        }
         return false;
     }
 
-    char buffer[4096];
+    char temp_buffer[4096];
-    const ssize_t bytes_read = read(fd, buffer, sizeof(buffer) - 1);
+    const ssize_t bytes_read = read(fd, temp_buffer, sizeof(temp_buffer));
 
-    if (bytes_read > 0) {
+    if (bytes_read <= 0) {
-        buffer[bytes_read] = '\0';
+        // peer closed or error
-        this->buffer.append(buffer);
+        std::cerr << "[Hyprland] Socket read returned " << bytes_read << std::endl;
-
+        if (fd != -1) {
-        size_t pos = 0;
+            close(fd);
-
+            fd = -1;
-        while ((pos = this->buffer.find('\n')) != std::string::npos) {
-            const std::string line = this->buffer.substr(0, pos);
-            parse_message(line);
-            this->buffer.erase(0, pos + 1);
         }
+        return false;
+    }
+
+    // append exactly bytes_read bytes (may contain embedded nulls)
+    this->socket_buffer.append(temp_buffer, static_cast<size_t>(bytes_read));
+
+    size_t pos = 0;
+    while ((pos = this->socket_buffer.find('\n')) != std::string::npos) {
+        const std::string line = this->socket_buffer.substr(0, pos);
+        parse_message(line);
+        this->socket_buffer.erase(0, pos + 1);
     }
 
     return true;
@@ -123,7 +137,7 @@ void HyprlandService::parse_message(const std::string &line) {
 }
 
 std::string HyprlandService::get_socket_path() {
-    const char *sig = std::getenv("HYPRLAND_INSTANCE_SIGNATURE");
+    const char *sig     = std::getenv("HYPRLAND_INSTANCE_SIGNATURE");
     const char *runtime = std::getenv("XDG_RUNTIME_DIR");
 
     if (!sig || !runtime) {
@@ -135,177 +149,94 @@ std::string HyprlandService::get_socket_path() {
 }
 
 void HyprlandService::refresh_monitors() {
-    std::string output;
+    // free any previously allocated WorkspaceState objects before rebuilding
-
+    for (auto &p : this->workspaces) {
-    try {
+        delete p.second;
-        output = SystemHelper::get_command_output(kMonitorCommand);
-    } catch (const std::exception &ex) {
-        std::cerr << "[Hyprland] Failed to query monitors: " << ex.what()
-                  << std::endl;
-        return;
     }
+    this->workspaces.clear();
+    this->monitors.clear();
 
-    auto monitorsJson = nlohmann::json::parse(output, nullptr, false);
+    std::string output = SystemHelper::get_command_output(kMonitorCommand);
-    if (!monitorsJson.is_array()) {
+    auto monitorsJson  = nlohmann::json::parse(output, nullptr, false);
-        std::cerr << "[Hyprland] Unexpected monitor payload" << std::endl;
-        return;
-    }
-
-    std::map<int, Monitor> updated;
 
     for (const auto &monitorJson : monitorsJson) {
-        if (!monitorJson.is_object()) {
-            continue;
-        }
-
         Monitor monitor;
-        monitor.id = monitorJson.value("id", -1);
+        monitor.id   = monitorJson.value("id", -1);
         monitor.name = monitorJson.value("name", "");
-        monitor.x = monitorJson.value("x", 0);
+        monitor.x    = monitorJson.value("x", 0);
-        monitor.y = monitorJson.value("y", 0);
+        monitor.y    = monitorJson.value("y", 0);
 
-        if (monitorJson.contains("activeWorkspace") &&
+        monitor.focusedWorkspaceId = monitorJson["activeWorkspace"].value("id", -1);
-            monitorJson["activeWorkspace"].is_object()) {
-            monitor.focusedWorkspaceId =
-                monitorJson["activeWorkspace"].value("id", -1);
-        }
 
         if (monitor.id >= 0) {
-            updated.emplace(monitor.id, std::move(monitor));
+            this->monitors[monitor.id] = monitor;
+        }
+
+        for (int slot = 1; slot <= HyprlandService::kWorkspaceSlotCount; ++slot) {
+            WorkspaceState wsState;
+            wsState.focused   = false;
+            wsState.active    = false;
+            wsState.label     = std::to_string(slot);
+            wsState.monitorId = monitor.id;
+
+            int id                 = slot + monitor.id * HyprlandService::kWorkspaceSlotCount;
+            wsState.hyprId         = id;
+            this->workspaces[id]   = new WorkspaceState(wsState);
+            if (monitor.id >= 0) {
+                this->monitors[monitor.id].workspaceStates[slot] = this->workspaces[id];
+            }
         }
     }
 
-    monitors.swap(updated);
+    this->refresh_workspaces();
     monitorStateChanged.emit();
 }
 
+/**
+ * Called every time when workspace changes have been detected.
+ * Used to Update the internal state for the Workspaces,
+ */
 void HyprlandService::refresh_workspaces() {
-    if (monitors.empty()) {
+    std::string output  = SystemHelper::get_command_output(kWorkspaceCommand);
-        return;
-    }
-
-    std::string output;
-
-    try {
-        output = SystemHelper::get_command_output(kWorkspaceCommand);
-    } catch (const std::exception &ex) {
-        std::cerr << "[Hyprland] Failed to query workspaces: " << ex.what()
-                  << std::endl;
-        return;
-    }
-
     auto workspacesJson = nlohmann::json::parse(output, nullptr, false);
-    if (!workspacesJson.is_array()) {
+
-        std::cerr << "[Hyprland] Unexpected workspace payload" << std::endl;
+    for (auto &[id, ws] : this->workspaces) {
-        return;
+        ws->focused = false;
+        ws->active  = false;
     }
 
-    for (auto &pair : monitors) {
+    output            = SystemHelper::get_command_output(kMonitorCommand);
-        auto &monitor = pair.second;
+    auto monitorsJson = nlohmann::json::parse(output, nullptr, false);
-        monitor.workspaceStates.clear();
 
-        int focusedSlot = -1;
+    for (const auto &monitorJson : monitorsJson) {
-        if (monitor.focusedWorkspaceId > 0) {
+        const int monitorId          = monitorJson.value("id", -1);
-            focusedSlot = ((monitor.focusedWorkspaceId - 1) %
+        const int focusedWorkspaceId = monitorJson["activeWorkspace"].value("id", -1);
-                           HyprlandService::kWorkspaceSlotCount) +
-                          1;
-        }
 
-        for (int slot = 1; slot <= HyprlandService::kWorkspaceSlotCount;
+        // write into the stored monitor (use reference)
-             ++slot) {
+        auto it = this->monitors.find(monitorId);
-            WorkspaceState state;
+        if (it != this->monitors.end()) {
-            state.id = slot;
+            it->second.focusedWorkspaceId = focusedWorkspaceId;
-            state.hyprId = -1;
-            state.label = std::to_string(slot);
-            state.active = (slot == focusedSlot);
-            state.focused = state.focused;
-            state.urgent = false;
-            monitor.workspaceStates.emplace(slot, state);
         }
     }
 
     for (const auto &workspaceJson : workspacesJson) {
-        if (!workspaceJson.is_object()) {
+        const int workspaceId                                      = workspaceJson.value("id", -1);
+        auto workspaceStateIt = this->workspaces.find(workspaceId);
+        if (workspaceStateIt == this->workspaces.end()) {
             continue;
         }
 
-        const int monitorId = workspaceJson.value("monitorID", -1);
+        WorkspaceState *workspaceState = workspaceStateIt->second;
-        const int workspaceId = workspaceJson.value("id", -1);
+        auto mit = this->monitors.find(workspaceState->monitorId);
-
+        if (mit != this->monitors.end()) {
-        auto monitorIt = monitors.find(monitorId);
+            workspaceState->focused = mit->second.focusedWorkspaceId == workspaceId;
-        if (monitorIt == monitors.end() || workspaceId < 0) {
-            continue;
-        }
-
-        auto &monitor = monitorIt->second;
-        const int slot =
-            ((workspaceId - 1) % HyprlandService::kWorkspaceSlotCount) + 1;
-        auto &workspaceState = monitor.workspaceStates[slot];
-
-        workspaceState.id = slot;
-        workspaceState.hyprId = workspaceId;
-        workspaceState.focused = (monitor.focusedWorkspaceId == workspaceId);
-        workspaceState.active =
-            workspaceState.focused || workspaceJson.value("windows", 0) > 0;
-        workspaceState.urgent = false;
-
-        std::string labelCandidate;
-        if (workspaceJson.contains("name") &&
-            workspaceJson["name"].is_string()) {
-            labelCandidate = workspaceJson["name"].get<std::string>();
-        }
-
-        if (labelCandidate.empty() ||
-            labelCandidate == std::to_string(workspaceId)) {
-            workspaceState.label = std::to_string(slot);
         } else {
-            workspaceState.label = labelCandidate;
+            workspaceState->focused = false;
-        }
-
-        if (workspaceJson.contains("urgent") &&
-            workspaceJson["urgent"].is_boolean()) {
-            workspaceState.urgent = workspaceJson["urgent"].get<bool>();
-        } else if (workspaceJson.contains("hasurgent") &&
-                   workspaceJson["hasurgent"].is_boolean()) {
-            workspaceState.urgent = workspaceJson["hasurgent"].get<bool>();
         }
+        workspaceState->active = true;
     }
 
-    for (const auto &pair : monitors) {
+    workspaceStateChanged.emit();
-        workspaceStateChanged.emit(pair.first);
-    }
-}
-
-HyprlandService::Monitor *HyprlandService::getMonitorById(int id) {
-    auto it = monitors.find(id);
-    if (it == monitors.end()) {
-        throw std::runtime_error("Monitor with ID " + std::to_string(id) +
-                                 " not found.");
-    }
-
-    return &it->second;
-}
-
-const HyprlandService::Monitor *HyprlandService::getMonitorById(int id) const {
-    auto it = monitors.find(id);
-    if (it == monitors.end()) {
-        throw std::runtime_error("Monitor with ID " + std::to_string(id) +
-                                 " not found.");
-    }
-
-    return &it->second;
-}
-
-HyprlandService::Monitor *
-HyprlandService::getMonitorByIndex(std::size_t index) {
-    if (index >= monitors.size()) {
-        throw std::runtime_error("Monitor index out of bounds: " +
-                                 std::to_string(index));
-    }
-
-    auto it = monitors.begin();
-    std::advance(it, static_cast<long>(index));
-    return &it->second;
 }
 
 void HyprlandService::switchToWorkspace(int workspaceId) {
@@ -320,68 +251,113 @@ void HyprlandService::switchToWorkspace(int workspaceId) {
     }
 }
 
-const HyprlandService::Monitor *
+void HyprlandService::onUrgentEvent(std::string windowAddress) {
-HyprlandService::getMonitorByIndex(std::size_t index) const {
+    std::string output = SystemHelper::get_command_output(kClientsCommand);
+    auto clientsJson   = nlohmann::json::parse(output, nullptr, false);
+
+    for (const auto &clientJson : clientsJson) {
+        const std::string addr = clientJson.value("address", "");
+
+        if (addr == "0x" + windowAddress) {
+            int workspaceId = clientJson["workspace"].value("id", -1);
+
+            auto it = this->workspaces.find(workspaceId);
+            if (it != this->workspaces.end() && it->second) {
+
+                if (std::find(it->second->urgentWindows.begin(),
+                              it->second->urgentWindows.end(), windowAddress) ==
+                    it->second->urgentWindows.end()) {
+                    it->second->urgentWindows.push_back(windowAddress);
+                    workspaceStateChanged.emit();
+                }
+
+            }
+
+            break;
+        }
+    }
+}
+
+void HyprlandService::onActiveWindowEvent(std::string windowAddress) {
+    std::string output = SystemHelper::get_command_output(kClientsCommand);
+    auto clientsJson   = nlohmann::json::parse(output, nullptr, false);
+
+    for (const auto &clientJson : clientsJson) {
+        const std::string addr = clientJson.value("address", "");
+
+        if (addr == "0x" + windowAddress) {
+            int workspaceId = clientJson["workspace"]["id"];
+            auto it = this->workspaces.find(workspaceId);
+            if (it != this->workspaces.end() && it->second) {
+                WorkspaceState *ws = it->second;
+                auto uit = std::find(ws->urgentWindows.begin(), ws->urgentWindows.end(), windowAddress);
+                if (uit != ws->urgentWindows.end()) {
+                    ws->urgentWindows.erase(uit);
+                    workspaceStateChanged.emit();
+                }
+
+                break;
+            }
+        }
+    }
+}
+
+void HyprlandService::printMonitor(const Monitor &mon) const {
+    std::cout << "=== Monitor Info ===\n";
+    std::cout << "Name: " << mon.name << " (ID: " << mon.id << ")\n";
+    std::cout << "Position: (" << mon.x << ", " << mon.y << ")\n";
+    std::cout << "Focused Workspace ID: " << mon.focusedWorkspaceId << "\n";
+
+    std::cout << "Workspaces:\n";
+
+    if (mon.workspaceStates.empty()) {
+        std::cout << "  (None)\n";
+
+        return;
+    }
+
+    for (int slot = 1; slot <= HyprlandService::kWorkspaceSlotCount; ++slot) {
+        const auto it = mon.workspaceStates.find(slot);
+        if (it == mon.workspaceStates.end()) {
+            std::cout << "  - [Slot: " << slot << " | HyprID: n/a]"
+                      << " Label: <none> | Active: No | Focused: No | "
+                         "Urgent: No\n";
+            continue;
+        }
+
+        const WorkspaceState *ws = it->second;
+        std::cout << "  - [HyprID: "
+                  << (ws->hyprId >= 0 ? std::to_string(ws->hyprId)
+                                      : std::string("n/a"))
+                  << "] "
+                  << "Label: " << (ws->label.empty() ? "<none>" : ws->label)
+                  << " | "
+                  << "Active: " << (ws->active ? "Yes" : "No") << " | "
+                  << "Focused: " << (ws->focused ? "Yes" : "No") << " | "
+                  << "Urgent: " << (ws->urgentWindows.size() > 0 ? "Yes" : "No")
+                  << "\n";
+    }
+
+    std::cout << "====================\n";
+}
+
+HyprlandService::Monitor *HyprlandService::getMonitorById(int id) {
+    auto it = monitors.find(id);
+    if (it == monitors.end()) {
+        throw std::runtime_error("Monitor with ID " + std::to_string(id) +
+                                 " not found.");
+    }
+
+    return &it->second;
+}
+
+HyprlandService::Monitor *HyprlandService::getMonitorByIndex(std::size_t index) {
     if (index >= monitors.size()) {
-        throw std::runtime_error("Monitor index out of bounds: " +
+        throw std::runtime_error("Monitor index out of bounds: " + std::to_string(index));
-                                 std::to_string(index));
     }
 
     auto it = monitors.begin();
     std::advance(it, static_cast<long>(index));
+
     return &it->second;
 }
-
-void HyprlandService::handle_urgent_window(std::string windowAddress) {
-    std::string output;
-    try {
-        output = SystemHelper::get_command_output(kClientsCommand);
-    } catch (const std::exception &ex) {
-        std::cerr << "[Hyprland] Failed to query clients: " << ex.what()
-                  << std::endl;
-        return;
-    }
-
-    auto clientsJson = nlohmann::json::parse(output, nullptr, false);
-    if (!clientsJson.is_array()) {
-        return;
-    }
-
-    int workspaceId = -1;
-
-    for (const auto &client : clientsJson) {
-        if (!client.is_object())
-            continue;
-
-        std::string addr = client.value("address", "");
-        if (addr == "0x" + windowAddress) {
-            if (client.contains("workspace") &&
-                client["workspace"].is_object()) {
-                workspaceId = client["workspace"].value("id", -1);
-            }
-            break;
-        }
-    }
-
-    if (workspaceId == -1) {
-        return;
-    }
-
-    for (auto &pair : monitors) {
-        auto &monitor = pair.second;
-        bool changed = false;
-
-        for (auto &wsPair : monitor.workspaceStates) {
-            if (wsPair.second.hyprId == workspaceId) {
-                if (!wsPair.second.urgent) {
-                    wsPair.second.urgent = true;
-                    changed = true;
-                }
-            }
-        }
-
-        if (changed) {
-            workspaceStateChanged.emit(monitor.id);
-        }
-    }
-}

src/services/tray.cpp

@@ -15,12 +15,12 @@
 #include <vector>
 
 namespace {
-constexpr const char *kWatcherBusName = "org.kde.StatusNotifierWatcher";
+constexpr const char *kWatcherBusName      = "org.kde.StatusNotifierWatcher";
-constexpr const char *kWatcherObjectPath = "/StatusNotifierWatcher";
+constexpr const char *kWatcherObjectPath   = "/StatusNotifierWatcher";
-constexpr const char *kWatcherInterface = "org.kde.StatusNotifierWatcher";
+constexpr const char *kWatcherInterface    = "org.kde.StatusNotifierWatcher";
-constexpr const char *kItemInterface = "org.kde.StatusNotifierItem";
+constexpr const char *kItemInterface       = "org.kde.StatusNotifierItem";
 constexpr const char *kDBusPropertiesIface = "org.freedesktop.DBus.Properties";
-constexpr const char *kDBusMenuInterface = "com.canonical.dbusmenu";
+constexpr const char *kDBusMenuInterface   = "com.canonical.dbusmenu";
 
 const char *kWatcherIntrospection =
     R"(<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-Bus Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
@@ -55,25 +55,25 @@ ParsedService parse_service_identifier(const Glib::ustring &sender,
     ParsedService parsed;
 
     if (service.empty()) {
-        parsed.busName = sender;
+        parsed.busName    = sender;
         parsed.objectPath = "/StatusNotifierItem";
         return parsed;
     }
 
     if (service.front() == '/') {
-        parsed.busName = sender;
+        parsed.busName    = sender;
         parsed.objectPath = service;
         return parsed;
     }
 
     const auto slash = service.find('/');
     if (slash == std::string::npos) {
-        parsed.busName = service;
+        parsed.busName    = service;
         parsed.objectPath = "/StatusNotifierItem";
         return parsed;
     }
 
-    parsed.busName = service.substr(0, slash);
+    parsed.busName    = service.substr(0, slash);
     parsed.objectPath = service.substr(slash);
 
     if (parsed.busName.empty()) {
@@ -90,8 +90,8 @@ ParsedService parse_service_identifier(const Glib::ustring &sender,
 GVariant *create_property_list_variant() {
     GVariantBuilder builder;
     g_variant_builder_init(&builder, G_VARIANT_TYPE("as"));
-    const char *properties[] = {"label",       "label-markup",     "enabled",
+    const char *properties[] = {"label", "label-markup", "enabled",
-                                "visible",     "children-display", "type",
+                                "visible", "children-display", "type",
                                 "toggle-type", "toggle-state"};
     for (const char *prop : properties) {
         g_variant_builder_add(&builder, "s", prop);
@@ -106,7 +106,7 @@ void call_about_to_show(const Glib::RefPtr<Gio::DBus::Connection> &connection,
         return;
     }
 
-    GError *error = nullptr;
+    GError *error    = nullptr;
     GVariant *result = g_dbus_connection_call_sync(
         connection->gobj(), busName.c_str(), menuPath.c_str(),
         kDBusMenuInterface, "AboutToShow", g_variant_new("(i)", id), nullptr,
@@ -137,7 +137,7 @@ GVariant *call_get_layout(const Glib::RefPtr<Gio::DBus::Connection> &connection,
     GVariant *params = g_variant_new("(ii@as)", 0, -1, properties);
     g_variant_ref_sink(properties);
 
-    GError *error = nullptr;
+    GError *error    = nullptr;
     GVariant *result = g_dbus_connection_call_sync(
         connection->gobj(), busName.c_str(), menuPath.c_str(),
         kDBusMenuInterface, "GetLayout", params, nullptr,
@@ -174,15 +174,15 @@ void parse_menu_node(GVariant *tuple, TrayService::MenuNode &outNode) {
         return;
     }
 
-    int id = 0;
+    int id                    = 0;
-    GVariant *propsVariant = nullptr;
+    GVariant *propsVariant    = nullptr;
     GVariant *childrenVariant = nullptr;
 
     g_variant_get(tuple, "(i@a{sv}@av)", &id, &propsVariant, &childrenVariant);
 
-    outNode.id = id;
+    outNode.id        = id;
-    outNode.enabled = true;
+    outNode.enabled   = true;
-    outNode.visible = true;
+    outNode.visible   = true;
     outNode.separator = false;
     outNode.label.clear();
 
@@ -190,7 +190,7 @@ void parse_menu_node(GVariant *tuple, TrayService::MenuNode &outNode) {
         GVariantIter iter;
         g_variant_iter_init(&iter, propsVariant);
         const gchar *key = nullptr;
-        GVariant *value = nullptr;
+        GVariant *value  = nullptr;
 
         while (g_variant_iter_next(&iter, "{sv}", &key, &value)) {
             if (!key || !value) {
@@ -214,13 +214,13 @@ void parse_menu_node(GVariant *tuple, TrayService::MenuNode &outNode) {
             if (std::strcmp(key, "label") == 0) {
                 if (g_variant_is_of_type(unboxed, G_VARIANT_TYPE_STRING)) {
                     const gchar *str = g_variant_get_string(unboxed, nullptr);
-                    outNode.label = str ? str : "";
+                    outNode.label    = str ? str : "";
                 }
             } else if (std::strcmp(key, "label-markup") == 0 &&
                        outNode.label.empty()) {
                 if (g_variant_is_of_type(unboxed, G_VARIANT_TYPE_STRING)) {
                     const gchar *str = g_variant_get_string(unboxed, nullptr);
-                    outNode.label = str ? str : "";
+                    outNode.label    = str ? str : "";
                 }
             } else if (std::strcmp(key, "enabled") == 0) {
                 if (g_variant_is_of_type(unboxed, G_VARIANT_TYPE_BOOLEAN)) {
@@ -362,7 +362,7 @@ void TrayService::activate(const std::string &id, int32_t x, int32_t y) {
         return;
     }
 
-    GError *error = nullptr;
+    GError *error    = nullptr;
     GVariant *result = g_dbus_connection_call_sync(
         connection->gobj(), it->second->publicData.busName.c_str(),
         it->second->publicData.objectPath.c_str(), kItemInterface, "Activate",
@@ -387,7 +387,7 @@ void TrayService::secondaryActivate(const std::string &id, int32_t x,
         return;
     }
 
-    GError *error = nullptr;
+    GError *error    = nullptr;
     GVariant *result = g_dbus_connection_call_sync(
         connection->gobj(), it->second->publicData.busName.c_str(),
         it->second->publicData.objectPath.c_str(), kItemInterface,
@@ -411,7 +411,7 @@ void TrayService::contextMenu(const std::string &id, int32_t x, int32_t y) {
         return;
     }
 
-    GError *error = nullptr;
+    GError *error    = nullptr;
     GVariant *result = g_dbus_connection_call_sync(
         connection->gobj(), it->second->publicData.busName.c_str(),
         it->second->publicData.objectPath.c_str(), kItemInterface,
@@ -566,7 +566,7 @@ bool TrayService::activate_menu_item(const std::string &id, int itemId) {
         "(isvu)", itemId, "clicked", g_variant_new_variant(emptyData),
         static_cast<guint32>(g_get_monotonic_time() / 1000));
 
-    GError *error = nullptr;
+    GError *error    = nullptr;
     GVariant *result = g_dbus_connection_call_sync(
         connection->gobj(), item.publicData.busName.c_str(),
         item.publicData.menuPath.c_str(), kDBusMenuInterface, "Event", params,
@@ -723,16 +723,16 @@ void TrayService::register_item(const Glib::ustring &sender,
     }
 
     const std::string id = parsed.busName + parsed.objectPath;
-    auto existing = items.find(id);
+    auto existing        = items.find(id);
     if (existing != items.end()) {
         refresh_item(*existing->second);
         itemUpdatedSignal.emit(existing->second->publicData);
         return;
     }
 
-    auto item = std::make_unique<TrackedItem>();
+    auto item                   = std::make_unique<TrackedItem>();
-    item->publicData.id = id;
+    item->publicData.id         = id;
-    item->publicData.busName = parsed.busName;
+    item->publicData.busName    = parsed.busName;
     item->publicData.objectPath = parsed.objectPath;
 
     refresh_item(*item);
@@ -789,7 +789,7 @@ void TrayService::refresh_item(TrackedItem &item) {
         return;
     }
 
-    GError *error = nullptr;
+    GError *error   = nullptr;
     GVariant *reply = g_dbus_connection_call_sync(
         connection->gobj(), item.publicData.busName.c_str(),
         item.publicData.objectPath.c_str(), kDBusPropertiesIface, "GetAll",
@@ -816,7 +816,7 @@ void TrayService::refresh_item(TrackedItem &item) {
     g_variant_iter_init(&iter, dictVariant);
 
     const gchar *key = nullptr;
-    GVariant *value = nullptr;
+    GVariant *value  = nullptr;
 
     Glib::RefPtr<Gdk::Paintable> iconTexture;
     Glib::RefPtr<Gdk::Paintable> attentionTexture;
@@ -836,23 +836,23 @@ void TrayService::refresh_item(TrackedItem &item) {
 
         if (std::strcmp(key, "Title") == 0) {
             const gchar *str = g_variant_get_string(value, nullptr);
-            title = str ? str : "";
+            title            = str ? str : "";
         } else if (std::strcmp(key, "Status") == 0) {
             const gchar *str = g_variant_get_string(value, nullptr);
-            status = str ? str : "";
+            status           = str ? str : "";
         } else if (std::strcmp(key, "Menu") == 0) {
             if (g_variant_is_of_type(value, G_VARIANT_TYPE_OBJECT_PATH)) {
                 const gchar *str = g_variant_get_string(value, nullptr);
-                menuPath = str ? str : "";
+                menuPath         = str ? str : "";
             } else {
                 const gchar *str = g_variant_get_string(value, nullptr);
-                menuPath = str ? str : "";
+                menuPath         = str ? str : "";
             }
         } else if (std::strcmp(key, "IconName") == 0) {
             const gchar *str = g_variant_get_string(value, nullptr);
-            iconName = str ? str : "";
+            iconName         = str ? str : "";
         } else if (std::strcmp(key, "AttentionIconName") == 0) {
-            const gchar *str = g_variant_get_string(value, nullptr);
+            const gchar *str  = g_variant_get_string(value, nullptr);
             attentionIconName = str ? str : "";
         } else if (std::strcmp(key, "IconPixmap") == 0) {
             iconTexture = parse_icon_pixmap(value);
@@ -864,10 +864,10 @@ void TrayService::refresh_item(TrackedItem &item) {
     }
 
     g_variant_unref(dictVariant);
-    const bool menuPathChanged = (item.publicData.menuPath != menuPath);
+    const bool menuPathChanged    = (item.publicData.menuPath != menuPath);
-    item.publicData.title = title;
+    item.publicData.title         = title;
-    item.publicData.status = status;
+    item.publicData.status        = status;
-    item.publicData.menuPath = menuPath;
+    item.publicData.menuPath      = menuPath;
     item.publicData.menuAvailable = !menuPath.empty();
 
     if (menuPathChanged || !item.publicData.menuAvailable) {
@@ -1029,7 +1029,7 @@ Glib::RefPtr<Gdk::Paintable> TrayService::parse_icon_pixmap(GVariant *variant) {
         return {};
     }
 
-    int32_t width = 0;
+    int32_t width  = 0;
     int32_t height = 0;
     g_variant_get_child(entry, 0, "i", &width);
     g_variant_get_child(entry, 1, "i", &height);
@@ -1045,7 +1045,7 @@ Glib::RefPtr<Gdk::Paintable> TrayService::parse_icon_pixmap(GVariant *variant) {
         return {};
     }
 
-    gsize rawLength = 0;
+    gsize rawLength        = 0;
     const guint8 *rawBytes = static_cast<const guint8 *>(
         g_variant_get_fixed_array(bytesVariant, &rawLength, sizeof(guint8)));
     if (!rawBytes || rawLength < static_cast<gsize>(width * height * 4)) {
@@ -1062,16 +1062,16 @@ Glib::RefPtr<Gdk::Paintable> TrayService::parse_icon_pixmap(GVariant *variant) {
     const guint32 *pixels = reinterpret_cast<const guint32 *>(rawBytes);
     for (std::size_t idx = 0; idx < pixelCount; ++idx) {
         const guint32 pixel = pixels[idx];
-        const guint8 a = static_cast<guint8>((pixel >> 24) & 0xFF);
+        const guint8 a      = static_cast<guint8>((pixel >> 24) & 0xFF);
-        const guint8 r = static_cast<guint8>((pixel >> 16) & 0xFF);
+        const guint8 r      = static_cast<guint8>((pixel >> 16) & 0xFF);
-        const guint8 g = static_cast<guint8>((pixel >> 8) & 0xFF);
+        const guint8 g      = static_cast<guint8>((pixel >> 8) & 0xFF);
-        const guint8 b = static_cast<guint8>(pixel & 0xFF);
+        const guint8 b      = static_cast<guint8>(pixel & 0xFF);
 
         const std::size_t base = idx * 4;
-        rgba[base + 0] = r;
+        rgba[base + 0]         = r;
-        rgba[base + 1] = g;
+        rgba[base + 1]         = g;
-        rgba[base + 2] = b;
+        rgba[base + 2]         = b;
-        rgba[base + 3] = a;
+        rgba[base + 3]         = a;
     }
 
     auto pixbuf =
@@ -1082,9 +1082,9 @@ Glib::RefPtr<Gdk::Paintable> TrayService::parse_icon_pixmap(GVariant *variant) {
         return {};
     }
 
-    auto *dest = pixbuf->get_pixels();
+    auto *dest              = pixbuf->get_pixels();
     const int destRowstride = pixbuf->get_rowstride();
-    const int srcRowstride = width * 4;
+    const int srcRowstride  = width * 4;
 
     for (int y = 0; y < height; ++y) {
         std::memcpy(dest + y * destRowstride,

src/widgets/tray.cpp

@@ -13,6 +13,7 @@ TrayIconWidget::TrayIconWidget(TrayService &service, std::string id)
     set_focusable(false);
     set_valign(Gtk::Align::CENTER);
     set_halign(Gtk::Align::CENTER);
+    add_css_class("tray-icon");
 
     picture.set_halign(Gtk::Align::CENTER);
     picture.set_valign(Gtk::Align::CENTER);
@@ -98,8 +99,8 @@ void TrayIconWidget::on_secondary_released(int /*n_press*/, double x,
         return;
     }
 
-    pendingX = x;
+    pendingX         = x;
-    pendingY = y;
+    pendingY         = y;
     menuPopupPending = true;
     try_popup();
 }
@@ -124,7 +125,7 @@ bool TrayIconWidget::ensure_menu() {
 
     const auto &layout = *layoutOpt;
 
-    auto menu = Gio::Menu::create();
+    auto menu    = Gio::Menu::create();
     auto actions = Gio::SimpleActionGroup::create();
 
     populate_menu_items(layout.children, menu, actions);
@@ -137,7 +138,7 @@ bool TrayIconWidget::ensure_menu() {
         return false;
     }
 
-    menuModel = menu;
+    menuModel   = menu;
     menuActions = actions;
 
     if (!menuPopover) {

src/widgets/volumeWidget.cpp

@@ -17,15 +17,10 @@ VolumeWidget::VolumeWidget() : Gtk::Box(Gtk::Orientation::HORIZONTAL) {
 
     append(label);
 
-    // Click toggles mute using wpctl
     click = Gtk::GestureClick::create();
     click->set_button(GDK_BUTTON_PRIMARY);
-    // signal_released provides (int, double, double) — use lambda to ignore
+    click->signal_released().connect([this](int, double, double) {
-    // args
-    click->signal_released().connect([this](int /*n_press*/, double /*x*/,
-                                            double /*y*/) {
         try {
-            // Toggle mute then refresh
             (void)SystemHelper::get_command_output(
                 "wpctl set-mute @DEFAULT_SINK@ toggle");
         } catch (const std::exception &ex) {
@@ -34,19 +29,17 @@ VolumeWidget::VolumeWidget() : Gtk::Box(Gtk::Orientation::HORIZONTAL) {
         }
         this->update();
     });
-    add_controller(click);
 
-    // Initial read
+    add_controller(click);
     update();
 
-    // Start polling every 1 second to keep the display up to date
+    this->timeoutConn = Glib::signal_timeout().connect(
-    timeoutConn = Glib::signal_timeout().connect(
         sigc::mem_fun(*this, &VolumeWidget::on_timeout), 100);
 }
 
 VolumeWidget::~VolumeWidget() {
-    if (timeoutConn.connected())
+    if (this->timeoutConn.connected())
-        timeoutConn.disconnect();
+        this->timeoutConn.disconnect();
 }
 
 void VolumeWidget::update() {
@@ -54,18 +47,16 @@ void VolumeWidget::update() {
         const std::string out =
             SystemHelper::get_command_output("wpctl get-volume @DEFAULT_SINK@");
 
-        // Attempt to parse a number (percentage or fraction)
         std::smatch m;
         std::regex r_percent(R"((\d+(?:\.\d+)?)%)");
         std::regex r_number(R"((\d+(?:\.\d+)?))");
 
         std::string text = out;
-        int percent = -1;
+        int percent      = -1;
 
         if (std::regex_search(text, m, r_percent)) {
             percent = static_cast<int>(std::round(std::stod(m[1].str())));
         } else if (std::regex_search(text, m, r_number)) {
-            // If number looks like 0.8 treat as fraction
             const double v = std::stod(m[1].str());
             if (v <= 1.0)
                 percent = static_cast<int>(std::round(v * 100.0));
@@ -76,7 +67,6 @@ void VolumeWidget::update() {
         if (percent >= 0) {
             label.set_text(std::to_string(percent) + "%");
         } else {
-            // Fallback to raw output (trimmed)
             auto pos = text.find_first_not_of(" \t\n\r");
             if (pos != std::string::npos) {
                 auto end = text.find_last_not_of(" \t\n\r");
@@ -94,5 +84,6 @@ void VolumeWidget::update() {
 
 bool VolumeWidget::on_timeout() {
     update();
+
     return true; // keep timeout active
 }

src/widgets/workspaceIndicator.cpp

@@ -1,6 +1,7 @@
 #include "widgets/workspaceIndicator.hpp"
+#include "services/hyprland.hpp"
 
-#include <exception>
+#include <cassert>
 #include <gdk/gdk.h>
 #include <gtkmm/gestureclick.h>
 #include <gtkmm/widget.h>
@@ -17,6 +18,25 @@ WorkspaceIndicator::WorkspaceIndicator(HyprlandService &service, int monitorId)
     monitorConnection = service.monitorStateChanged.connect(
         sigc::mem_fun(*this, &WorkspaceIndicator::on_monitor_update));
 
+    for (int i = 1; i <= HyprlandService::kWorkspaceSlotCount; ++i) {
+        auto label = Gtk::make_managed<Gtk::Label>(std::to_string(i));
+        label->add_css_class("workspace-pill");
+
+        // create and store a gesture controller once to avoid duplicate handlers
+        auto gesture = Gtk::GestureClick::create();
+        gesture->set_button(GDK_BUTTON_PRIMARY);
+        gesture->signal_released().connect(
+            [this, i](int, double, double) {
+                this->service.switchToWorkspace(
+                    i + this->monitorId * HyprlandService::kWorkspaceSlotCount);
+            });
+        label->add_controller(gesture);
+        workspaceGestures[i] = gesture;
+
+        workspaceLabels[i] = label;
+        append(*label);
+    }
+
     rebuild();
 }
 
@@ -30,77 +50,34 @@ WorkspaceIndicator::~WorkspaceIndicator() {
     }
 }
 
-void WorkspaceIndicator::on_workspace_update(int monitorId) {
+void WorkspaceIndicator::on_workspace_update() {
-    if (this->monitorId != monitorId && monitorId != -1) {
-        return;
-    }
-
     rebuild();
 }
 
 void WorkspaceIndicator::on_monitor_update() { rebuild(); }
 
+void WorkspaceIndicator::refreshLabel(Gtk::Label *label, const HyprlandService::WorkspaceState &state) {
+    label->remove_css_class("workspace-pill-active");
+    label->remove_css_class("workspace-pill-focused");
+    label->remove_css_class("workspace-pill-urgent");
+
+    // controller created once in constructor and reused
+    if (state.urgentWindows.size() > 0) {
+        label->add_css_class("workspace-pill-urgent");
+    } else {
+        if (state.focused) {
+            label->add_css_class("workspace-pill-focused");
+        } else if (state.active) {
+            label->add_css_class("workspace-pill-active");
+        }
+    }
+}
+
 void WorkspaceIndicator::rebuild() {
-    clear_children();
+    HyprlandService::Monitor *mon = service.getMonitorById(this->monitorId);
 
-    HyprlandService::Monitor *monitor = nullptr;
+    for (auto [id, workspaceState] : mon->workspaceStates) {
-    try {
+        Gtk::Label *label = workspaceLabels[id];
-        monitor = service.getMonitorById(monitorId);
+        this->refreshLabel(label, *workspaceState);
-    } catch (const std::exception &) {
-        return;
-    }
-
-    if (monitor == nullptr) {
-        return;
-    }
-
-    for (int workspaceId = 1;
-         workspaceId <= HyprlandService::kWorkspaceSlotCount; ++workspaceId) {
-        const HyprlandService::WorkspaceState *state = nullptr;
-        auto it = monitor->workspaceStates.find(workspaceId);
-
-        if (it != monitor->workspaceStates.end()) {
-            state = &it->second;
-        }
-
-        const std::string display = (state && !state->label.empty())
-                                        ? state->label
-                                        : std::to_string(workspaceId);
-
-        auto label = Gtk::make_managed<Gtk::Label>(display);
-        label->add_css_class("workspace-pill");
-
-        auto gesture = Gtk::GestureClick::create();
-        gesture->set_button(GDK_BUTTON_PRIMARY);
-        gesture->signal_released().connect(
-            [this, workspaceId](int /*n_press*/, double /*x*/, double /*y*/) {
-                int realWorkspaceId = workspaceId + 5 * (monitorId);
-
-                service.switchToWorkspace(realWorkspaceId);
-            });
-        label->add_controller(gesture);
-
-        if (state != nullptr) {
-            if (state->urgent != true) {
-                if (state->focused) {
-                    label->add_css_class("workspace-pill-focused");
-                } else if (state->active) {
-                    label->add_css_class("workspace-pill-active");
-                }
-            } else {
-                label->add_css_class("workspace-pill-urgent");
-            }
-        }
-
-        append(*label);
-    }
-}
-
-void WorkspaceIndicator::clear_children() {
-    Gtk::Widget *child = get_first_child();
-    while (child != nullptr) {
-        Gtk::Widget *next = child->get_next_sibling();
-        remove(*child);
-        child = next;
     }
 }

tmp_test.cpp

@@ -1,10 +0,0 @@
-#include <giomm/menumodel.h>
-#include <gio/gio.h>
-#include <gio/gdbusmenumodel.h>
-
-int main(){
-    GDBusMenuModel *dbusModel = g_dbus_menu_model_get_for_bus_sync(G_BUS_TYPE_SESSION, G_DBUS_MENU_MODEL_FLAGS_NONE, "org.freedesktop.Notifications", "/Menu", nullptr, nullptr);
-    if(!dbusModel) return 0;
-    Glib::RefPtr<Gio::MenuModel> model = Glib::wrap(G_MENU_MODEL(dbusModel));
-    return model ? 0 : 1;
-}