diff --git a/include/ALabel.hpp b/include/ALabel.hpp index f066f56..433d5a6 100644 --- a/include/ALabel.hpp +++ b/include/ALabel.hpp @@ -1,35 +1,35 @@ #pragma once -#include -#include "IModule.hpp" #include #include #include +#include +#include "IModule.hpp" namespace waybar { class ALabel : public IModule { -public: + public: ALabel(const Json::Value &, const std::string format, uint16_t interval = 0); virtual ~ALabel() = default; - virtual auto update() -> void; + virtual auto update() -> void; virtual std::string getIcon(uint16_t, const std::string &alt = ""); - virtual operator Gtk::Widget &(); + virtual operator Gtk::Widget &(); -protected: + protected: bool tooltipEnabled(); - Gtk::EventBox event_box_; - Gtk::Label label_; - const Json::Value &config_; - std::string format_; - std::mutex mutex_; + Gtk::EventBox event_box_; + Gtk::Label label_; + const Json::Value & config_; + std::string format_; + std::mutex mutex_; const std::chrono::seconds interval_; - bool alt_ = false; - std::string default_format_; + bool alt_ = false; + std::string default_format_; virtual bool handleToggle(GdkEventButton *const &ev); virtual bool handleScroll(GdkEventScroll *); }; -} // namespace waybar +} // namespace waybar diff --git a/include/IModule.hpp b/include/IModule.hpp index e278a1d..a9b2f17 100644 --- a/include/IModule.hpp +++ b/include/IModule.hpp @@ -7,11 +7,11 @@ namespace waybar { class IModule { - public: - virtual ~IModule() = default; - virtual auto update() -> void = 0; - virtual operator Gtk::Widget &() = 0; - Glib::Dispatcher dp; // Hmmm Maybe I should create an abstract class ? + public: + virtual ~IModule() = default; + virtual auto update() -> void = 0; + virtual operator Gtk::Widget &() = 0; + Glib::Dispatcher dp; // Hmmm Maybe I should create an abstract class ? }; -} +} // namespace waybar diff --git a/include/bar.hpp b/include/bar.hpp index bb48aeb..73de06b 100644 --- a/include/bar.hpp +++ b/include/bar.hpp @@ -1,73 +1,69 @@ #pragma once -#include #include -#include #include +#include #include +#include +#include "IModule.hpp" +#include "idle-inhibit-unstable-v1-client-protocol.h" #include "wlr-layer-shell-unstable-v1-client-protocol.h" #include "xdg-output-unstable-v1-client-protocol.h" -#include "idle-inhibit-unstable-v1-client-protocol.h" -#include "IModule.hpp" namespace waybar { -class Client; class Factory; - -class Bar { - public: - Bar(const Client&, std::unique_ptr&&, uint32_t); - Bar(const Bar&) = delete; - ~Bar() = default; - - auto toggle() -> void; - void handleSignal(int); - - const Client& client; - Gtk::Window window; - struct wl_surface *surface; - struct zwlr_layer_surface_v1 *layer_surface; - std::unique_ptr output; - std::string output_name; - uint32_t wl_name; - bool visible = true; - bool vertical = false; - private: - static void handleLogicalPosition(void *, struct zxdg_output_v1 *, int32_t, - int32_t); - static void handleLogicalSize(void *, struct zxdg_output_v1 *, int32_t, - int32_t); - static void handleDone(void *, struct zxdg_output_v1 *); - static void handleName(void *, struct zxdg_output_v1 *, const char *); - static void handleDescription(void *, struct zxdg_output_v1 *, - const char *); - static void layerSurfaceHandleConfigure(void *, - struct zwlr_layer_surface_v1 *, uint32_t, uint32_t, uint32_t); - static void layerSurfaceHandleClosed(void *, - struct zwlr_layer_surface_v1 *); - - void initBar(); - bool isValidOutput(const Json::Value &config); - void destroyOutput(); - auto setupConfig() -> void; - auto setupWidgets() -> void; - auto setupCss() -> void; - void getModules(const Factory&, const std::string&); - - uint32_t width_ = 0; - uint32_t height_ = 30; - Json::Value config_; - Glib::RefPtr style_context_; - Glib::RefPtr css_provider_; - struct zxdg_output_v1 *xdg_output_; - Gtk::Box left_; - Gtk::Box center_; - Gtk::Box right_; - Gtk::Box box_; - std::vector> modules_left_; - std::vector> modules_center_; - std::vector> modules_right_; +struct waybar_output { + struct wl_output * output; + std::string name; + uint32_t wl_name; + struct zxdg_output_v1 *xdg_output; + Json::Value config; }; -} +class Bar { + public: + Bar(struct waybar_output *w_output); + Bar(const Bar &) = delete; + ~Bar() = default; + + auto toggle() -> void; + void handleSignal(int); + + struct waybar_output * output; + Gtk::Window window; + struct wl_surface * surface; + struct zwlr_layer_surface_v1 *layer_surface; + bool visible = true; + bool vertical = false; + + private: + static inline const std::string MIN_HEIGHT_MSG = + "Requested height: {} exceeds the minimum height: {} required by the modules"; + static inline const std::string MIN_WIDTH_MSG = + "Requested width: {} exceeds the minimum width: {} required by the modules"; + static inline const std::string BAR_SIZE_MSG = + "Bar configured (width: {}, height: {}) for output: {}"; + static void layerSurfaceHandleConfigure(void *, struct zwlr_layer_surface_v1 *, uint32_t, + uint32_t, uint32_t); + static void layerSurfaceHandleClosed(void *, struct zwlr_layer_surface_v1 *); + + void destroyOutput(); + void onWindowRealize(); + auto setupWidgets() -> void; + void getModules(const Factory &, const std::string &); + void setupAltFormatKeyForModule(const std::string &module_name); + void setupAltFormatKeyForModuleList(const char *module_list_name); + + uint32_t width_ = 0; + uint32_t height_ = 30; + Gtk::Box left_; + Gtk::Box center_; + Gtk::Box right_; + Gtk::Box box_; + std::vector> modules_left_; + std::vector> modules_center_; + std::vector> modules_right_; +}; + +} // namespace waybar diff --git a/include/client.hpp b/include/client.hpp index 5f0e9e5..78eaf87 100644 --- a/include/client.hpp +++ b/include/client.hpp @@ -1,41 +1,54 @@ #pragma once -#include -#include #include #include -#include #include +#include +#include +#include #include "bar.hpp" namespace waybar { class Client { - public: - Client(int argc, char *argv[]); - int main(int argc, char *argv[]); + public: + static Client *inst(); + int main(int argc, char *argv[]); - Glib::RefPtr gtk_app; - std::string css_file; - std::string config_file; - Glib::RefPtr gdk_display; - struct wl_display *wl_display = nullptr; - struct wl_registry *registry = nullptr; - struct zwlr_layer_shell_v1 *layer_shell = nullptr; - struct zxdg_output_manager_v1 *xdg_output_manager = nullptr; - struct wl_seat *seat = nullptr; - struct zwp_idle_inhibit_manager_v1 *idle_inhibit_manager = nullptr; - std::vector> bars; + Glib::RefPtr gtk_app; + Glib::RefPtr gdk_display; + struct wl_display * wl_display = nullptr; + struct wl_registry * registry = nullptr; + struct zwlr_layer_shell_v1 * layer_shell = nullptr; + struct zxdg_output_manager_v1 * xdg_output_manager = nullptr; + struct zwp_idle_inhibit_manager_v1 *idle_inhibit_manager = nullptr; + std::vector> bars; - private: - void setupConfigs(const std::string& config, const std::string& style); - void bindInterfaces(); - const std::string getValidPath(std::vector paths); + private: + Client(); + void setupConfigs(const std::string &config, const std::string &style); + void bindInterfaces(); + const std::string getValidPath(std::vector paths); + void handleOutput(std::unique_ptr &output); + bool isValidOutput(const Json::Value &config, std::unique_ptr &output); + auto setupConfig() -> void; + auto setupCss() -> void; - static void handleGlobal(void *data, struct wl_registry *registry, - uint32_t name, const char *interface, uint32_t version); - static void handleGlobalRemove(void *data, - struct wl_registry *registry, uint32_t name); + static void handleGlobal(void *data, struct wl_registry *registry, uint32_t name, + const char *interface, uint32_t version); + static void handleGlobalRemove(void *data, struct wl_registry *registry, uint32_t name); + static void handleLogicalPosition(void *, struct zxdg_output_v1 *, int32_t, int32_t); + static void handleLogicalSize(void *, struct zxdg_output_v1 *, int32_t, int32_t); + static void handleDone(void *, struct zxdg_output_v1 *); + static void handleName(void *, struct zxdg_output_v1 *, const char *); + static void handleDescription(void *, struct zxdg_output_v1 *, const char *); + + Json::Value config_; + std::string css_file_; + std::string config_file_; + Glib::RefPtr style_context_; + Glib::RefPtr css_provider_; + std::vector> outputs_; }; -} +} // namespace waybar diff --git a/include/factory.hpp b/include/factory.hpp index 2f55046..fa41ef4 100644 --- a/include/factory.hpp +++ b/include/factory.hpp @@ -4,13 +4,13 @@ #include "modules/clock.hpp" #ifdef HAVE_SWAY #include "modules/sway/mode.hpp" -#include "modules/sway/workspaces.hpp" #include "modules/sway/window.hpp" +#include "modules/sway/workspaces.hpp" #endif -#include "modules/idle_inhibitor.hpp" #include "modules/battery.hpp" -#include "modules/memory.hpp" #include "modules/cpu.hpp" +#include "modules/idle_inhibitor.hpp" +#include "modules/memory.hpp" #ifdef HAVE_DBUSMENU #include "modules/sni/tray.hpp" #endif @@ -26,20 +26,20 @@ #ifdef HAVE_LIBMPDCLIENT #include "modules/mpd.hpp" #endif -#include "modules/temperature.hpp" +#include "bar.hpp" #include "modules/custom.hpp" +#include "modules/temperature.hpp" namespace waybar { -class Bar; - class Factory { - public: - Factory(const Bar& bar, const Json::Value& config); - IModule* makeModule(const std::string &name) const; - private: - const Bar& bar_; - const Json::Value& config_; + public: + Factory(const Bar& bar, const Json::Value& config); + IModule* makeModule(const std::string& name) const; + + private: + const Bar& bar_; + const Json::Value& config_; }; -} +} // namespace waybar diff --git a/include/modules/backlight.hpp b/include/modules/backlight.hpp index 80d2b1e..42e38f2 100644 --- a/include/modules/backlight.hpp +++ b/include/modules/backlight.hpp @@ -16,52 +16,47 @@ namespace waybar::modules { class Backlight : public ALabel { class BacklightDev { - public: + public: BacklightDev() = default; BacklightDev(std::string name, int actual, int max); - std::string_view name() const; - int get_actual() const; - void set_actual(int actual); - int get_max() const; - void set_max(int max); - friend inline bool operator==(const BacklightDev &lhs, - const BacklightDev &rhs) { - return lhs.name_ == rhs.name_ && lhs.actual_ == rhs.actual_ && - lhs.max_ == rhs.max_; + std::string_view name() const; + int get_actual() const; + void set_actual(int actual); + int get_max() const; + void set_max(int max); + friend inline bool operator==(const BacklightDev &lhs, const BacklightDev &rhs) { + return lhs.name_ == rhs.name_ && lhs.actual_ == rhs.actual_ && lhs.max_ == rhs.max_; } - private: + private: std::string name_; - int actual_ = 1; - int max_ = 1; + int actual_ = 1; + int max_ = 1; }; -public: + public: Backlight(const std::string &, const Json::Value &); ~Backlight(); auto update() -> void; -private: + private: template - static const BacklightDev *best_device(ForwardIt first, ForwardIt last, - std::string_view); + static const BacklightDev *best_device(ForwardIt first, ForwardIt last, std::string_view); template - static void upsert_device(ForwardIt first, ForwardIt last, Inserter inserter, - udev_device *dev); + static void upsert_device(ForwardIt first, ForwardIt last, Inserter inserter, udev_device *dev); template - static void enumerate_devices(ForwardIt first, ForwardIt last, - Inserter inserter, udev *udev); + static void enumerate_devices(ForwardIt first, ForwardIt last, Inserter inserter, udev *udev); - const std::string name_; - const std::string preferred_device_; + const std::string name_; + const std::string preferred_device_; static constexpr int EPOLL_MAX_EVENTS = 16; std::optional previous_best_; - std::string previous_format_; + std::string previous_format_; - std::mutex udev_thread_mutex_; + std::mutex udev_thread_mutex_; std::vector devices_; // thread must destruct before shared data waybar::util::SleeperThread udev_thread_; }; -} // namespace waybar::modules +} // namespace waybar::modules diff --git a/include/modules/battery.hpp b/include/modules/battery.hpp index f933a0c..4b39744 100644 --- a/include/modules/battery.hpp +++ b/include/modules/battery.hpp @@ -5,13 +5,13 @@ #else #include #endif -#include -#include #include #include #include -#include "util/sleeper_thread.hpp" +#include +#include #include "ALabel.hpp" +#include "util/sleeper_thread.hpp" namespace waybar::modules { @@ -22,26 +22,27 @@ namespace fs = std::filesystem; #endif class Battery : public ALabel { - public: - Battery(const std::string&, const Json::Value&); - ~Battery(); - auto update() -> void; - private: - static inline const fs::path data_dir_ = "/sys/class/power_supply/"; + public: + Battery(const std::string&, const Json::Value&); + ~Battery(); + auto update() -> void; - void getBatteries(); - void worker(); - const std::string getAdapterStatus(uint8_t capacity) const; - const std::tuple getInfos() const; - const std::string getState(uint8_t) const; + private: + static inline const fs::path data_dir_ = "/sys/class/power_supply/"; - util::SleeperThread thread_; - util::SleeperThread thread_timer_; - std::vector batteries_; - fs::path adapter_; - int fd_; - std::vector wds_; - std::string old_status_; + void getBatteries(); + void worker(); + const std::string getAdapterStatus(uint8_t capacity) const; + const std::tuple getInfos() const; + const std::string getState(uint8_t) const; + + util::SleeperThread thread_; + util::SleeperThread thread_timer_; + std::vector batteries_; + fs::path adapter_; + int fd_; + std::vector wds_; + std::string old_status_; }; -} +} // namespace waybar::modules diff --git a/include/modules/clock.hpp b/include/modules/clock.hpp index fe80dc5..a42b882 100644 --- a/include/modules/clock.hpp +++ b/include/modules/clock.hpp @@ -1,19 +1,20 @@ #pragma once #include +#include "ALabel.hpp" #include "fmt/time.h" #include "util/sleeper_thread.hpp" -#include "ALabel.hpp" namespace waybar::modules { class Clock : public ALabel { - public: - Clock(const std::string&, const Json::Value&); - ~Clock() = default; - auto update() -> void; - private: - waybar::util::SleeperThread thread_; + public: + Clock(const std::string&, const Json::Value&); + ~Clock() = default; + auto update() -> void; + + private: + waybar::util::SleeperThread thread_; }; -} +} // namespace waybar::modules diff --git a/include/modules/cpu.hpp b/include/modules/cpu.hpp index 467b11f..5c17d3a 100644 --- a/include/modules/cpu.hpp +++ b/include/modules/cpu.hpp @@ -3,27 +3,28 @@ #include #include #include -#include -#include #include -#include "util/sleeper_thread.hpp" +#include +#include #include "ALabel.hpp" +#include "util/sleeper_thread.hpp" namespace waybar::modules { class Cpu : public ALabel { - public: - Cpu(const std::string&, const Json::Value&); - ~Cpu() = default; - auto update() -> void; - private: - static inline const std::string data_dir_ = "/proc/stat"; - uint16_t getCpuLoad(); - std::tuple getCpuUsage(); - std::vector> parseCpuinfo(); + public: + Cpu(const std::string&, const Json::Value&); + ~Cpu() = default; + auto update() -> void; - std::vector> prev_times_; - waybar::util::SleeperThread thread_; + private: + static inline const std::string data_dir_ = "/proc/stat"; + uint16_t getCpuLoad(); + std::tuple getCpuUsage(); + std::vector> parseCpuinfo(); + + std::vector> prev_times_; + waybar::util::SleeperThread thread_; }; -} +} // namespace waybar::modules diff --git a/include/modules/custom.hpp b/include/modules/custom.hpp index 5eab56b..7f4c50d 100644 --- a/include/modules/custom.hpp +++ b/include/modules/custom.hpp @@ -1,37 +1,38 @@ #pragma once #include -#include #include -#include "util/sleeper_thread.hpp" +#include +#include "ALabel.hpp" #include "util/command.hpp" #include "util/json.hpp" -#include "ALabel.hpp" +#include "util/sleeper_thread.hpp" namespace waybar::modules { class Custom : public ALabel { - public: - Custom(const std::string&, const Json::Value&); - ~Custom(); - auto update() -> void; - void refresh(int /*signal*/); - private: - void delayWorker(); - void continuousWorker(); - void parseOutputRaw(); - void parseOutputJson(); + public: + Custom(const std::string&, const Json::Value&); + ~Custom(); + auto update() -> void; + void refresh(int /*signal*/); - const std::string name_; - std::string text_; - std::string alt_; - std::string tooltip_; - std::vector class_; - int percentage_; - waybar::util::SleeperThread thread_; - waybar::util::command::res output_; - waybar::util::JsonParser parser_; - FILE* fp_; + private: + void delayWorker(); + void continuousWorker(); + void parseOutputRaw(); + void parseOutputJson(); + + const std::string name_; + std::string text_; + std::string alt_; + std::string tooltip_; + std::vector class_; + int percentage_; + waybar::util::SleeperThread thread_; + waybar::util::command::res output_; + waybar::util::JsonParser parser_; + FILE* fp_; }; -} +} // namespace waybar::modules diff --git a/include/modules/idle_inhibitor.hpp b/include/modules/idle_inhibitor.hpp index 76f54d3..83b13e6 100644 --- a/include/modules/idle_inhibitor.hpp +++ b/include/modules/idle_inhibitor.hpp @@ -1,23 +1,24 @@ #pragma once #include +#include "ALabel.hpp" #include "bar.hpp" #include "client.hpp" -#include "ALabel.hpp" namespace waybar::modules { -class IdleInhibitor: public ALabel { - public: - IdleInhibitor(const std::string&, const waybar::Bar&, const Json::Value&); - ~IdleInhibitor(); - auto update() -> void; - private: - bool handleToggle(GdkEventButton* const& e); +class IdleInhibitor : public ALabel { + public: + IdleInhibitor(const std::string&, const waybar::Bar&, const Json::Value&); + ~IdleInhibitor(); + auto update() -> void; - const Bar& bar_; - std::string status_; - struct zwp_idle_inhibitor_v1 *idle_inhibitor_; + private: + bool handleToggle(GdkEventButton* const& e); + + const Bar& bar_; + std::string status_; + struct zwp_idle_inhibitor_v1* idle_inhibitor_; }; -} +} // namespace waybar::modules diff --git a/include/modules/memory.hpp b/include/modules/memory.hpp index 1b21e8a..c2d157d 100644 --- a/include/modules/memory.hpp +++ b/include/modules/memory.hpp @@ -2,22 +2,23 @@ #include #include -#include "util/sleeper_thread.hpp" #include "ALabel.hpp" +#include "util/sleeper_thread.hpp" namespace waybar::modules { class Memory : public ALabel { - public: - Memory(const std::string&, const Json::Value&); - ~Memory() = default; - auto update() -> void; - private: - static inline const std::string data_dir_ = "/proc/meminfo"; - unsigned long memtotal_; - unsigned long memfree_; - void parseMeminfo(); - waybar::util::SleeperThread thread_; + public: + Memory(const std::string&, const Json::Value&); + ~Memory() = default; + auto update() -> void; + + private: + static inline const std::string data_dir_ = "/proc/meminfo"; + unsigned long memtotal_; + unsigned long memfree_; + void parseMeminfo(); + waybar::util::SleeperThread thread_; }; -} +} // namespace waybar::modules diff --git a/include/modules/network.hpp b/include/modules/network.hpp index 90805cb..ade3bb2 100644 --- a/include/modules/network.hpp +++ b/include/modules/network.hpp @@ -1,62 +1,63 @@ #pragma once -#include #include -#include -#include -#include -#include -#include -#include #include -#include "util/sleeper_thread.hpp" +#include +#include +#include +#include +#include +#include +#include #include "ALabel.hpp" +#include "util/sleeper_thread.hpp" namespace waybar::modules { class Network : public ALabel { - public: - Network(const std::string&, const Json::Value&); - ~Network(); - auto update() -> void; - private: - static const uint8_t MAX_RETRY = 5; - static const uint8_t EPOLL_MAX = 255; + public: + Network(const std::string&, const Json::Value&); + ~Network(); + auto update() -> void; - static int handleEvents(struct nl_msg*, void*); - static int handleScan(struct nl_msg*, void*); + private: + static const uint8_t MAX_RETRY = 5; + static const uint8_t EPOLL_MAX = 200; - void worker(); - void disconnected(); - void createInfoSocket(); - void createEventSocket(); - int getExternalInterface(); - void getInterfaceAddress(); - int netlinkRequest(void*, uint32_t, uint32_t groups = 0); - int netlinkResponse(void*, uint32_t, uint32_t groups = 0); - void parseEssid(struct nlattr**); - void parseSignal(struct nlattr**); - bool associatedOrJoined(struct nlattr**); - auto getInfo() -> void; + static int handleEvents(struct nl_msg*, void*); + static int handleScan(struct nl_msg*, void*); - waybar::util::SleeperThread thread_; - waybar::util::SleeperThread thread_timer_; - int ifid_; - sa_family_t family_; - struct sockaddr_nl nladdr_ = {0}; - struct nl_sock* sk_ = nullptr; - struct nl_sock* info_sock_ = nullptr; - int efd_; - int ev_fd_; - int nl80211_id_; + void worker(); + void disconnected(); + void createInfoSocket(); + void createEventSocket(); + int getExternalInterface(); + void getInterfaceAddress(); + int netlinkRequest(void*, uint32_t, uint32_t groups = 0); + int netlinkResponse(void*, uint32_t, uint32_t groups = 0); + void parseEssid(struct nlattr**); + void parseSignal(struct nlattr**); + bool associatedOrJoined(struct nlattr**); + auto getInfo() -> void; - std::string essid_; - std::string ifname_; - std::string ipaddr_; - std::string netmask_; - int cidr_; - int32_t signal_strength_dbm_; - uint8_t signal_strength_; + waybar::util::SleeperThread thread_; + waybar::util::SleeperThread thread_timer_; + int ifid_; + sa_family_t family_; + struct sockaddr_nl nladdr_ = {0}; + struct nl_sock* sk_ = nullptr; + struct nl_sock* info_sock_ = nullptr; + int efd_; + int ev_fd_; + int nl80211_id_; + + std::string essid_; + std::string ifname_; + std::string ipaddr_; + std::string netmask_; + int cidr_; + int32_t signal_strength_dbm_; + uint8_t signal_strength_; }; -} +} // namespace waybar::modules diff --git a/include/modules/pulseaudio.hpp b/include/modules/pulseaudio.hpp index 4864533..b16118c 100644 --- a/include/modules/pulseaudio.hpp +++ b/include/modules/pulseaudio.hpp @@ -9,31 +9,31 @@ namespace waybar::modules { class Pulseaudio : public ALabel { - public: - Pulseaudio(const std::string&, const Json::Value&); - ~Pulseaudio(); - auto update() -> void; - private: - static void subscribeCb(pa_context*, pa_subscription_event_type_t, - uint32_t, void*); - static void contextStateCb(pa_context*, void*); - static void sinkInfoCb(pa_context*, const pa_sink_info*, int, void*); - static void serverInfoCb(pa_context*, const pa_server_info*, void*); - static void volumeModifyCb(pa_context*, int, void*); - bool handleScroll(GdkEventScroll* e); + public: + Pulseaudio(const std::string&, const Json::Value&); + ~Pulseaudio(); + auto update() -> void; - const std::string getPortIcon() const; + private: + static void subscribeCb(pa_context*, pa_subscription_event_type_t, uint32_t, void*); + static void contextStateCb(pa_context*, void*); + static void sinkInfoCb(pa_context*, const pa_sink_info*, int, void*); + static void serverInfoCb(pa_context*, const pa_server_info*, void*); + static void volumeModifyCb(pa_context*, int, void*); + bool handleScroll(GdkEventScroll* e); - pa_threaded_mainloop* mainloop_; - pa_mainloop_api* mainloop_api_; - pa_context* context_; - uint32_t sink_idx_{0}; - uint16_t volume_; - pa_cvolume pa_volume_; - bool muted_; - std::string port_name_; - std::string desc_; - bool scrolling_; + const std::string getPortIcon() const; + + pa_threaded_mainloop* mainloop_; + pa_mainloop_api* mainloop_api_; + pa_context* context_; + uint32_t sink_idx_{0}; + uint16_t volume_; + pa_cvolume pa_volume_; + bool muted_; + std::string port_name_; + std::string desc_; + bool scrolling_; }; } // namespace waybar::modules diff --git a/include/modules/sni/host.hpp b/include/modules/sni/host.hpp index 54829a6..f97900f 100644 --- a/include/modules/sni/host.hpp +++ b/include/modules/sni/host.hpp @@ -16,26 +16,26 @@ class Host { ~Host(); private: - void busAcquired(const Glib::RefPtr&, Glib::ustring); - void nameAppeared(const Glib::RefPtr&, Glib::ustring, - const Glib::ustring&); - void nameVanished(const Glib::RefPtr&, Glib::ustring); + void busAcquired(const Glib::RefPtr&, Glib::ustring); + void nameAppeared(const Glib::RefPtr&, Glib::ustring, + const Glib::ustring&); + void nameVanished(const Glib::RefPtr&, Glib::ustring); static void proxyReady(GObject*, GAsyncResult*, gpointer); static void registerHost(GObject*, GAsyncResult*, gpointer); static void itemRegistered(SnWatcher*, const gchar*, gpointer); static void itemUnregistered(SnWatcher*, const gchar*, gpointer); std::tuple getBusNameAndObjectPath(const std::string); - void addRegisteredItem(std::string service); + void addRegisteredItem(std::string service); - std::vector> items_; - const std::string bus_name_; - const std::string object_path_; - std::size_t bus_name_id_; - std::size_t watcher_id_; - GCancellable* cancellable_ = nullptr; - SnWatcher* watcher_ = nullptr; - const Json::Value& config_; + std::vector> items_; + const std::string bus_name_; + const std::string object_path_; + std::size_t bus_name_id_; + std::size_t watcher_id_; + GCancellable* cancellable_ = nullptr; + SnWatcher* watcher_ = nullptr; + const Json::Value& config_; const std::function&)> on_add_; const std::function&)> on_remove_; }; diff --git a/include/modules/sni/item.hpp b/include/modules/sni/item.hpp index ac0c38a..2da7776 100644 --- a/include/modules/sni/item.hpp +++ b/include/modules/sni/item.hpp @@ -26,27 +26,27 @@ class Item : public sigc::trackable { std::string bus_name; std::string object_path; - int icon_size; - int effective_icon_size; - Gtk::Image image; + int icon_size; + int effective_icon_size; + Gtk::Image image; Gtk::EventBox event_box; - std::string category; - std::string id; - std::string status; + std::string category; + std::string id; + std::string status; - std::string title; - int32_t window_id; - std::string icon_name; - Glib::RefPtr icon_pixmap; + std::string title; + int32_t window_id; + std::string icon_name; + Glib::RefPtr icon_pixmap; Glib::RefPtr icon_theme; - std::string overlay_icon_name; - std::string attention_icon_name; - std::string attention_movie_name; - std::string icon_theme_path; - std::string menu; - DbusmenuGtkMenu* dbus_menu = nullptr; - Gtk::Menu* gtk_menu = nullptr; - bool item_is_menu; + std::string overlay_icon_name; + std::string attention_icon_name; + std::string attention_movie_name; + std::string icon_theme_path; + std::string menu; + DbusmenuGtkMenu* dbus_menu = nullptr; + Gtk::Menu* gtk_menu = nullptr; + bool item_is_menu; private: void proxyReady(Glib::RefPtr& result); @@ -56,16 +56,16 @@ class Item : public sigc::trackable { void onSignal(const Glib::ustring& sender_name, const Glib::ustring& signal_name, const Glib::VariantContainerBase& arguments); - void updateImage(); + void updateImage(); Glib::RefPtr extractPixBuf(GVariant* variant); Glib::RefPtr getIconByName(std::string name, int size); - static void onMenuDestroyed(Item* self); - bool makeMenu(GdkEventButton* const& ev); - bool handleClick(GdkEventButton* const& /*ev*/); + static void onMenuDestroyed(Item* self); + bool makeMenu(GdkEventButton* const& ev); + bool handleClick(GdkEventButton* const& /*ev*/); Glib::RefPtr cancellable_; Glib::RefPtr proxy_; - bool update_pending_; + bool update_pending_; }; } // namespace waybar::modules::SNI diff --git a/include/modules/sni/tray.hpp b/include/modules/sni/tray.hpp index 01ed4d5..dd092c9 100644 --- a/include/modules/sni/tray.hpp +++ b/include/modules/sni/tray.hpp @@ -14,17 +14,17 @@ class Tray : public IModule { Tray(const std::string&, const Bar&, const Json::Value&); ~Tray() = default; auto update() -> void; - operator Gtk::Widget&(); + operator Gtk::Widget&(); private: void onAdd(std::unique_ptr& item); void onRemove(std::unique_ptr& item); static inline std::size_t nb_hosts_ = 0; - const Json::Value& config_; - Gtk::Box box_; - SNI::Watcher watcher_; - SNI::Host host_; + const Json::Value& config_; + Gtk::Box box_; + SNI::Watcher watcher_; + SNI::Host host_; }; } // namespace waybar::modules::SNI diff --git a/include/modules/sni/watcher.hpp b/include/modules/sni/watcher.hpp index 7387860..30a2115 100644 --- a/include/modules/sni/watcher.hpp +++ b/include/modules/sni/watcher.hpp @@ -16,30 +16,28 @@ class Watcher { typedef struct { GfWatchType type; - Watcher *watcher; - gchar *service; - gchar *bus_name; - gchar *object_path; - guint watch_id; + Watcher * watcher; + gchar * service; + gchar * bus_name; + gchar * object_path; + guint watch_id; } GfWatch; - void busAcquired(const Glib::RefPtr &, Glib::ustring); + void busAcquired(const Glib::RefPtr &, Glib::ustring); static gboolean handleRegisterHost(Watcher *, GDBusMethodInvocation *, const gchar *); static gboolean handleRegisterItem(Watcher *, GDBusMethodInvocation *, const gchar *); static GfWatch *gfWatchFind(GSList *list, const gchar *bus_name, const gchar *object_path); static GfWatch *gfWatchNew(GfWatchType, const gchar *, const gchar *, const gchar *, Watcher *); - static void nameVanished(GDBusConnection *connection, const char *name, gpointer data); - static void gfWatchFree(gpointer data); + static void nameVanished(GDBusConnection *connection, const char *name, gpointer data); + static void gfWatchFree(gpointer data); void updateRegisteredItems(SnWatcher *obj); - uint32_t bus_name_id_; - uint32_t watcher_id_; - GSList *hosts_ = nullptr; - GSList *items_ = nullptr; + uint32_t bus_name_id_; + uint32_t watcher_id_; + GSList * hosts_ = nullptr; + GSList * items_ = nullptr; SnWatcher *watcher_ = nullptr; - gulong handler_item_id_; - gulong handler_host_id_; }; } // namespace waybar::modules::SNI diff --git a/include/modules/sway/ipc/client.hpp b/include/modules/sway/ipc/client.hpp index 3dbbc0f..1d149cb 100644 --- a/include/modules/sway/ipc/client.hpp +++ b/include/modules/sway/ipc/client.hpp @@ -1,40 +1,47 @@ #pragma once -#include -#include -#include +#include #include #include +#include +#include +#include +#include #include "ipc.hpp" namespace waybar::modules::sway { class Ipc { -public: + public: Ipc(); ~Ipc(); struct ipc_response { - uint32_t size; - uint32_t type; + uint32_t size; + uint32_t type; std::string payload; }; - struct ipc_response sendCmd(uint32_t type, const std::string &payload = "") const; - void subscribe(const std::string &payload) const; - struct ipc_response handleEvent() const; + sigc::signal signal_event; + sigc::signal signal_cmd; -protected: + void sendCmd(uint32_t type, const std::string &payload = ""); + void subscribe(const std::string &payload); + void handleEvent(); + + protected: static inline const std::string ipc_magic_ = "i3-ipc"; - static inline const size_t ipc_header_size_ = ipc_magic_.size() + 8; + static inline const size_t ipc_header_size_ = ipc_magic_.size() + 8; - const std::string getSocketPath() const; - int open(const std::string &) const; - struct ipc_response send(int fd, uint32_t type, const std::string &payload = "") const; - struct ipc_response recv(int fd) const; + const std::string getSocketPath() const; + int open(const std::string &) const; + struct ipc_response send(int fd, uint32_t type, const std::string &payload = ""); + struct ipc_response recv(int fd); - int fd_; - int fd_event_; + int fd_; + int fd_event_; + std::mutex mutex_; + std::mutex mutex_event_; }; -} // namespace waybar::modules::sway +} // namespace waybar::modules::sway diff --git a/include/modules/sway/mode.hpp b/include/modules/sway/mode.hpp index 326342c..89c9a8b 100644 --- a/include/modules/sway/mode.hpp +++ b/include/modules/sway/mode.hpp @@ -1,28 +1,30 @@ #pragma once #include +#include "ALabel.hpp" #include "bar.hpp" #include "client.hpp" -#include "util/sleeper_thread.hpp" -#include "util/json.hpp" -#include "ALabel.hpp" #include "modules/sway/ipc/client.hpp" +#include "util/json.hpp" +#include "util/sleeper_thread.hpp" namespace waybar::modules::sway { class Mode : public ALabel { - public: - Mode(const std::string&, const waybar::Bar&, const Json::Value&); - ~Mode() = default; - auto update() -> void; - private: - void worker(); - - const Bar& bar_; - waybar::util::SleeperThread thread_; - util::JsonParser parser_; - Ipc ipc_; - std::string mode_; + public: + Mode(const std::string&, const waybar::Bar&, const Json::Value&); + ~Mode() = default; + auto update() -> void; + + private: + void onEvent(const struct Ipc::ipc_response); + void worker(); + + const Bar& bar_; + waybar::util::SleeperThread thread_; + util::JsonParser parser_; + Ipc ipc_; + std::string mode_; }; -} \ No newline at end of file +} // namespace waybar::modules::sway \ No newline at end of file diff --git a/include/modules/sway/window.hpp b/include/modules/sway/window.hpp index d89d066..aaeb2d3 100644 --- a/include/modules/sway/window.hpp +++ b/include/modules/sway/window.hpp @@ -2,31 +2,34 @@ #include #include +#include "ALabel.hpp" #include "bar.hpp" #include "client.hpp" -#include "util/sleeper_thread.hpp" -#include "util/json.hpp" -#include "ALabel.hpp" #include "modules/sway/ipc/client.hpp" +#include "util/json.hpp" +#include "util/sleeper_thread.hpp" namespace waybar::modules::sway { class Window : public ALabel { - public: - Window(const std::string&, const waybar::Bar&, const Json::Value&); - ~Window() = default; - auto update() -> void; - private: - void worker(); - std::tuple getFocusedNode(Json::Value nodes); - void getFocusedWindow(); + public: + Window(const std::string&, const waybar::Bar&, const Json::Value&); + ~Window() = default; + auto update() -> void; - const Bar& bar_; - waybar::util::SleeperThread thread_; - util::JsonParser parser_; - Ipc ipc_; - std::string window_; - int windowId_; + private: + void onEvent(const struct Ipc::ipc_response); + void onCmd(const struct Ipc::ipc_response); + void worker(); + std::tuple getFocusedNode(Json::Value nodes); + void getFocusedWindow(); + + const Bar& bar_; + waybar::util::SleeperThread thread_; + util::JsonParser parser_; + Ipc ipc_; + std::string window_; + int windowId_; }; -} +} // namespace waybar::modules::sway diff --git a/include/modules/sway/workspaces.hpp b/include/modules/sway/workspaces.hpp index 2884efd..187e5cb 100644 --- a/include/modules/sway/workspaces.hpp +++ b/include/modules/sway/workspaces.hpp @@ -1,43 +1,46 @@ #pragma once #include -#include "bar.hpp" -#include "client.hpp" -#include "util/sleeper_thread.hpp" -#include "util/json.hpp" -#include "IModule.hpp" -#include "modules/sway/ipc/client.hpp" #include #include +#include "IModule.hpp" +#include "bar.hpp" +#include "client.hpp" +#include "modules/sway/ipc/client.hpp" +#include "util/json.hpp" +#include "util/sleeper_thread.hpp" namespace waybar::modules::sway { class Workspaces : public IModule { - public: - Workspaces(const std::string&, const waybar::Bar&, const Json::Value&); - ~Workspaces() = default; - auto update() -> void; - operator Gtk::Widget &(); - private: - void worker(); - void addWorkspace(const Json::Value&); - void onButtonReady(const Json::Value&, Gtk::Button&); - std::string getIcon(const std::string&, const Json::Value&); - bool handleScroll(GdkEventScroll*); - const std::string getCycleWorkspace(uint8_t current, bool prev) const; - uint16_t getWorkspaceIndex(const std::string &name) const; - std::string trimWorkspaceName(std::string); + public: + Workspaces(const std::string&, const waybar::Bar&, const Json::Value&); + ~Workspaces() = default; + auto update() -> void; + operator Gtk::Widget&(); - const Bar& bar_; - const Json::Value& config_; - Json::Value workspaces_; - waybar::util::SleeperThread thread_; - Gtk::Box box_; - util::JsonParser parser_; - Ipc ipc_; - std::mutex mutex_; - bool scrolling_; - std::unordered_map buttons_; + private: + void onCmd(const struct Ipc::ipc_response); + void onEvent(const struct Ipc::ipc_response); + void worker(); + bool filterButtons(); + Gtk::Button& addButton(const Json::Value&); + void onButtonReady(const Json::Value&, Gtk::Button&); + std::string getIcon(const std::string&, const Json::Value&); + bool handleScroll(GdkEventScroll*); + const std::string getCycleWorkspace(std::vector::iterator, bool prev) const; + uint16_t getWorkspaceIndex(const std::string& name) const; + std::string trimWorkspaceName(std::string); + + const Bar& bar_; + const Json::Value& config_; + std::vector workspaces_; + waybar::util::SleeperThread thread_; + Gtk::Box box_; + util::JsonParser parser_; + Ipc ipc_; + bool scrolling_; + std::unordered_map buttons_; }; -} +} // namespace waybar::modules::sway diff --git a/include/modules/temperature.hpp b/include/modules/temperature.hpp index 13ec097..4941003 100644 --- a/include/modules/temperature.hpp +++ b/include/modules/temperature.hpp @@ -2,8 +2,8 @@ #include #include -#include "util/sleeper_thread.hpp" #include "ALabel.hpp" +#include "util/sleeper_thread.hpp" #ifdef FILESYSTEM_EXPERIMENTAL #include #else @@ -13,16 +13,17 @@ namespace waybar::modules { class Temperature : public ALabel { - public: - Temperature(const std::string&, const Json::Value&); - ~Temperature() = default; - auto update() -> void; - private: - std::tuple getTemperature(); - bool isCritical(uint16_t); + public: + Temperature(const std::string&, const Json::Value&); + ~Temperature() = default; + auto update() -> void; - std::string file_path_; - waybar::util::SleeperThread thread_; + private: + std::tuple getTemperature(); + bool isCritical(uint16_t); + + std::string file_path_; + waybar::util::SleeperThread thread_; }; -} \ No newline at end of file +} // namespace waybar::modules \ No newline at end of file diff --git a/include/util/command.hpp b/include/util/command.hpp index 02468b8..873c775 100644 --- a/include/util/command.hpp +++ b/include/util/command.hpp @@ -1,25 +1,24 @@ #pragma once -#include #include +#include #include namespace waybar::util::command { struct res { - int exit_code; + int exit_code; std::string out; }; -inline struct res exec(const std::string cmd) -{ +inline struct res exec(const std::string cmd) { FILE* fp(popen(cmd.c_str(), "r")); if (!fp) { - return { -1, "" }; + return {-1, ""}; } std::array buffer = {0}; - std::string output; + std::string output; while (feof(fp) == 0) { if (fgets(buffer.data(), 128, fp) != nullptr) { output += buffer.data(); @@ -27,8 +26,8 @@ inline struct res exec(const std::string cmd) } // Remove last newline - if (!output.empty() && output[output.length()-1] == '\n') { - output.erase(output.length()-1); + if (!output.empty() && output[output.length() - 1] == '\n') { + output.erase(output.length() - 1); } int exit_code = WEXITSTATUS(pclose(fp)); return {exit_code, output}; diff --git a/include/util/json.hpp b/include/util/json.hpp index 7671fa1..cc0d86c 100644 --- a/include/util/json.hpp +++ b/include/util/json.hpp @@ -5,27 +5,24 @@ namespace waybar::util { struct JsonParser { + JsonParser() : reader_(builder_.newCharReader()) {} - JsonParser() - : reader_(builder_.newCharReader()) - {} - - const Json::Value parse(const std::string& data) const - { + const Json::Value parse(const std::string& data) const { Json::Value root; std::string err; - bool res = - reader_->parse(data.c_str(), data.c_str() + data.size(), &root, &err); - if (!res) - throw std::runtime_error(err); + if (data.empty()) { + return root; + } + bool res = reader_->parse(data.c_str(), data.c_str() + data.size(), &root, &err); + if (!res) throw std::runtime_error(err); return root; } ~JsonParser() = default; -private: - Json::CharReaderBuilder builder_; + private: + Json::CharReaderBuilder builder_; std::unique_ptr const reader_; }; -} +} // namespace waybar::util diff --git a/include/util/sleeper_thread.hpp b/include/util/sleeper_thread.hpp index eacd9a3..90ef9d8 100644 --- a/include/util/sleeper_thread.hpp +++ b/include/util/sleeper_thread.hpp @@ -1,25 +1,23 @@ #pragma once #include +#include #include #include -#include #include namespace waybar::util { class SleeperThread { -public: + public: SleeperThread() = default; SleeperThread(std::function func) - : thread_{[this, func] { - while (do_run_) func(); - }} - {} + : thread_{[this, func] { + while (do_run_) func(); + }} {} - SleeperThread& operator=(std::function func) - { + SleeperThread& operator=(std::function func) { thread_ = std::thread([this, func] { while (do_run_) { signal_ = false; @@ -29,32 +27,26 @@ public: return *this; } - bool isRunning() const - { - return do_run_; - } + bool isRunning() const { return do_run_; } - auto sleep_for(std::chrono::system_clock::duration dur) - { + auto sleep_for(std::chrono::system_clock::duration dur) { std::unique_lock lk(mutex_); return condvar_.wait_for(lk, dur, [this] { return signal_ || !do_run_; }); } - auto sleep_until(std::chrono::time_point time_point) - { + auto sleep_until( + std::chrono::time_point + time_point) { std::unique_lock lk(mutex_); return condvar_.wait_until(lk, time_point, [this] { return signal_ || !do_run_; }); } - auto wake_up() - { + auto wake_up() { signal_ = true; condvar_.notify_all(); } - auto stop() - { + auto stop() { { std::lock_guard lck(mutex_); signal_ = true; @@ -63,20 +55,19 @@ public: condvar_.notify_all(); } - ~SleeperThread() - { + ~SleeperThread() { stop(); if (thread_.joinable()) { thread_.join(); } } -private: - std::thread thread_; + private: + std::thread thread_; std::condition_variable condvar_; - std::mutex mutex_; - bool do_run_ = true; - bool signal_ = false; + std::mutex mutex_; + bool do_run_ = true; + bool signal_ = false; }; -} +} // namespace waybar::util diff --git a/src/ALabel.cpp b/src/ALabel.cpp index 54b561e..a2e711c 100644 --- a/src/ALabel.cpp +++ b/src/ALabel.cpp @@ -4,33 +4,31 @@ #include waybar::ALabel::ALabel(const Json::Value& config, const std::string format, uint16_t interval) - : config_(config), - format_(config_["format"].isString() ? config_["format"].asString() : format), - interval_(config_["interval"] == "once" ? std::chrono::seconds(100000000) : - std::chrono::seconds(config_["interval"].isUInt() ? - config_["interval"].asUInt() : interval)), default_format_(format_) -{ + : config_(config), + format_(config_["format"].isString() ? config_["format"].asString() : format), + interval_(config_["interval"] == "once" + ? std::chrono::seconds(100000000) + : std::chrono::seconds( + config_["interval"].isUInt() ? config_["interval"].asUInt() : interval)), + default_format_(format_) { event_box_.add(label_); - if (config_["max-length"].isUInt()) { + if (config_["max-length"].isUInt()) { label_.set_max_width_chars(config_["max-length"].asUInt()); label_.set_ellipsize(Pango::EllipsizeMode::ELLIPSIZE_END); } if (config_["format-alt"].isString()) { event_box_.add_events(Gdk::BUTTON_PRESS_MASK); - event_box_.signal_button_press_event().connect( - sigc::mem_fun(*this, &ALabel::handleToggle)); + event_box_.signal_button_press_event().connect(sigc::mem_fun(*this, &ALabel::handleToggle)); } // configure events' user commands if (config_["on-click"].isString() || config_["on-click-right"].isString()) { event_box_.add_events(Gdk::BUTTON_PRESS_MASK); - event_box_.signal_button_press_event().connect( - sigc::mem_fun(*this, &ALabel::handleToggle)); + event_box_.signal_button_press_event().connect(sigc::mem_fun(*this, &ALabel::handleToggle)); } if (config_["on-scroll-up"].isString() || config_["on-scroll-down"].isString()) { event_box_.add_events(Gdk::SCROLL_MASK | Gdk::SMOOTH_SCROLL_MASK); - event_box_.signal_scroll_event().connect( - sigc::mem_fun(*this, &ALabel::handleScroll)); + event_box_.signal_scroll_event().connect(sigc::mem_fun(*this, &ALabel::handleScroll)); } } @@ -49,8 +47,6 @@ bool waybar::ALabel::handleToggle(GdkEventButton* const& e) { waybar::util::command::forkExec(config_["on-click-backward"].asString()); } else if (config_["on-click-backward"].isString() && e->button == 9) { waybar::util::command::forkExec(config_["on-click-forward"].asString()); - - } if (config_["format-alt-click"].isUInt() && e->button == config_["format-alt-click"].asUInt()) { alt_ = !alt_; @@ -66,10 +62,9 @@ bool waybar::ALabel::handleToggle(GdkEventButton* const& e) { } bool waybar::ALabel::handleScroll(GdkEventScroll* e) { - // Avoid concurrent scroll event std::lock_guard lock(mutex_); - bool direction_up = false; + bool direction_up = false; if (e->direction == GDK_SCROLL_UP) { direction_up = true; @@ -79,8 +74,7 @@ bool waybar::ALabel::handleScroll(GdkEventScroll* e) { } if (e->direction == GDK_SCROLL_SMOOTH) { gdouble delta_x, delta_y; - gdk_event_get_scroll_deltas(reinterpret_cast(e), - &delta_x, &delta_y); + gdk_event_get_scroll_deltas(reinterpret_cast(e), &delta_x, &delta_y); if (delta_y < 0) { direction_up = true; } else if (delta_y > 0) { @@ -96,8 +90,7 @@ bool waybar::ALabel::handleScroll(GdkEventScroll* e) { return true; } -std::string waybar::ALabel::getIcon(uint16_t percentage, const std::string& alt) -{ +std::string waybar::ALabel::getIcon(uint16_t percentage, const std::string& alt) { auto format_icons = config_["format-icons"]; if (format_icons.isObject()) { if (!alt.empty() && (format_icons[alt].isString() || format_icons[alt].isArray())) { @@ -117,8 +110,7 @@ std::string waybar::ALabel::getIcon(uint16_t percentage, const std::string& alt) return ""; } -bool waybar::ALabel::tooltipEnabled() -{ +bool waybar::ALabel::tooltipEnabled() { return config_["tooltip"].isBool() ? config_["tooltip"].asBool() : true; } diff --git a/src/bar.cpp b/src/bar.cpp index 4183547..a718a79 100644 --- a/src/bar.cpp +++ b/src/bar.cpp @@ -1,32 +1,25 @@ #include "bar.hpp" #include "client.hpp" #include "factory.hpp" -#include "util/json.hpp" -waybar::Bar::Bar(const Client& client, - std::unique_ptr &&p_output, uint32_t p_wl_name) - : client(client), window{Gtk::WindowType::WINDOW_TOPLEVEL}, - surface(nullptr), layer_surface(nullptr), - output(std::move(p_output)), wl_name(p_wl_name), - left_(Gtk::ORIENTATION_HORIZONTAL, 0), center_(Gtk::ORIENTATION_HORIZONTAL, 0), - right_(Gtk::ORIENTATION_HORIZONTAL, 0), box_(Gtk::ORIENTATION_HORIZONTAL, 0) -{ - static const struct zxdg_output_v1_listener xdgOutputListener = { - .logical_position = handleLogicalPosition, - .logical_size = handleLogicalSize, - .done = handleDone, - .name = handleName, - .description = handleDescription, - }; - xdg_output_ = - zxdg_output_manager_v1_get_xdg_output(client.xdg_output_manager, *output); - zxdg_output_v1_add_listener(xdg_output_, &xdgOutputListener, this); +waybar::Bar::Bar(struct waybar_output* w_output) + : output(w_output), + window{Gtk::WindowType::WINDOW_TOPLEVEL}, + surface(nullptr), + layer_surface(nullptr), + left_(Gtk::ORIENTATION_HORIZONTAL, 0), + center_(Gtk::ORIENTATION_HORIZONTAL, 0), + right_(Gtk::ORIENTATION_HORIZONTAL, 0), + box_(Gtk::ORIENTATION_HORIZONTAL, 0) { window.set_title("waybar"); window.set_name("waybar"); window.set_decorated(false); - window.set_resizable(false); - setupConfig(); - setupCss(); + + if (output->config["position"] == "right" || output->config["position"] == "left") { + height_ = 0; + width_ = 30; + } + window.set_size_request(width_, height_); auto gtk_window = window.gobj(); auto gtk_widget = GTK_WIDGET(gtk_window); @@ -34,87 +27,33 @@ waybar::Bar::Bar(const Client& client, auto gdk_window = window.get_window()->gobj(); gdk_wayland_window_set_use_custom_surface(gdk_window); surface = gdk_wayland_window_get_wl_surface(gdk_window); -} -void waybar::Bar::initBar() -{ - // Converting string to button code rn as to avoid doing it later - auto setupAltFormatKeyForModule = [this](const std::string& module_name){ - if (config_.isMember(module_name)) { - Json::Value& module = config_[module_name]; - if (module.isMember("format-alt")) { - if (module.isMember("format-alt-click")) { - Json::Value& click = module["format-alt-click"]; - if (click.isString()) { - std::string str_click = click.asString(); - - if (str_click == "click-right") { - module["format-alt-click"] = 3u; - } else if (str_click == "click-middle") { - module["format-alt-click"] = 2u; - } else if (str_click == "click-backward") { - module["format-alt-click"] = 8u; - } else if (str_click == "click-forward") { - module["format-alt-click"] = 9u; - } else { - module["format-alt-click"] = 1u; // default click-left - } - } else { - module["format-alt-click"] = 1u; - } - } else { - module["format-alt-click"] = 1u; - } - - } - } - }; - - auto setupAltFormatKeyForModuleList = [this, &setupAltFormatKeyForModule](const char* module_list_name) { - if (config_.isMember(module_list_name)) { - Json::Value& modules = config_[module_list_name]; - for (const Json::Value& module_name : modules) { - if (module_name.isString()) { - setupAltFormatKeyForModule(module_name.asString()); - } - } - } - }; - - // Convert to button code for every module that is used. - setupAltFormatKeyForModuleList("modules-left"); - setupAltFormatKeyForModuleList("modules-right"); - setupAltFormatKeyForModuleList("modules-center"); - std::size_t layer = config_["layer"] == "top" - ? ZWLR_LAYER_SHELL_V1_LAYER_TOP : ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM; + std::size_t layer = output->config["layer"] == "top" ? ZWLR_LAYER_SHELL_V1_LAYER_TOP + : ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM; + auto client = waybar::Client::inst(); layer_surface = zwlr_layer_shell_v1_get_layer_surface( - client.layer_shell, surface, *output, layer, "waybar"); - + client->layer_shell, surface, output->output, layer, "waybar"); static const struct zwlr_layer_surface_v1_listener layer_surface_listener = { - .configure = layerSurfaceHandleConfigure, - .closed = layerSurfaceHandleClosed, + .configure = layerSurfaceHandleConfigure, + .closed = layerSurfaceHandleClosed, }; zwlr_layer_surface_v1_add_listener(layer_surface, &layer_surface_listener, this); - if (config_["position"] == "right" || config_["position"] == "left") { - height_ = 0; - width_ = 30; - } - - auto height = config_["height"].isUInt() ? config_["height"].asUInt() : height_; - auto width = config_["width"].isUInt() ? config_["width"].asUInt() : width_; + auto height = output->config["height"].isUInt() ? output->config["height"].asUInt() : height_; + auto width = output->config["width"].isUInt() ? output->config["width"].asUInt() : width_; std::size_t anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP; - if (config_["position"] == "bottom") { + if (output->config["position"] == "bottom") { anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM; - } else if (config_["position"] == "left") { + } else if (output->config["position"] == "left") { anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT; - } else if (config_["position"] == "right") { + } else if (output->config["position"] == "right") { anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT; } if (anchor == ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM || anchor == ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP) { anchor |= ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT; - } else if (anchor == ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT || anchor == ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT) { + } else if (anchor == ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT || + anchor == ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT) { anchor |= ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM; left_ = Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0); center_ = Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0); @@ -128,103 +67,71 @@ void waybar::Bar::initBar() zwlr_layer_surface_v1_set_size(layer_surface, width, height); wl_surface_commit(surface); + wl_display_roundtrip(client->wl_display); setupWidgets(); } -void waybar::Bar::handleLogicalPosition(void* /*data*/, - struct zxdg_output_v1* /*zxdg_output_v1*/, int32_t /*x*/, int32_t /*y*/) -{ - // Nothing here -} +// Converting string to button code rn as to avoid doing it later +void waybar::Bar::setupAltFormatKeyForModule(const std::string& module_name) { + if (output->config.isMember(module_name)) { + Json::Value& module = output->config[module_name]; + if (module.isMember("format-alt")) { + if (module.isMember("format-alt-click")) { + Json::Value& click = module["format-alt-click"]; + if (click.isString()) { + std::string str_click = click.asString(); -void waybar::Bar::handleLogicalSize(void* /*data*/, - struct zxdg_output_v1* /*zxdg_output_v1*/, int32_t /*width*/, - int32_t /*height*/) -{ - // Nothing here -} - -void waybar::Bar::handleDone(void* /*data*/, - struct zxdg_output_v1* /*zxdg_output_v1*/) -{ - // Nothing here -} - -bool waybar::Bar::isValidOutput(const Json::Value &config) -{ - bool found = true; - if (config["output"].isArray()) { - bool in_array = false; - for (auto const &output : config["output"]) { - if (output.isString() && output.asString() == output_name) { - in_array = true; - break; + if (str_click == "click-right") { + module["format-alt-click"] = 3u; + } else if (str_click == "click-middle") { + module["format-alt-click"] = 2u; + } else if (str_click == "click-backward") { + module["format-alt-click"] = 8u; + } else if (str_click == "click-forward") { + module["format-alt-click"] = 9u; + } else { + module["format-alt-click"] = 1u; // default click-left + } + } else { + module["format-alt-click"] = 1u; + } + } else { + module["format-alt-click"] = 1u; } } - found = in_array; } - if (config["output"].isString() && config["output"].asString() != output_name) { - found = false; - } - return found; } -void waybar::Bar::handleName(void* data, struct zxdg_output_v1* /*xdg_output*/, - const char* name) -{ - auto o = static_cast(data); - o->output_name = name; - bool found = true; - if (o->config_.isArray()) { - bool in_array = false; - for (auto const &config : o->config_) { - if (config.isObject() && o->isValidOutput(config)) { - in_array = true; - o->config_ = config; - break; +void waybar::Bar::setupAltFormatKeyForModuleList(const char* module_list_name) { + if (output->config.isMember(module_list_name)) { + Json::Value& modules = output->config[module_list_name]; + for (const Json::Value& module_name : modules) { + if (module_name.isString()) { + setupAltFormatKeyForModule(module_name.asString()); } } - found = in_array; - } else { - found = o->isValidOutput(o->config_); - } - if (!found) { - wl_output_destroy(*o->output); - zxdg_output_v1_destroy(o->xdg_output_); - } else { - o->initBar(); } } -void waybar::Bar::handleDescription(void* /*data*/, - struct zxdg_output_v1* /*zxdg_output_v1*/, const char* /*description*/) -{ - // Nothing here -} - -void waybar::Bar::handleSignal(int signal) -{ +void waybar::Bar::handleSignal(int signal) { for (auto& module : modules_left_) { auto* custom = dynamic_cast(module.get()); - if(custom) custom->refresh(signal); + if (custom) custom->refresh(signal); } for (auto& module : modules_center_) { auto* custom = dynamic_cast(module.get()); - if(custom) custom->refresh(signal); + if (custom) custom->refresh(signal); } for (auto& module : modules_right_) { auto* custom = dynamic_cast(module.get()); - if(custom) custom->refresh(signal); + if (custom) custom->refresh(signal); } } -void waybar::Bar::layerSurfaceHandleConfigure(void* data, - struct zwlr_layer_surface_v1* surface, uint32_t serial, uint32_t width, - uint32_t height) -{ - auto o = static_cast(data); - zwlr_layer_surface_v1_ack_configure(surface, serial); +void waybar::Bar::layerSurfaceHandleConfigure(void* data, struct zwlr_layer_surface_v1* surface, + uint32_t serial, uint32_t width, uint32_t height) { + auto o = static_cast(data); if (width != o->width_ || height != o->height_) { o->width_ = width; o->height_ = height; @@ -234,37 +141,29 @@ void waybar::Bar::layerSurfaceHandleConfigure(void* data, int min_width, min_height; o->window.get_size(min_width, min_height); if (o->height_ < static_cast(min_height)) { - std::cout << fmt::format("Requested height: {} exceeds the minimum \ -height: {} required by the modules", o->height_, min_height) << std::endl; + std::cout << fmt::format(MIN_HEIGHT_MSG, o->height_, min_height) << std::endl; o->height_ = min_height; } if (o->width_ < static_cast(min_width)) { - std::cout << fmt::format("Requested width: {} exceeds the minimum \ -width: {} required by the modules", o->height_, min_width) << std::endl; + std::cout << fmt::format(MIN_WIDTH_MSG, o->height_, min_width) << std::endl; o->width_ = min_width; } - std::cout << fmt::format( - "Bar configured (width: {}, height: {}) for output: {}", - o->width_, o->height_, o->output_name) << std::endl; + std::cout << fmt::format(BAR_SIZE_MSG, o->width_, o->height_, o->output->name) << std::endl; wl_surface_commit(o->surface); } + zwlr_layer_surface_v1_ack_configure(surface, serial); } -void waybar::Bar::layerSurfaceHandleClosed(void* data, - struct zwlr_layer_surface_v1* /*surface*/) -{ - auto o = static_cast(data); +void waybar::Bar::layerSurfaceHandleClosed(void* data, struct zwlr_layer_surface_v1* /*surface*/) { + auto o = static_cast(data); zwlr_layer_surface_v1_destroy(o->layer_surface); - wl_output_destroy(*o->output); - zxdg_output_v1_destroy(o->xdg_output_); o->modules_left_.clear(); o->modules_center_.clear(); o->modules_right_.clear(); } -auto waybar::Bar::toggle() -> void -{ +auto waybar::Bar::toggle() -> void { visible = !visible; auto zone = visible ? height_ : 0; if (!visible) { @@ -276,35 +175,9 @@ auto waybar::Bar::toggle() -> void wl_surface_commit(surface); } -auto waybar::Bar::setupConfig() -> void -{ - std::ifstream file(client.config_file); - if (!file.is_open()) { - throw std::runtime_error("Can't open config file"); - } - std::string str((std::istreambuf_iterator(file)), - std::istreambuf_iterator()); - util::JsonParser parser; - config_ = parser.parse(str); -} - -auto waybar::Bar::setupCss() -> void -{ - css_provider_ = Gtk::CssProvider::create(); - style_context_ = Gtk::StyleContext::create(); - - // Load our css file, wherever that may be hiding - if (css_provider_->load_from_path(client.css_file)) { - Glib::RefPtr screen = window.get_screen(); - style_context_->add_provider_for_screen(screen, css_provider_, - GTK_STYLE_PROVIDER_PRIORITY_USER); - } -} - -void waybar::Bar::getModules(const Factory& factory, const std::string& pos) -{ - if (config_[pos].isArray()) { - for (const auto &name : config_[pos]) { +void waybar::Bar::getModules(const Factory& factory, const std::string& pos) { + if (output->config[pos].isArray()) { + for (const auto& name : output->config[pos]) { try { auto module = factory.makeModule(name.asString()); if (pos == "modules-left") { @@ -330,14 +203,18 @@ void waybar::Bar::getModules(const Factory& factory, const std::string& pos) } } -auto waybar::Bar::setupWidgets() -> void -{ +auto waybar::Bar::setupWidgets() -> void { window.add(box_); box_.pack_start(left_, true, true); box_.set_center_widget(center_); box_.pack_end(right_, true, true); - Factory factory(*this, config_); + // Convert to button code for every module that is used. + setupAltFormatKeyForModuleList("modules-left"); + setupAltFormatKeyForModuleList("modules-right"); + setupAltFormatKeyForModuleList("modules-center"); + + Factory factory(*this, output->config); getModules(factory, "modules-left"); getModules(factory, "modules-center"); getModules(factory, "modules-right"); diff --git a/src/client.cpp b/src/client.cpp index d05e256..752ad91 100644 --- a/src/client.cpp +++ b/src/client.cpp @@ -1,25 +1,20 @@ #include "client.hpp" -#include "util/clara.hpp" +#include #include +#include "util/clara.hpp" +#include "util/json.hpp" -waybar::Client::Client(int argc, char* argv[]) - : gtk_app(Gtk::Application::create(argc, argv, "fr.arouillard.waybar")), - gdk_display(Gdk::Display::get_default()) -{ - if (!gdk_display) { - throw std::runtime_error("Can't find display"); - } - if (!GDK_IS_WAYLAND_DISPLAY(gdk_display->gobj())) { - throw std::runtime_error("Bar need to run under Wayland"); - } - wl_display = gdk_wayland_display_get_wl_display(gdk_display->gobj()); +waybar::Client::Client() {} + +waybar::Client *waybar::Client::inst() { + static Client *c = new Client(); + return c; } -const std::string waybar::Client::getValidPath(std::vector paths) -{ +const std::string waybar::Client::getValidPath(std::vector paths) { wordexp_t p; - for (const std::string &path: paths) { + for (const std::string &path : paths) { if (wordexp(path.c_str(), &p, 0) == 0) { if (access(*p.we_wordv, F_OK) == 0) { std::string result = *p.we_wordv; @@ -33,98 +28,215 @@ const std::string waybar::Client::getValidPath(std::vector paths) return std::string(); } -void waybar::Client::handleGlobal(void *data, struct wl_registry *registry, - uint32_t name, const char *interface, uint32_t version) -{ - auto o = static_cast(data); +void waybar::Client::handleGlobal(void *data, struct wl_registry *registry, uint32_t name, + const char *interface, uint32_t version) { + auto client = static_cast(data); if (strcmp(interface, zwlr_layer_shell_v1_interface.name) == 0) { - o->layer_shell = static_cast( - wl_registry_bind(registry, name, &zwlr_layer_shell_v1_interface, version)); + client->layer_shell = static_cast( + wl_registry_bind(registry, name, &zwlr_layer_shell_v1_interface, version)); } else if (strcmp(interface, wl_output_interface.name) == 0) { - auto output = std::make_unique(); - *output = static_cast(wl_registry_bind(registry, name, - &wl_output_interface, version)); - if (o->xdg_output_manager != nullptr) { - o->bars.emplace_back(std::make_unique(*o, std::move(output), name)); - } - } else if (strcmp(interface, wl_seat_interface.name) == 0) { - o->seat = static_cast(wl_registry_bind(registry, name, - &wl_seat_interface, version)); - } else if (strcmp(interface, zxdg_output_manager_v1_interface.name) == 0 - && version >= ZXDG_OUTPUT_V1_NAME_SINCE_VERSION) { - o->xdg_output_manager = static_cast( - wl_registry_bind(registry, name, - &zxdg_output_manager_v1_interface, ZXDG_OUTPUT_V1_NAME_SINCE_VERSION)); + auto wl_output = static_cast( + wl_registry_bind(registry, name, &wl_output_interface, version)); + client->outputs_.emplace_back(new struct waybar_output({wl_output, "", name, nullptr})); + client->handleOutput(client->outputs_.back()); + } else if (strcmp(interface, zxdg_output_manager_v1_interface.name) == 0 && + version >= ZXDG_OUTPUT_V1_NAME_SINCE_VERSION) { + client->xdg_output_manager = static_cast(wl_registry_bind( + registry, name, &zxdg_output_manager_v1_interface, ZXDG_OUTPUT_V1_NAME_SINCE_VERSION)); } else if (strcmp(interface, zwp_idle_inhibit_manager_v1_interface.name) == 0) { - o->idle_inhibit_manager = static_cast( - wl_registry_bind(registry, name, - &zwp_idle_inhibit_manager_v1_interface, 1)); + client->idle_inhibit_manager = static_cast( + wl_registry_bind(registry, name, &zwp_idle_inhibit_manager_v1_interface, 1)); } } -void waybar::Client::handleGlobalRemove(void* data, - struct wl_registry* /*registry*/, uint32_t name) -{ - auto o = static_cast(data); - for (auto it = o->bars.begin(); it != o->bars.end(); ++it) { - if ((*it)->wl_name == name) { - auto output_name = (*it)->output_name; - o->bars.erase(it); +void waybar::Client::handleGlobalRemove(void * data, struct wl_registry * /*registry*/, + uint32_t name) { + auto client = static_cast(data); + for (auto it = client->bars.begin(); it != client->bars.end();) { + if ((*it)->output->wl_name == name) { + auto output_name = (*it)->output->name; + (*it)->window.close(); + it = client->bars.erase(it); std::cout << "Bar removed from output: " + output_name << std::endl; - break; + } else { + ++it; } } + auto it = std::find_if(client->outputs_.begin(), + client->outputs_.end(), + [&name](const auto &output) { return output->wl_name == name; }); + if (it != client->outputs_.end()) { + zxdg_output_v1_destroy((*it)->xdg_output); + wl_output_destroy((*it)->output); + client->outputs_.erase(it); + } } -void waybar::Client::setupConfigs(const std::string& config, const std::string& style) -{ - config_file = config.empty() ? getValidPath({ - "$XDG_CONFIG_HOME/waybar/config", - "$HOME/.config/waybar/config", - "$HOME/waybar/config", - "/etc/xdg/waybar/config", - "./resources/config", - }) : config; - css_file = style.empty() ? getValidPath({ - "$XDG_CONFIG_HOME/waybar/style.css", - "$HOME/.config/waybar/style.css", - "$HOME/waybar/style.css", - "/etc/xdg/waybar/style.css", - "./resources/style.css", - }) : style; - if (css_file.empty() || config_file.empty()) { +void waybar::Client::handleOutput(std::unique_ptr &output) { + static const struct zxdg_output_v1_listener xdgOutputListener = { + .logical_position = handleLogicalPosition, + .logical_size = handleLogicalSize, + .done = handleDone, + .name = handleName, + .description = handleDescription, + }; + output->xdg_output = zxdg_output_manager_v1_get_xdg_output(xdg_output_manager, output->output); + zxdg_output_v1_add_listener(output->xdg_output, &xdgOutputListener, &output->wl_name); +} + +void waybar::Client::handleLogicalPosition(void * /*data*/, + struct zxdg_output_v1 * /*zxdg_output_v1*/, + int32_t /*x*/, int32_t /*y*/) { + // Nothing here +} + +void waybar::Client::handleLogicalSize(void * /*data*/, struct zxdg_output_v1 * /*zxdg_output_v1*/, + int32_t /*width*/, int32_t /*height*/) { + // Nothing here +} + +void waybar::Client::handleDone(void * /*data*/, struct zxdg_output_v1 * /*zxdg_output_v1*/) { + // Nothing here +} + +bool waybar::Client::isValidOutput(const Json::Value & config, + std::unique_ptr &output) { + bool found = true; + if (config["output"].isArray()) { + bool in_array = false; + for (auto const &output_conf : config["output"]) { + if (output_conf.isString() && output_conf.asString() == output->name) { + in_array = true; + break; + } + } + found = in_array; + } + if (config["output"].isString() && config["output"].asString() != output->name) { + found = false; + } + return found; +} + +void waybar::Client::handleName(void * data, struct zxdg_output_v1 * /*xdg_output*/, + const char *name) { + auto wl_name = *static_cast(data); + auto client = waybar::Client::inst(); + auto it = std::find_if(client->outputs_.begin(), + client->outputs_.end(), + [&wl_name](const auto &output) { return output->wl_name == wl_name; }); + if (it == client->outputs_.end()) { + std::cerr << "Unable to find valid output" << std::endl; + return; + } + (*it)->name = name; + bool found = true; + if (client->config_.isArray()) { + bool in_array = false; + for (auto const &config : client->config_) { + if (config.isObject() && client->isValidOutput(config, *it)) { + in_array = true; + (*it)->config = config; + break; + } + } + found = in_array; + } else { + (*it)->config = client->config_; + found = client->isValidOutput((*it)->config, *it); + } + if (!found) { + wl_output_destroy((*it)->output); + zxdg_output_v1_destroy((*it)->xdg_output); + } else { + client->bars.emplace_back(std::make_unique(it->get())); + Glib::RefPtr screen = client->bars.back()->window.get_screen(); + client->style_context_->add_provider_for_screen( + screen, client->css_provider_, GTK_STYLE_PROVIDER_PRIORITY_USER); + } +} + +void waybar::Client::handleDescription(void * /*data*/, struct zxdg_output_v1 * /*zxdg_output_v1*/, + const char * /*description*/) { + // Nothing here +} + +void waybar::Client::setupConfigs(const std::string &config, const std::string &style) { + config_file_ = config.empty() ? getValidPath({ + "$XDG_CONFIG_HOME/waybar/config", + "$HOME/.config/waybar/config", + "$HOME/waybar/config", + "/etc/xdg/waybar/config", + "./resources/config", + }) + : config; + css_file_ = style.empty() ? getValidPath({ + "$XDG_CONFIG_HOME/waybar/style.css", + "$HOME/.config/waybar/style.css", + "$HOME/waybar/style.css", + "/etc/xdg/waybar/style.css", + "./resources/style.css", + }) + : style; + if (css_file_.empty() || config_file_.empty()) { throw std::runtime_error("Missing required resources files"); } - std::cout << "Resources files: " + config_file + ", " + css_file << std::endl; + std::cout << "Resources files: " + config_file_ + ", " + css_file_ << std::endl; } -void waybar::Client::bindInterfaces() -{ +auto waybar::Client::setupConfig() -> void { + std::ifstream file(config_file_); + if (!file.is_open()) { + throw std::runtime_error("Can't open config file"); + } + std::string str((std::istreambuf_iterator(file)), std::istreambuf_iterator()); + util::JsonParser parser; + config_ = parser.parse(str); +} + +auto waybar::Client::setupCss() -> void { + css_provider_ = Gtk::CssProvider::create(); + style_context_ = Gtk::StyleContext::create(); + + // Load our css file, wherever that may be hiding + if (!css_provider_->load_from_path(css_file_)) { + throw std::runtime_error("Can't open style file"); + } +} + +void waybar::Client::bindInterfaces() { registry = wl_display_get_registry(wl_display); static const struct wl_registry_listener registry_listener = { - .global = handleGlobal, - .global_remove = handleGlobalRemove, + .global = handleGlobal, + .global_remove = handleGlobalRemove, }; wl_registry_add_listener(registry, ®istry_listener, this); wl_display_roundtrip(wl_display); - if (!layer_shell || !seat || !xdg_output_manager) { + if (!layer_shell || !xdg_output_manager) { throw std::runtime_error("Failed to acquire required resources."); } - wl_display_roundtrip(wl_display); } -int waybar::Client::main(int argc, char* argv[]) -{ - bool show_help = false; - bool show_version = false; +int waybar::Client::main(int argc, char *argv[]) { + gtk_app = Gtk::Application::create(argc, argv, "fr.arouillard.waybar"); + gdk_display = Gdk::Display::get_default(); + if (!gdk_display) { + throw std::runtime_error("Can't find display"); + } + if (!GDK_IS_WAYLAND_DISPLAY(gdk_display->gobj())) { + throw std::runtime_error("Bar need to run under Wayland"); + } + wl_display = gdk_wayland_display_get_wl_display(gdk_display->gobj()); + bool show_help = false; + bool show_version = false; std::string config; std::string style; std::string bar_id; - auto cli = clara::detail::Help(show_help) - | clara::detail::Opt(show_version)["-v"]["--version"]("Show version") - | clara::detail::Opt(config, "config")["-c"]["--config"]("Config path") - | clara::detail::Opt(style, "style")["-s"]["--style"]("Style path") - | clara::detail::Opt(bar_id, "id")["-b"]["--bar"]("Bar id"); + auto cli = clara::detail::Help(show_help) | + clara::detail::Opt(show_version)["-v"]["--version"]("Show version") | + clara::detail::Opt(config, "config")["-c"]["--config"]("Config path") | + clara::detail::Opt(style, "style")["-s"]["--style"]("Style path") | + clara::detail::Opt(bar_id, "id")["-b"]["--bar"]("Bar id"); auto res = cli.parse(clara::detail::Args(argc, argv)); if (!res) { std::cerr << "Error in command line: " << res.errorMessage() << std::endl; @@ -139,6 +251,8 @@ int waybar::Client::main(int argc, char* argv[]) return 0; } setupConfigs(config, style); + setupConfig(); + setupCss(); bindInterfaces(); gtk_app->hold(); gtk_app->run(); @@ -147,7 +261,6 @@ int waybar::Client::main(int argc, char* argv[]) zwlr_layer_shell_v1_destroy(layer_shell); zwp_idle_inhibit_manager_v1_destroy(idle_inhibit_manager); wl_registry_destroy(registry); - wl_seat_destroy(seat); wl_display_disconnect(wl_display); return 0; } diff --git a/src/factory.cpp b/src/factory.cpp index 067ecac..974d276 100644 --- a/src/factory.cpp +++ b/src/factory.cpp @@ -1,11 +1,8 @@ #include "factory.hpp" -waybar::Factory::Factory(const Bar& bar, const Json::Value& config) - : bar_(bar), config_(config) -{} +waybar::Factory::Factory(const Bar& bar, const Json::Value& config) : bar_(bar), config_(config) {} -waybar::IModule* waybar::Factory::makeModule(const std::string &name) const -{ +waybar::IModule* waybar::Factory::makeModule(const std::string& name) const { try { auto hash_pos = name.find("#"); auto ref = name.substr(0, hash_pos); @@ -13,7 +10,7 @@ waybar::IModule* waybar::Factory::makeModule(const std::string &name) const if (ref == "battery") { return new waybar::modules::Battery(id, config_[name]); } - #ifdef HAVE_SWAY +#ifdef HAVE_SWAY if (ref == "sway/mode") { return new waybar::modules::sway::Mode(id, bar_, config_[name]); } @@ -23,7 +20,7 @@ waybar::IModule* waybar::Factory::makeModule(const std::string &name) const if (ref == "sway/window") { return new waybar::modules::sway::Window(id, bar_, config_[name]); } - #endif +#endif if (ref == "idle_inhibitor") { return new waybar::modules::IdleInhibitor(id, bar_, config_[name]); } @@ -36,31 +33,31 @@ waybar::IModule* waybar::Factory::makeModule(const std::string &name) const if (ref == "clock") { return new waybar::modules::Clock(id, config_[name]); } - #ifdef HAVE_DBUSMENU +#ifdef HAVE_DBUSMENU if (ref == "tray") { return new waybar::modules::SNI::Tray(id, bar_, config_[name]); } - #endif - #ifdef HAVE_LIBNL +#endif +#ifdef HAVE_LIBNL if (ref == "network") { return new waybar::modules::Network(id, config_[name]); } - #endif - #ifdef HAVE_LIBUDEV +#endif +#ifdef HAVE_LIBUDEV if (ref == "backlight") { return new waybar::modules::Backlight(id, config_[name]); } - #endif - #ifdef HAVE_LIBPULSE +#endif +#ifdef HAVE_LIBPULSE if (ref == "pulseaudio") { return new waybar::modules::Pulseaudio(id, config_[name]); } - #endif - #ifdef HAVE_LIBMPDCLIENT +#endif +#ifdef HAVE_LIBMPDCLIENT if (ref == "mpd") { return new waybar::modules::MPD(id, config_[name]); } - #endif +#endif if (ref == "temperature") { return new waybar::modules::Temperature(id, config_[name]); } diff --git a/src/main.cpp b/src/main.cpp index c3909aa..59471aa 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -2,31 +2,26 @@ #include #include "client.hpp" -namespace waybar { - -static Client* client; - -} // namespace waybar - int main(int argc, char* argv[]) { try { - waybar::Client c(argc, argv); - waybar::client = &c; + auto client = waybar::Client::inst(); std::signal(SIGUSR1, [](int /*signal*/) { - for (auto& bar : waybar::client->bars) { + for (auto& bar : waybar::Client::inst()->bars) { bar->toggle(); } }); for (int sig = SIGRTMIN + 1; sig <= SIGRTMAX; ++sig) { - std::signal(sig, [](int sig /*signal*/) { - for (auto& bar : waybar::client->bars) { + std::signal(sig, [](int sig) { + for (auto& bar : waybar::Client::inst()->bars) { bar->handleSignal(sig); } }); } - return c.main(argc, argv); + auto ret = client->main(argc, argv); + delete client; + return ret; } catch (const std::exception& e) { std::cerr << e.what() << std::endl; return 1; diff --git a/src/modules/backlight.cpp b/src/modules/backlight.cpp index 25eeaa2..2cdd5a9 100644 --- a/src/modules/backlight.cpp +++ b/src/modules/backlight.cpp @@ -13,7 +13,7 @@ namespace { class FileDescriptor { -public: + public: explicit FileDescriptor(int fd) : fd_(fd) {} FileDescriptor(const FileDescriptor &other) = delete; FileDescriptor(FileDescriptor &&other) noexcept = delete; @@ -28,7 +28,7 @@ public: } int get() const { return fd_; } -private: + private: int fd_; }; @@ -60,9 +60,7 @@ void check_neq(int rc, int bad_rc, const char *message = "neq, rc was: ") { } } -void check0(int rc, const char *message = "rc wasn't 0") { - check_eq(rc, 0, message); -} +void check0(int rc, const char *message = "rc wasn't 0") { check_eq(rc, 0, message); } void check_gte(int rc, int gte, const char *message = "rc was: ") { if (rc < gte) { @@ -75,41 +73,33 @@ void check_nn(const void *ptr, const char *message = "ptr was null") { throw std::runtime_error(message); } } -} // namespace +} // namespace -waybar::modules::Backlight::BacklightDev::BacklightDev(std::string name, - int actual, int max) +waybar::modules::Backlight::BacklightDev::BacklightDev(std::string name, int actual, int max) : name_(std::move(name)), actual_(actual), max_(max) {} -std::string_view waybar::modules::Backlight::BacklightDev::name() const { - return name_; -} +std::string_view waybar::modules::Backlight::BacklightDev::name() const { return name_; } -int waybar::modules::Backlight::BacklightDev::get_actual() const { - return actual_; -} +int waybar::modules::Backlight::BacklightDev::get_actual() const { return actual_; } -void waybar::modules::Backlight::BacklightDev::set_actual(int actual) { - actual_ = actual; -} +void waybar::modules::Backlight::BacklightDev::set_actual(int actual) { actual_ = actual; } int waybar::modules::Backlight::BacklightDev::get_max() const { return max_; } void waybar::modules::Backlight::BacklightDev::set_max(int max) { max_ = max; } -waybar::modules::Backlight::Backlight(const std::string &name, - const Json::Value &config) - : ALabel(config, "{percent}%", 2), name_(name), - preferred_device_( - config["device"].isString() ? config["device"].asString() : "") { +waybar::modules::Backlight::Backlight(const std::string &name, const Json::Value &config) + : ALabel(config, "{percent}%", 2), + name_(name), + preferred_device_(config["device"].isString() ? config["device"].asString() : "") { label_.set_name("backlight"); // Get initial state { std::unique_ptr udev_check{udev_new()}; check_nn(udev_check.get(), "Udev check new failed"); - enumerate_devices(devices_.begin(), devices_.end(), - std::back_inserter(devices_), udev_check.get()); + enumerate_devices( + devices_.begin(), devices_.end(), std::back_inserter(devices_), udev_check.get()); if (devices_.empty()) { throw std::runtime_error("No backlight found"); } @@ -123,9 +113,9 @@ waybar::modules::Backlight::Backlight(const std::string &name, std::unique_ptr mon{ udev_monitor_new_from_netlink(udev.get(), "udev")}; check_nn(mon.get(), "udev monitor new failed"); - check_gte(udev_monitor_filter_add_match_subsystem_devtype( - mon.get(), "backlight", nullptr), - 0, "udev failed to add monitor filter: "); + check_gte(udev_monitor_filter_add_match_subsystem_devtype(mon.get(), "backlight", nullptr), + 0, + "udev failed to add monitor filter: "); udev_monitor_enable_receiving(mon.get()); auto udev_fd = udev_monitor_get_fd(mon.get()); @@ -136,15 +126,13 @@ waybar::modules::Backlight::Backlight(const std::string &name, ctl_event.events = EPOLLIN; ctl_event.data.fd = udev_fd; - check0( - epoll_ctl(epoll_fd.get(), EPOLL_CTL_ADD, ctl_event.data.fd, &ctl_event), - "epoll_ctl failed: {}"); + check0(epoll_ctl(epoll_fd.get(), EPOLL_CTL_ADD, ctl_event.data.fd, &ctl_event), + "epoll_ctl failed: {}"); epoll_event events[EPOLL_MAX_EVENTS]; while (udev_thread_.isRunning()) { - const int event_count = - epoll_wait(epoll_fd.get(), events, EPOLL_MAX_EVENTS, - std::chrono::milliseconds{interval_}.count()); + const int event_count = epoll_wait( + epoll_fd.get(), events, EPOLL_MAX_EVENTS, std::chrono::milliseconds{interval_}.count()); if (!udev_thread_.isRunning()) { break; } @@ -156,17 +144,14 @@ waybar::modules::Backlight::Backlight(const std::string &name, for (int i = 0; i < event_count; ++i) { const auto &event = events[i]; check_eq(event.data.fd, udev_fd, "unexpected udev fd"); - std::unique_ptr dev{ - udev_monitor_receive_device(mon.get())}; + std::unique_ptr dev{udev_monitor_receive_device(mon.get())}; check_nn(dev.get(), "epoll dev was null"); - upsert_device(devices.begin(), devices.end(), - std::back_inserter(devices), dev.get()); + upsert_device(devices.begin(), devices.end(), std::back_inserter(devices), dev.get()); } // Refresh state if timed out if (event_count == 0) { - enumerate_devices(devices.begin(), devices.end(), - std::back_inserter(devices), udev.get()); + enumerate_devices(devices.begin(), devices.end(), std::back_inserter(devices), udev.get()); } { std::scoped_lock lock(udev_thread_mutex_); @@ -186,19 +171,16 @@ auto waybar::modules::Backlight::update() -> void { devices = devices_; } - const auto best = - best_device(devices.cbegin(), devices.cend(), preferred_device_); + const auto best = best_device(devices.cbegin(), devices.cend(), preferred_device_); if (best != nullptr) { if (previous_best_.has_value() && previous_best_.value() == *best && !previous_format_.empty() && previous_format_ == format_) { return; } - const auto percent = - best->get_max() == 0 ? 100 : best->get_actual() * 100 / best->get_max(); - label_.set_markup(fmt::format(format_, - fmt::arg("percent", std::to_string(percent)), - fmt::arg("icon", getIcon(percent)))); + const auto percent = best->get_max() == 0 ? 100 : best->get_actual() * 100 / best->get_max(); + label_.set_markup(fmt::format( + format_, fmt::arg("percent", std::to_string(percent)), fmt::arg("icon", getIcon(percent)))); } else { if (!previous_best_.has_value()) { return; @@ -210,28 +192,22 @@ auto waybar::modules::Backlight::update() -> void { } template -const waybar::modules::Backlight::BacklightDev * -waybar::modules::Backlight::best_device(ForwardIt first, ForwardIt last, - std::string_view preferred_device) { - const auto found = - std::find_if(first, last, [preferred_device](const auto &dev) { - return dev.name() == preferred_device; - }); +const waybar::modules::Backlight::BacklightDev *waybar::modules::Backlight::best_device( + ForwardIt first, ForwardIt last, std::string_view preferred_device) { + const auto found = std::find_if( + first, last, [preferred_device](const auto &dev) { return dev.name() == preferred_device; }); if (found != last) { return &(*found); } - const auto max = - std::max_element(first, last, [](const auto &l, const auto &r) { - return l.get_max() < r.get_max(); - }); + const auto max = std::max_element( + first, last, [](const auto &l, const auto &r) { return l.get_max() < r.get_max(); }); return max == last ? nullptr : &(*max); } template -void waybar::modules::Backlight::upsert_device(ForwardIt first, ForwardIt last, - Inserter inserter, +void waybar::modules::Backlight::upsert_device(ForwardIt first, ForwardIt last, Inserter inserter, udev_device *dev) { const char *name = udev_device_get_sysname(dev); check_nn(name); @@ -244,9 +220,8 @@ void waybar::modules::Backlight::upsert_device(ForwardIt first, ForwardIt last, check_nn(max); const int max_int = std::stoi(max); - auto found = std::find_if(first, last, [name](const auto &device) { - return device.name() == name; - }); + auto found = + std::find_if(first, last, [name](const auto &device) { return device.name() == name; }); if (found != last) { found->set_actual(actual_int); found->set_max(max_int); @@ -257,21 +232,16 @@ void waybar::modules::Backlight::upsert_device(ForwardIt first, ForwardIt last, } template -void waybar::modules::Backlight::enumerate_devices(ForwardIt first, - ForwardIt last, - Inserter inserter, - udev *udev) { - std::unique_ptr enumerate{ - udev_enumerate_new(udev)}; +void waybar::modules::Backlight::enumerate_devices(ForwardIt first, ForwardIt last, + Inserter inserter, udev *udev) { + std::unique_ptr enumerate{udev_enumerate_new(udev)}; udev_enumerate_add_match_subsystem(enumerate.get(), "backlight"); udev_enumerate_scan_devices(enumerate.get()); - udev_list_entry *enum_devices = - udev_enumerate_get_list_entry(enumerate.get()); + udev_list_entry *enum_devices = udev_enumerate_get_list_entry(enumerate.get()); udev_list_entry *dev_list_entry; udev_list_entry_foreach(dev_list_entry, enum_devices) { - const char *path = udev_list_entry_get_name(dev_list_entry); - std::unique_ptr dev{ - udev_device_new_from_syspath(udev, path)}; + const char * path = udev_list_entry_get_name(dev_list_entry); + std::unique_ptr dev{udev_device_new_from_syspath(udev, path)}; check_nn(dev.get(), "dev new failed"); upsert_device(first, last, inserter, dev.get()); } diff --git a/src/modules/battery.cpp b/src/modules/battery.cpp index 27d8baa..aabdcd6 100644 --- a/src/modules/battery.cpp +++ b/src/modules/battery.cpp @@ -1,8 +1,7 @@ #include "modules/battery.hpp" waybar::modules::Battery::Battery(const std::string& id, const Json::Value& config) - : ALabel(config, "{capacity}%", 60) -{ + : ALabel(config, "{capacity}%", 60) { label_.set_name("battery"); if (!id.empty()) { label_.get_style_context()->add_class(id); @@ -21,23 +20,21 @@ waybar::modules::Battery::Battery(const std::string& id, const Json::Value& conf worker(); } -waybar::modules::Battery::~Battery() -{ +waybar::modules::Battery::~Battery() { for (auto wd : wds_) { inotify_rm_watch(fd_, wd); } close(fd_); } -void waybar::modules::Battery::worker() -{ +void waybar::modules::Battery::worker() { thread_timer_ = [this] { dp.emit(); thread_timer_.sleep_for(interval_); }; thread_ = [this] { struct inotify_event event = {0}; - int nbytes = read(fd_, &event, sizeof(event)); + int nbytes = read(fd_, &event, sizeof(event)); if (nbytes != sizeof(event) || event.mask & IN_IGNORED) { thread_.stop(); return; @@ -48,8 +45,7 @@ void waybar::modules::Battery::worker() }; } -void waybar::modules::Battery::getBatteries() -{ +void waybar::modules::Battery::getBatteries() { try { for (auto const& node : fs::directory_iterator(data_dir_)) { if (!fs::is_directory(node)) { @@ -57,18 +53,18 @@ void waybar::modules::Battery::getBatteries() } auto dir_name = node.path().filename(); auto bat_defined = config_["bat"].isString(); - if (((bat_defined && dir_name == config_["bat"].asString()) - || !bat_defined) && fs::exists(node / "capacity") - && fs::exists(node / "uevent") && fs::exists(node / "status")) { - batteries_.push_back(node); + if (((bat_defined && dir_name == config_["bat"].asString()) || !bat_defined) && + fs::exists(node / "capacity") && fs::exists(node / "uevent") && + fs::exists(node / "status")) { + batteries_.push_back(node); } auto adap_defined = config_["adapter"].isString(); - if (((adap_defined && dir_name == config_["adapter"].asString()) - || !adap_defined) && fs::exists(node / "online")) { - adapter_ = node; + if (((adap_defined && dir_name == config_["adapter"].asString()) || !adap_defined) && + fs::exists(node / "online")) { + adapter_ = node; } } - } catch (fs::filesystem_error &e) { + } catch (fs::filesystem_error& e) { throw std::runtime_error(e.what()); } if (batteries_.empty()) { @@ -79,13 +75,12 @@ void waybar::modules::Battery::getBatteries() } } -const std::tuple waybar::modules::Battery::getInfos() const -{ +const std::tuple waybar::modules::Battery::getInfos() const { try { - uint16_t total = 0; + uint16_t total = 0; std::string status = "Unknown"; for (auto const& bat : batteries_) { - uint16_t capacity; + uint16_t capacity; std::string _status; std::ifstream(bat / "capacity") >> capacity; std::ifstream(bat / "status") >> _status; @@ -102,8 +97,7 @@ const std::tuple waybar::modules::Battery::getInfos() cons } } -const std::string waybar::modules::Battery::getAdapterStatus(uint8_t capacity) const -{ +const std::string waybar::modules::Battery::getAdapterStatus(uint8_t capacity) const { if (!adapter_.empty()) { bool online; std::ifstream(adapter_ / "online") >> online; @@ -115,8 +109,7 @@ const std::string waybar::modules::Battery::getAdapterStatus(uint8_t capacity) c return "Unknown"; } -const std::string waybar::modules::Battery::getState(uint8_t capacity) const -{ +const std::string waybar::modules::Battery::getState(uint8_t capacity) const { // Get current state std::vector> states; if (config_["states"].isObject()) { @@ -127,9 +120,7 @@ const std::string waybar::modules::Battery::getState(uint8_t capacity) const } } // Sort states - std::sort(states.begin(), states.end(), [](auto &a, auto &b) { - return a.second < b.second; - }); + std::sort(states.begin(), states.end(), [](auto& a, auto& b) { return a.second < b.second; }); std::string valid_state; for (auto const& state : states) { if (capacity <= state.second && valid_state.empty()) { @@ -142,8 +133,7 @@ const std::string waybar::modules::Battery::getState(uint8_t capacity) const return valid_state; } -auto waybar::modules::Battery::update() -> void -{ +auto waybar::modules::Battery::update() -> void { auto [capacity, status] = getInfos(); if (status == "Unknown") { status = getAdapterStatus(capacity); @@ -168,7 +158,7 @@ auto waybar::modules::Battery::update() -> void event_box_.hide(); } else { event_box_.show(); - label_.set_markup(fmt::format(format, fmt::arg("capacity", capacity), - fmt::arg("icon", getIcon(capacity)))); + label_.set_markup( + fmt::format(format, fmt::arg("capacity", capacity), fmt::arg("icon", getIcon(capacity)))); } } diff --git a/src/modules/clock.cpp b/src/modules/clock.cpp index 8df3c4f..3822a2d 100644 --- a/src/modules/clock.cpp +++ b/src/modules/clock.cpp @@ -1,8 +1,7 @@ #include "modules/clock.hpp" waybar::modules::Clock::Clock(const std::string& id, const Json::Value& config) - : ALabel(config, "{:%H:%M}", 60) -{ + : ALabel(config, "{:%H:%M}", 60) { label_.set_name("clock"); if (!id.empty()) { label_.get_style_context()->add_class(id); @@ -13,18 +12,20 @@ waybar::modules::Clock::Clock(const std::string& id, const Json::Value& config) auto timeout = std::chrono::floor(now + interval_); auto time_s = std::chrono::time_point_cast(timeout); auto sub_m = - std::chrono::duration_cast(time_s.time_since_epoch()).count() % interval_.count(); - if (sub_m > 0) thread_.sleep_until(timeout - std::chrono::seconds(sub_m - 1)); - else thread_.sleep_until(timeout - std::chrono::seconds(sub_m)); + std::chrono::duration_cast(time_s.time_since_epoch()).count() % + interval_.count(); + if (sub_m > 0) + thread_.sleep_until(timeout - std::chrono::seconds(sub_m - 1)); + else + thread_.sleep_until(timeout - std::chrono::seconds(sub_m)); }; } -auto waybar::modules::Clock::update() -> void -{ +auto waybar::modules::Clock::update() -> void { auto localtime = fmt::localtime(std::time(nullptr)); auto text = fmt::format(format_, localtime); label_.set_markup(text); - + if (tooltipEnabled()) { if (config_["tooltip-format"].isString()) { auto tooltip_format = config_["tooltip-format"].asString(); diff --git a/src/modules/cpu.cpp b/src/modules/cpu.cpp index e800dbf..da09211 100644 --- a/src/modules/cpu.cpp +++ b/src/modules/cpu.cpp @@ -1,8 +1,7 @@ #include "modules/cpu.hpp" waybar::modules::Cpu::Cpu(const std::string& id, const Json::Value& config) - : ALabel(config, "{usage}%", 10) -{ + : ALabel(config, "{usage}%", 10) { label_.set_name("cpu"); if (!id.empty()) { label_.get_style_context()->add_class(id); @@ -13,44 +12,40 @@ waybar::modules::Cpu::Cpu(const std::string& id, const Json::Value& config) }; } -auto waybar::modules::Cpu::update() -> void -{ +auto waybar::modules::Cpu::update() -> void { // TODO: as creating dynamic fmt::arg arrays is buggy we have to calc both auto cpu_load = getCpuLoad(); auto [cpu_usage, tooltip] = getCpuUsage(); if (tooltipEnabled()) { label_.set_tooltip_text(tooltip); } - label_.set_markup(fmt::format(format_, - fmt::arg("load", cpu_load), fmt::arg("usage", cpu_usage))); + label_.set_markup(fmt::format(format_, fmt::arg("load", cpu_load), fmt::arg("usage", cpu_usage))); } -uint16_t waybar::modules::Cpu::getCpuLoad() -{ +uint16_t waybar::modules::Cpu::getCpuLoad() { struct sysinfo info = {0}; if (sysinfo(&info) == 0) { - float f_load = 1.f / (1u << SI_LOAD_SHIFT); + float f_load = 1.f / (1u << SI_LOAD_SHIFT); uint16_t load = info.loads[0] * f_load * 100 / get_nprocs(); return load; } throw std::runtime_error("Can't get Cpu load"); } -std::tuple waybar::modules::Cpu::getCpuUsage() -{ +std::tuple waybar::modules::Cpu::getCpuUsage() { if (prev_times_.empty()) { prev_times_ = parseCpuinfo(); std::this_thread::sleep_for(std::chrono::milliseconds(100)); } std::vector> curr_times = parseCpuinfo(); - std::string tooltip; - uint16_t usage = 0; + std::string tooltip; + uint16_t usage = 0; for (size_t i = 0; i < curr_times.size(); ++i) { auto [curr_idle, curr_total] = curr_times[i]; auto [prev_idle, prev_total] = prev_times_[i]; const float delta_idle = curr_idle - prev_idle; const float delta_total = curr_total - prev_total; - uint16_t tmp = 100 * (1 - delta_idle / delta_total); + uint16_t tmp = 100 * (1 - delta_idle / delta_total); if (i == 0) { usage = tmp; tooltip = fmt::format("Total: {}%", tmp); @@ -62,21 +57,21 @@ std::tuple waybar::modules::Cpu::getCpuUsage() return {usage, tooltip}; } -std::vector> waybar::modules::Cpu::parseCpuinfo() -{ +std::vector> waybar::modules::Cpu::parseCpuinfo() { std::ifstream info(data_dir_); if (!info.is_open()) { throw std::runtime_error("Can't open " + data_dir_); } - std::vector< std::tuple > cpuinfo; - std::string line; - while (getline(info, line)) { - if (line.substr(0,3).compare("cpu") != 0) { + std::vector> cpuinfo; + std::string line; + while (getline(info, line)) { + if (line.substr(0, 3).compare("cpu") != 0) { break; } - std::stringstream sline(line.substr(5)); + std::stringstream sline(line.substr(5)); std::vector times; - for (size_t time; sline >> time; times.push_back(time)); + for (size_t time; sline >> time; times.push_back(time)) + ; size_t idle_time = 0; size_t total_time = 0; diff --git a/src/modules/custom.cpp b/src/modules/custom.cpp index fb2dc9d..358db81 100644 --- a/src/modules/custom.cpp +++ b/src/modules/custom.cpp @@ -1,9 +1,7 @@ #include "modules/custom.hpp" -waybar::modules::Custom::Custom(const std::string& name, - const Json::Value& config) - : ALabel(config, "{}"), name_(name), fp_(nullptr) -{ +waybar::modules::Custom::Custom(const std::string& name, const Json::Value& config) + : ALabel(config, "{}"), name_(name), fp_(nullptr) { label_.set_name("custom-" + name_); if (config_["exec"].isString()) { if (interval_.count() > 0) { @@ -15,16 +13,14 @@ waybar::modules::Custom::Custom(const std::string& name, dp.emit(); } -waybar::modules::Custom::~Custom() -{ +waybar::modules::Custom::~Custom() { if (fp_) { pclose(fp_); fp_ = nullptr; } } -void waybar::modules::Custom::delayWorker() -{ +void waybar::modules::Custom::delayWorker() { thread_ = [this] { bool can_update = true; if (config_["exec-if"].isString()) { @@ -42,15 +38,14 @@ void waybar::modules::Custom::delayWorker() }; } -void waybar::modules::Custom::continuousWorker() -{ +void waybar::modules::Custom::continuousWorker() { auto cmd = config_["exec"].asString(); fp_ = popen(cmd.c_str(), "r"); if (!fp_) { throw std::runtime_error("Unable to open " + cmd); } thread_ = [this] { - char* buff = nullptr; + char* buff = nullptr; size_t len = 0; if (getline(&buff, &len, fp_) == -1) { int exit_code = 1; @@ -60,7 +55,7 @@ void waybar::modules::Custom::continuousWorker() } thread_.stop(); if (exit_code != 0) { - output_ = { exit_code, "" }; + output_ = {exit_code, ""}; dp.emit(); std::cerr << name_ + " just stopped unexpectedly, is it endless?" << std::endl; } @@ -69,23 +64,21 @@ void waybar::modules::Custom::continuousWorker() std::string output = buff; // Remove last newline - if (!output.empty() && output[output.length()-1] == '\n') { - output.erase(output.length()-1); + if (!output.empty() && output[output.length() - 1] == '\n') { + output.erase(output.length() - 1); } - output_ = { 0, output }; + output_ = {0, output}; dp.emit(); }; } -void waybar::modules::Custom::refresh(int sig /*signal*/) -{ - if(sig == SIGRTMIN + config_["signal"].asInt()) { +void waybar::modules::Custom::refresh(int sig /*signal*/) { + if (sig == SIGRTMIN + config_["signal"].asInt()) { thread_.wake_up(); } } -auto waybar::modules::Custom::update() -> void -{ +auto waybar::modules::Custom::update() -> void { // Hide label if output is empty if (config_["exec"].isString() && (output_.out.empty() || output_.exit_code != 0)) { event_box_.hide(); @@ -96,10 +89,11 @@ auto waybar::modules::Custom::update() -> void parseOutputRaw(); } - auto str = fmt::format(format_, text_, - fmt::arg("alt", alt_), - fmt::arg("icon", getIcon(percentage_, alt_)), - fmt::arg("percentage", percentage_)); + auto str = fmt::format(format_, + text_, + fmt::arg("alt", alt_), + fmt::arg("icon", getIcon(percentage_, alt_)), + fmt::arg("percentage", percentage_)); label_.set_markup(str); if (tooltipEnabled()) { if (text_ == tooltip_) { @@ -109,10 +103,10 @@ auto waybar::modules::Custom::update() -> void } } auto classes = label_.get_style_context()->list_classes(); - for (auto const &c : classes) { + for (auto const& c : classes) { label_.get_style_context()->remove_class(c); } - for (auto const &c : class_) { + for (auto const& c : class_) { label_.get_style_context()->add_class(c); } @@ -120,11 +114,10 @@ auto waybar::modules::Custom::update() -> void } } -void waybar::modules::Custom::parseOutputRaw() -{ +void waybar::modules::Custom::parseOutputRaw() { std::istringstream output(output_.out); - std::string line; - int i = 0; + std::string line; + int i = 0; while (getline(output, line)) { if (i == 0) { if (config_["escape"].isBool() && config_["escape"].asBool()) { @@ -145,10 +138,9 @@ void waybar::modules::Custom::parseOutputRaw() } } -void waybar::modules::Custom::parseOutputJson() -{ +void waybar::modules::Custom::parseOutputJson() { std::istringstream output(output_.out); - std::string line; + std::string line; class_.clear(); while (getline(output, line)) { auto parsed = parser_.parse(line); @@ -166,7 +158,7 @@ void waybar::modules::Custom::parseOutputJson() if (parsed["class"].isString()) { class_.push_back(parsed["class"].asString()); } else if (parsed["class"].isArray()) { - for (auto const &c : parsed["class"]) { + for (auto const& c : parsed["class"]) { class_.push_back(c.asString()); } } diff --git a/src/modules/idle_inhibitor.cpp b/src/modules/idle_inhibitor.cpp index 430433f..7840542 100644 --- a/src/modules/idle_inhibitor.cpp +++ b/src/modules/idle_inhibitor.cpp @@ -1,9 +1,9 @@ #include "modules/idle_inhibitor.hpp" #include "util/command.hpp" -waybar::modules::IdleInhibitor::IdleInhibitor(const std::string& id, const Bar& bar, const Json::Value& config) - : ALabel(config, "{status}"), bar_(bar), status_("deactivated"), idle_inhibitor_(nullptr) -{ +waybar::modules::IdleInhibitor::IdleInhibitor(const std::string& id, const Bar& bar, + const Json::Value& config) + : ALabel(config, "{status}"), bar_(bar), status_("deactivated"), idle_inhibitor_(nullptr) { label_.set_name("idle_inhibitor"); if (!id.empty()) { label_.get_style_context()->add_class(id); @@ -14,21 +14,18 @@ waybar::modules::IdleInhibitor::IdleInhibitor(const std::string& id, const Bar& dp.emit(); } -waybar::modules::IdleInhibitor::~IdleInhibitor() -{ - if(idle_inhibitor_) { +waybar::modules::IdleInhibitor::~IdleInhibitor() { + if (idle_inhibitor_) { zwp_idle_inhibitor_v1_destroy(idle_inhibitor_); idle_inhibitor_ = nullptr; } } -auto waybar::modules::IdleInhibitor::update() -> void -{ +auto waybar::modules::IdleInhibitor::update() -> void { label_.set_markup( - fmt::format(format_, fmt::arg("status", status_), - fmt::arg("icon", getIcon(0, status_)))); + fmt::format(format_, fmt::arg("status", status_), fmt::arg("icon", getIcon(0, status_)))); label_.get_style_context()->add_class(status_); - if(tooltipEnabled()) { + if (tooltipEnabled()) { label_.set_tooltip_text(status_); } } @@ -42,7 +39,7 @@ bool waybar::modules::IdleInhibitor::handleToggle(GdkEventButton* const& e) { status_ = "deactivated"; } else { idle_inhibitor_ = zwp_idle_inhibit_manager_v1_create_inhibitor( - bar_.client.idle_inhibit_manager, bar_.surface); + waybar::Client::inst()->idle_inhibit_manager, bar_.surface); status_ = "activated"; } if (config_["on-click"].isString() && e->button == 1) { diff --git a/src/modules/memory.cpp b/src/modules/memory.cpp index 649cdf6..d8f35c0 100644 --- a/src/modules/memory.cpp +++ b/src/modules/memory.cpp @@ -1,8 +1,7 @@ #include "modules/memory.hpp" waybar::modules::Memory::Memory(const std::string& id, const Json::Value& config) - : ALabel(config, "{}%", 30) -{ + : ALabel(config, "{}%", 30) { label_.set_name("memory"); if (!id.empty()) { label_.get_style_context()->add_class(id); @@ -13,8 +12,7 @@ waybar::modules::Memory::Memory(const std::string& id, const Json::Value& config }; } -auto waybar::modules::Memory::update() -> void -{ +auto waybar::modules::Memory::update() -> void { parseMeminfo(); if (memtotal_ > 0 && memfree_ >= 0) { int used_ram_percentage = 100 * (memtotal_ - memfree_) / memtotal_; @@ -29,9 +27,8 @@ auto waybar::modules::Memory::update() -> void } } -void waybar::modules::Memory::parseMeminfo() -{ - long memfree = -1, membuffer = -1, memcache = -1, memavail = -1; +void waybar::modules::Memory::parseMeminfo() { + long memfree = -1, membuffer = -1, memcache = -1, memavail = -1; std::ifstream info(data_dir_); if (!info.is_open()) { throw std::runtime_error("Can't open " + data_dir_); @@ -43,7 +40,7 @@ void waybar::modules::Memory::parseMeminfo() continue; } std::string name = line.substr(0, posDelim); - long value = std::stol(line.substr(posDelim + 1)); + long value = std::stol(line.substr(posDelim + 1)); if (name.compare("MemTotal") == 0) { memtotal_ = value; @@ -56,8 +53,7 @@ void waybar::modules::Memory::parseMeminfo() } else if (name.compare("Cached") == 0) { memcache = value; } - if (memtotal_ > 0 && - (memavail >= 0 || (memfree > -1 && membuffer > -1 && memcache > -1))) { + if (memtotal_ > 0 && (memavail >= 0 || (memfree > -1 && membuffer > -1 && memcache > -1))) { break; } } diff --git a/src/modules/network.cpp b/src/modules/network.cpp index 36587e6..5ba364d 100644 --- a/src/modules/network.cpp +++ b/src/modules/network.cpp @@ -1,10 +1,14 @@ -#include #include "modules/network.hpp" +#include -waybar::modules::Network::Network(const std::string& id, const Json::Value& config) - : ALabel(config, "{ifname}", 60), family_(AF_INET), efd_(-1), ev_fd_(-1), - cidr_(-1), signal_strength_dbm_(0), signal_strength_(0) -{ +waybar::modules::Network::Network(const std::string &id, const Json::Value &config) + : ALabel(config, "{ifname}", 60), + family_(AF_INET), + efd_(-1), + ev_fd_(-1), + cidr_(-1), + signal_strength_dbm_(0), + signal_strength_(0) { label_.set_name("network"); if (!id.empty()) { label_.get_style_context()->add_class(id); @@ -29,8 +33,7 @@ waybar::modules::Network::Network(const std::string& id, const Json::Value& conf worker(); } -waybar::modules::Network::~Network() -{ +waybar::modules::Network::~Network() { if (ev_fd_ > -1) { eventfd_write(ev_fd_, 1); std::this_thread::sleep_for(std::chrono::milliseconds(150)); @@ -51,8 +54,7 @@ waybar::modules::Network::~Network() } } -void waybar::modules::Network::createInfoSocket() -{ +void waybar::modules::Network::createInfoSocket() { info_sock_ = nl_socket_alloc(); if (nl_connect(info_sock_, NETLINK_ROUTE) != 0) { throw std::runtime_error("Can't connect network socket"); @@ -72,7 +74,7 @@ void waybar::modules::Network::createInfoSocket() } { ev_fd_ = eventfd(0, EFD_NONBLOCK); - struct epoll_event event; + struct epoll_event event = {0}; event.events = EPOLLIN | EPOLLET; event.data.fd = ev_fd_; if (epoll_ctl(efd_, EPOLL_CTL_ADD, ev_fd_, &event) == -1) { @@ -80,8 +82,8 @@ void waybar::modules::Network::createInfoSocket() } } { - auto fd = nl_socket_get_fd(info_sock_); - struct epoll_event event; + auto fd = nl_socket_get_fd(info_sock_); + struct epoll_event event = {0}; event.events = EPOLLIN | EPOLLET | EPOLLRDHUP; event.data.fd = fd; if (epoll_ctl(efd_, EPOLL_CTL_ADD, fd, &event) == -1) { @@ -90,8 +92,7 @@ void waybar::modules::Network::createInfoSocket() } } -void waybar::modules::Network::createEventSocket() -{ +void waybar::modules::Network::createEventSocket() { sk_ = nl_socket_alloc(); if (genl_connect(sk_) != 0) { throw std::runtime_error("Can't connect to netlink socket"); @@ -105,8 +106,7 @@ void waybar::modules::Network::createEventSocket() } } -void waybar::modules::Network::worker() -{ +void waybar::modules::Network::worker() { thread_timer_ = [this] { if (ifid_ > 0) { getInfo(); @@ -114,9 +114,9 @@ void waybar::modules::Network::worker() } thread_timer_.sleep_for(interval_); }; - struct epoll_event events[EPOLL_MAX]; + std::array events; thread_ = [this, &events] { - int ec = epoll_wait(efd_, events, EPOLL_MAX, -1); + int ec = epoll_wait(efd_, events.data(), EPOLL_MAX, -1); if (ec > 0) { for (auto i = 0; i < ec; i++) { if (events[i].data.fd == nl_socket_get_fd(info_sock_)) { @@ -132,8 +132,7 @@ void waybar::modules::Network::worker() }; } -auto waybar::modules::Network::update() -> void -{ +auto waybar::modules::Network::update() -> void { std::string connectiontype; std::string tooltip_format = ""; if (config_["tooltip-format"].isString()) { @@ -172,28 +171,26 @@ auto waybar::modules::Network::update() -> void format_ = default_format_; } auto text = fmt::format(format_, - fmt::arg("essid", essid_), - fmt::arg("signaldBm", signal_strength_dbm_), - fmt::arg("signalStrength", signal_strength_), - fmt::arg("ifname", ifname_), - fmt::arg("netmask", netmask_), - fmt::arg("ipaddr", ipaddr_), - fmt::arg("cidr", cidr_), - fmt::arg("icon", getIcon(signal_strength_, connectiontype)) - ); + fmt::arg("essid", essid_), + fmt::arg("signaldBm", signal_strength_dbm_), + fmt::arg("signalStrength", signal_strength_), + fmt::arg("ifname", ifname_), + fmt::arg("netmask", netmask_), + fmt::arg("ipaddr", ipaddr_), + fmt::arg("cidr", cidr_), + fmt::arg("icon", getIcon(signal_strength_, connectiontype))); label_.set_markup(text); if (tooltipEnabled()) { if (!tooltip_format.empty()) { auto tooltip_text = fmt::format(tooltip_format, - fmt::arg("essid", essid_), - fmt::arg("signaldBm", signal_strength_dbm_), - fmt::arg("signalStrength", signal_strength_), - fmt::arg("ifname", ifname_), - fmt::arg("netmask", netmask_), - fmt::arg("ipaddr", ipaddr_), - fmt::arg("cidr", cidr_), - fmt::arg("icon", getIcon(signal_strength_, connectiontype)) - ); + fmt::arg("essid", essid_), + fmt::arg("signaldBm", signal_strength_dbm_), + fmt::arg("signalStrength", signal_strength_), + fmt::arg("ifname", ifname_), + fmt::arg("netmask", netmask_), + fmt::arg("ipaddr", ipaddr_), + fmt::arg("cidr", cidr_), + fmt::arg("icon", getIcon(signal_strength_, connectiontype))); label_.set_tooltip_text(tooltip_text); } else { label_.set_tooltip_text(text); @@ -201,8 +198,7 @@ auto waybar::modules::Network::update() -> void } } -void waybar::modules::Network::disconnected() -{ +void waybar::modules::Network::disconnected() { essid_.clear(); signal_strength_dbm_ = 0; signal_strength_ = 0; @@ -218,17 +214,16 @@ void waybar::modules::Network::disconnected() } // Based on https://gist.github.com/Yawning/c70d804d4b8ae78cc698 -int waybar::modules::Network::getExternalInterface() -{ +int waybar::modules::Network::getExternalInterface() { static const uint32_t route_buffer_size = 8192; - struct nlmsghdr *hdr = nullptr; - struct rtmsg *rt = nullptr; - char resp[route_buffer_size] = {0}; - int ifidx = -1; + struct nlmsghdr * hdr = nullptr; + struct rtmsg * rt = nullptr; + char resp[route_buffer_size] = {0}; + int ifidx = -1; /* Prepare request. */ constexpr uint32_t reqlen = NLMSG_SPACE(sizeof(*rt)); - char req[reqlen] = {0}; + char req[reqlen] = {0}; /* Build the RTM_GETROUTE request. */ hdr = reinterpret_cast(req); @@ -257,7 +252,7 @@ int waybar::modules::Network::getExternalInterface() /* Parse the response payload into netlink messages. */ for (hdr = reinterpret_cast(resp); NLMSG_OK(hdr, len); - hdr = NLMSG_NEXT(hdr, len)) { + hdr = NLMSG_NEXT(hdr, len)) { if (hdr->nlmsg_type == NLMSG_DONE) { goto out; } @@ -284,10 +279,10 @@ int waybar::modules::Network::getExternalInterface() /* Parse all the attributes for a single routing table entry. */ struct rtattr *attr = RTM_RTA(rt); - uint64_t attrlen = RTM_PAYLOAD(hdr); - bool has_gateway = false; - bool has_destination = false; - int temp_idx = -1; + uint64_t attrlen = RTM_PAYLOAD(hdr); + bool has_gateway = false; + bool has_destination = false; + int temp_idx = -1; for (; RTA_OK(attr, attrlen); attr = RTA_NEXT(attr, attrlen)) { /* Determine if this routing table entry corresponds to the default * route by seeing if it has a gateway, and if a destination addr is @@ -307,8 +302,8 @@ int waybar::modules::Network::getExternalInterface() * Should be either missing, or maybe all 0s. Accept both. */ const uint32_t nr_zeroes = (family_ == AF_INET) ? 4 : 16; - unsigned char c = 0; - size_t dstlen = RTA_PAYLOAD(attr); + unsigned char c = 0; + size_t dstlen = RTA_PAYLOAD(attr); if (dstlen != nr_zeroes) { break; } @@ -320,7 +315,7 @@ int waybar::modules::Network::getExternalInterface() } case RTA_OIF: /* The output interface index. */ - temp_idx = *static_cast(RTA_DATA(attr)); + temp_idx = *static_cast(RTA_DATA(attr)); break; default: break; @@ -341,7 +336,7 @@ out: } void waybar::modules::Network::getInterfaceAddress() { - unsigned int cidrRaw; + unsigned int cidrRaw; struct ifaddrs *ifaddr, *ifa; ipaddr_.clear(); netmask_.clear(); @@ -352,13 +347,13 @@ void waybar::modules::Network::getInterfaceAddress() { while (ifa != nullptr && ipaddr_.empty() && netmask_.empty()) { if (ifa->ifa_addr != nullptr && ifa->ifa_addr->sa_family == family_) { if (strcmp(ifa->ifa_name, ifname_.c_str()) == 0) { - ipaddr_ = inet_ntoa(((struct sockaddr_in*)ifa->ifa_addr)->sin_addr); - netmask_ = inet_ntoa(((struct sockaddr_in*)ifa->ifa_netmask)->sin_addr); + ipaddr_ = inet_ntoa(((struct sockaddr_in *)ifa->ifa_addr)->sin_addr); + netmask_ = inet_ntoa(((struct sockaddr_in *)ifa->ifa_netmask)->sin_addr); cidrRaw = ((struct sockaddr_in *)(ifa->ifa_netmask))->sin_addr.s_addr; unsigned int cidr = 0; while (cidrRaw) { - cidr += cidrRaw & 1; - cidrRaw >>= 1; + cidr += cidrRaw & 1; + cidrRaw >>= 1; } cidr_ = cidr; } @@ -369,26 +364,22 @@ void waybar::modules::Network::getInterfaceAddress() { } } -int waybar::modules::Network::netlinkRequest(void *req, - uint32_t reqlen, uint32_t groups) -{ +int waybar::modules::Network::netlinkRequest(void *req, uint32_t reqlen, uint32_t groups) { struct sockaddr_nl sa = {}; sa.nl_family = AF_NETLINK; sa.nl_groups = groups; - struct iovec iov = { req, reqlen }; - struct msghdr msg = { &sa, sizeof(sa), &iov, 1, nullptr, 0, 0 }; + struct iovec iov = {req, reqlen}; + struct msghdr msg = {&sa, sizeof(sa), &iov, 1, nullptr, 0, 0}; return sendmsg(nl_socket_get_fd(info_sock_), &msg, 0); } -int waybar::modules::Network::netlinkResponse(void *resp, - uint32_t resplen, uint32_t groups) -{ +int waybar::modules::Network::netlinkResponse(void *resp, uint32_t resplen, uint32_t groups) { struct sockaddr_nl sa = {}; sa.nl_family = AF_NETLINK; sa.nl_groups = groups; - struct iovec iov = { resp, resplen }; - struct msghdr msg = { &sa, sizeof(sa), &iov, 1, nullptr, 0, 0 }; - auto ret = recvmsg(nl_socket_get_fd(info_sock_), &msg, 0); + struct iovec iov = {resp, resplen}; + struct msghdr msg = {&sa, sizeof(sa), &iov, 1, nullptr, 0, 0}; + auto ret = recvmsg(nl_socket_get_fd(info_sock_), &msg, 0); if (msg.msg_flags & MSG_TRUNC) { return -1; } @@ -396,11 +387,10 @@ int waybar::modules::Network::netlinkResponse(void *resp, } int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) { - int ret = 0; + int ret = 0; auto net = static_cast(data); bool need_update = false; - for (nlmsghdr *nh = nlmsg_hdr(msg); NLMSG_OK(nh, ret); - nh = NLMSG_NEXT(nh, ret)) { + for (nlmsghdr *nh = nlmsg_hdr(msg); NLMSG_OK(nh, ret); nh = NLMSG_NEXT(nh, ret)) { if (nh->nlmsg_type == RTM_NEWADDR) { need_update = true; } @@ -443,10 +433,10 @@ int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) { } int waybar::modules::Network::handleScan(struct nl_msg *msg, void *data) { - auto net = static_cast(data); - auto gnlh = static_cast(nlmsg_data(nlmsg_hdr(msg))); - struct nlattr* tb[NL80211_ATTR_MAX + 1]; - struct nlattr* bss[NL80211_BSS_MAX + 1]; + auto net = static_cast(data); + auto gnlh = static_cast(nlmsg_data(nlmsg_hdr(msg))); + struct nlattr * tb[NL80211_ATTR_MAX + 1]; + struct nlattr * bss[NL80211_BSS_MAX + 1]; struct nla_policy bss_policy[NL80211_BSS_MAX + 1]{}; bss_policy[NL80211_BSS_TSF].type = NLA_U64; bss_policy[NL80211_BSS_FREQUENCY].type = NLA_U32; @@ -458,7 +448,8 @@ int waybar::modules::Network::handleScan(struct nl_msg *msg, void *data) { bss_policy[NL80211_BSS_SIGNAL_UNSPEC].type = NLA_U8; bss_policy[NL80211_BSS_STATUS].type = NLA_U32; - if (nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0), genlmsg_attrlen(gnlh, 0), nullptr) < 0) { + if (nla_parse( + tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0), genlmsg_attrlen(gnlh, 0), nullptr) < 0) { return NL_SKIP; } if (tb[NL80211_ATTR_BSS] == nullptr) { @@ -476,21 +467,19 @@ int waybar::modules::Network::handleScan(struct nl_msg *msg, void *data) { return NL_SKIP; } -void waybar::modules::Network::parseEssid(struct nlattr **bss) -{ +void waybar::modules::Network::parseEssid(struct nlattr **bss) { essid_.clear(); if (bss[NL80211_BSS_INFORMATION_ELEMENTS] != nullptr) { - auto ies = - static_cast(nla_data(bss[NL80211_BSS_INFORMATION_ELEMENTS])); - auto ies_len = nla_len(bss[NL80211_BSS_INFORMATION_ELEMENTS]); + auto ies = static_cast(nla_data(bss[NL80211_BSS_INFORMATION_ELEMENTS])); + auto ies_len = nla_len(bss[NL80211_BSS_INFORMATION_ELEMENTS]); const auto hdr_len = 2; while (ies_len > hdr_len && ies[0] != 0) { ies_len -= ies[1] + hdr_len; ies += ies[1] + hdr_len; } if (ies_len > hdr_len && ies_len > ies[1] + hdr_len) { - auto essid_begin = ies + hdr_len; - auto essid_end = essid_begin + ies[1]; + auto essid_begin = ies + hdr_len; + auto essid_end = essid_begin + ies[1]; std::string essid_raw; std::copy(essid_begin, essid_end, std::back_inserter(essid_raw)); essid_ = Glib::Markup::escape_text(essid_raw); @@ -506,16 +495,15 @@ void waybar::modules::Network::parseSignal(struct nlattr **bss) { // WiFi-hardware usually operates in the range -90 to -20dBm. const int hardwareMax = -20; const int hardwareMin = -90; - signal_strength_ = ((signal_strength_dbm_ - hardwareMin) - / double{hardwareMax - hardwareMin}) * 100; + signal_strength_ = + ((signal_strength_dbm_ - hardwareMin) / double{hardwareMax - hardwareMin}) * 100; } if (bss[NL80211_BSS_SIGNAL_UNSPEC] != nullptr) { signal_strength_ = nla_get_u8(bss[NL80211_BSS_SIGNAL_UNSPEC]); } } -bool waybar::modules::Network::associatedOrJoined(struct nlattr** bss) -{ +bool waybar::modules::Network::associatedOrJoined(struct nlattr **bss) { if (bss[NL80211_BSS_STATUS] == nullptr) { return false; } @@ -530,16 +518,16 @@ bool waybar::modules::Network::associatedOrJoined(struct nlattr** bss) } } -auto waybar::modules::Network::getInfo() -> void -{ +auto waybar::modules::Network::getInfo() -> void { getInterfaceAddress(); - struct nl_msg* nl_msg = nlmsg_alloc(); + struct nl_msg *nl_msg = nlmsg_alloc(); if (nl_msg == nullptr) { return; } - if (genlmsg_put(nl_msg, NL_AUTO_PORT, NL_AUTO_SEQ, nl80211_id_, 0, NLM_F_DUMP, - NL80211_CMD_GET_SCAN, 0) == nullptr - || nla_put_u32(nl_msg, NL80211_ATTR_IFINDEX, ifid_) < 0) { + if (genlmsg_put( + nl_msg, NL_AUTO_PORT, NL_AUTO_SEQ, nl80211_id_, 0, NLM_F_DUMP, NL80211_CMD_GET_SCAN, 0) == + nullptr || + nla_put_u32(nl_msg, NL80211_ATTR_IFINDEX, ifid_) < 0) { nlmsg_free(nl_msg); return; } diff --git a/src/modules/pulseaudio.cpp b/src/modules/pulseaudio.cpp index b5dfe49..7cb095c 100644 --- a/src/modules/pulseaudio.cpp +++ b/src/modules/pulseaudio.cpp @@ -1,7 +1,7 @@ #include "modules/pulseaudio.hpp" #include -waybar::modules::Pulseaudio::Pulseaudio(const std::string& id, const Json::Value &config) +waybar::modules::Pulseaudio::Pulseaudio(const std::string &id, const Json::Value &config) : ALabel(config, "{volume}%"), mainloop_(nullptr), mainloop_api_(nullptr), @@ -24,10 +24,9 @@ waybar::modules::Pulseaudio::Pulseaudio(const std::string& id, const Json::Value if (context_ == nullptr) { throw std::runtime_error("pa_context_new() failed."); } - if (pa_context_connect(context_, nullptr, PA_CONTEXT_NOAUTOSPAWN, - nullptr) < 0) { - auto err = fmt::format("pa_context_connect() failed: {}", - pa_strerror(pa_context_errno(context_))); + if (pa_context_connect(context_, nullptr, PA_CONTEXT_NOAUTOSPAWN, nullptr) < 0) { + auto err = + fmt::format("pa_context_connect() failed: {}", pa_strerror(pa_context_errno(context_))); throw std::runtime_error(err); } pa_context_set_state_callback(context_, contextStateCb, this); @@ -38,11 +37,9 @@ waybar::modules::Pulseaudio::Pulseaudio(const std::string& id, const Json::Value // define the pulse scroll events only when no user provided // events are configured - if (!config["on-scroll-up"].isString() && - !config["on-scroll-down"].isString()) { + if (!config["on-scroll-up"].isString() && !config["on-scroll-down"].isString()) { event_box_.add_events(Gdk::SCROLL_MASK | Gdk::SMOOTH_SCROLL_MASK); - event_box_.signal_scroll_event().connect( - sigc::mem_fun(*this, &Pulseaudio::handleScroll)); + event_box_.signal_scroll_event().connect(sigc::mem_fun(*this, &Pulseaudio::handleScroll)); } } @@ -52,8 +49,7 @@ waybar::modules::Pulseaudio::~Pulseaudio() { pa_threaded_mainloop_free(mainloop_); } -void waybar::modules::Pulseaudio::contextStateCb(pa_context *c, void *data) -{ +void waybar::modules::Pulseaudio::contextStateCb(pa_context *c, void *data) { auto pa = static_cast(data); switch (pa_context_get_state(c)) { case PA_CONTEXT_TERMINATED: @@ -77,8 +73,8 @@ void waybar::modules::Pulseaudio::contextStateCb(pa_context *c, void *data) bool waybar::modules::Pulseaudio::handleScroll(GdkEventScroll *e) { // Avoid concurrent scroll event - bool direction_up = false; - uint16_t change = config_["scroll-step"].isUInt() ? config_["scroll-step"].asUInt() * 100 : 100; + bool direction_up = false; + uint16_t change = config_["scroll-step"].isUInt() ? config_["scroll-step"].asUInt() * 100 : 100; pa_cvolume pa_volume = pa_volume_; if (scrolling_) { @@ -94,8 +90,7 @@ bool waybar::modules::Pulseaudio::handleScroll(GdkEventScroll *e) { if (e->direction == GDK_SCROLL_SMOOTH) { gdouble delta_x, delta_y; - gdk_event_get_scroll_deltas(reinterpret_cast(e), &delta_x, - &delta_y); + gdk_event_get_scroll_deltas(reinterpret_cast(e), &delta_x, &delta_y); if (delta_y < 0) { direction_up = true; } else if (delta_y > 0) { @@ -109,8 +104,7 @@ bool waybar::modules::Pulseaudio::handleScroll(GdkEventScroll *e) { if (volume_ - 1 > 0) pa_cvolume_dec(&pa_volume, change); } - pa_context_set_sink_volume_by_index(context_, sink_idx_, &pa_volume, - volumeModifyCb, this); + pa_context_set_sink_volume_by_index(context_, sink_idx_, &pa_volume, volumeModifyCb, this); return true; } @@ -118,43 +112,39 @@ bool waybar::modules::Pulseaudio::handleScroll(GdkEventScroll *e) { /* * Called when an event we subscribed to occurs. */ -void waybar::modules::Pulseaudio::subscribeCb(pa_context* context, - pa_subscription_event_type_t type, uint32_t idx, void* data) -{ +void waybar::modules::Pulseaudio::subscribeCb(pa_context * context, + pa_subscription_event_type_t type, uint32_t idx, + void *data) { unsigned facility = type & PA_SUBSCRIPTION_EVENT_FACILITY_MASK; switch (facility) { case PA_SUBSCRIPTION_EVENT_SINK: - pa_context_get_sink_info_by_index(context, idx, sinkInfoCb, data); - break; + pa_context_get_sink_info_by_index(context, idx, sinkInfoCb, data); + break; default: - break; + break; } } /* * Called in response to a volume change request */ -void waybar::modules::Pulseaudio::volumeModifyCb(pa_context *c, int success, - void *data) { +void waybar::modules::Pulseaudio::volumeModifyCb(pa_context *c, int success, void *data) { auto pa = static_cast(data); if (success) { - pa_context_get_sink_info_by_index(pa->context_, pa->sink_idx_, sinkInfoCb, - data); + pa_context_get_sink_info_by_index(pa->context_, pa->sink_idx_, sinkInfoCb, data); } } /* * Called when the requested sink information is ready. */ -void waybar::modules::Pulseaudio::sinkInfoCb(pa_context * /*context*/, - const pa_sink_info *i, int /*eol*/, - void *data) { +void waybar::modules::Pulseaudio::sinkInfoCb(pa_context * /*context*/, const pa_sink_info *i, + int /*eol*/, void * data) { if (i != nullptr) { auto pa = static_cast(data); pa->pa_volume_ = i->volume; - float volume = static_cast(pa_cvolume_avg(&(pa->pa_volume_))) / - float{PA_VOLUME_NORM}; + float volume = static_cast(pa_cvolume_avg(&(pa->pa_volume_))) / float{PA_VOLUME_NORM}; pa->sink_idx_ = i->index; pa->volume_ = std::round(volume * 100.0f); pa->muted_ = i->mute != 0; @@ -168,30 +158,27 @@ void waybar::modules::Pulseaudio::sinkInfoCb(pa_context * /*context*/, * Called when the requested information on the server is ready. This is * used to find the default PulseAudio sink. */ -void waybar::modules::Pulseaudio::serverInfoCb(pa_context *context, - const pa_server_info *i, void *data) -{ - pa_context_get_sink_info_by_name(context, i->default_sink_name, - sinkInfoCb, data); +void waybar::modules::Pulseaudio::serverInfoCb(pa_context *context, const pa_server_info *i, + void *data) { + pa_context_get_sink_info_by_name(context, i->default_sink_name, sinkInfoCb, data); } static const std::array ports = { - "headphones", - "speaker", - "hdmi", - "headset", - "handsfree", - "portable", - "car", - "hifi", - "phone", + "headphones", + "speaker", + "hdmi", + "headset", + "handsfree", + "portable", + "car", + "hifi", + "phone", }; -const std::string waybar::modules::Pulseaudio::getPortIcon() const -{ +const std::string waybar::modules::Pulseaudio::getPortIcon() const { std::string nameLC = port_name_; std::transform(nameLC.begin(), nameLC.end(), nameLC.begin(), ::tolower); - for (auto const& port : ports) { + for (auto const &port : ports) { if (nameLC.find(port) != std::string::npos) { return port; } @@ -199,26 +186,23 @@ const std::string waybar::modules::Pulseaudio::getPortIcon() const return port_name_; } -auto waybar::modules::Pulseaudio::update() -> void -{ +auto waybar::modules::Pulseaudio::update() -> void { auto format = format_; if (muted_) { - format = - config_["format-muted"].isString() ? config_["format-muted"].asString() : format; + format = config_["format-muted"].isString() ? config_["format-muted"].asString() : format; label_.get_style_context()->add_class("muted"); } else { label_.get_style_context()->remove_class("muted"); if (port_name_.find("a2dp_sink") != std::string::npos) { - format = config_["format-bluetooth"].isString() - ? config_["format-bluetooth"].asString() : format; + format = + config_["format-bluetooth"].isString() ? config_["format-bluetooth"].asString() : format; label_.get_style_context()->add_class("bluetooth"); } else { label_.get_style_context()->remove_class("bluetooth"); } } - label_.set_markup( - fmt::format(format, fmt::arg("volume", volume_), - fmt::arg("icon", getIcon(volume_, getPortIcon())))); + label_.set_markup(fmt::format( + format, fmt::arg("volume", volume_), fmt::arg("icon", getIcon(volume_, getPortIcon())))); if (tooltipEnabled()) { label_.set_tooltip_text(desc_); } diff --git a/src/modules/sni/host.cpp b/src/modules/sni/host.cpp index e12d0bc..2be0ba8 100644 --- a/src/modules/sni/host.cpp +++ b/src/modules/sni/host.cpp @@ -16,10 +16,23 @@ Host::Host(const std::size_t id, const Json::Value& config, on_add_(on_add), on_remove_(on_remove) {} -Host::~Host() { Gio::DBus::unwatch_name(bus_name_id_); } +Host::~Host() { + if (bus_name_id_ > 0) { + Gio::DBus::unwatch_name(bus_name_id_); + bus_name_id_ = 0; + } + if (watcher_id_ > 0) { + Gio::DBus::unwatch_name(watcher_id_); + watcher_id_ = 0; + } + g_cancellable_cancel(cancellable_); + g_clear_object(&cancellable_); + g_clear_object(&watcher_); +} void Host::busAcquired(const Glib::RefPtr& conn, Glib::ustring name) { - watcher_id_ = Gio::DBus::watch_name(conn, "org.kde.StatusNotifierWatcher", + watcher_id_ = Gio::DBus::watch_name(conn, + "org.kde.StatusNotifierWatcher", sigc::mem_fun(*this, &Host::nameAppeared), sigc::mem_fun(*this, &Host::nameVanished)); } @@ -31,8 +44,13 @@ void Host::nameAppeared(const Glib::RefPtr& conn, const G return; } cancellable_ = g_cancellable_new(); - sn_watcher_proxy_new(conn->gobj(), G_DBUS_PROXY_FLAGS_NONE, "org.kde.StatusNotifierWatcher", - "/StatusNotifierWatcher", cancellable_, &Host::proxyReady, this); + sn_watcher_proxy_new(conn->gobj(), + G_DBUS_PROXY_FLAGS_NONE, + "org.kde.StatusNotifierWatcher", + "/StatusNotifierWatcher", + cancellable_, + &Host::proxyReady, + this); } void Host::nameVanished(const Glib::RefPtr& conn, const Glib::ustring name) { @@ -43,7 +61,7 @@ void Host::nameVanished(const Glib::RefPtr& conn, const G } void Host::proxyReady(GObject* src, GAsyncResult* res, gpointer data) { - GError* error = nullptr; + GError* error = nullptr; SnWatcher* watcher = sn_watcher_proxy_new_finish(res, &error); if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { std::cerr << error->message << std::endl; @@ -57,8 +75,8 @@ void Host::proxyReady(GObject* src, GAsyncResult* res, gpointer data) { g_error_free(error); return; } - sn_watcher_call_register_host(host->watcher_, host->object_path_.c_str(), host->cancellable_, - &Host::registerHost, data); + sn_watcher_call_register_host( + host->watcher_, host->object_path_.c_str(), host->cancellable_, &Host::registerHost, data); } void Host::registerHost(GObject* src, GAsyncResult* res, gpointer data) { diff --git a/src/modules/sni/item.cpp b/src/modules/sni/item.cpp index cb2e6d7..601f835 100644 --- a/src/modules/sni/item.cpp +++ b/src/modules/sni/item.cpp @@ -5,7 +5,7 @@ using namespace Glib; -static const ustring SNI_INTERFACE_NAME = sn_item_interface_info()->name; +static const ustring SNI_INTERFACE_NAME = sn_item_interface_info()->name; static const unsigned UPDATE_DEBOUNCE_TIME = 10; waybar::modules::SNI::Item::Item(std::string bn, std::string op, const Json::Value& config) @@ -25,9 +25,13 @@ waybar::modules::SNI::Item::Item(std::string bn, std::string op, const Json::Val cancellable_ = Gio::Cancellable::create(); auto interface = Glib::wrap(sn_item_interface_info(), true); - Gio::DBus::Proxy::create_for_bus(Gio::DBus::BusType::BUS_TYPE_SESSION, bus_name, object_path, - SNI_INTERFACE_NAME, sigc::mem_fun(*this, &Item::proxyReady), - cancellable_, interface); + Gio::DBus::Proxy::create_for_bus(Gio::DBus::BusType::BUS_TYPE_SESSION, + bus_name, + object_path, + SNI_INTERFACE_NAME, + sigc::mem_fun(*this, &Item::proxyReady), + cancellable_, + interface); } void waybar::modules::SNI::Item::proxyReady(Glib::RefPtr& result) { @@ -52,10 +56,14 @@ void waybar::modules::SNI::Item::proxyReady(Glib::RefPtr& resu // this->event_box.set_tooltip_text(this->title); } catch (const Glib::Error& err) { - g_error("Failed to create DBus Proxy for %s %s: %s", bus_name.c_str(), object_path.c_str(), + g_error("Failed to create DBus Proxy for %s %s: %s", + bus_name.c_str(), + object_path.c_str(), err.what().c_str()); } catch (const std::exception& err) { - g_error("Failed to create DBus Proxy for %s %s: %s", bus_name.c_str(), object_path.c_str(), + g_error("Failed to create DBus Proxy for %s %s: %s", + bus_name.c_str(), + object_path.c_str(), err.what()); } } @@ -109,7 +117,8 @@ void waybar::modules::SNI::Item::getUpdatedProperties() { auto params = VariantContainerBase::create_tuple({Variant::create(SNI_INTERFACE_NAME)}); proxy_->call("org.freedesktop.DBus.Properties.GetAll", - sigc::mem_fun(*this, &Item::processUpdatedProperties), params); + sigc::mem_fun(*this, &Item::processUpdatedProperties), + params); }; void waybar::modules::SNI::Item::processUpdatedProperties(Glib::RefPtr& _result) { @@ -159,11 +168,11 @@ Glib::RefPtr waybar::modules::SNI::Item::extractPixBuf(GVariant* va return Glib::RefPtr{}; } GVariant* val; - gint lwidth = 0; - gint lheight = 0; - gint width; - gint height; - guchar* array = nullptr; + gint lwidth = 0; + gint lheight = 0; + gint width; + gint height; + guchar* array = nullptr; while (g_variant_iter_loop(it, "(ii@ay)", &width, &height, &val)) { if (width > 0 && height > 0 && val != nullptr && width * height > lwidth * lheight) { auto size = g_variant_get_size(val); @@ -192,8 +201,14 @@ Glib::RefPtr waybar::modules::SNI::Item::extractPixBuf(GVariant* va array[i + 2] = array[i + 3]; array[i + 3] = alpha; } - return Gdk::Pixbuf::create_from_data(array, Gdk::Colorspace::COLORSPACE_RGB, true, 8, lwidth, - lheight, 4 * lwidth, &pixbuf_data_deleter); + return Gdk::Pixbuf::create_from_data(array, + Gdk::Colorspace::COLORSPACE_RGB, + true, + 8, + lwidth, + lheight, + 4 * lwidth, + &pixbuf_data_deleter); } return Glib::RefPtr{}; } @@ -230,7 +245,7 @@ void waybar::modules::SNI::Item::updateImage() { } Glib::RefPtr waybar::modules::SNI::Item::getIconByName(std::string name, - int request_size) { + int request_size) { int tmp_size = 0; icon_theme->rescan_if_needed(); auto sizes = icon_theme->get_icon_sizes(name.c_str()); @@ -250,15 +265,16 @@ Glib::RefPtr waybar::modules::SNI::Item::getIconByName(std::string if (tmp_size == 0) { tmp_size = request_size; } - auto icon = - icon_theme->load_icon(name.c_str(), tmp_size, Gtk::IconLookupFlags::ICON_LOOKUP_FORCE_SIZE); - if (!icon) { - Glib::RefPtr default_theme = Gtk::IconTheme::get_default(); - default_theme->rescan_if_needed(); - return default_theme->load_icon(name.c_str(), tmp_size, - Gtk::IconLookupFlags::ICON_LOOKUP_FORCE_SIZE); + if (!icon_theme_path.empty() && + icon_theme->lookup_icon( + name.c_str(), tmp_size, Gtk::IconLookupFlags::ICON_LOOKUP_FORCE_SIZE)) { + return icon_theme->load_icon( + name.c_str(), tmp_size, Gtk::IconLookupFlags::ICON_LOOKUP_FORCE_SIZE); } - return icon; + Glib::RefPtr default_theme = Gtk::IconTheme::get_default(); + default_theme->rescan_if_needed(); + return default_theme->load_icon( + name.c_str(), tmp_size, Gtk::IconLookupFlags::ICON_LOOKUP_FORCE_SIZE); } void waybar::modules::SNI::Item::onMenuDestroyed(Item* self) { diff --git a/src/modules/sni/tray.cpp b/src/modules/sni/tray.cpp index 746656a..c2578aa 100644 --- a/src/modules/sni/tray.cpp +++ b/src/modules/sni/tray.cpp @@ -8,7 +8,6 @@ waybar::modules::SNI::Tray::Tray(const std::string& id, const Bar& bar, const Js watcher_(), host_(nb_hosts_, config, std::bind(&Tray::onAdd, this, std::placeholders::_1), std::bind(&Tray::onRemove, this, std::placeholders::_1)) { - std::cout << "Tray is in beta, so there may be bugs or even be unusable." << std::endl; if (config_["spacing"].isUInt()) { box_.set_spacing(config_["spacing"].asUInt()); } diff --git a/src/modules/sni/watcher.cpp b/src/modules/sni/watcher.cpp index 24050d5..366526f 100644 --- a/src/modules/sni/watcher.cpp +++ b/src/modules/sni/watcher.cpp @@ -28,23 +28,22 @@ Watcher::~Watcher() { g_slist_free_full(items_, gfWatchFree); items_ = NULL; } - g_signal_handler_disconnect(watcher_, handler_host_id_); - g_signal_handler_disconnect(watcher_, handler_item_id_); + g_dbus_interface_skeleton_unexport(G_DBUS_INTERFACE_SKELETON(watcher_)); } void Watcher::busAcquired(const Glib::RefPtr& conn, Glib::ustring name) { GError* error = nullptr; - g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(watcher_), conn->gobj(), - "/StatusNotifierWatcher", &error); + g_dbus_interface_skeleton_export( + G_DBUS_INTERFACE_SKELETON(watcher_), conn->gobj(), "/StatusNotifierWatcher", &error); if (error != nullptr) { std::cerr << error->message << std::endl; g_error_free(error); return; } - handler_item_id_ = g_signal_connect_swapped(watcher_, "handle-register-item", - G_CALLBACK(&Watcher::handleRegisterItem), this); - handler_host_id_ = g_signal_connect_swapped(watcher_, "handle-register-host", - G_CALLBACK(&Watcher::handleRegisterHost), this); + g_signal_connect_swapped( + watcher_, "handle-register-item", G_CALLBACK(&Watcher::handleRegisterItem), this); + g_signal_connect_swapped( + watcher_, "handle-register-host", G_CALLBACK(&Watcher::handleRegisterHost), this); } gboolean Watcher::handleRegisterHost(Watcher* obj, GDBusMethodInvocation* invocation, @@ -57,16 +56,22 @@ gboolean Watcher::handleRegisterHost(Watcher* obj, GDBusMethodInvocation* invoca object_path = service; } if (g_dbus_is_name(bus_name) == FALSE) { - g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, - "D-Bus bus name '%s' is not valid", bus_name); + g_dbus_method_invocation_return_error(invocation, + G_DBUS_ERROR, + G_DBUS_ERROR_INVALID_ARGS, + "D-Bus bus name '%s' is not valid", + bus_name); return TRUE; } auto watch = gfWatchFind(obj->hosts_, bus_name, object_path); if (watch != nullptr) { g_dbus_method_invocation_return_error( - invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, + invocation, + G_DBUS_ERROR, + G_DBUS_ERROR_INVALID_ARGS, "Status Notifier Host with bus name '%s' and object path '%s' is already registered", - bus_name, object_path); + bus_name, + object_path); return TRUE; } watch = gfWatchNew(GF_WATCH_TYPE_HOST, service, bus_name, object_path, obj); @@ -89,14 +94,18 @@ gboolean Watcher::handleRegisterItem(Watcher* obj, GDBusMethodInvocation* invoca object_path = service; } if (g_dbus_is_name(bus_name) == FALSE) { - g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, - "D-Bus bus name '%s' is not valid", bus_name); + g_dbus_method_invocation_return_error(invocation, + G_DBUS_ERROR, + G_DBUS_ERROR_INVALID_ARGS, + "D-Bus bus name '%s' is not valid", + bus_name); return TRUE; } auto watch = gfWatchFind(obj->items_, bus_name, object_path); if (watch != nullptr) { g_warning("Status Notifier Item with bus name '%s' and object path '%s' is already registered", - bus_name, object_path); + bus_name, + object_path); sn_watcher_complete_register_item(obj->watcher_, invocation); return TRUE; } @@ -144,8 +153,13 @@ Watcher::GfWatch* Watcher::gfWatchNew(GfWatchType type, const gchar* service, co watch->service = g_strdup(service); watch->bus_name = g_strdup(bus_name); watch->object_path = g_strdup(object_path); - watch->watch_id = g_bus_watch_name(G_BUS_TYPE_SESSION, bus_name, G_BUS_NAME_WATCHER_FLAGS_NONE, - nullptr, &Watcher::nameVanished, watch, nullptr); + watch->watch_id = g_bus_watch_name(G_BUS_TYPE_SESSION, + bus_name, + G_BUS_NAME_WATCHER_FLAGS_NONE, + nullptr, + &Watcher::nameVanished, + watch, + nullptr); return watch; } @@ -171,11 +185,11 @@ void Watcher::updateRegisteredItems(SnWatcher* obj) { g_variant_builder_init(&builder, G_VARIANT_TYPE("as")); for (GSList* l = items_; l != nullptr; l = g_slist_next(l)) { GfWatch* watch = static_cast(l->data); - gchar* item = g_strdup_printf("%s%s", watch->bus_name, watch->object_path); + gchar* item = g_strdup_printf("%s%s", watch->bus_name, watch->object_path); g_variant_builder_add(&builder, "s", item); g_free(item); } - GVariant* variant = g_variant_builder_end(&builder); + GVariant* variant = g_variant_builder_end(&builder); const gchar** items = g_variant_get_strv(variant, nullptr); sn_watcher_set_registered_items(obj, items); g_variant_unref(variant); diff --git a/src/modules/sway/ipc/client.cpp b/src/modules/sway/ipc/client.cpp index e23c787..eafca41 100644 --- a/src/modules/sway/ipc/client.cpp +++ b/src/modules/sway/ipc/client.cpp @@ -1,33 +1,38 @@ #include "modules/sway/ipc/client.hpp" +#include -waybar::modules::sway::Ipc::Ipc() -{ +namespace waybar::modules::sway { + +Ipc::Ipc() { const std::string& socketPath = getSocketPath(); fd_ = open(socketPath); fd_event_ = open(socketPath); } -waybar::modules::sway::Ipc::~Ipc() -{ +Ipc::~Ipc() { // To fail the IPC header write(fd_, "close-sway-ipc", 14); write(fd_event_, "close-sway-ipc", 14); - - close(fd_); - close(fd_event_); + if (fd_ > 0) { + close(fd_); + fd_ = -1; + } + if (fd_event_ > 0) { + close(fd_event_); + fd_event_ = -1; + } } -const std::string waybar::modules::sway::Ipc::getSocketPath() const -{ - const char *env = getenv("SWAYSOCK"); +const std::string Ipc::getSocketPath() const { + const char* env = getenv("SWAYSOCK"); if (env != nullptr) { return std::string(env); } std::string str; { std::string str_buf; - FILE* in; - char buf[512] = { 0 }; + FILE* in; + char buf[512] = {0}; if ((in = popen("sway --get-socketpath 2>/dev/null", "r")) == nullptr) { throw std::runtime_error("Failed to get socket path"); } @@ -36,6 +41,9 @@ const std::string waybar::modules::sway::Ipc::getSocketPath() const } pclose(in); str = str_buf; + if (str.empty()) { + throw std::runtime_error("Socket path is empty"); + } } if (str.back() == '\n') { str.pop_back(); @@ -43,39 +51,41 @@ const std::string waybar::modules::sway::Ipc::getSocketPath() const return str; } -int waybar::modules::sway::Ipc::open(const std::string& socketPath) const -{ - struct sockaddr_un addr = {0}; - int fd = -1; - if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) { +int Ipc::open(const std::string& socketPath) const { + int32_t fd = socket(AF_UNIX, SOCK_STREAM, 0); + if (fd == -1) { throw std::runtime_error("Unable to open Unix socket"); } + (void)fcntl(fd, F_SETFD, FD_CLOEXEC); + struct sockaddr_un addr; + memset(&addr, 0, sizeof(struct sockaddr_un)); addr.sun_family = AF_UNIX; strncpy(addr.sun_path, socketPath.c_str(), sizeof(addr.sun_path) - 1); addr.sun_path[sizeof(addr.sun_path) - 1] = 0; int l = sizeof(struct sockaddr_un); - if (::connect(fd, reinterpret_cast(&addr), l) == -1) { + if (::connect(fd, reinterpret_cast(&addr), l) == -1) { throw std::runtime_error("Unable to connect to Sway"); } return fd; } -struct waybar::modules::sway::Ipc::ipc_response - waybar::modules::sway::Ipc::recv(int fd) const -{ +struct Ipc::ipc_response Ipc::recv(int fd) { std::string header; header.resize(ipc_header_size_); - auto data32 = reinterpret_cast(header.data() + ipc_magic_.size()); + auto data32 = reinterpret_cast(header.data() + ipc_magic_.size()); size_t total = 0; while (total < ipc_header_size_) { auto res = ::recv(fd, header.data() + total, ipc_header_size_ - total, 0); + if (fd_event_ == -1 || fd_ == -1) { + // IPC is closed so just return an empty response + return {0, 0, ""}; + } if (res <= 0) { throw std::runtime_error("Unable to receive IPC header"); } total += res; } - auto magic = std::string(header.data(), header.data() + ipc_magic_.size()); if (magic != ipc_magic_) { throw std::runtime_error("Invalid IPC magic"); @@ -91,16 +101,13 @@ struct waybar::modules::sway::Ipc::ipc_response } total += res; } - return { data32[0], data32[1], &payload.front() }; + return {data32[0], data32[1], &payload.front()}; } -struct waybar::modules::sway::Ipc::ipc_response - waybar::modules::sway::Ipc::send(int fd, uint32_t type, - const std::string& payload) const -{ +struct Ipc::ipc_response Ipc::send(int fd, uint32_t type, const std::string& payload) { std::string header; header.resize(ipc_header_size_); - auto data32 = reinterpret_cast(header.data() + ipc_magic_.size()); + auto data32 = reinterpret_cast(header.data() + ipc_magic_.size()); memcpy(header.data(), ipc_magic_.c_str(), ipc_magic_.size()); data32[0] = payload.size(); data32[1] = type; @@ -111,26 +118,27 @@ struct waybar::modules::sway::Ipc::ipc_response if (::send(fd, payload.c_str(), payload.size(), 0) == -1) { throw std::runtime_error("Unable to send IPC payload"); } - return recv(fd); + return Ipc::recv(fd); } -struct waybar::modules::sway::Ipc::ipc_response - waybar::modules::sway::Ipc::sendCmd(uint32_t type, - const std::string& payload) const -{ - return send(fd_, type, payload); +void Ipc::sendCmd(uint32_t type, const std::string& payload) { + std::lock_guard lock(mutex_); + const auto res = Ipc::send(fd_, type, payload); + signal_cmd.emit(res); } -void waybar::modules::sway::Ipc::subscribe(const std::string& payload) const -{ - auto res = send(fd_event_, IPC_SUBSCRIBE, payload); +void Ipc::subscribe(const std::string& payload) { + std::lock_guard lock(mutex_event_); + auto res = Ipc::send(fd_event_, IPC_SUBSCRIBE, payload); if (res.payload != "{\"success\": true}") { throw std::runtime_error("Unable to subscribe ipc event"); } } -struct waybar::modules::sway::Ipc::ipc_response - waybar::modules::sway::Ipc::handleEvent() const -{ - return recv(fd_event_); +void Ipc::handleEvent() { + std::lock_guard lock(mutex_event_); + const auto res = Ipc::recv(fd_event_); + signal_event.emit(res); } + +} // namespace waybar::modules::sway \ No newline at end of file diff --git a/src/modules/sway/mode.cpp b/src/modules/sway/mode.cpp index c4b4735..f43f929 100644 --- a/src/modules/sway/mode.cpp +++ b/src/modules/sway/mode.cpp @@ -1,38 +1,41 @@ #include "modules/sway/mode.hpp" -waybar::modules::sway::Mode::Mode(const std::string& id, const Bar& bar, const Json::Value& config) - : ALabel(config, "{}"), bar_(bar) -{ +namespace waybar::modules::sway { + +Mode::Mode(const std::string& id, const Bar& bar, const Json::Value& config) + : ALabel(config, "{}"), bar_(bar) { label_.set_name("mode"); if (!id.empty()) { label_.get_style_context()->add_class(id); } ipc_.subscribe("[ \"mode\" ]"); + ipc_.signal_event.connect(sigc::mem_fun(*this, &Mode::onEvent)); // Launch worker worker(); dp.emit(); } -void waybar::modules::sway::Mode::worker() -{ +void Mode::onEvent(const struct Ipc::ipc_response res) { + auto parsed = parser_.parse(res.payload); + if (parsed["change"] != "default") { + mode_ = parsed["change"].asString(); + } else { + mode_.clear(); + } + dp.emit(); +} + +void Mode::worker() { thread_ = [this] { try { - auto res = ipc_.handleEvent(); - auto parsed = parser_.parse(res.payload); - if (parsed["change"] != "default") { - mode_ = parsed["change"].asString(); - } else { - mode_.clear(); - } - dp.emit(); + ipc_.handleEvent(); } catch (const std::exception& e) { std::cerr << "Mode: " << e.what() << std::endl; } }; } -auto waybar::modules::sway::Mode::update() -> void -{ +auto Mode::update() -> void { if (mode_.empty()) { event_box_.hide(); } else { @@ -42,4 +45,6 @@ auto waybar::modules::sway::Mode::update() -> void } event_box_.show(); } -} \ No newline at end of file +} + +} // namespace waybar::modules::sway \ No newline at end of file diff --git a/src/modules/sway/window.cpp b/src/modules/sway/window.cpp index aa54978..7173fec 100644 --- a/src/modules/sway/window.cpp +++ b/src/modules/sway/window.cpp @@ -1,8 +1,9 @@ #include "modules/sway/window.hpp" -waybar::modules::sway::Window::Window(const std::string& id, const Bar &bar, const Json::Value& config) - : ALabel(config, "{}"), bar_(bar), windowId_(-1) -{ +namespace waybar::modules::sway { + +Window::Window(const std::string& id, const Bar& bar, const Json::Value& config) + : ALabel(config, "{}"), bar_(bar), windowId_(-1) { label_.set_name("window"); if (!id.empty()) { label_.get_style_context()->add_class(id); @@ -12,72 +13,76 @@ waybar::modules::sway::Window::Window(const std::string& id, const Bar &bar, con label_.set_ellipsize(Pango::EllipsizeMode::ELLIPSIZE_END); } ipc_.subscribe("[\"window\",\"workspace\"]"); + ipc_.signal_event.connect(sigc::mem_fun(*this, &Window::onEvent)); + ipc_.signal_cmd.connect(sigc::mem_fun(*this, &Window::onCmd)); getFocusedWindow(); // Launch worker worker(); } -void waybar::modules::sway::Window::worker() -{ +void Window::onEvent(const struct Ipc::ipc_response res) { + auto parsed = parser_.parse(res.payload); + // Check for waybar prevents flicker when hovering window module + if ((parsed["change"] == "focus" || parsed["change"] == "title") && + parsed["container"]["focused"].asBool() && + parsed["container"]["name"].asString() != "waybar") { + window_ = Glib::Markup::escape_text(parsed["container"]["name"].asString()); + windowId_ = parsed["container"]["id"].asInt(); + dp.emit(); + } else if ((parsed["change"] == "close" && parsed["container"]["focused"].asBool() && + windowId_ == parsed["container"]["id"].asInt()) || + (parsed["change"] == "focus" && parsed["current"]["focus"].isArray() && + parsed["current"]["focus"].empty())) { + window_.clear(); + windowId_ = -1; + dp.emit(); + } +} + +void Window::onCmd(const struct Ipc::ipc_response res) { + auto parsed = parser_.parse(res.payload); + auto [id, name] = getFocusedNode(parsed["nodes"]); + windowId_ = id; + window_ = name; + dp.emit(); +} + +void Window::worker() { thread_ = [this] { try { - auto res = ipc_.handleEvent(); - auto parsed = parser_.parse(res.payload); - // Check for waybar prevents flicker when hovering window module - if ((parsed["change"] == "focus" || parsed["change"] == "title") - && parsed["container"]["focused"].asBool() - && parsed["container"]["name"].asString() != "waybar") { - window_ = Glib::Markup::escape_text(parsed["container"]["name"].asString()); - windowId_ = parsed["container"]["id"].asInt(); - dp.emit(); - } else if ((parsed["change"] == "close" - && parsed["container"]["focused"].asBool() - && windowId_ == parsed["container"]["id"].asInt()) - || (parsed["change"] == "focus" && parsed["current"]["focus"].isArray() - && parsed["current"]["focus"].empty())) { - window_.clear(); - windowId_ = -1; - dp.emit(); - } + ipc_.handleEvent(); } catch (const std::exception& e) { std::cerr << "Window: " << e.what() << std::endl; } }; } -auto waybar::modules::sway::Window::update() -> void -{ +auto Window::update() -> void { label_.set_markup(fmt::format(format_, window_)); if (tooltipEnabled()) { label_.set_tooltip_text(window_); } } -std::tuple waybar::modules::sway::Window::getFocusedNode( - Json::Value nodes) -{ +std::tuple Window::getFocusedNode(Json::Value nodes) { for (auto const& node : nodes) { if (node["focused"].asBool() && node["type"] == "con") { - return { node["id"].asInt(), node["name"].asString() }; + return {node["id"].asInt(), node["name"].asString()}; } auto [id, name] = getFocusedNode(node["nodes"]); if (id > -1 && !name.empty()) { - return { id, name }; + return {id, name}; } } - return { -1, std::string() }; + return {-1, std::string()}; } -void waybar::modules::sway::Window::getFocusedWindow() -{ +void Window::getFocusedWindow() { try { - auto res = ipc_.sendCmd(IPC_GET_TREE); - auto parsed = parser_.parse(res.payload); - auto [id, name] = getFocusedNode(parsed["nodes"]); - windowId_ = id; - window_ = name; - Glib::signal_idle().connect_once(sigc::mem_fun(*this, &Window::update)); - } catch (const std::exception &e) { + ipc_.sendCmd(IPC_GET_TREE); + } catch (const std::exception& e) { std::cerr << e.what() << std::endl; } } + +} // namespace waybar::modules::sway \ No newline at end of file diff --git a/src/modules/sway/workspaces.cpp b/src/modules/sway/workspaces.cpp index 3f1bcef..b3ebeef 100644 --- a/src/modules/sway/workspaces.cpp +++ b/src/modules/sway/workspaces.cpp @@ -1,154 +1,138 @@ #include "modules/sway/workspaces.hpp" -waybar::modules::sway::Workspaces::Workspaces(const std::string& id, const Bar& bar, - const Json::Value& config) - : bar_(bar), config_(config), - box_(bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0), - scrolling_(false) -{ +namespace waybar::modules::sway { + +Workspaces::Workspaces(const std::string &id, const Bar &bar, const Json::Value &config) + : bar_(bar), + config_(config), + box_(bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0), + scrolling_(false) { box_.set_name("workspaces"); if (!id.empty()) { box_.get_style_context()->add_class(id); } ipc_.subscribe("[ \"workspace\" ]"); + ipc_.signal_event.connect(sigc::mem_fun(*this, &Workspaces::onEvent)); + ipc_.signal_cmd.connect(sigc::mem_fun(*this, &Workspaces::onCmd)); + ipc_.sendCmd(IPC_GET_WORKSPACES); // Launch worker worker(); } -void waybar::modules::sway::Workspaces::worker() -{ +void Workspaces::onEvent(const struct Ipc::ipc_response res) { ipc_.sendCmd(IPC_GET_WORKSPACES); } + +void Workspaces::onCmd(const struct Ipc::ipc_response res) { + if (res.type == IPC_GET_WORKSPACES) { + auto workspaces = parser_.parse(res.payload); + workspaces_.clear(); + std::copy_if(workspaces.begin(), + workspaces.end(), + std::back_inserter(workspaces_), + [&](const auto &workspace) { + return !config_["all-outputs"].asBool() + ? workspace["output"].asString() == bar_.output->name + : true; + }); + dp.emit(); + } else { + if (scrolling_) { + scrolling_ = false; + } + } +} + +void Workspaces::worker() { thread_ = [this] { try { - if (!workspaces_.empty()) { - ipc_.handleEvent(); - } - { - std::lock_guard lock(mutex_); - auto res = ipc_.sendCmd(IPC_GET_WORKSPACES); - if (thread_.isRunning()) { - workspaces_ = parser_.parse(res.payload); - } - } - dp.emit(); - } catch (const std::exception& e) { + ipc_.handleEvent(); + } catch (const std::exception &e) { std::cerr << "Workspaces: " << e.what() << std::endl; } }; } -auto waybar::modules::sway::Workspaces::update() -> void -{ +bool Workspaces::filterButtons() { bool needReorder = false; - std::lock_guard lock(mutex_); for (auto it = buttons_.begin(); it != buttons_.end();) { - auto ws = std::find_if(workspaces_.begin(), workspaces_.end(), - [it](auto node) -> bool { return node["name"].asString() == it->first; }); + auto ws = std::find_if(workspaces_.begin(), workspaces_.end(), [it](const auto &node) { + return node["name"].asString() == it->first; + }); if (ws == workspaces_.end() || - (!config_["all-outputs"].asBool() && (*ws)["output"].asString() != bar_.output_name)) { + (!config_["all-outputs"].asBool() && (*ws)["output"].asString() != bar_.output->name)) { it = buttons_.erase(it); needReorder = true; } else { ++it; } } - for (auto const& node : workspaces_) { - if (!config_["all-outputs"].asBool() - && bar_.output_name != node["output"].asString()) { - continue; - } - auto it = buttons_.find(node["name"].asString()); - if (it == buttons_.end()) { - addWorkspace(node); + return needReorder; +} + +auto Workspaces::update() -> void { + bool needReorder = filterButtons(); + for (auto it = workspaces_.begin(); it != workspaces_.end(); ++it) { + auto bit = buttons_.find((*it)["name"].asString()); + if (bit == buttons_.end()) { needReorder = true; - } else { - auto &button = it->second; - if (node["focused"].asBool()) { - button.get_style_context()->add_class("focused"); - } else { - button.get_style_context()->remove_class("focused"); - } - if (node["visible"].asBool()) { - button.get_style_context()->add_class("visible"); - } else { - button.get_style_context()->remove_class("visible"); - } - if (node["urgent"].asBool()) { - button.get_style_context()->add_class("urgent"); - } else { - button.get_style_context()->remove_class("urgent"); - } - if (needReorder) { - box_.reorder_child(button, getWorkspaceIndex(node["name"].asString())); - } - auto icon = getIcon(node["name"].asString(), node); - std::string output = icon; - if (config_["format"].isString()) { - auto format = config_["format"].asString(); - output = fmt::format(format, fmt::arg("icon", icon), - fmt::arg("name", trimWorkspaceName(node["name"].asString())), - fmt::arg("index", node["num"].asString())); - } - if (!config_["disable-markup"].asBool()) { - static_cast(button.get_children()[0])->set_markup(output); - } else { - button.set_label(output); - } - onButtonReady(node, button); } - } - if (scrolling_) { - scrolling_ = false; + auto &button = bit == buttons_.end() ? addButton(*it) : bit->second; + if ((*it)["focused"].asBool()) { + button.get_style_context()->add_class("focused"); + } else { + button.get_style_context()->remove_class("focused"); + } + if ((*it)["visible"].asBool()) { + button.get_style_context()->add_class("visible"); + } else { + button.get_style_context()->remove_class("visible"); + } + if ((*it)["urgent"].asBool()) { + button.get_style_context()->add_class("urgent"); + } else { + button.get_style_context()->remove_class("urgent"); + } + if (needReorder) { + box_.reorder_child(button, it - workspaces_.begin()); + } + std::string output = getIcon((*it)["name"].asString(), *it); + if (config_["format"].isString()) { + auto format = config_["format"].asString(); + output = fmt::format(format, + fmt::arg("icon", output), + fmt::arg("name", trimWorkspaceName((*it)["name"].asString())), + fmt::arg("index", (*it)["num"].asString())); + } + if (!config_["disable-markup"].asBool()) { + static_cast(button.get_children()[0])->set_markup(output); + } else { + button.set_label(output); + } + onButtonReady(*it, button); } } -void waybar::modules::sway::Workspaces::addWorkspace(const Json::Value &node) -{ - auto icon = getIcon(node["name"].asString(), node); - auto format = config_["format"].isString() - ? fmt::format(config_["format"].asString(), fmt::arg("icon", icon), - fmt::arg("name", trimWorkspaceName(node["name"].asString())), - fmt::arg("index", node["num"].asString())) - : icon; - auto pair = buttons_.emplace(node["name"].asString(), format); +Gtk::Button &Workspaces::addButton(const Json::Value &node) { + auto pair = buttons_.emplace(node["name"].asString(), node["name"].asString()); auto &button = pair.first->second; - if (!config_["disable-markup"].asBool()) { - static_cast(button.get_children()[0])->set_markup(format); - } box_.pack_start(button, false, false, 0); button.set_relief(Gtk::RELIEF_NONE); button.signal_clicked().connect([this, pair] { try { - std::lock_guard lock(mutex_); - auto cmd = fmt::format("workspace \"{}\"", pair.first->first); - ipc_.sendCmd(IPC_COMMAND, cmd); - } catch (const std::exception& e) { + ipc_.sendCmd(IPC_COMMAND, fmt::format("workspace \"{}\"", pair.first->first)); + } catch (const std::exception &e) { std::cerr << e.what() << std::endl; } }); if (!config_["disable-scroll"].asBool()) { button.add_events(Gdk::SCROLL_MASK | Gdk::SMOOTH_SCROLL_MASK); - button.signal_scroll_event() - .connect(sigc::mem_fun(*this, &Workspaces::handleScroll)); + button.signal_scroll_event().connect(sigc::mem_fun(*this, &Workspaces::handleScroll)); } - box_.reorder_child(button, getWorkspaceIndex(node["name"].asString())); - if (node["focused"].asBool()) { - button.get_style_context()->add_class("focused"); - } - if (node["visible"].asBool()) { - button.get_style_context()->add_class("visible"); - } - if (node["urgent"].asBool()) { - button.get_style_context()->add_class("urgent"); - } - - onButtonReady(node, button); + return button; } -std::string waybar::modules::sway::Workspaces::getIcon(const std::string &name, - const Json::Value &node) -{ - std::vector keys = { name, "urgent", "focused", "visible", "default" }; - for (auto const& key : keys) { +std::string Workspaces::getIcon(const std::string &name, const Json::Value &node) { + std::vector keys = {name, "urgent", "focused", "visible", "default"}; + for (auto const &key : keys) { if (key == "focused" || key == "visible" || key == "urgent") { if (config_["format-icons"][key].isString() && node[key].asBool()) { return config_["format-icons"][key].asString(); @@ -160,112 +144,84 @@ std::string waybar::modules::sway::Workspaces::getIcon(const std::string &name, return name; } -bool waybar::modules::sway::Workspaces::handleScroll(GdkEventScroll *e) -{ +bool Workspaces::handleScroll(GdkEventScroll *e) { // Avoid concurrent scroll event if (scrolling_) { return false; } - std::lock_guard lock(mutex_); - uint8_t idx; scrolling_ = true; - for (idx = 0; idx < workspaces_.size(); idx += 1) { - if (workspaces_[idx]["focused"].asBool()) { - break; - } - } - if (idx == workspaces_.size()) { + std::string name; + auto it = std::find_if(workspaces_.begin(), workspaces_.end(), [](const auto &workspace) { + return workspace["focused"].asBool(); + }); + if (it == workspaces_.end()) { scrolling_ = false; return false; } - std::string name; - if (e->direction == GDK_SCROLL_UP) { - name = getCycleWorkspace(idx, true); + switch (e->direction) { + case GDK_SCROLL_DOWN: + case GDK_SCROLL_RIGHT: + name = getCycleWorkspace(it, false); + break; + case GDK_SCROLL_UP: + case GDK_SCROLL_LEFT: + name = getCycleWorkspace(it, true); + break; + case GDK_SCROLL_SMOOTH: + gdouble delta_x, delta_y; + gdk_event_get_scroll_deltas(reinterpret_cast(e), &delta_x, &delta_y); + if (delta_y < 0) { + name = getCycleWorkspace(it, true); + } else if (delta_y > 0) { + name = getCycleWorkspace(it, false); + } + break; + default: + break; } - if (e->direction == GDK_SCROLL_DOWN) { - name = getCycleWorkspace(idx, false); - } - if (e->direction == GDK_SCROLL_SMOOTH) { - gdouble delta_x, delta_y; - gdk_event_get_scroll_deltas(reinterpret_cast(e), - &delta_x, &delta_y); - if (delta_y < 0) { - name = getCycleWorkspace(idx, true); - } else if (delta_y > 0) { - name = getCycleWorkspace(idx, false); - } - } - if (name.empty() || name == workspaces_[idx]["name"].asString()) { + if (name.empty() || name == (*it)["name"].asString()) { scrolling_ = false; return false; } ipc_.sendCmd(IPC_COMMAND, fmt::format("workspace \"{}\"", name)); - std::this_thread::sleep_for(std::chrono::milliseconds(150)); return true; } -const std::string waybar::modules::sway::Workspaces::getCycleWorkspace( - uint8_t focused_workspace, bool prev) const -{ - auto inc = prev ? -1 : 1; - int size = workspaces_.size(); - uint8_t idx = 0; - for (int i = focused_workspace; i < size && i >= 0; i += inc) { - bool same_output = (workspaces_[i]["output"].asString() == bar_.output_name - && !config_["all-outputs"].asBool()) || config_["all-outputs"].asBool(); - bool same_name = - workspaces_[i]["name"].asString() == workspaces_[focused_workspace]["name"].asString(); - if (same_output && !same_name) { - return workspaces_[i]["name"].asString(); - } - if (prev && i - 1 < 0) { - i = size; - } else if (!prev && i + 1 >= size) { - i = -1; - } else if (idx >= workspaces_.size()) { - return ""; - } - idx += 1; +const std::string Workspaces::getCycleWorkspace(std::vector::iterator it, + bool prev) const { + if (prev && it == workspaces_.begin()) { + return (*(--workspaces_.end()))["name"].asString(); } - return ""; + if (prev && it != workspaces_.begin()) + --it; + else if (!prev && it != workspaces_.end()) + ++it; + if (!prev && it == workspaces_.end()) { + return (*(++workspaces_.begin()))["name"].asString(); + } + return (*it)["name"].asString(); } -uint16_t waybar::modules::sway::Workspaces::getWorkspaceIndex(const std::string &name) const -{ - uint16_t idx = 0; - for (const auto &workspace : workspaces_) { - if (workspace["name"].asString() == name) { - return idx; - } - if (!(!config_["all-outputs"].asBool() && workspace["output"].asString() != bar_.output_name)) { - idx += 1; - } - } - return workspaces_.size(); -} - -std::string waybar::modules::sway::Workspaces::trimWorkspaceName(std::string name) -{ +std::string Workspaces::trimWorkspaceName(std::string name) { std::size_t found = name.find(":"); - if (found!=std::string::npos) { - return name.substr(found+1); + if (found != std::string::npos) { + return name.substr(found + 1); } return name; } -void waybar::modules::sway::Workspaces::onButtonReady(const Json::Value& node, Gtk::Button& button) -{ - if (config_["current-only"].asBool()) { - if (node["focused"].asBool()) { - button.show(); - } else { - button.hide(); - } - } else { - button.show(); - } +void Workspaces::onButtonReady(const Json::Value &node, Gtk::Button &button) { + if (config_["current-only"].asBool()) { + if (node["focused"].asBool()) { + button.show(); + } else { + button.hide(); + } + } else { + button.show(); + } } -waybar::modules::sway::Workspaces::operator Gtk::Widget &() { - return box_; -} +Workspaces::operator Gtk::Widget &() { return box_; } + +} // namespace waybar::modules::sway \ No newline at end of file diff --git a/src/modules/temperature.cpp b/src/modules/temperature.cpp index 272c685..72c2880 100644 --- a/src/modules/temperature.cpp +++ b/src/modules/temperature.cpp @@ -1,13 +1,11 @@ #include "modules/temperature.hpp" waybar::modules::Temperature::Temperature(const std::string& id, const Json::Value& config) - : ALabel(config, "{temperatureC}°C", 10) -{ + : ALabel(config, "{temperatureC}°C", 10) { if (config_["hwmon-path"].isString()) { file_path_ = config_["hwmon-path"].asString(); } else { - auto zone = - config_["thermal-zone"].isInt() ? config_["thermal-zone"].asInt() : 0; + auto zone = config_["thermal-zone"].isInt() ? config_["thermal-zone"].asInt() : 0; file_path_ = fmt::format("/sys/class/thermal/thermal_zone{}/temp", zone); } #ifdef FILESYSTEM_EXPERIMENTAL @@ -27,24 +25,21 @@ waybar::modules::Temperature::Temperature(const std::string& id, const Json::Val }; } -auto waybar::modules::Temperature::update() -> void -{ +auto waybar::modules::Temperature::update() -> void { auto [temperature_c, temperature_f] = getTemperature(); auto critical = isCritical(temperature_c); auto format = format_; if (critical) { - format = - config_["format-critical"].isString() ? config_["format-critical"].asString() : format; + format = config_["format-critical"].isString() ? config_["format-critical"].asString() : format; label_.get_style_context()->add_class("critical"); } else { label_.get_style_context()->remove_class("critical"); } - label_.set_markup(fmt::format(format, - fmt::arg("temperatureC", temperature_c), fmt::arg("temperatureF", temperature_f))); + label_.set_markup(fmt::format( + format, fmt::arg("temperatureC", temperature_c), fmt::arg("temperatureF", temperature_f))); } -std::tuple waybar::modules::Temperature::getTemperature() -{ +std::tuple waybar::modules::Temperature::getTemperature() { std::ifstream temp(file_path_); if (!temp.is_open()) { throw std::runtime_error("Can't open " + file_path_); @@ -54,13 +49,13 @@ std::tuple waybar::modules::Temperature::getTemperature() getline(temp, line); } temp.close(); - auto temperature_c = std::strtol(line.c_str(), nullptr, 10) / 1000.0; - auto temperature_f = temperature_c * 1.8 + 32; + auto temperature_c = std::strtol(line.c_str(), nullptr, 10) / 1000.0; + auto temperature_f = temperature_c * 1.8 + 32; std::tuple temperatures(std::round(temperature_c), std::round(temperature_f)); return temperatures; } -bool waybar::modules::Temperature::isCritical(uint16_t temperature_c) -{ - return config_["critical-threshold"].isInt() && temperature_c >= config_["critical-threshold"].asInt(); +bool waybar::modules::Temperature::isCritical(uint16_t temperature_c) { + return config_["critical-threshold"].isInt() && + temperature_c >= config_["critical-threshold"].asInt(); } \ No newline at end of file