Zander671/Waybar
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge tag '0.15.0' of https://github.com/Alexays/Waybar
Some checks failed
clang-format / lint (push) Has been cancelled
Details
freebsd / build (push) Has been cancelled
Details
linux / build (c++20, alpine) (push) Has been cancelled
Details
linux / build (c++20, archlinux) (push) Has been cancelled
Details
linux / build (c++20, debian) (push) Has been cancelled
Details
linux / build (c++20, fedora) (push) Has been cancelled
Details
linux / build (c++20, gentoo) (push) Has been cancelled
Details
linux / build (c++20, opensuse) (push) Has been cancelled
Details
Nix-Tests / nix-flake-check (push) Has been cancelled
Details

Browse Source
This commit is contained in:
Alexander Rosenberg
2026-02-19 20:54:36 -08:00
parent 0abbf221a2 90b209add8
commit 4d2fb11a05
116 changed files with 2513 additions and 1511 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
include/AAppIconLabel.hpp
View File

@ -9,15 +9,15 @@ namespace waybar {
class AAppIconLabel : public AIconLabel {
public:
AAppIconLabel(const Json::Value &config, const std::string &name, const std::string &id,
const std::string &format, uint16_t interval = 0, bool ellipsize = false,
AAppIconLabel(const Json::Value& config, const std::string& name, const std::string& id,
const std::string& format, uint16_t interval = 0, bool ellipsize = false,
bool enable_click = false, bool enable_scroll = false);
virtual ~AAppIconLabel() = default;
auto update() -> void override;
protected:
void updateAppIconName(const std::string &app_identifier,
const std::string &alternative_app_identifier);
void updateAppIconName(const std::string& app_identifier,
const std::string& alternative_app_identifier);
void updateAppIcon();
unsigned app_icon_size_{24};
bool update_app_icon_{true};

4
include/AIconLabel.hpp
View File

@ -9,8 +9,8 @@ namespace waybar {
class AIconLabel : public ALabel {
public:
AIconLabel(const Json::Value &config, const std::string &name, const std::string &id,
const std::string &format, uint16_t interval = 0, bool ellipsize = false,
AIconLabel(const Json::Value& config, const std::string& name, const std::string& id,
const std::string& format, uint16_t interval = 0, bool ellipsize = false,
bool enable_click = false, bool enable_scroll = false);
virtual ~AIconLabel() = default;
auto update() -> void override;

12
include/ALabel.hpp
View File

@ -10,13 +10,13 @@ namespace waybar {
class ALabel : public AModule {
public:
ALabel(const Json::Value &, const std::string &, const std::string &, const std::string &format,
ALabel(const Json::Value&, const std::string&, const std::string&, const std::string& format,
uint16_t interval = 0, bool ellipsize = false, bool enable_click = false,
bool enable_scroll = false);
virtual ~ALabel() = default;
auto update() -> void override;
virtual std::string getIcon(uint16_t, const std::string &alt = "", uint16_t max = 0);
virtual std::string getIcon(uint16_t, const std::vector<std::string> &alts, uint16_t max = 0);
virtual std::string getIcon(uint16_t, const std::string& alt = "", uint16_t max = 0);
virtual std::string getIcon(uint16_t, const std::vector<std::string>& alts, uint16_t max = 0);
protected:
Gtk::Label label_;
@ -25,12 +25,12 @@ class ALabel : public AModule {
bool alt_ = false;
std::string default_format_;
bool handleToggle(GdkEventButton *const &e) override;
bool handleToggle(GdkEventButton* const& e) override;
virtual std::string getState(uint8_t value, bool lesser = false);
std::map<std::string, GtkMenuItem *> submenus_;
std::map<std::string, GtkMenuItem*> submenus_;
std::map<std::string, std::string> menuActionsMap_;
static void handleGtkMenuEvent(GtkMenuItem *menuitem, gpointer data);
static void handleGtkMenuEvent(GtkMenuItem* menuitem, gpointer data);
};
} // namespace waybar

28
include/AModule.hpp
View File

@ -12,13 +12,13 @@ namespace waybar {
class AModule : public IModule {
public:
static constexpr const char *MODULE_CLASS = "module";
static constexpr const char* MODULE_CLASS = "module";
~AModule() override;
auto update() -> void override;
virtual auto refresh(int shouldRefresh) -> void {};
operator Gtk::Widget &() override;
auto doAction(const std::string &name) -> void override;
operator Gtk::Widget&() override;
auto doAction(const std::string& name) -> void override;
/// Emitting on this dispatcher triggers a update() call
Glib::Dispatcher dp;
@ -28,30 +28,30 @@ class AModule : public IModule {
protected:
// Don't need to make an object directly
// Derived classes are able to use it
AModule(const Json::Value &, const std::string &, const std::string &, bool enable_click = false,
AModule(const Json::Value&, const std::string&, const std::string&, bool enable_click = false,
bool enable_scroll = false);
enum SCROLL_DIR { NONE, UP, DOWN, LEFT, RIGHT };
SCROLL_DIR getScrollDir(GdkEventScroll *e);
SCROLL_DIR getScrollDir(GdkEventScroll* e);
bool tooltipEnabled() const;
std::vector<int> pid_children_;
const std::string name_;
const Json::Value &config_;
const Json::Value& config_;
Gtk::EventBox event_box_;
virtual void setCursor(Gdk::CursorType const &c);
virtual void setCursor(Gdk::CursorType const& c);
virtual bool handleToggle(GdkEventButton *const &ev);
virtual bool handleMouseEnter(GdkEventCrossing *const &ev);
virtual bool handleMouseLeave(GdkEventCrossing *const &ev);
virtual bool handleScroll(GdkEventScroll *);
virtual bool handleRelease(GdkEventButton *const &ev);
GObject *menu_;
virtual bool handleToggle(GdkEventButton* const& ev);
virtual bool handleMouseEnter(GdkEventCrossing* const& ev);
virtual bool handleMouseLeave(GdkEventCrossing* const& ev);
virtual bool handleScroll(GdkEventScroll*);
virtual bool handleRelease(GdkEventButton* const& ev);
GObject* menu_;
private:
bool handleUserEvent(GdkEventButton *const &ev);
bool handleUserEvent(GdkEventButton* const& ev);
const bool isTooltip;
const bool isExpand;
bool hasUserEvents_;

22
include/bar.hpp
View File

@ -62,11 +62,11 @@ class Bar : public sigc::trackable {
static const std::string MODE_DEFAULT;
static const std::string MODE_INVISIBLE;
Bar(struct waybar_output *w_output, const Json::Value &);
Bar(const Bar &) = delete;
Bar(struct waybar_output* w_output, const Json::Value&);
Bar(const Bar&) = delete;
~Bar();
void setMode(const std::string &mode);
void setMode(const std::string& mode);
void setVisible(bool value);
void toggle();
void show();
@ -75,9 +75,9 @@ class Bar : public sigc::trackable {
util::KillSignalAction getOnSigusr1Action();
util::KillSignalAction getOnSigusr2Action();
struct waybar_output *output;
struct waybar_output* output;
Json::Value config;
struct wl_surface *surface;
struct wl_surface* surface;
bool visible = true;
Gtk::Window window;
Gtk::Orientation orientation = Gtk::ORIENTATION_HORIZONTAL;
@ -91,15 +91,15 @@ class Bar : public sigc::trackable {
#endif
private:
void onMap(GdkEventAny *);
void onMap(GdkEventAny*);
auto setupWidgets() -> void;
void getModules(const Factory &, const std::string &, waybar::Group *);
void setupAltFormatKeyForModule(const std::string &module_name);
void setupAltFormatKeyForModuleList(const char *module_list_name);
void setMode(const bar_mode &);
void getModules(const Factory&, const std::string&, waybar::Group*);
void setupAltFormatKeyForModule(const std::string& module_name);
void setupAltFormatKeyForModuleList(const char* module_list_name);
void setMode(const bar_mode&);
void setPassThrough(bool passthrough);
void setPosition(Gtk::PositionType position);
void onConfigure(GdkEventConfigure *ev);
void onConfigure(GdkEventConfigure* ev);
void configureGlobalOffset(int width, int height);
void onOutputGeometryChanged();

2
include/client.hpp
View File

@ -63,6 +63,8 @@ class Client {
std::string m_cssFile;
std::map<int, bool> signal_toggle_state;
sigc::connection monitor_added_connection_;
sigc::connection monitor_removed_connection_;
};
} // namespace waybar

22
include/config.hpp
View File

@ -14,29 +14,29 @@ namespace waybar {
class Config {
public:
static const std::vector<std::string> CONFIG_DIRS;
static const char *CONFIG_PATH_ENV;
static const char* CONFIG_PATH_ENV;
/* Try to find any of provided names in the supported set of config directories */
static std::optional<std::string> findConfigPath(
const std::vector<std::string> &names, const std::vector<std::string> &dirs = CONFIG_DIRS);
const std::vector<std::string>& names, const std::vector<std::string>& dirs = CONFIG_DIRS);
static std::vector<std::string> tryExpandPath(const std::string &base,
const std::string &filename);
static std::vector<std::string> tryExpandPath(const std::string& base,
const std::string& filename);
Config() = default;
void load(const std::string &config);
void load(const std::string& config);
Json::Value &getConfig() { return config_; }
Json::Value& getConfig() { return config_; }
std::vector<Json::Value> getOutputConfigs(const std::string &name, const std::string &identifier);
std::vector<Json::Value> getOutputConfigs(const std::string& name, const std::string& identifier);
private:
void setupConfig(Json::Value &dst, const std::string &config_file, int depth);
void resolveConfigIncludes(Json::Value &config, int depth);
void mergeConfig(Json::Value &a_config_, Json::Value &b_config_);
void setupConfig(Json::Value& dst, const std::string& config_file, int depth);
void resolveConfigIncludes(Json::Value& config, int depth);
void mergeConfig(Json::Value& a_config_, Json::Value& b_config_);
static std::vector<std::string> findIncludePath(
const std::string &name, const std::vector<std::string> &dirs = CONFIG_DIRS);
const std::string& name, const std::vector<std::string>& dirs = CONFIG_DIRS);
std::string config_file_;

4
include/modules/backlight.hpp
View File

@ -17,11 +17,11 @@ namespace waybar::modules {
class Backlight : public ALabel {
public:
Backlight(const std::string &, const Json::Value &);
Backlight(const std::string&, const Json::Value&);
virtual ~Backlight() = default;
auto update() -> void override;
bool handleScroll(GdkEventScroll *e) override;
bool handleScroll(GdkEventScroll* e) override;
const std::string preferred_device_;

8
include/modules/battery.hpp
View File

@ -6,6 +6,7 @@
#if defined(__linux__)
#include <sys/inotify.h>
#endif
#include <sys/poll.h>
#include <algorithm>
#include <fstream>
@ -15,6 +16,7 @@
#include "ALabel.hpp"
#include "bar.hpp"
#include "util/sleeper_thread.hpp"
#include "util/udev_deleter.hpp"
namespace waybar::modules {
@ -37,15 +39,17 @@ class Battery : public ALabel {
void setBarClass(std::string&);
void processEvents(std::string& state, std::string& status, uint8_t capacity);
int global_watch;
std::map<fs::path, int> batteries_;
std::unique_ptr<udev, util::UdevDeleter> udev_;
std::array<pollfd, 1> poll_fds_;
std::unique_ptr<udev_monitor, util::UdevMonitorDeleter> mon_;
fs::path adapter_;
int battery_watch_fd_;
int global_watch_fd_;
std::mutex battery_list_mutex_;
std::string old_status_;
std::string last_event_;
bool warnFirstTime_{true};
bool weightedAverage_{true};
const Bar& bar_;
util::SleeperThread thread_;

43
include/modules/cava/cavaGLSL.hpp Normal file
View File

@ -0,0 +1,43 @@
#pragma once
#include <epoxy/gl.h>
#include "AModule.hpp"
#include "cava_backend.hpp"
namespace waybar::modules::cava {
class CavaGLSL final : public AModule, public Gtk::GLArea {
public:
CavaGLSL(const std::string&, const Json::Value&);
~CavaGLSL() = default;
private:
std::shared_ptr<CavaBackend> backend_;
struct ::cava::config_params prm_;
int frame_counter{0};
bool silence_{false};
bool hide_on_silence_{false};
// Cava method
auto onUpdate(const ::cava::audio_raw& input) -> void;
auto onSilence() -> void;
// Member variable to store the shared pointer
std::shared_ptr<::cava::audio_raw> m_data_;
GLuint shaderProgram_;
// OpenGL variables
GLuint fbo_;
GLuint texture_;
GLint uniform_bars_;
GLint uniform_previous_bars_;
GLint uniform_bars_count_;
GLint uniform_time_;
// Methods
void onRealize();
bool onRender(const Glib::RefPtr<Gdk::GLContext>& context);
void initShaders();
void initSurface();
void initGLSL();
GLuint loadShader(const std::string& fileName, GLenum type);
};
} // namespace waybar::modules::cava

8
include/modules/cava/cava.hpp → include/modules/cava/cavaRaw.hpp
View File

@ -9,20 +9,20 @@ class Cava final : public ALabel, public sigc::trackable {
public:
Cava(const std::string&, const Json::Value&);
~Cava() = default;
auto onUpdate(const std::string& input) -> void;
auto onSilence() -> void;
auto doAction(const std::string& name) -> void override;
private:
std::shared_ptr<CavaBackend> backend_;
// Text to display
std::string label_text_{""};
Glib::ustring label_text_{""};
bool silence_{false};
bool hide_on_silence_{false};
std::string format_silent_{""};
int ascii_range_{0};
bool silence_{false};
// Cava method
void pause_resume();
auto onUpdate(const std::string& input) -> void;
auto onSilence() -> void;
// ModuleActionMap
static inline std::map<const std::string, void (waybar::modules::cava::Cava::* const)()>
actionMap_{{"mode", &waybar::modules::cava::Cava::pause_resume}};

16
include/modules/cava/cava_backend.hpp
View File

@ -32,29 +32,36 @@ class CavaBackend final {
int getAsciiRange();
void doPauseResume();
void Update();
const struct ::cava::config_params* getPrm();
std::chrono::milliseconds getFrameTimeMilsec();
// Signal accessor
using type_signal_update = sigc::signal<void(const std::string&)>;
type_signal_update signal_update();
using type_signal_audio_raw_update = sigc::signal<void(const ::cava::audio_raw&)>;
type_signal_audio_raw_update signal_audio_raw_update();
using type_signal_silence = sigc::signal<void()>;
type_signal_silence signal_silence();
private:
CavaBackend(const Json::Value& config);
util::SleeperThread thread_;
util::SleeperThread read_thread_;
util::SleeperThread out_thread_;
// Cava API to read audio source
::cava::ptr input_source_;
::cava::ptr input_source_{NULL};
struct ::cava::error_s error_{}; // cava errors
struct ::cava::config_params prm_{}; // cava parameters
struct ::cava::audio_raw audio_raw_{}; // cava handled raw audio data(is based on audio_data)
struct ::cava::audio_data audio_data_{}; // cava audio data
struct ::cava::cava_plan* plan_; //{new cava_plan{}};
struct ::cava::cava_plan* plan_{NULL}; //{new cava_plan{}};
std::chrono::seconds fetch_input_delay_{4};
// Delay to handle audio source
std::chrono::milliseconds frame_time_milsec_{1s};
const Json::Value& config_;
int re_paint_{0};
bool silence_{false};
bool silence_prev_{false};
@ -66,9 +73,12 @@ class CavaBackend final {
void execute();
bool isSilence();
void doUpdate(bool force = false);
void loadConfig();
void freeBackend();
// Signal
type_signal_update m_signal_update_;
type_signal_audio_raw_update m_signal_audio_raw_;
type_signal_silence m_signal_silence_;
};
} // namespace waybar::modules::cava

27
include/modules/cava/cava_frontend.hpp Normal file
View File

@ -0,0 +1,27 @@
#pragma once
#ifdef HAVE_LIBCAVA
#include "cavaRaw.hpp"
#include "cava_backend.hpp"
#ifdef HAVE_LIBCAVAGLSL
#include "cavaGLSL.hpp"
#endif
#endif
namespace waybar::modules::cava {
AModule* getModule(const std::string& id, const Json::Value& config) {
#ifdef HAVE_LIBCAVA
const std::shared_ptr<CavaBackend> backend_{waybar::modules::cava::CavaBackend::inst(config)};
switch (backend_->getPrm()->output) {
#ifdef HAVE_LIBCAVAGLSL
case ::cava::output_method::OUTPUT_SDL_GLSL:
return new waybar::modules::cava::CavaGLSL(id, config);
#endif
default:
return new waybar::modules::cava::Cava(id, config);
}
#else
throw std::runtime_error("Unknown module");
#endif
};
} // namespace waybar::modules::cava

12
include/modules/dwl/tags.hpp
View File

@ -12,23 +12,23 @@ namespace waybar::modules::dwl {
class Tags : public waybar::AModule {
public:
Tags(const std::string &, const waybar::Bar &, const Json::Value &);
Tags(const std::string&, const waybar::Bar&, const Json::Value&);
virtual ~Tags();
// Handlers for wayland events
void handle_view_tags(uint32_t tag, uint32_t state, uint32_t clients, uint32_t focused);
void handle_primary_clicked(uint32_t tag);
bool handle_button_press(GdkEventButton *event_button, uint32_t tag);
bool handle_button_press(GdkEventButton* event_button, uint32_t tag);
struct zdwl_ipc_manager_v2 *status_manager_;
struct wl_seat *seat_;
struct zdwl_ipc_manager_v2* status_manager_;
struct wl_seat* seat_;
private:
const waybar::Bar &bar_;
const waybar::Bar& bar_;
Gtk::Box box_;
std::vector<Gtk::Button> buttons_;
struct zdwl_ipc_output_v2 *output_status_;
struct zdwl_ipc_output_v2* output_status_;
};
} /* namespace waybar::modules::dwl */

14
include/modules/dwl/window.hpp
View File

@ -13,26 +13,26 @@ namespace waybar::modules::dwl {
class Window : public AAppIconLabel, public sigc::trackable {
public:
Window(const std::string &, const waybar::Bar &, const Json::Value &);
Window(const std::string&, const waybar::Bar&, const Json::Value&);
~Window();
void handle_layout(const uint32_t layout);
void handle_title(const char *title);
void handle_appid(const char *ppid);
void handle_layout_symbol(const char *layout_symbol);
void handle_title(const char* title);
void handle_appid(const char* ppid);
void handle_layout_symbol(const char* layout_symbol);
void handle_frame();
struct zdwl_ipc_manager_v2 *status_manager_;
struct zdwl_ipc_manager_v2* status_manager_;
private:
const Bar &bar_;
const Bar& bar_;
std::string title_;
std::string appid_;
std::string layout_symbol_;
uint32_t layout_;
struct zdwl_ipc_output_v2 *output_status_;
struct zdwl_ipc_output_v2* output_status_;
};
} // namespace waybar::modules::dwl

62
include/modules/ext/workspace_manager.hpp
View File

@ -20,16 +20,16 @@ class Workspace;
class WorkspaceManager final : public AModule {
public:
WorkspaceManager(const std::string &id, const waybar::Bar &bar, const Json::Value &config);
WorkspaceManager(const std::string& id, const waybar::Bar& bar, const Json::Value& config);
~WorkspaceManager() override;
void register_manager(wl_registry *registry, uint32_t name, uint32_t version);
void register_manager(wl_registry* registry, uint32_t name, uint32_t version);
void remove_workspace_group(uint32_t id);
void remove_workspace(uint32_t id);
void set_needs_sorting() { needs_sorting_ = true; }
// wl events
void handle_workspace_group(ext_workspace_group_handle_v1 *handle);
void handle_workspace(ext_workspace_handle_v1 *handle);
void handle_workspace_group(ext_workspace_group_handle_v1* handle);
void handle_workspace(ext_workspace_handle_v1* handle);
void handle_done();
void handle_finished();
@ -38,7 +38,7 @@ class WorkspaceManager final : public AModule {
private:
void update() override;
bool has_button(const Gtk::Button *button);
bool has_button(const Gtk::Button* button);
void sort_workspaces();
void clear_buttons();
void update_buttons();
@ -52,10 +52,10 @@ class WorkspaceManager final : public AModule {
bool sort_by_coordinates_ = false;
bool all_outputs_ = false;
const waybar::Bar &bar_;
const waybar::Bar& bar_;
Gtk::Box box_;
ext_workspace_manager_v1 *ext_manager_ = nullptr;
ext_workspace_manager_v1* ext_manager_ = nullptr;
std::vector<std::unique_ptr<WorkspaceGroup>> groups_;
std::vector<std::unique_ptr<Workspace>> workspaces_;
@ -64,60 +64,60 @@ class WorkspaceManager final : public AModule {
class WorkspaceGroup {
public:
WorkspaceGroup(WorkspaceManager &manager, ext_workspace_group_handle_v1 *handle, uint32_t id);
WorkspaceGroup(WorkspaceManager& manager, ext_workspace_group_handle_v1* handle, uint32_t id);
~WorkspaceGroup();
u_int32_t id() const { return id_; }
bool has_output(const wl_output *output);
bool has_workspace(const ext_workspace_handle_v1 *workspace);
bool has_output(const wl_output* output);
bool has_workspace(const ext_workspace_handle_v1* workspace);
// wl events
void handle_capabilities(uint32_t capabilities);
void handle_output_enter(wl_output *output);
void handle_output_leave(wl_output *output);
void handle_workspace_enter(ext_workspace_handle_v1 *handle);
void handle_workspace_leave(ext_workspace_handle_v1 *handle);
void handle_output_enter(wl_output* output);
void handle_output_leave(wl_output* output);
void handle_workspace_enter(ext_workspace_handle_v1* handle);
void handle_workspace_leave(ext_workspace_handle_v1* handle);
void handle_removed();
private:
WorkspaceManager &workspaces_manager_;
ext_workspace_group_handle_v1 *ext_handle_;
WorkspaceManager& workspaces_manager_;
ext_workspace_group_handle_v1* ext_handle_;
uint32_t id_;
std::vector<wl_output *> outputs_;
std::vector<ext_workspace_handle_v1 *> workspaces_;
std::vector<wl_output*> outputs_;
std::vector<ext_workspace_handle_v1*> workspaces_;
};
class Workspace {
public:
Workspace(const Json::Value &config, WorkspaceManager &manager, ext_workspace_handle_v1 *handle,
uint32_t id, const std::string &name);
Workspace(const Json::Value& config, WorkspaceManager& manager, ext_workspace_handle_v1* handle,
uint32_t id, const std::string& name);
~Workspace();
ext_workspace_handle_v1 *handle() const { return ext_handle_; }
ext_workspace_handle_v1* handle() const { return ext_handle_; }
u_int32_t id() const { return id_; }
std::string &workspace_id() { return workspace_id_; }
std::string &name() { return name_; }
std::vector<u_int32_t> &coordinates() { return coordinates_; }
Gtk::Button &button() { return button_; }
std::string& workspace_id() { return workspace_id_; }
std::string& name() { return name_; }
std::vector<u_int32_t>& coordinates() { return coordinates_; }
Gtk::Button& button() { return button_; }
void update();
// wl events
void handle_id(const std::string &id);
void handle_name(const std::string &name);
void handle_coordinates(const std::vector<uint32_t> &coordinates);
void handle_id(const std::string& id);
void handle_name(const std::string& name);
void handle_coordinates(const std::vector<uint32_t>& coordinates);
void handle_state(uint32_t state);
void handle_capabilities(uint32_t capabilities);
void handle_removed();
// gdk events
bool handle_clicked(const GdkEventButton *button) const;
bool handle_clicked(const GdkEventButton* button) const;
private:
bool has_state(uint32_t state) const { return (state_ & state) == state; }
std::string icon();
WorkspaceManager &workspace_manager_;
ext_workspace_handle_v1 *ext_handle_ = nullptr;
WorkspaceManager& workspace_manager_;
ext_workspace_handle_v1* ext_handle_ = nullptr;
uint32_t id_;
uint32_t state_ = 0;
std::string workspace_id_;

12
include/modules/ext/workspace_manager_binding.hpp
View File

@ -1,10 +1,10 @@
#include "ext-workspace-v1-client-protocol.h"
namespace waybar::modules::ext {
void add_registry_listener(void *data);
void add_workspace_listener(ext_workspace_handle_v1 *workspace_handle, void *data);
void add_workspace_group_listener(ext_workspace_group_handle_v1 *workspace_group_handle,
void *data);
ext_workspace_manager_v1 *workspace_manager_bind(wl_registry *registry, uint32_t name,
uint32_t version, void *data);
void add_registry_listener(void* data);
void add_workspace_listener(ext_workspace_handle_v1* workspace_handle, void* data);
void add_workspace_group_listener(ext_workspace_group_handle_v1* workspace_group_handle,
void* data);
ext_workspace_manager_v1* workspace_manager_bind(wl_registry* registry, uint32_t name,
uint32_t version, void* data);
} // namespace waybar::modules::ext

22
include/modules/gamemode.hpp
View File

@ -17,7 +17,7 @@ namespace waybar::modules {
class Gamemode : public AModule {
public:
Gamemode(const std::string &, const Json::Value &);
Gamemode(const std::string&, const Json::Value&);
virtual ~Gamemode();
auto update() -> void override;
@ -28,18 +28,18 @@ class Gamemode : public AModule {
const std::string DEFAULT_TOOLTIP_FORMAT = "Games running: {count}";
const std::string DEFAULT_GLYPH = "";
void appear(const Glib::RefPtr<Gio::DBus::Connection> &connection, const Glib::ustring &name,
const Glib::ustring &name_owner);
void disappear(const Glib::RefPtr<Gio::DBus::Connection> &connection, const Glib::ustring &name);
void prepareForSleep_cb(const Glib::RefPtr<Gio::DBus::Connection> &connection,
const Glib::ustring &sender_name, const Glib::ustring &object_path,
const Glib::ustring &interface_name, const Glib::ustring &signal_name,
const Glib::VariantContainerBase &parameters);
void notify_cb(const Glib::ustring &sender_name, const Glib::ustring &signal_name,
const Glib::VariantContainerBase &arguments);
void appear(const Glib::RefPtr<Gio::DBus::Connection>& connection, const Glib::ustring& name,
const Glib::ustring& name_owner);
void disappear(const Glib::RefPtr<Gio::DBus::Connection>& connection, const Glib::ustring& name);
void prepareForSleep_cb(const Glib::RefPtr<Gio::DBus::Connection>& connection,
const Glib::ustring& sender_name, const Glib::ustring& object_path,
const Glib::ustring& interface_name, const Glib::ustring& signal_name,
const Glib::VariantContainerBase& parameters);
void notify_cb(const Glib::ustring& sender_name, const Glib::ustring& signal_name,
const Glib::VariantContainerBase& arguments);
void getData();
bool handleToggle(GdkEventButton *const &) override;
bool handleToggle(GdkEventButton* const&) override;
// Config
std::string format = DEFAULT_FORMAT;

1
include/modules/hyprland/submap.hpp
View File

@ -26,6 +26,7 @@ class Submap : public waybar::ALabel, public EventHandler {
const Bar& bar_;
util::JsonParser parser_;
std::string submap_;
std::string prev_submap_;
bool always_on_ = false;
std::string default_submap_ = "Default";

12
include/modules/jack.hpp
View File

@ -13,7 +13,7 @@ namespace waybar::modules {
class JACK : public ALabel {
public:
JACK(const std::string &, const Json::Value &);
JACK(const std::string&, const Json::Value&);
virtual ~JACK() = default;
auto update() -> void override;
@ -25,7 +25,7 @@ class JACK : public ALabel {
private:
std::string JACKState();
jack_client_t *client_;
jack_client_t* client_;
jack_nframes_t bufsize_;
jack_nframes_t samplerate_;
unsigned int xruns_;
@ -38,7 +38,7 @@ class JACK : public ALabel {
} // namespace waybar::modules
int bufSizeCallback(jack_nframes_t size, void *obj);
int sampleRateCallback(jack_nframes_t rate, void *obj);
int xrunCallback(void *obj);
void shutdownCallback(void *obj);
int bufSizeCallback(jack_nframes_t size, void* obj);
int sampleRateCallback(jack_nframes_t rate, void* obj);
int xrunCallback(void* obj);
void shutdownCallback(void* obj);

8
include/modules/niri/language.hpp
View File

@ -10,13 +10,13 @@ namespace waybar::modules::niri {
class Language : public ALabel, public EventHandler {
public:
Language(const std::string &, const Bar &, const Json::Value &);
Language(const std::string&, const Bar&, const Json::Value&);
~Language() override;
void update() override;
private:
void updateFromIPC();
void onEvent(const Json::Value &ev) override;
void onEvent(const Json::Value& ev) override;
void doUpdate();
struct Layout {
@ -26,10 +26,10 @@ class Language : public ALabel, public EventHandler {
std::string short_description;
};
static Layout getLayout(const std::string &fullName);
static Layout getLayout(const std::string& fullName);
std::mutex mutex_;
const Bar &bar_;
const Bar& bar_;
std::vector<Layout> layouts_;
unsigned current_idx_;

8
include/modules/niri/window.hpp
View File

@ -11,16 +11,16 @@ namespace waybar::modules::niri {
class Window : public AAppIconLabel, public EventHandler {
public:
Window(const std::string &, const Bar &, const Json::Value &);
Window(const std::string&, const Bar&, const Json::Value&);
~Window() override;
void update() override;
private:
void onEvent(const Json::Value &ev) override;
void onEvent(const Json::Value& ev) override;
void doUpdate();
void setClass(const std::string &className, bool enable);
void setClass(const std::string& className, bool enable);
const Bar &bar_;
const Bar& bar_;
std::string oldAppId_;
};

10
include/modules/niri/workspaces.hpp
View File

@ -11,17 +11,17 @@ namespace waybar::modules::niri {
class Workspaces : public AModule, public EventHandler {
public:
Workspaces(const std::string &, const Bar &, const Json::Value &);
Workspaces(const std::string&, const Bar&, const Json::Value&);
~Workspaces() override;
void update() override;
private:
void onEvent(const Json::Value &ev) override;
void onEvent(const Json::Value& ev) override;
void doUpdate();
Gtk::Button &addButton(const Json::Value &ws);
std::string getIcon(const std::string &value, const Json::Value &ws);
Gtk::Button& addButton(const Json::Value& ws);
std::string getIcon(const std::string& value, const Json::Value& ws);
const Bar &bar_;
const Bar& bar_;
Gtk::Box box_;
// Map from niri workspace id to button.
std::unordered_map<uint64_t, Gtk::Button> buttons_;

16
include/modules/power_profiles_daemon.hpp
View File

@ -16,15 +16,15 @@ struct Profile {
class PowerProfilesDaemon : public ALabel {
public:
PowerProfilesDaemon(const std::string &, const Json::Value &);
PowerProfilesDaemon(const std::string&, const Json::Value&);
auto update() -> void override;
void profileChangedCb(const Gio::DBus::Proxy::MapChangedProperties &,
const std::vector<Glib::ustring> &);
void busConnectedCb(Glib::RefPtr<Gio::AsyncResult> &r);
void getAllPropsCb(Glib::RefPtr<Gio::AsyncResult> &r);
void setPropCb(Glib::RefPtr<Gio::AsyncResult> &r);
void profileChangedCb(const Gio::DBus::Proxy::MapChangedProperties&,
const std::vector<Glib::ustring>&);
void busConnectedCb(Glib::RefPtr<Gio::AsyncResult>& r);
void getAllPropsCb(Glib::RefPtr<Gio::AsyncResult>& r);
void setPropCb(Glib::RefPtr<Gio::AsyncResult>& r);
void populateInitState();
bool handleToggle(GdkEventButton *const &e) override;
bool handleToggle(GdkEventButton* const& e) override;
private:
// True if we're connected to the dbug interface. False if we're
@ -32,7 +32,7 @@ class PowerProfilesDaemon : public ALabel {
bool connected_;
// Look for a profile name in the list of available profiles and
// switch activeProfile_ to it.
void switchToProfile(std::string const &);
void switchToProfile(std::string const&);
// Used to toggle/display the profiles
std::vector<Profile> availableProfiles_;
// Points to the active profile in the profiles list

8
include/modules/privacy/privacy.hpp
View File

@ -13,15 +13,15 @@ namespace waybar::modules::privacy {
class Privacy : public AModule {
public:
Privacy(const std::string &, const Json::Value &, Gtk::Orientation, const std::string &pos);
Privacy(const std::string&, const Json::Value&, Gtk::Orientation, const std::string& pos);
auto update() -> void override;
void onPrivacyNodesChanged();
private:
std::list<PrivacyNodeInfo *> nodes_screenshare; // Screen is being shared
std::list<PrivacyNodeInfo *> nodes_audio_in; // Application is using the microphone
std::list<PrivacyNodeInfo *> nodes_audio_out; // Application is outputting audio
std::list<PrivacyNodeInfo*> nodes_screenshare; // Screen is being shared
std::list<PrivacyNodeInfo*> nodes_audio_in; // Application is using the microphone
std::list<PrivacyNodeInfo*> nodes_audio_out; // Application is outputting audio
std::mutex mutex_;
sigc::connection visibility_conn;

8
include/modules/privacy/privacy_item.hpp
View File

@ -16,16 +16,16 @@ namespace waybar::modules::privacy {
class PrivacyItem : public Gtk::Revealer {
public:
PrivacyItem(const Json::Value &config_, enum PrivacyNodeType privacy_type_,
std::list<PrivacyNodeInfo *> *nodes, Gtk::Orientation orientation,
const std::string &pos, const uint icon_size, const uint transition_duration);
PrivacyItem(const Json::Value& config_, enum PrivacyNodeType privacy_type_,
std::list<PrivacyNodeInfo*>* nodes, Gtk::Orientation orientation,
const std::string& pos, const uint icon_size, const uint transition_duration);
enum PrivacyNodeType privacy_type;
void set_in_use(bool in_use);
private:
std::list<PrivacyNodeInfo *> *nodes;
std::list<PrivacyNodeInfo*>* nodes;
sigc::connection signal_conn;

22
include/modules/river/layout.hpp
View File

@ -10,25 +10,25 @@ namespace waybar::modules::river {
class Layout : public waybar::ALabel {
public:
Layout(const std::string &, const waybar::Bar &, const Json::Value &);
Layout(const std::string&, const waybar::Bar&, const Json::Value&);
virtual ~Layout();
// Handlers for wayland events
void handle_name(const char *name);
void handle_name(const char* name);
void handle_clear();
void handle_focused_output(struct wl_output *output);
void handle_unfocused_output(struct wl_output *output);
void handle_focused_output(struct wl_output* output);
void handle_unfocused_output(struct wl_output* output);
struct zriver_status_manager_v1 *status_manager_;
struct wl_seat *seat_;
struct zriver_status_manager_v1* status_manager_;
struct wl_seat* seat_;
private:
const waybar::Bar &bar_;
const waybar::Bar& bar_;
std::string name_;
struct wl_output *output_; // stores the output this module belongs to
struct wl_output *focused_output_; // stores the currently focused output
struct zriver_output_status_v1 *output_status_;
struct zriver_seat_status_v1 *seat_status_;
struct wl_output* output_; // stores the output this module belongs to
struct wl_output* focused_output_; // stores the currently focused output
struct zriver_output_status_v1* output_status_;
struct zriver_seat_status_v1* seat_status_;
};
} /* namespace waybar::modules::river */

12
include/modules/river/mode.hpp
View File

@ -10,20 +10,20 @@ namespace waybar::modules::river {
class Mode : public waybar::ALabel {
public:
Mode(const std::string &, const waybar::Bar &, const Json::Value &);
Mode(const std::string&, const waybar::Bar&, const Json::Value&);
virtual ~Mode();
// Handlers for wayland events
void handle_mode(const char *mode);
void handle_mode(const char* mode);
struct zriver_status_manager_v1 *status_manager_;
struct wl_seat *seat_;
struct zriver_status_manager_v1* status_manager_;
struct wl_seat* seat_;
private:
const waybar::Bar &bar_;
const waybar::Bar& bar_;
std::set<std::string> hidden_modes_;
std::string mode_;
struct zriver_seat_status_v1 *seat_status_;
struct zriver_seat_status_v1* seat_status_;
};
} /* namespace waybar::modules::river */

20
include/modules/river/tags.hpp
View File

@ -13,32 +13,32 @@ namespace waybar::modules::river {
class Tags : public waybar::AModule {
public:
Tags(const std::string &, const waybar::Bar &, const Json::Value &);
Tags(const std::string&, const waybar::Bar&, const Json::Value&);
virtual ~Tags();
// Handlers for wayland events
void handle_focused_tags(uint32_t tags);
void handle_view_tags(struct wl_array *tags);
void handle_view_tags(struct wl_array* tags);
void handle_urgent_tags(uint32_t tags);
void handle_focused_view(const char *title, uint32_t tags);
void handle_show();
void handle_primary_clicked(uint32_t tag);
bool handle_button_press(GdkEventButton *event_button, uint32_t tag);
bool handle_button_press(GdkEventButton* event_button, uint32_t tag);
struct zriver_status_manager_v1 *status_manager_;
struct zriver_control_v1 *control_;
struct zriver_status_manager_v1* status_manager_;
struct zriver_control_v1* control_;
struct zriver_seat_status_v1 *seat_status_;
struct wl_seat *seat_;
struct wl_seat* seat_;
// used to make sure the focused view tags are on the correct output
const wl_output *output_;
const wl_output *focused_output_;
const wl_output* output_;
const wl_output* focused_output_;
private:
const waybar::Bar &bar_;
const waybar::Bar& bar_;
Gtk::Box box_;
std::vector<Gtk::Button> buttons_;
struct zriver_output_status_v1 *output_status_;
struct zriver_output_status_v1* output_status_;
};
} /* namespace waybar::modules::river */

20
include/modules/river/window.hpp
View File

@ -14,23 +14,23 @@ namespace waybar::modules::river {
class Window : public waybar::ALabel {
public:
Window(const std::string &, const waybar::Bar &, const Json::Value &);
Window(const std::string&, const waybar::Bar&, const Json::Value&);
virtual ~Window();
// Handlers for wayland events
void handle_focused_view(const char *title, uint32_t);
void handle_focused_output(struct wl_output *output);
void handle_unfocused_output(struct wl_output *output);
void handle_focused_view(const char* title, uint32_t tags);
void handle_focused_output(struct wl_output* output);
void handle_unfocused_output(struct wl_output* output);
struct zriver_status_manager_v1 *status_manager_;
struct wl_seat *seat_;
struct zriver_status_manager_v1* status_manager_;
struct wl_seat* seat_;
private:
const waybar::Bar &bar_;
const waybar::Bar& bar_;
std::optional<std::string> default_format_; // format when there is no window
struct wl_output *output_; // stores the output this module belongs to
struct wl_output *focused_output_; // stores the currently focused output
struct zriver_seat_status_v1 *seat_status_;
struct wl_output* output_; // stores the output this module belongs to
struct wl_output* focused_output_; // stores the currently focused output
struct zriver_seat_status_v1* seat_status_;
};
} /* namespace waybar::modules::river */

10
include/modules/sndio.hpp
View File

@ -11,18 +11,18 @@ namespace waybar::modules {
class Sndio : public ALabel {
public:
Sndio(const std::string &, const Json::Value &);
Sndio(const std::string&, const Json::Value&);
virtual ~Sndio();
auto update() -> void override;
auto set_desc(struct sioctl_desc *, unsigned int) -> void;
auto set_desc(struct sioctl_desc*, unsigned int) -> void;
auto put_val(unsigned int, unsigned int) -> void;
bool handleScroll(GdkEventScroll *) override;
bool handleToggle(GdkEventButton *const &) override;
bool handleScroll(GdkEventScroll*) override;
bool handleToggle(GdkEventButton* const&) override;
private:
auto connect_to_sndio() -> void;
util::SleeperThread thread_;
struct sioctl_hdl *hdl_;
struct sioctl_hdl* hdl_;
std::vector<struct pollfd> pfds_;
unsigned int addr_;
unsigned int volume_, old_volume_, maxval_;

28
include/modules/sni/watcher.hpp
View File

@ -30,27 +30,27 @@ class Watcher {
typedef struct {
GfWatchType type;
Watcher *watcher;
gchar *service;
gchar *bus_name;
gchar *object_path;
Watcher* watcher;
gchar* service;
gchar* bus_name;
gchar* object_path;
guint watch_id;
} GfWatch;
void busAcquired(const Glib::RefPtr<Gio::DBus::Connection> &, 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);
void busAcquired(const Glib::RefPtr<Gio::DBus::Connection>&, 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);
void updateRegisteredItems(SnWatcher *obj);
void updateRegisteredItems(SnWatcher* obj);
uint32_t bus_name_id_;
GSList *hosts_ = nullptr;
GSList *items_ = nullptr;
SnWatcher *watcher_ = nullptr;
GSList* hosts_ = nullptr;
GSList* items_ = nullptr;
SnWatcher* watcher_ = nullptr;
};
} // namespace waybar::modules::SNI

14
include/modules/sway/ipc/client.hpp
View File

@ -27,21 +27,21 @@ class Ipc {
std::string payload;
};
sigc::signal<void, const struct ipc_response &> signal_event;
sigc::signal<void, const struct ipc_response &> signal_cmd;
sigc::signal<void, const struct ipc_response&> signal_event;
sigc::signal<void, const struct ipc_response&> signal_cmd;
void sendCmd(uint32_t type, const std::string &payload = "");
void subscribe(const std::string &payload);
void sendCmd(uint32_t type, const std::string& payload = "");
void subscribe(const std::string& payload);
void handleEvent();
void setWorker(std::function<void()> &&func);
void setWorker(std::function<void()>&& func);
protected:
static inline const std::string ipc_magic_ = "i3-ipc";
static inline const size_t ipc_header_size_ = ipc_magic_.size() + 8;
const std::string getSocketPath() const;
int open(const std::string &) const;
struct ipc_response send(int fd, uint32_t type, const std::string &payload = "");
int open(const std::string&) const;
struct ipc_response send(int fd, uint32_t type, const std::string& payload = "");
struct ipc_response recv(int fd);
int fd_;

6
include/modules/systemd_failed_units.hpp
View File

@ -10,7 +10,7 @@ namespace waybar::modules {
class SystemdFailedUnits : public ALabel {
public:
SystemdFailedUnits(const std::string &, const Json::Value &);
SystemdFailedUnits(const std::string&, const Json::Value&);
virtual ~SystemdFailedUnits();
auto update() -> void override;
@ -24,8 +24,8 @@ class SystemdFailedUnits : public ALabel {
std::string last_status;
Glib::RefPtr<Gio::DBus::Proxy> system_proxy, user_proxy;
void notify_cb(const Glib::ustring &sender_name, const Glib::ustring &signal_name,
const Glib::VariantContainerBase &arguments);
void notify_cb(const Glib::ustring& sender_name, const Glib::ustring& signal_name,
const Glib::VariantContainerBase& arguments);
void RequestFailedUnits();
void RequestSystemState();
void updateData();

44
include/modules/upower.hpp
View File

@ -12,7 +12,7 @@ namespace waybar::modules {
class UPower final : public AIconLabel {
public:
UPower(const std::string &, const Json::Value &);
UPower(const std::string&, const Json::Value&);
virtual ~UPower();
auto update() -> void override;
@ -30,17 +30,17 @@ class UPower final : public AIconLabel {
// UPower device info
struct upDevice_output {
UpDevice *upDevice{NULL};
UpDevice* upDevice{NULL};
double percentage{0.0};
double temperature{0.0};
guint64 time_full{0u};
guint64 time_empty{0u};
gchar *icon_name{(char *)'\0'};
gchar* icon_name{(char*)'\0'};
bool upDeviceValid{false};
UpDeviceState state;
UpDeviceKind kind;
char *nativePath{(char *)'\0'};
char *model{(char *)'\0'};
char* nativePath{(char*)'\0'};
char* model{(char*)'\0'};
};
// Technical variables
@ -53,13 +53,13 @@ class UPower final : public AIconLabel {
bool sleeping_;
// Technical functions
void addDevice(UpDevice *);
void removeDevice(const gchar *);
void addDevice(UpDevice*);
void removeDevice(const gchar*);
void removeDevices();
void resetDevices();
void setDisplayDevice();
const Glib::ustring getText(const upDevice_output &upDevice_, const std::string &format);
bool queryTooltipCb(int, int, bool, const Glib::RefPtr<Gtk::Tooltip> &);
const Glib::ustring getText(const upDevice_output& upDevice_, const std::string& format);
bool queryTooltipCb(int, int, bool, const Glib::RefPtr<Gtk::Tooltip>&);
// DBUS variables
guint watcherID_;
@ -67,28 +67,28 @@ class UPower final : public AIconLabel {
guint subscrID_{0u};
// UPower variables
UpClient *upClient_;
UpClient* upClient_;
upDevice_output upDevice_; // Device to display
typedef std::unordered_map<std::string, upDevice_output> Devices;
Devices devices_;
bool upRunning_{true};
// DBus callbacks
void getConn_cb(Glib::RefPtr<Gio::AsyncResult> &result);
void onAppear(const Glib::RefPtr<Gio::DBus::Connection> &, const Glib::ustring &,
const Glib::ustring &);
void onVanished(const Glib::RefPtr<Gio::DBus::Connection> &, const Glib::ustring &);
void prepareForSleep_cb(const Glib::RefPtr<Gio::DBus::Connection> &connection,
const Glib::ustring &sender_name, const Glib::ustring &object_path,
const Glib::ustring &interface_name, const Glib::ustring &signal_name,
const Glib::VariantContainerBase &parameters);
void getConn_cb(Glib::RefPtr<Gio::AsyncResult>& result);
void onAppear(const Glib::RefPtr<Gio::DBus::Connection>&, const Glib::ustring&,
const Glib::ustring&);
void onVanished(const Glib::RefPtr<Gio::DBus::Connection>&, const Glib::ustring&);
void prepareForSleep_cb(const Glib::RefPtr<Gio::DBus::Connection>& connection,
const Glib::ustring& sender_name, const Glib::ustring& object_path,
const Glib::ustring& interface_name, const Glib::ustring& signal_name,
const Glib::VariantContainerBase& parameters);
// UPower callbacks
static void deviceAdded_cb(UpClient *client, UpDevice *device, gpointer data);
static void deviceRemoved_cb(UpClient *client, const gchar *objectPath, gpointer data);
static void deviceNotify_cb(UpDevice *device, GParamSpec *pspec, gpointer user_data);
static void deviceAdded_cb(UpClient* client, UpDevice* device, gpointer data);
static void deviceRemoved_cb(UpClient* client, const gchar* objectPath, gpointer data);
static void deviceNotify_cb(UpDevice* device, GParamSpec* pspec, gpointer user_data);
// UPower secondary functions
void getUpDeviceInfo(upDevice_output &upDevice_);
void getUpDeviceInfo(upDevice_output& upDevice_);
};
} // namespace waybar::modules

70
include/modules/wlr/taskbar.hpp
View File

@ -33,8 +33,8 @@ class Taskbar;
class Task {
public:
Task(const waybar::Bar &, const Json::Value &, Taskbar *,
struct zwlr_foreign_toplevel_handle_v1 *, struct wl_seat *);
Task(const waybar::Bar&, const Json::Value&, Taskbar*, struct zwlr_foreign_toplevel_handle_v1*,
struct wl_seat*);
~Task();
public:
@ -53,11 +53,11 @@ class Task {
static uint32_t global_id;
private:
const waybar::Bar &bar_;
const Json::Value &config_;
Taskbar *tbar_;
struct zwlr_foreign_toplevel_handle_v1 *handle_;
struct wl_seat *seat_;
const waybar::Bar& bar_;
const Json::Value& config_;
Taskbar* tbar_;
struct zwlr_foreign_toplevel_handle_v1* handle_;
struct wl_seat* seat_;
uint32_t id_;
@ -89,7 +89,7 @@ class Task {
std::string repr() const;
std::string state_string(bool = false) const;
void set_minimize_hint();
void on_button_size_allocated(Gtk::Allocation &alloc);
void on_button_size_allocated(Gtk::Allocation& alloc);
void hide_if_ignored();
public:
@ -105,26 +105,26 @@ class Task {
public:
/* Callbacks for the wlr protocol */
void handle_title(const char *);
void handle_app_id(const char *);
void handle_output_enter(struct wl_output *);
void handle_output_leave(struct wl_output *);
void handle_state(struct wl_array *);
void handle_title(const char*);
void handle_app_id(const char*);
void handle_output_enter(struct wl_output*);
void handle_output_leave(struct wl_output*);
void handle_state(struct wl_array*);
void handle_done();
void handle_closed();
/* Callbacks for Gtk events */
bool handle_clicked(GdkEventButton *);
bool handle_button_release(GdkEventButton *);
bool handle_motion_notify(GdkEventMotion *);
void handle_drag_data_get(const Glib::RefPtr<Gdk::DragContext> &context,
Gtk::SelectionData &selection_data, guint info, guint time);
void handle_drag_data_received(const Glib::RefPtr<Gdk::DragContext> &context, int x, int y,
bool handle_clicked(GdkEventButton*);
bool handle_button_release(GdkEventButton*);
bool handle_motion_notify(GdkEventMotion*);
void handle_drag_data_get(const Glib::RefPtr<Gdk::DragContext>& context,
Gtk::SelectionData& selection_data, guint info, guint time);
void handle_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y,
Gtk::SelectionData selection_data, guint info, guint time);
public:
bool operator==(const Task &) const;
bool operator!=(const Task &) const;
bool operator==(const Task&) const;
bool operator!=(const Task&) const;
public:
void update();
@ -142,12 +142,12 @@ using TaskPtr = std::unique_ptr<Task>;
class Taskbar : public waybar::AModule {
public:
Taskbar(const std::string &, const waybar::Bar &, const Json::Value &);
Taskbar(const std::string&, const waybar::Bar&, const Json::Value&);
~Taskbar();
void update();
private:
const waybar::Bar &bar_;
const waybar::Bar& bar_;
Gtk::Box box_;
std::vector<TaskPtr> tasks_;
@ -155,30 +155,30 @@ class Taskbar : public waybar::AModule {
std::unordered_set<std::string> ignore_list_;
std::map<std::string, std::string> app_ids_replace_map_;
struct zwlr_foreign_toplevel_manager_v1 *manager_;
struct wl_seat *seat_;
struct zwlr_foreign_toplevel_manager_v1* manager_;
struct wl_seat* seat_;
public:
/* Callbacks for global registration */
void register_manager(struct wl_registry *, uint32_t name, uint32_t version);
void register_seat(struct wl_registry *, uint32_t name, uint32_t version);
void register_manager(struct wl_registry*, uint32_t name, uint32_t version);
void register_seat(struct wl_registry*, uint32_t name, uint32_t version);
/* Callbacks for the wlr protocol */
void handle_toplevel_create(struct zwlr_foreign_toplevel_handle_v1 *);
void handle_toplevel_create(struct zwlr_foreign_toplevel_handle_v1*);
void handle_finished();
public:
void add_button(Gtk::Button &);
void move_button(Gtk::Button &, int);
void remove_button(Gtk::Button &);
void add_button(Gtk::Button&);
void move_button(Gtk::Button&, int);
void remove_button(Gtk::Button&);
void remove_task(uint32_t);
bool show_output(struct wl_output *) const;
bool show_output(struct wl_output*) const;
bool all_outputs() const;
const IconLoader &icon_loader() const;
const std::unordered_set<std::string> &ignore_list() const;
const std::map<std::string, std::string> &app_ids_replace_map() const;
const IconLoader& icon_loader() const;
const std::unordered_set<std::string>& ignore_list() const;
const std::map<std::string, std::string>& app_ids_replace_map() const;
};
} /* namespace waybar::modules::wlr */

16
include/util/backlight_backend.hpp
View File

@ -36,7 +36,7 @@ class BacklightDevice {
void set_max(int max);
bool get_powered() const;
void set_powered(bool powered);
friend inline bool operator==(const BacklightDevice &lhs, const BacklightDevice &rhs) {
friend inline bool operator==(const BacklightDevice& lhs, const BacklightDevice& rhs) {
return lhs.name_ == rhs.name_ && lhs.actual_ == rhs.actual_ && lhs.max_ == rhs.max_;
}
@ -52,25 +52,25 @@ class BacklightBackend {
BacklightBackend(std::chrono::milliseconds interval, std::function<void()> on_updated_cb = NOOP);
// const inline BacklightDevice *get_best_device(std::string_view preferred_device);
const BacklightDevice *get_previous_best_device();
const BacklightDevice* get_previous_best_device();
void set_previous_best_device(const BacklightDevice *device);
void set_previous_best_device(const BacklightDevice* device);
void set_brightness(const std::string &preferred_device, ChangeType change_type, double step);
void set_brightness(const std::string& preferred_device, ChangeType change_type, double step);
void set_scaled_brightness(const std::string &preferred_device, int brightness);
int get_scaled_brightness(const std::string &preferred_device);
void set_scaled_brightness(const std::string& preferred_device, int brightness);
int get_scaled_brightness(const std::string& preferred_device);
bool is_login_proxy_initialized() const { return static_cast<bool>(login_proxy_); }
static const BacklightDevice *best_device(const std::vector<BacklightDevice> &devices,
static const BacklightDevice* best_device(const std::vector<BacklightDevice>& devices,
std::string_view);
std::vector<BacklightDevice> devices_;
std::mutex udev_thread_mutex_;
private:
void set_brightness_internal(const std::string &device_name, int brightness, int max_brightness);
void set_brightness_internal(const std::string& device_name, int brightness, int max_brightness);
std::function<void()> on_updated_cb_;
std::chrono::milliseconds polling_interval_;

256
include/util/clara.hpp
View File

@ -78,7 +78,7 @@ class Column {
class iterator {
friend Column;
Column const &m_column;
Column const& m_column;
size_t m_stringIndex = 0;
size_t m_pos = 0;
@ -86,10 +86,10 @@ class Column {
size_t m_end = 0;
bool m_suffix = false;
iterator(Column const &column, size_t stringIndex)
iterator(Column const& column, size_t stringIndex)
: m_column(column), m_stringIndex(stringIndex) {}
auto line() const -> std::string const & { return m_column.m_strings[m_stringIndex]; }
auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }
auto isBoundary(size_t at) const -> bool {
assert(at > 0);
@ -129,18 +129,18 @@ class Column {
return initial == std::string::npos ? m_column.m_indent : initial;
}
auto addIndentAndSuffix(std::string const &plain) const -> std::string {
auto addIndentAndSuffix(std::string const& plain) const -> std::string {
return std::string(indent(), ' ') + (m_suffix ? plain + "-" : plain);
}
public:
using difference_type = std::ptrdiff_t;
using value_type = std::string;
using pointer = value_type *;
using reference = value_type &;
using pointer = value_type*;
using reference = value_type&;
using iterator_category = std::forward_iterator_tag;
explicit iterator(Column const &column) : m_column(column) {
explicit iterator(Column const& column) : m_column(column) {
assert(m_column.m_width > m_column.m_indent);
assert(m_column.m_initialIndent == std::string::npos ||
m_column.m_width > m_column.m_initialIndent);
@ -154,7 +154,7 @@ class Column {
return addIndentAndSuffix(line().substr(m_pos, m_len));
}
auto operator++() -> iterator & {
auto operator++() -> iterator& {
m_pos += m_len;
if (m_pos < line().size() && line()[m_pos] == '\n')
m_pos += 1;
@ -174,26 +174,26 @@ class Column {
return prev;
}
auto operator==(iterator const &other) const -> bool {
auto operator==(iterator const& other) const -> bool {
return m_pos == other.m_pos && m_stringIndex == other.m_stringIndex &&
&m_column == &other.m_column;
}
auto operator!=(iterator const &other) const -> bool { return !operator==(other); }
auto operator!=(iterator const& other) const -> bool { return !operator==(other); }
};
using const_iterator = iterator;
explicit Column(std::string const &text) { m_strings.push_back(text); }
explicit Column(std::string const& text) { m_strings.push_back(text); }
auto width(size_t newWidth) -> Column & {
auto width(size_t newWidth) -> Column& {
assert(newWidth > 0);
m_width = newWidth;
return *this;
}
auto indent(size_t newIndent) -> Column & {
auto indent(size_t newIndent) -> Column& {
m_indent = newIndent;
return *this;
}
auto initialIndent(size_t newIndent) -> Column & {
auto initialIndent(size_t newIndent) -> Column& {
m_initialIndent = newIndent;
return *this;
}
@ -202,7 +202,7 @@ class Column {
auto begin() const -> iterator { return iterator(*this); }
auto end() const -> iterator { return {*this, m_strings.size()}; }
inline friend std::ostream &operator<<(std::ostream &os, Column const &col) {
inline friend std::ostream& operator<<(std::ostream& os, Column const& col) {
bool first = true;
for (auto line : col) {
if (first)
@ -214,7 +214,7 @@ class Column {
return os;
}
auto operator+(Column const &other) -> Columns;
auto operator+(Column const& other) -> Columns;
auto toString() const -> std::string {
std::ostringstream oss;
@ -236,34 +236,34 @@ class Columns {
friend Columns;
struct EndTag {};
std::vector<Column> const &m_columns;
std::vector<Column> const& m_columns;
std::vector<Column::iterator> m_iterators;
size_t m_activeIterators;
iterator(Columns const &columns, EndTag) : m_columns(columns.m_columns), m_activeIterators(0) {
iterator(Columns const& columns, EndTag) : m_columns(columns.m_columns), m_activeIterators(0) {
m_iterators.reserve(m_columns.size());
for (auto const &col : m_columns) m_iterators.push_back(col.end());
for (auto const& col : m_columns) m_iterators.push_back(col.end());
}
public:
using difference_type = std::ptrdiff_t;
using value_type = std::string;
using pointer = value_type *;
using reference = value_type &;
using pointer = value_type*;
using reference = value_type&;
using iterator_category = std::forward_iterator_tag;
explicit iterator(Columns const &columns)
explicit iterator(Columns const& columns)
: m_columns(columns.m_columns), m_activeIterators(m_columns.size()) {
m_iterators.reserve(m_columns.size());
for (auto const &col : m_columns) m_iterators.push_back(col.begin());
for (auto const& col : m_columns) m_iterators.push_back(col.begin());
}
auto operator==(iterator const &other) const -> bool {
auto operator==(iterator const& other) const -> bool {
return m_iterators == other.m_iterators;
}
auto operator!=(iterator const &other) const -> bool {
auto operator!=(iterator const& other) const -> bool {
return m_iterators != other.m_iterators;
}
auto operator*() const -> std::string {
@ -284,7 +284,7 @@ class Columns {
}
return row;
}
auto operator++() -> iterator & {
auto operator++() -> iterator& {
for (size_t i = 0; i < m_columns.size(); ++i) {
if (m_iterators[i] != m_columns[i].end()) ++m_iterators[i];
}
@ -301,17 +301,17 @@ class Columns {
auto begin() const -> iterator { return iterator(*this); }
auto end() const -> iterator { return {*this, iterator::EndTag()}; }
auto operator+=(Column const &col) -> Columns & {
auto operator+=(Column const& col) -> Columns& {
m_columns.push_back(col);
return *this;
}
auto operator+(Column const &col) -> Columns {
auto operator+(Column const& col) -> Columns {
Columns combined = *this;
combined += col;
return combined;
}
inline friend std::ostream &operator<<(std::ostream &os, Columns const &cols) {
inline friend std::ostream& operator<<(std::ostream& os, Columns const& cols) {
bool first = true;
for (auto line : cols) {
if (first)
@ -330,7 +330,7 @@ class Columns {
}
};
inline auto Column::operator+(Column const &other) -> Columns {
inline auto Column::operator+(Column const& other) -> Columns {
Columns cols;
cols += *this;
cols += other;
@ -381,7 +381,7 @@ class Args {
std::vector<std::string> m_args;
public:
Args(int argc, char const *const *argv) : m_exeName(argv[0]), m_args(argv + 1, argv + argc) {}
Args(int argc, char const* const* argv) : m_exeName(argv[0]), m_args(argv + 1, argv + argc) {}
Args(std::initializer_list<std::string> args)
: m_exeName(*args.begin()), m_args(args.begin() + 1, args.end()) {}
@ -419,7 +419,7 @@ class TokenStream {
while (it != itEnd && it->empty()) ++it;
if (it != itEnd) {
auto const &next = *it;
auto const& next = *it;
if (isOptPrefix(next[0])) {
auto delimiterPos = next.find_first_of(" :=");
if (delimiterPos != std::string::npos) {
@ -443,7 +443,7 @@ class TokenStream {
}
public:
explicit TokenStream(Args const &args) : TokenStream(args.m_args.begin(), args.m_args.end()) {}
explicit TokenStream(Args const& args) : TokenStream(args.m_args.begin(), args.m_args.end()) {}
TokenStream(Iterator it, Iterator itEnd) : it(it), itEnd(itEnd) { loadBuffer(); }
@ -456,12 +456,12 @@ class TokenStream {
return m_tokenBuffer.front();
}
auto operator->() const -> Token const * {
auto operator->() const -> Token const* {
assert(!m_tokenBuffer.empty());
return &m_tokenBuffer.front();
}
auto operator++() -> TokenStream & {
auto operator++() -> TokenStream& {
if (m_tokenBuffer.size() >= 2) {
m_tokenBuffer.erase(m_tokenBuffer.begin());
} else {
@ -488,7 +488,7 @@ class ResultBase {
template <typename T>
class ResultValueBase : public ResultBase {
public:
auto value() const -> T const & {
auto value() const -> T const& {
enforceOk();
return m_value;
}
@ -496,13 +496,13 @@ class ResultValueBase : public ResultBase {
protected:
ResultValueBase(Type type) : ResultBase(type) {}
ResultValueBase(ResultValueBase const &other) : ResultBase(other) {
ResultValueBase(ResultValueBase const& other) : ResultBase(other) {
if (m_type == ResultBase::Ok) new (&m_value) T(other.m_value);
}
ResultValueBase(Type, T const &value) : ResultBase(Ok) { new (&m_value) T(value); }
ResultValueBase(Type, T const& value) : ResultBase(Ok) { new (&m_value) T(value); }
auto operator=(ResultValueBase const &other) -> ResultValueBase & {
auto operator=(ResultValueBase const& other) -> ResultValueBase& {
if (m_type == ResultBase::Ok) m_value.~T();
ResultBase::operator=(other);
if (m_type == ResultBase::Ok) new (&m_value) T(other.m_value);
@ -528,20 +528,20 @@ template <typename T = void>
class BasicResult : public ResultValueBase<T> {
public:
template <typename U>
explicit BasicResult(BasicResult<U> const &other)
explicit BasicResult(BasicResult<U> const& other)
: ResultValueBase<T>(other.type()), m_errorMessage(other.errorMessage()) {
assert(type() != ResultBase::Ok);
}
template <typename U>
static auto ok(U const &value) -> BasicResult {
static auto ok(U const& value) -> BasicResult {
return {ResultBase::Ok, value};
}
static auto ok() -> BasicResult { return {ResultBase::Ok}; }
static auto logicError(std::string const &message) -> BasicResult {
static auto logicError(std::string const& message) -> BasicResult {
return {ResultBase::LogicError, message};
}
static auto runtimeError(std::string const &message) -> BasicResult {
static auto runtimeError(std::string const& message) -> BasicResult {
return {ResultBase::RuntimeError, message};
}
@ -560,7 +560,7 @@ class BasicResult : public ResultValueBase<T> {
std::string m_errorMessage; // Only populated if resultType is an error
BasicResult(ResultBase::Type type, std::string const &message)
BasicResult(ResultBase::Type type, std::string const& message)
: ResultValueBase<T>(type), m_errorMessage(message) {
assert(m_type != ResultBase::Ok);
}
@ -573,7 +573,7 @@ enum class ParseResultType { Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
class ParseState {
public:
ParseState(ParseResultType type, TokenStream const &remainingTokens)
ParseState(ParseResultType type, TokenStream const& remainingTokens)
: m_type(type), m_remainingTokens(remainingTokens) {}
auto type() const -> ParseResultType { return m_type; }
@ -594,7 +594,7 @@ struct HelpColumns {
};
template <typename T>
inline auto convertInto(std::string const &source, T &target) -> ParserResult {
inline auto convertInto(std::string const& source, T& target) -> ParserResult {
std::stringstream ss;
ss << source;
ss >> target;
@ -603,11 +603,11 @@ inline auto convertInto(std::string const &source, T &target) -> ParserResult {
else
return ParserResult::ok(ParseResultType::Matched);
}
inline auto convertInto(std::string const &source, std::string &target) -> ParserResult {
inline auto convertInto(std::string const& source, std::string& target) -> ParserResult {
target = source;
return ParserResult::ok(ParseResultType::Matched);
}
inline auto convertInto(std::string const &source, bool &target) -> ParserResult {
inline auto convertInto(std::string const& source, bool& target) -> ParserResult {
std::string srcLC = source;
std::transform(srcLC.begin(), srcLC.end(), srcLC.begin(),
[](char c) { return static_cast<char>(::tolower(c)); });
@ -622,7 +622,7 @@ inline auto convertInto(std::string const &source, bool &target) -> ParserResult
}
#ifdef CLARA_CONFIG_OPTIONAL_TYPE
template <typename T>
inline auto convertInto(std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T> &target)
inline auto convertInto(std::string const& source, CLARA_CONFIG_OPTIONAL_TYPE<T>& target)
-> ParserResult {
T temp;
auto result = convertInto(source, temp);
@ -633,10 +633,10 @@ inline auto convertInto(std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T>
struct NonCopyable {
NonCopyable() = default;
NonCopyable(NonCopyable const &) = delete;
NonCopyable(NonCopyable &&) = delete;
NonCopyable &operator=(NonCopyable const &) = delete;
NonCopyable &operator=(NonCopyable &&) = delete;
NonCopyable(NonCopyable const&) = delete;
NonCopyable(NonCopyable&&) = delete;
NonCopyable& operator=(NonCopyable const&) = delete;
NonCopyable& operator=(NonCopyable&&) = delete;
};
struct BoundRef : NonCopyable {
@ -645,7 +645,7 @@ struct BoundRef : NonCopyable {
virtual auto isFlag() const -> bool { return false; }
};
struct BoundValueRefBase : BoundRef {
virtual auto setValue(std::string const &arg) -> ParserResult = 0;
virtual auto setValue(std::string const& arg) -> ParserResult = 0;
};
struct BoundFlagRefBase : BoundRef {
virtual auto setFlag(bool flag) -> ParserResult = 0;
@ -654,22 +654,22 @@ struct BoundFlagRefBase : BoundRef {
template <typename T>
struct BoundValueRef : BoundValueRefBase {
T &m_ref;
T& m_ref;
explicit BoundValueRef(T &ref) : m_ref(ref) {}
explicit BoundValueRef(T& ref) : m_ref(ref) {}
auto setValue(std::string const &arg) -> ParserResult override { return convertInto(arg, m_ref); }
auto setValue(std::string const& arg) -> ParserResult override { return convertInto(arg, m_ref); }
};
template <typename T>
struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
std::vector<T> &m_ref;
std::vector<T>& m_ref;
explicit BoundValueRef(std::vector<T> &ref) : m_ref(ref) {}
explicit BoundValueRef(std::vector<T>& ref) : m_ref(ref) {}
auto isContainer() const -> bool override { return true; }
auto setValue(std::string const &arg) -> ParserResult override {
auto setValue(std::string const& arg) -> ParserResult override {
T temp;
auto result = convertInto(arg, temp);
if (result) m_ref.push_back(temp);
@ -678,9 +678,9 @@ struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
};
struct BoundFlagRef : BoundFlagRefBase {
bool &m_ref;
bool& m_ref;
explicit BoundFlagRef(bool &ref) : m_ref(ref) {}
explicit BoundFlagRef(bool& ref) : m_ref(ref) {}
auto setFlag(bool flag) -> ParserResult override {
m_ref = flag;
@ -694,7 +694,7 @@ struct LambdaInvoker {
"Lambda must return void or clara::ParserResult");
template <typename L, typename ArgType>
static auto invoke(L const &lambda, ArgType const &arg) -> ParserResult {
static auto invoke(L const& lambda, ArgType const& arg) -> ParserResult {
return lambda(arg);
}
};
@ -702,14 +702,14 @@ struct LambdaInvoker {
template <>
struct LambdaInvoker<void> {
template <typename L, typename ArgType>
static auto invoke(L const &lambda, ArgType const &arg) -> ParserResult {
static auto invoke(L const& lambda, ArgType const& arg) -> ParserResult {
lambda(arg);
return ParserResult::ok(ParseResultType::Matched);
}
};
template <typename ArgType, typename L>
inline auto invokeLambda(L const &lambda, std::string const &arg) -> ParserResult {
inline auto invokeLambda(L const& lambda, std::string const& arg) -> ParserResult {
ArgType temp{};
auto result = convertInto(arg, temp);
return !result ? result
@ -721,9 +721,9 @@ struct BoundLambda : BoundValueRefBase {
L m_lambda;
static_assert(UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument");
explicit BoundLambda(L const &lambda) : m_lambda(lambda) {}
explicit BoundLambda(L const& lambda) : m_lambda(lambda) {}
auto setValue(std::string const &arg) -> ParserResult override {
auto setValue(std::string const& arg) -> ParserResult override {
return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>(m_lambda, arg);
}
};
@ -736,7 +736,7 @@ struct BoundFlagLambda : BoundFlagRefBase {
static_assert(std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value,
"flags must be boolean");
explicit BoundFlagLambda(L const &lambda) : m_lambda(lambda) {}
explicit BoundFlagLambda(L const& lambda) : m_lambda(lambda) {}
auto setFlag(bool flag) -> ParserResult override {
return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke(m_lambda, flag);
@ -751,11 +751,11 @@ class ParserBase {
public:
virtual ~ParserBase() = default;
virtual auto validate() const -> Result { return Result::ok(); }
virtual auto parse(std::string const &exeName, TokenStream const &tokens) const
virtual auto parse(std::string const& exeName, TokenStream const& tokens) const
-> InternalParseResult = 0;
virtual auto cardinality() const -> size_t { return 1; }
auto parse(Args const &args) const -> InternalParseResult {
auto parse(Args const& args) const -> InternalParseResult {
return parse(args.exeName(), TokenStream(args));
}
};
@ -764,10 +764,10 @@ template <typename DerivedT>
class ComposableParserImpl : public ParserBase {
public:
template <typename T>
auto operator|(T const &other) const -> Parser;
auto operator|(T const& other) const -> Parser;
template <typename T>
auto operator+(T const &other) const -> Parser;
auto operator+(T const& other) const -> Parser;
};
// Common code and state for Args and Opts
@ -779,30 +779,30 @@ class ParserRefImpl : public ComposableParserImpl<DerivedT> {
std::string m_hint;
std::string m_description;
explicit ParserRefImpl(std::shared_ptr<BoundRef> const &ref) : m_ref(ref) {}
explicit ParserRefImpl(std::shared_ptr<BoundRef> const& ref) : m_ref(ref) {}
public:
template <typename T>
ParserRefImpl(T &ref, std::string const &hint)
ParserRefImpl(T& ref, std::string const& hint)
: m_ref(std::make_shared<BoundValueRef<T>>(ref)), m_hint(hint) {}
template <typename LambdaT>
ParserRefImpl(LambdaT const &ref, std::string const &hint)
ParserRefImpl(LambdaT const& ref, std::string const& hint)
: m_ref(std::make_shared<BoundLambda<LambdaT>>(ref)), m_hint(hint) {}
auto operator()(std::string const &description) -> DerivedT & {
auto operator()(std::string const& description) -> DerivedT& {
m_description = description;
return static_cast<DerivedT &>(*this);
return static_cast<DerivedT&>(*this);
}
auto optional() -> DerivedT & {
auto optional() -> DerivedT& {
m_optionality = Optionality::Optional;
return static_cast<DerivedT &>(*this);
return static_cast<DerivedT&>(*this);
};
auto required() -> DerivedT & {
auto required() -> DerivedT& {
m_optionality = Optionality::Required;
return static_cast<DerivedT &>(*this);
return static_cast<DerivedT&>(*this);
};
auto isOptional() const -> bool { return m_optionality == Optionality::Optional; }
@ -822,29 +822,29 @@ class ExeName : public ComposableParserImpl<ExeName> {
std::shared_ptr<BoundValueRefBase> m_ref;
template <typename LambdaT>
static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<BoundValueRefBase> {
static auto makeRef(LambdaT const& lambda) -> std::shared_ptr<BoundValueRefBase> {
return std::make_shared<BoundLambda<LambdaT>>(lambda);
}
public:
ExeName() : m_name(std::make_shared<std::string>("<executable>")) {}
explicit ExeName(std::string &ref) : ExeName() {
explicit ExeName(std::string& ref) : ExeName() {
m_ref = std::make_shared<BoundValueRef<std::string>>(ref);
}
template <typename LambdaT>
explicit ExeName(LambdaT const &lambda) : ExeName() {
explicit ExeName(LambdaT const& lambda) : ExeName() {
m_ref = std::make_shared<BoundLambda<LambdaT>>(lambda);
}
// The exe name is not parsed out of the normal tokens, but is handled specially
auto parse(std::string const &, TokenStream const &tokens) const -> InternalParseResult override {
auto parse(std::string const&, TokenStream const& tokens) const -> InternalParseResult override {
return InternalParseResult::ok(ParseState(ParseResultType::NoMatch, tokens));
}
auto name() const -> std::string { return *m_name; }
auto set(std::string const &newName) -> ParserResult {
auto set(std::string const& newName) -> ParserResult {
auto lastSlash = newName.find_last_of("\\/");
auto filename = (lastSlash == std::string::npos) ? newName : newName.substr(lastSlash + 1);
@ -860,17 +860,17 @@ class Arg : public ParserRefImpl<Arg> {
public:
using ParserRefImpl::ParserRefImpl;
auto parse(std::string const &, TokenStream const &tokens) const -> InternalParseResult override {
auto parse(std::string const&, TokenStream const& tokens) const -> InternalParseResult override {
auto validationResult = validate();
if (!validationResult) return InternalParseResult(validationResult);
auto remainingTokens = tokens;
auto const &token = *remainingTokens;
auto const& token = *remainingTokens;
if (token.type != TokenType::Argument)
return InternalParseResult::ok(ParseState(ParseResultType::NoMatch, remainingTokens));
assert(!m_ref->isFlag());
auto valueRef = static_cast<detail::BoundValueRefBase *>(m_ref.get());
auto valueRef = static_cast<detail::BoundValueRefBase*>(m_ref.get());
auto result = valueRef->setValue(remainingTokens->token);
if (!result)
@ -880,7 +880,7 @@ class Arg : public ParserRefImpl<Arg> {
}
};
inline auto normaliseOpt(std::string const &optName) -> std::string {
inline auto normaliseOpt(std::string const& optName) -> std::string {
#ifdef CLARA_PLATFORM_WINDOWS
if (optName[0] == '/')
return "-" + optName.substr(1);
@ -895,18 +895,18 @@ class Opt : public ParserRefImpl<Opt> {
public:
template <typename LambdaT>
explicit Opt(LambdaT const &ref)
explicit Opt(LambdaT const& ref)
: ParserRefImpl(std::make_shared<BoundFlagLambda<LambdaT>>(ref)) {}
explicit Opt(bool &ref) : ParserRefImpl(std::make_shared<BoundFlagRef>(ref)) {}
explicit Opt(bool& ref) : ParserRefImpl(std::make_shared<BoundFlagRef>(ref)) {}
template <typename LambdaT>
Opt(LambdaT const &ref, std::string const &hint) : ParserRefImpl(ref, hint) {}
Opt(LambdaT const& ref, std::string const& hint) : ParserRefImpl(ref, hint) {}
template <typename T>
Opt(T &ref, std::string const &hint) : ParserRefImpl(ref, hint) {}
Opt(T& ref, std::string const& hint) : ParserRefImpl(ref, hint) {}
auto operator[](std::string const &optName) -> Opt & {
auto operator[](std::string const& optName) -> Opt& {
m_optNames.push_back(optName);
return *this;
}
@ -914,7 +914,7 @@ class Opt : public ParserRefImpl<Opt> {
auto getHelpColumns() const -> std::vector<HelpColumns> {
std::ostringstream oss;
bool first = true;
for (auto const &opt : m_optNames) {
for (auto const& opt : m_optNames) {
if (first)
first = false;
else
@ -925,9 +925,9 @@ class Opt : public ParserRefImpl<Opt> {
return {{oss.str(), m_description}};
}
auto isMatch(std::string const &optToken) const -> bool {
auto isMatch(std::string const& optToken) const -> bool {
auto normalisedToken = normaliseOpt(optToken);
for (auto const &name : m_optNames) {
for (auto const& name : m_optNames) {
if (normaliseOpt(name) == normalisedToken) return true;
}
return false;
@ -935,26 +935,26 @@ class Opt : public ParserRefImpl<Opt> {
using ParserBase::parse;
auto parse(std::string const &, TokenStream const &tokens) const -> InternalParseResult override {
auto parse(std::string const&, TokenStream const& tokens) const -> InternalParseResult override {
auto validationResult = validate();
if (!validationResult) return InternalParseResult(validationResult);
auto remainingTokens = tokens;
if (remainingTokens && remainingTokens->type == TokenType::Option) {
auto const &token = *remainingTokens;
auto const& token = *remainingTokens;
if (isMatch(token.token)) {
if (m_ref->isFlag()) {
auto flagRef = static_cast<detail::BoundFlagRefBase *>(m_ref.get());
auto flagRef = static_cast<detail::BoundFlagRefBase*>(m_ref.get());
auto result = flagRef->setFlag(true);
if (!result) return InternalParseResult(result);
if (result.value() == ParseResultType::ShortCircuitAll)
return InternalParseResult::ok(ParseState(result.value(), remainingTokens));
} else {
auto valueRef = static_cast<detail::BoundValueRefBase *>(m_ref.get());
auto valueRef = static_cast<detail::BoundValueRefBase*>(m_ref.get());
++remainingTokens;
if (!remainingTokens)
return InternalParseResult::runtimeError("Expected argument following " + token.token);
auto const &argToken = *remainingTokens;
auto const& argToken = *remainingTokens;
if (argToken.type != TokenType::Argument)
return InternalParseResult::runtimeError("Expected argument following " + token.token);
auto result = valueRef->setValue(argToken.token);
@ -970,7 +970,7 @@ class Opt : public ParserRefImpl<Opt> {
auto validate() const -> Result override {
if (m_optNames.empty()) return Result::logicError("No options supplied to Opt");
for (auto const &name : m_optNames) {
for (auto const& name : m_optNames) {
if (name.empty()) return Result::logicError("Option name cannot be empty");
#ifdef CLARA_PLATFORM_WINDOWS
if (name[0] != '-' && name[0] != '/')
@ -984,12 +984,12 @@ class Opt : public ParserRefImpl<Opt> {
};
struct Help : Opt {
Help(bool &showHelpFlag)
Help(bool& showHelpFlag)
: Opt([&](bool flag) {
showHelpFlag = flag;
return ParserResult::ok(ParseResultType::ShortCircuitAll);
}) {
static_cast<Opt &>(*this)("display usage information")["-?"]["-h"]["--help"].optional();
static_cast<Opt&>(*this)("display usage information")["-?"]["-h"]["--help"].optional();
}
};
@ -998,57 +998,57 @@ struct Parser : ParserBase {
std::vector<Opt> m_options;
std::vector<Arg> m_args;
auto operator|=(ExeName const &exeName) -> Parser & {
auto operator|=(ExeName const& exeName) -> Parser& {
m_exeName = exeName;
return *this;
}
auto operator|=(Arg const &arg) -> Parser & {
auto operator|=(Arg const& arg) -> Parser& {
m_args.push_back(arg);
return *this;
}
auto operator|=(Opt const &opt) -> Parser & {
auto operator|=(Opt const& opt) -> Parser& {
m_options.push_back(opt);
return *this;
}
auto operator|=(Parser const &other) -> Parser & {
auto operator|=(Parser const& other) -> Parser& {
m_options.insert(m_options.end(), other.m_options.begin(), other.m_options.end());
m_args.insert(m_args.end(), other.m_args.begin(), other.m_args.end());
return *this;
}
template <typename T>
auto operator|(T const &other) const -> Parser {
auto operator|(T const& other) const -> Parser {
return Parser(*this) |= other;
}
// Forward deprecated interface with '+' instead of '|'
template <typename T>
auto operator+=(T const &other) -> Parser & {
auto operator+=(T const& other) -> Parser& {
return operator|=(other);
}
template <typename T>
auto operator+(T const &other) const -> Parser {
auto operator+(T const& other) const -> Parser {
return operator|(other);
}
auto getHelpColumns() const -> std::vector<HelpColumns> {
std::vector<HelpColumns> cols;
for (auto const &o : m_options) {
for (auto const& o : m_options) {
auto childCols = o.getHelpColumns();
cols.insert(cols.end(), childCols.begin(), childCols.end());
}
return cols;
}
void writeToStream(std::ostream &os) const {
void writeToStream(std::ostream& os) const {
if (!m_exeName.name().empty()) {
os << "usage:\n"
<< " " << m_exeName.name() << " ";
bool required = true, first = true;
for (auto const &arg : m_args) {
for (auto const& arg : m_args) {
if (first)
first = false;
else
@ -1068,28 +1068,28 @@ struct Parser : ParserBase {
auto rows = getHelpColumns();
size_t consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH;
size_t optWidth = 0;
for (auto const &cols : rows) optWidth = (std::max)(optWidth, cols.left.size() + 2);
for (auto const& cols : rows) optWidth = (std::max)(optWidth, cols.left.size() + 2);
optWidth = (std::min)(optWidth, consoleWidth / 2);
for (auto const &cols : rows) {
for (auto const& cols : rows) {
auto row = TextFlow::Column(cols.left).width(optWidth).indent(2) + TextFlow::Spacer(4) +
TextFlow::Column(cols.right).width(consoleWidth - 7 - optWidth);
os << row << std::endl;
}
}
friend auto operator<<(std::ostream &os, Parser const &parser) -> std::ostream & {
friend auto operator<<(std::ostream& os, Parser const& parser) -> std::ostream& {
parser.writeToStream(os);
return os;
}
auto validate() const -> Result override {
for (auto const &opt : m_options) {
for (auto const& opt : m_options) {
auto result = opt.validate();
if (!result) return result;
}
for (auto const &arg : m_args) {
for (auto const& arg : m_args) {
auto result = arg.validate();
if (!result) return result;
}
@ -1098,10 +1098,10 @@ struct Parser : ParserBase {
using ParserBase::parse;
auto parse(std::string const &exeName, TokenStream const &tokens) const
auto parse(std::string const& exeName, TokenStream const& tokens) const
-> InternalParseResult override {
struct ParserInfo {
ParserBase const *parser = nullptr;
ParserBase const* parser = nullptr;
size_t count = 0;
};
const size_t totalParsers = m_options.size() + m_args.size();
@ -1111,8 +1111,8 @@ struct Parser : ParserBase {
{
size_t i = 0;
for (auto const &opt : m_options) parseInfos[i++].parser = &opt;
for (auto const &arg : m_args) parseInfos[i++].parser = &arg;
for (auto const& opt : m_options) parseInfos[i++].parser = &opt;
for (auto const& arg : m_args) parseInfos[i++].parser = &arg;
}
m_exeName.set(exeName);
@ -1122,7 +1122,7 @@ struct Parser : ParserBase {
bool tokenParsed = false;
for (size_t i = 0; i < totalParsers; ++i) {
auto &parseInfo = parseInfos[i];
auto& parseInfo = parseInfos[i];
if (parseInfo.parser->cardinality() == 0 ||
parseInfo.count < parseInfo.parser->cardinality()) {
result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
@ -1147,8 +1147,8 @@ struct Parser : ParserBase {
template <typename DerivedT>
template <typename T>
auto ComposableParserImpl<DerivedT>::operator|(T const &other) const -> Parser {
return Parser() | static_cast<DerivedT const &>(*this) | other;
auto ComposableParserImpl<DerivedT>::operator|(T const& other) const -> Parser {
return Parser() | static_cast<DerivedT const&>(*this) | other;
}
} // namespace detail

11
include/util/command.hpp
View File

@ -109,7 +109,7 @@ inline FILE* open(const std::string& cmd, int& pid, const std::string& output_na
::close(fd[0]);
dup2(fd[1], 1);
setpgid(child_pid, child_pid);
if (output_name != "") {
if (!output_name.empty()) {
setenv("WAYBAR_OUTPUT_NAME", output_name.c_str(), 1);
}
execlp("/bin/sh", "sh", "-c", cmd.c_str(), (char*)0);
@ -138,7 +138,7 @@ inline struct res execNoRead(const std::string& cmd) {
return {WEXITSTATUS(stat), ""};
}
inline int32_t forkExec(const std::string& cmd) {
inline int32_t forkExec(const std::string& cmd, const std::string& output_name) {
if (cmd == "") return -1;
pid_t pid = fork();
@ -157,6 +157,9 @@ inline int32_t forkExec(const std::string& cmd) {
err = pthread_sigmask(SIG_UNBLOCK, &mask, nullptr);
if (err != 0) spdlog::error("pthread_sigmask in forkExec failed: {}", strerror(err));
setpgid(pid, pid);
if (!output_name.empty()) {
setenv("WAYBAR_OUTPUT_NAME", output_name.c_str(), 1);
}
execl("/bin/sh", "sh", "-c", cmd.c_str(), (char*)0);
exit(0);
} else {
@ -169,4 +172,8 @@ inline int32_t forkExec(const std::string& cmd) {
return pid;
}
inline int32_t forkExec(const std::string& cmd) {
return forkExec(cmd, "");
}
} // namespace waybar::util::command

18
include/util/icon_loader.hpp
View File

@ -17,18 +17,18 @@ class IconLoader {
std::vector<Glib::RefPtr<Gtk::IconTheme>> custom_icon_themes_;
Glib::RefPtr<Gtk::IconTheme> default_icon_theme_ = Gtk::IconTheme::get_default();
static std::vector<std::string> search_prefix();
static Glib::RefPtr<Gio::DesktopAppInfo> get_app_info_by_name(const std::string &app_id);
static Glib::RefPtr<Gio::DesktopAppInfo> get_desktop_app_info(const std::string &app_id);
static Glib::RefPtr<Gdk::Pixbuf> load_icon_from_file(std::string const &icon_path, int size);
static std::string get_icon_name_from_icon_theme(const Glib::RefPtr<Gtk::IconTheme> &icon_theme,
const std::string &app_id);
static bool image_load_icon(Gtk::Image &image, const Glib::RefPtr<Gtk::IconTheme> &icon_theme,
static Glib::RefPtr<Gio::DesktopAppInfo> get_app_info_by_name(const std::string& app_id);
static Glib::RefPtr<Gio::DesktopAppInfo> get_desktop_app_info(const std::string& app_id);
static Glib::RefPtr<Gdk::Pixbuf> load_icon_from_file(std::string const& icon_path, int size);
static std::string get_icon_name_from_icon_theme(const Glib::RefPtr<Gtk::IconTheme>& icon_theme,
const std::string& app_id);
static bool image_load_icon(Gtk::Image& image, const Glib::RefPtr<Gtk::IconTheme>& icon_theme,
Glib::RefPtr<Gio::DesktopAppInfo> app_info, int size);
public:
void add_custom_icon_theme(const std::string &theme_name);
bool image_load_icon(Gtk::Image &image, Glib::RefPtr<Gio::DesktopAppInfo> app_info,
void add_custom_icon_theme(const std::string& theme_name);
bool image_load_icon(Gtk::Image& image, Glib::RefPtr<Gio::DesktopAppInfo> app_info,
int size) const;
static Glib::RefPtr<Gio::DesktopAppInfo> get_app_info_from_app_id_list(
const std::string &app_id_list);
const std::string& app_id_list);
};

7
include/util/json.hpp
View File

@ -30,15 +30,16 @@ class JsonParser {
std::istringstream jsonStream(modifiedJsonStr);
std::string errs;
if (!Json::parseFromStream(m_readerBuilder, jsonStream, &root, &errs)) {
// Use local CharReaderBuilder for thread safety - the IPC singleton's
// parser can be called concurrently from multiple module threads
Json::CharReaderBuilder readerBuilder;
if (!Json::parseFromStream(readerBuilder, jsonStream, &root, &errs)) {
throw std::runtime_error("Error parsing JSON: " + errs);
}
return root;
}
private:
Json::CharReaderBuilder m_readerBuilder;
static std::string replaceHexadecimalEscape(const std::string& str) {
static std::regex re("\\\\x");
return std::regex_replace(str, re, "\\u00");

4
include/util/pipewire/privacy_node_info.hpp
View File

@ -33,14 +33,14 @@ class PrivacyNodeInfo {
struct spa_hook object_listener;
struct spa_hook proxy_listener;
void *data;
void* data;
std::string getName();
std::string getIconName();
// Handlers for PipeWire events
void handleProxyEventDestroy();
void handleNodeEventInfo(const struct pw_node_info *info);
void handleNodeEventInfo(const struct pw_node_info* info);
};
} // namespace waybar::util::PipewireBackend

21
include/util/udev_deleter.hpp Normal file
View File

@ -0,0 +1,21 @@
#pragma once
#include <libudev.h>
namespace waybar::util {
struct UdevDeleter {
void operator()(udev* ptr) const { udev_unref(ptr); }
};
struct UdevDeviceDeleter {
void operator()(udev_device* ptr) const { udev_device_unref(ptr); }
};
struct UdevEnumerateDeleter {
void operator()(udev_enumerate* ptr) const { udev_enumerate_unref(ptr); }
};
struct UdevMonitorDeleter {
void operator()(udev_monitor* ptr) const { udev_monitor_unref(ptr); }
};
} // namespace waybar::util

2
include/util/ustring_clen.hpp
View File

@ -2,4 +2,4 @@
#include <glibmm/ustring.h>
// calculate column width of ustring
int ustring_clen(const Glib::ustring &str);
int ustring_clen(const Glib::ustring& str);