close one notification to close all

.gitea/workflows/ci.yml

@@ -1,48 +0,0 @@
-name: ci
-
-on:
-  push:
-  pull_request:
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    container:
-      image: git.rivercry.com/system/bar:latest
-      credentials:
-        username: docker
-        password: ${{ secrets.DOCKER_PASSWORD }}
-    steps:
-      - name: Checkout
-        run: |
-          git init
-          git remote add origin https://${{ github.actor }}:${{ secrets.GITHUB_TOKEN }}@git.rivercry.com/${{ github.repository }}.git
-          git fetch --depth 1 origin ${{ github.sha }}
-          git checkout FETCH_HEAD
-      - name: Toolchain Info
-        run: |
-          echo "CC=$CC"
-          echo "CXX=$CXX"
-          command -v gcc || true
-          command -v g++ || true
-          command -v gcov || true
-          gcc --version || true
-          g++ --version || true
-          gcov --version || true
-      - name: Configure
-        run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug -DENABLE_COVERAGE=ON -DCMAKE_C_COMPILER=/usr/bin/gcc -DCMAKE_CXX_COMPILER=/usr/bin/g++
-
-      - name: Build
-        run: cmake --build build --config Debug -j "$(nproc)"
-
-      - name: Test & Coverage
-        run: |
-          cd build
-          ctest -T Test --output-on-failure
-          ctest -T Coverage --output-on-failure
-          gcovr -r .. --xml-pretty -o coverage.xml
-
-      - name: SonarQube Scan
-        uses: docker://sonarsource/sonar-scanner-cli:latest
-        env:
-          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

.gitignore

@@ -55,4 +55,5 @@ test/test_runner
 
 cmake-build-debug/**/*
 .idea
-
+.cache/
+Testing/

CMakeLists.txt

