fix timer

CMakeLists.txt

@@ -47,6 +47,7 @@ target_sources(bar_lib
     src/connection/httpConnection.cpp
     src/connection/dbus/notification.cpp
     src/connection/dbus/mpris.cpp
+    src/connection/dbus/bluetooth.cpp
     src/connection/dbus/tray.cpp
 
     src/widgets/clock.cpp
@@ -57,16 +58,19 @@ target_sources(bar_lib
     src/widgets/notification/spotifyNotification.cpp
     src/widgets/controlCenter/controlCenter.cpp
     src/widgets/controlCenter/mediaWidget.cpp
+    src/widgets/controlCenter/timer.cpp
     src/widgets/volumeWidget.cpp
     src/widgets/weather.cpp
     src/widgets/webWidget.cpp
     src/widgets/tray.cpp
+    src/widgets/controlCenter/bluetoothSettings.cpp
+    src/widgets/controlCenter/settings.cpp
+    src/widgets/controlCenter/bluetoothSettingsRow.cpp
     
     src/services/hyprland.cpp
     src/services/notificationController.cpp
     src/services/textureCache.cpp
 
-
     src/components/popover.cpp
     src/components/workspaceIndicator.cpp
 )

include/app.hpp

@@ -1,29 +1,38 @@
 #pragma once
 
-#include <vector>
+#include <memory>
 
 #include "bar/bar.hpp"
+#include "connection/dbus/bluetooth.hpp"
 #include "connection/dbus/notification.hpp"
 #include "connection/dbus/tray.hpp"
 #include "services/hyprland.hpp"
+#include "services/notificationController.hpp"
 
+#include "gdkmm/monitor.h"
 #include "glibmm/refptr.h"
 #include "gtkmm/application.h"
 
-class MprisController;
-
 class App {
   public:
+    struct BarMonitorPair {
+        std::shared_ptr<Bar> bar;
+        std::shared_ptr<Gdk::Monitor> window;
+    };
+
     App();
 
     int run();
 
   private:
     Glib::RefPtr<Gtk::Application> app;
-    std::vector<std::shared_ptr<Bar>> bars;
-    std::shared_ptr<NotificationService> notificationService = nullptr;
-    std::shared_ptr<MprisController> mprisController         = nullptr;
-    HyprlandService *hyprlandService                         = nullptr;
+    std::map<std::string, BarMonitorPair> bars;
+
+    std::shared_ptr<NotificationService> notificationService       = NotificationService::getInstance();
+    std::shared_ptr<NotificationController> notificationController = NotificationController::getInstance();
+    std::shared_ptr<BluetoothController> bluetoothController       = BluetoothController::getInstance();
+    std::shared_ptr<MprisController> mprisController               = MprisController::getInstance();
+    std::shared_ptr<HyprlandService> hyprlandService               = HyprlandService::getInstance();
 
     TrayService *trayService = TrayService::getInstance();
     void setupServices();

include/components/button/iconButton.hpp

@@ -7,6 +7,6 @@
 
 class IconButton : public TextButton {
   public:
-    IconButton(Icon::Type icon, std::string fontFamilyCss = "materia-icons");
+    IconButton(Icon::Type icon, std::string fontFamilyCss = "material-icons");
     void setIcon(Icon::Type icon);
 };

include/components/timer.hpp

@@ -0,0 +1,105 @@
+#pragma once
+
+#include <iomanip>
+#include <iostream>
+#include <memory>
+#include <sys/types.h>
+
+#include "components/button/iconButton.hpp"
+#include "services/timerService.hpp"
+
+#include "gtkmm/box.h"
+#include "gtkmm/label.h"
+
+namespace {
+std::string format_duration(const std::string &digits) {
+    std::string d = digits;
+    if (d.size() > 6) {
+        d = d.substr(d.size() - 6);
+    }
+    if (d.empty()) {
+        return "";
+    }
+
+    std::string padded = std::string(6 - d.size(), '0') + d;
+
+    int h = std::stoi(padded.substr(0, 2));
+    int m = std::stoi(padded.substr(2, 2));
+    int s = std::stoi(padded.substr(4, 2));
+
+    std::ostringstream out;
+    if (h > 0) {
+        out << h << "h " << std::setw(2) << std::setfill('0') << m << "m "
+            << std::setw(2) << std::setfill('0') << s << "s";
+    } else if (m > 0) {
+        out << m << "m " << std::setw(2) << std::setfill('0') << s << "s";
+    } else {
+        out << s << "s";
+    }
+
+    return out.str();
+}
+} // namespace
+class Timer : public Gtk::Box {
+  public:
+    Timer(const std::string &duration, uint64_t timerId) {
+        uint32_t totalTime = std::stoul(duration);
+        u_int64_t seconds  = totalTime % 100;
+        u_int64_t minutes  = (totalTime / 100) % 100;
+        u_int64_t hours    = totalTime / 10000;
+
+        u_int64_t totalSeconds = hours * 3600 + minutes * 60 + seconds + 1; // +1 to account for the first tick happening after 1 second
+
+        this->timeLeft   = totalSeconds;
+        this->timerLabel = std::make_shared<Gtk::Label>(format_duration(duration));
+        timerLabel->add_css_class("control-center-timer-label");
+
+        auto timerBox = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 5);
+        timerBox->append(*timerLabel);
+
+        auto cancelButton = Gtk::make_managed<IconButton>(Icon::Type::TOKEN);
+        cancelButton->set_tooltip_text("Cancel Timer");
+        cancelButton->signal_clicked().connect([this, timerId]() {
+            this->timerService->removeTimer(timerId);
+        });
+        timerBox->append(*cancelButton);
+        this->append(*timerBox);
+    }
+
+    void activateTimer() {
+        // std::cout << "Timer activated" << std::endl;
+    }
+
+    void updateTimeLeft(uint64_t timeValue) {
+        uint64_t s            = timeValue % 100;
+        uint64_t m            = (timeValue / 100) % 100;
+        uint64_t h            = timeValue / 10000;
+        uint64_t totalSeconds = h * 3600 + m * 60 + s;
+        this->timeLeft        = totalSeconds;
+
+        std::ostringstream out;
+        if (h > 0) {
+            out << h << "h " << std::setw(2) << std::setfill('0') << m << "m "
+                << std::setw(2) << std::setfill('0') << s << "s";
+        } else if (m > 0) {
+            out << m << "m " << std::setw(2) << std::setfill('0') << s << "s";
+        } else {
+            out << s << "s";
+        }
+
+        this->timerLabel->set_text(out.str());
+    }
+
+    void tickDown() {
+        if (timeLeft > 0) {
+            this->updateTimeLeft(this->timeLeft - 1);
+        } else {
+            timeLeft = 0;
+        }
+    }
+
+  private:
+    std::shared_ptr<TimerService> timerService = TimerService::getInstance();
+    uint64_t timeLeft;
+    std::shared_ptr<Gtk::Label> timerLabel;
+};

include/components/types/icon.hpp

@@ -22,6 +22,20 @@ class Icon {
         CONTENT_COPY,
 
         TOKEN,
+
+        SETTINGS,
+        POWER_SETTINGS_NEW,
+        BLUETOOTH,
+        BLUETOOTH_CONNECTED,
+        BLUETOOTH_SEARCHING,
+        LINK,
+        LINK_OFF,
+
+        VERIFIED,
+        VERIFIED_OFF,
+
+        DONE_ALL,
+        REMOVE_DONE,
     };
 
     static const std::string toString(Type type) {
@@ -46,5 +60,19 @@ class Icon {
         {CONTENT_COPY, "\ue14d"},
 
         {TOKEN, "\uea25"},
+
+        {SETTINGS, "\ue8b8"},
+        {POWER_SETTINGS_NEW, "\ue8ac"},
+        {BLUETOOTH, "\ue1a7"},
+        {BLUETOOTH_CONNECTED, "\ue1a8"},
+        {BLUETOOTH_SEARCHING, "\ue1aa"},
+        {LINK, "\ue157"},
+        {LINK_OFF, "\ue16f"},
+
+        {VERIFIED, "\uef76"},
+        {VERIFIED_OFF, "\uf30e"},
+      
+        {DONE_ALL, "\ue877"},
+        {REMOVE_DONE, "\ue9d3"},
     };
 };

include/connection/dbus/bluetooth.hpp

@@ -0,0 +1,128 @@
+#pragma once
+
+#include <cstdint>
+#include <giomm.h>
+#include <map>
+#include <memory>
+#include <sigc++/sigc++.h>
+#include <string>
+#include <vector>
+
+#include "connection/dbus/dbus.hpp"
+
+struct BluetoothDevice {
+    std::string object_path;
+    std::string address;
+    std::string name;
+    std::string icon;
+    bool paired    = false;
+    bool connected = false;
+    bool trusted   = false;
+    int16_t rssi   = 0;
+};
+
+class BluetoothController : public DbusConnection {
+    using PropertiesMap = std::map<Glib::ustring, Glib::VariantBase>;
+
+  public:
+    static std::shared_ptr<BluetoothController> getInstance() {
+        if (!instance) {
+            instance = std::shared_ptr<BluetoothController>(new BluetoothController());
+        }
+        return instance;
+    }
+
+    // Adapter control
+    void setPowered(bool powered);
+    bool isPowered() const;
+
+    // Discovery
+    void startDiscovery();
+    void stopDiscovery();
+    bool isDiscovering() const;
+
+    // Device actions (identified by object_path)
+    void pairDevice(const std::string &object_path);
+    void unpairDevice(const std::string &object_path);
+    void connectDevice(const std::string &object_path);
+    void disconnectDevice(const std::string &object_path);
+    void trustDevice(const std::string &object_path, bool trusted);
+
+    // Queries
+    std::vector<BluetoothDevice> getDevices() const;
+    std::vector<BluetoothDevice> getPairedDevices() const;
+
+    // Signals
+    sigc::signal<void(bool)> &signalPoweredChanged();
+    sigc::signal<void(bool)> &signalDiscoveringChanged();
+    sigc::signal<void(const BluetoothDevice &)> &signalDeviceAdded();
+    sigc::signal<void(const std::string &)> &signalDeviceRemoved();
+    sigc::signal<void(const BluetoothDevice &)> &signalDeviceChanged();
+
+  private:
+    BluetoothController();
+
+    inline static std::shared_ptr<BluetoothController> instance = nullptr;
+
+    bool m_powered     = false;
+    bool m_discovering = false;
+
+    std::string m_adapter_path;
+    Glib::RefPtr<Gio::DBus::Proxy> m_adapter_proxy;
+    Glib::RefPtr<Gio::DBus::Proxy> m_object_manager_proxy;
+
+    std::map<std::string, BluetoothDevice> m_devices;
+    std::map<std::string, Glib::RefPtr<Gio::DBus::Proxy>> m_device_proxies;
+
+    sigc::signal<void(bool)> m_powered_signal;
+    sigc::signal<void(bool)> m_discovering_signal;
+    sigc::signal<void(const BluetoothDevice &)> m_device_added_signal;
+    sigc::signal<void(const std::string &)> m_device_removed_signal;
+    sigc::signal<void(const BluetoothDevice &)> m_device_changed_signal;
+
+    // Bus setup
+    void onBusConnected(const Glib::RefPtr<Gio::AsyncResult> &result);
+    void enumerateObjects();
+    void parseInterfaces(const std::string &object_path, const Glib::VariantBase &interfaces_var);
+
+    // ObjectManager signals
+    void onObjectManagerSignal(const Glib::ustring &sender_name,
+                               const Glib::ustring &signal_name,
+                               const Glib::VariantContainerBase &parameters);
+
+    // Agent
+    guint m_agent_id = 0;
+    void registerAgent();
+    void on_agent_method_call(const Glib::RefPtr<Gio::DBus::Connection> &connection,
+                              const Glib::ustring &sender,
+                              const Glib::ustring &object_path,
+                              const Glib::ustring &interface_name,
+                              const Glib::ustring &method_name,
+                              const Glib::VariantContainerBase &parameters,
+                              const Glib::RefPtr<Gio::DBus::MethodInvocation> &invocation);
+
+    // Adapter
+    void setupAdapter(const std::string &path, const PropertiesMap &properties);
+    void onAdapterPropertiesChanged(const Gio::DBus::Proxy::MapChangedProperties &changed,
+                                    const std::vector<Glib::ustring> &invalidated);
+
+    // Devices
+    void addDevice(const std::string &path, const PropertiesMap &properties);
+    void removeDevice(const std::string &path);
+    void onDevicePropertiesChanged(const std::string &object_path,
+                                   const Gio::DBus::Proxy::MapChangedProperties &changed,
+                                   const std::vector<Glib::ustring> &invalidated);
+
+    // Helpers
+    static BluetoothDevice parseDeviceProperties(const std::string &path, const PropertiesMap &properties);
+    void setDbusProperty(const std::string &object_path,
+               const std::string &interface,
+               const std::string &property,
+               const Glib::VariantBase &value);
+
+    // HID Authorization handler
+    void authorizeHIDDevice(const std::string &object_path);
+
+    Glib::RefPtr<Gio::DBus::NodeInfo> m_node_info;
+    std::shared_ptr<Gio::DBus::InterfaceVTable> m_interface_vtable;
+};

include/connection/dbus/dbus.hpp

@@ -14,6 +14,10 @@ class DbusConnection {
         Gio::DBus::Connection::get(Gio::DBus::BusType::SESSION, callback);
     }
 
+    void connect_system_async(const sigc::slot<void(const Glib::RefPtr<Gio::AsyncResult> &)> &callback) {
+        Gio::DBus::Connection::get(Gio::DBus::BusType::SYSTEM, callback);
+    }
+
     static void ensure_gio_init() {
         try {
             Gio::init();

include/connection/dbus/messages.hpp

@@ -37,11 +37,15 @@ struct NotifyMessage {
     std::string body;
     std::vector<std::string> actions;
     NotificationUrgency urgency = NORMAL;
-    int32_t expire_timeout;
+    int32_t expire_timeout      = -1;
     // Callback to invoke when an action is triggered
     std::function<void(const std::string &action_id)> on_action;
     // Guard to prevent multiple action invocations across mirrors
-    std::shared_ptr<bool> actionInvoked;
+    std::shared_ptr<bool> actionInvoked = std::make_shared<bool>(false);
     // image data (if any) from dbus
     std::optional<Glib::RefPtr<Gdk::Pixbuf>> imageData;
+
+    bool has_input = false;
+    std::string input_placeholder;
+    std::function<void(const std::string &)> on_input;
 };

include/connection/dbus/notification.hpp

@@ -4,6 +4,7 @@
 #include <giomm.h>
 #include <gtkmm.h>
 #include <sigc++/sigc++.h>
+#include <sys/stat.h>
 
 #include "connection/dbus/dbus.hpp"
 
@@ -43,7 +44,17 @@ const Glib::ustring introspection_xml = R"(
 
 class NotificationService : public DbusConnection {
   public:
-    NotificationService() : notificationIdCounter(1) {
+    static std::shared_ptr<NotificationService> getInstance() {
+        if (NotificationService::instance == nullptr) {
+            NotificationService::instance = std::shared_ptr<NotificationService>(new NotificationService());
+        }
+        return NotificationService::instance;
+    }
+
+    void onBusAcquired(const Glib::RefPtr<Gio::DBus::Connection> &connection, const Glib::ustring &name);
+
+  private:
+    NotificationService() {
         Gio::DBus::own_name(
             Gio::DBus::BusType::SESSION,
             "org.freedesktop.Notifications",
@@ -53,10 +64,9 @@ class NotificationService : public DbusConnection {
             Gio::DBus::BusNameOwnerFlags::REPLACE);
     }
 
-    void onBusAcquired(const Glib::RefPtr<Gio::DBus::Connection> &connection, const Glib::ustring &name);
+    static inline std::shared_ptr<NotificationService> instance = nullptr;
 
-  private:
-    guint notificationIdCounter;
+    guint notificationIdCounter = 0;
     const Gio::DBus::InterfaceVTable &getMessageInterfaceVTable();
     void on_method_call(const Glib::RefPtr<Gio::DBus::Connection> &connection,
                         const Glib::ustring &sender,

include/helpers/hypr.hpp

@@ -4,8 +4,8 @@
 #include <array>
 #include <cassert>
 #include <cstring>
-#include <span>
 #include <nlohmann/json.hpp>
+#include <span>
 #include <string>
 #include <sys/socket.h>
 #include <sys/un.h>
@@ -57,7 +57,7 @@ class HyprctlHelper {
         int socketFd = socket(AF_UNIX, SOCK_STREAM, 0);
         assert(socketFd != -1 && "Failed to create Hyprland command socket");
 
-        struct sockaddr_un addr {};
+        struct sockaddr_un addr{};
         std::memset(&addr, 0, sizeof(addr));
         addr.sun_family = AF_UNIX;
 
@@ -78,7 +78,7 @@ class HyprctlHelper {
 
         std::string response;
         constexpr size_t kBufferSize = 4096;
-        std::array<char, kBufferSize> buffer {};
+        std::array<char, kBufferSize> buffer{};
         while (true) {
             ssize_t bytesRead = recv(socketFd, buffer.data(), buffer.size(), 0);
             if (bytesRead <= 0) {

include/helpers/string.hpp

@@ -41,6 +41,12 @@ class StringHelper {
         if (input.length() <= maxSize) {
             return input;
         }
-        return input.substr(0, maxSize) + "...";
+
+        size_t len = maxSize;
+        while (len > 0 && (static_cast<unsigned char>(input[len]) & 0xC0) == 0x80) {
+            len--;
+        }
+
+        return input.substr(0, len) + "...";
     }
 };

include/services/bluetooth.hpp

@@ -1,49 +0,0 @@
-#pragma once
-
-#include <gio/gio.h>
-#include <gtk/gtk.h>
-#include <string>
-#include <vector>
-
-#include "sigc++/signal.h"
-
-class BluetoothService {
-    inline static BluetoothService *instance = nullptr;
-
-  public:
-    sigc::signal<void(bool)> powerStateChangedSignal;
-    sigc::signal<void(bool)> isDiscoveringChangedSignal;
-
-    bool getPowerState();
-    bool getIsDiscovering();
-
-    void togglePowerState();
-    void toggleIsDiscovering();
-
-    static BluetoothService *getInstance() {
-        if (BluetoothService::instance == nullptr) {
-
-            BluetoothService::instance = new BluetoothService();
-        }
-        return BluetoothService::instance;
-    }
-
-  private:
-    BluetoothService();
-
-    GDBusProxy *adapter_proxy = nullptr;
-
-    std::vector<std::string> getDeviceObjectPaths();
-    bool powerState    = false;
-    bool isDiscovering = false;
-
-    void onPropertyChanged(GDBusProxy *proxy,
-                           GVariant *changed_properties,
-                           const gchar *const *invalidated_properties,
-                           gpointer user_data);
-
-    static void onPropertyChangedStatic(GDBusProxy *proxy,
-                                        GVariant *changed_properties,
-                                        const gchar *const *invalidated_properties,
-                                        gpointer user_data);
-};

include/services/hyprland.hpp

@@ -17,7 +17,7 @@
 #define NUM_WORKSPACES 7
 
 class HyprlandService {
-    inline static HyprlandService *instance = nullptr;
+    static inline std::shared_ptr<HyprlandService> instance;
 
   public:
     struct Client {
@@ -49,9 +49,9 @@ class HyprlandService {
         std::shared_ptr<Bar> bar;
     };
 
-    static HyprlandService *getInstance() {
+    static std::shared_ptr<HyprlandService> getInstance() {
         if (!instance) {
-            instance = new HyprlandService();
+            instance = std::shared_ptr<HyprlandService>(new HyprlandService());
         }
         return instance;
     }
@@ -60,7 +60,12 @@ class HyprlandService {
 
     void addBar(std::shared_ptr<Bar> bar, std::string monitorName);
 
+    sigc::signal<void(std::string)> &signal_monitor_added() { return m_signal_monitor_added; }
+    sigc::signal<void(std::string)> &signal_monitor_removed() { return m_signal_monitor_removed; }
+
   private:
+    HyprlandService();
+
     enum SocketEventType {
         WORKSPACE_CHANGED,
 
@@ -72,6 +77,7 @@ class HyprlandService {
 
         FOCUSED_MONITOR,
         MONITOR_REMOVED,
+        MONITOR_ADDED,
     };
 
     std::map<std::string, SocketEventType> socketEventTypeMap = {
@@ -83,7 +89,9 @@ class HyprlandService {
         {"urgent", URGENT},
         {"focusedmon", FOCUSED_MONITOR},
         {"monitorremoved", MONITOR_REMOVED},
+        {"monitoradded", MONITOR_ADDED},
     };
+
     void onWorkspaceChanged(int workspaceId);
     void onFocusedMonitorChanged(std::string monitorData);
     void onOpenWindow(std::string windowData);
@@ -92,16 +100,15 @@ class HyprlandService {
     void onUrgent(std::string windowAddress);
     void onActiveWindowChanged(std::string windowAddress);
     void onMonitorRemoved(std::string monitorName);
-    // void onMonitorAdded(std::string monitorName);
+    void onMonitorAdded(std::string monitorName);
 
-    HyprlandService();
     std::map<std::string, std::shared_ptr<Monitor>> monitors;
     std::map<int, std::shared_ptr<Workspace>> workspaces;
     std::map<std::string, std::shared_ptr<Client>> clients;
 
     /// maybe refactor into reusable class
     std::string socketBuffer;
-    int socketFd;
+    int socketFd = -1;
     ///
 
     void bindHyprlandSocket();
@@ -112,4 +119,7 @@ class HyprlandService {
     void refreshIndicator(std::shared_ptr<Workspace> workspace);
 
     void handleSocketMessage(SocketHelper::SocketMessage message);
+
+    sigc::signal<void(std::string)> m_signal_monitor_added;
+    sigc::signal<void(std::string)> m_signal_monitor_removed;
 };

include/services/notificationController.hpp

@@ -12,11 +12,11 @@
 #include "gdkmm/monitor.h"
 
 class NotificationController {
-    static std::shared_ptr<NotificationController> instance;
+    inline static std::shared_ptr<NotificationController> instance = nullptr;
 
   public:
     static std::shared_ptr<NotificationController> getInstance() {
-        if (!NotificationController::instance) {
+        if (NotificationController::instance == nullptr) {
             NotificationController::instance = std::shared_ptr<NotificationController>(new NotificationController());
         }
         return NotificationController::instance;
@@ -26,12 +26,15 @@ class NotificationController {
     void showNotificationOnAllMonitors(NotifyMessage notify);
     void showCopyNotification(NotifyMessage notify);
 
+    void addMonitor(std::shared_ptr<Gdk::Monitor> monitor);
+    void removeMonitor(std::shared_ptr<Gdk::Monitor> monitor);
+
   private:
     uint64_t globalNotificationId = 1;
     std::map<uint64_t, std::vector<std::shared_ptr<BaseNotification>>> activeNotifications;
     std::map<uint64_t, int> hoverCounts;
     NotificationController();
-    std::vector<std::shared_ptr<Gdk::Monitor>> activeMonitors;
+    std::map<std::string, std::shared_ptr<Gdk::Monitor>> activeMonitors;
     void updateHoverState(uint64_t notificationId, bool isHovered);
     void closeNotification(uint64_t notificationId);
 };

include/services/textureCache.hpp

@@ -12,9 +12,11 @@ class TextureCacheService {
 
     Glib::RefPtr<Gdk::Texture> getTexture(const std::string &url);
     void pruneCache();
+    void clear();
 
   private:
-    TextureCacheService() = default;
+    TextureCacheService();
+    ~TextureCacheService();
 
     std::unordered_map<std::string, Glib::RefPtr<Gdk::Texture>> cache;
 };

include/services/timerService.hpp

@@ -0,0 +1,129 @@
+#pragma once
+
+#include <map>
+#include <memory>
+#include <spdlog/spdlog.h>
+#include <sys/types.h>
+
+#include "glibmm/main.h"
+#include "gtkmm/mediafile.h"
+#include "gtkmm/mediastream.h"
+#include "sigc++/signal.h"
+
+class TimerService {
+    struct TimerData {
+        uint64_t duration;
+        uint64_t timerId;
+    };
+
+  public:
+    static std::shared_ptr<TimerService> getInstance() {
+        if (!instance) {
+            instance = std::shared_ptr<TimerService>(new TimerService());
+
+            // add a timer to tick every second
+            Glib::signal_timeout().connect([]() {
+                instance->tick();
+                return true; // continue calling every second
+            },
+                                           1000);
+        }
+        return instance;
+    }
+
+    void addTimer(uint64_t duration) {
+        this->timerAddedSignal.emit(std::to_string(duration), timerIdCounter);
+
+        this->activeTimers[timerIdCounter] = TimerData{.duration = duration, .timerId = timerIdCounter};
+
+        timerIdCounter++;
+    }
+
+    void expireTimer(uint64_t timerId) {
+        this->timerExpiredSignal.emit(timerId);
+
+        if (ringingTimerCounter == 0) {
+            mediaFile->set_volume(1.0);
+            mediaFile->set_loop(true);
+            mediaFile->play();
+            spdlog::info("Playing timer sound");
+        }
+
+        ringingTimerCounter++;
+    }
+
+    void removeTimer(uint64_t timerId) {
+        ringingTimerCounter--;
+        this->activeTimers.erase(timerId);
+        this->timerCancelledSignal.emit(timerId);
+
+        if (ringingTimerCounter <= 0) {
+            ringingTimerCounter = 0;
+            mediaFile->pause();
+            spdlog::info("Paused timer sound");
+        }
+    }
+
+    sigc::signal<void(const std::string &, u_int64_t)> &getSignalTimerSet() {
+        return this->timerAddedSignal;
+    }
+
+    sigc::signal<void(u_int64_t)> &getSignalTimerExpired() {
+        return this->timerExpiredSignal;
+    }
+
+    sigc::signal<void(u_int64_t)> &getSignalTimerCancelled() {
+        return this->timerCancelledSignal;
+    }
+
+    sigc::signal<void()> tickSignal;
+
+  private:
+    TimerService() {
+        this->mediaFile = Gtk::MediaFile::create();
+        if (this->mediaFile) {
+            this->mediaFile->set_filename("/usr/share/sounds/freedesktop/stereo/alarm-clock-elapsed.oga");
+
+            // Connect to signals to debug playback issues
+            this->mediaFile->property_error().signal_changed().connect([]() {
+                if (auto err = mediaFile->get_error()) {
+                    spdlog::error("Timer sound error: {}", err.what());
+                }
+            });
+
+            this->mediaFile->property_prepared().signal_changed().connect([]() {
+                if (mediaFile->is_prepared()) {
+                    spdlog::info("Timer sound ready");
+                }
+            });
+        } else {
+            spdlog::error("Failed to create media file!");
+        }
+    }
+
+    inline static Glib::RefPtr<Gtk::MediaFile> mediaFile;
+
+    static inline uint64_t timerIdCounter       = 0;
+    static inline u_int64_t ringingTimerCounter = 0;
+    sigc::signal<void(const std::string &, u_int64_t)> timerAddedSignal;
+    sigc::signal<void(u_int64_t)> timerCancelledSignal;
+    sigc::signal<void(u_int64_t)> timerExpiredSignal;
+    inline static std::shared_ptr<TimerService> instance = nullptr;
+
+    std::map<uint64_t, TimerData> activeTimers;
+
+    void tick() {
+        for (auto &[id, timer] : activeTimers) {
+
+            if (timer.duration > 0) {
+                timer.duration--;
+            } else if (timer.duration == 0) {
+                spdlog::info("Timer {} expired", timer.timerId);
+                expireTimer(timer.timerId);
+                timer.duration = -1; // Mark as expired to prevent multiple expirations
+            }
+        }
+
+        tickSignal.emit();
+    }
+};

include/widgets/controlCenter/bluetoothSettings.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <spdlog/spdlog.h>
+
+#include "components/button/iconButton.hpp"
+#include "connection/dbus/bluetooth.hpp"
+
+#include "gtkmm/box.h"
+#include "gtkmm/scrolledwindow.h"
+
+#include "widgets/controlCenter/bluetoothSettingsRow.hpp"
+
+class BluetoothSettings : public Gtk::Box {
+  public:
+    BluetoothSettings();
+
+  private:
+    std::shared_ptr<BluetoothController> bluetoothController = BluetoothController::getInstance();
+    std::map<std::string, BluetoothDevice> activeBluetoothDevices;
+    std::map<std::string, std::shared_ptr<BluetoothSettingsRow>> deviceRows;
+
+    std::shared_ptr<IconButton> powerButton = std::make_shared<IconButton>(Icon::POWER_SETTINGS_NEW);
+    std::shared_ptr<IconButton> scanButton  = std::make_shared<IconButton>(Icon::BLUETOOTH_SEARCHING);
+
+    Gtk::Box buttonRow;
+    Gtk::Box connectedDevicesBox;
+    Gtk::ScrolledWindow connectedDevicesScroll;
+    Gtk::Box availableDevicesBox;
+    Gtk::ScrolledWindow availableDevicesScroll;
+
+    bool bluetoothIsPowered  = false;
+    bool bluetoothIsScanning = false;
+
+    void addBluetoothDevice(const BluetoothDevice &device);
+    void removeBluetoothDevice(const std::string &object_path);
+    void updateBluetoothDevice(const BluetoothDevice &device);
+
+    void setBluetoothPowered(bool powered);
+    void setScanning(bool scanning);
+};

include/widgets/controlCenter/bluetoothSettingsRow.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <spdlog/spdlog.h>
+#include "components/button/iconButton.hpp"
+#include "connection/dbus/bluetooth.hpp"
+#include "gtkmm/box.h"
+#include "gtkmm/button.h"
+#include "gtkmm/image.h"
+#include "gtkmm/label.h"
+
+class BluetoothSettingsRow : public Gtk::Box {
+  public:
+    BluetoothSettingsRow(const BluetoothDevice &device);
+    void updateDevice(const BluetoothDevice &device);
+
+  private:
+    BluetoothDevice device;
+    Gtk::Image icon;
+    Gtk::Label nameLabel;
+    Gtk::Label addressLabel;
+    IconButton pairButton;
+    IconButton connectButton;
+    IconButton trustButton;
+};

include/widgets/controlCenter/controlCenter.hpp

@@ -6,6 +6,8 @@
 #include "components/button/tabButton.hpp"
 #include "components/popover.hpp"
 #include "widgets/controlCenter/mediaWidget.hpp"
+#include "widgets/controlCenter/settings.hpp"
+#include "widgets/controlCenter/timer.hpp"
 #include "widgets/weather.hpp"
 
 #include "gtkmm/box.h"
@@ -26,9 +28,12 @@ class ControlCenter : public Popover {
     std::unique_ptr<TabButton> mediaTabButton;
     std::unique_ptr<TabButton> infoTabButton;
     std::unique_ptr<TabButton> timerButton;
+    std::unique_ptr<TabButton> settingsTabButton;
 
     std::unique_ptr<WeatherWidget> weatherWidget;
     std::unique_ptr<MediaWidget> mediaControlWidget;
+    std::unique_ptr<TimerWidget> timerWidget;
+    std::unique_ptr<SettingsWidget> settingsWidget;
 
     void addPlayerWidget(const std::string &bus_name);
     void removePlayerWidget(const std::string &bus_name);

include/widgets/controlCenter/mediaWidget.hpp

@@ -1,10 +1,10 @@
 #pragma once
 
-#include "components/mediaPlayer.hpp"
 #include <map>
 #include <memory>
 #include <string>
 
+#include "components/mediaPlayer.hpp"
 #include "connection/dbus/mpris.hpp"
 
 #include "gtkmm/box.h"

include/widgets/controlCenter/settings.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <map>
+
+#include "connection/dbus/bluetooth.hpp"
+#include "widgets/controlCenter/bluetoothSettings.hpp"
+
+#include "gtkmm/box.h"
+
+class SettingsWidget : public Gtk::Box {
+  public:
+    SettingsWidget();
+
+  private:
+    BluetoothSettings bluetoothSettings;
+};

include/widgets/controlCenter/timer.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <memory>
+#include <sigc++/connection.h>
+#include <sys/types.h>
+
+#include "components/timer.hpp"
+
+#include "gtkmm/box.h"
+
+class TimerWidget : public Gtk::Box {
+  public:
+    TimerWidget();
+    ~TimerWidget();
+    void addTimer(const std::string &duration, uint64_t timerId);
+    void removeTimer(uint64_t timerId);
+    void activateTimer(uint64_t timerId);
+
+  private:
+    std::shared_ptr<TimerService> timerService = TimerService::getInstance();
+    bool updatingText                          = false;
+    std::string rawDigits;
+
+    std::map<uint64_t, std::unique_ptr<Timer>> activeTimers;
+    sigc::connection timerSetConnection;
+    sigc::connection timerCancelledConnection;
+    sigc::connection timerExpiredConnection;
+    sigc::connection tickConnection;
+};

include/widgets/notification/baseNotification.hpp

@@ -2,6 +2,7 @@
 
 #include <chrono>
 #include <cstdint>
+#include <memory>
 #include <sigc++/connection.h>
 
 #include "gdkmm/monitor.h"
@@ -9,7 +10,7 @@
 
 #define DEFAULT_NOTIFICATION_TIMEOUT 6700
 
-class BaseNotification : public Gtk::Window {
+class BaseNotification : public Gtk::Window, public std::enable_shared_from_this<BaseNotification> {
   public:
     BaseNotification(uint64_t notificationId, std::shared_ptr<Gdk::Monitor> monitor);
 

main.cpp

@@ -1,7 +1,6 @@
 #include "app.hpp"
 
-int main()
-{
+int main() {
     App app;
 
     return app.run();

resources/bar.css

@@ -1,3 +1,27 @@
+/* Custom Scrollbar Styling */
+scrollbar, scrollbar * {
+	min-width: 8px;
+	background: transparent;
+}
+
+scrollbar slider {
+	background: rgba(255, 255, 255, 0.25);
+	border-radius: 6px;
+	min-width: 8px;
+}
+
+scrollbar slider:hover, scrollbar slider:active {
+	background: rgba(255, 255, 255, 0.45);
+}
+
+scrollbar trough {
+	background: rgba(255, 255, 255, 0.08);
+	border-radius: 6px;
+}
+
+scrollbar button {
+	background: transparent;
+}
 /** biome-ignore-all lint/correctness/noUnknownTypeSelector: gtk css has more valid identifiers */
 * {
 	all: unset;
@@ -16,28 +40,39 @@ window {
 	color: #ffffff;
 	font-size: 14px;
 	font-family: var(--text-font);
-	padding: 2px 6px;
+	padding: 3px;
+}
+
+
+.text-area {
+	font-family: var(--text-font-mono);
+	background-color: rgba(25, 25, 25, 0.8);
+	border-radius: 8px;
+	padding: 4px 8px;
 }
 
 .material-icons {
 	font-family: var(--icon-font-material);
 }
 
-.icon-button {
-	font-size: 20px;
+.power-button-on {
+	/* bright green */
+	background-color: rgba(0, 255, 0, 0.2);
 }
 
-.tab-icon {
-	font-size: 20px;
+.power-button-off {
+	/* bright red */
+	background-color: rgba(255, 0, 0, 0.2);
+	color: #ffffff;
 }
 
 .control-center-tab-row {
-	background-color: rgba(50, 50, 50, 0.8);
+	background-color: rgba(255, 255, 255, 0.1);
 	border-radius: 4px;
-	padding: 2px 4px;
-	margin-bottom: 4px;
 }
 
+
+
 .active-button {
 	background-color: #ffffff;
 	color: #1e1e1e;
@@ -46,20 +81,20 @@ window {
 }
 
 popover {
-	margin-top: 4px;
 	font-family: var(--text-font);	
-	border-radius: 4px;
+	border-radius: 12px;
 
-	background: rgba(25, 25, 25, 0.8);
+
+	background: rgba(25, 25, 25, 0.9);
 	box-shadow: 0 4px 30px rgba(0, 0, 0, 0.1);
 	border: 1px solid rgba(57, 57, 57, 0.71);
 }
 
 .control-center-popover {
+	margin-top: 6px;
 	background-color: rgba(35, 35, 35, 0.95);
 	padding: 12px;
 	padding-top : 6px;
-	border-radius: 4px;
 	box-shadow: 0 4px 30px rgba(0, 0, 0, 0.3);
 	border: 1px solid rgba(57, 57, 57, 0.8);
 }
@@ -67,7 +102,6 @@ popover {
 .control-center-player-container {
 	border-radius: 4px;
 	background: rgba(35, 35, 35, 0.95);
-	margin-bottom: 6px;
 }
 
 
@@ -137,7 +171,6 @@ tooltip {
 #spacer {
 	font-weight: 900;
 	padding: 0 5px;
-	text-shadow: 0 0 5px #ffffffaa;
 	border-radius: 4px;
 }
 
@@ -147,10 +180,10 @@ tooltip {
 }
 
 .workspace-pill {
-	padding: 2px 5px;
-	margin-right: 6px;
+	padding: 2px 4px;
 	border-radius: 4px;
-	text-shadow: 0 0 2px #646464;
+	margin: 0 2px;
+	color: #cccccc;
 	transition:
 		background-color 0.2s,
 		color 0.2s,
@@ -201,6 +234,17 @@ tooltip {
 	margin-top: 4px;
 }
 
+
+
+.icon-button {
+	font-weight: 700;
+	font-size: 18px;
+}
+
+.tab-icon {
+}
+
+
 @keyframes workspace-updown {
 	0% {
 		transform: translateY(4px);
@@ -228,3 +272,27 @@ tooltip {
 		opacity: 1;
 	}
 }
+
+.bluetooth-settings {
+	font-family: var(--text-font);
+	font-size: 14px;
+}
+
+.bluetooth-device-address {
+	font-size: 10px;
+	color: #cccccce7;
+}
+
+.bluetooth-settings-row {
+	transition: background-color 0.2s;
+}
+
+.active-devices {
+	background-color: rgba(0, 255, 0, 0.1);
+	border-radius: 4px;
+}
+
+.available-devices {
+	background-color: rgba(255, 255, 255, 0.1);
+	border-radius: 4px;
+}

src/app.cpp

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

src/bar/bar.cpp

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

src/components/button/iconButton.cpp

@@ -1,8 +1,8 @@
 #include "components/button/iconButton.hpp"
 
 IconButton::IconButton(Icon::Type icon, std::string fontFamilyCss) : TextButton(Icon::toString(icon)) {
+    this->get_style_context()->add_class("icon-button");
     this->get_style_context()->add_class(fontFamilyCss);
-    this->add_css_class("icon-button");
 }
 
 void IconButton::setIcon(Icon::Type icon) {

src/components/mediaControl.cpp

@@ -1,6 +1,5 @@
-#include "components/mediaPlayer.hpp"
-
 #include "components/button/iconButton.hpp"
+#include "components/mediaPlayer.hpp"
 #include "helpers/string.hpp"
 #include "services/textureCache.hpp"
 

src/components/popover.cpp

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

src/components/workspaceIndicator.cpp

@@ -6,7 +6,6 @@
 
 WorkspaceIndicator::WorkspaceIndicator(int id, std::string label, sigc::slot<void(int)> onClick)
     : Gtk::Box(Gtk::Orientation::HORIZONTAL) {
-
     overlay            = std::make_shared<Gtk::Overlay>();
     auto numLabel      = Gtk::make_managed<Gtk::Label>(label);
     auto pillContainer = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);

src/connection/dbus/bluetooth.cpp

@@ -0,0 +1,768 @@
+#include "connection/dbus/bluetooth.hpp"
+#include "services/notificationController.hpp"
+
+#include <spdlog/spdlog.h>
+#include <iomanip>
+#include <sstream>
+
+const std::string agent_introspection_xml = R"(
+<node>
+  <interface name="org.bluez.Agent1">
+    <method name="Release"/>
+    <method name="RequestPinCode">
+      <arg type="o" name="device" direction="in"/>
+      <arg type="s" name="pincode" direction="out"/>
+    </method>
+    <method name="DisplayPinCode">
+      <arg type="o" name="device" direction="in"/>
+      <arg type="s" name="pincode" direction="in"/>
+    </method>
+    <method name="RequestPasskey">
+      <arg type="o" name="device" direction="in"/>
+      <arg type="u" name="passkey" direction="out"/>
+    </method>
+    <method name="DisplayPasskey">
+      <arg type="o" name="device" direction="in"/>
+      <arg type="u" name="passkey" direction="in"/>
+      <arg type="q" name="entered" direction="in"/>
+    </method>
+    <method name="RequestConfirmation">
+      <arg type="o" name="device" direction="in"/>
+      <arg type="u" name="passkey" direction="in"/>
+    </method>
+    <method name="RequestAuthorization">
+      <arg type="o" name="device" direction="in"/>
+    </method>
+    <method name="AuthorizeService">
+      <arg type="o" name="device" direction="in"/>
+      <arg type="s" name="uuid" direction="in"/>
+    </method>
+    <method name="Cancel"/>
+  </interface>
+</node>
+)";
+
+BluetoothController::BluetoothController() {
+    connect_system_async(sigc::mem_fun(*this, &BluetoothController::onBusConnected));
+}
+
+sigc::signal<void(bool)> &BluetoothController::signalPoweredChanged() { return m_powered_signal; }
+sigc::signal<void(bool)> &BluetoothController::signalDiscoveringChanged() { return m_discovering_signal; }
+sigc::signal<void(const BluetoothDevice &)> &BluetoothController::signalDeviceAdded() { return m_device_added_signal; }
+sigc::signal<void(const std::string &)> &BluetoothController::signalDeviceRemoved() { return m_device_removed_signal; }
+sigc::signal<void(const BluetoothDevice &)> &BluetoothController::signalDeviceChanged() { return m_device_changed_signal; }
+
+bool BluetoothController::isPowered() const { return m_powered; }
+bool BluetoothController::isDiscovering() const { return m_discovering; }
+
+std::vector<BluetoothDevice> BluetoothController::getDevices() const {
+    std::vector<BluetoothDevice> result;
+    result.reserve(m_devices.size());
+    for (const auto &[_, device] : m_devices) {
+        result.push_back(device);
+    }
+    return result;
+}
+
+std::vector<BluetoothDevice> BluetoothController::getPairedDevices() const {
+    std::vector<BluetoothDevice> result;
+    for (const auto &[_, device] : m_devices) {
+        if (device.paired) {
+            result.push_back(device);
+        }
+    }
+    return result;
+}
+
+void BluetoothController::setPowered(bool powered) {
+    spdlog::info("Bluetooth: setting powered to {}", powered);
+    setDbusProperty(m_adapter_path, "org.bluez.Adapter1", "Powered",
+                    Glib::Variant<bool>::create(powered));
+}
+
+void BluetoothController::startDiscovery() {
+    spdlog::info("Bluetooth: starting discovery");
+    if (m_adapter_proxy) {
+        m_adapter_proxy->call("StartDiscovery");
+    }
+}
+
+void BluetoothController::stopDiscovery() {
+    spdlog::info("Bluetooth: stopping discovery");
+    if (m_adapter_proxy) {
+        m_adapter_proxy->call("StopDiscovery");
+    }
+}
+
+void BluetoothController::pairDevice(const std::string &object_path) {
+    spdlog::info("Bluetooth: pairing device {}", object_path);
+    auto it = m_device_proxies.find(object_path);
+    if (it != m_device_proxies.end() && it->second) {
+        it->second->call("Pair");
+    }
+}
+
+void BluetoothController::unpairDevice(const std::string &object_path) {
+    spdlog::info("Bluetooth: unpairing device {}", object_path);
+    if (!m_adapter_proxy)
+        return;
+
+    auto params = Glib::VariantContainerBase::create_tuple(
+        Glib::Variant<Glib::DBusObjectPathString>::create(object_path));
+    m_adapter_proxy->call("RemoveDevice", params);
+}
+
+void BluetoothController::connectDevice(const std::string &object_path) {
+    spdlog::info("Bluetooth: connecting device {}", object_path);
+    auto it = m_device_proxies.find(object_path);
+    if (it != m_device_proxies.end() && it->second) {
+        it->second->call("Connect");
+    }
+}
+
+void BluetoothController::disconnectDevice(const std::string &object_path) {
+    spdlog::info("Bluetooth: disconnecting device {}", object_path);
+    auto it = m_device_proxies.find(object_path);
+    if (it != m_device_proxies.end() && it->second) {
+        it->second->call("Disconnect");
+    }
+}
+
+void BluetoothController::trustDevice(const std::string &object_path, bool trusted) {
+    spdlog::info("Bluetooth: setting trusted={} for device {}", trusted, object_path);
+    setDbusProperty(object_path, "org.bluez.Device1", "Trusted",
+                    Glib::Variant<bool>::create(trusted));
+}
+
+// ---------------------------------------------------------------------------
+// Bus connection
+// ---------------------------------------------------------------------------
+
+void BluetoothController::onBusConnected(const Glib::RefPtr<Gio::AsyncResult> &result) {
+    if (!result) {
+        spdlog::error("Bluetooth: null async result");
+        return;
+    }
+
+    try {
+        connection = Gio::DBus::Connection::get_finish(result);
+
+        m_object_manager_proxy = Gio::DBus::Proxy::create_sync(
+            connection,
+            "org.bluez",
+            "/",
+            "org.freedesktop.DBus.ObjectManager");
+
+        if (m_object_manager_proxy) {
+            m_object_manager_proxy->signal_signal().connect(
+                sigc::mem_fun(*this, &BluetoothController::onObjectManagerSignal));
+
+            enumerateObjects();
+        }
+        
+        registerAgent();
+    } catch (const Glib::Error &ex) {
+        spdlog::error("Bluetooth DBus Connection Error: {}", ex.what());
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Enumerate existing BlueZ objects
+// ---------------------------------------------------------------------------
+
+void BluetoothController::enumerateObjects() {
+    if (!m_object_manager_proxy)
+        return;
+
+    try {
+        auto result  = m_object_manager_proxy->call_sync("GetManagedObjects");
+        auto objects = Glib::VariantBase::cast_dynamic<Glib::VariantContainerBase>(
+            result.get_child(0));
+
+        for (gsize i = 0; i < objects.get_n_children(); i++) {
+            auto entry = Glib::VariantBase::cast_dynamic<Glib::VariantContainerBase>(
+                objects.get_child(i));
+
+            auto path = static_cast<std::string>(
+                Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::DBusObjectPathString>>(
+                    entry.get_child(0))
+                    .get());
+
+            parseInterfaces(path, entry.get_child(1));
+        }
+    } catch (const Glib::Error &ex) {
+        spdlog::error("Bluetooth: Error enumerating objects: {}", ex.what());
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Parse an interfaces-and-properties dict  a{sa{sv}}
+// ---------------------------------------------------------------------------
+
+void BluetoothController::parseInterfaces(const std::string &object_path,
+                                          const Glib::VariantBase &interfaces_var) {
+    auto ifaces = Glib::VariantBase::cast_dynamic<Glib::VariantContainerBase>(interfaces_var);
+
+    for (gsize i = 0; i < ifaces.get_n_children(); i++) {
+        auto entry = Glib::VariantBase::cast_dynamic<Glib::VariantContainerBase>(
+            ifaces.get_child(i));
+
+        auto iface_name = static_cast<std::string>(
+            Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::ustring>>(
+                entry.get_child(0))
+                .get());
+
+        if (iface_name != "org.bluez.Device1" && iface_name != "org.bluez.Adapter1") {
+            continue;
+        }
+
+        auto props = Glib::VariantBase::cast_dynamic<Glib::Variant<PropertiesMap>>(
+                         entry.get_child(1))
+                         .get();
+
+        if (iface_name == "org.bluez.Device1") {
+            addDevice(object_path, props);
+        } else {
+            setupAdapter(object_path, props);
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// ObjectManager signal handler  (InterfacesAdded / InterfacesRemoved)
+// ---------------------------------------------------------------------------
+
+void BluetoothController::onObjectManagerSignal(
+    const Glib::ustring &,
+    const Glib::ustring &signal_name,
+    const Glib::VariantContainerBase &parameters) {
+
+    if (signal_name == "InterfacesAdded") {
+        // signature: (oa{sa{sv}})
+        auto path = static_cast<std::string>(
+            Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::DBusObjectPathString>>(
+                parameters.get_child(0))
+                .get());
+
+        parseInterfaces(path, parameters.get_child(1));
+
+    } else if (signal_name == "InterfacesRemoved") {
+        // signature: (oas)
+        auto path = static_cast<std::string>(
+            Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::DBusObjectPathString>>(
+                parameters.get_child(0))
+                .get());
+
+        auto ifaces = Glib::VariantBase::cast_dynamic<
+                          Glib::Variant<std::vector<Glib::ustring>>>(parameters.get_child(1))
+                          .get();
+
+        for (const auto &iface : ifaces) {
+            if (iface == "org.bluez.Device1") {
+                removeDevice(path);
+            } else if (iface == "org.bluez.Adapter1" && path == m_adapter_path) {
+                m_adapter_proxy.reset();
+                m_adapter_path.clear();
+                m_powered     = false;
+                m_discovering = false;
+                m_powered_signal.emit(false);
+                m_discovering_signal.emit(false);
+                spdlog::info("Bluetooth adapter removed");
+            }
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Adapter
+// ---------------------------------------------------------------------------
+
+void BluetoothController::setupAdapter(const std::string &path,
+                                       const PropertiesMap &properties) {
+    m_adapter_path = path;
+    spdlog::info("Bluetooth adapter found: {}", path);
+
+    auto it = properties.find("Powered");
+    if (it != properties.end() && it->second.is_of_type(Glib::VariantType("b"))) {
+        m_powered = Glib::VariantBase::cast_dynamic<Glib::Variant<bool>>(it->second).get();
+        m_powered_signal.emit(m_powered);
+    }
+
+    it = properties.find("Discovering");
+    if (it != properties.end() && it->second.is_of_type(Glib::VariantType("b"))) {
+        m_discovering = Glib::VariantBase::cast_dynamic<Glib::Variant<bool>>(it->second).get();
+        m_discovering_signal.emit(m_discovering);
+    }
+
+    try {
+        m_adapter_proxy = Gio::DBus::Proxy::create_sync(
+            connection, "org.bluez", path, "org.bluez.Adapter1");
+
+        if (m_adapter_proxy) {
+            m_adapter_proxy->signal_properties_changed().connect(
+                sigc::mem_fun(*this, &BluetoothController::onAdapterPropertiesChanged));
+        }
+    } catch (const Glib::Error &ex) {
+        spdlog::error("Bluetooth: Error creating adapter proxy: {}", ex.what());
+    }
+}
+
+void BluetoothController::onAdapterPropertiesChanged(
+    const Gio::DBus::Proxy::MapChangedProperties &changed,
+    const std::vector<Glib::ustring> &) {
+
+    auto it = changed.find("Powered");
+    if (it != changed.end() && it->second.is_of_type(Glib::VariantType("b"))) {
+        m_powered = Glib::VariantBase::cast_dynamic<Glib::Variant<bool>>(it->second).get();
+        spdlog::info("Bluetooth powered: {}", m_powered);
+        m_powered_signal.emit(m_powered);
+    }
+
+    it = changed.find("Discovering");
+    if (it != changed.end() && it->second.is_of_type(Glib::VariantType("b"))) {
+        m_discovering = Glib::VariantBase::cast_dynamic<Glib::Variant<bool>>(it->second).get();
+        spdlog::info("Bluetooth discovering: {}", m_discovering);
+        m_discovering_signal.emit(m_discovering);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Device management
+// ---------------------------------------------------------------------------
+
+void BluetoothController::addDevice(const std::string &path,
+                                    const PropertiesMap &properties) {
+    auto device     = parseDeviceProperties(path, properties);
+    m_devices[path] = device;
+
+    spdlog::info("Bluetooth device added: {} ({}) {}", device.name, device.address, device.icon);
+
+    try {
+        auto proxy = Gio::DBus::Proxy::create_sync(
+            connection, "org.bluez", path, "org.bluez.Device1");
+
+        if (proxy) {
+            proxy->signal_properties_changed().connect(
+                [this, path](const Gio::DBus::Proxy::MapChangedProperties &changed,
+                             const std::vector<Glib::ustring> &invalidated) {
+                    onDevicePropertiesChanged(path, changed, invalidated);
+                });
+            m_device_proxies[path] = proxy;
+        }
+    } catch (const Glib::Error &ex) {
+        spdlog::error("Bluetooth: Error creating device proxy for {}: {}", path, ex.what());
+    }
+
+    m_device_added_signal.emit(device);
+}
+
+void BluetoothController::removeDevice(const std::string &path) {
+    spdlog::info("Bluetooth device removed: {}", path);
+    m_devices.erase(path);
+    m_device_proxies.erase(path);
+    m_device_removed_signal.emit(path);
+}
+
+void BluetoothController::onDevicePropertiesChanged(
+    const std::string &object_path,
+    const Gio::DBus::Proxy::MapChangedProperties &changed,
+    const std::vector<Glib::ustring> &) {
+
+    auto it = m_devices.find(object_path);
+    if (it == m_devices.end())
+        return;
+
+    auto &device = it->second;
+
+    for (const auto &[key, value] : changed) {
+        if (key == "Name" && value.is_of_type(Glib::VariantType("s"))) {
+            device.name = static_cast<std::string>(
+                Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::ustring>>(value).get());
+        } else if (key == "Alias" && value.is_of_type(Glib::VariantType("s"))) {
+            // Only use Alias as fallback if Name is still the MAC address
+            auto alias = static_cast<std::string>(
+                Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::ustring>>(value).get());
+            if (device.name == device.address) {
+                device.name = alias;
+            }
+        } else if (key == "Paired" && value.is_of_type(Glib::VariantType("b"))) {
+            device.paired = Glib::VariantBase::cast_dynamic<Glib::Variant<bool>>(value).get();
+        } else if (key == "Connected" && value.is_of_type(Glib::VariantType("b"))) {
+            device.connected = Glib::VariantBase::cast_dynamic<Glib::Variant<bool>>(value).get();
+        } else if (key == "Trusted" && value.is_of_type(Glib::VariantType("b"))) {
+            device.trusted = Glib::VariantBase::cast_dynamic<Glib::Variant<bool>>(value).get();
+        } else if (key == "RSSI" && value.is_of_type(Glib::VariantType("n"))) {
+            device.rssi = Glib::VariantBase::cast_dynamic<Glib::Variant<gint16>>(value).get();
+        } else if (key == "Icon" && value.is_of_type(Glib::VariantType("s"))) {
+            device.icon = static_cast<std::string>(
+                Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::ustring>>(value).get());
+        }
+    }
+
+    m_device_changed_signal.emit(device);
+}
+
+// ---------------------------------------------------------------------------
+// Property parsing helper
+// ---------------------------------------------------------------------------
+
+BluetoothDevice BluetoothController::parseDeviceProperties(
+    const std::string &path,
+    const PropertiesMap &properties) {
+
+    BluetoothDevice device;
+    device.object_path = path;
+
+    auto getString = [&](const Glib::ustring &key) -> std::string {
+        auto it = properties.find(key);
+        if (it != properties.end() && it->second.is_of_type(Glib::VariantType("s"))) {
+            return static_cast<std::string>(
+                Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::ustring>>(it->second).get());
+        }
+        return "";
+    };
+
+    auto getBool = [&](const Glib::ustring &key) -> bool {
+        auto it = properties.find(key);
+        if (it != properties.end() && it->second.is_of_type(Glib::VariantType("b"))) {
+            return Glib::VariantBase::cast_dynamic<Glib::Variant<bool>>(it->second).get();
+        }
+        return false;
+    };
+
+    device.address = getString("Address");
+    device.name    = getString("Name");
+    if (device.name.empty())
+        device.name = getString("Alias");
+    if (device.name.empty())
+        device.name = device.address;
+    device.icon      = getString("Icon");
+    device.paired    = getBool("Paired");
+    device.connected = getBool("Connected");
+    device.trusted   = getBool("Trusted");
+
+    auto rssi_it = properties.find("RSSI");
+    if (rssi_it != properties.end() && rssi_it->second.is_of_type(Glib::VariantType("n"))) {
+        device.rssi = Glib::VariantBase::cast_dynamic<Glib::Variant<gint16>>(rssi_it->second).get();
+    }
+
+    return device;
+}
+
+// ---------------------------------------------------------------------------
+// D-Bus property setter  (calls org.freedesktop.DBus.Properties.Set)
+// ---------------------------------------------------------------------------
+
+void BluetoothController::setDbusProperty(const std::string &object_path,
+                                          const std::string &interface,
+                                          const std::string &property,
+                                          const Glib::VariantBase &value) {
+    if (!connection || object_path.empty())
+        return;
+
+    try {
+        auto props_proxy = Gio::DBus::Proxy::create_sync(
+            connection, "org.bluez", object_path, "org.freedesktop.DBus.Properties");
+
+        auto wrapped = Glib::Variant<Glib::VariantBase>::create(value);
+        auto params  = Glib::VariantContainerBase::create_tuple({Glib::Variant<Glib::ustring>::create(interface),
+                                                                 Glib::Variant<Glib::ustring>::create(property),
+                                                                 wrapped});
+
+        props_proxy->call_sync("Set", params);
+    } catch (const Glib::Error &ex) {
+        spdlog::error("Error setting {}.{}: {}", interface, property, ex.what());
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Agent
+// ---------------------------------------------------------------------------
+
+void BluetoothController::registerAgent() {
+    if (!connection)
+        return;
+
+    try {
+        m_node_info = Gio::DBus::NodeInfo::create_for_xml(agent_introspection_xml);
+        auto interface_info = m_node_info->lookup_interface("org.bluez.Agent1");
+
+        m_interface_vtable = std::make_shared<Gio::DBus::InterfaceVTable>(
+            sigc::mem_fun(*this, &BluetoothController::on_agent_method_call));
+
+        m_agent_id = connection->register_object("/org/bluez/bar_agent", interface_info, *m_interface_vtable);
+
+        auto agent_manager = Gio::DBus::Proxy::create_sync(
+            connection, "org.bluez", "/org/bluez", "org.bluez.AgentManager1");
+
+        if (agent_manager) {
+            agent_manager->call_sync(
+                "RegisterAgent",
+                Glib::VariantContainerBase::create_tuple(
+                    {Glib::Variant<Glib::DBusObjectPathString>::create("/org/bluez/bar_agent"),
+                     Glib::Variant<Glib::ustring>::create("DisplayYesNo")}));
+            
+            agent_manager->call_sync(
+                "RequestDefaultAgent",
+                Glib::VariantContainerBase::create_tuple(
+                    {Glib::Variant<Glib::DBusObjectPathString>::create("/org/bluez/bar_agent")}));
+            
+            spdlog::info("Bluetooth Agent registered successfully");
+        }
+    } catch (const Glib::Error &ex) {
+        spdlog::error("Bluetooth: Failed to register agent: {}", ex.what());
+    }
+}
+
+void BluetoothController::on_agent_method_call(
+    const Glib::RefPtr<Gio::DBus::Connection> &,
+    const Glib::ustring &,
+    const Glib::ustring &,
+    const Glib::ustring &,
+    const Glib::ustring &method_name,
+    const Glib::VariantContainerBase &parameters,
+    const Glib::RefPtr<Gio::DBus::MethodInvocation> &invocation) {
+
+    spdlog::info("Bluetooth Agent method called: {}", method_name.c_str());
+
+    if (method_name == "RequestConfirmation") {
+        // Signature: (ou)
+        std::string device_path = static_cast<std::string>(
+             Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::DBusObjectPathString>>(
+                parameters.get_child(0)).get());
+                
+        guint32 passkey = Glib::VariantBase::cast_dynamic<Glib::Variant<guint32>>(
+            parameters.get_child(1)).get();
+
+        std::string device_name = device_path;
+        if (m_devices.count(device_path)) {
+            device_name = m_devices[device_path].name;
+            if (device_name.empty())
+                device_name = m_devices[device_path].address;
+        }
+
+        std::ostringstream ss;
+        ss << std::setw(6) << std::setfill('0') << passkey;
+        std::string passkey_str = ss.str();
+
+        NotifyMessage msg;
+        msg.summary = "Bluetooth Pairing Request";
+        msg.body    = "Device '" + device_name + "' wants to pair.\nPasskey: " + passkey_str;
+        msg.app_name = "Bar";
+        msg.actions  = {"Confirm", "Confirm", "Cancel", "Cancel"};
+        msg.urgency  = NotificationUrgency::CRITICAL;
+        msg.expire_timeout = -1;  // No timeout, requires user interaction
+
+        // Capture invocation to respond later
+        // Note: invocation is a RefPtr, so copying it increases ref count
+        msg.on_action = [invocation](const std::string &action) {
+            if (action == "Confirm") {
+                invocation->return_value(Glib::VariantContainerBase());
+            } else {
+                invocation->return_dbus_error("org.bluez.Error.Rejected", "Rejected by user");
+            }
+        };
+
+        NotificationController::getInstance()->showNotificationOnAllMonitors(msg);
+        
+    } else if (method_name == "RequestAuthorization") {
+        // Signature: (o)
+        std::string device_path = static_cast<std::string>(
+            Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::DBusObjectPathString>>(
+                parameters.get_child(0)).get());
+
+        std::string device_name = device_path;
+        if (m_devices.count(device_path)) {
+            device_name = m_devices[device_path].name;
+            if (device_name.empty())
+                device_name = m_devices[device_path].address;
+        }
+
+        NotifyMessage msg;
+        msg.summary = "Bluetooth Authorization Request";
+        msg.body    = "Device '" + device_name + "' requests authorization to connect.";
+        msg.app_name = "Bar";
+        msg.actions  = {"Allow", "Allow", "Deny", "Deny"};
+        msg.urgency  = NotificationUrgency::LOW;
+        msg.expire_timeout = -1;
+
+        msg.on_action = [invocation](const std::string &action) {
+            if (action == "Allow") {
+                invocation->return_value(Glib::VariantContainerBase());
+            } else {
+                invocation->return_dbus_error("org.bluez.Error.Rejected", "Rejected by user");
+            }
+        };
+
+        NotificationController::getInstance()->showNotificationOnAllMonitors(msg);
+
+    } else if (method_name == "AuthorizeService") {
+        // Signature: (os)
+        std::string device_path = static_cast<std::string>(
+             Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::DBusObjectPathString>>(
+                parameters.get_child(0)).get());
+        std::string uuid = static_cast<std::string>(
+             Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::ustring>>(
+                parameters.get_child(1)).get());
+
+        std::string device_name = device_path;
+        if (m_devices.count(device_path)) {
+            device_name = m_devices[device_path].name;
+             if (device_name.empty())
+                device_name = m_devices[device_path].address;
+        }
+
+        NotifyMessage msg;
+        msg.summary = "Bluetooth Service Authorization";
+        msg.body    = "Device '" + device_name + "' wants to access service: " + uuid;
+        msg.app_name = "Bar";
+        msg.actions  = {"Allow", "Allow", "Deny", "Deny"};
+        msg.urgency  = NotificationUrgency::CRITICAL;
+        msg.expire_timeout = -1;
+
+         msg.on_action = [invocation](const std::string &action) {
+            if (action == "Allow") {
+                invocation->return_value(Glib::VariantContainerBase());
+            } else {
+                invocation->return_dbus_error("org.bluez.Error.Rejected", "Rejected by user");
+            }
+        };
+
+        NotificationController::getInstance()->showNotificationOnAllMonitors(msg);
+        
+    } else if (method_name == "DisplayPinCode") {
+        // Signature: (os)
+        std::string device_path = static_cast<std::string>(
+             Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::DBusObjectPathString>>(
+                parameters.get_child(0)).get());
+        std::string pincode = static_cast<std::string>(
+             Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::ustring>>(
+                parameters.get_child(1)).get());
+
+        std::string device_name = device_path;
+        if (m_devices.count(device_path)) {
+             device_name = m_devices[device_path].name;
+             if (device_name.empty())
+                device_name = m_devices[device_path].address;
+        }
+
+        NotifyMessage msg;
+        msg.summary = "Bluetooth Pin Code";
+        msg.body    = "Pin code for device '" + device_name + "': " + pincode;
+        msg.app_name = "Bar";
+        msg.actions  = {"Dismiss"};
+        msg.urgency  = NotificationUrgency::NORMAL;
+        msg.expire_timeout = 0;
+
+        NotificationController::getInstance()->showNotificationOnAllMonitors(msg);
+        invocation->return_value(Glib::VariantContainerBase());
+
+    } else if (method_name == "DisplayPasskey") {
+        // Signature: (ouq)
+        std::string device_path = static_cast<std::string>(
+             Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::DBusObjectPathString>>(
+                parameters.get_child(0)).get());
+        guint32 passkey = Glib::VariantBase::cast_dynamic<Glib::Variant<guint32>>(
+            parameters.get_child(1)).get();
+        guint16 entered = Glib::VariantBase::cast_dynamic<Glib::Variant<guint16>>(
+            parameters.get_child(2)).get();
+
+        // Only show on first display (entered == 0) to avoid spam
+        if (entered == 0) {
+            std::string device_name = device_path;
+            if (m_devices.count(device_path)) {
+                device_name = m_devices[device_path].name;
+                if (device_name.empty())
+                    device_name = m_devices[device_path].address;
+            }
+
+            std::ostringstream ss;
+            ss << std::setw(6) << std::setfill('0') << passkey;
+            std::string passkey_str = ss.str();
+
+            NotifyMessage msg;
+            msg.summary = "Bluetooth Passkey";
+            msg.body    = "Type this passkey on '" + device_name + "': " + passkey_str;
+            msg.app_name = "Bar";
+            msg.actions  = {"Dismiss"};
+            msg.urgency  = NotificationUrgency::CRITICAL;
+            msg.expire_timeout = -1;
+            
+            NotificationController::getInstance()->showNotificationOnAllMonitors(msg);
+        }
+        invocation->return_value(Glib::VariantContainerBase());
+
+    } else if (method_name == "RequestPinCode") {
+        // Signature: (o) -> s
+         std::string device_path = static_cast<std::string>(
+             Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::DBusObjectPathString>>(
+                parameters.get_child(0)).get());
+        
+        std::string device_name = device_path;
+        if (m_devices.count(device_path)) {
+            device_name = m_devices[device_path].name;
+            if (device_name.empty())
+                device_name = m_devices[device_path].address;
+        }
+
+        NotifyMessage msg;
+        msg.summary = "Bluetooth PIN Request";
+        msg.body    = "Enter PIN Code for '" + device_name + "'";
+        msg.app_name = "Bar";
+        msg.urgency  = NotificationUrgency::CRITICAL;
+        msg.expire_timeout = -1;
+        msg.has_input = true;
+        msg.input_placeholder = "PIN Code";
+
+        msg.on_input = [invocation](const std::string &input) {
+             invocation->return_value(
+                Glib::VariantContainerBase::create_tuple(
+                    {Glib::Variant<Glib::ustring>::create(input)}));
+        };
+
+        NotificationController::getInstance()->showNotificationOnAllMonitors(msg);
+
+    } else if (method_name == "RequestPasskey") {
+        // Signature: (o) -> u
+         std::string device_path = static_cast<std::string>(
+             Glib::VariantBase::cast_dynamic<Glib::Variant<Glib::DBusObjectPathString>>(
+                parameters.get_child(0)).get());
+        
+        std::string device_name = device_path;
+        if (m_devices.count(device_path)) {
+            device_name = m_devices[device_path].name;
+            if (device_name.empty())
+                device_name = m_devices[device_path].address;
+        }
+
+        NotifyMessage msg;
+        msg.summary = "Bluetooth Passkey Request";
+        msg.body    = "Enter Passkey for '" + device_name + "'";
+        msg.app_name = "Bar";
+        msg.urgency  = NotificationUrgency::CRITICAL;
+        msg.expire_timeout = -1;
+        msg.has_input = true;
+        msg.input_placeholder = "Passkey (0-999999)";
+
+        msg.on_input = [invocation](const std::string &input) {
+            try {
+                uint32_t passkey = std::stoul(input);
+                invocation->return_value(
+                    Glib::VariantContainerBase::create_tuple(
+                        {Glib::Variant<guint32>::create(passkey)}));
+            } catch (...) {
+                 invocation->return_dbus_error("org.bluez.Error.Failed", "Invalid passkey format");
+            }
+        };
+
+        NotificationController::getInstance()->showNotificationOnAllMonitors(msg);
+
+    } else if (method_name == "Cancel" || method_name == "Release") {
+        // Just return
+        invocation->return_value(Glib::VariantContainerBase());
+    } else {
+        // Not implemented
+        invocation->return_dbus_error("org.bluez.Error.Rejected", "Not implemented");
+    }
+
+}

src/connection/dbus/mpris.cpp

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

src/services/hyprland.cpp

@@ -1,5 +1,6 @@
 #include "services/hyprland.hpp"
 
+#include <algorithm>
 #include <cstring>
 #include <glib-unix.h>
 #include <glib.h>
@@ -17,6 +18,9 @@
 #include "spdlog/spdlog.h"
 
 HyprlandService::HyprlandService() {
+    if (instance) {
+        throw std::runtime_error("HyprlandService instance already exists");
+    }
     init();
     this->bindHyprlandSocket();
 }
@@ -62,7 +66,11 @@ void HyprlandService::init() {
         clientPtr->title                  = client["title"].get<std::string>();
         this->clients[clientPtr->address] = clientPtr;
 
-        auto workspacePtr                                = workspaces[clientPtr->workspaceId];
+        auto workspaceIt = workspaces.find(clientPtr->workspaceId);
+        if (workspaceIt == workspaces.end()) {
+            continue;
+        }
+        auto workspacePtr                                = workspaceIt->second;
         workspacePtr->state->clients[clientPtr->address] = clientPtr;
 
         if (client.contains("urgent") && client["urgent"].get<bool>()) {
@@ -73,7 +81,11 @@ void HyprlandService::init() {
     auto workspaceDataJson = HyprctlHelper::getWorkspaceData();
 
     for (const auto &workspace : workspaceDataJson) {
-        auto workspacePtr = workspaces[workspace["id"].get<int>()];
+        auto workspaceIt = workspaces.find(workspace["id"].get<int>());
+        if (workspaceIt == workspaces.end()) {
+            continue;
+        }
+        auto workspacePtr = workspaceIt->second;
         auto state        = workspacePtr->state;
 
         state->id          = workspace["id"].get<int>();
@@ -84,6 +96,9 @@ void HyprlandService::init() {
 }
 
 void HyprlandService::bindHyprlandSocket() {
+    if (socketFd != -1) {
+        return;
+    }
     std::string socketPath = HyprSocketHelper::getHyprlandSocketPath();
 
     socketFd = socket(AF_UNIX, SOCK_STREAM, 0);
@@ -106,36 +121,49 @@ void HyprlandService::bindHyprlandSocket() {
     }
 
     auto socket_conditions = static_cast<GIOCondition>(G_IO_IN | G_IO_HUP | G_IO_ERR); // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
-    GSource *source        = g_unix_fd_source_new(socketFd, socket_conditions);
+    g_unix_fd_add(
+        socketFd,
+        socket_conditions,
+        [](gint fd, GIOCondition condition, gpointer user_data) -> gboolean {
+            auto *self = static_cast<HyprlandService *>(user_data);
+            if (condition & (G_IO_HUP | G_IO_ERR)) {
+                spdlog::error("[Hyprland] Socket read error or connection closed");
+                close(fd);
+                self->socketFd = -1;
+                return FALSE;
+            }
 
-    auto onSocketEvent = [](gint fd, GIOCondition, gpointer user_data) -> gboolean {
-        HyprlandService *self = static_cast<HyprlandService *>(user_data);
-        auto messages         = SocketHelper::parseSocketMessage(fd, ">>");
-
-        for (const auto &message : messages) {
-            self->handleSocketMessage(message);
-        }
-
-        return G_SOURCE_CONTINUE;
-    };
-
-    g_source_set_callback(source, reinterpret_cast<GSourceFunc>(reinterpret_cast<void *>(+onSocketEvent)), this, nullptr);
-    g_source_attach(source, g_main_context_default());
-    g_source_unref(source);
+            auto messages = SocketHelper::parseSocketMessage(fd, ">>");
+            for (const auto &message : messages) {
+                self->handleSocketMessage(message);
+            }
+            return TRUE;
+        },
+        this);
 }
 
 void HyprlandService::onWorkspaceChanged(int workspaceId) {
-    auto newActive  = workspaces[workspaceId];
+    auto newActiveIt = workspaces.find(workspaceId);
+    if (newActiveIt == workspaces.end()) {
+        return;
+    }
+    auto newActive  = newActiveIt->second;
     auto state      = newActive->state;
-    auto monitorPtr = monitors[state->monitorName];
+    auto monitorIt  = monitors.find(state->monitorName);
+    if (monitorIt == monitors.end()) {
+        return;
+    }
+    auto monitorPtr = monitorIt->second;
 
     int oldActiveWorkspaceId = monitorPtr->activeWorkspaceId;
-    auto oldActive           = workspaces[oldActiveWorkspaceId];
-
     monitorPtr->activeWorkspaceId = workspaceId;
 
     refreshIndicator(newActive);
-    refreshIndicator(oldActive);
+
+    auto oldActiveIt = workspaces.find(oldActiveWorkspaceId);
+    if (oldActiveIt != workspaces.end()) {
+        refreshIndicator(oldActiveIt->second);
+    }
 }
 
 void HyprlandService::onFocusedMonitorChanged(std::string monitorData) {
@@ -160,20 +188,6 @@ void HyprlandService::onFocusedMonitorChanged(std::string monitorData) {
     }
 }
 
-void HyprlandService::onMonitorRemoved(std::string monitorName) {
-    auto monitorPtr = this->monitors[monitorName];
-
-    for (const auto &[wsId, wsPtr] : monitorPtr->monitorWorkspaces) {
-        this->workspaces.erase(wsId);
-    }
-
-    monitorPtr->monitorWorkspaces.clear();
-    monitorPtr->bar->close();
-    monitorPtr->bar = nullptr;
-
-    this->monitors.erase(monitorName);
-}
-
 void HyprlandService::onMoveWindow(std::string windowData) {
     auto parts         = StringHelper::split(windowData, ',');
     std::string addr   = "0x" + parts[0];
@@ -187,19 +201,24 @@ void HyprlandService::onMoveWindow(std::string windowData) {
     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);
+    auto oldWorkspaceIt = workspaces.find(oldWorkspaceId);
+    bool wasUrgent = false;
+    if (oldWorkspaceIt != workspaces.end()) {
+        oldWorkspaceIt->second->state->clients.erase(addr);
+        wasUrgent = oldWorkspaceIt->second->state->urgentClients.erase(addr) > 0;
+        refreshIndicator(oldWorkspaceIt->second);
+    }
 
     clientPtr->workspaceId = newWorkspaceId;
 
-    auto newWorkspacePtr                  = workspaces[newWorkspaceId];
-    newWorkspacePtr->state->clients[addr] = clientPtr;
-    if (wasUrgent) {
-        newWorkspacePtr->state->urgentClients.insert(addr);
+    auto newWorkspaceIt = workspaces.find(newWorkspaceId);
+    if (newWorkspaceIt != workspaces.end()) {
+        newWorkspaceIt->second->state->clients[addr] = clientPtr;
+        if (wasUrgent) {
+            newWorkspaceIt->second->state->urgentClients.insert(addr);
+        }
+        refreshIndicator(newWorkspaceIt->second);
     }
-    refreshIndicator(newWorkspacePtr);
 }
 
 void HyprlandService::onOpenWindow(std::string windowData) {
@@ -213,10 +232,11 @@ void HyprlandService::onOpenWindow(std::string windowData) {
     clientPtr->workspaceId                           = workspaceId;
     clientPtr->title                                 = title;
     this->clients[clientPtr->address]                = clientPtr;
-    auto workspacePtr                                = workspaces[clientPtr->workspaceId];
-    workspacePtr->state->clients[clientPtr->address] = clientPtr;
-
-    refreshIndicator(workspacePtr);
+    auto workspaceIt = workspaces.find(clientPtr->workspaceId);
+    if (workspaceIt != workspaces.end()) {
+        workspaceIt->second->state->clients[clientPtr->address] = clientPtr;
+        refreshIndicator(workspaceIt->second);
+    }
 }
 
 void HyprlandService::onCloseWindow(std::string windowData) {
@@ -229,12 +249,15 @@ void HyprlandService::onCloseWindow(std::string windowData) {
 
     auto clientPtr  = this->clients[addr];
     int workspaceId = clientPtr->workspaceId;
-
-    auto workspacePtr = workspaces[workspaceId];
-    workspacePtr->state->clients.erase(addr);
     this->clients.erase(addr);
 
-    refreshIndicator(workspacePtr);
+    auto workspaceIt = workspaces.find(workspaceId);
+    if (workspaceIt == workspaces.end()) {
+        return;
+    }
+    workspaceIt->second->state->clients.erase(addr);
+
+    refreshIndicator(workspaceIt->second);
 }
 
 void HyprlandService::handleSocketMessage(SocketHelper::SocketMessage message) {
@@ -270,6 +293,10 @@ void HyprlandService::handleSocketMessage(SocketHelper::SocketMessage message) {
         this->onActiveWindowChanged(eventData);
         break;
     }
+    case MONITOR_ADDED: {
+        this->onMonitorAdded(eventData);
+        break;
+    }
     case MONITOR_REMOVED: {
         this->onMonitorRemoved(eventData);
         break;
@@ -280,6 +307,112 @@ void HyprlandService::handleSocketMessage(SocketHelper::SocketMessage message) {
     }
     }
 }
+
+void HyprlandService::onMonitorAdded(std::string monitorName) {
+    spdlog::info("[Hyprland] Monitor added: {}", monitorName);
+    auto monitorDataJson = HyprctlHelper::getMonitorData();
+    auto monitorIt       = std::ranges::find_if(monitorDataJson,
+                                                [&monitorName](const auto &item) {
+                                              return item.contains("name") && item["name"] == monitorName;
+                                          });
+
+    if (monitorIt == monitorDataJson.end()) {
+        spdlog::warn("[Hyprland] Monitor data not found for {}", monitorName);
+        return;
+    }
+
+    auto monitorPtr               = std::make_shared<Monitor>();
+    monitorPtr->id                = (*monitorIt)["id"];
+    monitorPtr->name              = monitorName;
+    monitorPtr->activeWorkspaceId = (*monitorIt)["activeWorkspace"]["id"];
+    monitorPtr->focused           = (*monitorIt)["focused"];
+    this->monitors[monitorName]   = monitorPtr;
+
+    auto onClick = sigc::mem_fun(*this, &HyprlandService::switchToWorkspace);
+    for (int i = 1; i <= NUM_WORKSPACES; i++) {
+        auto state      = std::make_shared<WorkspaceData>();
+        int workspaceId = i + (NUM_WORKSPACES * monitorPtr->id);
+
+        state->id          = workspaceId;
+        state->monitorName = monitorName;
+        auto view          = std::make_shared<WorkspaceIndicator>(workspaceId, std::to_string(i), onClick);
+        auto workSpace     = std::make_shared<Workspace>();
+        workSpace->state   = state;
+        workSpace->view    = view;
+
+        monitorPtr->monitorWorkspaces[workspaceId] = workSpace;
+        this->workspaces[workspaceId]              = workSpace;
+    }
+
+    auto workspaceDataJson = HyprctlHelper::getWorkspaceData();
+    for (const auto &workspace : workspaceDataJson) {
+        if (!workspace.contains("monitor") || workspace["monitor"].get<std::string>() != monitorName) {
+            continue;
+        }
+        auto workspaceIt = workspaces.find(workspace["id"].get<int>());
+        if (workspaceIt == workspaces.end()) {
+            continue;
+        }
+        auto workspacePtr = workspaceIt->second;
+        auto state        = workspacePtr->state;
+
+        state->id          = workspace["id"].get<int>();
+        state->monitorName = workspace["monitor"].get<std::string>();
+
+        refreshIndicator(workspacePtr);
+    }
+
+    auto clientsDataJson = HyprctlHelper::getClientData();
+    for (const auto &client : clientsDataJson) {
+        auto address = client["address"].get<std::string>();
+        if (this->clients.find(address) != this->clients.end()) {
+            continue;
+        }
+        int workspaceId  = client["workspace"]["id"].get<int>();
+        auto workspaceIt = workspaces.find(workspaceId);
+        if (workspaceIt == workspaces.end()) {
+            continue;
+        }
+        if (workspaceIt->second->state->monitorName != monitorName) {
+            continue;
+        }
+
+        auto clientPtr                    = std::make_shared<Client>();
+        clientPtr->address                = address;
+        clientPtr->workspaceId            = workspaceId;
+        clientPtr->title                  = client["title"].get<std::string>();
+        this->clients[clientPtr->address] = clientPtr;
+
+        workspaceIt->second->state->clients[clientPtr->address] = clientPtr;
+        if (client.contains("urgent") && client["urgent"].get<bool>()) {
+            workspaceIt->second->state->urgentClients.insert(clientPtr->address);
+        }
+        refreshIndicator(workspaceIt->second);
+    }
+
+    m_signal_monitor_added.emit(monitorName);
+}
+
+void HyprlandService::onMonitorRemoved(std::string monitorName) {
+    spdlog::info("[Hyprland] Monitor removed: {}", monitorName);
+    auto monitorIt = monitors.find(monitorName);
+    if (monitorIt == monitors.end()) {
+        return;
+    }
+
+    auto monitorPtr = monitorIt->second;
+    for (const auto &[workspaceId, workspacePtr] : monitorPtr->monitorWorkspaces) {
+        for (const auto &[clientAddr, _] : workspacePtr->state->clients) {
+            clients.erase(clientAddr);
+        }
+        workspaces.erase(workspaceId);
+    }
+
+    this->monitors.erase(monitorIt);
+
+    m_signal_monitor_removed.emit(monitorName);
+}
+
 void HyprlandService::onUrgent(std::string windowAddress) {
     std::string addr = "0x" + windowAddress;
     if (this->clients.find(addr) == this->clients.end()) {
@@ -289,10 +422,13 @@ void HyprlandService::onUrgent(std::string windowAddress) {
     auto clientPtr  = this->clients[addr];
     int workspaceId = clientPtr->workspaceId;
 
-    auto workspacePtr = workspaces[workspaceId];
-    workspacePtr->state->urgentClients.insert(addr);
+    auto workspaceIt = workspaces.find(workspaceId);
+    if (workspaceIt == workspaces.end()) {
+        return;
+    }
+    workspaceIt->second->state->urgentClients.insert(addr);
 
-    refreshIndicator(workspacePtr);
+    refreshIndicator(workspaceIt->second);
 }
 
 void HyprlandService::onActiveWindowChanged(std::string windowAddress) {
@@ -304,15 +440,22 @@ void HyprlandService::onActiveWindowChanged(std::string windowAddress) {
     auto clientPtr  = this->clients[addr];
     int workspaceId = clientPtr->workspaceId;
 
-    auto workspacePtr = workspaces[workspaceId];
-    workspacePtr->state->urgentClients.erase(addr);
+    auto workspaceIt = workspaces.find(workspaceId);
+    if (workspaceIt == workspaces.end()) {
+        return;
+    }
+    workspaceIt->second->state->urgentClients.erase(addr);
 
-    refreshIndicator(workspacePtr);
+    refreshIndicator(workspaceIt->second);
 }
 
 std::shared_ptr<Gtk::Box> HyprlandService::getWorkspaceIndicatorsForMonitor(std::string monitorName) {
-    auto box     = std::make_shared<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
-    auto monitor = monitors[monitorName];
+    auto box       = std::make_shared<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
+    auto monitorIt = monitors.find(monitorName);
+    if (monitorIt == monitors.end()) {
+        return box;
+    }
+    auto monitor = monitorIt->second;
 
     for (const auto &[wsId, wsPair] : monitor->monitorWorkspaces) {
         box->append((Gtk::Box &)*wsPair->view);
@@ -328,8 +471,12 @@ void HyprlandService::switchToWorkspace(int workspaceId) {
 void HyprlandService::refreshIndicator(std::shared_ptr<Workspace> workspace) {
     auto view = workspace->view;
 
-    auto state       = workspace->state;
-    auto monitorsPtr = monitors[state->monitorName];
+    auto state     = workspace->state;
+    auto monitorIt = monitors.find(state->monitorName);
+    if (monitorIt == monitors.end()) {
+        return;
+    }
+    auto monitorsPtr = monitorIt->second;
 
     bool isUrgent      = !state->urgentClients.empty();
     bool isEmpty       = state->clients.empty();
@@ -350,5 +497,9 @@ void HyprlandService::refreshIndicator(std::shared_ptr<Workspace> workspace) {
 }
 
 void HyprlandService::addBar(std::shared_ptr<Bar> bar, std::string monitorName) {
-    this->monitors[monitorName]->bar = bar;
+    auto monitorIt = monitors.find(monitorName);
+    if (monitorIt == monitors.end()) {
+        return;
+    }
+    monitorIt->second->bar = bar;
 }

src/services/notificationController.cpp

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

src/services/textureCache.cpp

@@ -132,6 +132,15 @@ TextureCacheService *TextureCacheService::getInstance() {
     return &instance;
 }
 
+TextureCacheService::TextureCacheService() {
+    curl_global_init(CURL_GLOBAL_DEFAULT);
+}
+
+TextureCacheService::~TextureCacheService() {
+    clear();
+    curl_global_cleanup();
+}
+
 Glib::RefPtr<Gdk::Texture> TextureCacheService::getTexture(const std::string &url) {
     if (url.empty()) {
         return {};
@@ -220,3 +229,7 @@ void TextureCacheService::pruneCache() {
         }
     }
 }
+
+void TextureCacheService::clear() {
+    cache.clear();
+}

src/widgets/controlCenter/bluetoothSettings.cpp

@@ -0,0 +1,145 @@
+#include "widgets/controlCenter/bluetoothSettings.hpp"
+
+#include <memory>
+
+BluetoothSettings::BluetoothSettings() : bluetoothIsPowered(this->bluetoothController->isPowered()), bluetoothIsScanning(this->bluetoothController->isDiscovering()) {
+    set_orientation(Gtk::Orientation::VERTICAL);
+    set_spacing(12);
+
+    add_css_class("bluetooth-settings");
+
+    powerButton->add_css_class("power-button");
+
+    setBluetoothPowered(bluetoothIsPowered);
+
+    powerButton->set_tooltip_text(bluetoothIsPowered ? "Turn Bluetooth Off" : "Turn Bluetooth On");
+    powerButton->signal_clicked().connect([this]() {
+        bluetoothIsPowered = !bluetoothIsPowered;
+        this->bluetoothController->setPowered(bluetoothIsPowered);
+    });
+
+    this->buttonRow.append(*powerButton);
+
+    scanButton->add_css_class("power-button");
+    setScanning(bluetoothIsScanning);
+    scanButton->set_tooltip_text(bluetoothIsScanning ? "Stop Scanning" : "Start Scanning");
+    scanButton->signal_clicked().connect([this]() {
+        bluetoothIsScanning = !bluetoothIsScanning;
+        if (bluetoothIsScanning) {
+            this->bluetoothController->startDiscovery();
+        } else {
+            this->bluetoothController->stopDiscovery();
+        }
+    });
+    this->buttonRow.append(*scanButton);
+
+    this->buttonRow.set_spacing(12);
+    append(this->buttonRow);
+
+
+    connectedDevicesBox.add_css_class("active-devices");
+    connectedDevicesBox.set_orientation(Gtk::Orientation::VERTICAL);
+    connectedDevicesScroll.set_child(connectedDevicesBox);
+    connectedDevicesScroll.set_policy(Gtk::PolicyType::NEVER, Gtk::PolicyType::AUTOMATIC);
+    connectedDevicesScroll.set_propagate_natural_height(true);
+    connectedDevicesScroll.set_max_content_height(200);
+    
+    append(connectedDevicesScroll);
+
+
+    availableDevicesBox.add_css_class("available-devices");
+    availableDevicesBox.set_orientation(Gtk::Orientation::VERTICAL);
+    availableDevicesScroll.set_child(availableDevicesBox);
+    availableDevicesScroll.set_policy(Gtk::PolicyType::NEVER, Gtk::PolicyType::AUTOMATIC);
+    availableDevicesScroll.set_propagate_natural_height(true);
+    availableDevicesScroll.set_max_content_height(200);
+    append(availableDevicesScroll);
+
+    this->bluetoothController->signalPoweredChanged().connect([this](bool powered) {
+        bluetoothIsPowered = powered;
+        setBluetoothPowered(powered);
+    });
+
+    this->bluetoothController->signalDiscoveringChanged().connect([this](bool scanning) {
+        bluetoothIsScanning = scanning;
+        setScanning(scanning);
+    });
+
+    auto devices = this->bluetoothController->getDevices();
+
+    for (const auto &device : devices) {
+        auto row                       = std::make_shared<BluetoothSettingsRow>(device);
+        deviceRows[device.object_path] = row;
+        if (device.connected) {
+            connectedDevicesBox.append(*row);
+        } else {
+            availableDevicesBox.append(*row);
+        }
+    }
+
+    this->bluetoothController->signalDeviceAdded().connect([this](const BluetoothDevice &device) {
+        auto row                       = std::make_shared<BluetoothSettingsRow>(device);
+        deviceRows[device.object_path] = row;
+        if (device.connected) {
+            connectedDevicesBox.append(*row);
+        } else {
+            availableDevicesBox.append(*row);
+        }
+    });
+
+    this->bluetoothController->signalDeviceRemoved().connect([this](const std::string &object_path) {
+        auto it = deviceRows.find(object_path);
+        if (it != deviceRows.end()) {
+            auto parent = it->second->get_parent();
+            if (parent) {
+                dynamic_cast<Gtk::Box *>(parent)->remove(*it->second);
+            }
+            deviceRows.erase(it);
+        }
+    });
+
+    this->bluetoothController->signalDeviceChanged().connect([this](const BluetoothDevice &device) {
+        auto it = deviceRows.find(device.object_path);
+        if (it != deviceRows.end()) {
+            it->second->updateDevice(device);
+
+            // Move between boxes if connection status changed
+            auto parent = it->second->get_parent();
+            Gtk::Box *targetBox = device.connected ? &connectedDevicesBox : &availableDevicesBox;
+            if (parent != targetBox) {
+                if (parent) {
+                    dynamic_cast<Gtk::Box *>(parent)->remove(*it->second);
+                }
+                targetBox->append(*it->second);
+            }
+        }
+    });
+}
+
+void BluetoothSettings::setBluetoothPowered(bool powered) {
+    this->bluetoothIsPowered = powered;
+
+    if (powered) {
+        powerButton->remove_css_class("power-button-off");
+        powerButton->add_css_class("power-button-on");
+        powerButton->set_tooltip_text("Turn Bluetooth Off");
+    } else {
+        powerButton->remove_css_class("power-button-on");
+        powerButton->add_css_class("power-button-off");
+        powerButton->set_tooltip_text("Turn Bluetooth On");
+    }
+}
+
+void BluetoothSettings::setScanning(bool scanning) {
+    this->bluetoothIsScanning = scanning;
+
+    if (scanning) {
+        scanButton->add_css_class("power-button-on");
+        scanButton->remove_css_class("power-button-off");
+        scanButton->set_tooltip_text("Stop Scanning");
+    } else {
+        scanButton->remove_css_class("power-button-on");
+        scanButton->add_css_class("power-button-off");
+        scanButton->set_tooltip_text("Start Scanning");
+    }
+}

src/widgets/controlCenter/bluetoothSettingsRow.cpp

@@ -0,0 +1,88 @@
+#include "widgets/controlCenter/bluetoothSettingsRow.hpp"
+
+#include <spdlog/spdlog.h>
+
+#include "components/button/iconButton.hpp"
+#include "connection/dbus/bluetooth.hpp"
+#include "helpers/string.hpp"
+#include "services/notificationController.hpp"
+
+BluetoothSettingsRow::BluetoothSettingsRow(const BluetoothDevice &device)
+    : device(device),
+      pairButton(device.paired ? Icon::BLUETOOTH_CONNECTED : Icon::BLUETOOTH),
+      connectButton(device.connected ? Icon::LINK : Icon::LINK_OFF),
+      trustButton(device.trusted ? Icon::DONE_ALL : Icon::REMOVE_DONE) {
+    set_orientation(Gtk::Orientation::HORIZONTAL);
+    set_spacing(10);
+
+    add_css_class("bluetooth-settings-row");
+    set_hexpand(true);
+    set_halign(Gtk::Align::FILL);
+
+    if (!device.icon.empty()) {
+        this->icon.set_from_icon_name(device.icon);
+        this->icon.set_pixel_size(24);
+        append(this->icon);
+    }
+
+    auto deviceInfoBox = Gtk::Box(Gtk::Orientation::VERTICAL);
+    deviceInfoBox.set_spacing(2);
+    append(deviceInfoBox);
+
+    nameLabel.set_ellipsize(Pango::EllipsizeMode::END);
+    nameLabel.set_text(device.name.empty() ? "Unknown Device" : device.name );
+    nameLabel.set_halign(Gtk::Align::START);
+    nameLabel.set_valign(Gtk::Align::CENTER);
+    deviceInfoBox.append(nameLabel);
+
+    addressLabel.set_text(device.address);
+    addressLabel.set_halign(Gtk::Align::START);
+    addressLabel.set_valign(Gtk::Align::CENTER);
+    addressLabel.add_css_class("bluetooth-device-address");
+    deviceInfoBox.append(addressLabel);
+    deviceInfoBox.set_size_request(140, -1);
+
+    auto buttonBox = Gtk::Box(Gtk::Orientation::HORIZONTAL);
+    buttonBox.set_hexpand(true);
+    buttonBox.set_halign(Gtk::Align::END);
+    append(buttonBox);
+
+    pairButton.signal_clicked().connect([this]() {
+        if (this->device.paired) {
+            BluetoothController::getInstance()->unpairDevice(this->device.object_path);
+        } else {
+            BluetoothController::getInstance()->pairDevice(this->device.object_path);
+        }
+    });
+    buttonBox.append(pairButton);
+
+    connectButton.signal_clicked().connect([this]() {
+        if (this->device.connected) {
+            BluetoothController::getInstance()->disconnectDevice(this->device.object_path);
+        } else {
+            BluetoothController::getInstance()->connectDevice(this->device.object_path);
+        }
+    });
+    buttonBox.append(connectButton);
+
+    trustButton.signal_clicked().connect([this]() {
+        BluetoothController::getInstance()->trustDevice(this->device.object_path, !this->device.trusted);
+    });
+    buttonBox.append(trustButton);
+}
+
+void BluetoothSettingsRow::updateDevice(const BluetoothDevice &device) {
+    this->device = device;
+
+    if (!device.icon.empty()) {
+        this->icon.set_from_icon_name(device.icon);
+    }
+
+    spdlog::info("Updating device {}: paired={}, connected={}, trusted={}", device.name, device.paired, device.connected, device.trusted);
+
+    nameLabel.set_text(device.name.empty() ? "Unknown Device" : device.name);
+    addressLabel.set_text(device.address);
+    pairButton.setIcon(device.paired ? Icon::BLUETOOTH_CONNECTED : Icon::BLUETOOTH);
+    connectButton.setIcon(device.connected ? Icon::LINK : Icon::LINK_OFF);
+    trustButton.setIcon(device.trusted ? Icon::DONE_ALL : Icon::REMOVE_DONE);
+}

src/widgets/controlCenter/controlCenter.cpp

@@ -21,16 +21,17 @@ ControlCenter::ControlCenter(Icon::Type icon, std::string name)
 
     this->tabRow.set_orientation(Gtk::Orientation::HORIZONTAL);
     this->tabRow.set_spacing(4);
-    this->tabRow.set_margin_bottom(4);
     this->tabRow.add_css_class("control-center-tab-row");
 
-    this->mediaTabButton = std::make_unique<TabButton>(Icon::PLAY_CIRCLE);
-    this->infoTabButton  = std::make_unique<TabButton>(Icon::EMPTY_DASHBOARD);
-    this->timerButton    = std::make_unique<TabButton>(Icon::TOKEN);
+    this->mediaTabButton    = std::make_unique<TabButton>(Icon::PLAY_CIRCLE);
+    this->infoTabButton     = std::make_unique<TabButton>(Icon::EMPTY_DASHBOARD);
+    this->timerButton       = std::make_unique<TabButton>(Icon::TOKEN);
+    this->settingsTabButton = std::make_unique<TabButton>(Icon::SETTINGS);
 
     this->tabRow.append(*this->mediaTabButton);
     this->tabRow.append(*this->infoTabButton);
     this->tabRow.append(*this->timerButton);
+    this->tabRow.append(*this->settingsTabButton);
 
     this->container.append(this->tabRow);
 
@@ -39,15 +40,17 @@ ControlCenter::ControlCenter(Icon::Type icon, std::string name)
     this->contentStack.set_transition_type(Gtk::StackTransitionType::CROSSFADE);
 
     this->mediaControlWidget = std::make_unique<MediaWidget>();
-
-    this->weatherWidget = std::make_unique<WeatherWidget>();
+    this->weatherWidget      = std::make_unique<WeatherWidget>();
+    this->timerWidget        = std::make_unique<TimerWidget>();
+    this->settingsWidget     = std::make_unique<SettingsWidget>();
 
     this->contentStack.add(*this->mediaControlWidget, "controls", "Controls");
     this->contentStack.add(*this->weatherWidget, "info", "Info");
-    this->contentStack.add(*Gtk::make_managed<Gtk::Label>("Timer"), "timer", "Timer");
+    this->contentStack.add(*this->timerWidget, "timer", "Timer");
+    this->contentStack.add(*this->settingsWidget, "settings", "Settings");
 
     this->contentStack.set_visible_child("controls");
-    this->setActiveTab("info");
+    this->setActiveTab("controls");
 
     this->container.append(this->contentStack);
 
@@ -63,6 +66,9 @@ ControlCenter::ControlCenter(Icon::Type icon, std::string name)
         this->setActiveTab("timer");
     });
 
+    this->settingsTabButton->signal_clicked().connect([this]() {
+        this->setActiveTab("settings");
+    });
 }
 
 void ControlCenter::setActiveTab(const std::string &tab_name) {
@@ -71,6 +77,7 @@ void ControlCenter::setActiveTab(const std::string &tab_name) {
     this->mediaTabButton->setActive(false);
     this->infoTabButton->setActive(false);
     this->timerButton->setActive(false);
+    this->settingsTabButton->setActive(false);
     
     if (tab_name == "controls") {
         this->mediaTabButton->setActive(true);
@@ -78,6 +85,7 @@ void ControlCenter::setActiveTab(const std::string &tab_name) {
         this->infoTabButton->setActive(true);
     } else if (tab_name == "timer") {
         this->timerButton->setActive(true);
+    } else if (tab_name == "settings") {
+        this->settingsTabButton->setActive(true);
     }
 }
-

src/widgets/controlCenter/settings.cpp

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

src/widgets/controlCenter/timer.cpp

@@ -0,0 +1,143 @@
+#include "widgets/controlCenter/timer.hpp"
+
+#include <cstdint>
+#include <gdk/gdkkeysyms.h>
+#include <memory>
+#include <spdlog/spdlog.h>
+#include <sys/types.h>
+
+#include "gtkmm/entry.h"
+#include "gtkmm/eventcontrollerkey.h"
+#include "gtkmm/label.h"
+
+TimerWidget::TimerWidget() {
+    set_orientation(Gtk::Orientation::VERTICAL);
+    set_spacing(6);
+
+    this->timerSetConnection = this->timerService->getSignalTimerSet().connect([this](const std::string &duration, uint64_t timerId) {
+        this->addTimer(duration, timerId);
+    });
+
+    this->timerCancelledConnection = this->timerService->getSignalTimerCancelled().connect([this](uint64_t timerId) {
+        this->removeTimer(timerId);
+    });
+
+    this->timerExpiredConnection = this->timerService->getSignalTimerExpired().connect([this](uint64_t timerId) {
+        this->activateTimer(timerId);
+    });
+
+    this->tickConnection = this->timerService->tickSignal.connect([this]() {
+        for (auto &[id, timer] : activeTimers) {
+            timer->tickDown();
+        }
+    });
+
+    auto label = Gtk::make_managed<Gtk::Label>("Set Timer");
+    label->add_css_class("control-center-timer-label");
+
+    auto entry = Gtk::make_managed<Gtk::Entry>();
+    entry->set_placeholder_text("0s");
+    entry->set_valign(Gtk::Align::CENTER);
+    entry->set_alignment(0.5);
+    entry->add_css_class("text-area");
+    entry->set_editable(false);
+    entry->set_focusable(true);
+    entry->set_position(-1);
+
+    set_focusable(false);
+
+    auto keyController = Gtk::EventControllerKey::create();
+    keyController->set_propagation_phase(Gtk::PropagationPhase::CAPTURE);
+    keyController->signal_key_pressed().connect([this, entry](guint keyval, guint, Gdk::ModifierType) -> bool {
+        if (updatingText) {
+            return true;
+        }
+
+        if (keyval >= GDK_KEY_0 && keyval <= GDK_KEY_9) {
+            rawDigits.push_back(static_cast<char>('0' + (keyval - GDK_KEY_0)));
+        } else if (keyval >= GDK_KEY_KP_0 && keyval <= GDK_KEY_KP_9) {
+            rawDigits.push_back(static_cast<char>('0' + (keyval - GDK_KEY_KP_0)));
+        } else if (keyval == GDK_KEY_BackSpace || keyval == GDK_KEY_Delete ||
+                   keyval == GDK_KEY_KP_Delete) {
+            if (!rawDigits.empty()) {
+                rawDigits.pop_back();
+            }
+        } else if (keyval == GDK_KEY_Return || keyval == GDK_KEY_KP_Enter ||
+                   keyval == GDK_KEY_Tab || keyval == GDK_KEY_ISO_Left_Tab) {
+            return false;
+        } else {
+            return true;
+        }
+
+        if (rawDigits.size() > 6) {
+            rawDigits.erase(0, rawDigits.size() - 6);
+        }
+
+        updatingText = true;
+        entry->set_text(format_duration(rawDigits));
+        entry->set_position(-1);
+        updatingText = false;
+        return true;
+    },
+                                                false);
+    entry->add_controller(keyController);
+
+    entry->signal_activate().connect([this, entry]() {
+        if (rawDigits.empty()) {
+            return;
+        }
+
+        uint64_t rawValue = std::stoull(rawDigits);
+        uint64_t seconds = (rawValue / 10000) * 3600 + ((rawValue / 100) % 100) * 60 + (rawValue % 100);
+
+        spdlog::info("Timer set for {} seconds", seconds);
+        this->timerService->addTimer(seconds);
+        rawDigits.clear();
+        this->updatingText = true;
+        entry->set_text("");
+        entry->set_position(-1);
+        this->updatingText = false;
+    },
+                                     false);
+
+    append(*label);
+    append(*entry);
+}
+
+TimerWidget::~TimerWidget() {
+    if (this->timerSetConnection.connected()) {
+        this->timerSetConnection.disconnect();
+    }
+    if (this->timerCancelledConnection.connected()) {
+        this->timerCancelledConnection.disconnect();
+    }
+    if (this->timerExpiredConnection.connected()) {
+        this->timerExpiredConnection.disconnect();
+    }
+    if (this->tickConnection.connected()) {
+        this->tickConnection.disconnect();
+    }
+};
+
+void TimerWidget::addTimer(const std::string &duration, uint64_t timerId) {
+    std::unique_ptr<Timer> timer = std::make_unique<Timer>(duration, timerId);
+
+    append(*timer);
+
+    this->activeTimers[timerId] = std::move(timer);
+}
+
+void TimerWidget::removeTimer(uint64_t timerId) {
+    auto it = this->activeTimers.find(timerId);
+    if (it != this->activeTimers.end()) {
+        this->remove(*it->second);
+        this->activeTimers.erase(it);
+    }
+}
+
+void TimerWidget::activateTimer(uint64_t timerId) {
+    auto it = this->activeTimers.find(timerId);
+    if (it != this->activeTimers.end()) {
+        it->second->activateTimer();
+    }
+}

src/widgets/notification/baseNotification.cpp

@@ -81,8 +81,8 @@ void BaseNotification::start_auto_close_timeout(int timeoutMs) {
     }
 
     autoCloseDeadline   = std::chrono::steady_clock::now() + std::chrono::milliseconds(timeoutMs);
-    autoCloseConnection = Glib::signal_timeout().connect([this]() {
-        this->getSignalClose().emit(this->notificationId);
+    autoCloseConnection = Glib::signal_timeout().connect([self = shared_from_this()]() {
+        self->getSignalClose().emit(self->getNotificationId());
         return false; // Don't repeat
     },
                                                          timeoutMs);

src/widgets/notification/copyNotification.cpp

@@ -79,7 +79,6 @@ void CopyNotification::createImageNotification(NotifyMessage notify) {
 
     auto contentBox = Gtk::make_managed<Gtk::Box>();
     contentBox->set_orientation(Gtk::Orientation::VERTICAL);
-    contentBox->set_margin(0);
     auto imageWidget = Gtk::make_managed<Gtk::Image>(this->copiedImage);
     contentBox->append(*imageWidget);
     imageWidget->set_pixel_size(300);

src/widgets/notification/notificationWindow.cpp

@@ -7,6 +7,7 @@
 #include "helpers/string.hpp"
 
 #include "gtkmm/box.h"
+#include "gtkmm/entry.h"
 #include "gtkmm/image.h"
 #include "gtkmm/label.h"
 
@@ -44,26 +45,49 @@ NotificationWindow::NotificationWindow(uint64_t notificationId, std::shared_ptr<
         header_box->append(*img);
     }
 
-    auto app_label = Gtk::make_managed<Gtk::Label>(StringHelper::trimToSize(notify.app_name, 24));
+    auto app_label = Gtk::make_managed<Gtk::Label>(notify.app_name);
     app_label->set_halign(Gtk::Align::START);
+    app_label->set_ellipsize(Pango::EllipsizeMode::END);
+    app_label->set_max_width_chars(24);
     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>");
+    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);
+    summary_label->set_ellipsize(Pango::EllipsizeMode::END);
+    summary_label->set_lines(1);
     summary_label->set_wrap(true);
     vbox->append(*summary_label);
 
-    auto body_label = Gtk::make_managed<Gtk::Label>(StringHelper::trimToSize(notify.body, 100));
+    auto body_label = Gtk::make_managed<Gtk::Label>(notify.body);
     body_label->set_use_markup(true);
     body_label->set_halign(Gtk::Align::START);
+    body_label->set_ellipsize(Pango::EllipsizeMode::END);
+    body_label->set_lines(3);
     body_label->set_wrap(true);
     vbox->append(*body_label);
 
+    if (notify.has_input) {
+        auto entry = Gtk::make_managed<Gtk::Entry>();
+        entry->set_placeholder_text(notify.input_placeholder);
+        entry->set_halign(Gtk::Align::FILL);
+        entry->set_hexpand(true);
+        entry->add_css_class("notification-entry");
+        vbox->append(*entry);
+        entry->grab_focus_without_selecting();
+
+        entry->signal_activate().connect([this, entry, cb = notify.on_input]() {
+            if (cb) {
+                cb(entry->get_text());
+                this->getSignalClose().emit(this->getNotificationId());
+            }
+        });
+    }
+
     // If actions exist, add buttons
     if (!notify.actions.empty()) {
         auto actions_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 6);

src/widgets/notification/spotifyNotification.cpp

@@ -36,10 +36,12 @@ SpotifyNotification::SpotifyNotification(uint64_t notificationId, std::shared_pt
 
     auto artistLabel = Gtk::make_managed<Gtk::Label>();
     if (!mpris.artist.empty()) {
-        artistLabel->set_text(StringHelper::trimToSize(mpris.artist[0], 30));
+        artistLabel->set_text(mpris.artist[0]);
     } else {
         artistLabel->set_text("Unknown Artist");
     }
+    artistLabel->set_ellipsize(Pango::EllipsizeMode::END);
+    artistLabel->set_max_width_chars(30);
     artistLabel->set_hexpand(true);
     artistLabel->set_halign(Gtk::Align::CENTER);
 

src/widgets/tray.cpp

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

src/widgets/weather.cpp

@@ -32,10 +32,6 @@ WeatherWidget::WeatherWidget()
     : Gtk::Box(Gtk::Orientation::VERTICAL) {
     this->set_orientation(Gtk::Orientation::VERTICAL);
     this->set_spacing(6);
-    this->set_margin_top(4);
-    this->set_margin_bottom(4);
-    this->set_margin_start(4);
-    this->set_margin_end(4);
 
     this->titleLabel.set_text("Weather");
     this->currentLabel.set_text("Now: --");