From 6ed8f94dabc516394f8f54af990124682a43ebf5 Mon Sep 17 00:00:00 2001 From: Alex Date: Thu, 18 Apr 2019 17:52:00 +0200 Subject: [PATCH] refactor: format code --- include/ALabel.hpp | 28 ++--- include/IModule.hpp | 12 +- include/bar.hpp | 32 +++--- include/client.hpp | 34 +++--- include/factory.hpp | 25 ++-- include/modules/backlight.hpp | 47 ++++---- include/modules/battery.hpp | 45 ++++---- include/modules/clock.hpp | 17 +-- include/modules/cpu.hpp | 31 ++--- include/modules/custom.hpp | 49 ++++---- include/modules/idle_inhibitor.hpp | 25 ++-- include/modules/memory.hpp | 25 ++-- include/modules/network.hpp | 95 +++++++-------- include/modules/pulseaudio.hpp | 46 ++++---- include/modules/sni/host.hpp | 26 ++--- include/modules/sni/item.hpp | 46 ++++---- include/modules/sni/tray.hpp | 10 +- include/modules/sni/watcher.hpp | 28 ++--- include/modules/sway/ipc/client.hpp | 24 ++-- include/modules/sway/mode.hpp | 33 +++--- include/modules/sway/window.hpp | 37 +++--- include/modules/sway/workspaces.hpp | 63 +++++----- include/modules/temperature.hpp | 23 ++-- include/util/command.hpp | 15 ++- include/util/json.hpp | 20 ++-- include/util/sleeper_thread.hpp | 49 ++++---- src/ALabel.cpp | 38 +++--- src/bar.cpp | 16 ++- src/client.cpp | 24 ++-- src/factory.cpp | 31 +++-- src/modules/backlight.cpp | 116 +++++++------------ src/modules/battery.cpp | 54 ++++----- src/modules/clock.cpp | 17 +-- src/modules/cpu.cpp | 39 +++---- src/modules/custom.cpp | 60 +++++----- src/modules/idle_inhibitor.cpp | 2 +- src/modules/memory.cpp | 16 +-- src/modules/network.cpp | 172 +++++++++++++--------------- src/modules/pulseaudio.cpp | 100 +++++++--------- src/modules/sni/host.cpp | 18 ++- src/modules/sni/item.cpp | 49 +++++--- src/modules/sni/watcher.cpp | 49 +++++--- src/modules/sway/ipc/client.cpp | 51 +++------ src/modules/sway/mode.cpp | 9 +- src/modules/sway/window.cpp | 42 +++---- src/modules/sway/workspaces.cpp | 14 +-- src/modules/temperature.cpp | 29 ++--- 47 files changed, 871 insertions(+), 960 deletions(-) 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 1957354..1b4816e 100644 --- a/include/bar.hpp +++ b/include/bar.hpp @@ -14,28 +14,28 @@ namespace waybar { class Factory; struct waybar_output { - struct wl_output *output; - std::string name; - uint32_t wl_name; + struct wl_output * output; + std::string name; + uint32_t wl_name; struct zxdg_output_v1 *xdg_output; - Json::Value config; + Json::Value config; }; class Bar { public: - Bar(struct waybar_output* w_output); + 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 waybar_output * output; + Gtk::Window window; + struct wl_surface * surface; struct zwlr_layer_surface_v1 *layer_surface; - bool visible = true; - bool vertical = false; + bool visible = true; + bool vertical = false; private: static void layerSurfaceHandleConfigure(void *, struct zwlr_layer_surface_v1 *, uint32_t, @@ -49,12 +49,12 @@ class Bar { 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_; + 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_; diff --git a/include/client.hpp b/include/client.hpp index 5185508..c831bc0 100644 --- a/include/client.hpp +++ b/include/client.hpp @@ -13,24 +13,24 @@ namespace waybar { class Client { public: static Client *inst(); - int main(int argc, char *argv[]); + int main(int argc, char *argv[]); - 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 wl_seat *seat = nullptr; + 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 wl_seat * seat = nullptr; struct zwp_idle_inhibit_manager_v1 *idle_inhibit_manager = nullptr; - std::vector> bars; + std::vector> bars; private: Client(); - void setupConfigs(const std::string &config, const std::string &style); - void bindInterfaces(); + 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); + void handleOutput(std::unique_ptr &output); bool isValidOutput(const Json::Value &config, std::unique_ptr &output); auto setupConfig() -> void; auto setupCss() -> void; @@ -44,11 +44,11 @@ class Client { 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_; + Json::Value config_; + std::string css_file_; + std::string config_file_; + Glib::RefPtr style_context_; + Glib::RefPtr css_provider_; std::vector> outputs_; }; diff --git a/include/factory.hpp b/include/factory.hpp index a31ef8f..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,19 +26,20 @@ #ifdef HAVE_LIBMPDCLIENT #include "modules/mpd.hpp" #endif -#include "modules/temperature.hpp" -#include "modules/custom.hpp" #include "bar.hpp" +#include "modules/custom.hpp" +#include "modules/temperature.hpp" namespace waybar { 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 bbfe884..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 = 200; + 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..f892730 100644 --- a/include/modules/sni/watcher.hpp +++ b/include/modules/sni/watcher.hpp @@ -16,30 +16,30 @@ 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_; + 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..ba862ff 100644 --- a/include/modules/sway/ipc/client.hpp +++ b/include/modules/sway/ipc/client.hpp @@ -1,35 +1,35 @@ #pragma once -#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; + void subscribe(const std::string &payload) const; struct ipc_response handleEvent() const; -protected: + 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; + 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; @@ -37,4 +37,4 @@ protected: int fd_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..6c0d923 100644 --- a/include/modules/sway/mode.hpp +++ b/include/modules/sway/mode.hpp @@ -1,28 +1,29 @@ #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 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..b5e2bd7 100644 --- a/include/modules/sway/window.hpp +++ b/include/modules/sway/window.hpp @@ -2,31 +2,32 @@ #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 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..4e3173c 100644 --- a/include/modules/sway/workspaces.hpp +++ b/include/modules/sway/workspaces.hpp @@ -1,43 +1,44 @@ #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 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); + + 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_; }; -} +} // 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 a9841ab..cc0d86c 100644 --- a/include/util/json.hpp +++ b/include/util/json.hpp @@ -5,30 +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; 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); + 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 a16a81f..6662dd7 100644 --- a/src/bar.cpp +++ b/src/bar.cpp @@ -35,8 +35,8 @@ waybar::Bar::Bar(struct waybar_output* w_output) setupAltFormatKeyForModuleList("modules-center"); std::size_t layer = output->config["layer"] == "top" ? ZWLR_LAYER_SHELL_V1_LAYER_TOP : ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM; - layer_surface = zwlr_layer_shell_v1_get_layer_surface(waybar::Client::inst()->layer_shell, - surface, output->output, layer, "waybar"); + layer_surface = zwlr_layer_shell_v1_get_layer_surface( + waybar::Client::inst()->layer_shell, surface, output->output, layer, "waybar"); static const struct zwlr_layer_surface_v1_listener layer_surface_listener = { .configure = layerSurfaceHandleConfigure, @@ -149,7 +149,8 @@ void waybar::Bar::layerSurfaceHandleConfigure(void* data, struct zwlr_layer_surf std::cout << fmt::format( "Requested height: {} exceeds the minimum \ height: {} required by the modules", - o->height_, min_height) + o->height_, + min_height) << std::endl; o->height_ = min_height; } @@ -157,12 +158,15 @@ height: {} required by the modules", std::cout << fmt::format( "Requested width: {} exceeds the minimum \ width: {} required by the modules", - o->height_, min_width) + 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::cout << fmt::format("Bar configured (width: {}, height: {}) for output: {}", + o->width_, + o->height_, + o->output->name) << std::endl; wl_surface_commit(o->surface); diff --git a/src/client.cpp b/src/client.cpp index 0d1d877..bec28b5 100644 --- a/src/client.cpp +++ b/src/client.cpp @@ -53,7 +53,7 @@ void waybar::Client::handleGlobal(void *data, struct wl_registry *registry, uint } } -void waybar::Client::handleGlobalRemove(void *data, struct wl_registry * /*registry*/, +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();) { @@ -66,7 +66,8 @@ void waybar::Client::handleGlobalRemove(void *data, struct wl_registry * /*regis ++it; } } - auto it = std::find_if(client->outputs_.begin(), client->outputs_.end(), + 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); @@ -102,7 +103,7 @@ void waybar::Client::handleDone(void * /*data*/, struct zxdg_output_v1 * /*zxdg_ // Nothing here } -bool waybar::Client::isValidOutput(const Json::Value &config, +bool waybar::Client::isValidOutput(const Json::Value & config, std::unique_ptr &output) { bool found = true; if (config["output"].isArray()) { @@ -121,11 +122,12 @@ bool waybar::Client::isValidOutput(const Json::Value &config, return found; } -void waybar::Client::handleName(void *data, struct zxdg_output_v1 * /*xdg_output*/, +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(), + 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; @@ -153,8 +155,8 @@ void waybar::Client::handleName(void *data, struct zxdg_output_v1 * /*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); + client->style_context_->add_provider_for_screen( + screen, client->css_provider_, GTK_STYLE_PROVIDER_PRIORITY_USER); } } @@ -191,7 +193,7 @@ auto waybar::Client::setupConfig() -> void { if (!file.is_open()) { throw std::runtime_error("Can't open config file"); } - std::string str((std::istreambuf_iterator(file)), std::istreambuf_iterator()); + std::string str((std::istreambuf_iterator(file)), std::istreambuf_iterator()); util::JsonParser parser; config_ = parser.parse(str); } @@ -230,12 +232,12 @@ int waybar::Client::main(int argc, char *argv[]) { 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; + 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) | + 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") | 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/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 7de1013..7840542 100644 --- a/src/modules/idle_inhibitor.cpp +++ b/src/modules/idle_inhibitor.cpp @@ -36,7 +36,7 @@ bool waybar::modules::IdleInhibitor::handleToggle(GdkEventButton* const& e) { if (idle_inhibitor_) { zwp_idle_inhibitor_v1_destroy(idle_inhibitor_); idle_inhibitor_ = nullptr; - status_ = "deactivated"; + status_ = "deactivated"; } else { idle_inhibitor_ = zwp_idle_inhibit_manager_v1_create_inhibitor( waybar::Client::inst()->idle_inhibit_manager, bar_.surface); 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 55e1f39..713cc1c 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"); @@ -80,7 +82,7 @@ void waybar::modules::Network::createInfoSocket() } } { - auto fd = nl_socket_get_fd(info_sock_); + auto fd = nl_socket_get_fd(info_sock_); struct epoll_event event = {0}; event.events = EPOLLIN | EPOLLET | EPOLLRDHUP; event.data.fd = fd; @@ -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(); @@ -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 8cfe5dd..2be0ba8 100644 --- a/src/modules/sni/host.cpp +++ b/src/modules/sni/host.cpp @@ -31,7 +31,8 @@ Host::~Host() { } 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)); } @@ -43,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) { @@ -55,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; @@ -69,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..19cde58 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()); @@ -255,8 +270,8 @@ Glib::RefPtr waybar::modules::SNI::Item::getIconByName(std::string 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); + return default_theme->load_icon( + name.c_str(), tmp_size, Gtk::IconLookupFlags::ICON_LOOKUP_FORCE_SIZE); } return icon; } diff --git a/src/modules/sni/watcher.cpp b/src/modules/sni/watcher.cpp index 24050d5..eb83a5a 100644 --- a/src/modules/sni/watcher.cpp +++ b/src/modules/sni/watcher.cpp @@ -34,17 +34,17 @@ Watcher::~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); + 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); } gboolean Watcher::handleRegisterHost(Watcher* obj, GDBusMethodInvocation* invocation, @@ -57,16 +57,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 +95,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 +154,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 +186,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..fe794a4 100644 --- a/src/modules/sway/ipc/client.cpp +++ b/src/modules/sway/ipc/client.cpp @@ -1,14 +1,12 @@ #include "modules/sway/ipc/client.hpp" -waybar::modules::sway::Ipc::Ipc() -{ +waybar::modules::sway::Ipc::Ipc() { const std::string& socketPath = getSocketPath(); fd_ = open(socketPath); fd_event_ = open(socketPath); } -waybar::modules::sway::Ipc::~Ipc() -{ +waybar::modules::sway::Ipc::~Ipc() { // To fail the IPC header write(fd_, "close-sway-ipc", 14); write(fd_event_, "close-sway-ipc", 14); @@ -17,17 +15,16 @@ waybar::modules::sway::Ipc::~Ipc() close(fd_event_); } -const std::string waybar::modules::sway::Ipc::getSocketPath() const -{ - const char *env = getenv("SWAYSOCK"); +const std::string waybar::modules::sway::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"); } @@ -43,10 +40,9 @@ const std::string waybar::modules::sway::Ipc::getSocketPath() const return str; } -int waybar::modules::sway::Ipc::open(const std::string& socketPath) const -{ +int waybar::modules::sway::Ipc::open(const std::string& socketPath) const { struct sockaddr_un addr = {0}; - int fd = -1; + int fd = -1; if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) { throw std::runtime_error("Unable to open Unix socket"); } @@ -54,18 +50,16 @@ int waybar::modules::sway::Ipc::open(const std::string& socketPath) const 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 waybar::modules::sway::Ipc::ipc_response waybar::modules::sway::Ipc::recv(int fd) const { 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_) { @@ -91,16 +85,14 @@ 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 waybar::modules::sway::Ipc::ipc_response waybar::modules::sway::Ipc::send( + int fd, uint32_t type, const std::string& payload) const { 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; @@ -114,23 +106,18 @@ struct waybar::modules::sway::Ipc::ipc_response return recv(fd); } -struct waybar::modules::sway::Ipc::ipc_response - waybar::modules::sway::Ipc::sendCmd(uint32_t type, - const std::string& payload) const -{ +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 waybar::modules::sway::Ipc::subscribe(const std::string& payload) const -{ +void waybar::modules::sway::Ipc::subscribe(const std::string& payload) const { auto res = 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 -{ +struct waybar::modules::sway::Ipc::ipc_response waybar::modules::sway::Ipc::handleEvent() const { return recv(fd_event_); } diff --git a/src/modules/sway/mode.cpp b/src/modules/sway/mode.cpp index c4b4735..b797017 100644 --- a/src/modules/sway/mode.cpp +++ b/src/modules/sway/mode.cpp @@ -1,8 +1,7 @@ #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) -{ + : ALabel(config, "{}"), bar_(bar) { label_.set_name("mode"); if (!id.empty()) { label_.get_style_context()->add_class(id); @@ -13,8 +12,7 @@ waybar::modules::sway::Mode::Mode(const std::string& id, const Bar& bar, const J dp.emit(); } -void waybar::modules::sway::Mode::worker() -{ +void waybar::modules::sway::Mode::worker() { thread_ = [this] { try { auto res = ipc_.handleEvent(); @@ -31,8 +29,7 @@ void waybar::modules::sway::Mode::worker() }; } -auto waybar::modules::sway::Mode::update() -> void -{ +auto waybar::modules::sway::Mode::update() -> void { if (mode_.empty()) { event_box_.hide(); } else { diff --git a/src/modules/sway/window.cpp b/src/modules/sway/window.cpp index aa54978..0a3f3a9 100644 --- a/src/modules/sway/window.cpp +++ b/src/modules/sway/window.cpp @@ -1,8 +1,8 @@ #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) -{ +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); @@ -17,24 +17,22 @@ waybar::modules::sway::Window::Window(const std::string& id, const Bar &bar, con worker(); } -void waybar::modules::sway::Window::worker() -{ +void waybar::modules::sway::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") { + 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())) { + } 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(); @@ -45,31 +43,27 @@ void waybar::modules::sway::Window::worker() }; } -auto waybar::modules::sway::Window::update() -> void -{ +auto waybar::modules::sway::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 waybar::modules::sway::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 waybar::modules::sway::Window::getFocusedWindow() { try { auto res = ipc_.sendCmd(IPC_GET_TREE); auto parsed = parser_.parse(res.payload); @@ -77,7 +71,7 @@ void waybar::modules::sway::Window::getFocusedWindow() windowId_ = id; window_ = name; Glib::signal_idle().connect_once(sigc::mem_fun(*this, &Window::update)); - } catch (const std::exception &e) { + } catch (const std::exception& e) { std::cerr << e.what() << std::endl; } } diff --git a/src/modules/sway/workspaces.cpp b/src/modules/sway/workspaces.cpp index 8a12eb7..bd2635c 100644 --- a/src/modules/sway/workspaces.cpp +++ b/src/modules/sway/workspaces.cpp @@ -44,7 +44,7 @@ auto waybar::modules::sway::Workspaces::update() -> void { }); if (ws == workspaces_.end() || (!config_["all-outputs"].asBool() && (*ws)["output"].asString() != bar_.output->name)) { - it = buttons_.erase(it); + it = buttons_.erase(it); needReorder = true; } else { ++it; @@ -78,11 +78,11 @@ auto waybar::modules::sway::Workspaces::update() -> void { if (needReorder) { box_.reorder_child(button, getWorkspaceIndex(node["name"].asString())); } - auto icon = getIcon(node["name"].asString(), node); + auto icon = getIcon(node["name"].asString(), node); std::string output = icon; if (config_["format"].isString()) { auto format = config_["format"].asString(); - output = fmt::format(format, + output = fmt::format(format, fmt::arg("icon", icon), fmt::arg("name", trimWorkspaceName(node["name"].asString())), fmt::arg("index", node["num"].asString())); @@ -101,14 +101,14 @@ auto waybar::modules::sway::Workspaces::update() -> void { } void waybar::modules::sway::Workspaces::addWorkspace(const Json::Value &node) { - auto icon = getIcon(node["name"].asString(), 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); + auto pair = buttons_.emplace(node["name"].asString(), format); auto &button = pair.first->second; if (!config_["disable-markup"].asBool()) { static_cast(button.get_children()[0])->set_markup(format); @@ -201,9 +201,9 @@ bool waybar::modules::sway::Workspaces::handleScroll(GdkEventScroll *e) { const std::string waybar::modules::sway::Workspaces::getCycleWorkspace(uint8_t focused_workspace, bool prev) const { - auto inc = prev ? -1 : 1; + auto inc = prev ? -1 : 1; int size = workspaces_.size(); - uint8_t idx = 0; + 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()) || 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