@@ -41,7 +41,7 @@ target_sources(bar_lib
     src/widgets/clock.cpp
     src/widgets/date.cpp
     src/widgets/notification/baseNotification.cpp
-    src/widgets/notification/notification.cpp
+    src/widgets/notification/notificationWindow.cpp
     src/widgets/notification/spotifyNotification.cpp
     src/widgets/volumeWidget.cpp
     src/widgets/webWidget.cpp
@@ -54,7 +54,8 @@ target_sources(bar_lib
     src/services/dbus/mpris.cpp
 
     src/widgets/tray.cpp
-    src/widgets/controlCenter.cpp
+    src/widgets/controlCenter/controlCenter.cpp
+    src/widgets/controlCenter/mediaControl.cpp
 
     src/components/popover.cpp
     src/components/workspaceIndicator.cpp
@@ -68,7 +69,13 @@ add_executable(bar main.cpp)
 
 target_link_libraries(bar bar_lib ${GTKMM_LIBRARIES} ${LAYERSHELL_LIBRARIES} ${WEBKIT_LIBRARIES} ${CURL_LIBRARIES} nlohmann_json::nlohmann_json)
 
-# ---- Tests (Catch2) ----
+
+# add spdlog
+find_package(spdlog REQUIRED)
+target_link_libraries(bar_lib PRIVATE spdlog::spdlog)
+
+
+# ---- Testing shit
 find_package(Catch2 3 REQUIRED)
 
 add_executable(bar_tests

Testing/Temporary/CTestCostData.txt

@@ -1 +0,0 @@
----

Testing/Temporary/LastTest.log

@@ -1,3 +0,0 @@
-Start testing: Feb 01 19:16 CET
-----------------------------------------------------------
-End testing: Feb 01 19:16 CET

include/bar/bar.hpp

@@ -9,7 +9,7 @@
 #include "widgets/tray.hpp"
 #include "widgets/volumeWidget.hpp"
 #include "widgets/webWidget.hpp"
-#include "widgets/controlCenter.hpp"
+#include "widgets/controlCenter/controlCenter.hpp"
 
 class Bar : public Gtk::Window {
   public:

include/helpers/socket.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <cassert>
-#include <iostream>
+#include <spdlog/spdlog.h>
 #include <string>
 #include <sys/socket.h>
 #include <vector>
@@ -25,9 +25,9 @@ class SocketHelper {
             buffer[bytesRead] = '\0';
             data              = std::string(buffer);
         } else if (bytesRead == 0) {
-            std::cerr << "Socket closed by peer" << std::endl;
+            spdlog::warn("Socket closed by peer");
         } else {
-            std::cerr << "Error reading from socket" << std::endl;
+            spdlog::error("Error reading from socket");
         }
 
         auto delimiterPos = data.find(delimiter);

include/services/dbus/messages.hpp

@@ -4,21 +4,30 @@
 #include <functional>
 #include <string>
 #include <map>
+#include <sys/types.h>
 #include <vector>
+#include "gdkmm/pixbuf.h"
 #include "glibmm/variant.h"
 
 
 
 struct MprisPlayer2Message {
     std::string title;
-    std::string artist;
+    std::vector<std::string> artist;
     std::string artwork_url;
+    int64_t length_ms;
 
     std::function<void()> play_pause;
     std::function<void()> next;
     std::function<void()> previous;
 };
 
+enum NotificationUrgency {
+    LOW = 0,
+    NORMAL = 1,
+    CRITICAL = 2
+};
+
 struct NotifyMessage {
     std::string app_name;
     uint32_t replaces_id;
@@ -26,8 +35,10 @@ struct NotifyMessage {
     std::string summary;
     std::string body;
     std::vector<std::string> actions;
-    std::map<std::string, Glib::VariantBase> hints;
+    NotificationUrgency urgency = NORMAL;
     int32_t expire_timeout;
     // Callback to invoke when an action is triggered
     std::function<void(const std::string& action_id)> on_action;
+    // image data (if any) from dbus
+    std::optional<Glib::RefPtr<Gdk::Pixbuf>> imageData;
 };

include/services/dbus/mpris.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstdint>
 #include <giomm.h>
 #include <sigc++/sigc++.h>
 #include <vector>
@@ -7,19 +8,45 @@
 
 class MprisController {
   public:
+    struct PlayerState {
+        std::string title;
+        std::vector<std::string> artist;
+        std::string artwork_url;
+        int64_t length_ms;
+    };
+    enum class PlaybackStatus {
+        Playing,
+        Paused,
+        Stopped,
+    };
 
-    MprisController();
+    static std::shared_ptr<MprisController> getInstance();
 
     void toggle_play();
     void next_song();
     void previous_song();
+    void emit_seeked(int64_t position_us);
 
     sigc::signal<void(const MprisPlayer2Message &)> &signal_mpris_updated();
+    sigc::signal<void(PlaybackStatus)> &signal_playback_status_changed();
+    sigc::signal<void(int64_t)> &signal_playback_position_changed();
 
   private:
+    MprisController();
+    std::map<std::string, PlaybackStatus> playbackStatusMap = {
+        {"Playing", PlaybackStatus::Playing},
+        {"Paused", PlaybackStatus::Paused},
+        {"Stopped", PlaybackStatus::Stopped},
+    };
+
+    PlaybackStatus currentPlaybackStatus = PlaybackStatus::Stopped;
+
     Glib::RefPtr<Gio::DBus::Connection> m_connection;
     Glib::RefPtr<Gio::DBus::Proxy> m_proxy;
+    
     sigc::signal<void(const MprisPlayer2Message &)> mprisUpdatedSignal;
+    sigc::signal<void(PlaybackStatus)> playbackStatusChangedSignal;
+    sigc::signal<void(int64_t)> playbackPositionChangedSignal;
 
     void on_bus_connected(const Glib::RefPtr<Gio::AsyncResult> &result);
     void signalNotification();

include/services/hyprland.hpp

@@ -67,6 +67,7 @@ class HyprlandService {
         ACTIVE_WINDOW,
         OPEN_WINDOW,
         CLOSE_WINDOW,
+        MOVE_WINDOW,
         URGENT,
 
         FOCUSED_MONITOR,
@@ -78,6 +79,7 @@ class HyprlandService {
         {"activewindowv2", ACTIVE_WINDOW},
         {"openwindow", OPEN_WINDOW},
         {"closewindow", CLOSE_WINDOW},
+        {"movewindowv2", MOVE_WINDOW},
         {"urgent", URGENT},
         {"focusedmon", FOCUSED_MONITOR},
         {"monitorremoved", MONITOR_REMOVED},
@@ -86,6 +88,7 @@ class HyprlandService {
     void onFocusedMonitorChanged(std::string monitorData);
     void onOpenWindow(std::string windowData);
     void onCloseWindow(std::string windowData);
+    void onMoveWindow(std::string windowData);
     void onUrgent(std::string windowAddress);
     void onActiveWindowChanged(std::string windowAddress);
     void onMonitorRemoved(std::string monitorName);

include/services/notificationController.hpp

@@ -1,8 +1,13 @@
 #pragma once
 
+#include <cstdint>
+#include <map>
 #include <memory>
+#include <sys/types.h>
 #include <vector>
+
 #include "services/dbus/messages.hpp"
+#include "widgets/notification/baseNotification.hpp"
 
 #include "gdkmm/monitor.h"
 
@@ -21,6 +26,10 @@ class NotificationController {
     void showNotificationOnAllMonitors(NotifyMessage notify);
 
   private:
+    uint64_t globalNotificationId = 1;
+    std::map<uint64_t, std::vector<std::shared_ptr<BaseNotification>>> activeNotifications;
     NotificationController();
     std::vector<std::shared_ptr<Gdk::Monitor>> activeMonitors;
-};
+
+    void closeNotification(uint64_t notificationId);
+  };

include/widgets/controlCenter/controlCenter.hpp

@@ -2,6 +2,7 @@
 
 #include "components/popover.hpp"
 #include "gtkmm/box.h"
+#include "widgets/controlCenter/mediaControl.hpp"
 
 class ControlCenter : public Popover {
     public:
@@ -9,4 +10,6 @@ class ControlCenter : public Popover {
     
     private:
         Gtk::Box container;
+        MediaControlWidget mediaControlWidget;
+
 };

include/widgets/controlCenter/mediaControl.hpp

@@ -0,0 +1,57 @@
+#pragma once
+#include "gtkmm/box.h"
+#include "gtkmm/button.h"
+#include "gtkmm/label.h"
+#include "gtkmm/overlay.h"
+#include "gtkmm/picture.h"
+#include "gtkmm/scale.h"
+#include "gtkmm/scrolledwindow.h"
+
+#include "services/dbus/mpris.hpp"
+
+class MediaControlWidget : public Gtk::Box {
+    public:
+        MediaControlWidget();
+
+  private:
+    std::shared_ptr<MprisController> mprisController = MprisController::getInstance();
+
+    int64_t currentPositionUs = 0;
+    int64_t totalLengthUs     = 0;
+    sigc::connection seekTimerConnection;
+
+    void setCurrentPosition(int64_t position_us);
+    void setTotalLength(int64_t length_us);
+    void resetSeekTimer(int64_t start_position_us);
+    bool onSeekTick();
+
+    Gtk::Box spotifyContainer;
+
+    // image as background, artist, title
+    Gtk::Overlay topContainer;
+    Gtk::Picture backgroundImage;
+    Gtk::Box infoContainer;
+    Gtk::Label artistLabel;
+    Gtk::Label titleLabel;
+
+    //
+    Gtk::Box seekBarContainer;
+    Gtk::Label currentTimeLabel;
+    Gtk::Scale seekBar;
+    Gtk::Label totalTimeLabel;
+
+    // playback controls
+    Gtk::Box bottomContainer;
+    Gtk::Button previousButton;
+    Gtk::Button playPauseButton;
+    Gtk::Button nextButton;
+
+    Gtk::ScrolledWindow imageWrapper;
+
+    void onSpotifyMprisUpdated(const MprisPlayer2Message &message);
+
+    void onRunningStateChanged(MprisController::PlaybackStatus status);
+    void onPlay();
+    void onPause();
+    void onStop();
+};

include/widgets/notification/baseNotification.hpp

@@ -1,24 +1,30 @@
 #pragma once
 
-#include <filesystem>
+#include <csignal>
-#include <string>
+#include <cstdint>
-
-#include "helpers/system.hpp"
 
 #include "gdkmm/monitor.h"
-#include "gtk4-layer-shell.h"
-#include "gtkmm/cssprovider.h"
 #include "gtkmm/window.h"
 
+#define DEFAULT_NOTIFICATION_TIMEOUT 7000
 
-#define DEFAULT_NOTIFICATION_TIMEOUT 4000
 
 class BaseNotification : public Gtk::Window {
   public:
-    BaseNotification(std::shared_ptr<Gdk::Monitor> monitor);
+    BaseNotification( uint64_t notificationId, std::shared_ptr<Gdk::Monitor> monitor);
+
+    sigc::signal<void(int)> signal_close;
 
     virtual ~BaseNotification() = default;
 
+    uint64_t getNotificationId() const {
+        return this->notificationId;
+    }
+
   private:
     void ensure_notification_css_loaded();
+
+    // onClose signal can be added here if needed
+  protected:
+    uint64_t notificationId;
 };

include/widgets/notification/notificationWindow.hpp

@@ -1,11 +1,13 @@
 
 #pragma once
 
+#include <cstdint>
 #include "services/dbus/messages.hpp"
 #include "widgets/notification/baseNotification.hpp"
 
 class NotificationWindow : public BaseNotification {
   public:
-    NotificationWindow(std::shared_ptr<Gdk::Monitor> monitor, NotifyMessage message);
+    NotificationWindow(uint64_t notificationId, std::shared_ptr<Gdk::Monitor> monitor, NotifyMessage message);
     virtual ~NotificationWindow() = default;
+
 };

include/widgets/notification/spotifyNotification.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstdint>
 #include <memory>
 
 #include "services/dbus/messages.hpp"
@@ -9,7 +10,7 @@
 
 class SpotifyNotification : public BaseNotification {
   public:
-    SpotifyNotification(std::shared_ptr<Gdk::Monitor> monitor, MprisPlayer2Message message);
+    SpotifyNotification(uint64_t notificationId, std::shared_ptr<Gdk::Monitor> monitor, MprisPlayer2Message message);
     virtual ~SpotifyNotification() = default;
 
   private:

resources/bar.css

@@ -16,7 +16,6 @@ window {
 	color: #ffffff;
 	padding-left: 4px;
 	padding-right: 4px;
-	padding-top: 2px;
 	padding-bottom: 2px;
 	font-size: 14px;
 	font-family: var(--text-font);
@@ -34,6 +33,63 @@ popover {
 	font-size: 14px;
 }
 
+.control-center-popover {
+	padding: 12px;
+	background-color: rgba(25, 25, 25, 0.95);
+}
+
+.control-center-spotify-container {
+	border: 1px solid rgba(80, 80, 80, 0.8);
+	border-radius: 8px;
+	background: rgba(30, 30, 30, 0.95);
+}
+
+.control-center-spotify-artist-label {
+	font-size: 14px;
+	font-weight: 600;
+	color: #ffffff;
+	padding: 2px 6px;
+	border-radius: 4px;
+	background: rgba(0, 0, 0, 0.45);
+	/* bold text shadow */
+	text-shadow: 0 0 5px #000000aa;
+}
+
+.control-center-spotify-title-label {
+	font-size: 12px;
+	color: #cccccc;
+	padding: 2px 6px;
+	border-radius: 4px;
+	background: rgba(0, 0, 0, 0.35);
+	/* bold text shadow */
+	text-shadow: 0 0 5px #000000aa;
+}
+
+.control-center-seek-bar {
+	min-height: 6px;
+	min-width: 120px;
+	margin: 0 6px;
+}
+
+.control-center-seek-bar trough {
+	background-color: rgba(255, 255, 255, 0.18);
+	border-radius: 999px;
+	min-height: 6px;
+	min-width: 120px;
+}
+
+.control-center-seek-bar highlight {
+	background-color: rgba(255, 255, 255, 0.65);
+	border-radius: 999px;
+}
+
+.control-center-seek-bar slider {
+	background-color: #ffffff;
+	border-radius: 999px;
+	min-width: 10px;
+	min-height: 10px;
+}
+
 tooltip {
 	background-color: #222222;
 	color: #ffffff;

resources/notification.css

@@ -5,6 +5,7 @@
     --text-font-mono: "Hack Nerd Font Mono", monospace;
 
 	--color-notification-bg: rgba(30, 30, 30, 0.95);
+	--color-notification-critical-bg: rgba(50, 20, 20, 0.95);
 	--color-border: rgba(80, 80, 80, 0.8);
 }
 
@@ -12,11 +13,40 @@
 	border-radius: 8px;
 	padding: 8px 12px;
 	background: var(--color-notification-bg);
-	box-shadow: 0 4px 30px rgba(0, 0, 0, 0.2);
+	box-shadow: 0 4px 30px rgba(0, 0, 0, 0.5);
 	border: 1px solid var(--color-border);
 	font-size: 14px;
 }
 
+.notification-critical {
+    background: linear-gradient(145deg, #321010, #1e1e1e);
+    border: 1px solid rgba(255, 75, 75, 0.5);
+    box-shadow: 
+        0 4px 30px rgba(0, 0, 0, 0.8),        
+        0 0 15px rgba(255, 75, 75, 0.2),    
+        inset 0 0 10px rgba(255, 75, 75, 0.1); 
+        
+    color: #ffffff;
+    font-weight: 500;
+}
+
+.notification-normal {
+    background: linear-gradient(90deg, #0c1f3a 0%, #1e1e1e 100%);
+    border: 1px solid rgba(60, 160, 255, 0.3);
+    border-left: 3px solid #3c9aff;
+    box-shadow: 0 4px 20px rgba(0, 0, 0, 0.5), 
+                0 0 10px rgba(60, 160, 255, 0.1);
+    color: #ffffff;
+}
+
+.notification-low {
+    background: linear-gradient(145deg, #2a2a2a, #1e1e1e);
+    border: 1px solid rgba(255, 255, 255, 0.15);
+    color: rgba(255, 255, 255, 0.95);
+	/* white box shadow */
+	box-shadow: 0 4px 20px rgba(255, 255, 255, 0.05);
+	font-size: 13px;
+}
 .notification-button-box {
 	border-top: 1px solid var(--color-border);
 	padding-top: 6px;
@@ -40,3 +70,20 @@
 .notification-button:hover {
 	background-color: #555555;
 }
+
+.notification-app-icon {
+	padding-right: 8px;
+	border-radius: 4px;
+	border: 1px solid var(--color-border);
+}
+
+.notification-app-name {
+	font-weight: 600;
+	font-size: 12px;
+	color: #ffffff;
+}
+
+.notification-header {
+	margin-bottom: 6px;
+	border-bottom: 1px solid var(--color-border);
+}

sonar-project.properties

@@ -1,5 +0,0 @@
-sonar.projectKey=bar
-# relative paths to source directories. More details and properties are described
-# at https://docs.sonarsource.com/sonarqube-cloud/advanced-setup/analysis-scope/
-sonar.host.url=https://cov.rivercry.com
-sonar.cfamily.gcovr.reportPaths=build/coverage.xml

src/app.cpp

@@ -12,7 +12,7 @@ App::App() {
     this->setupServices();
     this->hyprlandService = HyprlandService::getInstance();
     this->notificationService = std::make_shared<NotificationService>();
-    this->mprisController = std::make_shared<MprisController>();
+    this->mprisController = MprisController::getInstance();
 
     auto notificationController = NotificationController::getInstance();
     this->mprisController->signal_mpris_updated().connect(

src/services/dbus/mpris.cpp

@@ -1,27 +1,40 @@
 #include "services/dbus/mpris.hpp"
-#include <iostream>
+
 #include <map>
+#include <spdlog/spdlog.h>
+#include <sys/types.h>
 
 #include "helpers/string.hpp"
 
 #include "giomm/dbusconnection.h"
 #include "giomm/dbusproxy.h"
 
+std::shared_ptr<MprisController> MprisController::getInstance() {
+    static std::shared_ptr<MprisController> instance = std::shared_ptr<MprisController>(new MprisController());
+    return instance;
+}
+
 MprisController::MprisController() {
-    // 1. Connect to the Session Bus
     Gio::DBus::Connection::get(
         Gio::DBus::BusType::SESSION,
         sigc::mem_fun(*this, &MprisController::on_bus_connected));
 }
 
-sigc::signal<void(const MprisPlayer2Message &)> &
+sigc::signal<void(const MprisPlayer2Message &)> &MprisController::signal_mpris_updated() {
-MprisController::signal_mpris_updated() {
     return mprisUpdatedSignal;
 }
 
+sigc::signal<void(MprisController::PlaybackStatus)> &MprisController::signal_playback_status_changed() {
+    return playbackStatusChangedSignal;
+}
+
+sigc::signal<void(int64_t)> &MprisController::signal_playback_position_changed() {
+    return playbackPositionChangedSignal;
+}
+
 void MprisController::on_bus_connected(const Glib::RefPtr<Gio::AsyncResult> &result) {
     if (!result) {
-        std::cerr << "DBus Connection Error: null async result" << std::endl;
+        spdlog::error("DBus Connection Error: null async result");
         return;
     }
     try {
@@ -37,9 +50,8 @@ void MprisController::on_bus_connected(const Glib::RefPtr<Gio::AsyncResult> &res
         );
 
         if (m_proxy) {
-            std::cout << "Connected to: " << player_bus_name << std::endl;
+            spdlog::info("Connected to: {}", player_bus_name);
 
-            // uncomment if launch notification on start
             signalNotification();
 
             m_proxy->signal_properties_changed().connect(
@@ -47,7 +59,7 @@ void MprisController::on_bus_connected(const Glib::RefPtr<Gio::AsyncResult> &res
         }
 
     } catch (const Glib::Error &ex) {
-        std::cerr << "DBus Connection Error: " << ex.what() << std::endl;
+        spdlog::error("DBus Connection Error: {}", ex.what());
     }
 }
 
@@ -60,7 +72,12 @@ void MprisController::signalNotification() {
     m_proxy->get_cached_property(metadata_var, "Metadata");
 
     if (!metadata_var) {
-        std::cout << "No metadata available." << std::endl;
+        spdlog::info("No metadata available.");
+        return;
+    }
+
+    if (!metadata_var.is_of_type(Glib::VariantType("a{sv}"))) {
+        spdlog::error("Unexpected metadata type.");
         return;
     }
 
@@ -72,36 +89,61 @@ void MprisController::signalNotification() {
 
     metadata_map = variant_dict.get();
 
-    std::string title, artist, artwork_url;
+    std::string title, artwork_url;
+    std::vector<std::string> artist;
 
     if (metadata_map.count("xesam:title")) {
-        auto title_var = Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::ustring>>(metadata_map["xesam:title"]);
+        const auto &title_base = metadata_map["xesam:title"];
+        if (title_base.is_of_type(Glib::VariantType("s"))) {
+            auto title_var = Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::ustring>>(title_base);
             title          = title_var.get();
         }
+    }
 
     if (metadata_map.count("xesam:artist")) {
-        auto artist_var = metadata_map["xesam:artist"];
+        const auto &artist_var = metadata_map["xesam:artist"];
 
         if (artist_var.is_of_type(Glib::VariantType("as"))) {
             auto artists = Glib::VariantBase::cast_dynamic<Glib::Variant<std::vector<Glib::ustring>>>(artist_var).get();
             if (!artists.empty()) {
-                artist = artists[0]; // Take the first artist
+                for (const auto &a : artists) {
+                    artist.push_back(a);
                 }
             }
+        } else if (artist_var.is_of_type(Glib::VariantType("s"))) {
+            auto artist_str = Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::ustring>>(artist_var);
+            artist.push_back(artist_str.get());
+        }
     }
 
     if (metadata_map.count("mpris:artUrl")) {
-        auto art_var = Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::ustring>>(metadata_map["mpris:artUrl"]);
+        const auto &art_base = metadata_map["mpris:artUrl"];
+        if (art_base.is_of_type(Glib::VariantType("s"))) {
+            auto art_var = Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::ustring>>(art_base);
             artwork_url  = art_var.get();
         }
+    }
+
+    int64_t length_us = 0;
+    if (metadata_map.count("mpris:length")) {
+        const auto &length_base = metadata_map["mpris:length"];
+        if (length_base.is_of_type(Glib::VariantType("x"))) {
+            auto length_var = Glib::VariantBase::cast_dynamic<Glib::Variant<gint64>>(length_base);
+            length_us       = static_cast<int64_t>(length_var.get());
+        } else if (length_base.is_of_type(Glib::VariantType("t"))) {
+            auto length_var = Glib::VariantBase::cast_dynamic<Glib::Variant<guint64>>(length_base);
+            length_us       = static_cast<int64_t>(length_var.get());
+        }
+    }
 
     MprisPlayer2Message mpris;
     mpris.title       = StringHelper::trimToSize(title, 30);
-    mpris.artist      = StringHelper::trimToSize(artist, 30);
+    mpris.artist      = artist;
     mpris.artwork_url = artwork_url;
     mpris.play_pause  = [this]() { this->toggle_play(); };
     mpris.next        = [this]() { this->next_song(); };
     mpris.previous    = [this]() { this->previous_song(); };
+    mpris.length_ms   = length_us; // Convert microseconds to milliseconds
     mprisUpdatedSignal.emit(mpris);
 }
 
@@ -111,6 +153,31 @@ void MprisController::on_properties_changed(const Gio::DBus::Proxy::MapChangedPr
     if (changed_properties.find("Metadata") != changed_properties.end()) {
         signalNotification();
     }
+
+    if (changed_properties.find("PlaybackStatus") != changed_properties.end()) {
+        auto status_var = changed_properties.at("PlaybackStatus");
+        if (status_var.is_of_type(Glib::VariantType("s"))) {
+            auto status = Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::ustring>>(status_var).get();
+            spdlog::info("Playback Status changed to: {}", status.raw());
+            auto parsedStatusIt = playbackStatusMap.find(static_cast<std::string>(status));
+
+            if (parsedStatusIt != playbackStatusMap.end()) {
+                currentPlaybackStatus = parsedStatusIt->second;
+                playbackStatusChangedSignal.emit(currentPlaybackStatus);
+            } else {
+                spdlog::error("Unknown playback status: {}", status.raw());
+            }
+        }
+    }
+
+    if (changed_properties.find("Position") != changed_properties.end()) {
+        auto position_var = changed_properties.at("Position");
+        if (position_var.is_of_type(Glib::VariantType("x"))) {
+            auto position = Glib::VariantBase::cast_dynamic<Glib::Variant<gint64>>(position_var).get();
+            spdlog::info("Position changed to: {}", position);
+            playbackPositionChangedSignal.emit(static_cast<int64_t>(position));
+        }
+    }   
 }
 
 void MprisController::previous_song() {
@@ -119,7 +186,6 @@ void MprisController::previous_song() {
     }
 }
 
-
 void MprisController::toggle_play() {
     if (m_proxy) {
         m_proxy->call("PlayPause");
@@ -131,3 +197,18 @@ void MprisController::next_song() {
         m_proxy->call("Next");
     }
 }
+
+void MprisController::emit_seeked(int64_t position_us) {
+    if (!m_proxy) {
+        return;
+    }
+
+    try {
+        Glib::VariantContainerBase params = Glib::VariantContainerBase::create_tuple(
+            Glib::Variant<gint64>::create(position_us));
+
+        m_proxy->call("Seek", params);
+    } catch (const Glib::Error &ex) {
+        spdlog::error("Error seeking: {}", ex.what());
+    }
+}

src/services/dbus/notification.cpp

@@ -1,14 +1,16 @@
 #include "services/dbus/notification.hpp"
 
-#include <iostream>
+#include <spdlog/spdlog.h>
+#include <sys/types.h>
 
+#include "helpers/string.hpp"
 #include "services/notificationController.hpp"
 
 #include "glib.h"
 #include "glibconfig.h"
 
 void NotificationService::onBusAcquired(const Glib::RefPtr<Gio::DBus::Connection> &connection, const Glib::ustring &name) {
-    std::cout << "Acquired bus name: " << name << std::endl;
+    spdlog::info("Acquired bus name: {}", name.raw());
 
     auto introspection_data = Gio::DBus::NodeInfo::create_for_xml(introspection_xml);
 
@@ -74,27 +76,79 @@ void NotificationService::handle_notify(const Glib::VariantContainerBase &parame
     std::map<Glib::ustring, Glib::VariantBase> hints = Glib::VariantBase::cast_dynamic<Glib::Variant<std::map<Glib::ustring, Glib::VariantBase>>>(hints_var).get();
     gint32 expire_timeout = Glib::VariantBase::cast_dynamic<Glib::Variant<gint32>>(timeout_var).get();
 
-    std::cout << "Notification Received: " << summary << " - " << body << std::endl;
+    spdlog::info("Notification Received: {} - {}", summary.raw(), body.raw());
 
     NotifyMessage notify;
     notify.app_name    = app_name;
     notify.replaces_id = replaces_id;
     notify.app_icon    = app_icon;
-    notify.summary     = summary;
+    notify.summary     = static_cast<std::string>(summary);
-    notify.body        = body;
+    notify.body        = static_cast<std::string>(body);
 
     std::vector<std::string> actions_converted;
     actions_converted.reserve(actions.size());
-    for (const auto &a : actions) {
+    for (ulong i = 0; i < actions.size(); i += 2) {
-        actions_converted.emplace_back(static_cast<std::string>(a));
+        auto name = static_cast<std::string>(actions[i]);
+        auto label = static_cast<std::string>(actions[i + 1]);
+
+        if (name == "default") {
+            label = "Open";
         }
         
+        actions_converted.push_back(name);
+        actions_converted.push_back(label);
+    }
     notify.actions = actions_converted;
 
-    // notify.hints        = hints;
+
+    for (const auto &[key, value] : hints) {
+        if (key == "urgency") {
+            if (value.is_of_type(Glib::VariantType("y"))) {
+                auto urgency = Glib::VariantBase::cast_dynamic<Glib::Variant<guint8>>(value).get();
+                notify.urgency = static_cast<NotificationUrgency>(urgency);
+            }
+        }
+
+        if (key == "image-data") {
+            Glib::VariantBase image_value = value;
+            if (image_value.is_of_type(Glib::VariantType("v"))) {
+                try {
+                    image_value = Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::VariantBase>>(image_value).get();
+                } catch (const std::bad_cast &) {
+                    spdlog::warn("Failed to unwrap image-data variant");
+                }
+            }
+
+            if (image_value.is_of_type(Glib::VariantType("(iiibiiay)"))) {
+                // This is a raw data image format which describes width, height, rowstride, has alpha,
+                // bits per sample, channels and image data respectively.
+                try {
+                    auto image_data_variant = Glib::VariantBase::cast_dynamic<
+                        Glib::Variant<std::tuple<gint32, gint32, gint32, bool, gint32, gint32, std::vector<guint8>>>>(image_value);
+                    auto [width, height, rowstride, has_alpha, bits_per_sample, channels, data] = image_data_variant.get();
+                    (void)channels;
+                    auto pixbuf = Gdk::Pixbuf::create_from_data(
+                        data.data(),
+                        Gdk::Colorspace::RGB,
+                        has_alpha,
+                        bits_per_sample,
+                        width,
+                        height,
+                        rowstride);
+                    notify.imageData = pixbuf;
+                } catch (const std::bad_cast &e) {
+                    spdlog::warn("Failed to decode image-data hint: {}", e.what());
+                }
+            }
+        }
+    } 
 
     notify.expire_timeout = expire_timeout;
 
+    if (app_name == "Thunderbird") {
+        notify.expire_timeout = 10000; // 10 seconds for email notifications
+    }
+
     guint id = notificationIdCounter++;
     // Set up the callback to emit ActionInvoked on D-Bus
     Glib::RefPtr<Gio::DBus::Connection> dbus_conn = invocation->get_connection();
@@ -108,7 +162,7 @@ void NotificationService::handle_notify(const Glib::VariantContainerBase &parame
                 Glib::VariantContainerBase::create_tuple({Glib::Variant<guint>::create(id),
                                                           Glib::Variant<Glib::ustring>::create(action_id)}));
         } catch (const std::exception &e) {
-            std::cerr << "Failed to emit ActionInvoked: " << e.what() << std::endl;
+            spdlog::error("Failed to emit ActionInvoked: {}", e.what());
         }
     };
     NotificationController::getInstance()->showNotificationOnAllMonitors(notify);

src/services/hyprland.cpp

@@ -3,7 +3,6 @@
 #include <cstring>
 #include <glib-unix.h>
 #include <glib.h>
-#include <iostream>
 #include <memory>
 #include <nlohmann/json.hpp>
 #include <string>
@@ -16,6 +15,8 @@
 
 #include "gtkmm/box.h"
 
+#include "spdlog/spdlog.h"
+
 HyprlandService::HyprlandService() {
     init();
     this->bindHyprlandSocket();
@@ -88,7 +89,7 @@ void HyprlandService::bindHyprlandSocket() {
 
     socketFd = socket(AF_UNIX, SOCK_STREAM, 0);
     if (socketFd == -1) {
-        std::cerr << "[Hyprland] Failed to create socket" << std::endl;
+        spdlog::error("[Hyprland] Failed to create socket");
         return;
     }
 
@@ -98,7 +99,7 @@ void HyprlandService::bindHyprlandSocket() {
     std::strncpy(addr.sun_path, socketPath.c_str(), sizeof(addr.sun_path) - 1);
 
     if (connect(socketFd, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)) == -1) {
-        std::cerr << "[Hyprland] Failed to connect to " << socketPath << std::endl;
+        spdlog::error("[Hyprland] Failed to connect to {}", socketPath);
         close(socketFd);
         socketFd = -1;
 
@@ -108,7 +109,7 @@ 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);
 
-    auto onSocketEvent = [](gint fd, GIOCondition , gpointer user_data) -> gboolean {
+    auto onSocketEvent = [](gint fd, GIOCondition, gpointer user_data) -> gboolean {
         HyprlandService *self = static_cast<HyprlandService *>(user_data);
         auto messages         = SocketHelper::parseSocketMessage(fd, ">>");
 
@@ -119,7 +120,7 @@ void HyprlandService::bindHyprlandSocket() {
         return G_SOURCE_CONTINUE;
     };
 
-    g_source_set_callback(source, reinterpret_cast<GSourceFunc>(reinterpret_cast<void*>(+onSocketEvent)), this, nullptr);
+    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);
 }
@@ -169,14 +170,38 @@ void HyprlandService::onMonitorRemoved(std::string monitorName) {
 
     monitorPtr->monitorWorkspaces.clear();
     monitorPtr->bar->close();
+    monitorPtr->bar = nullptr;
 
     this->monitors.erase(monitorName);
 }
 
-// void HyprlandService::onMonitorAdded(std::string monitorName) {
+void HyprlandService::onMoveWindow(std::string windowData) {
-//     // this->signalMonitorAdded.emit();
+    auto parts         = StringHelper::split(windowData, ',');
-// }
+    std::string addr   = "0x" + parts[0];
+    int newWorkspaceId = std::stoi(parts[1]);
 
+    if (this->clients.find(addr) == this->clients.end()) {
+        spdlog::warn("[Hyprland] onMoveWindow: Client {} not found", addr);
+        return;
+    }
+
+    auto clientPtr     = this->clients[addr];
+    int oldWorkspaceId = clientPtr->workspaceId;
+
+    auto oldWorkspacePtr = workspaces[oldWorkspaceId];
+    oldWorkspacePtr->state->clients.erase(addr);
+    bool wasUrgent = oldWorkspacePtr->state->urgentClients.erase(addr) > 0;
+    refreshIndicator(oldWorkspacePtr);
+
+    clientPtr->workspaceId = newWorkspaceId;
+
+    auto newWorkspacePtr                  = workspaces[newWorkspaceId];
+    newWorkspacePtr->state->clients[addr] = clientPtr;
+    if (wasUrgent) {
+        newWorkspacePtr->state->urgentClients.insert(addr);
+    }
+    refreshIndicator(newWorkspacePtr);
+}
 
 void HyprlandService::onOpenWindow(std::string windowData) {
     auto parts        = StringHelper::split(windowData, ',');
@@ -250,6 +275,10 @@ void HyprlandService::handleSocketMessage(SocketHelper::SocketMessage message) {
         this->onMonitorRemoved(eventData);
         break;
     }
+    case MOVE_WINDOW: {
+        this->onMoveWindow(eventData);
+        break;
+    }
     }
 }
 void HyprlandService::onUrgent(std::string windowAddress) {

src/services/notificationController.cpp

@@ -3,14 +3,13 @@
 #include <memory>
 
 #include "services/dbus/messages.hpp"
-#include "widgets/notification/notification.hpp"
+#include "widgets/notification/baseNotification.hpp"
+#include "widgets/notification/notificationWindow.hpp"
 #include "widgets/notification/spotifyNotification.hpp"
 
 #include "gdkmm/display.h"
 #include "glibmm/main.h"
-
+#include "sigc++/adaptors/bind.h"
-
-#define DEFAULT_NOTIFICATION_TIMEOUT 4000
 
 std::shared_ptr<NotificationController> NotificationController::instance = nullptr;
 
@@ -38,9 +37,21 @@ NotificationController::NotificationController() {
 }
 
 void NotificationController::showSpotifyNotification(MprisPlayer2Message mpris) {
+    return;
+
+    std::vector<std::shared_ptr<BaseNotification>> notifications;
+
+    uint64_t id = this->globalNotificationId++;
+
     for (const auto &monitor : this->activeMonitors) {
-        auto notification = std::make_shared<SpotifyNotification>(monitor, mpris);
+        auto notification = std::make_shared<SpotifyNotification>(id, monitor, mpris);
         notification->show();
+        notifications.push_back(notification);
+        notification->signal_close.connect([this, id = notification->getNotificationId()](int) {
+            closeNotification(id);
+        });
+
+        this->activeNotifications[id] = notifications;
 
         Glib::signal_timeout().connect([notification]() {
             notification->close();
@@ -48,17 +59,32 @@ void NotificationController::showSpotifyNotification(MprisPlayer2Message mpris)
         },
                                        DEFAULT_NOTIFICATION_TIMEOUT);
     }
+
+    this->activeNotifications[id] = notifications;
 }
 
 void NotificationController::showNotificationOnAllMonitors(NotifyMessage notify) {
+    uint64_t id = this->globalNotificationId++;
+    std::vector<std::shared_ptr<BaseNotification>> notifications;
+
     for (const auto &monitor : this->activeMonitors) {
-        auto notification = std::make_shared<NotificationWindow>(monitor, notify);
+        auto notification = std::make_shared<NotificationWindow>(id, monitor, notify);
+        notifications.push_back(notification);
 
         auto timeout = notify.expire_timeout;
         notification->show();
         // -1 means use default timeout, 0 means never expire
         if (timeout <= 0) {
-            timeout = DEFAULT_NOTIFICATION_TIMEOUT; // default to 3 seconds
+            timeout = DEFAULT_NOTIFICATION_TIMEOUT;
+        }
+
+        notification->signal_close.connect(
+            [this, id = notification->getNotificationId()](int) {
+                closeNotification(id);
+            });
+
+        if (timeout == 0) {
+            continue;
         }
 
         Glib::signal_timeout().connect([notification]() {
@@ -67,4 +93,19 @@ void NotificationController::showNotificationOnAllMonitors(NotifyMessage notify)
         },
                                        timeout);
     }
+
+    this->activeNotifications[id] = notifications;
+}
+
+void NotificationController::closeNotification(uint64_t notificationId) {
+    if (this->activeNotifications.find(notificationId) == this->activeNotifications.end()) {
+        return;
+    }
+
+    auto notifications = this->activeNotifications[notificationId];
+    for (const auto &notification : notifications) {
+        notification->close();
+    }
+
+    this->activeNotifications.erase(notificationId);
 }

src/services/tray.cpp

@@ -9,7 +9,7 @@
 #include <giomm/dbusactiongroup.h>
 #include <giomm/dbusownname.h>
 #include <giomm/menumodel.h>
-#include <iostream>
+#include <spdlog/spdlog.h>
 #include <memory>
 #include <tuple>
 #include <vector>
@@ -143,9 +143,9 @@ void on_simple_call_finished(GObject *source, GAsyncResult *res,
     const bool isUnknownMethod =
         (error->domain == G_DBUS_ERROR && error->code == G_DBUS_ERROR_UNKNOWN_METHOD);
     if (!(data && data->ignoreUnknownMethod && isUnknownMethod)) {
-        std::cerr << "[TrayService] "
+        spdlog::error("[TrayService] {} failed: {}",
-                  << (data ? data->debugLabel : std::string("D-Bus call"))
+                      (data ? data->debugLabel : std::string("D-Bus call")),
-                  << " failed: " << error->message << std::endl;
+                      error->message);
     }
     g_error_free(error);
 }
@@ -288,8 +288,9 @@ void TrayService::start() {
             nodeInfo =
                 Gio::DBus::NodeInfo::create_for_xml(kWatcherIntrospection);
         } catch (const Glib::Error &err) {
-            std::cerr << "[TrayService] Failed to parse introspection data: "
+            spdlog::error(
-                      << err.what() << std::endl;
+                "[TrayService] Failed to parse introspection data: {}",
+                err.what());
             return;
         }
     }
@@ -577,9 +578,9 @@ bool TrayService::activate_menu_item(const std::string &id, int itemId,
     const guint32 nowMs = static_cast<guint32>(g_get_real_time() / 1000);
     const guint32 ts    = timestampMs ? timestampMs : nowMs;
 
-    std::cerr << "[TrayService] MenuEvent id=" << id << " item=" << itemId
+    spdlog::debug(
-              << " x=" << x << " y=" << y << " button=" << button
+        "[TrayService] MenuEvent id={} item={} x={} y={} button={} tsMs={}",
-              << " tsMs=" << ts << std::endl;
+        id, itemId, x, y, button, ts);
 
     // dbusmenu Event signature: (i s v u)
     // Some handlers (e.g., media players) look for both "timestamp" and
@@ -637,8 +638,7 @@ void TrayService::on_bus_acquired(
 
     auto interface_info = nodeInfo->lookup_interface(kWatcherInterface);
     if (!interface_info) {
-        std::cerr << "[TrayService] Missing interface info for watcher."
+        spdlog::error("[TrayService] Missing interface info for watcher.");
-                  << std::endl;
         return;
     }
 
@@ -646,8 +646,9 @@ void TrayService::on_bus_acquired(
         registrationId = connection->register_object(kWatcherObjectPath,
                                                      interface_info, vtable);
     } catch (const Glib::Error &err) {
-        std::cerr << "[TrayService] Failed to register watcher object: "
+        spdlog::error(
-                  << err.what() << std::endl;
+            "[TrayService] Failed to register watcher object: {}",
+            err.what());
         registrationId = 0;
         return;
     }
@@ -747,8 +748,8 @@ void TrayService::register_item(const Glib::ustring &sender,
 
     ParsedService parsed = parse_service_identifier(sender, service);
     if (parsed.busName.empty() || parsed.objectPath.empty()) {
-        std::cerr << "[TrayService] Invalid service registration: " << service
+        spdlog::warn("[TrayService] Invalid service registration: {}",
-                  << std::endl;
+                     service);
         return;
     }
 
@@ -845,8 +846,9 @@ void TrayService::on_refresh_finished_static(GObject *source, GAsyncResult *res,
         g_dbus_connection_call_finish(G_DBUS_CONNECTION(source), res, &error);
     if (!reply) {
         if (error) {
-            std::cerr << "[TrayService] Failed to query properties for "
+            spdlog::error(
-                      << data->id << ": " << error->message << std::endl;
+                "[TrayService] Failed to query properties for {}: {}",
+                data->id, error->message);
             g_error_free(error);
         }
 
@@ -1240,8 +1242,8 @@ Glib::RefPtr<Gdk::Paintable> TrayService::parse_icon_pixmap(GVariant *variant) {
     try {
         return Gdk::Texture::create_for_pixbuf(pixbuf);
     } catch (const Glib::Error &err) {
-        std::cerr << "[TrayService] Failed to create texture: " << err.what()
+        spdlog::error("[TrayService] Failed to create texture: {}",
-                  << std::endl;
+                      err.what());
         return {};
     }
 }

src/widgets/controlCenter.cpp

@@ -1,8 +0,0 @@
-#include "widgets/controlCenter.hpp"
-
-ControlCenter::ControlCenter(std::string icon, std::string name)
-    : Popover(icon, name) {
-    this->popover->set_size_request(200, -1);
-    set_popover_child(this->container);
-
-}

src/widgets/controlCenter/controlCenter.cpp

@@ -0,0 +1,20 @@
+#include "widgets/controlCenter/controlCenter.hpp"
+
+
+ControlCenter::ControlCenter(std::string icon, std::string name)
+    : Popover(icon, name) {
+    this->popover->add_css_class("control-center-popover");
+    this->container.set_orientation(Gtk::Orientation::VERTICAL);
+    this->container.set_spacing(0);
+    this->container.set_margin_top(0);
+    this->container.set_margin_bottom(0);
+    this->container.set_margin_start(0);
+    this->container.set_margin_end(0);
+
+    set_popover_child(this->container);
+
+
+    this->container.append(this->mediaControlWidget);
+
+}
+

src/widgets/controlCenter/mediaControl.cpp

@@ -0,0 +1,217 @@
+#include "widgets/controlCenter/mediaControl.hpp"
+
+#include "helpers/string.hpp"
+#include "services/textureCache.hpp"
+
+MediaControlWidget::MediaControlWidget()
+    : Gtk::Box(Gtk::Orientation::VERTICAL) {
+
+    this->set_orientation(Gtk::Orientation::VERTICAL);
+    this->set_size_request(200, 240);
+    this->set_hexpand(false);
+    this->set_vexpand(false);
+    this->add_css_class("control-center-spotify-container");
+
+    this->append(this->topContainer);
+    this->append(this->seekBarContainer);
+    this->append(this->bottomContainer);
+
+    this->backgroundImage.set_content_fit(Gtk::ContentFit::COVER);
+    this->backgroundImage.set_can_shrink(true);
+
+    this->imageWrapper.set_policy(Gtk::PolicyType::NEVER, Gtk::PolicyType::NEVER);
+    this->imageWrapper.set_child(this->backgroundImage);
+
+    this->topContainer.set_child(this->imageWrapper);
+
+    this->topContainer.set_size_request(200, 100);
+    this->topContainer.set_vexpand(false);
+    this->topContainer.set_hexpand(true);
+
+    this->infoContainer.set_orientation(Gtk::Orientation::VERTICAL);
+    this->infoContainer.set_valign(Gtk::Align::END);
+    this->infoContainer.set_halign(Gtk::Align::START);
+    this->infoContainer.append(this->artistLabel);
+    this->infoContainer.append(this->titleLabel);
+    this->topContainer.add_overlay(this->infoContainer);
+
+    this->artistLabel.set_halign(Gtk::Align::START);
+    this->titleLabel.set_halign(Gtk::Align::START);
+
+    this->seekBarContainer.set_orientation(Gtk::Orientation::HORIZONTAL);
+    this->seekBarContainer.set_vexpand(false);
+    this->seekBarContainer.set_hexpand(true);
+    this->seekBarContainer.set_halign(Gtk::Align::CENTER);
+    this->seekBarContainer.append(this->currentTimeLabel);
+    this->seekBarContainer.append(this->seekBar);
+    this->seekBarContainer.append(this->totalTimeLabel);
+
+    this->currentTimeLabel.set_text("0:00");
+    this->currentTimeLabel.set_halign(Gtk::Align::START);
+    this->totalTimeLabel.set_text("0:00");
+    this->totalTimeLabel.set_halign(Gtk::Align::END);
+    this->seekBar.set_range(0, 100);
+    this->seekBar.set_value(0);
+    this->seekBar.set_orientation(Gtk::Orientation::HORIZONTAL);
+    this->seekBar.set_draw_value(false);
+    this->seekBar.set_size_request(120, -1);
+    this->seekBar.set_hexpand(true);
+    this->seekBar.set_halign(Gtk::Align::CENTER);
+    this->seekBar.add_css_class("control-center-seek-bar");
+
+    this->seekBar.signal_value_changed().connect([this]() {
+        double fraction = this->seekBar.get_value() / 100.0;
+        int64_t new_position_us =
+            static_cast<int64_t>(fraction * static_cast<double>(this->totalLengthUs));
+        this->mprisController->emit_seeked(new_position_us - this->currentPositionUs); // in us
+        this->resetSeekTimer(new_position_us);
+    });
+
+    this->bottomContainer.set_orientation(Gtk::Orientation::HORIZONTAL);
+    this->bottomContainer.set_vexpand(false);
+    this->bottomContainer.set_hexpand(false);
+    this->bottomContainer.set_valign(Gtk::Align::START);
+    this->bottomContainer.set_homogeneous(true);
+    this->topContainer.set_vexpand(false);
+    this->topContainer.set_hexpand(true);
+    this->bottomContainer.append(this->previousButton);
+    this->bottomContainer.append(this->playPauseButton);
+    this->bottomContainer.append(this->nextButton);
+
+    this->previousButton.set_label("\u23EE"); // Previous track symbol
+    this->previousButton.add_css_class("notification-button");
+    this->previousButton.add_css_class("notification-icon-button");
+    this->playPauseButton.set_label("\u23EF"); // Play/Pause symbol
+    this->playPauseButton.add_css_class("notification-button");
+    this->playPauseButton.add_css_class("notification-icon-button");
+    this->nextButton.set_label("\u23ED"); // Next track symbol
+    this->nextButton.add_css_class("notification-button");
+    this->nextButton.add_css_class("notification-icon-button");
+
+    this->previousButton.signal_clicked().connect([this]() {
+        this->mprisController->previous_song();
+    });
+    this->playPauseButton.signal_clicked().connect([this]() {
+        this->mprisController->toggle_play();
+    });
+    this->nextButton.signal_clicked().connect([this]() {
+        this->mprisController->next_song();
+    });
+
+    this->mprisController->signal_mpris_updated().connect(
+        sigc::mem_fun(*this, &MediaControlWidget::onSpotifyMprisUpdated));
+
+    this->mprisController->signal_playback_status_changed().connect(
+        [this](MprisController::PlaybackStatus status) {
+            this->onRunningStateChanged(status);
+        });
+
+    this->mprisController->signal_playback_position_changed().connect(
+        [this](int64_t position_us) {
+            this->setCurrentPosition(position_us);
+        });
+
+    this->artistLabel.set_text("Artist Name");
+    this->artistLabel.add_css_class("control-center-spotify-artist-label");
+    this->titleLabel.set_text("Song Title");
+    this->titleLabel.add_css_class("control-center-spotify-title-label");
+
+    this->resetSeekTimer(0);
+}
+
+void MediaControlWidget::onSpotifyMprisUpdated(const MprisPlayer2Message &message) {
+    std::string artistText = "Unknown Artist";
+    if (!message.artist.empty()) {
+        artistText = StringHelper::trimToSize(message.artist[0], 30);
+    }
+    this->artistLabel.set_text(artistText);
+    this->titleLabel.set_text(message.title);
+
+    if (auto texture = TextureCacheService::getInstance()->getTexture(message.artwork_url)) {
+        this->backgroundImage.set_paintable(texture);
+    }
+
+    this->setTotalLength(message.length_ms);
+    this->setCurrentPosition(0);
+    this->resetSeekTimer(0);
+}
+
+void MediaControlWidget::setCurrentPosition(int64_t position_us) {
+    this->currentPositionUs = position_us;
+    int64_t seconds         = (position_us / 1000000) % 60;
+    int64_t minutes         = (position_us / (1000000 * 60)) % 60;
+    this->currentTimeLabel.set_text(
+        std::to_string(minutes) + ":" + (seconds < 10 ? "0" : "") + std::to_string(seconds));
+    if (totalLengthUs > 0) {
+        double fraction = static_cast<double>(currentPositionUs) / static_cast<double>(totalLengthUs);
+        this->seekBar.set_value(fraction * 100);
+    }
+}
+
+void MediaControlWidget::setTotalLength(int64_t length_us) {
+    this->totalLengthUs = length_us;
+    int64_t seconds     = (length_us / 1000000) % 60;
+    int64_t minutes     = (length_us / (1000000 * 60)) % 60;
+    this->totalTimeLabel.set_text(
+        std::to_string(minutes) + ":" + (seconds < 10 ? "0" : "") + std::to_string(seconds));
+}
+
+void MediaControlWidget::resetSeekTimer(int64_t start_position_us) {
+    if (seekTimerConnection.connected()) {
+        seekTimerConnection.disconnect();
+    }
+
+    setCurrentPosition(start_position_us);
+
+    seekTimerConnection = Glib::signal_timeout().connect(
+        sigc::mem_fun(*this, &MediaControlWidget::onSeekTick),
+        1000);
+}
+
+bool MediaControlWidget::onSeekTick() {
+    if (totalLengthUs <= 0) {
+        return true;
+    }
+
+    int64_t nextPosition = currentPositionUs + 1000000;
+    if (nextPosition > totalLengthUs) {
+        nextPosition = totalLengthUs;
+    }
+    setCurrentPosition(nextPosition);
+    return true;
+}
+
+void MediaControlWidget::onRunningStateChanged(MprisController::PlaybackStatus status) {
+    switch (status) {
+    case MprisController::PlaybackStatus::Playing:
+        this->onPlay();
+        break;
+    case MprisController::PlaybackStatus::Paused:
+        this->onPause();
+        break;
+    case MprisController::PlaybackStatus::Stopped:
+        this->onStop();
+        break;
+    }
+}
+
+void MediaControlWidget::onPlay() {
+    this->playPauseButton.set_label("\u23F8"); // Pause symbol
+    // strart seek timer if not already running
+    this->resetSeekTimer(currentPositionUs);
+}
+
+void MediaControlWidget::onPause() {
+    this->playPauseButton.set_label("\u23EF"); // Play symbol
+    if (seekTimerConnection.connected()) {
+        seekTimerConnection.disconnect();
+    }
+}
+
+void MediaControlWidget::onStop() {
+    this->playPauseButton.set_label("\u23EF"); // Play symbol
+    if (seekTimerConnection.connected()) {
+        seekTimerConnection.disconnect();
+    }
+    this->setCurrentPosition(0);
+}

src/widgets/notification/baseNotification.cpp

@@ -9,9 +9,9 @@
 #include "gtk4-layer-shell.h"
 #include "gtkmm/cssprovider.h"
 
-BaseNotification::BaseNotification(std::shared_ptr<Gdk::Monitor> monitor) {
+BaseNotification::BaseNotification(uint64_t notificationId, std::shared_ptr<Gdk::Monitor> monitor) {
     ensure_notification_css_loaded();
-    set_default_size(300, 100);
+    set_default_size(350, -1);
     gtk_layer_init_for_window(gobj());
     gtk_layer_set_monitor(gobj(), monitor->gobj());
     gtk_layer_set_layer(gobj(), GTK_LAYER_SHELL_LAYER_OVERLAY);
@@ -20,6 +20,11 @@ BaseNotification::BaseNotification(std::shared_ptr<Gdk::Monitor> monitor) {
     gtk_layer_set_margin(gobj(), GTK_LAYER_SHELL_EDGE_TOP, 2);
     gtk_layer_set_margin(gobj(), GTK_LAYER_SHELL_EDGE_RIGHT, 2);
     add_css_class("notification-popup");
+
+    this->set_hexpand(false);
+    this->set_vexpand(false);
+
+    this->notificationId = notificationId;
 }
 
 void BaseNotification::ensure_notification_css_loaded() {

src/widgets/notification/notification.cpp

@@ -1,48 +0,0 @@
-#include "widgets/notification/notification.hpp"
-
-#include "gtkmm/box.h"
-#include "gtkmm/button.h"
-#include "gtkmm/label.h"
-
-NotificationWindow::NotificationWindow(std::shared_ptr<Gdk::Monitor> monitor, NotifyMessage notify) : BaseNotification(monitor) {
-    set_title(notify.summary);
-
-    // Main vertical box
-    auto vbox = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 8);
-
-    // Summary label
-    auto summary_label = Gtk::make_managed<Gtk::Label>("<b>" + notify.summary + "</b>");
-    summary_label->set_use_markup(true);
-    summary_label->set_halign(Gtk::Align::START);
-    vbox->append(*summary_label);
-
-    // Body label
-    auto body_label = Gtk::make_managed<Gtk::Label>(notify.body);
-    body_label->set_use_markup(true);
-    body_label->set_halign(Gtk::Align::START);
-    vbox->append(*body_label);
-
-    // If actions exist, add buttons
-    if (!notify.actions.empty()) {
-        auto actions_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 6);
-        for (size_t i = 0; i + 1 < notify.actions.size(); i += 2) {
-            std::string action_id    = notify.actions[i];
-            std::string action_label = notify.actions[i + 1];
-
-            auto btn = Gtk::make_managed<Gtk::Button>();
-            btn->set_label(action_label);
-
-            btn->add_css_class("notification-button");
-            btn->signal_clicked().connect([this, action_id, cb = notify.on_action]() {
-                if (cb) {
-                    cb(action_id);
-                    this->close();
-                }
-            });
-            actions_box->append(*btn);
-        }
-        vbox->append(*actions_box);
-    }
-
-    set_child(*vbox);
-}

src/widgets/notification/notificationWindow.cpp

@@ -0,0 +1,103 @@
+#include "widgets/notification/notificationWindow.hpp"
+#include <cstdint>
+#include <sys/types.h>
+#include "helpers/string.hpp"
+
+#include "gtkmm/box.h"
+#include "gtkmm/button.h"
+#include "gtkmm/gestureclick.h"
+#include "gtkmm/image.h"
+#include "gtkmm/label.h"
+
+NotificationWindow::NotificationWindow(uint64_t notificationId, std::shared_ptr<Gdk::Monitor> monitor, NotifyMessage notify) : BaseNotification(notificationId, monitor) {
+    set_title(notify.summary);
+
+    auto window_click = Gtk::GestureClick::create();
+    window_click->set_button(GDK_BUTTON_PRIMARY);
+    window_click->set_exclusive(false);
+    window_click->signal_released().connect([this](int, double x, double y) {
+        Gtk::Widget *picked = this->pick(x, y, Gtk::PickFlags::DEFAULT);
+        for (auto *w = picked; w != nullptr; w = w->get_parent()) {
+            if (dynamic_cast<Gtk::Button *>(w) != nullptr) {
+                return;
+            }
+        }
+        this->signal_close.emit(this->notificationId);
+    });
+    add_controller(window_click);
+
+    // Main vertical box
+    auto vbox = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 8);
+    vbox->set_halign(Gtk::Align::FILL);
+
+    switch (notify.urgency) {
+        case NotificationUrgency::CRITICAL:
+            add_css_class("notification-critical");
+            break;
+        case NotificationUrgency::NORMAL:
+            add_css_class("notification-normal");
+            break;
+        case NotificationUrgency::LOW:
+            add_css_class("notification-low");
+            break;
+    }
+
+    auto header_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
+    header_box->set_halign(Gtk::Align::START);
+    header_box->add_css_class("notification-header");
+    header_box->set_hexpand(true);
+    header_box->set_halign(Gtk::Align::FILL);
+
+    if (notify.imageData) {
+        auto img = Gtk::make_managed<Gtk::Image>(*(notify.imageData));
+        img->set_pixel_size(16);
+        img->set_halign(Gtk::Align::START);
+        img->set_valign(Gtk::Align::CENTER);
+        img->add_css_class("notification-app-icon");
+        header_box->append(*img);
+    }
+
+    auto app_label = Gtk::make_managed<Gtk::Label>(StringHelper::trimToSize(notify.app_name, 24));
+    app_label->set_halign(Gtk::Align::START);
+    app_label->set_wrap(false);
+    app_label->add_css_class("notification-app-name");
+    header_box->append(*app_label);
+    vbox->append(*header_box);
+
+    // Summary label
+    auto summary_label = Gtk::make_managed<Gtk::Label>("<b>" + StringHelper::trimToSize(notify.summary, 20) + "</b>");
+    summary_label->set_use_markup(true);
+    summary_label->set_halign(Gtk::Align::START);
+    summary_label->set_wrap(true);
+    vbox->append(*summary_label);
+
+    auto body_label = Gtk::make_managed<Gtk::Label>(StringHelper::trimToSize(notify.body, 100));
+    body_label->set_use_markup(true);
+    body_label->set_halign(Gtk::Align::START);
+    body_label->set_wrap(true);
+    vbox->append(*body_label);
+
+    // If actions exist, add buttons
+    if (!notify.actions.empty()) {
+        auto actions_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 6);
+        for (size_t i = 0; i + 1 < notify.actions.size(); i += 2) {
+            std::string action_id    = notify.actions[i];
+            std::string action_label = notify.actions[i + 1];
+
+            auto btn = Gtk::make_managed<Gtk::Button>();
+            btn->set_label(action_label);
+
+            btn->add_css_class("notification-button");
+            btn->signal_clicked().connect([this, action_id, cb = notify.on_action]() {
+                if (cb) {
+                    cb(action_id);
+                    this->signal_close.emit(this->notificationId);
+                }
+            });
+            actions_box->append(*btn);
+        }
+        vbox->append(*actions_box);
+    }
+
+    set_child(*vbox);
+}

src/widgets/notification/spotifyNotification.cpp

@@ -1,5 +1,7 @@
 #include "widgets/notification/spotifyNotification.hpp"
+#include <sys/types.h>
 
+#include "helpers/string.hpp"
 #include "services/textureCache.hpp"
 
 #include "gtkmm/box.h"
@@ -8,7 +10,7 @@
 #include "gtkmm/image.h"
 #include "gtkmm/label.h"
 
-SpotifyNotification::SpotifyNotification(std::shared_ptr<Gdk::Monitor> monitor, MprisPlayer2Message mpris) : BaseNotification(monitor) {
+SpotifyNotification::SpotifyNotification(uint64_t notificationId, std::shared_ptr<Gdk::Monitor> monitor, MprisPlayer2Message mpris) : BaseNotification(notificationId, monitor) {
     auto container = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 10);
     container->set_hexpand(true);
 
@@ -30,7 +32,8 @@ SpotifyNotification::SpotifyNotification(std::shared_ptr<Gdk::Monitor> monitor,
     title_label->set_halign(Gtk::Align::CENTER);
     title_label->set_ellipsize(Pango::EllipsizeMode::END);
 
-    auto artistLabel = Gtk::make_managed<Gtk::Label>(mpris.artist);
+    auto artistLabel = Gtk::make_managed<Gtk::Label>();
+    artistLabel->set_text(StringHelper::trimToSize(mpris.artist[0], 30));
     artistLabel->set_hexpand(true);
     artistLabel->set_halign(Gtk::Align::CENTER);
 
@@ -57,7 +60,7 @@ std::unique_ptr<Gtk::CenterBox> SpotifyNotification::createButtonBox(MprisPlayer
     backButton->signal_clicked().connect([this, mpris]() {
         if (mpris.previous) {
             mpris.previous();
-            this->close();
+            this->signal_close.emit(this->notificationId);
         }
     });
 
@@ -84,7 +87,7 @@ std::unique_ptr<Gtk::CenterBox> SpotifyNotification::createButtonBox(MprisPlayer
     nextButton->signal_clicked().connect([this, mpris]() {
         if (mpris.next) {
             mpris.next();
-            this->close();
+            this->signal_close.emit(this->notificationId);
         }
     });
     buttonBox->set_start_widget(*backButton);

src/widgets/tray.cpp

@@ -6,7 +6,7 @@
 #include <cmath>
 #include <graphene.h>
 #include <utility>
-#include <iostream>
+#include <spdlog/spdlog.h>
 #include "components/base/button.hpp"
 
 namespace {
@@ -168,11 +168,13 @@ void log_menu_tree(const std::vector<TrayService::MenuNode> &nodes,
         if (!node.visible) {
             continue;
         }
-        std::cerr << "[TrayIconWidget] menu node id=" << node.id
+        spdlog::debug(
-                  << " label='" << node.label << "' enabled="
+            "[TrayIconWidget] menu node id={} label='{}' enabled={} sep={} depth={}",
-                  << (node.enabled ? "1" : "0") << " sep="
+            node.id,
-                  << (node.separator ? "1" : "0") << " depth=" << depth
+            node.label,
-                  << std::endl;
+            node.enabled ? 1 : 0,
+            node.separator ? 1 : 0,
+            depth);
         if (!node.children.empty()) {
             log_menu_tree(node.children, depth + 1);
         }
@@ -299,8 +301,8 @@ void TrayIconWidget::on_primary_released(int /*n_press*/, double x, double y) {
         }
     }
 
-    std::cerr << "[TrayIconWidget] Activate primary id=" << id << " x="
+    spdlog::debug("[TrayIconWidget] Activate primary id={} x={} y={}", id, sendX,
-              << sendX << " y=" << sendY << std::endl;
+                  sendY);
     service.activate(id, sendX, sendY);
 }
 
@@ -317,8 +319,9 @@ void TrayIconWidget::on_middle_released(int /*n_press*/, double x, double y) {
         }
     }
 
-    std::cerr << "[TrayIconWidget] SecondaryActivate (middle) id=" << id
+    spdlog::debug(
-              << " x=" << sendX << " y=" << sendY << std::endl;
+        "[TrayIconWidget] SecondaryActivate (middle) id={} x={} y={}", id,
+        sendX, sendY);
     service.secondaryActivate(id, sendX, sendY);
 }
 
@@ -329,8 +332,9 @@ void TrayIconWidget::on_secondary_released(int /*n_press*/, double x,
     // would crash without a mapped surface.
     GtkWidget *selfWidget = GTK_WIDGET(gobj());
     if (!gtk_widget_get_mapped(selfWidget) || !has_popup_surface(selfWidget)) {
-        std::cerr << "[TrayIconWidget] Secondary fallback ContextMenu (no surface) id="
+        spdlog::debug(
-                  << id << std::endl;
+            "[TrayIconWidget] Secondary fallback ContextMenu (no surface) id={}",
+            id);
         service.contextMenu(id, -1, -1);
         return;
     }
@@ -341,8 +345,7 @@ void TrayIconWidget::on_secondary_released(int /*n_press*/, double x,
     // Use dbusmenu popover when available and we have a mapped surface; else
     // fall back to the item's ContextMenu.
     if (hasRemoteMenu && has_popup_surface(selfWidget)) {
-        std::cerr << "[TrayIconWidget] Requesting dbusmenu for id=" << id
+        spdlog::debug("[TrayIconWidget] Requesting dbusmenu for id={}", id);
-                  << std::endl;
         menuPopupPending = true;
         if (menuRequestInFlight) {
             return;
@@ -367,12 +370,12 @@ void TrayIconWidget::on_secondary_released(int /*n_press*/, double x,
         (void)try_get_global_pointer_coords(GTK_WIDGET(gobj()), sendX, sendY);
     }
     if (is_wayland_display(GTK_WIDGET(gobj()))) {
-        std::cerr << "[TrayIconWidget] ContextMenu wayland id=" << id
+        spdlog::debug(
-                  << " x=-1 y=-1" << std::endl;
+            "[TrayIconWidget] ContextMenu wayland id={} x=-1 y=-1", id);
         service.contextMenu(id, -1, -1);
     } else {
-        std::cerr << "[TrayIconWidget] ContextMenu id=" << id << " x=" << sendX
+        spdlog::debug("[TrayIconWidget] ContextMenu id={} x={} y={}", id,
-                  << " y=" << sendY << std::endl;
+                      sendX, sendY);
         service.contextMenu(id, sendX, sendY);
     }
 }
@@ -518,9 +521,8 @@ void TrayIconWidget::on_menu_action(const Glib::VariantBase & /*parameter*/,
     int32_t sendY = -1;
     (void)try_get_pending_coords(sendX, sendY);
 
-    std::cerr << "[TrayIconWidget] Menu action id=" << this->id
+    spdlog::debug("[TrayIconWidget] Menu action id={} item={} x={} y={}",
-              << " item=" << itemId << " x=" << sendX << " y=" << sendY
+                  this->id, itemId, sendX, sendY);
-              << std::endl;
 
     const uint32_t nowMs = static_cast<uint32_t>(g_get_monotonic_time() / 1000);
     // Use button 1 for menu activation events; some dbusmenu handlers ignore

src/widgets/volumeWidget.cpp

@@ -1,7 +1,7 @@
 #include "widgets/volumeWidget.hpp"
 
 #include <cmath>
-#include <iostream>
+#include <spdlog/spdlog.h>
 #include <regex>
 #include <sigc++/functors/mem_fun.h>
 
@@ -26,8 +26,7 @@ VolumeWidget::VolumeWidget() : Gtk::Box(Gtk::Orientation::HORIZONTAL) {
             (void)CommandHelper::exec(
                 "wpctl set-mute @DEFAULT_SINK@ toggle");
         } catch (const std::exception &ex) {
-            std::cerr << "[VolumeWidget] failed to toggle mute: " << ex.what()
+            spdlog::error("[VolumeWidget] failed to toggle mute: {}", ex.what());
-                      << std::endl;
         }
         this->update();
     });
@@ -77,8 +76,7 @@ void VolumeWidget::update() {
             }
         }
     } catch (const std::exception &ex) {
-        std::cerr << "[VolumeWidget] failed to read volume: " << ex.what()
+        spdlog::error("[VolumeWidget] failed to read volume: {}", ex.what());
-                  << std::endl;
         label.set_text("N/A");
     }
 }