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

fix code style

Browse Source
This commit is contained in:
Arif Hasanic
2025-12-10 17:58:01 +01:00
parent 4d61a80a7c
commit 0b3a6c4696
19 changed files with 1016 additions and 1366 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
include/app.hpp
View File

@@ -9,15 +9,16 @@
#include "services/tray.hpp" #include "services/tray.hpp"
class App { class App {
public: public:
App(); App();
int run(); int run();
private:
private:
Glib::RefPtr<Gtk::Application> app; Glib::RefPtr<Gtk::Application> app;
std::vector<Bar*> bars; std::vector<Bar *> bars;
HyprlandService hyprlandService; HyprlandService hyprlandService;
TrayService trayService; TrayService trayService;
void setupServices(); void setupServices();
}; };

22
include/bar/bar.hpp
View File

@@ -6,28 +6,28 @@
#include "services/hyprland.hpp" #include "services/hyprland.hpp"
#include "services/tray.hpp" #include "services/tray.hpp"
#include "widgets/clock.hpp" #include "widgets/clock.hpp"
#include "widgets/workspaceIndicator.hpp"
#include "widgets/tray.hpp" #include "widgets/tray.hpp"
#include "widgets/workspaceIndicator.hpp"
class Bar : public Gtk::Window class Bar : public Gtk::Window {
{
public: public:
Bar(GdkMonitor *monitor, HyprlandService &hyprlandService, TrayService &trayService, int monitorId); Bar(GdkMonitor *monitor, HyprlandService &hyprlandService,
TrayService &trayService, int monitorId);
protected: protected:
Clock clock;
Gtk::CenterBox main_box{}; Gtk::CenterBox main_box{};
Gtk::Box left_box{Gtk::Orientation::HORIZONTAL}; Gtk::Box left_box{Gtk::Orientation::HORIZONTAL};
Gtk::Box center_box{Gtk::Orientation::HORIZONTAL}; Gtk::Box center_box{Gtk::Orientation::HORIZONTAL};
Gtk::Box right_box{Gtk::Orientation::HORIZONTAL}; Gtk::Box right_box{Gtk::Orientation::HORIZONTAL};
private: private:
HyprlandService &m_hyprlandService; Clock clock;
TrayService &m_trayService; TrayService &trayService;
int m_monitorId; HyprlandService &hyprlandService;
WorkspaceIndicator *m_workspaceIndicator = nullptr; int monitorId;
TrayWidget *m_trayWidget = nullptr; WorkspaceIndicator *workspaceIndicator = nullptr;
class VolumeWidget *m_volumeWidget = nullptr; TrayWidget *trayWidget = nullptr;
class VolumeWidget *volumeWidget = nullptr;
void setup_ui(); void setup_ui();
void load_css(); void load_css();

22
include/helpers/systemHelper.hpp
View File

@@ -1,28 +1,24 @@
#pragma once #pragma once
#include <array> #include <array>
#include <memory>
#include <string>
#include <fstream> #include <fstream>
#include <memory>
#include <sstream> #include <sstream>
#include <string>
class SystemHelper class SystemHelper {
{
public: public:
static std::string get_command_output(const char *cmd) static std::string get_command_output(const char *cmd) {
{
std::array<char, 128> buffer; std::array<char, 128> buffer;
std::string result; std::string result;
std::unique_ptr<FILE, int (*)(FILE *)> pipe(popen(cmd, "r"), pclose); std::unique_ptr<FILE, int (*)(FILE *)> pipe(popen(cmd, "r"), pclose);
if (!pipe) if (!pipe) {
{
throw std::runtime_error("popen() failed!"); throw std::runtime_error("popen() failed!");
} }
// Read the output a chunk at a time until the stream ends // Read the output a chunk at a time until the stream ends
while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
{
result += buffer.data(); result += buffer.data();
} }
@@ -30,11 +26,9 @@ class SystemHelper
} }
// Read an entire file into a string. Throws std::runtime_error on failure. // Read an entire file into a string. Throws std::runtime_error on failure.
static std::string read_file_to_string(const std::string &path) static std::string read_file_to_string(const std::string &path) {
{
std::ifstream in(path, std::ios::in | std::ios::binary); std::ifstream in(path, std::ios::in | std::ios::binary);
if (!in) if (!in) {
{
throw std::runtime_error("Failed to open file: " + path); throw std::runtime_error("Failed to open file: " + path);
} }

46
include/services/hyprland.hpp
View File

@@ -7,13 +7,11 @@
#include <sigc++/sigc++.h> #include <sigc++/sigc++.h>
#include <string> #include <string>
class HyprlandService class HyprlandService {
{
public: public:
static constexpr int kWorkspaceSlotCount = 5; static constexpr int kWorkspaceSlotCount = 5;
struct WorkspaceState struct WorkspaceState {
{
int id = -1; int id = -1;
int hyprId = -1; int hyprId = -1;
bool active = false; bool active = false;
@@ -22,8 +20,7 @@ class HyprlandService
std::string label; std::string label;
}; };
struct Monitor struct Monitor {
{
std::map<int, WorkspaceState> workspaceStates; std::map<int, WorkspaceState> workspaceStates;
std::string name; std::string name;
int x = 0; int x = 0;
@@ -52,12 +49,12 @@ class HyprlandService
// associated Hyprland workspace id (hyprId >= 0) that id will be used. // associated Hyprland workspace id (hyprId >= 0) that id will be used.
// Otherwise the slot and monitor name will be used to request creation // Otherwise the slot and monitor name will be used to request creation
// / activation via `hyprctl`. // / activation via `hyprctl`.
void switchToWorkspace(int monitorId, int slot); void switchToWorkspace(int workspaceId);
private: private:
int m_fd = -1; int fd = -1;
std::string m_buffer; std::string buffer;
std::map<int, Monitor> m_monitors; std::map<int, Monitor> monitors;
bool on_socket_read(Glib::IOCondition condition); bool on_socket_read(Glib::IOCondition condition);
void parse_message(const std::string &line); void parse_message(const std::string &line);
@@ -66,8 +63,7 @@ class HyprlandService
void refresh_workspaces(); void refresh_workspaces();
}; };
inline void HyprlandService::printMonitor(const Monitor &mon) const inline void HyprlandService::printMonitor(const Monitor &mon) const {
{
std::cout << "=== Monitor Info ===\n"; std::cout << "=== Monitor Info ===\n";
std::cout << "Name: " << mon.name << " (ID: " << mon.id << ")\n"; std::cout << "Name: " << mon.name << " (ID: " << mon.id << ")\n";
std::cout << "Position: (" << mon.x << ", " << mon.y << ")\n"; std::cout << "Position: (" << mon.x << ", " << mon.y << ")\n";
@@ -75,26 +71,26 @@ inline void HyprlandService::printMonitor(const Monitor &mon) const
std::cout << "Workspaces:\n"; std::cout << "Workspaces:\n";
if (mon.workspaceStates.empty()) if (mon.workspaceStates.empty()) {
{
std::cout << " (None)\n"; std::cout << " (None)\n";
} } else {
else for (int slot = 1; slot <= HyprlandService::kWorkspaceSlotCount;
{ ++slot) {
for (int slot = 1; slot <= HyprlandService::kWorkspaceSlotCount; ++slot)
{
const auto it = mon.workspaceStates.find(slot); const auto it = mon.workspaceStates.find(slot);
if (it == mon.workspaceStates.end()) if (it == mon.workspaceStates.end()) {
{
std::cout << " - [Slot: " << slot << " | HyprID: n/a]" std::cout << " - [Slot: " << slot << " | HyprID: n/a]"
<< " Label: <none> | Active: No | Focused: No | Urgent: No\n"; << " Label: <none> | Active: No | Focused: No | "
"Urgent: No\n";
continue; continue;
} }
const WorkspaceState &ws = it->second; const WorkspaceState &ws = it->second;
std::cout << " - [Slot: " << ws.id << " | HyprID: " std::cout << " - [Slot: " << ws.id << " | HyprID: "
<< (ws.hyprId >= 0 ? std::to_string(ws.hyprId) : std::string("n/a")) << "] " << (ws.hyprId >= 0 ? std::to_string(ws.hyprId)
<< "Label: " << (ws.label.empty() ? "<none>" : ws.label) << " | " : std::string("n/a"))
<< "] "
<< "Label: " << (ws.label.empty() ? "<none>" : ws.label)
<< " | "
<< "Active: " << (ws.active ? "Yes" : "No") << " | " << "Active: " << (ws.active ? "Yes" : "No") << " | "
<< "Focused: " << (ws.focused ? "Yes" : "No") << " | " << "Focused: " << (ws.focused ? "Yes" : "No") << " | "
<< "Urgent: " << (ws.urgent ? "Yes" : "No") << "\n"; << "Urgent: " << (ws.urgent ? "Yes" : "No") << "\n";

126
include/services/tray.hpp
View File

@@ -3,8 +3,8 @@
#include <gdkmm/memorytexture.h> #include <gdkmm/memorytexture.h>
#include <giomm/actiongroup.h> #include <giomm/actiongroup.h>
#include <giomm/dbusconnection.h> #include <giomm/dbusconnection.h>
#include <giomm/menumodel.h>
#include <giomm/init.h> #include <giomm/init.h>
#include <giomm/menumodel.h>
#include <glibmm/bytes.h> #include <glibmm/bytes.h>
#include <glibmm/refptr.h> #include <glibmm/refptr.h>
#include <sigc++/sigc++.h> #include <sigc++/sigc++.h>
@@ -16,11 +16,9 @@
#include <string> #include <string>
#include <vector> #include <vector>
class TrayService class TrayService {
{
public: public:
struct Item struct Item {
{
std::string id; std::string id;
std::string busName; std::string busName;
std::string objectPath; std::string objectPath;
@@ -48,14 +46,13 @@ class TrayService
Glib::RefPtr<Gio::MenuModel> get_menu_model(const std::string &id); Glib::RefPtr<Gio::MenuModel> get_menu_model(const std::string &id);
Glib::RefPtr<Gio::ActionGroup> get_menu_action_group(const std::string &id); Glib::RefPtr<Gio::ActionGroup> get_menu_action_group(const std::string &id);
void debug_dump_menu_layout(const std::string &id); void debug_dump_menu_layout(const std::string &id);
struct MenuNode struct MenuNode {
{ int id = 0;
int id = 0; std::string label;
std::string label; bool enabled = true;
bool enabled = true; bool visible = true;
bool visible = true; bool separator = false;
bool separator = false; std::vector<MenuNode> children;
std::vector<MenuNode> children;
}; };
std::optional<MenuNode> get_menu_layout(const std::string &id); std::optional<MenuNode> get_menu_layout(const std::string &id);
bool activate_menu_item(const std::string &id, int itemId); bool activate_menu_item(const std::string &id, int itemId);
@@ -65,56 +62,57 @@ class TrayService
sigc::signal<void(const Item &)> &signal_item_updated(); sigc::signal<void(const Item &)> &signal_item_updated();
private: private:
struct TrackedItem struct TrackedItem {
{
Item publicData; Item publicData;
guint signalSubscriptionId = 0; guint signalSubscriptionId = 0;
guint ownerWatchId = 0; guint ownerWatchId = 0;
Glib::RefPtr<Gio::MenuModel> menuModel; Glib::RefPtr<Gio::MenuModel> menuModel;
Glib::RefPtr<Gio::ActionGroup> menuActions; Glib::RefPtr<Gio::ActionGroup> menuActions;
}; };
Glib::RefPtr<Gio::DBus::Connection> m_connection; Glib::RefPtr<Gio::DBus::Connection> connection;
Glib::RefPtr<Gio::DBus::NodeInfo> m_nodeInfo; Glib::RefPtr<Gio::DBus::NodeInfo> nodeInfo;
Gio::DBus::InterfaceVTable m_vtable; Gio::DBus::InterfaceVTable vtable;
guint m_nameOwnerId = 0; guint nameOwnerId = 0;
guint m_registrationId = 0; guint registrationId = 0;
bool m_hostRegistered = false; bool hostRegistered = false;
std::map<std::string, std::unique_ptr<TrackedItem>> m_items; std::map<std::string, std::unique_ptr<TrackedItem>> items;
sigc::signal<void(const Item &)> m_itemAddedSignal; sigc::signal<void(const Item &)> itemAddedSignal;
sigc::signal<void(const std::string &)> m_itemRemovedSignal; sigc::signal<void(const std::string &)> itemRemovedSignal;
sigc::signal<void(const Item &)> m_itemUpdatedSignal; sigc::signal<void(const Item &)> itemUpdatedSignal;
void on_bus_acquired(const Glib::RefPtr<Gio::DBus::Connection> &connection, const Glib::ustring &name); void on_bus_acquired(const Glib::RefPtr<Gio::DBus::Connection> &connection,
void on_name_acquired(const Glib::RefPtr<Gio::DBus::Connection> &connection, const Glib::ustring &name); const Glib::ustring &name);
void on_name_lost(const Glib::RefPtr<Gio::DBus::Connection> &connection, const Glib::ustring &name); void on_name_acquired(const Glib::RefPtr<Gio::DBus::Connection> &connection,
const Glib::ustring &name);
void on_name_lost(const Glib::RefPtr<Gio::DBus::Connection> &connection,
const Glib::ustring &name);
void handle_method_call(const Glib::RefPtr<Gio::DBus::Connection> &connection, void handle_method_call(
const Glib::ustring &sender, const Glib::RefPtr<Gio::DBus::Connection> &connection,
const Glib::ustring &object_path, const Glib::ustring &sender, const Glib::ustring &object_path,
const Glib::ustring &interface_name, const Glib::ustring &interface_name, const Glib::ustring &method_name,
const Glib::ustring &method_name, const Glib::VariantContainerBase &parameters,
const Glib::VariantContainerBase &parameters, const Glib::RefPtr<Gio::DBus::MethodInvocation> &invocation);
const Glib::RefPtr<Gio::DBus::MethodInvocation> &invocation);
void handle_get_property_slot(Glib::VariantBase &result, void handle_get_property_slot(
const Glib::RefPtr<Gio::DBus::Connection> &connection, Glib::VariantBase &result,
const Glib::ustring &sender, const Glib::RefPtr<Gio::DBus::Connection> &connection,
const Glib::ustring &object_path, const Glib::ustring &sender, const Glib::ustring &object_path,
const Glib::ustring &interface_name, const Glib::ustring &interface_name,
const Glib::ustring &property_name); const Glib::ustring &property_name);
bool handle_set_property_slot(const Glib::RefPtr<Gio::DBus::Connection> &connection, bool handle_set_property_slot(
const Glib::ustring &sender, const Glib::RefPtr<Gio::DBus::Connection> &connection,
const Glib::ustring &object_path, const Glib::ustring &sender, const Glib::ustring &object_path,
const Glib::ustring &interface_name, const Glib::ustring &interface_name, const Glib::ustring &property_name,
const Glib::ustring &property_name, const Glib::VariantBase &value);
const Glib::VariantBase &value);
Glib::VariantBase handle_get_property(const Glib::ustring &property_name); Glib::VariantBase handle_get_property(const Glib::ustring &property_name);
bool handle_set_property(const Glib::ustring &property_name, const Glib::VariantBase &value); bool handle_set_property(const Glib::ustring &property_name,
const Glib::VariantBase &value);
void register_item(const Glib::ustring &sender, const std::string &service); void register_item(const Glib::ustring &sender, const std::string &service);
void unregister_item(const std::string &id); void unregister_item(const std::string &id);
@@ -122,25 +120,23 @@ class TrayService
void refresh_item(TrackedItem &item); void refresh_item(TrackedItem &item);
void emit_registered_items_changed(); void emit_registered_items_changed();
Glib::Variant<std::vector<Glib::ustring>> create_registered_items_variant() const; Glib::Variant<std::vector<Glib::ustring>>
create_registered_items_variant() const;
void emit_watcher_signal(const Glib::ustring &signal_name, const Glib::VariantContainerBase &parameters); void emit_watcher_signal(const Glib::ustring &signal_name,
const Glib::VariantContainerBase &parameters);
static void on_dbus_signal_static(GDBusConnection *connection, static void on_dbus_signal_static(GDBusConnection *connection,
const gchar *sender_name, const gchar *sender_name,
const gchar *object_path, const gchar *object_path,
const gchar *interface_name, const gchar *interface_name,
const gchar *signal_name, const gchar *signal_name,
GVariant *parameters, GVariant *parameters, gpointer user_data);
gpointer user_data); void on_dbus_signal(const gchar *sender_name, const gchar *object_path,
void on_dbus_signal(const gchar *sender_name, const gchar *interface_name, const gchar *signal_name,
const gchar *object_path, GVariant *parameters);
const gchar *interface_name,
const gchar *signal_name,
GVariant *parameters);
static void on_name_vanished_static(GDBusConnection *connection, static void on_name_vanished_static(GDBusConnection *connection,
const gchar *name, const gchar *name, gpointer user_data);
gpointer user_data);
void on_name_vanished(const gchar *bus_name); void on_name_vanished(const gchar *bus_name);
static Glib::RefPtr<Gdk::Paintable> parse_icon_pixmap(GVariant *variant); static Glib::RefPtr<Gdk::Paintable> parse_icon_pixmap(GVariant *variant);

3
include/widgets/clock.hpp
View File

@@ -6,8 +6,7 @@
#include "interface/updateable.ipp" #include "interface/updateable.ipp"
class Clock : public Gtk::Label, public IUpdatable class Clock : public Gtk::Label, public IUpdatable {
{
public: public:
bool onUpdate(); bool onUpdate();
}; };

7
include/widgets/spacer.hpp
View File

@@ -4,12 +4,9 @@
#include <gtkmm.h> #include <gtkmm.h>
#include <gtkmm/label.h> #include <gtkmm/label.h>
class Spacer : public Gtk::Label {
class Spacer : public Gtk::Label
{
public: public:
Spacer() Spacer() {
{
set_hexpand(true); set_hexpand(true);
set_text("|"); set_text("|");
set_name("spacer"); set_name("spacer");

63
include/widgets/tray.hpp
View File

@@ -1,16 +1,16 @@
#pragma once #pragma once
#include <giomm/menu.h>
#include <giomm/menuitem.h>
#include <giomm/menumodel.h>
#include <giomm/simpleaction.h>
#include <giomm/simpleactiongroup.h>
#include <gtkmm/box.h> #include <gtkmm/box.h>
#include <gtkmm/button.h> #include <gtkmm/button.h>
#include <gtkmm/gestureclick.h> #include <gtkmm/gestureclick.h>
#include <gtkmm/picture.h>
#include <gtkmm/image.h> #include <gtkmm/image.h>
#include <gtkmm/picture.h>
#include <gtkmm/popovermenu.h> #include <gtkmm/popovermenu.h>
#include <giomm/menumodel.h>
#include <giomm/menu.h>
#include <giomm/menuitem.h>
#include <giomm/simpleaction.h>
#include <giomm/simpleactiongroup.h>
#include <map> #include <map>
#include <memory> #include <memory>
@@ -18,53 +18,52 @@
#include "services/tray.hpp" #include "services/tray.hpp"
class TrayIconWidget : public Gtk::Button class TrayIconWidget : public Gtk::Button {
{
public: public:
TrayIconWidget(TrayService &service, std::string id); TrayIconWidget(TrayService &service, std::string id);
void update(const TrayService::Item &item); void update(const TrayService::Item &item);
private: private:
TrayService &m_service; TrayService &service;
std::string m_id; std::string id;
Gtk::Box m_container; Gtk::Box container;
Gtk::Picture m_picture; Gtk::Picture picture;
Gtk::Image m_image; Gtk::Image image;
Glib::RefPtr<Gtk::GestureClick> m_primaryGesture; Glib::RefPtr<Gtk::GestureClick> primaryGesture;
Glib::RefPtr<Gtk::GestureClick> m_secondaryGesture; Glib::RefPtr<Gtk::GestureClick> secondaryGesture;
Glib::RefPtr<Gtk::PopoverMenu> m_menuPopover; Glib::RefPtr<Gtk::PopoverMenu> menuPopover;
Glib::RefPtr<Gio::SimpleActionGroup> m_menuActions; Glib::RefPtr<Gio::SimpleActionGroup> menuActions;
Glib::RefPtr<Gio::MenuModel> m_menuModel; Glib::RefPtr<Gio::MenuModel> menuModel;
sigc::connection m_menuChangedConnection; sigc::connection menuChangedConnection;
bool m_menuPopupPending = false; bool menuPopupPending = false;
double m_pendingX = 0.0; double pendingX = 0.0;
double m_pendingY = 0.0; double pendingY = 0.0;
void on_primary_released(int n_press, double x, double y); void on_primary_released(int n_press, double x, double y);
void on_secondary_released(int n_press, double x, double y); void on_secondary_released(int n_press, double x, double y);
bool ensure_menu(); bool ensure_menu();
void on_menu_items_changed(guint position, guint removed, guint added); void on_menu_items_changed(guint position, guint removed, guint added);
void try_popup(); void try_popup();
void populate_menu_items(const std::vector<TrayService::MenuNode> &nodes, void
const Glib::RefPtr<Gio::Menu> &menu, populate_menu_items(const std::vector<TrayService::MenuNode> &nodes,
const Glib::RefPtr<Gio::SimpleActionGroup> &actions); const Glib::RefPtr<Gio::Menu> &menu,
const Glib::RefPtr<Gio::SimpleActionGroup> &actions);
void on_menu_action(const Glib::VariantBase &parameter, int itemId); void on_menu_action(const Glib::VariantBase &parameter, int itemId);
}; };
class TrayWidget : public Gtk::Box class TrayWidget : public Gtk::Box {
{
public: public:
explicit TrayWidget(TrayService &service); explicit TrayWidget(TrayService &service);
~TrayWidget() override; ~TrayWidget() override;
private: private:
TrayService &m_service; TrayService &service;
std::map<std::string, std::unique_ptr<TrayIconWidget>> m_icons; std::map<std::string, std::unique_ptr<TrayIconWidget>> icons;
sigc::connection m_addConnection; sigc::connection addConnection;
sigc::connection m_removeConnection; sigc::connection removeConnection;
sigc::connection m_updateConnection; sigc::connection updateConnection;
void on_item_added(const TrayService::Item &item); void on_item_added(const TrayService::Item &item);
void on_item_removed(const std::string &id); void on_item_removed(const std::string &id);

11
include/widgets/volumeWidget.hpp
View File

@@ -1,11 +1,10 @@
#pragma once #pragma once
#include <gtkmm.h> #include <gtkmm.h>
#include <string>
#include <sigc++/sigc++.h> #include <sigc++/sigc++.h>
#include <string>
class VolumeWidget : public Gtk::Box class VolumeWidget : public Gtk::Box {
{
public: public:
VolumeWidget(); VolumeWidget();
virtual ~VolumeWidget(); virtual ~VolumeWidget();
@@ -18,7 +17,7 @@ class VolumeWidget : public Gtk::Box
bool on_timeout(); bool on_timeout();
private: private:
Gtk::Label m_label; Gtk::Label label;
Glib::RefPtr<Gtk::GestureClick> m_click; Glib::RefPtr<Gtk::GestureClick> click;
sigc::connection m_timeoutConn; sigc::connection timeoutConn;
}; };

11
include/widgets/workspaceIndicator.hpp
View File

@@ -6,17 +6,16 @@
#include "services/hyprland.hpp" #include "services/hyprland.hpp"
class WorkspaceIndicator : public Gtk::Box class WorkspaceIndicator : public Gtk::Box {
{
public: public:
WorkspaceIndicator(HyprlandService &service, int monitorId); WorkspaceIndicator(HyprlandService &service, int monitorId);
~WorkspaceIndicator() override; ~WorkspaceIndicator() override;
private: private:
HyprlandService &m_service; HyprlandService &service;
int m_monitorId; int monitorId;
sigc::connection m_workspaceConnection; sigc::connection workspaceConnection;
sigc::connection m_monitorConnection; sigc::connection monitorConnection;
void rebuild(); void rebuild();
void on_workspace_update(int monitorId); void on_workspace_update(int monitorId);

42
resources/bar.css
View File

@@ -1,15 +1,13 @@
* { * {
all: unset; /* Tries to remove all styling */ all: unset;
} }
window { window {
/* sleak modern */
background-color: rgba(30, 30, 30, 0.8); background-color: rgba(30, 30, 30, 0.8);
color: #ffffff; color: #ffffff;
font-family: "IBMPlexSans-Regular", sans-serif; font-family: "IBMPlexSans-Regular", sans-serif;
font-size: 14px; font-size: 14px;
padding: 2px 7px; padding: 2px 7px;
} }
#clock-label { #clock-label {
@@ -23,6 +21,9 @@ window {
border-radius: 5px; border-radius: 5px;
} }
.workspace-pill:hover {
background-color: rgba(104, 104, 104, 0.2);
}
.workspace-pill:last-child { .workspace-pill:last-child {
margin-right: 0; margin-right: 0;
} }
@@ -40,21 +41,36 @@ window {
color: #111; color: #111;
} }
/* Hover effect: slightly brighten background and show pointer */ button {
.workspace-pill:hover { padding: 2px 5px;
background-color: rgba(255, 255, 255, 0.3); margin: 0 2px;
border-radius: 3px;
background-color: transparent;
color: #ffffff;
border: none;
} }
.tray-icon { /* Hover effect: slightly brighten background and show pointer */
padding: 0; button:hover {
margin: 0; background-color: #111111;
border: none;
background: transparent;
min-width: 0;
min-height: 0;
} }
#spacer { #spacer {
color: rgba(255, 255, 255, 0.3); color: rgba(255, 255, 255, 0.3);
padding: 0 5px; padding: 0 5px;
}
popover {
background-color: rgb(30, 30, 30);
color: #ffffff;
font-family: "IBMPlexSans-Regular", sans-serif;
}
tooltip {
background-color: rgba(50, 50, 50, 0.9);
color: #ffffff;
font-family: "IBMPlexSans-Regular", sans-serif;
padding: 5px 10px;
} }

17
src/app.cpp
View File

@@ -8,7 +8,7 @@ App::App() {
this->setupServices(); this->setupServices();
this->app = Gtk::Application::create("org.example.mybar"); this->app = Gtk::Application::create("org.example.mybar");
app->signal_activate().connect([&]() { app->signal_activate().connect([&]() {
auto display = Gdk::Display::get_default(); auto display = Gdk::Display::get_default();
auto monitors = display->get_monitors(); auto monitors = display->get_monitors();
@@ -17,16 +17,19 @@ App::App() {
auto monitor = std::dynamic_pointer_cast<Gdk::Monitor>( auto monitor = std::dynamic_pointer_cast<Gdk::Monitor>(
monitors->get_object(i)); monitors->get_object(i));
if (monitor) { if (monitor) {
HyprlandService::Monitor* hyprlandMonitor = nullptr; HyprlandService::Monitor *hyprlandMonitor = nullptr;
try { try {
hyprlandMonitor = this->hyprlandService.getMonitorByIndex(i); hyprlandMonitor =
this->hyprlandService.getMonitorByIndex(i);
} catch (const std::exception &ex) { } catch (const std::exception &ex) {
std::cerr << "[App] Failed to fetch Hyprland monitor: " << ex.what() << std::endl; std::cerr << "[App] Failed to fetch Hyprland monitor: "
<< ex.what() << std::endl;
continue; continue;
} }
auto bar = new Bar(monitor->gobj(), this->hyprlandService, this->trayService, hyprlandMonitor->id); auto bar = new Bar(monitor->gobj(), this->hyprlandService,
this->trayService, hyprlandMonitor->id);
bar->set_application(app); bar->set_application(app);
bar->show(); bar->show();
@@ -53,6 +56,4 @@ void App::setupServices() {
this->trayService.start(); this->trayService.start();
} }
int App::run() { int App::run() { return this->app->run(); }
return this->app->run();
}

47
src/bar/bar.cpp
View File

@@ -1,8 +1,8 @@
#include "bar/bar.hpp" #include "bar/bar.hpp"
#include "gtk/gtk.h" #include "gtk/gtk.h"
#include "widgets/spacer.hpp" #include "widgets/spacer.hpp"
#include "widgets/workspaceIndicator.hpp"
#include "widgets/volumeWidget.hpp" #include "widgets/volumeWidget.hpp"
#include "widgets/workspaceIndicator.hpp"
#include "helpers/systemHelper.hpp" #include "helpers/systemHelper.hpp"
@@ -13,16 +13,15 @@
#include "glibmm/main.h" #include "glibmm/main.h"
#include "sigc++/functors/mem_fun.h" #include "sigc++/functors/mem_fun.h"
Bar::Bar(GdkMonitor *monitor, HyprlandService &hyprlandService, TrayService &trayService, int monitorId) Bar::Bar(GdkMonitor *monitor, HyprlandService &hyprlandService,
: m_hyprlandService(hyprlandService), m_trayService(trayService), m_monitorId(monitorId) TrayService &trayService, int monitorId)
{ : hyprlandService(hyprlandService), trayService(trayService),
// Name the window so CSS can be scoped specifically to this bar. monitorId(monitorId) {
set_name("bar-window"); set_name("bar-window");
gtk_layer_init_for_window(this->gobj()); gtk_layer_init_for_window(this->gobj());
if (monitor) if (monitor) {
{
gtk_layer_set_monitor(this->gobj(), monitor); gtk_layer_set_monitor(this->gobj(), monitor);
} }
@@ -39,15 +38,11 @@ Bar::Bar(GdkMonitor *monitor, HyprlandService &hyprlandService, TrayService &tra
clock.onUpdate(); clock.onUpdate();
Glib::signal_timeout().connect( Glib::signal_timeout().connect(sigc::mem_fun(clock, &Clock::onUpdate),
sigc::mem_fun( 1000);
clock,
&Clock::onUpdate),
1000);
} }
void Bar::setup_ui() void Bar::setup_ui() {
{
main_box.set_hexpand(true); main_box.set_hexpand(true);
main_box.set_start_widget(left_box); main_box.set_start_widget(left_box);
@@ -64,8 +59,9 @@ void Bar::setup_ui()
right_box.set_valign(Gtk::Align::CENTER); right_box.set_valign(Gtk::Align::CENTER);
m_workspaceIndicator = Gtk::make_managed<WorkspaceIndicator>(m_hyprlandService, m_monitorId); workspaceIndicator =
left_box.append(*m_workspaceIndicator); Gtk::make_managed<WorkspaceIndicator>(hyprlandService, monitorId);
left_box.append(*workspaceIndicator);
clock.set_name("clock-label"); clock.set_name("clock-label");
clock.set_hexpand(false); clock.set_hexpand(false);
@@ -74,24 +70,21 @@ void Bar::setup_ui()
center_box.append(clock); center_box.append(clock);
center_box.append(*(new Spacer())); center_box.append(*(new Spacer()));
// Volume widget placed after spacer volumeWidget = Gtk::make_managed<VolumeWidget>();
m_volumeWidget = Gtk::make_managed<VolumeWidget>(); center_box.append(*volumeWidget);
center_box.append(*m_volumeWidget);
m_trayWidget = Gtk::make_managed<TrayWidget>(m_trayService); trayWidget = Gtk::make_managed<TrayWidget>(trayService);
right_box.append(*m_trayWidget); right_box.append(*trayWidget);
} }
void Bar::load_css() void Bar::load_css() {
{
auto css_provider = Gtk::CssProvider::create(); auto css_provider = Gtk::CssProvider::create();
// Load CSS from external resource file. Fall back to embedded CSS on error. const std::string css =
const std::string css = SystemHelper::read_file_to_string("resources/bar.css"); SystemHelper::read_file_to_string("resources/bar.css");
css_provider->load_from_data(css); css_provider->load_from_data(css);
Gtk::StyleContext::add_provider_for_display( Gtk::StyleContext::add_provider_for_display(
Gdk::Display::get_default(), Gdk::Display::get_default(), css_provider,
css_provider,
GTK_STYLE_PROVIDER_PRIORITY_USER + 1); GTK_STYLE_PROVIDER_PRIORITY_USER + 1);
} }

303
src/services/hyprland.cpp
View File

@@ -14,48 +14,41 @@
#include "helpers/systemHelper.hpp" #include "helpers/systemHelper.hpp"
namespace namespace {
{ const char *kMonitorCommand = "hyprctl monitors -j";
const char *kMonitorCommand = "hyprctl monitors -j";
const char *kWorkspaceCommand = "hyprctl workspaces -j"; const char *kWorkspaceCommand = "hyprctl workspaces -j";
bool is_workspace_event(const std::string &event) bool is_workspace_event(const std::string &event) {
{
return event.find("workspace") != std::string::npos; return event.find("workspace") != std::string::npos;
} }
} } // namespace
HyprlandService::HyprlandService() = default; HyprlandService::HyprlandService() = default;
HyprlandService::~HyprlandService() HyprlandService::~HyprlandService() {
{ if (fd != -1) {
if (m_fd != -1) close(fd);
{ fd = -1;
close(m_fd);
m_fd = -1;
} }
} }
void HyprlandService::on_hyprland_event(std::string event, std::string /*data*/) void HyprlandService::on_hyprland_event(std::string event,
{ std::string /*data*/) {
if (is_workspace_event(event) || event == "focusedmon" || event == "monitoradded" || event == "monitorremoved") if (is_workspace_event(event) || event == "focusedmon" ||
{ event == "monitoradded" || event == "monitorremoved") {
refresh_monitors(); refresh_monitors();
refresh_workspaces(); refresh_workspaces();
} }
} }
void HyprlandService::start() void HyprlandService::start() {
{
const std::string socket_path = get_socket_path(); const std::string socket_path = get_socket_path();
if (socket_path.empty()) if (socket_path.empty()) {
{
return; return;
} }
m_fd = socket(AF_UNIX, SOCK_STREAM, 0); fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (m_fd == -1) if (fd == -1) {
{
std::cerr << "[Hyprland] Failed to create socket" << std::endl; std::cerr << "[Hyprland] Failed to create socket" << std::endl;
return; return;
} }
@@ -65,63 +58,59 @@ void HyprlandService::start()
addr.sun_family = AF_UNIX; addr.sun_family = AF_UNIX;
std::strncpy(addr.sun_path, socket_path.c_str(), sizeof(addr.sun_path) - 1); std::strncpy(addr.sun_path, socket_path.c_str(), sizeof(addr.sun_path) - 1);
if (connect(m_fd, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)) == -1) if (connect(fd, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)) ==
{ -1) {
std::cerr << "[Hyprland] Failed to connect to " << socket_path << std::endl; std::cerr << "[Hyprland] Failed to connect to " << socket_path
close(m_fd); << std::endl;
m_fd = -1; close(fd);
fd = -1;
return; return;
} }
std::cout << "[Hyprland] Connected to event socket." << std::endl; std::cout << "[Hyprland] Connected to event socket." << std::endl;
Glib::signal_io().connect( Glib::signal_io().connect(
sigc::mem_fun(*this, &HyprlandService::on_socket_read), sigc::mem_fun(*this, &HyprlandService::on_socket_read), fd,
m_fd, Glib::IOCondition::IO_IN | Glib::IOCondition::IO_HUP |
Glib::IOCondition::IO_IN | Glib::IOCondition::IO_HUP | Glib::IOCondition::IO_ERR); Glib::IOCondition::IO_ERR);
refresh_monitors(); refresh_monitors();
refresh_workspaces(); refresh_workspaces();
} }
bool HyprlandService::on_socket_read(Glib::IOCondition condition) bool HyprlandService::on_socket_read(Glib::IOCondition condition) {
{ const auto error_mask =
const auto error_mask = Glib::IOCondition::IO_HUP | Glib::IOCondition::IO_ERR; Glib::IOCondition::IO_HUP | Glib::IOCondition::IO_ERR;
if (static_cast<int>(condition & error_mask) != 0) if (static_cast<int>(condition & error_mask) != 0) {
{
std::cerr << "[Hyprland] Socket disconnected." << std::endl; std::cerr << "[Hyprland] Socket disconnected." << std::endl;
close(m_fd); close(fd);
m_fd = -1; fd = -1;
return false; return false;
} }
char buffer[4096]; char buffer[4096];
const ssize_t bytes_read = read(m_fd, buffer, sizeof(buffer) - 1); const ssize_t bytes_read = read(fd, buffer, sizeof(buffer) - 1);
if (bytes_read > 0) if (bytes_read > 0) {
{
buffer[bytes_read] = '\0'; buffer[bytes_read] = '\0';
m_buffer.append(buffer); this->buffer.append(buffer);
size_t pos = 0; size_t pos = 0;
while ((pos = m_buffer.find('\n')) != std::string::npos) while ((pos = this->buffer.find('\n')) != std::string::npos) {
{ const std::string line = this->buffer.substr(0, pos);
const std::string line = m_buffer.substr(0, pos);
parse_message(line); parse_message(line);
m_buffer.erase(0, pos + 1); this->buffer.erase(0, pos + 1);
} }
} }
return true; return true;
} }
void HyprlandService::parse_message(const std::string &line) void HyprlandService::parse_message(const std::string &line) {
{
const size_t split = line.find(">>"); const size_t split = line.find(">>");
if (split != std::string::npos) if (split != std::string::npos) {
{
const std::string event_name = line.substr(0, split); const std::string event_name = line.substr(0, split);
const std::string event_data = line.substr(split + 2); const std::string event_data = line.substr(split + 2);
@@ -129,13 +118,11 @@ void HyprlandService::parse_message(const std::string &line)
} }
} }
std::string HyprlandService::get_socket_path() std::string HyprlandService::get_socket_path() {
{ const char *sig = std::getenv("HYPRLAND_INSTANCE_SIGNATURE");
const char *sig = std::getenv("HYPRLAND_INSTANCE_SIGNATURE");
const char *runtime = std::getenv("XDG_RUNTIME_DIR"); const char *runtime = std::getenv("XDG_RUNTIME_DIR");
if (!sig || !runtime) if (!sig || !runtime) {
{
std::cerr << "[Hyprland] Environment variables missing!" << std::endl; std::cerr << "[Hyprland] Environment variables missing!" << std::endl;
return ""; return "";
} }
@@ -143,232 +130,200 @@ std::string HyprlandService::get_socket_path()
return std::string(runtime) + "/hypr/" + sig + "/.socket2.sock"; return std::string(runtime) + "/hypr/" + sig + "/.socket2.sock";
} }
void HyprlandService::refresh_monitors() void HyprlandService::refresh_monitors() {
{
std::string output; std::string output;
try try {
{
output = SystemHelper::get_command_output(kMonitorCommand); output = SystemHelper::get_command_output(kMonitorCommand);
} } catch (const std::exception &ex) {
catch (const std::exception &ex) std::cerr << "[Hyprland] Failed to query monitors: " << ex.what()
{ << std::endl;
std::cerr << "[Hyprland] Failed to query monitors: " << ex.what() << std::endl;
return; return;
} }
auto monitorsJson = nlohmann::json::parse(output, nullptr, false); auto monitorsJson = nlohmann::json::parse(output, nullptr, false);
if (!monitorsJson.is_array()) if (!monitorsJson.is_array()) {
{
std::cerr << "[Hyprland] Unexpected monitor payload" << std::endl; std::cerr << "[Hyprland] Unexpected monitor payload" << std::endl;
return; return;
} }
std::map<int, Monitor> updated; std::map<int, Monitor> updated;
for (const auto &monitorJson : monitorsJson) for (const auto &monitorJson : monitorsJson) {
{ if (!monitorJson.is_object()) {
if (!monitorJson.is_object())
{
continue; continue;
} }
Monitor monitor; Monitor monitor;
monitor.id = monitorJson.value("id", -1); monitor.id = monitorJson.value("id", -1);
monitor.name = monitorJson.value("name", ""); monitor.name = monitorJson.value("name", "");
monitor.x = monitorJson.value("x", 0); monitor.x = monitorJson.value("x", 0);
monitor.y = monitorJson.value("y", 0); monitor.y = monitorJson.value("y", 0);
if (monitorJson.contains("activeWorkspace") && monitorJson["activeWorkspace"].is_object()) if (monitorJson.contains("activeWorkspace") &&
{ monitorJson["activeWorkspace"].is_object()) {
monitor.focusedWorkspaceId = monitorJson["activeWorkspace"].value("id", -1); monitor.focusedWorkspaceId =
monitorJson["activeWorkspace"].value("id", -1);
} }
if (monitor.id >= 0) if (monitor.id >= 0) {
{
updated.emplace(monitor.id, std::move(monitor)); updated.emplace(monitor.id, std::move(monitor));
} }
} }
m_monitors.swap(updated); monitors.swap(updated);
monitorStateChanged.emit(); monitorStateChanged.emit();
} }
void HyprlandService::refresh_workspaces() void HyprlandService::refresh_workspaces() {
{ if (monitors.empty()) {
if (m_monitors.empty())
{
return; return;
} }
std::string output; std::string output;
try try {
{
output = SystemHelper::get_command_output(kWorkspaceCommand); output = SystemHelper::get_command_output(kWorkspaceCommand);
} } catch (const std::exception &ex) {
catch (const std::exception &ex) std::cerr << "[Hyprland] Failed to query workspaces: " << ex.what()
{ << std::endl;
std::cerr << "[Hyprland] Failed to query workspaces: " << ex.what() << std::endl;
return; return;
} }
auto workspacesJson = nlohmann::json::parse(output, nullptr, false); auto workspacesJson = nlohmann::json::parse(output, nullptr, false);
if (!workspacesJson.is_array()) if (!workspacesJson.is_array()) {
{
std::cerr << "[Hyprland] Unexpected workspace payload" << std::endl; std::cerr << "[Hyprland] Unexpected workspace payload" << std::endl;
return; return;
} }
for (auto &pair : m_monitors) for (auto &pair : monitors) {
{
auto &monitor = pair.second; auto &monitor = pair.second;
monitor.workspaceStates.clear(); monitor.workspaceStates.clear();
int focusedSlot = -1; int focusedSlot = -1;
if (monitor.focusedWorkspaceId > 0) if (monitor.focusedWorkspaceId > 0) {
{ focusedSlot = ((monitor.focusedWorkspaceId - 1) %
focusedSlot = ((monitor.focusedWorkspaceId - 1) % HyprlandService::kWorkspaceSlotCount) + 1; HyprlandService::kWorkspaceSlotCount) +
1;
} }
for (int slot = 1; slot <= HyprlandService::kWorkspaceSlotCount; ++slot) for (int slot = 1; slot <= HyprlandService::kWorkspaceSlotCount;
{ ++slot) {
WorkspaceState state; WorkspaceState state;
state.id = slot; state.id = slot;
state.hyprId = -1; state.hyprId = -1;
state.label = std::to_string(slot); state.label = std::to_string(slot);
state.focused = (slot == focusedSlot); state.focused = (slot == focusedSlot);
state.active = state.focused; state.active = state.focused;
state.urgent = false; state.urgent = false;
monitor.workspaceStates.emplace(slot, state); monitor.workspaceStates.emplace(slot, state);
} }
} }
for (const auto &workspaceJson : workspacesJson) for (const auto &workspaceJson : workspacesJson) {
{ if (!workspaceJson.is_object()) {
if (!workspaceJson.is_object())
{
continue; continue;
} }
const int monitorId = workspaceJson.value("monitorID", -1); const int monitorId = workspaceJson.value("monitorID", -1);
const int workspaceId = workspaceJson.value("id", -1); const int workspaceId = workspaceJson.value("id", -1);
auto monitorIt = m_monitors.find(monitorId); auto monitorIt = monitors.find(monitorId);
if (monitorIt == m_monitors.end() || workspaceId < 0) if (monitorIt == monitors.end() || workspaceId < 0) {
{
continue; continue;
} }
auto &monitor = monitorIt->second; auto &monitor = monitorIt->second;
const int slot = ((workspaceId - 1) % HyprlandService::kWorkspaceSlotCount) + 1; const int slot =
((workspaceId - 1) % HyprlandService::kWorkspaceSlotCount) + 1;
auto &workspaceState = monitor.workspaceStates[slot]; auto &workspaceState = monitor.workspaceStates[slot];
workspaceState.id = slot; workspaceState.id = slot;
workspaceState.hyprId = workspaceId; workspaceState.hyprId = workspaceId;
workspaceState.focused = (monitor.focusedWorkspaceId == workspaceId); workspaceState.focused = (monitor.focusedWorkspaceId == workspaceId);
workspaceState.active = workspaceState.focused || workspaceJson.value("windows", 0) > 0; workspaceState.active =
workspaceState.urgent = false; workspaceState.focused || workspaceJson.value("windows", 0) > 0;
workspaceState.urgent = false;
std::string labelCandidate; std::string labelCandidate;
if (workspaceJson.contains("name") && workspaceJson["name"].is_string()) if (workspaceJson.contains("name") &&
{ workspaceJson["name"].is_string()) {
labelCandidate = workspaceJson["name"].get<std::string>(); labelCandidate = workspaceJson["name"].get<std::string>();
} }
if (labelCandidate.empty() || labelCandidate == std::to_string(workspaceId)) if (labelCandidate.empty() ||
{ labelCandidate == std::to_string(workspaceId)) {
workspaceState.label = std::to_string(slot); workspaceState.label = std::to_string(slot);
} } else {
else
{
workspaceState.label = labelCandidate; workspaceState.label = labelCandidate;
} }
if (workspaceJson.contains("urgent") && workspaceJson["urgent"].is_boolean()) if (workspaceJson.contains("urgent") &&
{ workspaceJson["urgent"].is_boolean()) {
workspaceState.urgent = workspaceJson["urgent"].get<bool>(); workspaceState.urgent = workspaceJson["urgent"].get<bool>();
} } else if (workspaceJson.contains("hasurgent") &&
else if (workspaceJson.contains("hasurgent") && workspaceJson["hasurgent"].is_boolean()) workspaceJson["hasurgent"].is_boolean()) {
{
workspaceState.urgent = workspaceJson["hasurgent"].get<bool>(); workspaceState.urgent = workspaceJson["hasurgent"].get<bool>();
} }
} }
for (const auto &pair : m_monitors) for (const auto &pair : monitors) {
{
workspaceStateChanged.emit(pair.first); workspaceStateChanged.emit(pair.first);
} }
} }
HyprlandService::Monitor *HyprlandService::getMonitorById(int id) HyprlandService::Monitor *HyprlandService::getMonitorById(int id) {
{ auto it = monitors.find(id);
auto it = m_monitors.find(id); if (it == monitors.end()) {
if (it == m_monitors.end()) throw std::runtime_error("Monitor with ID " + std::to_string(id) +
{ " not found.");
throw std::runtime_error("Monitor with ID " + std::to_string(id) + " not found.");
} }
return &it->second; return &it->second;
} }
const HyprlandService::Monitor *HyprlandService::getMonitorById(int id) const const HyprlandService::Monitor *HyprlandService::getMonitorById(int id) const {
{ auto it = monitors.find(id);
auto it = m_monitors.find(id); if (it == monitors.end()) {
if (it == m_monitors.end()) throw std::runtime_error("Monitor with ID " + std::to_string(id) +
{ " not found.");
throw std::runtime_error("Monitor with ID " + std::to_string(id) + " not found.");
} }
return &it->second; return &it->second;
} }
HyprlandService::Monitor *HyprlandService::getMonitorByIndex(std::size_t index) HyprlandService::Monitor *
{ HyprlandService::getMonitorByIndex(std::size_t index) {
if (index >= m_monitors.size()) if (index >= monitors.size()) {
{ throw std::runtime_error("Monitor index out of bounds: " +
throw std::runtime_error("Monitor index out of bounds: " + std::to_string(index)); std::to_string(index));
} }
auto it = m_monitors.begin(); auto it = monitors.begin();
std::advance(it, static_cast<long>(index)); std::advance(it, static_cast<long>(index));
return &it->second; return &it->second;
} }
void HyprlandService::switchToWorkspace(int monitorId, int slot) void HyprlandService::switchToWorkspace(int workspaceId) {
{ std::string cmd =
auto it = m_monitors.find(monitorId); "hyprctl dispatch workspace " + std::to_string(workspaceId);
if (it == m_monitors.end())
{
std::cerr << "[Hyprland] switchToWorkspace: monitor " << monitorId << " not found\n";
return;
}
const auto &monitor = it->second; try {
auto wsIt = monitor.workspaceStates.find(slot);
std::string cmd;
// Use the Hyprland workspace id if available
cmd = "hyprctl dispatch workspace " + std::to_string(wsIt->second.hyprId);
try
{
(void)SystemHelper::get_command_output(cmd.c_str()); (void)SystemHelper::get_command_output(cmd.c_str());
} } catch (const std::exception &ex) {
catch (const std::exception &ex) std::cerr << "[Hyprland] Failed to dispatch workspace command: "
{ << ex.what() << " cmd=" << cmd << std::endl;
std::cerr << "[Hyprland] Failed to dispatch workspace command: " << ex.what() << " cmd=" << cmd << std::endl;
} }
} }
const HyprlandService::Monitor *HyprlandService::getMonitorByIndex(std::size_t index) const const HyprlandService::Monitor *
{ HyprlandService::getMonitorByIndex(std::size_t index) const {
if (index >= m_monitors.size()) if (index >= monitors.size()) {
{ throw std::runtime_error("Monitor index out of bounds: " +
throw std::runtime_error("Monitor index out of bounds: " + std::to_string(index)); std::to_string(index));
} }
auto it = m_monitors.begin(); auto it = monitors.begin();
std::advance(it, static_cast<long>(index)); std::advance(it, static_cast<long>(index));
return &it->second; return &it->second;
} }

1070
src/services/tray.cpp
View File

File diff suppressed because it is too large Load Diff

6
src/widgets/clock.cpp
View File

@@ -3,9 +3,9 @@
#include <chrono> #include <chrono>
#include <iomanip> #include <iomanip>
bool Clock::onUpdate() bool Clock::onUpdate() {
{ auto now =
auto now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now()); std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
std::stringstream ss; std::stringstream ss;
ss << std::put_time(std::localtime(&now), "%H:%M:%S"); ss << std::put_time(std::localtime(&now), "%H:%M:%S");

371
src/widgets/tray.cpp
View File

@@ -1,363 +1,326 @@
#include "widgets/tray.hpp" #include "widgets/tray.hpp"
#include <gtk/gtk.h>
#include <gdkmm/rectangle.h> #include <gdkmm/rectangle.h>
#include <gio/gmenu.h> #include <gio/gmenu.h>
#include <utility> #include <gtk/gtk.h>
#include <iostream> #include <iostream>
#include <utility>
TrayIconWidget::TrayIconWidget(TrayService &service, std::string id) TrayIconWidget::TrayIconWidget(TrayService &service, std::string id)
: m_service(service), m_id(std::move(id)), m_container(Gtk::Orientation::HORIZONTAL) : service(service), id(std::move(id)),
{ container(Gtk::Orientation::HORIZONTAL) {
set_has_frame(false); set_has_frame(false);
set_focusable(false); set_focusable(false);
set_valign(Gtk::Align::CENTER); set_valign(Gtk::Align::CENTER);
set_halign(Gtk::Align::CENTER); set_halign(Gtk::Align::CENTER);
m_picture.set_halign(Gtk::Align::CENTER); picture.set_halign(Gtk::Align::CENTER);
m_picture.set_valign(Gtk::Align::CENTER); picture.set_valign(Gtk::Align::CENTER);
m_picture.set_can_shrink(true); picture.set_can_shrink(true);
m_picture.set_size_request(20, 20); picture.set_size_request(20, 20);
m_image.set_pixel_size(20); image.set_pixel_size(20);
m_image.set_halign(Gtk::Align::CENTER); image.set_halign(Gtk::Align::CENTER);
m_image.set_valign(Gtk::Align::CENTER); image.set_valign(Gtk::Align::CENTER);
m_container.set_halign(Gtk::Align::CENTER); container.set_halign(Gtk::Align::CENTER);
m_container.set_valign(Gtk::Align::CENTER); container.set_valign(Gtk::Align::CENTER);
m_container.append(m_picture); container.append(picture);
m_container.append(m_image); container.append(image);
m_picture.set_visible(false); picture.set_visible(false);
m_image.set_visible(true); image.set_visible(true);
set_child(m_container); set_child(container);
m_primaryGesture = Gtk::GestureClick::create(); primaryGesture = Gtk::GestureClick::create();
m_primaryGesture->set_button(GDK_BUTTON_PRIMARY); primaryGesture->set_button(GDK_BUTTON_PRIMARY);
m_primaryGesture->signal_released().connect(sigc::mem_fun(*this, &TrayIconWidget::on_primary_released)); primaryGesture->signal_released().connect(
add_controller(m_primaryGesture); sigc::mem_fun(*this, &TrayIconWidget::on_primary_released));
add_controller(primaryGesture);
m_secondaryGesture = Gtk::GestureClick::create(); secondaryGesture = Gtk::GestureClick::create();
m_secondaryGesture->set_button(GDK_BUTTON_SECONDARY); secondaryGesture->set_button(GDK_BUTTON_SECONDARY);
m_secondaryGesture->signal_released().connect(sigc::mem_fun(*this, &TrayIconWidget::on_secondary_released)); secondaryGesture->signal_released().connect(
add_controller(m_secondaryGesture); sigc::mem_fun(*this, &TrayIconWidget::on_secondary_released));
add_controller(secondaryGesture);
} }
void TrayIconWidget::update(const TrayService::Item &item) void TrayIconWidget::update(const TrayService::Item &item) {
{ if (!item.menuAvailable) {
if (!item.menuAvailable) menuModel.reset();
{ menuActions.reset();
m_menuModel.reset(); menuPopupPending = false;
m_menuActions.reset(); if (menuChangedConnection.connected()) {
m_menuPopupPending = false; menuChangedConnection.disconnect();
if (m_menuChangedConnection.connected())
{
m_menuChangedConnection.disconnect();
} }
if (m_menuPopover) if (menuPopover) {
{ menuPopover->insert_action_group("dbusmenu",
m_menuPopover->insert_action_group("dbusmenu", Glib::RefPtr<Gio::ActionGroup>()); Glib::RefPtr<Gio::ActionGroup>());
m_menuPopover->set_menu_model({}); menuPopover->set_menu_model({});
m_menuPopover->unparent(); menuPopover->unparent();
m_menuPopover.reset(); menuPopover.reset();
} }
} }
if (item.iconPaintable) if (item.iconPaintable) {
{ picture.set_paintable(item.iconPaintable);
m_picture.set_paintable(item.iconPaintable); picture.set_visible(true);
m_picture.set_visible(true); image.set_visible(false);
m_image.set_visible(false); } else if (!item.iconName.empty()) {
} image.set_from_icon_name(item.iconName);
else if (!item.iconName.empty()) image.set_pixel_size(20);
{ image.set_visible(true);
m_image.set_from_icon_name(item.iconName); picture.set_visible(false);
m_image.set_pixel_size(20); } else {
m_image.set_visible(true); picture.set_paintable({});
m_picture.set_visible(false); image.set_visible(false);
} picture.set_visible(false);
else
{
m_picture.set_paintable({});
m_image.set_visible(false);
m_picture.set_visible(false);
} }
if (!item.title.empty()) if (!item.title.empty()) {
{
set_tooltip_text(item.title); set_tooltip_text(item.title);
} } else {
else
{
set_tooltip_text(""); set_tooltip_text("");
} }
set_sensitive(item.status != "Passive"); set_sensitive(item.status != "Passive");
} }
void TrayIconWidget::on_primary_released(int /*n_press*/, double x, double y) void TrayIconWidget::on_primary_released(int /*n_press*/, double x, double y) {
{ service.activate(id, -1, -1);
m_service.activate(m_id, -1, -1);
} }
void TrayIconWidget::on_secondary_released(int /*n_press*/, double x, double y) void TrayIconWidget::on_secondary_released(int /*n_press*/, double x,
{ double y) {
m_service.contextMenu(m_id, -1, -1); service.contextMenu(id, -1, -1);
if (!ensure_menu()) if (!ensure_menu()) {
{
return; return;
} }
m_pendingX = x; pendingX = x;
m_pendingY = y; pendingY = y;
m_menuPopupPending = true; menuPopupPending = true;
try_popup(); try_popup();
} }
bool TrayIconWidget::ensure_menu() bool TrayIconWidget::ensure_menu() {
{ auto layoutOpt = service.get_menu_layout(id);
auto layoutOpt = m_service.get_menu_layout(m_id); if (!layoutOpt) {
if (!layoutOpt) menuModel.reset();
{ menuActions.reset();
m_menuModel.reset(); menuPopupPending = false;
m_menuActions.reset(); if (menuChangedConnection.connected()) {
m_menuPopupPending = false; menuChangedConnection.disconnect();
if (m_menuChangedConnection.connected())
{
m_menuChangedConnection.disconnect();
} }
if (m_menuPopover) if (menuPopover) {
{
remove_action_group("dbusmenu"); remove_action_group("dbusmenu");
m_menuPopover->set_menu_model({}); menuPopover->set_menu_model({});
m_menuPopover->unparent(); menuPopover->unparent();
m_menuPopover.reset(); menuPopover.reset();
} }
return false; return false;
} }
const auto &layout = *layoutOpt; const auto &layout = *layoutOpt;
auto menu = Gio::Menu::create(); auto menu = Gio::Menu::create();
auto actions = Gio::SimpleActionGroup::create(); auto actions = Gio::SimpleActionGroup::create();
populate_menu_items(layout.children, menu, actions); populate_menu_items(layout.children, menu, actions);
const auto itemCount = menu->get_n_items(); const auto itemCount = menu->get_n_items();
std::cout << "[TrayIconWidget] menu update for " << m_id << ", items: " << itemCount << std::endl; std::cout << "[TrayIconWidget] menu update for " << id
if (itemCount == 0) << ", items: " << itemCount << std::endl;
{ if (itemCount == 0) {
m_service.debug_dump_menu_layout(m_id); service.debug_dump_menu_layout(id);
return false; return false;
} }
m_menuModel = menu; menuModel = menu;
m_menuActions = actions; menuActions = actions;
if (!m_menuPopover) if (!menuPopover) {
{
auto *rawPopover = Gtk::make_managed<Gtk::PopoverMenu>(); auto *rawPopover = Gtk::make_managed<Gtk::PopoverMenu>();
m_menuPopover = Glib::make_refptr_for_instance<Gtk::PopoverMenu>(rawPopover); menuPopover =
if (!m_menuPopover) Glib::make_refptr_for_instance<Gtk::PopoverMenu>(rawPopover);
{ if (!menuPopover) {
return false; return false;
} }
m_menuPopover->set_has_arrow(false); menuPopover->set_has_arrow(false);
m_menuPopover->set_autohide(true); menuPopover->set_autohide(true);
m_menuPopover->set_parent(*this); menuPopover->set_parent(*this);
} }
m_menuPopover->remove_action_group("dbusmenu"); menuPopover->remove_action_group("dbusmenu");
m_menuPopover->insert_action_group("dbusmenu", m_menuActions); menuPopover->insert_action_group("dbusmenu", menuActions);
if (m_menuChangedConnection.connected()) if (menuChangedConnection.connected()) {
{ menuChangedConnection.disconnect();
m_menuChangedConnection.disconnect();
} }
m_menuChangedConnection = m_menuModel->signal_items_changed().connect(sigc::mem_fun(*this, &TrayIconWidget::on_menu_items_changed)); menuChangedConnection = menuModel->signal_items_changed().connect(
sigc::mem_fun(*this, &TrayIconWidget::on_menu_items_changed));
m_menuPopover->set_menu_model(m_menuModel); menuPopover->set_menu_model(menuModel);
return true; return true;
} }
void TrayIconWidget::on_menu_items_changed(guint /*position*/, guint /*removed*/, guint /*added*/) void TrayIconWidget::on_menu_items_changed(guint /*position*/,
{ guint /*removed*/, guint /*added*/) {
if (!m_menuModel) if (!menuModel) {
{
return; return;
} }
const auto count = m_menuModel->get_n_items(); const auto count = menuModel->get_n_items();
std::cout << "[TrayIconWidget] items changed for " << m_id << ": " << count << " entries" << std::endl; std::cout << "[TrayIconWidget] items changed for " << id << ": " << count
<< " entries" << std::endl;
try_popup(); try_popup();
} }
void TrayIconWidget::try_popup() void TrayIconWidget::try_popup() {
{ if (!menuPopupPending || !menuPopover || !menuModel) {
if (!m_menuPopupPending || !m_menuPopover || !m_menuModel)
{
return; return;
} }
if (m_menuModel->get_n_items() == 0) if (menuModel->get_n_items() == 0) {
{
return; return;
} }
Gdk::Rectangle rect(static_cast<int>(m_pendingX), static_cast<int>(m_pendingY), 1, 1); Gdk::Rectangle rect(static_cast<int>(pendingX), static_cast<int>(pendingY),
m_menuPopover->set_pointing_to(rect); 1, 1);
m_menuPopover->popup(); menuPopover->set_pointing_to(rect);
m_menuPopupPending = false; menuPopover->popup();
menuPopupPending = false;
} }
void TrayIconWidget::populate_menu_items(const std::vector<TrayService::MenuNode> &nodes, void TrayIconWidget::populate_menu_items(
const Glib::RefPtr<Gio::Menu> &menu, const std::vector<TrayService::MenuNode> &nodes,
const Glib::RefPtr<Gio::SimpleActionGroup> &actions) const Glib::RefPtr<Gio::Menu> &menu,
{ const Glib::RefPtr<Gio::SimpleActionGroup> &actions) {
for (const auto &node : nodes) for (const auto &node : nodes) {
{ if (!node.visible) {
if (!node.visible)
{
continue; continue;
} }
if (node.separator) if (node.separator) {
{
auto section = Gio::Menu::create(); auto section = Gio::Menu::create();
menu->append_section("", section); menu->append_section("", section);
continue; continue;
} }
if (!node.children.empty()) if (!node.children.empty()) {
{
auto submenu = Gio::Menu::create(); auto submenu = Gio::Menu::create();
populate_menu_items(node.children, submenu, actions); populate_menu_items(node.children, submenu, actions);
auto submenuItem = Gio::MenuItem::create(node.label, Glib::ustring()); auto submenuItem =
Gio::MenuItem::create(node.label, Glib::ustring());
submenuItem->set_submenu(submenu); submenuItem->set_submenu(submenu);
if (!node.enabled) if (!node.enabled) {
{ submenuItem->set_attribute_value(
submenuItem->set_attribute_value("enabled", Glib::Variant<bool>::create(false)); "enabled", Glib::Variant<bool>::create(false));
} }
menu->append_item(submenuItem); menu->append_item(submenuItem);
continue; continue;
} }
const std::string actionName = "item" + std::to_string(node.id); const std::string actionName = "item" + std::to_string(node.id);
auto menuItem = Gio::MenuItem::create(node.label, "dbusmenu." + actionName); auto menuItem =
if (!node.enabled) Gio::MenuItem::create(node.label, "dbusmenu." + actionName);
{ if (!node.enabled) {
menuItem->set_attribute_value("enabled", Glib::Variant<bool>::create(false)); menuItem->set_attribute_value("enabled",
Glib::Variant<bool>::create(false));
} }
auto action = Gio::SimpleAction::create(actionName); auto action = Gio::SimpleAction::create(actionName);
action->set_enabled(node.enabled); action->set_enabled(node.enabled);
action->signal_activate().connect(sigc::bind(sigc::mem_fun(*this, &TrayIconWidget::on_menu_action), node.id)); action->signal_activate().connect(sigc::bind(
sigc::mem_fun(*this, &TrayIconWidget::on_menu_action), node.id));
actions->add_action(action); actions->add_action(action);
menu->append_item(menuItem); menu->append_item(menuItem);
} }
} }
void TrayIconWidget::on_menu_action(const Glib::VariantBase & /*parameter*/, int itemId) void TrayIconWidget::on_menu_action(const Glib::VariantBase & /*parameter*/,
{ int itemId) {
m_service.activate_menu_item(m_id, itemId); service.activate_menu_item(id, itemId);
if (m_menuPopover) if (menuPopover) {
{ menuPopover->popdown();
m_menuPopover->popdown();
} }
} }
TrayWidget::TrayWidget(TrayService &service) TrayWidget::TrayWidget(TrayService &service)
: Gtk::Box(Gtk::Orientation::HORIZONTAL), m_service(service) : Gtk::Box(Gtk::Orientation::HORIZONTAL), service(service) {
{
set_valign(Gtk::Align::CENTER); set_valign(Gtk::Align::CENTER);
set_halign(Gtk::Align::CENTER); set_halign(Gtk::Align::CENTER);
set_visible(false); set_visible(false);
m_addConnection = m_service.signal_item_added().connect(sigc::mem_fun(*this, &TrayWidget::on_item_added)); addConnection = service.signal_item_added().connect(
m_removeConnection = m_service.signal_item_removed().connect(sigc::mem_fun(*this, &TrayWidget::on_item_removed)); sigc::mem_fun(*this, &TrayWidget::on_item_added));
m_updateConnection = m_service.signal_item_updated().connect(sigc::mem_fun(*this, &TrayWidget::on_item_updated)); removeConnection = service.signal_item_removed().connect(
sigc::mem_fun(*this, &TrayWidget::on_item_removed));
updateConnection = service.signal_item_updated().connect(
sigc::mem_fun(*this, &TrayWidget::on_item_updated));
rebuild_existing(); rebuild_existing();
} }
TrayWidget::~TrayWidget() TrayWidget::~TrayWidget() {
{ if (addConnection.connected()) {
if (m_addConnection.connected()) addConnection.disconnect();
{
m_addConnection.disconnect();
} }
if (m_removeConnection.connected()) if (removeConnection.connected()) {
{ removeConnection.disconnect();
m_removeConnection.disconnect();
} }
if (m_updateConnection.connected()) if (updateConnection.connected()) {
{ updateConnection.disconnect();
m_updateConnection.disconnect();
} }
} }
void TrayWidget::rebuild_existing() void TrayWidget::rebuild_existing() {
{ auto items = service.snapshotItems();
auto items = m_service.snapshotItems(); for (const auto &item : items) {
for (const auto &item : items)
{
on_item_added(item); on_item_added(item);
} }
set_visible(!m_icons.empty()); set_visible(!icons.empty());
} }
void TrayWidget::on_item_added(const TrayService::Item &item) void TrayWidget::on_item_added(const TrayService::Item &item) {
{ auto it = icons.find(item.id);
auto it = m_icons.find(item.id); if (it != icons.end()) {
if (it != m_icons.end())
{
it->second->update(item); it->second->update(item);
return; return;
} }
auto icon = std::make_unique<TrayIconWidget>(m_service, item.id); auto icon = std::make_unique<TrayIconWidget>(service, item.id);
icon->update(item); icon->update(item);
auto *raw = icon.get(); auto *raw = icon.get();
append(*raw); append(*raw);
m_icons.emplace(item.id, std::move(icon)); icons.emplace(item.id, std::move(icon));
set_visible(true); set_visible(true);
} }
void TrayWidget::on_item_removed(const std::string &id) void TrayWidget::on_item_removed(const std::string &id) {
{ auto it = icons.find(id);
auto it = m_icons.find(id); if (it == icons.end()) {
if (it == m_icons.end())
{
return; return;
} }
remove(*it->second); remove(*it->second);
it->second->unparent(); it->second->unparent();
m_icons.erase(it); icons.erase(it);
if (m_icons.empty()) if (icons.empty()) {
{
set_visible(false); set_visible(false);
} }
} }
void TrayWidget::on_item_updated(const TrayService::Item &item) void TrayWidget::on_item_updated(const TrayService::Item &item) {
{ auto it = icons.find(item.id);
auto it = m_icons.find(item.id); if (it == icons.end()) {
if (it == m_icons.end())
{
on_item_added(item); on_item_added(item);
return; return;
} }

102
src/widgets/volumeWidget.cpp
View File

@@ -2,60 +2,57 @@
#include "helpers/systemHelper.hpp" #include "helpers/systemHelper.hpp"
#include <sigc++/functors/mem_fun.h>
#include <regex>
#include <iostream>
#include <cmath> #include <cmath>
#include <iostream>
#include <regex>
#include <sigc++/functors/mem_fun.h>
VolumeWidget::VolumeWidget() VolumeWidget::VolumeWidget() : Gtk::Box(Gtk::Orientation::HORIZONTAL) {
: Gtk::Box(Gtk::Orientation::HORIZONTAL)
{
set_valign(Gtk::Align::CENTER); set_valign(Gtk::Align::CENTER);
set_halign(Gtk::Align::CENTER); set_halign(Gtk::Align::CENTER);
m_label.set_halign(Gtk::Align::CENTER); label.set_halign(Gtk::Align::CENTER);
m_label.set_valign(Gtk::Align::CENTER); label.set_valign(Gtk::Align::CENTER);
m_label.set_text("Vol"); label.set_text("Vol");
append(m_label); append(label);
// Click toggles mute using wpctl // Click toggles mute using wpctl
m_click = Gtk::GestureClick::create(); click = Gtk::GestureClick::create();
m_click->set_button(GDK_BUTTON_PRIMARY); click->set_button(GDK_BUTTON_PRIMARY);
// signal_released provides (int, double, double) — use lambda to ignore args // signal_released provides (int, double, double) — use lambda to ignore
m_click->signal_released().connect([this](int /*n_press*/, double /*x*/, double /*y*/) // args
{ click->signal_released().connect([this](int /*n_press*/, double /*x*/,
try double /*y*/) {
{ try {
// Toggle mute then refresh // Toggle mute then refresh
(void)SystemHelper::get_command_output("wpctl set-mute @DEFAULT_SINK@ toggle"); (void)SystemHelper::get_command_output(
} "wpctl set-mute @DEFAULT_SINK@ toggle");
catch (const std::exception &ex) } catch (const std::exception &ex) {
{ std::cerr << "[VolumeWidget] failed to toggle mute: " << ex.what()
std::cerr << "[VolumeWidget] failed to toggle mute: " << ex.what() << std::endl; << std::endl;
} }
this->update(); this->update();
}); });
add_controller(m_click); add_controller(click);
// Initial read // Initial read
update(); update();
// Start polling every 1 second to keep the display up to date // Start polling every 1 second to keep the display up to date
m_timeoutConn = Glib::signal_timeout().connect(sigc::mem_fun(*this, &VolumeWidget::on_timeout), 100); timeoutConn = Glib::signal_timeout().connect(
sigc::mem_fun(*this, &VolumeWidget::on_timeout), 100);
} }
VolumeWidget::~VolumeWidget() VolumeWidget::~VolumeWidget() {
{ if (timeoutConn.connected())
if (m_timeoutConn.connected()) timeoutConn.disconnect();
m_timeoutConn.disconnect();
} }
void VolumeWidget::update() void VolumeWidget::update() {
{ try {
try const std::string out =
{ SystemHelper::get_command_output("wpctl get-volume @DEFAULT_SINK@");
const std::string out = SystemHelper::get_command_output("wpctl get-volume @DEFAULT_SINK@");
// Attempt to parse a number (percentage or fraction) // Attempt to parse a number (percentage or fraction)
std::smatch m; std::smatch m;
@@ -65,12 +62,9 @@ void VolumeWidget::update()
std::string text = out; std::string text = out;
int percent = -1; int percent = -1;
if (std::regex_search(text, m, r_percent)) if (std::regex_search(text, m, r_percent)) {
{
percent = static_cast<int>(std::round(std::stod(m[1].str()))); percent = static_cast<int>(std::round(std::stod(m[1].str())));
} } else if (std::regex_search(text, m, r_number)) {
else if (std::regex_search(text, m, r_number))
{
// If number looks like 0.8 treat as fraction // If number looks like 0.8 treat as fraction
const double v = std::stod(m[1].str()); const double v = std::stod(m[1].str());
if (v <= 1.0) if (v <= 1.0)
@@ -79,34 +73,26 @@ void VolumeWidget::update()
percent = static_cast<int>(std::round(v)); percent = static_cast<int>(std::round(v));
} }
if (percent >= 0) if (percent >= 0) {
{ label.set_text(std::to_string(percent) + "%");
m_label.set_text(std::to_string(percent) + "%"); } else {
}
else
{
// Fallback to raw output (trimmed) // Fallback to raw output (trimmed)
auto pos = text.find_first_not_of(" \t\n\r"); auto pos = text.find_first_not_of(" \t\n\r");
if (pos != std::string::npos) if (pos != std::string::npos) {
{
auto end = text.find_last_not_of(" \t\n\r"); auto end = text.find_last_not_of(" \t\n\r");
m_label.set_text(text.substr(pos, end - pos + 1)); label.set_text(text.substr(pos, end - pos + 1));
} } else {
else label.set_text("?");
{
m_label.set_text("?");
} }
} }
} } catch (const std::exception &ex) {
catch (const std::exception &ex) std::cerr << "[VolumeWidget] failed to read volume: " << ex.what()
{ << std::endl;
std::cerr << "[VolumeWidget] failed to read volume: " << ex.what() << std::endl; label.set_text("N/A");
m_label.set_text("N/A");
} }
} }
bool VolumeWidget::on_timeout() bool VolumeWidget::on_timeout() {
{
update(); update();
return true; // keep timeout active return true; // keep timeout active
} }

102
src/widgets/workspaceIndicator.cpp
View File

@@ -1,130 +1,104 @@
#include "widgets/workspaceIndicator.hpp" #include "widgets/workspaceIndicator.hpp"
#include <exception> #include <exception>
#include <gtkmm/widget.h>
#include <gtkmm/gestureclick.h>
#include <gdk/gdk.h> #include <gdk/gdk.h>
#include <gtkmm/gestureclick.h>
#include <gtkmm/widget.h>
#include <sigc++/functors/mem_fun.h> #include <sigc++/functors/mem_fun.h>
WorkspaceIndicator::WorkspaceIndicator(HyprlandService &service, int monitorId) WorkspaceIndicator::WorkspaceIndicator(HyprlandService &service, int monitorId)
: Gtk::Box(Gtk::Orientation::HORIZONTAL), m_service(service), m_monitorId(monitorId) : Gtk::Box(Gtk::Orientation::HORIZONTAL), service(service),
{ monitorId(monitorId) {
set_margin_top(2); set_margin_top(2);
set_margin_bottom(2); set_margin_bottom(2);
m_workspaceConnection = m_service.workspaceStateChanged.connect( workspaceConnection = service.workspaceStateChanged.connect(
sigc::mem_fun(*this, &WorkspaceIndicator::on_workspace_update)); sigc::mem_fun(*this, &WorkspaceIndicator::on_workspace_update));
m_monitorConnection = m_service.monitorStateChanged.connect( monitorConnection = service.monitorStateChanged.connect(
sigc::mem_fun(*this, &WorkspaceIndicator::on_monitor_update)); sigc::mem_fun(*this, &WorkspaceIndicator::on_monitor_update));
rebuild(); rebuild();
} }
WorkspaceIndicator::~WorkspaceIndicator() WorkspaceIndicator::~WorkspaceIndicator() {
{ if (workspaceConnection.connected()) {
if (m_workspaceConnection.connected()) workspaceConnection.disconnect();
{
m_workspaceConnection.disconnect();
} }
if (m_monitorConnection.connected()) if (monitorConnection.connected()) {
{ monitorConnection.disconnect();
m_monitorConnection.disconnect();
} }
} }
void WorkspaceIndicator::on_workspace_update(int monitorId) void WorkspaceIndicator::on_workspace_update(int monitorId) {
{ if (monitorId != monitorId && monitorId != -1) {
if (monitorId != m_monitorId && monitorId != -1)
{
return; return;
} }
rebuild(); rebuild();
} }
void WorkspaceIndicator::on_monitor_update() void WorkspaceIndicator::on_monitor_update() { rebuild(); }
{
rebuild();
}
void WorkspaceIndicator::rebuild() void WorkspaceIndicator::rebuild() {
{
clear_children(); clear_children();
HyprlandService::Monitor *monitor = nullptr; HyprlandService::Monitor *monitor = nullptr;
try try {
{ monitor = service.getMonitorById(monitorId);
monitor = m_service.getMonitorById(m_monitorId); } catch (const std::exception &) {
}
catch (const std::exception &)
{
return; return;
} }
if (monitor == nullptr) if (monitor == nullptr) {
{
return; return;
} }
for (int workspaceId = 1; workspaceId <= HyprlandService::kWorkspaceSlotCount; ++workspaceId) for (int workspaceId = 1;
{ workspaceId <= HyprlandService::kWorkspaceSlotCount; ++workspaceId) {
const HyprlandService::WorkspaceState *state = nullptr; const HyprlandService::WorkspaceState *state = nullptr;
auto it = monitor->workspaceStates.find(workspaceId); auto it = monitor->workspaceStates.find(workspaceId);
if (it != monitor->workspaceStates.end())
{ if (it != monitor->workspaceStates.end()) {
state = &it->second; state = &it->second;
} }
const std::string display = (state && !state->label.empty()) ? state->label : std::to_string(workspaceId); const std::string display = (state && !state->label.empty())
? state->label
: std::to_string(workspaceId);
auto label = Gtk::make_managed<Gtk::Label>(display); auto label = Gtk::make_managed<Gtk::Label>(display);
label->add_css_class("workspace-pill"); label->add_css_class("workspace-pill");
// Make the label clickable using a gesture click (primary button)
auto gesture = Gtk::GestureClick::create(); auto gesture = Gtk::GestureClick::create();
gesture->set_button(GDK_BUTTON_PRIMARY); gesture->set_button(GDK_BUTTON_PRIMARY);
// Use a lambda to capture the workspace slot id gesture->signal_released().connect(
gesture->signal_released().connect([this, workspaceId](int /*n_press*/, double /*x*/, double /*y*/) [this, workspaceId](int /*n_press*/, double /*x*/, double /*y*/) {
{ int realWorkspaceId = workspaceId + 5 * (monitorId);
try
{ service.switchToWorkspace(realWorkspaceId);
m_service.switchToWorkspace(m_monitorId, workspaceId); });
}
catch (const std::exception &ex)
{
std::cerr << "[WorkspaceIndicator] switchToWorkspace failed: " << ex.what() << std::endl;
}
});
label->add_controller(gesture); label->add_controller(gesture);
if (state != nullptr) if (state != nullptr) {
{ if (state->focused) {
if (state->focused)
{
label->add_css_class("workspace-pill-focused"); label->add_css_class("workspace-pill-focused");
} } else if (state->active) {
else if (state->active)
{
label->add_css_class("workspace-pill-active"); label->add_css_class("workspace-pill-active");
} }
if (state->urgent) if (state->urgent) {
{
label->add_css_class("workspace-pill-urgent"); label->add_css_class("workspace-pill-urgent");
} }
} }
append(*label); append(*label);
} }
} }
void WorkspaceIndicator::clear_children() void WorkspaceIndicator::clear_children() {
{
Gtk::Widget *child = get_first_child(); Gtk::Widget *child = get_first_child();
while (child != nullptr) while (child != nullptr) {
{
Gtk::Widget *next = child->get_next_sibling(); Gtk::Widget *next = child->get_next_sibling();
remove(*child); remove(*child);
child = next; child = next;