refactor: lint

pull/1492/head^2
Alex 2022-04-06 08:37:19 +02:00
parent 168ba2ca5b
commit f2fcadbf62
99 changed files with 3173 additions and 3512 deletions

View File

@ -1,6 +1,5 @@
--- ---
BasedOnStyle: Google BasedOnStyle: Google
AlignConsecutiveDeclarations: true AlignConsecutiveDeclarations: false
BinPackArguments: false
ColumnLimit: 100 ColumnLimit: 100
... ...

View File

@ -3,6 +3,7 @@
#include <glibmm/markup.h> #include <glibmm/markup.h>
#include <gtkmm/label.h> #include <gtkmm/label.h>
#include <json/json.h> #include <json/json.h>
#include "AModule.hpp" #include "AModule.hpp"
namespace waybar { namespace waybar {
@ -10,7 +11,8 @@ namespace waybar {
class ALabel : public AModule { class ALabel : public AModule {
public: 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); uint16_t interval = 0, bool ellipsize = false, bool enable_click = false,
bool enable_scroll = false);
virtual ~ALabel() = default; virtual ~ALabel() = default;
virtual auto update() -> void; virtual auto update() -> void;
virtual std::string getIcon(uint16_t, const std::string &alt = "", uint16_t max = 0); virtual std::string getIcon(uint16_t, const std::string &alt = "", uint16_t max = 0);

View File

@ -51,8 +51,7 @@ class AModule : public IModule {
{std::make_pair(8, GdkEventType::GDK_2BUTTON_PRESS), "on-triple-click-backward"}, {std::make_pair(8, GdkEventType::GDK_2BUTTON_PRESS), "on-triple-click-backward"},
{std::make_pair(9, GdkEventType::GDK_BUTTON_PRESS), "on-click-forward"}, {std::make_pair(9, GdkEventType::GDK_BUTTON_PRESS), "on-click-forward"},
{std::make_pair(9, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click-forward"}, {std::make_pair(9, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click-forward"},
{std::make_pair(9, GdkEventType::GDK_2BUTTON_PRESS), "on-triple-click-forward"} {std::make_pair(9, GdkEventType::GDK_2BUTTON_PRESS), "on-triple-click-forward"}};
};
}; };
} // namespace waybar } // namespace waybar

View File

@ -7,10 +7,10 @@
#include "modules/simpleclock.hpp" #include "modules/simpleclock.hpp"
#endif #endif
#ifdef HAVE_SWAY #ifdef HAVE_SWAY
#include "modules/sway/language.hpp"
#include "modules/sway/mode.hpp" #include "modules/sway/mode.hpp"
#include "modules/sway/window.hpp" #include "modules/sway/window.hpp"
#include "modules/sway/workspaces.hpp" #include "modules/sway/workspaces.hpp"
#include "modules/sway/language.hpp"
#endif #endif
#ifdef HAVE_WLR #ifdef HAVE_WLR
#include "modules/wlr/taskbar.hpp" #include "modules/wlr/taskbar.hpp"

View File

@ -1,8 +1,9 @@
#pragma once #pragma once
#include <gtkmm/widget.h>
#include <gtkmm/box.h> #include <gtkmm/box.h>
#include <gtkmm/widget.h>
#include <json/json.h> #include <json/json.h>
#include "AModule.hpp" #include "AModule.hpp"
#include "bar.hpp" #include "bar.hpp"
#include "factory.hpp" #include "factory.hpp"

View File

@ -7,10 +7,12 @@
#endif #endif
#include <fmt/format.h> #include <fmt/format.h>
#include <sys/inotify.h> #include <sys/inotify.h>
#include <algorithm> #include <algorithm>
#include <fstream> #include <fstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include "ALabel.hpp" #include "ALabel.hpp"
#include "util/sleeper_thread.hpp" #include "util/sleeper_thread.hpp"

View File

@ -1,6 +1,7 @@
#pragma once #pragma once
#include <date/tz.h> #include <date/tz.h>
#include "ALabel.hpp" #include "ALabel.hpp"
#include "util/sleeper_thread.hpp" #include "util/sleeper_thread.hpp"

View File

@ -1,12 +1,14 @@
#pragma once #pragma once
#include <fmt/format.h> #include <fmt/format.h>
#include <cstdint> #include <cstdint>
#include <fstream> #include <fstream>
#include <numeric> #include <numeric>
#include <string> #include <string>
#include <utility> #include <utility>
#include <vector> #include <vector>
#include "ALabel.hpp" #include "ALabel.hpp"
#include "util/sleeper_thread.hpp" #include "util/sleeper_thread.hpp"

View File

@ -1,8 +1,10 @@
#pragma once #pragma once
#include <fmt/format.h> #include <fmt/format.h>
#include <csignal> #include <csignal>
#include <string> #include <string>
#include "ALabel.hpp" #include "ALabel.hpp"
#include "util/command.hpp" #include "util/command.hpp"
#include "util/json.hpp" #include "util/json.hpp"

View File

@ -1,11 +1,13 @@
#pragma once #pragma once
#include <fmt/format.h> #include <fmt/format.h>
#include <fstream>
#include <sys/statvfs.h> #include <sys/statvfs.h>
#include <fstream>
#include "ALabel.hpp" #include "ALabel.hpp"
#include "util/sleeper_thread.hpp"
#include "util/format.hpp" #include "util/format.hpp"
#include "util/sleeper_thread.hpp"
namespace waybar::modules { namespace waybar::modules {

View File

@ -1,6 +1,7 @@
#pragma once #pragma once
#include <fmt/format.h> #include <fmt/format.h>
#include "ALabel.hpp" #include "ALabel.hpp"
#include "bar.hpp" #include "bar.hpp"
#include "client.hpp" #include "client.hpp"

View File

@ -1,9 +1,9 @@
#pragma once #pragma once
#include <memory>
#include <gio/gio.h> #include <gio/gio.h>
#include <memory>
#include "ALabel.hpp" #include "ALabel.hpp"
#include "bar.hpp" #include "bar.hpp"

View File

@ -6,10 +6,11 @@
#else #else
#include <fmt/chrono.h> #include <fmt/chrono.h>
#endif #endif
#include <gtkmm/label.h>
#include "AModule.hpp" #include "AModule.hpp"
#include "bar.hpp" #include "bar.hpp"
#include "util/sleeper_thread.hpp" #include "util/sleeper_thread.hpp"
#include <gtkmm/label.h>
extern "C" { extern "C" {
#include <libevdev/libevdev.h> #include <libevdev/libevdev.h>

View File

@ -1,8 +1,10 @@
#pragma once #pragma once
#include <fmt/format.h> #include <fmt/format.h>
#include <fstream> #include <fstream>
#include <unordered_map> #include <unordered_map>
#include "ALabel.hpp" #include "ALabel.hpp"
#include "util/sleeper_thread.hpp" #include "util/sleeper_thread.hpp"

View File

@ -1,7 +1,7 @@
#pragma once #pragma once
#include <mpd/client.h>
#include <fmt/format.h> #include <fmt/format.h>
#include <mpd/client.h>
#include <spdlog/spdlog.h> #include <spdlog/spdlog.h>
#include <condition_variable> #include <condition_variable>

View File

@ -12,9 +12,7 @@ inline void Context::tryConnect() const { mpd_module_->tryConne
inline unique_connection& Context::connection() { return mpd_module_->connection_; } inline unique_connection& Context::connection() { return mpd_module_->connection_; }
constexpr inline mpd_state Context::state() const { return mpd_module_->state_; } constexpr inline mpd_state Context::state() const { return mpd_module_->state_; }
inline void Context::do_update() { inline void Context::do_update() { mpd_module_->setLabel(); }
mpd_module_->setLabel();
}
inline void Context::checkErrors(mpd_connection* conn) const { mpd_module_->checkErrors(conn); } inline void Context::checkErrors(mpd_connection* conn) const { mpd_module_->checkErrors(conn); }
inline void Context::queryMPD() const { mpd_module_->queryMPD(); } inline void Context::queryMPD() const { mpd_module_->queryMPD(); }

View File

@ -7,6 +7,7 @@
#include <netlink/genl/genl.h> #include <netlink/genl/genl.h>
#include <netlink/netlink.h> #include <netlink/netlink.h>
#include <sys/epoll.h> #include <sys/epoll.h>
#include "ALabel.hpp" #include "ALabel.hpp"
#include "util/sleeper_thread.hpp" #include "util/sleeper_thread.hpp"
#ifdef WANT_RFKILL #ifdef WANT_RFKILL

View File

@ -3,8 +3,10 @@
#include <fmt/format.h> #include <fmt/format.h>
#include <pulse/pulseaudio.h> #include <pulse/pulseaudio.h>
#include <pulse/volume.h> #include <pulse/volume.h>
#include <algorithm> #include <algorithm>
#include <array> #include <array>
#include "ALabel.hpp" #include "ALabel.hpp"
namespace waybar::modules { namespace waybar::modules {

View File

@ -5,8 +5,8 @@
#include "AModule.hpp" #include "AModule.hpp"
#include "bar.hpp" #include "bar.hpp"
#include "river-status-unstable-v1-client-protocol.h"
#include "river-control-unstable-v1-client-protocol.h" #include "river-control-unstable-v1-client-protocol.h"
#include "river-status-unstable-v1-client-protocol.h"
#include "xdg-output-unstable-v1-client-protocol.h" #include "xdg-output-unstable-v1-client-protocol.h"
namespace waybar::modules::river { namespace waybar::modules::river {

View File

@ -1,7 +1,9 @@
#pragma once #pragma once
#include <sndio.h> #include <sndio.h>
#include <vector> #include <vector>
#include "ALabel.hpp" #include "ALabel.hpp"
#include "util/sleeper_thread.hpp" #include "util/sleeper_thread.hpp"

View File

@ -4,7 +4,9 @@
#include <giomm.h> #include <giomm.h>
#include <glibmm/refptr.h> #include <glibmm/refptr.h>
#include <json/json.h> #include <json/json.h>
#include <tuple> #include <tuple>
#include "bar.hpp" #include "bar.hpp"
#include "modules/sni/item.hpp" #include "modules/sni/item.hpp"

View File

@ -1,6 +1,7 @@
#pragma once #pragma once
#include <fmt/format.h> #include <fmt/format.h>
#include "AModule.hpp" #include "AModule.hpp"
#include "bar.hpp" #include "bar.hpp"
#include "modules/sni/host.hpp" #include "modules/sni/host.hpp"

View File

@ -4,9 +4,11 @@
#include <sys/socket.h> #include <sys/socket.h>
#include <sys/un.h> #include <sys/un.h>
#include <unistd.h> #include <unistd.h>
#include <cstring> #include <cstring>
#include <memory> #include <memory>
#include <mutex> #include <mutex>
#include "ipc.hpp" #include "ipc.hpp"
#include "util/sleeper_thread.hpp" #include "util/sleeper_thread.hpp"

View File

@ -21,11 +21,7 @@ class Language : public ALabel, public sigc::trackable {
auto update() -> void; auto update() -> void;
private: private:
enum class DispayedShortFlag { enum class DispayedShortFlag { None = 0, ShortName = 1, ShortDescription = 1 << 1 };
None = 0,
ShortName = 1,
ShortDescription = 1 << 1
};
struct Layout { struct Layout {
std::string full_name; std::string full_name;
@ -40,6 +36,7 @@ class Language : public ALabel, public sigc::trackable {
XKBContext(); XKBContext();
~XKBContext(); ~XKBContext();
auto next_layout() -> Layout*; auto next_layout() -> Layout*;
private: private:
rxkb_context* context_ = nullptr; rxkb_context* context_ = nullptr;
rxkb_layout* xkb_layout_ = nullptr; rxkb_layout* xkb_layout_ = nullptr;

View File

@ -1,6 +1,7 @@
#pragma once #pragma once
#include <fmt/format.h> #include <fmt/format.h>
#include "ALabel.hpp" #include "ALabel.hpp"
#include "bar.hpp" #include "bar.hpp"
#include "client.hpp" #include "client.hpp"

View File

@ -1,6 +1,7 @@
#pragma once #pragma once
#include <fmt/format.h> #include <fmt/format.h>
#include <tuple> #include <tuple>
#include "AIconLabel.hpp" #include "AIconLabel.hpp"

View File

@ -1,10 +1,11 @@
#pragma once #pragma once
#include <unordered_map>
#include <fmt/format.h> #include <fmt/format.h>
#include <gtkmm/button.h> #include <gtkmm/button.h>
#include <gtkmm/label.h> #include <gtkmm/label.h>
#include <unordered_map> #include <unordered_map>
#include "AModule.hpp" #include "AModule.hpp"
#include "bar.hpp" #include "bar.hpp"
#include "client.hpp" #include "client.hpp"

View File

@ -1,7 +1,9 @@
#pragma once #pragma once
#include <fmt/format.h> #include <fmt/format.h>
#include <fstream> #include <fstream>
#include "ALabel.hpp" #include "ALabel.hpp"
#include "util/sleeper_thread.hpp" #include "util/sleeper_thread.hpp"

View File

@ -1,37 +1,32 @@
#pragma once #pragma once
#include <gdk/gdk.h>
#include <glibmm/refptr.h>
#include <gtkmm/box.h>
#include <gtkmm/button.h>
#include <gtkmm/icontheme.h>
#include <gtkmm/image.h>
#include <gtkmm/label.h>
#include <wayland-client.h>
#include <map>
#include <memory>
#include <string>
#include <unordered_set>
#include <vector>
#include "AModule.hpp" #include "AModule.hpp"
#include "bar.hpp" #include "bar.hpp"
#include "client.hpp" #include "client.hpp"
#include "giomm/desktopappinfo.h" #include "giomm/desktopappinfo.h"
#include "util/json.hpp" #include "util/json.hpp"
#include <memory>
#include <string>
#include <vector>
#include <map>
#include <unordered_set>
#include <gdk/gdk.h>
#include <glibmm/refptr.h>
#include <gtkmm/box.h>
#include <gtkmm/button.h>
#include <gtkmm/image.h>
#include <gtkmm/label.h>
#include <gtkmm/icontheme.h>
#include <wayland-client.h>
#include "wlr-foreign-toplevel-management-unstable-v1-client-protocol.h" #include "wlr-foreign-toplevel-management-unstable-v1-client-protocol.h"
namespace waybar::modules::wlr { namespace waybar::modules::wlr {
class Taskbar; class Taskbar;
class Task class Task {
{
public: public:
Task(const waybar::Bar &, const Json::Value &, Taskbar *, Task(const waybar::Bar &, const Json::Value &, Taskbar *,
struct zwlr_foreign_toplevel_handle_v1 *, struct wl_seat *); struct zwlr_foreign_toplevel_handle_v1 *, struct wl_seat *);
@ -83,7 +78,8 @@ class Task
std::string repr() const; std::string repr() const;
std::string state_string(bool = false) const; std::string state_string(bool = false) const;
void set_app_info_from_app_id_list(const std::string &app_id_list); void set_app_info_from_app_id_list(const std::string &app_id_list);
bool image_load_icon(Gtk::Image& image, const Glib::RefPtr<Gtk::IconTheme>& icon_theme, Glib::RefPtr<Gio::DesktopAppInfo> app_info, int size); bool image_load_icon(Gtk::Image &image, const Glib::RefPtr<Gtk::IconTheme> &icon_theme,
Glib::RefPtr<Gio::DesktopAppInfo> app_info, int size);
void hide_if_ignored(); void hide_if_ignored();
public: public:
@ -128,9 +124,7 @@ class Task
using TaskPtr = std::unique_ptr<Task>; using TaskPtr = std::unique_ptr<Task>;
class Taskbar : public waybar::AModule {
class Taskbar : public waybar::AModule
{
public: public:
Taskbar(const std::string &, const waybar::Bar &, const Json::Value &); Taskbar(const std::string &, const waybar::Bar &, const Json::Value &);
~Taskbar(); ~Taskbar();

View File

@ -3,6 +3,8 @@
namespace waybar::modules::wlr { namespace waybar::modules::wlr {
void add_registry_listener(void *data); void add_registry_listener(void *data);
void add_workspace_listener(zext_workspace_handle_v1 *workspace_handle, void *data); void add_workspace_listener(zext_workspace_handle_v1 *workspace_handle, void *data);
void add_workspace_group_listener(zext_workspace_group_handle_v1 *workspace_group_handle, void *data); void add_workspace_group_listener(zext_workspace_group_handle_v1 *workspace_group_handle,
zext_workspace_manager_v1* workspace_manager_bind(wl_registry *registry, uint32_t name, uint32_t version, void *data); void *data);
} zext_workspace_manager_v1 *workspace_manager_bind(wl_registry *registry, uint32_t name,
uint32_t version, void *data);
} // namespace waybar::modules::wlr

View File

@ -27,7 +27,6 @@
#endif #endif
#endif #endif
// ----------- #included from clara_textflow.hpp ----------- // ----------- #included from clara_textflow.hpp -----------
// TextFlowCpp // TextFlowCpp
@ -51,8 +50,8 @@
#define CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80 #define CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
#endif #endif
namespace clara {
namespace clara { namespace TextFlow { namespace TextFlow {
inline auto isWhitespace(char c) -> bool { inline auto isWhitespace(char c) -> bool {
static std::string chars = " \t\n\r"; static std::string chars = " \t\n\r";
@ -88,9 +87,7 @@ namespace clara { namespace TextFlow {
bool m_suffix = false; bool m_suffix = false;
iterator(Column const &column, size_t stringIndex) iterator(Column const &column, size_t stringIndex)
: m_column( column ), : m_column(column), m_stringIndex(stringIndex) {}
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]; }
@ -98,10 +95,8 @@ namespace clara { namespace TextFlow {
assert(at > 0); assert(at > 0);
assert(at <= line().size()); assert(at <= line().size());
return at == line().size() || return at == line().size() || (isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
( isWhitespace( line()[at] ) && !isWhitespace( line()[at-1] ) ) || isBreakableBefore(line()[at]) || isBreakableAfter(line()[at - 1]);
isBreakableBefore( line()[at] ) ||
isBreakableAfter( line()[at-1] );
} }
void calcLength() { void calcLength() {
@ -110,18 +105,14 @@ namespace clara { namespace TextFlow {
m_suffix = false; m_suffix = false;
auto width = m_column.m_width - indent(); auto width = m_column.m_width - indent();
m_end = m_pos; m_end = m_pos;
while( m_end < line().size() && line()[m_end] != '\n' ) while (m_end < line().size() && line()[m_end] != '\n') ++m_end;
++m_end;
if (m_end < m_pos + width) { if (m_end < m_pos + width) {
m_len = m_end - m_pos; m_len = m_end - m_pos;
} } else {
else {
size_t len = width; size_t len = width;
while (len > 0 && !isBoundary(m_pos + len)) while (len > 0 && !isBoundary(m_pos + len)) --len;
--len; while (len > 0 && isWhitespace(line()[m_pos + len - 1])) --len;
while (len > 0 && isWhitespace( line()[m_pos + len - 1] ))
--len;
if (len > 0) { if (len > 0) {
m_len = len; m_len = len;
@ -133,7 +124,8 @@ namespace clara { namespace TextFlow {
} }
auto indent() const -> size_t { auto indent() const -> size_t {
auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos; auto initial =
m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
return initial == std::string::npos ? m_column.m_indent : initial; return initial == std::string::npos ? m_column.m_indent : initial;
} }
@ -150,10 +142,10 @@ namespace clara { namespace TextFlow {
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_width > m_column.m_indent);
assert( m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent ); assert(m_column.m_initialIndent == std::string::npos ||
m_column.m_width > m_column.m_initialIndent);
calcLength(); calcLength();
if( m_len == 0 ) if (m_len == 0) m_stringIndex++; // Empty string
m_stringIndex++; // Empty string
} }
auto operator*() const -> std::string { auto operator*() const -> std::string {
@ -167,15 +159,13 @@ namespace clara { namespace TextFlow {
if (m_pos < line().size() && line()[m_pos] == '\n') if (m_pos < line().size() && line()[m_pos] == '\n')
m_pos += 1; m_pos += 1;
else else
while( m_pos < line().size() && isWhitespace( line()[m_pos] ) ) while (m_pos < line().size() && isWhitespace(line()[m_pos])) ++m_pos;
++m_pos;
if (m_pos == line().size()) { if (m_pos == line().size()) {
m_pos = 0; m_pos = 0;
++m_stringIndex; ++m_stringIndex;
} }
if( m_stringIndex < m_column.m_strings.size() ) if (m_stringIndex < m_column.m_strings.size()) calcLength();
calcLength();
return *this; return *this;
} }
auto operator++(int) -> iterator { auto operator++(int) -> iterator {
@ -185,14 +175,10 @@ namespace clara { namespace TextFlow {
} }
auto operator==(iterator const &other) const -> bool { auto operator==(iterator const &other) const -> bool {
return return m_pos == other.m_pos && m_stringIndex == other.m_stringIndex &&
m_pos == other.m_pos &&
m_stringIndex == other.m_stringIndex &&
&m_column == &other.m_column; &m_column == &other.m_column;
} }
auto operator !=( iterator const& other ) const -> bool { auto operator!=(iterator const &other) const -> bool { return !operator==(other); }
return !operator==( other );
}
}; };
using const_iterator = iterator; using const_iterator = iterator;
@ -238,18 +224,14 @@ namespace clara { namespace TextFlow {
}; };
class Spacer : public Column { class Spacer : public Column {
public: public:
explicit Spacer( size_t spaceWidth ) : Column( "" ) { explicit Spacer(size_t spaceWidth) : Column("") { width(spaceWidth); }
width( spaceWidth );
}
}; };
class Columns { class Columns {
std::vector<Column> m_columns; std::vector<Column> m_columns;
public: public:
class iterator { class iterator {
friend Columns; friend Columns;
struct EndTag {}; struct EndTag {};
@ -258,14 +240,10 @@ namespace clara { namespace TextFlow {
std::vector<Column::iterator> m_iterators; std::vector<Column::iterator> m_iterators;
size_t m_activeIterators; size_t m_activeIterators;
iterator( Columns const& columns, EndTag ) iterator(Columns const &columns, EndTag) : m_columns(columns.m_columns), m_activeIterators(0) {
: m_columns( columns.m_columns ),
m_activeIterators( 0 )
{
m_iterators.reserve(m_columns.size()); m_iterators.reserve(m_columns.size());
for( auto const& col : m_columns ) for (auto const &col : m_columns) m_iterators.push_back(col.end());
m_iterators.push_back( col.end() );
} }
public: public:
@ -276,13 +254,10 @@ namespace clara { namespace TextFlow {
using iterator_category = std::forward_iterator_tag; using iterator_category = std::forward_iterator_tag;
explicit iterator(Columns const &columns) explicit iterator(Columns const &columns)
: m_columns( columns.m_columns ), : m_columns(columns.m_columns), m_activeIterators(m_columns.size()) {
m_activeIterators( m_columns.size() )
{
m_iterators.reserve(m_columns.size()); m_iterators.reserve(m_columns.size());
for( auto const& col : m_columns ) for (auto const &col : m_columns) m_iterators.push_back(col.begin());
m_iterators.push_back( col.begin() );
} }
auto operator==(iterator const &other) const -> bool { auto operator==(iterator const &other) const -> bool {
@ -303,8 +278,7 @@ namespace clara { namespace TextFlow {
padding = std::string(width - col.size(), ' '); padding = std::string(width - col.size(), ' ');
else else
padding = ""; padding = "";
} } else {
else {
padding += std::string(width, ' '); padding += std::string(width, ' ');
} }
} }
@ -312,8 +286,7 @@ namespace clara { namespace TextFlow {
} }
auto operator++() -> iterator & { auto operator++() -> iterator & {
for (size_t i = 0; i < m_columns.size(); ++i) { for (size_t i = 0; i < m_columns.size(); ++i) {
if (m_iterators[i] != m_columns[i].end()) if (m_iterators[i] != m_columns[i].end()) ++m_iterators[i];
++m_iterators[i];
} }
return *this; return *this;
} }
@ -339,7 +312,6 @@ namespace clara { namespace TextFlow {
} }
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; bool first = true;
for (auto line : cols) { for (auto line : cols) {
if (first) if (first)
@ -364,19 +336,20 @@ namespace clara { namespace TextFlow {
cols += other; cols += other;
return cols; return cols;
} }
}} } // namespace TextFlow
} // namespace clara
#endif // CLARA_TEXTFLOW_HPP_INCLUDED #endif // CLARA_TEXTFLOW_HPP_INCLUDED
// ----------- end of #include from clara_textflow.hpp ----------- // ----------- end of #include from clara_textflow.hpp -----------
// ........... back in clara.hpp // ........... back in clara.hpp
#include <algorithm>
#include <memory> #include <memory>
#include <set> #include <set>
#include <algorithm>
#if !defined(CLARA_PLATFORM_WINDOWS) && ( defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) ) #if !defined(CLARA_PLATFORM_WINDOWS) && \
(defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER))
#define CLARA_PLATFORM_WINDOWS #define CLARA_PLATFORM_WINDOWS
#endif #endif
@ -408,25 +381,17 @@ namespace detail {
std::vector<std::string> m_args; std::vector<std::string> m_args;
public: public:
Args( int argc, char const* const* argv ) Args(int argc, char const *const *argv) : m_exeName(argv[0]), m_args(argv + 1, argv + argc) {}
: m_exeName(argv[0]),
m_args(argv + 1, argv + argc) {}
Args(std::initializer_list<std::string> args) Args(std::initializer_list<std::string> args)
: m_exeName( *args.begin() ), : m_exeName(*args.begin()), m_args(args.begin() + 1, args.end()) {}
m_args( args.begin()+1, args.end() )
{}
auto exeName() const -> std::string { auto exeName() const -> std::string { return m_exeName; }
return m_exeName;
}
}; };
// Wraps a token coming from a token stream. These may not directly correspond to strings as a single string // Wraps a token coming from a token stream. These may not directly correspond to strings as a
// may encode an option + its argument if the : or = form is used // single string may encode an option + its argument if the : or = form is used
enum class TokenType { enum class TokenType { Option, Argument };
Option, Argument
};
struct Token { struct Token {
TokenType type; TokenType type;
std::string token; std::string token;
@ -451,8 +416,7 @@ namespace detail {
m_tokenBuffer.resize(0); m_tokenBuffer.resize(0);
// Skip any empty strings // Skip any empty strings
while( it != itEnd && it->empty() ) while (it != itEnd && it->empty()) ++it;
++it;
if (it != itEnd) { if (it != itEnd) {
auto const &next = *it; auto const &next = *it;
@ -481,13 +445,9 @@ namespace detail {
public: 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 ) { TokenStream(Iterator it, Iterator itEnd) : it(it), itEnd(itEnd) { loadBuffer(); }
loadBuffer();
}
explicit operator bool() const { explicit operator bool() const { return !m_tokenBuffer.empty() || it != itEnd; }
return !m_tokenBuffer.empty() || it != itEnd;
}
auto count() const -> size_t { return m_tokenBuffer.size() + (itEnd - it); } auto count() const -> size_t { return m_tokenBuffer.size() + (itEnd - it); }
@ -505,20 +465,16 @@ namespace detail {
if (m_tokenBuffer.size() >= 2) { if (m_tokenBuffer.size() >= 2) {
m_tokenBuffer.erase(m_tokenBuffer.begin()); m_tokenBuffer.erase(m_tokenBuffer.begin());
} else { } else {
if( it != itEnd ) if (it != itEnd) ++it;
++it;
loadBuffer(); loadBuffer();
} }
return *this; return *this;
} }
}; };
class ResultBase { class ResultBase {
public: public:
enum Type { enum Type { Ok, LogicError, RuntimeError };
Ok, LogicError, RuntimeError
};
protected: protected:
ResultBase(Type type) : m_type(type) {} ResultBase(Type type) : m_type(type) {}
@ -541,26 +497,20 @@ namespace detail {
ResultValueBase(Type type) : ResultBase(type) {} ResultValueBase(Type type) : ResultBase(type) {}
ResultValueBase(ResultValueBase const &other) : ResultBase(other) { ResultValueBase(ResultValueBase const &other) : ResultBase(other) {
if( m_type == ResultBase::Ok ) if (m_type == ResultBase::Ok) new (&m_value) T(other.m_value);
new( &m_value ) T( other.m_value );
} }
ResultValueBase( Type, T const &value ) : ResultBase( Ok ) { ResultValueBase(Type, T const &value) : ResultBase(Ok) { new (&m_value) T(value); }
new( &m_value ) T( value );
}
auto operator=(ResultValueBase const &other) -> ResultValueBase & { auto operator=(ResultValueBase const &other) -> ResultValueBase & {
if( m_type == ResultBase::Ok ) if (m_type == ResultBase::Ok) m_value.~T();
m_value.~T();
ResultBase::operator=(other); ResultBase::operator=(other);
if( m_type == ResultBase::Ok ) if (m_type == ResultBase::Ok) new (&m_value) T(other.m_value);
new( &m_value ) T( other.m_value );
return *this; return *this;
} }
~ResultValueBase() override { ~ResultValueBase() override {
if( m_type == Ok ) if (m_type == Ok) m_value.~T();
m_value.~T();
} }
union { union {
@ -579,17 +529,21 @@ namespace detail {
public: public:
template <typename U> template <typename U>
explicit BasicResult(BasicResult<U> const &other) explicit BasicResult(BasicResult<U> const &other)
: ResultValueBase<T>( other.type() ), : ResultValueBase<T>(other.type()), m_errorMessage(other.errorMessage()) {
m_errorMessage( other.errorMessage() )
{
assert(type() != ResultBase::Ok); assert(type() != ResultBase::Ok);
} }
template <typename U> template <typename U>
static auto ok( U const &value ) -> BasicResult { return { ResultBase::Ok, value }; } static auto ok(U const &value) -> BasicResult {
return {ResultBase::Ok, value};
}
static auto ok() -> BasicResult { return {ResultBase::Ok}; } static auto ok() -> BasicResult { return {ResultBase::Ok}; }
static auto logicError( std::string const &message ) -> BasicResult { return { ResultBase::LogicError, message }; } static auto logicError(std::string const &message) -> BasicResult {
static auto runtimeError( std::string const &message ) -> BasicResult { return { ResultBase::RuntimeError, message }; } return {ResultBase::LogicError, message};
}
static auto runtimeError(std::string const &message) -> BasicResult {
return {ResultBase::RuntimeError, message};
}
explicit operator bool() const { return m_type == ResultBase::Ok; } explicit operator bool() const { return m_type == ResultBase::Ok; }
auto type() const -> ResultBase::Type { return m_type; } auto type() const -> ResultBase::Type { return m_type; }
@ -597,21 +551,17 @@ namespace detail {
protected: protected:
void enforceOk() const override { void enforceOk() const override {
// Errors shouldn't reach this point, but if they do // Errors shouldn't reach this point, but if they do
// the actual error message will be in m_errorMessage // the actual error message will be in m_errorMessage
assert(m_type != ResultBase::LogicError); assert(m_type != ResultBase::LogicError);
assert(m_type != ResultBase::RuntimeError); assert(m_type != ResultBase::RuntimeError);
if( m_type != ResultBase::Ok ) if (m_type != ResultBase::Ok) std::abort();
std::abort();
} }
std::string m_errorMessage; // Only populated if resultType is an error 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), : ResultValueBase<T>(type), m_errorMessage(message) {
m_errorMessage(message)
{
assert(m_type != ResultBase::Ok); assert(m_type != ResultBase::Ok);
} }
@ -619,17 +569,12 @@ namespace detail {
using ResultBase::m_type; using ResultBase::m_type;
}; };
enum class ParseResultType { enum class ParseResultType { Matched, NoMatch, ShortCircuitAll, ShortCircuitSame };
Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
};
class ParseState { class ParseState {
public: public:
ParseState(ParseResultType type, TokenStream const &remainingTokens) ParseState(ParseResultType type, TokenStream const &remainingTokens)
: m_type(type), : m_type(type), m_remainingTokens(remainingTokens) {}
m_remainingTokens( remainingTokens )
{}
auto type() const -> ParseResultType { return m_type; } auto type() const -> ParseResultType { return m_type; }
auto remainingTokens() const -> TokenStream { return m_remainingTokens; } auto remainingTokens() const -> TokenStream { return m_remainingTokens; }
@ -664,22 +609,24 @@ namespace detail {
} }
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::string srcLC = source;
std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( ::tolower(c) ); } ); std::transform(srcLC.begin(), srcLC.end(), srcLC.begin(),
[](char c) { return static_cast<char>(::tolower(c)); });
if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on") if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
target = true; target = true;
else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off") else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
target = false; target = false;
else else
return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + "'" ); return ParserResult::runtimeError("Expected a boolean value but did not recognise: '" + source +
"'");
return ParserResult::ok(ParseResultType::Matched); return ParserResult::ok(ParseResultType::Matched);
} }
#ifdef CLARA_CONFIG_OPTIONAL_TYPE #ifdef CLARA_CONFIG_OPTIONAL_TYPE
template <typename T> template <typename T>
inline auto convertInto( std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T>& target ) -> ParserResult { inline auto convertInto(std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T> &target)
-> ParserResult {
T temp; T temp;
auto result = convertInto(source, temp); auto result = convertInto(source, temp);
if( result ) if (result) target = std::move(temp);
target = std::move(temp);
return result; return result;
} }
#endif // CLARA_CONFIG_OPTIONAL_TYPE #endif // CLARA_CONFIG_OPTIONAL_TYPE
@ -711,9 +658,7 @@ namespace detail {
explicit BoundValueRef(T &ref) : m_ref(ref) {} explicit BoundValueRef(T &ref) : m_ref(ref) {}
auto setValue( std::string const &arg ) -> ParserResult override { auto setValue(std::string const &arg) -> ParserResult override { return convertInto(arg, m_ref); }
return convertInto( arg, m_ref );
}
}; };
template <typename T> template <typename T>
@ -727,8 +672,7 @@ namespace detail {
auto setValue(std::string const &arg) -> ParserResult override { auto setValue(std::string const &arg) -> ParserResult override {
T temp; T temp;
auto result = convertInto(arg, temp); auto result = convertInto(arg, temp);
if( result ) if (result) m_ref.push_back(temp);
m_ref.push_back( temp );
return result; return result;
} }
}; };
@ -746,7 +690,8 @@ namespace detail {
template <typename ReturnType> template <typename ReturnType>
struct LambdaInvoker { struct LambdaInvoker {
static_assert( std::is_same<ReturnType, ParserResult>::value, "Lambda must return void or clara::ParserResult" ); static_assert(std::is_same<ReturnType, ParserResult>::value,
"Lambda must return void or clara::ParserResult");
template <typename L, typename ArgType> 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 {
@ -767,12 +712,10 @@ namespace detail {
inline auto invokeLambda(L const &lambda, std::string const &arg) -> ParserResult { inline auto invokeLambda(L const &lambda, std::string const &arg) -> ParserResult {
ArgType temp{}; ArgType temp{};
auto result = convertInto(arg, temp); auto result = convertInto(arg, temp);
return !result return !result ? result
? result
: LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke(lambda, temp); : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke(lambda, temp);
} }
template <typename L> template <typename L>
struct BoundLambda : BoundValueRefBase { struct BoundLambda : BoundValueRefBase {
L m_lambda; L m_lambda;
@ -790,7 +733,8 @@ namespace detail {
L m_lambda; L m_lambda;
static_assert(UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument"); static_assert(UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument");
static_assert( std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value, "flags must be boolean" ); 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) {}
@ -807,7 +751,8 @@ namespace detail {
public: public:
virtual ~ParserBase() = default; virtual ~ParserBase() = default;
virtual auto validate() const -> Result { return Result::ok(); } virtual auto validate() const -> Result { return Result::ok(); }
virtual auto parse( std::string const& exeName, TokenStream const &tokens) const -> InternalParseResult = 0; virtual auto parse(std::string const &exeName, TokenStream const &tokens) const
-> InternalParseResult = 0;
virtual auto cardinality() const -> size_t { return 1; } virtual auto cardinality() const -> size_t { return 1; }
auto parse(Args const &args) const -> InternalParseResult { auto parse(Args const &args) const -> InternalParseResult {
@ -839,15 +784,11 @@ namespace detail {
public: public:
template <typename T> 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_ref(std::make_shared<BoundValueRef<T>>(ref)), m_hint(hint) {}
m_hint( hint )
{}
template <typename LambdaT> 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_ref(std::make_shared<BoundLambda<LambdaT>>(ref)), m_hint(hint) {}
m_hint(hint)
{}
auto operator()(std::string const &description) -> DerivedT & { auto operator()(std::string const &description) -> DerivedT & {
m_description = description; m_description = description;
@ -864,9 +805,7 @@ namespace detail {
return static_cast<DerivedT &>(*this); return static_cast<DerivedT &>(*this);
}; };
auto isOptional() const -> bool { auto isOptional() const -> bool { return m_optionality == Optionality::Optional; }
return m_optionality == Optionality::Optional;
}
auto cardinality() const -> size_t override { auto cardinality() const -> size_t override {
if (m_ref->isContainer()) if (m_ref->isContainer())
@ -906,11 +845,8 @@ namespace detail {
auto name() const -> std::string { return *m_name; } 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 lastSlash = newName.find_last_of("\\/");
auto filename = ( lastSlash == std::string::npos ) auto filename = (lastSlash == std::string::npos) ? newName : newName.substr(lastSlash + 1);
? newName
: newName.substr( lastSlash+1 );
*m_name = filename; *m_name = filename;
if (m_ref) if (m_ref)
@ -926,8 +862,7 @@ namespace detail {
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(); auto validationResult = validate();
if( !validationResult ) if (!validationResult) return InternalParseResult(validationResult);
return InternalParseResult( validationResult );
auto remainingTokens = tokens; auto remainingTokens = tokens;
auto const &token = *remainingTokens; auto const &token = *remainingTokens;
@ -960,7 +895,8 @@ namespace detail {
public: public:
template <typename LambdaT> template <typename LambdaT>
explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shared<BoundFlagLambda<LambdaT>>( 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)) {}
@ -985,16 +921,14 @@ namespace detail {
oss << ", "; oss << ", ";
oss << opt; oss << opt;
} }
if( !m_hint.empty() ) if (!m_hint.empty()) oss << " <" << m_hint << ">";
oss << " <" << m_hint << ">";
return {{oss.str(), m_description}}; 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); auto normalisedToken = normaliseOpt(optToken);
for (auto const &name : m_optNames) { for (auto const &name : m_optNames) {
if( normaliseOpt( name ) == normalisedToken ) if (normaliseOpt(name) == normalisedToken) return true;
return true;
} }
return false; return false;
} }
@ -1003,8 +937,7 @@ namespace detail {
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(); auto validationResult = validate();
if( !validationResult ) if (!validationResult) return InternalParseResult(validationResult);
return InternalParseResult( validationResult );
auto remainingTokens = tokens; auto remainingTokens = tokens;
if (remainingTokens && remainingTokens->type == TokenType::Option) { if (remainingTokens && remainingTokens->type == TokenType::Option) {
@ -1013,8 +946,7 @@ namespace detail {
if (m_ref->isFlag()) { 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); auto result = flagRef->setFlag(true);
if( !result ) if (!result) return InternalParseResult(result);
return InternalParseResult( result );
if (result.value() == ParseResultType::ShortCircuitAll) if (result.value() == ParseResultType::ShortCircuitAll)
return InternalParseResult::ok(ParseState(result.value(), remainingTokens)); return InternalParseResult::ok(ParseState(result.value(), remainingTokens));
} else { } else {
@ -1026,8 +958,7 @@ namespace detail {
if (argToken.type != TokenType::Argument) if (argToken.type != TokenType::Argument)
return InternalParseResult::runtimeError("Expected argument following " + token.token); return InternalParseResult::runtimeError("Expected argument following " + token.token);
auto result = valueRef->setValue(argToken.token); auto result = valueRef->setValue(argToken.token);
if( !result ) if (!result) return InternalParseResult(result);
return InternalParseResult( result );
if (result.value() == ParseResultType::ShortCircuitAll) if (result.value() == ParseResultType::ShortCircuitAll)
return InternalParseResult::ok(ParseState(result.value(), remainingTokens)); return InternalParseResult::ok(ParseState(result.value(), remainingTokens));
} }
@ -1038,17 +969,14 @@ namespace detail {
} }
auto validate() const -> Result override { auto validate() const -> Result override {
if( m_optNames.empty() ) if (m_optNames.empty()) return Result::logicError("No options supplied to Opt");
return Result::logicError( "No options supplied to Opt" );
for (auto const &name : m_optNames) { for (auto const &name : m_optNames) {
if( name.empty() ) if (name.empty()) return Result::logicError("Option name cannot be empty");
return Result::logicError( "Option name cannot be empty" );
#ifdef CLARA_PLATFORM_WINDOWS #ifdef CLARA_PLATFORM_WINDOWS
if (name[0] != '-' && name[0] != '/') if (name[0] != '-' && name[0] != '/')
return Result::logicError("Option name must begin with '-' or '/'"); return Result::logicError("Option name must begin with '-' or '/'");
#else #else
if( name[0] != '-' ) if (name[0] != '-') return Result::logicError("Option name must begin with '-'");
return Result::logicError( "Option name must begin with '-'" );
#endif #endif
} }
return ParserRefImpl::validate(); return ParserRefImpl::validate();
@ -1060,18 +988,12 @@ namespace detail {
: Opt([&](bool flag) { : Opt([&](bool flag) {
showHelpFlag = flag; showHelpFlag = flag;
return ParserResult::ok(ParseResultType::ShortCircuitAll); 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();
} }
}; };
struct Parser : ParserBase { struct Parser : ParserBase {
mutable ExeName m_exeName; mutable ExeName m_exeName;
std::vector<Opt> m_options; std::vector<Opt> m_options;
std::vector<Arg> m_args; std::vector<Arg> m_args;
@ -1104,9 +1026,13 @@ namespace detail {
// Forward deprecated interface with '+' instead of '|' // Forward deprecated interface with '+' instead of '|'
template <typename T> template <typename T>
auto operator+=( T const &other ) -> Parser & { return operator|=( other ); } auto operator+=(T const &other) -> Parser & {
return operator|=(other);
}
template <typename T> template <typename T>
auto operator+( T const &other ) const -> Parser { return operator|( other ); } auto operator+(T const &other) const -> Parser {
return operator|(other);
}
auto getHelpColumns() const -> std::vector<HelpColumns> { auto getHelpColumns() const -> std::vector<HelpColumns> {
std::vector<HelpColumns> cols; std::vector<HelpColumns> cols;
@ -1119,7 +1045,8 @@ namespace detail {
void writeToStream(std::ostream &os) const { void writeToStream(std::ostream &os) const {
if (!m_exeName.name().empty()) { if (!m_exeName.name().empty()) {
os << "usage:\n" << " " << m_exeName.name() << " "; os << "usage:\n"
<< " " << m_exeName.name() << " ";
bool required = true, first = true; bool required = true, first = true;
for (auto const &arg : m_args) { for (auto const &arg : m_args) {
if (first) if (first)
@ -1131,28 +1058,22 @@ namespace detail {
required = false; required = false;
} }
os << "<" << arg.hint() << ">"; os << "<" << arg.hint() << ">";
if( arg.cardinality() == 0 ) if (arg.cardinality() == 0) os << " ... ";
os << " ... ";
} }
if( !required ) if (!required) os << "]";
os << "]"; if (!m_options.empty()) os << " options";
if( !m_options.empty() )
os << " options";
os << "\n\nwhere options are:" << std::endl; os << "\n\nwhere options are:" << std::endl;
} }
auto rows = getHelpColumns(); auto rows = getHelpColumns();
size_t consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH; size_t consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH;
size_t optWidth = 0; size_t optWidth = 0;
for( auto const &cols : rows ) for (auto const &cols : rows) optWidth = (std::max)(optWidth, cols.left.size() + 2);
optWidth = (std::max)(optWidth, cols.left.size() + 2);
optWidth = (std::min)(optWidth, consoleWidth / 2); optWidth = (std::min)(optWidth, consoleWidth / 2);
for (auto const &cols : rows) { for (auto const &cols : rows) {
auto row = auto row = TextFlow::Column(cols.left).width(optWidth).indent(2) + TextFlow::Spacer(4) +
TextFlow::Column( cols.left ).width( optWidth ).indent( 2 ) +
TextFlow::Spacer(4) +
TextFlow::Column(cols.right).width(consoleWidth - 7 - optWidth); TextFlow::Column(cols.right).width(consoleWidth - 7 - optWidth);
os << row << std::endl; os << row << std::endl;
} }
@ -1166,21 +1087,19 @@ namespace detail {
auto validate() const -> Result override { auto validate() const -> Result override {
for (auto const &opt : m_options) { for (auto const &opt : m_options) {
auto result = opt.validate(); auto result = opt.validate();
if( !result ) if (!result) return result;
return result;
} }
for (auto const &arg : m_args) { for (auto const &arg : m_args) {
auto result = arg.validate(); auto result = arg.validate();
if( !result ) if (!result) return result;
return result;
} }
return Result::ok(); return Result::ok();
} }
using ParserBase::parse; using ParserBase::parse;
auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override { auto parse(std::string const &exeName, TokenStream const &tokens) const
-> InternalParseResult override {
struct ParserInfo { struct ParserInfo {
ParserBase const *parser = nullptr; ParserBase const *parser = nullptr;
size_t count = 0; size_t count = 0;
@ -1204,10 +1123,10 @@ namespace detail {
for (size_t i = 0; i < totalParsers; ++i) { 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() ) { if (parseInfo.parser->cardinality() == 0 ||
parseInfo.count < parseInfo.parser->cardinality()) {
result = parseInfo.parser->parse(exeName, result.value().remainingTokens()); result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
if (!result) if (!result) return result;
return result;
if (result.value().type() != ParseResultType::NoMatch) { if (result.value().type() != ParseResultType::NoMatch) {
tokenParsed = true; tokenParsed = true;
++parseInfo.count; ++parseInfo.count;
@ -1216,10 +1135,10 @@ namespace detail {
} }
} }
if( result.value().type() == ParseResultType::ShortCircuitAll ) if (result.value().type() == ParseResultType::ShortCircuitAll) return result;
return result;
if (!tokenParsed) if (!tokenParsed)
return InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token ); return InternalParseResult::runtimeError("Unrecognised token: " +
result.value().remainingTokens()->token);
} }
// !TBD Check missing required options // !TBD Check missing required options
return result; return result;
@ -1233,7 +1152,6 @@ namespace detail {
} }
} // namespace detail } // namespace detail
// A Combined parser // A Combined parser
using detail::Parser; using detail::Parser;
@ -1258,7 +1176,6 @@ using detail::ParseResultType;
// Result type for parser operation // Result type for parser operation
using detail::ParserResult; using detail::ParserResult;
} // namespace clara } // namespace clara
#endif // CLARA_HPP_INCLUDED #endif // CLARA_HPP_INCLUDED

View File

@ -5,15 +5,14 @@
class pow_format { class pow_format {
public: public:
pow_format(long long val, std::string&& unit, bool binary = false): pow_format(long long val, std::string&& unit, bool binary = false)
val_(val), unit_(unit), binary_(binary) { }; : val_(val), unit_(unit), binary_(binary){};
long long val_; long long val_;
std::string unit_; std::string unit_;
bool binary_; bool binary_;
}; };
namespace fmt { namespace fmt {
template <> template <>
struct formatter<pow_format> { struct formatter<pow_format> {
@ -77,16 +76,16 @@ namespace fmt {
format = "{coefficient:.3g}{prefix}{unit}"; format = "{coefficient:.3g}{prefix}{unit}";
break; break;
} }
return format_to(ctx.out(), format return format_to(
, fmt::arg("coefficient", fraction) ctx.out(), format, fmt::arg("coefficient", fraction),
, fmt::arg("prefix", std::string() + units[pow] + ((s.binary_ && pow) ? "i" : "")) fmt::arg("prefix", std::string() + units[pow] + ((s.binary_ && pow) ? "i" : "")),
, fmt::arg("unit", s.unit_) fmt::arg("unit", s.unit_),
, fmt::arg("padding", pow ? "" : s.binary_ ? " " : " ") fmt::arg("padding", pow ? ""
); : s.binary_ ? " "
: " "));
} }
}; };
// Glib ustirng support // Glib ustirng support
template <> template <>
struct formatter<Glib::ustring> : formatter<std::string> { struct formatter<Glib::ustring> : formatter<std::string> {
@ -95,5 +94,4 @@ namespace fmt {
return formatter<std::string>::format(value, ctx); return formatter<std::string>::format(value, ctx);
} }
}; };
} } // namespace fmt

View File

@ -17,6 +17,7 @@ namespace waybar::util {
*/ */
class CancellationGuard { class CancellationGuard {
int oldstate; int oldstate;
public: public:
CancellationGuard() { pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate); } CancellationGuard() { pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate); }
~CancellationGuard() { pthread_setcancelstate(oldstate, &oldstate); } ~CancellationGuard() { pthread_setcancelstate(oldstate, &oldstate); }

View File

@ -1,5 +1,7 @@
#include "ALabel.hpp" #include "ALabel.hpp"
#include <fmt/format.h> #include <fmt/format.h>
#include <util/command.hpp> #include <util/command.hpp>
namespace waybar { namespace waybar {
@ -46,15 +48,10 @@ ALabel::ALabel(const Json::Value& config, const std::string& name, const std::st
} else { } else {
label_.set_xalign(align); label_.set_xalign(align);
} }
}
} }
auto ALabel::update() -> void { AModule::update(); }
}
auto ALabel::update() -> void {
AModule::update();
}
std::string ALabel::getIcon(uint16_t percentage, const std::string& alt, uint16_t max) { std::string ALabel::getIcon(uint16_t percentage, const std::string& alt, uint16_t max) {
auto format_icons = config_["format-icons"]; auto format_icons = config_["format-icons"];
@ -78,7 +75,8 @@ std::string ALabel::getIcon(uint16_t percentage, const std::string& alt, uint16_
return ""; return "";
} }
std::string ALabel::getIcon(uint16_t percentage, const std::vector<std::string>& alts, uint16_t max) { std::string ALabel::getIcon(uint16_t percentage, const std::vector<std::string>& alts,
uint16_t max) {
auto format_icons = config_["format-icons"]; auto format_icons = config_["format-icons"];
if (format_icons.isObject()) { if (format_icons.isObject()) {
std::string _alt = "default"; std::string _alt = "default";

View File

@ -1,14 +1,17 @@
#include "AModule.hpp" #include "AModule.hpp"
#include <fmt/format.h> #include <fmt/format.h>
#include <util/command.hpp> #include <util/command.hpp>
namespace waybar { namespace waybar {
AModule::AModule(const Json::Value& config, const std::string& name, const std::string& id, AModule::AModule(const Json::Value& config, const std::string& name, const std::string& id,
bool enable_click, bool enable_scroll) bool enable_click, bool enable_scroll)
: name_(std::move(name)), config_(std::move(config)) : name_(std::move(name)),
, distance_scrolled_y_(0.0) config_(std::move(config)),
, distance_scrolled_x_(0.0) { distance_scrolled_y_(0.0),
distance_scrolled_x_(0.0) {
// configure events' user commands // configure events' user commands
if (enable_click) { if (enable_click) {
event_box_.add_events(Gdk::BUTTON_PRESS_MASK); event_box_.add_events(Gdk::BUTTON_PRESS_MASK);
@ -18,7 +21,8 @@ AModule::AModule(const Json::Value& config, const std::string& name, const std::
while (it != eventMap_.cend()) { while (it != eventMap_.cend()) {
if (config_[it->second].isString()) { if (config_[it->second].isString()) {
event_box_.add_events(Gdk::BUTTON_PRESS_MASK); event_box_.add_events(Gdk::BUTTON_PRESS_MASK);
event_box_.signal_button_press_event().connect(sigc::mem_fun(*this, &AModule::handleToggle)); event_box_.signal_button_press_event().connect(
sigc::mem_fun(*this, &AModule::handleToggle));
break; break;
} }
++it; ++it;
@ -46,12 +50,15 @@ auto AModule::update() -> void {
} }
bool AModule::handleToggle(GdkEventButton* const& e) { bool AModule::handleToggle(GdkEventButton* const& e) {
const std::map<std::pair<uint, GdkEventType>, std::string>::const_iterator& rec{eventMap_.find(std::pair(e->button, e->type))}; const std::map<std::pair<uint, GdkEventType>, std::string>::const_iterator& rec{
eventMap_.find(std::pair(e->button, e->type))};
std::string format{(rec != eventMap_.cend()) ? rec->second : std::string{""}}; std::string format{(rec != eventMap_.cend()) ? rec->second : std::string{""}};
if (!format.empty()) { if (!format.empty()) {
if (config_[format].isString()) format = config_[format].asString(); if (config_[format].isString())
else format.clear(); format = config_[format].asString();
else
format.clear();
} }
if (!format.empty()) { if (!format.empty()) {
@ -63,10 +70,14 @@ bool AModule::handleToggle(GdkEventButton* const& e) {
AModule::SCROLL_DIR AModule::getScrollDir(GdkEventScroll* e) { AModule::SCROLL_DIR AModule::getScrollDir(GdkEventScroll* e) {
switch (e->direction) { switch (e->direction) {
case GDK_SCROLL_UP: return SCROLL_DIR::UP; case GDK_SCROLL_UP:
case GDK_SCROLL_DOWN: return SCROLL_DIR::DOWN; return SCROLL_DIR::UP;
case GDK_SCROLL_LEFT: return SCROLL_DIR::LEFT; case GDK_SCROLL_DOWN:
case GDK_SCROLL_RIGHT: return SCROLL_DIR::RIGHT; return SCROLL_DIR::DOWN;
case GDK_SCROLL_LEFT:
return SCROLL_DIR::LEFT;
case GDK_SCROLL_RIGHT:
return SCROLL_DIR::RIGHT;
case GDK_SCROLL_SMOOTH: { case GDK_SCROLL_SMOOTH: {
SCROLL_DIR dir{SCROLL_DIR::NONE}; SCROLL_DIR dir{SCROLL_DIR::NONE};
@ -104,7 +115,8 @@ AModule::SCROLL_DIR AModule::getScrollDir(GdkEventScroll* e) {
return dir; return dir;
} }
// Silence -Wreturn-type: // Silence -Wreturn-type:
default: return SCROLL_DIR::NONE; default:
return SCROLL_DIR::NONE;
} }
} }

View File

@ -170,10 +170,8 @@ struct GLSSurfaceImpl : public BarSurface, public sigc::trackable {
vertical_ = true; vertical_ = true;
unanchored = GTK_LAYER_SHELL_EDGE_LEFT; unanchored = GTK_LAYER_SHELL_EDGE_LEFT;
} }
for (auto edge : {GTK_LAYER_SHELL_EDGE_LEFT, for (auto edge : {GTK_LAYER_SHELL_EDGE_LEFT, GTK_LAYER_SHELL_EDGE_RIGHT,
GTK_LAYER_SHELL_EDGE_RIGHT, GTK_LAYER_SHELL_EDGE_TOP, GTK_LAYER_SHELL_EDGE_BOTTOM}) {
GTK_LAYER_SHELL_EDGE_TOP,
GTK_LAYER_SHELL_EDGE_BOTTOM}) {
gtk_layer_set_anchor(window_.gobj(), edge, unanchored != edge); gtk_layer_set_anchor(window_.gobj(), edge, unanchored != edge);
} }
} }
@ -276,8 +274,8 @@ struct RawSurfaceImpl : public BarSurface, public sigc::trackable {
margins_ = margins; margins_ = margins;
// updating already mapped window // updating already mapped window
if (layer_surface_) { if (layer_surface_) {
zwlr_layer_surface_v1_set_margin( zwlr_layer_surface_v1_set_margin(layer_surface_.get(), margins_.top, margins_.right,
layer_surface_.get(), margins_.top, margins_.right, margins_.bottom, margins_.left); margins_.bottom, margins_.left);
} }
} }
@ -365,14 +363,14 @@ struct RawSurfaceImpl : public BarSurface, public sigc::trackable {
auto gdk_window = window_.get_window()->gobj(); auto gdk_window = window_.get_window()->gobj();
surface_ = gdk_wayland_window_get_wl_surface(gdk_window); surface_ = gdk_wayland_window_get_wl_surface(gdk_window);
layer_surface_.reset(zwlr_layer_shell_v1_get_layer_surface( layer_surface_.reset(zwlr_layer_shell_v1_get_layer_surface(client->layer_shell, surface_,
client->layer_shell, surface_, output_, layer_, "waybar")); output_, layer_, "waybar"));
zwlr_layer_surface_v1_add_listener(layer_surface_.get(), &layer_surface_listener, this); zwlr_layer_surface_v1_add_listener(layer_surface_.get(), &layer_surface_listener, this);
zwlr_layer_surface_v1_set_keyboard_interactivity(layer_surface_.get(), false); zwlr_layer_surface_v1_set_keyboard_interactivity(layer_surface_.get(), false);
zwlr_layer_surface_v1_set_anchor(layer_surface_.get(), anchor_); zwlr_layer_surface_v1_set_anchor(layer_surface_.get(), anchor_);
zwlr_layer_surface_v1_set_margin( zwlr_layer_surface_v1_set_margin(layer_surface_.get(), margins_.top, margins_.right,
layer_surface_.get(), margins_.top, margins_.right, margins_.bottom, margins_.left); margins_.bottom, margins_.left);
setSurfaceSize(width_, height_); setSurfaceSize(width_, height_);
setExclusiveZone(exclusive_zone_); setExclusiveZone(exclusive_zone_);
@ -453,10 +451,8 @@ struct RawSurfaceImpl : public BarSurface, public sigc::trackable {
o->window_.set_size_request(o->width_, o->height_); o->window_.set_size_request(o->width_, o->height_);
o->window_.resize(o->width_, o->height_); o->window_.resize(o->width_, o->height_);
o->setExclusiveZone(o->exclusive_zone_); o->setExclusiveZone(o->exclusive_zone_);
spdlog::info(BAR_SIZE_MSG, spdlog::info(BAR_SIZE_MSG, o->width_ == 1 ? "auto" : std::to_string(o->width_),
o->width_ == 1 ? "auto" : std::to_string(o->width_), o->height_ == 1 ? "auto" : std::to_string(o->height_), o->output_name_);
o->height_ == 1 ? "auto" : std::to_string(o->height_),
o->output_name_);
o->commit(); o->commit();
} }
zwlr_layer_surface_v1_ack_configure(surface, serial); zwlr_layer_surface_v1_ack_configure(surface, serial);
@ -723,7 +719,8 @@ void waybar::Bar::handleSignal(int signal) {
} }
} }
void waybar::Bar::getModules(const Factory& factory, const std::string& pos, Gtk::Box* group = nullptr) { void waybar::Bar::getModules(const Factory& factory, const std::string& pos,
Gtk::Box* group = nullptr) {
auto module_list = group ? config[pos]["modules"] : config[pos]; auto module_list = group ? config[pos]["modules"] : config[pos];
if (module_list.isArray()) { if (module_list.isArray()) {
for (const auto& name : module_list) { for (const auto& name : module_list) {

View File

@ -52,8 +52,8 @@ void waybar::Client::handleOutput(struct waybar_output &output) {
} }
struct waybar::waybar_output &waybar::Client::getOutput(void *addr) { struct waybar::waybar_output &waybar::Client::getOutput(void *addr) {
auto it = std::find_if( auto it = std::find_if(outputs_.begin(), outputs_.end(),
outputs_.begin(), outputs_.end(), [&addr](const auto &output) { return &output == addr; }); [&addr](const auto &output) { return &output == addr; });
if (it == outputs_.end()) { if (it == outputs_.end()) {
throw std::runtime_error("Unable to find valid output"); throw std::runtime_error("Unable to find valid output");
} }
@ -169,8 +169,8 @@ auto waybar::Client::setupCss(const std::string &css_file) -> void {
throw std::runtime_error("Can't open style file"); throw std::runtime_error("Can't open style file");
} }
// there's always only one screen // there's always only one screen
style_context_->add_provider_for_screen( style_context_->add_provider_for_screen(Gdk::Screen::get_default(), css_provider_,
Gdk::Screen::get_default(), css_provider_, GTK_STYLE_PROVIDER_PRIORITY_USER); GTK_STYLE_PROVIDER_PRIORITY_USER);
} }
void waybar::Client::bindInterfaces() { void waybar::Client::bindInterfaces() {
@ -224,8 +224,8 @@ int waybar::Client::main(int argc, char *argv[]) {
if (!log_level.empty()) { if (!log_level.empty()) {
spdlog::set_level(spdlog::level::from_str(log_level)); spdlog::set_level(spdlog::level::from_str(log_level));
} }
gtk_app = Gtk::Application::create( gtk_app = Gtk::Application::create(argc, argv, "fr.arouillard.waybar",
argc, argv, "fr.arouillard.waybar", Gio::APPLICATION_HANDLES_COMMAND_LINE); Gio::APPLICATION_HANDLES_COMMAND_LINE);
gdk_display = Gdk::Display::get_default(); gdk_display = Gdk::Display::get_default();
if (!gdk_display) { if (!gdk_display) {
throw std::runtime_error("Can't find display"); throw std::runtime_error("Can't find display");
@ -244,6 +244,4 @@ int waybar::Client::main(int argc, char *argv[]) {
return 0; return 0;
} }
void waybar::Client::reset() { void waybar::Client::reset() { gtk_app->quit(); }
gtk_app->quit();
}

View File

@ -13,12 +13,8 @@
namespace waybar { namespace waybar {
const std::vector<std::string> Config::CONFIG_DIRS = { const std::vector<std::string> Config::CONFIG_DIRS = {
"$XDG_CONFIG_HOME/waybar/", "$XDG_CONFIG_HOME/waybar/", "$HOME/.config/waybar/", "$HOME/waybar/",
"$HOME/.config/waybar/", "/etc/xdg/waybar/", SYSCONFDIR "/xdg/waybar/", "./resources/",
"$HOME/waybar/",
"/etc/xdg/waybar/",
SYSCONFDIR "/xdg/waybar/",
"./resources/",
}; };
std::optional<std::string> tryExpandPath(const std::string &path) { std::optional<std::string> tryExpandPath(const std::string &path) {

View File

@ -1,14 +1,14 @@
#include "group.hpp" #include "group.hpp"
#include <fmt/format.h> #include <fmt/format.h>
#include <util/command.hpp> #include <util/command.hpp>
namespace waybar { namespace waybar {
Group::Group(const std::string& name, const Bar& bar, const Json::Value& config) Group::Group(const std::string& name, const Bar& bar, const Json::Value& config)
: AModule(config, name, "", false, false), : AModule(config, name, "", false, false),
box{bar.vertical ? Gtk::ORIENTATION_HORIZONTAL : Gtk::ORIENTATION_VERTICAL, 0} box{bar.vertical ? Gtk::ORIENTATION_HORIZONTAL : Gtk::ORIENTATION_VERTICAL, 0} {}
{
}
auto Group::update() -> void { auto Group::update() -> void {
// noop // noop

View File

@ -1,9 +1,11 @@
#include <spdlog/spdlog.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <csignal> #include <csignal>
#include <list> #include <list>
#include <mutex> #include <mutex>
#include <sys/types.h>
#include <sys/wait.h>
#include <spdlog/spdlog.h>
#include "client.hpp" #include "client.hpp"
std::mutex reap_mtx; std::mutex reap_mtx;
@ -38,8 +40,7 @@ void* signalThread(void* args) {
} }
break; break;
default: default:
spdlog::debug("Received signal with number {}, but not handling", spdlog::debug("Received signal with number {}, but not handling", signum);
signum);
break; break;
} }
} }

View File

@ -93,8 +93,8 @@ waybar::modules::Backlight::Backlight(const std::string &id, const Json::Value &
{ {
std::unique_ptr<udev, UdevDeleter> udev_check{udev_new()}; std::unique_ptr<udev, UdevDeleter> udev_check{udev_new()};
check_nn(udev_check.get(), "Udev check new failed"); check_nn(udev_check.get(), "Udev check new failed");
enumerate_devices( enumerate_devices(devices_.begin(), devices_.end(), std::back_inserter(devices_),
devices_.begin(), devices_.end(), std::back_inserter(devices_), udev_check.get()); udev_check.get());
if (devices_.empty()) { if (devices_.empty()) {
throw std::runtime_error("No backlight found"); throw std::runtime_error("No backlight found");
} }
@ -108,8 +108,7 @@ waybar::modules::Backlight::Backlight(const std::string &id, const Json::Value &
std::unique_ptr<udev_monitor, UdevMonitorDeleter> mon{ std::unique_ptr<udev_monitor, UdevMonitorDeleter> mon{
udev_monitor_new_from_netlink(udev.get(), "udev")}; udev_monitor_new_from_netlink(udev.get(), "udev")};
check_nn(mon.get(), "udev monitor new failed"); check_nn(mon.get(), "udev monitor new failed");
check_gte(udev_monitor_filter_add_match_subsystem_devtype(mon.get(), "backlight", nullptr), check_gte(udev_monitor_filter_add_match_subsystem_devtype(mon.get(), "backlight", nullptr), 0,
0,
"udev failed to add monitor filter: "); "udev failed to add monitor filter: ");
udev_monitor_enable_receiving(mon.get()); udev_monitor_enable_receiving(mon.get());
@ -126,8 +125,8 @@ waybar::modules::Backlight::Backlight(const std::string &id, const Json::Value &
epoll_event events[EPOLL_MAX_EVENTS]; epoll_event events[EPOLL_MAX_EVENTS];
while (udev_thread_.isRunning()) { while (udev_thread_.isRunning()) {
const int event_count = epoll_wait( const int event_count = epoll_wait(epoll_fd.get(), events, EPOLL_MAX_EVENTS,
epoll_fd.get(), events, EPOLL_MAX_EVENTS, std::chrono::milliseconds{interval_}.count()); std::chrono::milliseconds{interval_}.count());
if (!udev_thread_.isRunning()) { if (!udev_thread_.isRunning()) {
break; break;
} }
@ -173,9 +172,10 @@ auto waybar::modules::Backlight::update() -> void {
return; return;
} }
const uint8_t percent = best->get_max() == 0 ? 100 : round(best->get_actual() * 100.0f / best->get_max()); const uint8_t percent =
label_.set_markup(fmt::format( best->get_max() == 0 ? 100 : round(best->get_actual() * 100.0f / best->get_max());
format_, fmt::arg("percent", std::to_string(percent)), fmt::arg("icon", getIcon(percent)))); label_.set_markup(fmt::format(format_, fmt::arg("percent", std::to_string(percent)),
fmt::arg("icon", getIcon(percent))));
getState(percent); getState(percent);
} else { } else {
if (!previous_best_.has_value()) { if (!previous_best_.has_value()) {

View File

@ -139,11 +139,16 @@ void waybar::modules::Battery::refreshBatteries() {
// Unknown > Full > Not charging > Discharging > Charging // Unknown > Full > Not charging > Discharging > Charging
static bool status_gt(const std::string& a, const std::string& b) { static bool status_gt(const std::string& a, const std::string& b) {
if (a == b) return false; if (a == b)
else if (a == "Unknown") return true; return false;
else if (a == "Full" && b != "Unknown") return true; else if (a == "Unknown")
else if (a == "Not charging" && b != "Unknown" && b != "Full") return true; return true;
else if (a == "Discharging" && b != "Unknown" && b != "Full" && b != "Not charging") return true; else if (a == "Full" && b != "Unknown")
return true;
else if (a == "Not charging" && b != "Unknown" && b != "Full")
return true;
else if (a == "Discharging" && b != "Unknown" && b != "Full" && b != "Not charging")
return true;
return false; return false;
} }
@ -317,9 +322,8 @@ auto waybar::modules::Battery::update() -> void {
} }
auto status_pretty = status; auto status_pretty = status;
// Transform to lowercase and replace space with dash // Transform to lowercase and replace space with dash
std::transform(status.begin(), status.end(), status.begin(), [](char ch) { std::transform(status.begin(), status.end(), status.begin(),
return ch == ' ' ? '-' : std::tolower(ch); [](char ch) { return ch == ' ' ? '-' : std::tolower(ch); });
});
auto format = format_; auto format = format_;
auto state = getState(capacity, true); auto state = getState(capacity, true);
auto time_remaining_formatted = formatTimeRemaining(time_remaining); auto time_remaining_formatted = formatTimeRemaining(time_remaining);
@ -341,8 +345,7 @@ auto waybar::modules::Battery::update() -> void {
} else if (config_["tooltip-format"].isString()) { } else if (config_["tooltip-format"].isString()) {
tooltip_format = config_["tooltip-format"].asString(); tooltip_format = config_["tooltip-format"].asString();
} }
label_.set_tooltip_text(fmt::format(tooltip_format, label_.set_tooltip_text(fmt::format(tooltip_format, fmt::arg("timeTo", tooltip_text_default),
fmt::arg("timeTo", tooltip_text_default),
fmt::arg("capacity", capacity), fmt::arg("capacity", capacity),
fmt::arg("time", time_remaining_formatted))); fmt::arg("time", time_remaining_formatted)));
} }
@ -363,9 +366,7 @@ auto waybar::modules::Battery::update() -> void {
} else { } else {
event_box_.show(); event_box_.show();
auto icons = std::vector<std::string>{status + "-" + state, status, state}; auto icons = std::vector<std::string>{status + "-" + state, status, state};
label_.set_markup(fmt::format(format, label_.set_markup(fmt::format(format, fmt::arg("capacity", capacity), fmt::arg("power", power),
fmt::arg("capacity", capacity),
fmt::arg("power", power),
fmt::arg("icon", getIcon(capacity, icons)), fmt::arg("icon", getIcon(capacity, icons)),
fmt::arg("time", time_remaining_formatted))); fmt::arg("time", time_remaining_formatted)));
} }

View File

@ -24,42 +24,36 @@ waybar::modules::Clock::Clock(const std::string& id, const Json::Value& config)
: ALabel(config, "clock", id, "{:%H:%M}", 60, false, false, true), : ALabel(config, "clock", id, "{:%H:%M}", 60, false, false, true),
current_time_zone_idx_(0), current_time_zone_idx_(0),
is_calendar_in_tooltip_(false), is_calendar_in_tooltip_(false),
is_timezoned_list_in_tooltip_(false) is_timezoned_list_in_tooltip_(false) {
{
if (config_["timezones"].isArray() && !config_["timezones"].empty()) { if (config_["timezones"].isArray() && !config_["timezones"].empty()) {
for (const auto& zone_name : config_["timezones"]) { for (const auto& zone_name : config_["timezones"]) {
if (!zone_name.isString() || zone_name.asString().empty()) { if (!zone_name.isString() || zone_name.asString().empty()) {
time_zones_.push_back(nullptr); time_zones_.push_back(nullptr);
continue; continue;
} }
time_zones_.push_back( time_zones_.push_back(date::locate_zone(zone_name.asString()));
date::locate_zone(
zone_name.asString()
)
);
} }
} else if (config_["timezone"].isString() && !config_["timezone"].asString().empty()) { } else if (config_["timezone"].isString() && !config_["timezone"].asString().empty()) {
time_zones_.push_back( time_zones_.push_back(date::locate_zone(config_["timezone"].asString()));
date::locate_zone(
config_["timezone"].asString()
)
);
} }
// If all timezones are parsed and no one is good, add nullptr to the timezones vector, to mark that local time should be shown. // If all timezones are parsed and no one is good, add nullptr to the timezones vector, to mark
// that local time should be shown.
if (!time_zones_.size()) { if (!time_zones_.size()) {
time_zones_.push_back(nullptr); time_zones_.push_back(nullptr);
} }
if (!is_timezone_fixed()) { if (!is_timezone_fixed()) {
spdlog::warn("As using a timezone, some format args may be missing as the date library haven't got a release since 2018."); spdlog::warn(
"As using a timezone, some format args may be missing as the date library haven't got a "
"release since 2018.");
} }
// Check if a particular placeholder is present in the tooltip format, to know what to calculate on update. // Check if a particular placeholder is present in the tooltip format, to know what to calculate
// on update.
if (config_["tooltip-format"].isString()) { if (config_["tooltip-format"].isString()) {
std::string trimmed_format = config_["tooltip-format"].asString(); std::string trimmed_format = config_["tooltip-format"].asString();
trimmed_format.erase(std::remove_if(trimmed_format.begin(), trimmed_format.erase(std::remove_if(trimmed_format.begin(), trimmed_format.end(),
trimmed_format.end(),
[](unsigned char x) { return std::isspace(x); }), [](unsigned char x) { return std::isspace(x); }),
trimmed_format.end()); trimmed_format.end());
if (trimmed_format.find("{" + kCalendarPlaceholder + "}") != std::string::npos) { if (trimmed_format.find("{" + kCalendarPlaceholder + "}") != std::string::npos) {
@ -86,7 +80,8 @@ waybar::modules::Clock::Clock(const std::string& id, const Json::Value& config)
} }
const date::time_zone* waybar::modules::Clock::current_timezone() { const date::time_zone* waybar::modules::Clock::current_timezone() {
return time_zones_[current_time_zone_idx_] ? time_zones_[current_time_zone_idx_] : date::current_zone(); return time_zones_[current_time_zone_idx_] ? time_zones_[current_time_zone_idx_]
: date::current_zone();
} }
bool waybar::modules::Clock::is_timezone_fixed() { bool waybar::modules::Clock::is_timezone_fixed() {
@ -120,7 +115,9 @@ auto waybar::modules::Clock::update() -> void {
timezoned_time_lines = timezones_text(&now); timezoned_time_lines = timezones_text(&now);
} }
auto tooltip_format = config_["tooltip-format"].asString(); auto tooltip_format = config_["tooltip-format"].asString();
text = fmt::format(tooltip_format, wtime, fmt::arg(kCalendarPlaceholder.c_str(), calendar_lines), fmt::arg(KTimezonedTimeListPlaceholder.c_str(), timezoned_time_lines)); text =
fmt::format(tooltip_format, wtime, fmt::arg(kCalendarPlaceholder.c_str(), calendar_lines),
fmt::arg(KTimezonedTimeListPlaceholder.c_str(), timezoned_time_lines));
label_.set_tooltip_markup(text); label_.set_tooltip_markup(text);
} }
} }
@ -148,7 +145,8 @@ bool waybar::modules::Clock::handleScroll(GdkEventScroll *e) {
size_t new_idx = current_time_zone_idx_ + 1; size_t new_idx = current_time_zone_idx_ + 1;
current_time_zone_idx_ = new_idx == nr_zones ? 0 : new_idx; current_time_zone_idx_ = new_idx == nr_zones ? 0 : new_idx;
} else { } else {
current_time_zone_idx_ = current_time_zone_idx_ == 0 ? nr_zones - 1 : current_time_zone_idx_ - 1; current_time_zone_idx_ =
current_time_zone_idx_ == 0 ? nr_zones - 1 : current_time_zone_idx_ - 1;
} }
update(); update();
@ -219,7 +217,8 @@ auto waybar::modules::Clock::weekdays_header(const date::weekday& first_dow, std
os << "\n"; os << "\n";
} }
auto waybar::modules::Clock::timezones_text(std::chrono::system_clock::time_point *now) -> std::string { auto waybar::modules::Clock::timezones_text(std::chrono::system_clock::time_point* now)
-> std::string {
if (time_zones_.size() == 1) { if (time_zones_.size() == 1) {
return ""; return "";
} }

View File

@ -1,11 +1,12 @@
#include "modules/cpu.hpp"
#include <sys/types.h>
#include <sys/sysctl.h>
#include <spdlog/spdlog.h> #include <spdlog/spdlog.h>
#include <cstdlib> // malloc #include <sys/sysctl.h>
#include <sys/types.h>
#include <unistd.h> // sysconf #include <unistd.h> // sysconf
#include <cmath> // NAN #include <cmath> // NAN
#include <cstdlib> // malloc
#include "modules/cpu.hpp"
#if defined(__NetBSD__) || defined(__OpenBSD__) #if defined(__NetBSD__) || defined(__OpenBSD__)
#include <sys/sched.h> #include <sys/sched.h>
@ -101,7 +102,8 @@ std::vector<std::tuple<size_t, size_t>> waybar::modules::Cpu::parseCpuinfo() {
std::vector<float> waybar::modules::Cpu::parseCpuFrequencies() { std::vector<float> waybar::modules::Cpu::parseCpuFrequencies() {
static std::vector<float> frequencies; static std::vector<float> frequencies;
if (frequencies.empty()) { if (frequencies.empty()) {
spdlog::warn("cpu/bsd: parseCpuFrequencies is not implemented, expect garbage in {*_frequency}"); spdlog::warn(
"cpu/bsd: parseCpuFrequencies is not implemented, expect garbage in {*_frequency}");
frequencies.push_back(NAN); frequencies.push_back(NAN);
} }
return frequencies; return frequencies;

View File

@ -95,7 +95,8 @@ std::tuple<std::vector<uint16_t>, std::string> waybar::modules::Cpu::getCpuUsage
std::tuple<float, float, float> waybar::modules::Cpu::getCpuFrequency() { std::tuple<float, float, float> waybar::modules::Cpu::getCpuFrequency() {
std::vector<float> frequencies = parseCpuFrequencies(); std::vector<float> frequencies = parseCpuFrequencies();
auto [min, max] = std::minmax_element(std::begin(frequencies), std::end(frequencies)); auto [min, max] = std::minmax_element(std::begin(frequencies), std::end(frequencies));
float avg_frequency = std::accumulate(std::begin(frequencies), std::end(frequencies), 0.0) / frequencies.size(); float avg_frequency =
std::accumulate(std::begin(frequencies), std::end(frequencies), 0.0) / frequencies.size();
// Round frequencies with double decimal precision to get GHz // Round frequencies with double decimal precision to get GHz
float max_frequency = std::ceil(*max / 10.0) / 100.0; float max_frequency = std::ceil(*max / 10.0) / 100.0;

View File

@ -1,4 +1,5 @@
#include <filesystem> #include <filesystem>
#include "modules/cpu.hpp" #include "modules/cpu.hpp"
std::vector<std::tuple<size_t, size_t>> waybar::modules::Cpu::parseCpuinfo() { std::vector<std::tuple<size_t, size_t>> waybar::modules::Cpu::parseCpuinfo() {
@ -51,10 +52,7 @@ std::vector<float> waybar::modules::Cpu::parseCpuFrequencies() {
if (frequencies.size() <= 0) { if (frequencies.size() <= 0) {
std::string cpufreq_dir = "/sys/devices/system/cpu/cpufreq"; std::string cpufreq_dir = "/sys/devices/system/cpu/cpufreq";
if (std::filesystem::exists(cpufreq_dir)) { if (std::filesystem::exists(cpufreq_dir)) {
std::vector<std::string> frequency_files = { std::vector<std::string> frequency_files = {"/cpuinfo_min_freq", "/cpuinfo_max_freq"};
"/cpuinfo_min_freq",
"/cpuinfo_max_freq"
};
for (auto& p : std::filesystem::directory_iterator(cpufreq_dir)) { for (auto& p : std::filesystem::directory_iterator(cpufreq_dir)) {
for (auto freq_file : frequency_files) { for (auto freq_file : frequency_files) {
std::string freq_file_path = p.path().string() + freq_file; std::string freq_file_path = p.path().string() + freq_file;

View File

@ -120,9 +120,7 @@ auto waybar::modules::Custom::update() -> void {
} else { } else {
parseOutputRaw(); parseOutputRaw();
} }
auto str = fmt::format(format_, auto str = fmt::format(format_, text_, fmt::arg("alt", alt_),
text_,
fmt::arg("alt", alt_),
fmt::arg("icon", getIcon(percentage_, alt_)), fmt::arg("icon", getIcon(percentage_, alt_)),
fmt::arg("percentage", percentage_)); fmt::arg("percentage", percentage_));
if (str.empty()) { if (str.empty()) {

View File

@ -3,9 +3,7 @@
using namespace waybar::util; using namespace waybar::util;
waybar::modules::Disk::Disk(const std::string& id, const Json::Value& config) waybar::modules::Disk::Disk(const std::string& id, const Json::Value& config)
: ALabel(config, "disk", id, "{}%", 30) : ALabel(config, "disk", id, "{}%", 30), path_("/") {
, path_("/")
{
thread_ = [this] { thread_ = [this] {
dp.emit(); dp.emit();
thread_.sleep_for(interval_); thread_.sleep_for(interval_);
@ -28,7 +26,8 @@ auto waybar::modules::Disk::update() -> void {
unsigned long f_fsid; // filesystem ID unsigned long f_fsid; // filesystem ID
unsigned long f_flag; // mount flags unsigned long f_flag; // mount flags
unsigned long f_namemax; // maximum filename length unsigned long f_namemax; // maximum filename length
}; */ stats; }; */
stats;
int err = statvfs(path_.c_str(), &stats); int err = statvfs(path_.c_str(), &stats);
/* Conky options /* Conky options
@ -59,15 +58,11 @@ auto waybar::modules::Disk::update() -> void {
event_box_.hide(); event_box_.hide();
} else { } else {
event_box_.show(); event_box_.show();
label_.set_markup(fmt::format(format label_.set_markup(
, stats.f_bavail * 100 / stats.f_blocks fmt::format(format, stats.f_bavail * 100 / stats.f_blocks, fmt::arg("free", free),
, fmt::arg("free", free) fmt::arg("percentage_free", stats.f_bavail * 100 / stats.f_blocks),
, fmt::arg("percentage_free", stats.f_bavail * 100 / stats.f_blocks) fmt::arg("used", used), fmt::arg("percentage_used", percentage_used),
, fmt::arg("used", used) fmt::arg("total", total), fmt::arg("path", path_)));
, fmt::arg("percentage_used", percentage_used)
, fmt::arg("total", total)
, fmt::arg("path", path_)
));
} }
if (tooltipEnabled()) { if (tooltipEnabled()) {
@ -75,15 +70,11 @@ auto waybar::modules::Disk::update() -> void {
if (config_["tooltip-format"].isString()) { if (config_["tooltip-format"].isString()) {
tooltip_format = config_["tooltip-format"].asString(); tooltip_format = config_["tooltip-format"].asString();
} }
label_.set_tooltip_text(fmt::format(tooltip_format label_.set_tooltip_text(
, stats.f_bavail * 100 / stats.f_blocks fmt::format(tooltip_format, stats.f_bavail * 100 / stats.f_blocks, fmt::arg("free", free),
, fmt::arg("free", free) fmt::arg("percentage_free", stats.f_bavail * 100 / stats.f_blocks),
, fmt::arg("percentage_free", stats.f_bavail * 100 / stats.f_blocks) fmt::arg("used", used), fmt::arg("percentage_used", percentage_used),
, fmt::arg("used", used) fmt::arg("total", total), fmt::arg("path", path_)));
, fmt::arg("percentage_used", percentage_used)
, fmt::arg("total", total)
, fmt::arg("path", path_)
));
} }
// Call parent update // Call parent update
ALabel::update(); ALabel::update();

View File

@ -58,8 +58,8 @@ auto waybar::modules::IdleInhibitor::update() -> void {
} }
std::string status_text = status ? "activated" : "deactivated"; std::string status_text = status ? "activated" : "deactivated";
label_.set_markup( label_.set_markup(fmt::format(format_, fmt::arg("status", status_text),
fmt::format(format_, fmt::arg("status", status_text), fmt::arg("icon", getIcon(0, status_text)))); fmt::arg("icon", getIcon(0, status_text))));
label_.get_style_context()->add_class(status_text); label_.get_style_context()->add_class(status_text);
if (tooltipEnabled()) { if (tooltipEnabled()) {
label_.set_tooltip_text(status_text); label_.set_tooltip_text(status_text);

View File

@ -10,8 +10,7 @@ using DBus = std::unique_ptr<GDBusConnection, void(*)(GDBusConnection*)>;
auto dbus() -> DBus { auto dbus() -> DBus {
GError* error = nullptr; GError* error = nullptr;
GDBusConnection* connection = GDBusConnection* connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
if (error) { if (error) {
spdlog::error("g_bus_get_sync() failed: {}", error->message); spdlog::error("g_bus_get_sync() failed: {}", error->message);
@ -23,9 +22,7 @@ auto dbus() -> DBus {
GError* error = nullptr; GError* error = nullptr;
g_dbus_connection_close_sync(connection, nullptr, &error); g_dbus_connection_close_sync(connection, nullptr, &error);
if (error) { if (error) {
spdlog::error( spdlog::error("g_bus_connection_close_sync failed(): {}", error->message);
"g_bus_connection_close_sync failed(): {}",
error->message);
g_error_free(error); g_error_free(error);
} }
}; };
@ -38,28 +35,13 @@ auto getLocks(const DBus& bus, const std::string& inhibitors) -> int {
GUnixFDList* fd_list; GUnixFDList* fd_list;
int handle; int handle;
auto reply = g_dbus_connection_call_with_unix_fd_list_sync(bus.get(), auto reply = g_dbus_connection_call_with_unix_fd_list_sync(
"org.freedesktop.login1", bus.get(), "org.freedesktop.login1", "/org/freedesktop/login1",
"/org/freedesktop/login1", "org.freedesktop.login1.Manager", "Inhibit",
"org.freedesktop.login1.Manager", g_variant_new("(ssss)", inhibitors.c_str(), "waybar", "Asked by user", "block"),
"Inhibit", G_VARIANT_TYPE("(h)"), G_DBUS_CALL_FLAGS_NONE, -1, nullptr, &fd_list, nullptr, &error);
g_variant_new(
"(ssss)",
inhibitors.c_str(),
"waybar",
"Asked by user",
"block"),
G_VARIANT_TYPE("(h)"),
G_DBUS_CALL_FLAGS_NONE,
-1,
nullptr,
&fd_list,
nullptr,
&error);
if (error) { if (error) {
spdlog::error( spdlog::error("g_dbus_connection_call_with_unix_fd_list_sync() failed: {}", error->message);
"g_dbus_connection_call_with_unix_fd_list_sync() failed: {}",
error->message);
g_error_free(error); g_error_free(error);
handle = -1; handle = -1;
} else { } else {
@ -74,18 +56,15 @@ auto getLocks(const DBus& bus, const std::string& inhibitors) -> int {
} }
auto checkInhibitor(const std::string& inhibitor) -> const std::string& { auto checkInhibitor(const std::string& inhibitor) -> const std::string& {
static const auto inhibitors = std::array{ static const auto inhibitors = std::array{"idle",
"idle",
"shutdown", "shutdown",
"sleep", "sleep",
"handle-power-key", "handle-power-key",
"handle-suspend-key", "handle-suspend-key",
"handle-hibernate-key", "handle-hibernate-key",
"handle-lid-switch" "handle-lid-switch"};
};
if (std::find(inhibitors.begin(), inhibitors.end(), inhibitor) if (std::find(inhibitors.begin(), inhibitors.end(), inhibitor) == inhibitors.end()) {
== inhibitors.end()) {
throw std::runtime_error("invalid logind inhibitor " + inhibitor); throw std::runtime_error("invalid logind inhibitor " + inhibitor);
} }
@ -114,18 +93,16 @@ auto getInhibitors(const Json::Value& config) -> std::string {
return inhibitors; return inhibitors;
} }
} } // namespace
namespace waybar::modules { namespace waybar::modules {
Inhibitor::Inhibitor(const std::string& id, const Bar& bar, Inhibitor::Inhibitor(const std::string& id, const Bar& bar, const Json::Value& config)
const Json::Value& config)
: ALabel(config, "inhibitor", id, "{status}", true), : ALabel(config, "inhibitor", id, "{status}", true),
dbus_(::dbus()), dbus_(::dbus()),
inhibitors_(::getInhibitors(config)) { inhibitors_(::getInhibitors(config)) {
event_box_.add_events(Gdk::BUTTON_PRESS_MASK); event_box_.add_events(Gdk::BUTTON_PRESS_MASK);
event_box_.signal_button_press_event().connect( event_box_.signal_button_press_event().connect(sigc::mem_fun(*this, &Inhibitor::handleToggle));
sigc::mem_fun(*this, &Inhibitor::handleToggle));
dp.emit(); dp.emit();
} }
@ -135,17 +112,13 @@ Inhibitor::~Inhibitor() {
} }
} }
auto Inhibitor::activated() -> bool { auto Inhibitor::activated() -> bool { return handle_ != -1; }
return handle_ != -1;
}
auto Inhibitor::update() -> void { auto Inhibitor::update() -> void {
std::string status_text = activated() ? "activated" : "deactivated"; std::string status_text = activated() ? "activated" : "deactivated";
label_.get_style_context()->remove_class( label_.get_style_context()->remove_class(activated() ? "deactivated" : "activated");
activated() ? "deactivated" : "activated"); label_.set_markup(fmt::format(format_, fmt::arg("status", status_text),
label_.set_markup(
fmt::format(format_, fmt::arg("status", status_text),
fmt::arg("icon", getIcon(0, status_text)))); fmt::arg("icon", getIcon(0, status_text))));
label_.get_style_context()->add_class(status_text); label_.get_style_context()->add_class(status_text);
@ -172,4 +145,4 @@ auto Inhibitor::handleToggle(GdkEventButton* const& e) -> bool {
return ALabel::handleToggle(e); return ALabel::handleToggle(e);
} }
} // waybar::modules } // namespace waybar::modules

View File

@ -1,31 +1,32 @@
#include "modules/keyboard_state.hpp" #include "modules/keyboard_state.hpp"
#include <errno.h> #include <errno.h>
#include <filesystem>
#include <spdlog/spdlog.h> #include <spdlog/spdlog.h>
#include <string.h> #include <string.h>
#include <filesystem>
extern "C" { extern "C" {
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h> #include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
} }
class errno_error : public std::runtime_error { class errno_error : public std::runtime_error {
public: public:
int code; int code;
errno_error(int code, const std::string& msg) errno_error(int code, const std::string& msg)
: std::runtime_error(getErrorMsg(code, msg.c_str())), : std::runtime_error(getErrorMsg(code, msg.c_str())), code(code) {}
code(code) {} errno_error(int code, const char* msg) : std::runtime_error(getErrorMsg(code, msg)), code(code) {}
errno_error(int code, const char* msg)
: std::runtime_error(getErrorMsg(code, msg)),
code(code) {}
private: private:
static auto getErrorMsg(int err, const char* msg) -> std::string { static auto getErrorMsg(int err, const char* msg) -> std::string {
std::string error_msg{msg}; std::string error_msg{msg};
error_msg += ": "; error_msg += ": ";
#if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 32) #if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 32)
// strerrorname_np gets the error code's name; it's nice to have, but it's a recent GNU extension // strerrorname_np gets the error code's name; it's nice to have, but it's a recent GNU
// extension
const auto errno_name = strerrorname_np(err); const auto errno_name = strerrorname_np(err);
error_msg += errno_name; error_msg += errno_name;
error_msg += " "; error_msg += " ";
@ -67,27 +68,31 @@ auto openDevice(int fd) -> libevdev* {
} }
auto supportsLockStates(const libevdev* dev) -> bool { auto supportsLockStates(const libevdev* dev) -> bool {
return libevdev_has_event_type(dev, EV_LED) return libevdev_has_event_type(dev, EV_LED) && libevdev_has_event_code(dev, EV_LED, LED_NUML) &&
&& libevdev_has_event_code(dev, EV_LED, LED_NUML) libevdev_has_event_code(dev, EV_LED, LED_CAPSL) &&
&& libevdev_has_event_code(dev, EV_LED, LED_CAPSL) libevdev_has_event_code(dev, EV_LED, LED_SCROLLL);
&& libevdev_has_event_code(dev, EV_LED, LED_SCROLLL);
} }
waybar::modules::KeyboardState::KeyboardState(const std::string& id, const Bar& bar, const Json::Value& config) waybar::modules::KeyboardState::KeyboardState(const std::string& id, const Bar& bar,
const Json::Value& config)
: AModule(config, "keyboard-state", id, false, !config["disable-scroll"].asBool()), : AModule(config, "keyboard-state", id, false, !config["disable-scroll"].asBool()),
box_(bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0), box_(bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0),
numlock_label_(""), numlock_label_(""),
capslock_label_(""), capslock_label_(""),
numlock_format_(config_["format"].isString() ? config_["format"].asString() numlock_format_(config_["format"].isString() ? config_["format"].asString()
: config_["format"]["numlock"].isString() ? config_["format"]["numlock"].asString() : config_["format"]["numlock"].isString()
? config_["format"]["numlock"].asString()
: "{name} {icon}"), : "{name} {icon}"),
capslock_format_(config_["format"].isString() ? config_["format"].asString() capslock_format_(config_["format"].isString() ? config_["format"].asString()
: config_["format"]["capslock"].isString() ? config_["format"]["capslock"].asString() : config_["format"]["capslock"].isString()
? config_["format"]["capslock"].asString()
: "{name} {icon}"), : "{name} {icon}"),
scrolllock_format_(config_["format"].isString() ? config_["format"].asString() scrolllock_format_(config_["format"].isString() ? config_["format"].asString()
: config_["format"]["scrolllock"].isString() ? config_["format"]["scrolllock"].asString() : config_["format"]["scrolllock"].isString()
? config_["format"]["scrolllock"].asString()
: "{name} {icon}"), : "{name} {icon}"),
interval_(std::chrono::seconds(config_["interval"].isUInt() ? config_["interval"].asUInt() : 1)), interval_(
std::chrono::seconds(config_["interval"].isUInt() ? config_["interval"].asUInt() : 1)),
icon_locked_(config_["format-icons"]["locked"].isString() icon_locked_(config_["format-icons"]["locked"].isString()
? config_["format-icons"]["locked"].asString() ? config_["format-icons"]["locked"].asString()
: "locked"), : "locked"),

View File

@ -1,9 +1,9 @@
#include "modules/memory.hpp"
#include <sys/types.h>
#include <sys/sysctl.h> #include <sys/sysctl.h>
#include <sys/types.h>
#include <unistd.h> // getpagesize #include <unistd.h> // getpagesize
#include "modules/memory.hpp"
#if defined(__DragonFly__) #if defined(__DragonFly__)
#include <sys/vmmeter.h> // struct vmstats #include <sys/vmmeter.h> // struct vmstats
#elif defined(__NetBSD__) #elif defined(__NetBSD__)
@ -43,21 +43,15 @@ static uint64_t get_free_memory() {
if (sysctlbyname("vm.vmstats", &vms, &sz, NULL, 0)) { if (sysctlbyname("vm.vmstats", &vms, &sz, NULL, 0)) {
throw std::runtime_error("sysctl vm.vmstats failed"); throw std::runtime_error("sysctl vm.vmstats failed");
} }
return static_cast<uint64_t> return static_cast<uint64_t>(vms.v_free_count + vms.v_inactive_count + vms.v_cache_count) *
(vms.v_free_count + vms.v_inactive_count + vms.v_cache_count) getpagesize();
* getpagesize();
#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
u_int v_free_count = 0, v_inactive_count = 0, v_cache_count = 0; u_int v_free_count = 0, v_inactive_count = 0, v_cache_count = 0;
size_t sz = sizeof(u_int); size_t sz = sizeof(u_int);
sysctlbyname("vm.stats.vm.v_free_count", sysctlbyname("vm.stats.vm.v_free_count", &v_free_count, &sz, NULL, 0);
&v_free_count, &sz, NULL, 0); sysctlbyname("vm.stats.vm.v_inactive_count", &v_inactive_count, &sz, NULL, 0);
sysctlbyname("vm.stats.vm.v_inactive_count", sysctlbyname("vm.stats.vm.v_cache_count", &v_cache_count, &sz, NULL, 0);
&v_inactive_count, &sz, NULL, 0); return static_cast<uint64_t>(v_free_count + v_inactive_count + v_cache_count) * getpagesize();
sysctlbyname("vm.stats.vm.v_cache_count",
&v_cache_count, &sz, NULL, 0);
return static_cast<uint64_t>
(v_free_count + v_inactive_count + v_cache_count)
* getpagesize();
#elif defined(__NetBSD__) || defined(__OpenBSD__) #elif defined(__NetBSD__) || defined(__OpenBSD__)
#ifdef VM_UVMEXP2 #ifdef VM_UVMEXP2
#undef VM_UVMEXP #undef VM_UVMEXP
@ -77,9 +71,9 @@ static uint64_t get_free_memory() {
if (sysctl(mib, miblen, &uvmexp, &sz, NULL, 0)) { if (sysctl(mib, miblen, &uvmexp, &sz, NULL, 0)) {
throw std::runtime_error("sysctl vm.uvmexp failed"); throw std::runtime_error("sysctl vm.uvmexp failed");
} }
return static_cast<uint64_t> return static_cast<uint64_t>(uvmexp.free + uvmexp.inactive + uvmexp.filepages +
(uvmexp.free + uvmexp.inactive + uvmexp.filepages + uvmexp.execpages) uvmexp.execpages) *
* uvmexp.pagesize; uvmexp.pagesize;
#endif #endif
} }

View File

@ -54,31 +54,24 @@ auto waybar::modules::Memory::update() -> void {
} else { } else {
event_box_.show(); event_box_.show();
auto icons = std::vector<std::string>{state}; auto icons = std::vector<std::string>{state};
label_.set_markup(fmt::format(format, label_.set_markup(fmt::format(
used_ram_percentage, format, used_ram_percentage, fmt::arg("icon", getIcon(used_ram_percentage, icons)),
fmt::arg("icon", getIcon(used_ram_percentage, icons)), fmt::arg("total", total_ram_gigabytes), fmt::arg("swapTotal", total_swap_gigabytes),
fmt::arg("total", total_ram_gigabytes),
fmt::arg("swapTotal", total_swap_gigabytes),
fmt::arg("percentage", used_ram_percentage), fmt::arg("percentage", used_ram_percentage),
fmt::arg("swapPercentage", used_swap_percentage), fmt::arg("swapPercentage", used_swap_percentage), fmt::arg("used", used_ram_gigabytes),
fmt::arg("used", used_ram_gigabytes), fmt::arg("swapUsed", used_swap_gigabytes), fmt::arg("avail", available_ram_gigabytes),
fmt::arg("swapUsed", used_swap_gigabytes),
fmt::arg("avail", available_ram_gigabytes),
fmt::arg("swapAvail", available_swap_gigabytes))); fmt::arg("swapAvail", available_swap_gigabytes)));
} }
if (tooltipEnabled()) { if (tooltipEnabled()) {
if (config_["tooltip-format"].isString()) { if (config_["tooltip-format"].isString()) {
auto tooltip_format = config_["tooltip-format"].asString(); auto tooltip_format = config_["tooltip-format"].asString();
label_.set_tooltip_text(fmt::format(tooltip_format, label_.set_tooltip_text(fmt::format(
used_ram_percentage, tooltip_format, used_ram_percentage, fmt::arg("total", total_ram_gigabytes),
fmt::arg("total", total_ram_gigabytes),
fmt::arg("swapTotal", total_swap_gigabytes), fmt::arg("swapTotal", total_swap_gigabytes),
fmt::arg("percentage", used_ram_percentage), fmt::arg("percentage", used_ram_percentage),
fmt::arg("swapPercentage", used_swap_percentage), fmt::arg("swapPercentage", used_swap_percentage), fmt::arg("used", used_ram_gigabytes),
fmt::arg("used", used_ram_gigabytes), fmt::arg("swapUsed", used_swap_gigabytes), fmt::arg("avail", available_ram_gigabytes),
fmt::arg("swapUsed", used_swap_gigabytes),
fmt::arg("avail", available_ram_gigabytes),
fmt::arg("swapAvail", available_swap_gigabytes))); fmt::arg("swapAvail", available_swap_gigabytes)));
} else { } else {
label_.set_tooltip_text(fmt::format("{:.{}f}GiB used", used_ram_gigabytes, 1)); label_.set_tooltip_text(fmt::format("{:.{}f}GiB used", used_ram_gigabytes, 1));

View File

@ -1,8 +1,9 @@
#include "modules/mpd/mpd.hpp" #include "modules/mpd/mpd.hpp"
#include <fmt/chrono.h> #include <fmt/chrono.h>
#include <spdlog/spdlog.h>
#include <glibmm/ustring.h> #include <glibmm/ustring.h>
#include <spdlog/spdlog.h>
#include "modules/mpd/state.hpp" #include "modules/mpd/state.hpp"
#if defined(MPD_NOINLINE) #if defined(MPD_NOINLINE)
namespace waybar::modules { namespace waybar::modules {
@ -148,28 +149,23 @@ void waybar::modules::MPD::setLabel() {
bool singleActivated = mpd_status_get_single(status_.get()); bool singleActivated = mpd_status_get_single(status_.get());
std::string singleIcon = getOptionIcon("single", singleActivated); std::string singleIcon = getOptionIcon("single", singleActivated);
if (config_["artist-len"].isInt()) artist = artist.substr(0, config_["artist-len"].asInt()); if (config_["artist-len"].isInt()) artist = artist.substr(0, config_["artist-len"].asInt());
if (config_["album-artist-len"].isInt()) album_artist = album_artist.substr(0, config_["album-artist-len"].asInt()); if (config_["album-artist-len"].isInt())
album_artist = album_artist.substr(0, config_["album-artist-len"].asInt());
if (config_["album-len"].isInt()) album = album.substr(0, config_["album-len"].asInt()); if (config_["album-len"].isInt()) album = album.substr(0, config_["album-len"].asInt());
if (config_["title-len"].isInt()) title = title.substr(0, config_["title-len"].asInt()); if (config_["title-len"].isInt()) title = title.substr(0, config_["title-len"].asInt());
try { try {
label_.set_markup( label_.set_markup(
fmt::format(format, fmt::format(format, fmt::arg("artist", Glib::Markup::escape_text(artist).raw()),
fmt::arg("artist", Glib::Markup::escape_text(artist).raw()),
fmt::arg("albumArtist", Glib::Markup::escape_text(album_artist).raw()), fmt::arg("albumArtist", Glib::Markup::escape_text(album_artist).raw()),
fmt::arg("album", Glib::Markup::escape_text(album).raw()), fmt::arg("album", Glib::Markup::escape_text(album).raw()),
fmt::arg("title", Glib::Markup::escape_text(title).raw()), fmt::arg("title", Glib::Markup::escape_text(title).raw()),
fmt::arg("date", Glib::Markup::escape_text(date).raw()), fmt::arg("date", Glib::Markup::escape_text(date).raw()),
fmt::arg("volume", volume), fmt::arg("volume", volume), fmt::arg("elapsedTime", elapsedTime),
fmt::arg("elapsedTime", elapsedTime), fmt::arg("totalTime", totalTime), fmt::arg("songPosition", song_pos),
fmt::arg("totalTime", totalTime), fmt::arg("queueLength", queue_length), fmt::arg("stateIcon", stateIcon),
fmt::arg("songPosition", song_pos), fmt::arg("consumeIcon", consumeIcon), fmt::arg("randomIcon", randomIcon),
fmt::arg("queueLength", queue_length), fmt::arg("repeatIcon", repeatIcon), fmt::arg("singleIcon", singleIcon)));
fmt::arg("stateIcon", stateIcon),
fmt::arg("consumeIcon", consumeIcon),
fmt::arg("randomIcon", randomIcon),
fmt::arg("repeatIcon", repeatIcon),
fmt::arg("singleIcon", singleIcon)));
} catch (fmt::format_error const& e) { } catch (fmt::format_error const& e) {
spdlog::warn("mpd: format error: {}", e.what()); spdlog::warn("mpd: format error: {}", e.what());
} }
@ -179,22 +175,15 @@ void waybar::modules::MPD::setLabel() {
tooltip_format = config_["tooltip-format"].isString() ? config_["tooltip-format"].asString() tooltip_format = config_["tooltip-format"].isString() ? config_["tooltip-format"].asString()
: "MPD (connected)"; : "MPD (connected)";
try { try {
auto tooltip_text = fmt::format(tooltip_format, auto tooltip_text =
fmt::arg("artist", artist.raw()), fmt::format(tooltip_format, fmt::arg("artist", artist.raw()),
fmt::arg("albumArtist", album_artist.raw()), fmt::arg("albumArtist", album_artist.raw()), fmt::arg("album", album.raw()),
fmt::arg("album", album.raw()), fmt::arg("title", title.raw()), fmt::arg("date", date),
fmt::arg("title", title.raw()), fmt::arg("volume", volume), fmt::arg("elapsedTime", elapsedTime),
fmt::arg("date", date), fmt::arg("totalTime", totalTime), fmt::arg("songPosition", song_pos),
fmt::arg("volume", volume), fmt::arg("queueLength", queue_length), fmt::arg("stateIcon", stateIcon),
fmt::arg("elapsedTime", elapsedTime), fmt::arg("consumeIcon", consumeIcon), fmt::arg("randomIcon", randomIcon),
fmt::arg("totalTime", totalTime), fmt::arg("repeatIcon", repeatIcon), fmt::arg("singleIcon", singleIcon));
fmt::arg("songPosition", song_pos),
fmt::arg("queueLength", queue_length),
fmt::arg("stateIcon", stateIcon),
fmt::arg("consumeIcon", consumeIcon),
fmt::arg("randomIcon", randomIcon),
fmt::arg("repeatIcon", repeatIcon),
fmt::arg("singleIcon", singleIcon));
label_.set_tooltip_text(tooltip_text); label_.set_tooltip_text(tooltip_text);
} catch (fmt::format_error const& e) { } catch (fmt::format_error const& e) {
spdlog::warn("mpd: format error (tooltip): {}", e.what()); spdlog::warn("mpd: format error (tooltip): {}", e.what());

View File

@ -61,8 +61,7 @@ void Idle::entry() noexcept {
spdlog::debug("mpd: Idle: watching FD"); spdlog::debug("mpd: Idle: watching FD");
sigc::slot<bool, Glib::IOCondition const&> idle_slot = sigc::mem_fun(*this, &Idle::on_io); sigc::slot<bool, Glib::IOCondition const&> idle_slot = sigc::mem_fun(*this, &Idle::on_io);
idle_connection_ = idle_connection_ =
Glib::signal_io().connect(idle_slot, Glib::signal_io().connect(idle_slot, mpd_connection_get_fd(conn),
mpd_connection_get_fd(conn),
Glib::IO_IN | Glib::IO_PRI | Glib::IO_ERR | Glib::IO_HUP); Glib::IO_IN | Glib::IO_PRI | Glib::IO_ERR | Glib::IO_HUP);
} }
} }
@ -327,8 +326,7 @@ void Disconnected::arm_timer(int interval) noexcept {
// register timer // register timer
sigc::slot<bool> timer_slot = sigc::mem_fun(*this, &Disconnected::on_timer); sigc::slot<bool> timer_slot = sigc::mem_fun(*this, &Disconnected::on_timer);
timer_connection_ = timer_connection_ = Glib::signal_timeout().connect(timer_slot, interval);
Glib::signal_timeout().connect(timer_slot, interval);
spdlog::debug("mpd: Disconnected: enabled interval timer."); spdlog::debug("mpd: Disconnected: enabled interval timer.");
} }
@ -345,9 +343,7 @@ void Disconnected::entry() noexcept {
arm_timer(1'000); arm_timer(1'000);
} }
void Disconnected::exit() noexcept { void Disconnected::exit() noexcept { disarm_timer(); }
disarm_timer();
}
bool Disconnected::on_timer() { bool Disconnected::on_timer() {
// Attempt to connect with MPD. // Attempt to connect with MPD.

View File

@ -1,13 +1,14 @@
#include "modules/network.hpp"
#include <linux/if.h> #include <linux/if.h>
#include <spdlog/spdlog.h> #include <spdlog/spdlog.h>
#include <sys/eventfd.h> #include <sys/eventfd.h>
#include <cassert> #include <cassert>
#include <fstream> #include <fstream>
#include <sstream>
#include <optional> #include <optional>
#include <sstream>
#include "modules/network.hpp"
#include "util/format.hpp" #include "util/format.hpp"
#ifdef WANT_RFKILL #ifdef WANT_RFKILL
#include "util/rfkill.hpp" #include "util/rfkill.hpp"
@ -58,9 +59,13 @@ waybar::modules::Network::readBandwidthUsage() {
// Skip all the other columns in the received group // Skip all the other columns in the received group
for (int colsToSkip = 7; colsToSkip > 0; colsToSkip--) { for (int colsToSkip = 7; colsToSkip > 0; colsToSkip--) {
// skip whitespace between columns // skip whitespace between columns
while (iss.peek() == ' ') { iss.ignore(); } while (iss.peek() == ' ') {
iss.ignore();
}
// skip the irrelevant column // skip the irrelevant column
while (iss.peek() != ' ') { iss.ignore(); } while (iss.peek() != ' ') {
iss.ignore();
}
} }
// Read transmit bytes // Read transmit bytes
iss >> t; iss >> t;
@ -274,8 +279,7 @@ void waybar::modules::Network::worker() {
const std::string waybar::modules::Network::getNetworkState() const { const std::string waybar::modules::Network::getNetworkState() const {
if (ifid_ == -1) { if (ifid_ == -1) {
#ifdef WANT_RFKILL #ifdef WANT_RFKILL
if (rfkill_.getState()) if (rfkill_.getState()) return "disabled";
return "disabled";
#endif #endif
return "disconnected"; return "disconnected";
} }
@ -327,17 +331,11 @@ auto waybar::modules::Network::update() -> void {
getState(signal_strength_); getState(signal_strength_);
auto text = fmt::format( auto text = fmt::format(
format_, format_, fmt::arg("essid", essid_), fmt::arg("signaldBm", signal_strength_dbm_),
fmt::arg("essid", essid_),
fmt::arg("signaldBm", signal_strength_dbm_),
fmt::arg("signalStrength", signal_strength_), fmt::arg("signalStrength", signal_strength_),
fmt::arg("signalStrengthApp", signal_strength_app_), fmt::arg("signalStrengthApp", signal_strength_app_), fmt::arg("ifname", ifname_),
fmt::arg("ifname", ifname_), fmt::arg("netmask", netmask_), fmt::arg("ipaddr", ipaddr_), fmt::arg("gwaddr", gwaddr_),
fmt::arg("netmask", netmask_), fmt::arg("cidr", cidr_), fmt::arg("frequency", fmt::format("{:.1f}", frequency_)),
fmt::arg("ipaddr", ipaddr_),
fmt::arg("gwaddr", gwaddr_),
fmt::arg("cidr", cidr_),
fmt::arg("frequency", fmt::format("{:.1f}", frequency_)),
fmt::arg("icon", getIcon(signal_strength_, state_)), fmt::arg("icon", getIcon(signal_strength_, state_)),
fmt::arg("bandwidthDownBits", pow_format(bandwidth_down * 8ull / interval_.count(), "b/s")), fmt::arg("bandwidthDownBits", pow_format(bandwidth_down * 8ull / interval_.count(), "b/s")),
fmt::arg("bandwidthUpBits", pow_format(bandwidth_up * 8ull / interval_.count(), "b/s")), fmt::arg("bandwidthUpBits", pow_format(bandwidth_up * 8ull / interval_.count(), "b/s")),
@ -359,17 +357,11 @@ auto waybar::modules::Network::update() -> void {
} }
if (!tooltip_format.empty()) { if (!tooltip_format.empty()) {
auto tooltip_text = fmt::format( auto tooltip_text = fmt::format(
tooltip_format, tooltip_format, fmt::arg("essid", essid_), fmt::arg("signaldBm", signal_strength_dbm_),
fmt::arg("essid", essid_),
fmt::arg("signaldBm", signal_strength_dbm_),
fmt::arg("signalStrength", signal_strength_), fmt::arg("signalStrength", signal_strength_),
fmt::arg("signalStrengthApp", signal_strength_app_), fmt::arg("signalStrengthApp", signal_strength_app_), fmt::arg("ifname", ifname_),
fmt::arg("ifname", ifname_), fmt::arg("netmask", netmask_), fmt::arg("ipaddr", ipaddr_), fmt::arg("gwaddr", gwaddr_),
fmt::arg("netmask", netmask_), fmt::arg("cidr", cidr_), fmt::arg("frequency", fmt::format("{:.1f}", frequency_)),
fmt::arg("ipaddr", ipaddr_),
fmt::arg("gwaddr", gwaddr_),
fmt::arg("cidr", cidr_),
fmt::arg("frequency", fmt::format("{:.1f}", frequency_)),
fmt::arg("icon", getIcon(signal_strength_, state_)), fmt::arg("icon", getIcon(signal_strength_, state_)),
fmt::arg("bandwidthDownBits", fmt::arg("bandwidthDownBits",
pow_format(bandwidth_down * 8ull / interval_.count(), "b/s")), pow_format(bandwidth_down * 8ull / interval_.count(), "b/s")),
@ -436,8 +428,7 @@ int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) {
// Check if the interface goes "down" and if we want to detect the // Check if the interface goes "down" and if we want to detect the
// external interface. // external interface.
if (net->ifid_ != -1 && !(ifi->ifi_flags & IFF_UP) if (net->ifid_ != -1 && !(ifi->ifi_flags & IFF_UP) && !net->config_["interface"].isString()) {
&& !net->config_["interface"].isString()) {
// The current interface is now down, all the routes associated with // The current interface is now down, all the routes associated with
// it have been deleted, so start looking for a new default route. // it have been deleted, so start looking for a new default route.
spdlog::debug("network: if{} down", net->ifid_); spdlog::debug("network: if{} down", net->ifid_);
@ -537,15 +528,13 @@ int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) {
case IFA_ADDRESS: { case IFA_ADDRESS: {
char ipaddr[INET6_ADDRSTRLEN]; char ipaddr[INET6_ADDRSTRLEN];
if (!is_del_event) { if (!is_del_event) {
net->ipaddr_ = inet_ntop(ifa->ifa_family, RTA_DATA(ifa_rta), net->ipaddr_ = inet_ntop(ifa->ifa_family, RTA_DATA(ifa_rta), ipaddr, sizeof(ipaddr));
ipaddr, sizeof (ipaddr));
net->cidr_ = ifa->ifa_prefixlen; net->cidr_ = ifa->ifa_prefixlen;
switch (ifa->ifa_family) { switch (ifa->ifa_family) {
case AF_INET: { case AF_INET: {
struct in_addr netmask; struct in_addr netmask;
netmask.s_addr = htonl(~0 << (32 - ifa->ifa_prefixlen)); netmask.s_addr = htonl(~0 << (32 - ifa->ifa_prefixlen));
net->netmask_ = inet_ntop(ifa->ifa_family, &netmask, net->netmask_ = inet_ntop(ifa->ifa_family, &netmask, ipaddr, sizeof(ipaddr));
ipaddr, sizeof (ipaddr));
} }
case AF_INET6: { case AF_INET6: {
struct in6_addr netmask; struct in6_addr netmask;
@ -555,8 +544,7 @@ int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) {
if (v > 8) v = 8; if (v > 8) v = 8;
netmask.s6_addr[i] = ~0 << v; netmask.s6_addr[i] = ~0 << v;
} }
net->netmask_ = inet_ntop(ifa->ifa_family, &netmask, net->netmask_ = inet_ntop(ifa->ifa_family, &netmask, ipaddr, sizeof(ipaddr));
ipaddr, sizeof (ipaddr));
} }
} }
spdlog::debug("network: {}, new addr {}/{}", net->ifname_, net->ipaddr_, net->cidr_); spdlog::debug("network: {}, new addr {}/{}", net->ifname_, net->ipaddr_, net->cidr_);
@ -564,10 +552,8 @@ int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) {
net->ipaddr_.clear(); net->ipaddr_.clear();
net->cidr_ = 0; net->cidr_ = 0;
net->netmask_.clear(); net->netmask_.clear();
spdlog::debug("network: {} addr deleted {}/{}", spdlog::debug("network: {} addr deleted {}/{}", net->ifname_,
net->ifname_, inet_ntop(ifa->ifa_family, RTA_DATA(ifa_rta), ipaddr, sizeof(ipaddr)),
inet_ntop(ifa->ifa_family, RTA_DATA(ifa_rta),
ipaddr, sizeof (ipaddr)),
ifa->ifa_prefixlen); ifa->ifa_prefixlen);
} }
net->dp.emit(); net->dp.emit();
@ -593,7 +579,6 @@ int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) {
int temp_idx = -1; int temp_idx = -1;
uint32_t priority = 0; uint32_t priority = 0;
/* Find the message(s) concerting the main routing table, each message /* Find the message(s) concerting the main routing table, each message
* corresponds to a single routing table entry. * corresponds to a single routing table entry.
*/ */
@ -656,7 +641,8 @@ int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) {
net->ifid_ = temp_idx; net->ifid_ = temp_idx;
net->route_priority = priority; net->route_priority = priority;
net->gwaddr_ = temp_gw_addr; net->gwaddr_ = temp_gw_addr;
spdlog::debug("network: new default route via {} on if{} metric {}", temp_gw_addr, temp_idx, priority); spdlog::debug("network: new default route via {} on if{} metric {}", temp_gw_addr,
temp_idx, priority);
/* Ask ifname associated with temp_idx as well as carrier status */ /* Ask ifname associated with temp_idx as well as carrier status */
struct ifinfomsg ifinfo_hdr = { struct ifinfomsg ifinfo_hdr = {
@ -664,8 +650,8 @@ int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) {
.ifi_index = temp_idx, .ifi_index = temp_idx,
}; };
int err; int err;
err = nl_send_simple(net->ev_sock_, RTM_GETLINK, NLM_F_REQUEST, err = nl_send_simple(net->ev_sock_, RTM_GETLINK, NLM_F_REQUEST, &ifinfo_hdr,
&ifinfo_hdr, sizeof (ifinfo_hdr)); sizeof(ifinfo_hdr));
if (err < 0) { if (err < 0) {
spdlog::error("network: failed to ask link info: {}", err); spdlog::error("network: failed to ask link info: {}", err);
/* Ask for a dump of all links instead */ /* Ask for a dump of all links instead */
@ -678,10 +664,9 @@ int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) {
net->want_addr_dump_ = true; net->want_addr_dump_ = true;
net->askForStateDump(); net->askForStateDump();
net->thread_timer_.wake_up(); net->thread_timer_.wake_up();
} else if (is_del_event && temp_idx == net->ifid_ } else if (is_del_event && temp_idx == net->ifid_ && net->route_priority == priority) {
&& net->route_priority == priority) { spdlog::debug("network: default route deleted {}/if{} metric {}", net->ifname_, temp_idx,
spdlog::debug("network: default route deleted {}/if{} metric {}", priority);
net->ifname_, temp_idx, priority);
net->clearIface(); net->clearIface();
net->dp.emit(); net->dp.emit();
@ -702,8 +687,7 @@ int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) {
void waybar::modules::Network::askForStateDump(void) { void waybar::modules::Network::askForStateDump(void) {
/* We need to wait until the current dump is done before sending new /* We need to wait until the current dump is done before sending new
* messages. handleEventsDone() is called when a dump is done. */ * messages. handleEventsDone() is called when a dump is done. */
if (dump_in_progress_) if (dump_in_progress_) return;
return;
struct rtgenmsg rt_hdr = { struct rtgenmsg rt_hdr = {
.rtgen_family = AF_UNSPEC, .rtgen_family = AF_UNSPEC,
@ -711,21 +695,18 @@ void waybar::modules::Network::askForStateDump(void) {
if (want_route_dump_) { if (want_route_dump_) {
rt_hdr.rtgen_family = family_; rt_hdr.rtgen_family = family_;
nl_send_simple(ev_sock_, RTM_GETROUTE, NLM_F_DUMP, nl_send_simple(ev_sock_, RTM_GETROUTE, NLM_F_DUMP, &rt_hdr, sizeof(rt_hdr));
&rt_hdr, sizeof (rt_hdr));
want_route_dump_ = false; want_route_dump_ = false;
dump_in_progress_ = true; dump_in_progress_ = true;
} else if (want_link_dump_) { } else if (want_link_dump_) {
nl_send_simple(ev_sock_, RTM_GETLINK, NLM_F_DUMP, nl_send_simple(ev_sock_, RTM_GETLINK, NLM_F_DUMP, &rt_hdr, sizeof(rt_hdr));
&rt_hdr, sizeof (rt_hdr));
want_link_dump_ = false; want_link_dump_ = false;
dump_in_progress_ = true; dump_in_progress_ = true;
} else if (want_addr_dump_) { } else if (want_addr_dump_) {
rt_hdr.rtgen_family = family_; rt_hdr.rtgen_family = family_;
nl_send_simple(ev_sock_, RTM_GETADDR, NLM_F_DUMP, nl_send_simple(ev_sock_, RTM_GETADDR, NLM_F_DUMP, &rt_hdr, sizeof(rt_hdr));
&rt_hdr, sizeof (rt_hdr));
want_addr_dump_ = false; want_addr_dump_ = false;
dump_in_progress_ = true; dump_in_progress_ = true;
} }
@ -754,8 +735,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_SIGNAL_UNSPEC].type = NLA_U8;
bss_policy[NL80211_BSS_STATUS].type = NLA_U32; bss_policy[NL80211_BSS_STATUS].type = NLA_U32;
if (nla_parse( if (nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0), genlmsg_attrlen(gnlh, 0),
tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0), genlmsg_attrlen(gnlh, 0), nullptr) < 0) { nullptr) < 0) {
return NL_SKIP; return NL_SKIP;
} }
if (tb[NL80211_ATTR_BSS] == nullptr) { if (tb[NL80211_ATTR_BSS] == nullptr) {
@ -804,7 +785,9 @@ void waybar::modules::Network::parseSignal(struct nlattr **bss) {
const int hardwareOptimum = -45; const int hardwareOptimum = -45;
const int hardwareMin = -90; const int hardwareMin = -90;
const int strength = const int strength =
100 - ((abs(signal_strength_dbm_ - hardwareOptimum) / double{hardwareOptimum - hardwareMin}) * 100); 100 -
((abs(signal_strength_dbm_ - hardwareOptimum) / double{hardwareOptimum - hardwareMin}) *
100);
signal_strength_ = std::clamp(strength, 0, 100); signal_strength_ = std::clamp(strength, 0, 100);
if (signal_strength_dbm_ >= -50) { if (signal_strength_dbm_ >= -50) {
@ -853,9 +836,8 @@ auto waybar::modules::Network::getInfo() -> void {
if (nl_msg == nullptr) { if (nl_msg == nullptr) {
return; return;
} }
if (genlmsg_put( if (genlmsg_put(nl_msg, NL_AUTO_PORT, NL_AUTO_SEQ, nl80211_id_, 0, NLM_F_DUMP,
nl_msg, NL_AUTO_PORT, NL_AUTO_SEQ, nl80211_id_, 0, NLM_F_DUMP, NL80211_CMD_GET_SCAN, 0) == NL80211_CMD_GET_SCAN, 0) == nullptr ||
nullptr ||
nla_put_u32(nl_msg, NL80211_ATTR_IFINDEX, ifid_) < 0) { nla_put_u32(nl_msg, NL80211_ATTR_IFINDEX, ifid_) < 0) {
nlmsg_free(nl_msg); nlmsg_free(nl_msg);
return; return;

View File

@ -50,15 +50,14 @@ void waybar::modules::Pulseaudio::contextStateCb(pa_context *c, void *data) {
case PA_CONTEXT_READY: case PA_CONTEXT_READY:
pa_context_get_server_info(c, serverInfoCb, data); pa_context_get_server_info(c, serverInfoCb, data);
pa_context_set_subscribe_callback(c, subscribeCb, data); pa_context_set_subscribe_callback(c, subscribeCb, data);
pa_context_subscribe( pa_context_subscribe(c,
c, static_cast<enum pa_subscription_mask>(
static_cast<enum pa_subscription_mask>(static_cast<int>(PA_SUBSCRIPTION_MASK_SERVER) | static_cast<int>(PA_SUBSCRIPTION_MASK_SERVER) |
static_cast<int>(PA_SUBSCRIPTION_MASK_SINK) | static_cast<int>(PA_SUBSCRIPTION_MASK_SINK) |
static_cast<int>(PA_SUBSCRIPTION_MASK_SINK_INPUT) | static_cast<int>(PA_SUBSCRIPTION_MASK_SINK_INPUT) |
static_cast<int>(PA_SUBSCRIPTION_MASK_SOURCE) | static_cast<int>(PA_SUBSCRIPTION_MASK_SOURCE) |
static_cast<int>(PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT)), static_cast<int>(PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT)),
nullptr, nullptr, nullptr);
nullptr);
break; break;
case PA_CONTEXT_FAILED: case PA_CONTEXT_FAILED:
pa->mainloop_api_->quit(pa->mainloop_api_, 1); pa->mainloop_api_->quit(pa->mainloop_api_, 1);
@ -164,8 +163,7 @@ void waybar::modules::Pulseaudio::sourceInfoCb(pa_context * /*context*/, const p
*/ */
void waybar::modules::Pulseaudio::sinkInfoCb(pa_context * /*context*/, const pa_sink_info *i, void waybar::modules::Pulseaudio::sinkInfoCb(pa_context * /*context*/, const pa_sink_info *i,
int /*eol*/, void *data) { int /*eol*/, void *data) {
if (i == nullptr) if (i == nullptr) return;
return;
auto pa = static_cast<waybar::modules::Pulseaudio *>(data); auto pa = static_cast<waybar::modules::Pulseaudio *>(data);
if (pa->current_sink_name_ == i->name) { if (pa->current_sink_name_ == i->name) {
@ -212,15 +210,7 @@ void waybar::modules::Pulseaudio::serverInfoCb(pa_context *context, const pa_ser
} }
static const std::array<std::string, 9> ports = { static const std::array<std::string, 9> ports = {
"headphone", "headphone", "speaker", "hdmi", "headset", "hands-free", "portable", "car", "hifi", "phone",
"speaker",
"hdmi",
"headset",
"hands-free",
"portable",
"car",
"hifi",
"phone",
}; };
const std::vector<std::string> waybar::modules::Pulseaudio::getPulseIcon() const { const std::vector<std::string> waybar::modules::Pulseaudio::getPulseIcon() const {
@ -260,8 +250,7 @@ auto waybar::modules::Pulseaudio::update() -> void {
label_.get_style_context()->remove_class("muted"); label_.get_style_context()->remove_class("muted");
label_.get_style_context()->remove_class("sink-muted"); label_.get_style_context()->remove_class("sink-muted");
} }
format = format = config_[format_name].isString() ? config_[format_name].asString() : format;
config_[format_name].isString() ? config_[format_name].asString() : format;
} }
// TODO: find a better way to split source/sink // TODO: find a better way to split source/sink
std::string format_source = "{volume}%"; std::string format_source = "{volume}%";
@ -277,13 +266,10 @@ auto waybar::modules::Pulseaudio::update() -> void {
} }
} }
format_source = fmt::format(format_source, fmt::arg("volume", source_volume_)); format_source = fmt::format(format_source, fmt::arg("volume", source_volume_));
label_.set_markup(fmt::format(format, label_.set_markup(fmt::format(
fmt::arg("desc", desc_), format, fmt::arg("desc", desc_), fmt::arg("volume", volume_),
fmt::arg("volume", volume_), fmt::arg("format_source", format_source), fmt::arg("source_volume", source_volume_),
fmt::arg("format_source", format_source), fmt::arg("source_desc", source_desc_), fmt::arg("icon", getIcon(volume_, getPulseIcon()))));
fmt::arg("source_volume", source_volume_),
fmt::arg("source_desc", source_desc_),
fmt::arg("icon", getIcon(volume_, getPulseIcon()))));
getState(volume_); getState(volume_);
if (tooltipEnabled()) { if (tooltipEnabled()) {
@ -292,11 +278,8 @@ auto waybar::modules::Pulseaudio::update() -> void {
} }
if (!tooltip_format.empty()) { if (!tooltip_format.empty()) {
label_.set_tooltip_text(fmt::format( label_.set_tooltip_text(fmt::format(
tooltip_format, tooltip_format, fmt::arg("desc", desc_), fmt::arg("volume", volume_),
fmt::arg("desc", desc_), fmt::arg("format_source", format_source), fmt::arg("source_volume", source_volume_),
fmt::arg("volume", volume_),
fmt::arg("format_source", format_source),
fmt::arg("source_volume", source_volume_),
fmt::arg("source_desc", source_desc_), fmt::arg("source_desc", source_desc_),
fmt::arg("icon", getIcon(volume_, getPulseIcon())))); fmt::arg("icon", getIcon(volume_, getPulseIcon()))));
} else { } else {

View File

@ -1,3 +1,5 @@
#include "modules/river/tags.hpp"
#include <gtkmm/button.h> #include <gtkmm/button.h>
#include <gtkmm/label.h> #include <gtkmm/label.h>
#include <spdlog/spdlog.h> #include <spdlog/spdlog.h>
@ -6,7 +8,6 @@
#include <algorithm> #include <algorithm>
#include "client.hpp" #include "client.hpp"
#include "modules/river/tags.hpp"
#include "xdg-output-unstable-v1-client-protocol.h" #include "xdg-output-unstable-v1-client-protocol.h"
namespace waybar::modules::river { namespace waybar::modules::river {
@ -77,7 +78,6 @@ static void handle_global_remove(void *data, struct wl_registry *registry, uint3
/* Ignore event */ /* Ignore event */
} }
static const wl_registry_listener registry_listener_impl = {.global = handle_global, static const wl_registry_listener registry_listener_impl = {.global = handle_global,
.global_remove = handle_global_remove}; .global_remove = handle_global_remove};
@ -134,8 +134,10 @@ Tags::Tags(const std::string &id, const waybar::Bar &bar, const Json::Value &con
button.set_relief(Gtk::RELIEF_NONE); button.set_relief(Gtk::RELIEF_NONE);
box_.pack_start(button, false, false, 0); box_.pack_start(button, false, false, 0);
if (!config_["disable-click"].asBool()) { if (!config_["disable-click"].asBool()) {
button.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &Tags::handle_primary_clicked), i)); button.signal_clicked().connect(
button.signal_button_press_event().connect(sigc::bind(sigc::mem_fun(*this, &Tags::handle_button_press), i)); sigc::bind(sigc::mem_fun(*this, &Tags::handle_primary_clicked), i));
button.signal_button_press_event().connect(
sigc::bind(sigc::mem_fun(*this, &Tags::handle_button_press), i));
} }
button.show(); button.show();
i <<= 1; i <<= 1;

View File

@ -1,4 +1,5 @@
#include "modules/simpleclock.hpp" #include "modules/simpleclock.hpp"
#include <time.h> #include <time.h>
waybar::modules::Clock::Clock(const std::string& id, const Json::Value& config) waybar::modules::Clock::Clock(const std::string& id, const Json::Value& config)

View File

@ -1,9 +1,11 @@
#include "modules/sndio.hpp" #include "modules/sndio.hpp"
#include <fmt/format.h>
#include <poll.h>
#include <spdlog/spdlog.h>
#include <algorithm> #include <algorithm>
#include <cstdlib> #include <cstdlib>
#include <poll.h>
#include <fmt/format.h>
#include <spdlog/spdlog.h>
namespace waybar::modules { namespace waybar::modules {
@ -52,10 +54,8 @@ Sndio::Sndio(const std::string &id, const Json::Value &config)
event_box_.show(); event_box_.show();
event_box_.add_events(Gdk::SCROLL_MASK | Gdk::SMOOTH_SCROLL_MASK | Gdk::BUTTON_PRESS_MASK); event_box_.add_events(Gdk::SCROLL_MASK | Gdk::SMOOTH_SCROLL_MASK | Gdk::BUTTON_PRESS_MASK);
event_box_.signal_scroll_event().connect( event_box_.signal_scroll_event().connect(sigc::mem_fun(*this, &Sndio::handleScroll));
sigc::mem_fun(*this, &Sndio::handleScroll)); event_box_.signal_button_press_event().connect(sigc::mem_fun(*this, &Sndio::handleToggle));
event_box_.signal_button_press_event().connect(
sigc::mem_fun(*this, &Sndio::handleToggle));
thread_ = [this] { thread_ = [this] {
dp.emit(); dp.emit();
@ -98,9 +98,7 @@ Sndio::Sndio(const std::string &id, const Json::Value &config)
}; };
} }
Sndio::~Sndio() { Sndio::~Sndio() { sioctl_close(hdl_); }
sioctl_close(hdl_);
}
auto Sndio::update() -> void { auto Sndio::update() -> void {
auto format = format_; auto format = format_;
@ -112,9 +110,7 @@ auto Sndio::update() -> void {
label_.get_style_context()->remove_class("muted"); label_.get_style_context()->remove_class("muted");
} }
label_.set_markup(fmt::format(format, label_.set_markup(fmt::format(format, fmt::arg("volume", vol), fmt::arg("raw_value", volume_)));
fmt::arg("volume", vol),
fmt::arg("raw_value", volume_)));
ALabel::update(); ALabel::update();
} }

View File

@ -1,4 +1,5 @@
#include "modules/sni/host.hpp" #include "modules/sni/host.hpp"
#include <fmt/ostream.h> #include <fmt/ostream.h>
#include <spdlog/spdlog.h> #include <spdlog/spdlog.h>
@ -32,8 +33,7 @@ Host::~Host() {
} }
void Host::busAcquired(const Glib::RefPtr<Gio::DBus::Connection>& conn, Glib::ustring name) { void Host::busAcquired(const Glib::RefPtr<Gio::DBus::Connection>& conn, Glib::ustring name) {
watcher_id_ = Gio::DBus::watch_name(conn, watcher_id_ = Gio::DBus::watch_name(conn, "org.kde.StatusNotifierWatcher",
"org.kde.StatusNotifierWatcher",
sigc::mem_fun(*this, &Host::nameAppeared), sigc::mem_fun(*this, &Host::nameAppeared),
sigc::mem_fun(*this, &Host::nameVanished)); sigc::mem_fun(*this, &Host::nameVanished));
} }
@ -45,13 +45,8 @@ void Host::nameAppeared(const Glib::RefPtr<Gio::DBus::Connection>& conn, const G
return; return;
} }
cancellable_ = g_cancellable_new(); cancellable_ = g_cancellable_new();
sn_watcher_proxy_new(conn->gobj(), sn_watcher_proxy_new(conn->gobj(), G_DBUS_PROXY_FLAGS_NONE, "org.kde.StatusNotifierWatcher",
G_DBUS_PROXY_FLAGS_NONE, "/StatusNotifierWatcher", cancellable_, &Host::proxyReady, this);
"org.kde.StatusNotifierWatcher",
"/StatusNotifierWatcher",
cancellable_,
&Host::proxyReady,
this);
} }
void Host::nameVanished(const Glib::RefPtr<Gio::DBus::Connection>& conn, const Glib::ustring name) { void Host::nameVanished(const Glib::RefPtr<Gio::DBus::Connection>& conn, const Glib::ustring name) {
@ -76,8 +71,8 @@ void Host::proxyReady(GObject* src, GAsyncResult* res, gpointer data) {
g_error_free(error); g_error_free(error);
return; return;
} }
sn_watcher_call_register_host( sn_watcher_call_register_host(host->watcher_, host->object_path_.c_str(), host->cancellable_,
host->watcher_, host->object_path_.c_str(), host->cancellable_, &Host::registerHost, data); &Host::registerHost, data);
} }
void Host::registerHost(GObject* src, GAsyncResult* res, gpointer data) { void Host::registerHost(GObject* src, GAsyncResult* res, gpointer data) {

View File

@ -62,18 +62,12 @@ Item::Item(const std::string& bn, const std::string& op, const Json::Value& conf
cancellable_ = Gio::Cancellable::create(); cancellable_ = Gio::Cancellable::create();
auto interface = Glib::wrap(sn_item_interface_info(), true); auto interface = Glib::wrap(sn_item_interface_info(), true);
Gio::DBus::Proxy::create_for_bus(Gio::DBus::BusType::BUS_TYPE_SESSION, Gio::DBus::Proxy::create_for_bus(Gio::DBus::BusType::BUS_TYPE_SESSION, bus_name, object_path,
bus_name, SNI_INTERFACE_NAME, sigc::mem_fun(*this, &Item::proxyReady),
object_path, cancellable_, interface);
SNI_INTERFACE_NAME,
sigc::mem_fun(*this, &Item::proxyReady),
cancellable_,
interface);
} }
void Item::onConfigure(GdkEventConfigure* ev) { void Item::onConfigure(GdkEventConfigure* ev) { this->updateImage(); }
this->updateImage();
}
void Item::proxyReady(Glib::RefPtr<Gio::AsyncResult>& result) { void Item::proxyReady(Glib::RefPtr<Gio::AsyncResult>& result) {
try { try {
@ -167,16 +161,10 @@ void Item::setProperty(const Glib::ustring& name, Glib::VariantBase& value) {
} }
} catch (const Glib::Error& err) { } catch (const Glib::Error& err) {
spdlog::warn("Failed to set tray item property: {}.{}, value = {}, err = {}", spdlog::warn("Failed to set tray item property: {}.{}, value = {}, err = {}",
id.empty() ? bus_name : id, id.empty() ? bus_name : id, name, value, err.what());
name,
value,
err.what());
} catch (const std::exception& err) { } catch (const std::exception& err) {
spdlog::warn("Failed to set tray item property: {}.{}, value = {}, err = {}", spdlog::warn("Failed to set tray item property: {}.{}, value = {}, err = {}",
id.empty() ? bus_name : id, id.empty() ? bus_name : id, name, value, err.what());
name,
value,
err.what());
} }
} }
@ -199,8 +187,7 @@ void Item::getUpdatedProperties() {
auto params = Glib::VariantContainerBase::create_tuple( auto params = Glib::VariantContainerBase::create_tuple(
{Glib::Variant<Glib::ustring>::create(SNI_INTERFACE_NAME)}); {Glib::Variant<Glib::ustring>::create(SNI_INTERFACE_NAME)});
proxy_->call("org.freedesktop.DBus.Properties.GetAll", proxy_->call("org.freedesktop.DBus.Properties.GetAll",
sigc::mem_fun(*this, &Item::processUpdatedProperties), sigc::mem_fun(*this, &Item::processUpdatedProperties), params);
params);
}; };
void Item::processUpdatedProperties(Glib::RefPtr<Gio::AsyncResult>& _result) { void Item::processUpdatedProperties(Glib::RefPtr<Gio::AsyncResult>& _result) {
@ -303,14 +290,8 @@ Glib::RefPtr<Gdk::Pixbuf> Item::extractPixBuf(GVariant* variant) {
array[i + 2] = array[i + 3]; array[i + 2] = array[i + 3];
array[i + 3] = alpha; array[i + 3] = alpha;
} }
return Gdk::Pixbuf::create_from_data(array, return Gdk::Pixbuf::create_from_data(array, Gdk::Colorspace::COLORSPACE_RGB, true, 8, lwidth,
Gdk::Colorspace::COLORSPACE_RGB, lheight, 4 * lwidth, &pixbuf_data_deleter);
true,
8,
lwidth,
lheight,
4 * lwidth,
&pixbuf_data_deleter);
} }
return Glib::RefPtr<Gdk::Pixbuf>{}; return Glib::RefPtr<Gdk::Pixbuf>{};
} }
@ -374,15 +355,15 @@ Glib::RefPtr<Gdk::Pixbuf> Item::getIconByName(const std::string& name, int reque
tmp_size = request_size; tmp_size = request_size;
} }
if (!icon_theme_path.empty() && if (!icon_theme_path.empty() &&
icon_theme->lookup_icon( icon_theme->lookup_icon(name.c_str(), tmp_size,
name.c_str(), tmp_size, Gtk::IconLookupFlags::ICON_LOOKUP_FORCE_SIZE)) { Gtk::IconLookupFlags::ICON_LOOKUP_FORCE_SIZE)) {
return icon_theme->load_icon( return icon_theme->load_icon(name.c_str(), tmp_size,
name.c_str(), tmp_size, Gtk::IconLookupFlags::ICON_LOOKUP_FORCE_SIZE); Gtk::IconLookupFlags::ICON_LOOKUP_FORCE_SIZE);
} }
Glib::RefPtr<Gtk::IconTheme> default_theme = Gtk::IconTheme::get_default(); Glib::RefPtr<Gtk::IconTheme> default_theme = Gtk::IconTheme::get_default();
default_theme->rescan_if_needed(); default_theme->rescan_if_needed();
return default_theme->load_icon( return default_theme->load_icon(name.c_str(), tmp_size,
name.c_str(), tmp_size, Gtk::IconLookupFlags::ICON_LOOKUP_FORCE_SIZE); Gtk::IconLookupFlags::ICON_LOOKUP_FORCE_SIZE);
} }
double Item::getScaledIconSize() { double Item::getScaledIconSize() {

View File

@ -1,4 +1,5 @@
#include "modules/sni/tray.hpp" #include "modules/sni/tray.hpp"
#include <spdlog/spdlog.h> #include <spdlog/spdlog.h>
namespace waybar::modules::SNI { namespace waybar::modules::SNI {

View File

@ -1,4 +1,5 @@
#include "modules/sni/watcher.hpp" #include "modules/sni/watcher.hpp"
#include <spdlog/spdlog.h> #include <spdlog/spdlog.h>
using namespace waybar::modules::SNI; using namespace waybar::modules::SNI;
@ -29,8 +30,8 @@ Watcher::~Watcher() {
void Watcher::busAcquired(const Glib::RefPtr<Gio::DBus::Connection>& conn, Glib::ustring name) { void Watcher::busAcquired(const Glib::RefPtr<Gio::DBus::Connection>& conn, Glib::ustring name) {
GError* error = nullptr; GError* error = nullptr;
g_dbus_interface_skeleton_export( g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(watcher_), conn->gobj(),
G_DBUS_INTERFACE_SKELETON(watcher_), conn->gobj(), "/StatusNotifierWatcher", &error); "/StatusNotifierWatcher", &error);
if (error != nullptr) { if (error != nullptr) {
// Don't print an error when a watcher is already present // Don't print an error when a watcher is already present
if (error->code != 2) { if (error->code != 2) {
@ -39,10 +40,10 @@ void Watcher::busAcquired(const Glib::RefPtr<Gio::DBus::Connection>& conn, Glib:
g_error_free(error); g_error_free(error);
return; return;
} }
g_signal_connect_swapped( g_signal_connect_swapped(watcher_, "handle-register-item",
watcher_, "handle-register-item", G_CALLBACK(&Watcher::handleRegisterItem), this); G_CALLBACK(&Watcher::handleRegisterItem), this);
g_signal_connect_swapped( g_signal_connect_swapped(watcher_, "handle-register-host",
watcher_, "handle-register-host", G_CALLBACK(&Watcher::handleRegisterHost), this); G_CALLBACK(&Watcher::handleRegisterHost), this);
} }
gboolean Watcher::handleRegisterHost(Watcher* obj, GDBusMethodInvocation* invocation, gboolean Watcher::handleRegisterHost(Watcher* obj, GDBusMethodInvocation* invocation,
@ -55,22 +56,16 @@ gboolean Watcher::handleRegisterHost(Watcher* obj, GDBusMethodInvocation* invoca
object_path = service; object_path = service;
} }
if (g_dbus_is_name(bus_name) == FALSE) { if (g_dbus_is_name(bus_name) == FALSE) {
g_dbus_method_invocation_return_error(invocation, g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
G_DBUS_ERROR, "D-Bus bus name '%s' is not valid", bus_name);
G_DBUS_ERROR_INVALID_ARGS,
"D-Bus bus name '%s' is not valid",
bus_name);
return TRUE; return TRUE;
} }
auto watch = gfWatchFind(obj->hosts_, bus_name, object_path); auto watch = gfWatchFind(obj->hosts_, bus_name, object_path);
if (watch != nullptr) { if (watch != nullptr) {
g_dbus_method_invocation_return_error( g_dbus_method_invocation_return_error(
invocation, invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
G_DBUS_ERROR,
G_DBUS_ERROR_INVALID_ARGS,
"Status Notifier Host with bus name '%s' and object path '%s' is already registered", "Status Notifier Host with bus name '%s' and object path '%s' is already registered",
bus_name, bus_name, object_path);
object_path);
return TRUE; return TRUE;
} }
watch = gfWatchNew(GF_WATCH_TYPE_HOST, service, bus_name, object_path, obj); watch = gfWatchNew(GF_WATCH_TYPE_HOST, service, bus_name, object_path, obj);
@ -93,18 +88,14 @@ gboolean Watcher::handleRegisterItem(Watcher* obj, GDBusMethodInvocation* invoca
object_path = service; object_path = service;
} }
if (g_dbus_is_name(bus_name) == FALSE) { if (g_dbus_is_name(bus_name) == FALSE) {
g_dbus_method_invocation_return_error(invocation, g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
G_DBUS_ERROR, "D-Bus bus name '%s' is not valid", bus_name);
G_DBUS_ERROR_INVALID_ARGS,
"D-Bus bus name '%s' is not valid",
bus_name);
return TRUE; return TRUE;
} }
auto watch = gfWatchFind(obj->items_, bus_name, object_path); auto watch = gfWatchFind(obj->items_, bus_name, object_path);
if (watch != nullptr) { if (watch != nullptr) {
g_warning("Status Notifier Item with bus name '%s' and object path '%s' is already registered", g_warning("Status Notifier Item with bus name '%s' and object path '%s' is already registered",
bus_name, bus_name, object_path);
object_path);
sn_watcher_complete_register_item(obj->watcher_, invocation); sn_watcher_complete_register_item(obj->watcher_, invocation);
return TRUE; return TRUE;
} }
@ -152,13 +143,8 @@ Watcher::GfWatch* Watcher::gfWatchNew(GfWatchType type, const gchar* service, co
watch->service = g_strdup(service); watch->service = g_strdup(service);
watch->bus_name = g_strdup(bus_name); watch->bus_name = g_strdup(bus_name);
watch->object_path = g_strdup(object_path); watch->object_path = g_strdup(object_path);
watch->watch_id = g_bus_watch_name(G_BUS_TYPE_SESSION, watch->watch_id = g_bus_watch_name(G_BUS_TYPE_SESSION, bus_name, G_BUS_NAME_WATCHER_FLAGS_NONE,
bus_name, nullptr, &Watcher::nameVanished, watch, nullptr);
G_BUS_NAME_WATCHER_FLAGS_NONE,
nullptr,
&Watcher::nameVanished,
watch,
nullptr);
return watch; return watch;
} }

View File

@ -79,11 +79,8 @@ void BarIpcClient::onIpcEvent(const struct Ipc::ipc_response& res) {
} }
void BarIpcClient::onConfigUpdate(const swaybar_config& config) { void BarIpcClient::onConfigUpdate(const swaybar_config& config) {
spdlog::info("config update for {}: id {}, mode {}, hidden_state {}", spdlog::info("config update for {}: id {}, mode {}, hidden_state {}", bar_.bar_id, config.id,
bar_.bar_id, config.mode, config.hidden_state);
config.id,
config.mode,
config.hidden_state);
bar_config_ = config; bar_config_ = config;
update(); update();
} }

View File

@ -1,4 +1,5 @@
#include "modules/sway/ipc/client.hpp" #include "modules/sway/ipc/client.hpp"
#include <fcntl.h> #include <fcntl.h>
namespace waybar::modules::sway { namespace waybar::modules::sway {

View File

@ -95,20 +95,17 @@ void Language::onEvent(const struct Ipc::ipc_response& res) {
auto Language::update() -> void { auto Language::update() -> void {
std::lock_guard<std::mutex> lock(mutex_); std::lock_guard<std::mutex> lock(mutex_);
auto display_layout = trim(fmt::format(format_, auto display_layout = trim(fmt::format(
fmt::arg("short", layout_.short_name), format_, fmt::arg("short", layout_.short_name),
fmt::arg("shortDescription", layout_.short_description), fmt::arg("shortDescription", layout_.short_description), fmt::arg("long", layout_.full_name),
fmt::arg("long", layout_.full_name), fmt::arg("variant", layout_.variant), fmt::arg("flag", layout_.country_flag())));
fmt::arg("variant", layout_.variant),
fmt::arg("flag", layout_.country_flag())));
label_.set_markup(display_layout); label_.set_markup(display_layout);
if (tooltipEnabled()) { if (tooltipEnabled()) {
if (tooltip_format_ != "") { if (tooltip_format_ != "") {
auto tooltip_display_layout = trim(fmt::format(tooltip_format_, auto tooltip_display_layout = trim(
fmt::arg("short", layout_.short_name), fmt::format(tooltip_format_, fmt::arg("short", layout_.short_name),
fmt::arg("shortDescription", layout_.short_description), fmt::arg("shortDescription", layout_.short_description),
fmt::arg("long", layout_.full_name), fmt::arg("long", layout_.full_name), fmt::arg("variant", layout_.variant),
fmt::arg("variant", layout_.variant),
fmt::arg("flag", layout_.country_flag()))); fmt::arg("flag", layout_.country_flag())));
label_.set_tooltip_markup(tooltip_display_layout); label_.set_tooltip_markup(tooltip_display_layout);
} else { } else {
@ -155,8 +152,7 @@ auto Language::init_layouts_map(const std::vector<std::string>& used_layouts) ->
std::map<std::string, int> short_name_to_number_map; std::map<std::string, int> short_name_to_number_map;
for (const auto& used_layout_name : used_layouts) { for (const auto& used_layout_name : used_layouts) {
auto found = layouts_map_.find(used_layout_name); auto found = layouts_map_.find(used_layout_name);
if (found == layouts_map_.end()) if (found == layouts_map_.end()) continue;
continue;
auto used_layout = &found->second; auto used_layout = &found->second;
auto layouts_with_same_name_list = found_by_short_names[used_layout->short_name]; auto layouts_with_same_name_list = found_by_short_names[used_layout->short_name];
if (layouts_with_same_name_list.size() < 2) { if (layouts_with_same_name_list.size() < 2) {
@ -169,10 +165,8 @@ auto Language::init_layouts_map(const std::vector<std::string>& used_layouts) ->
if (displayed_short_flag != static_cast<std::byte>(0)) { if (displayed_short_flag != static_cast<std::byte>(0)) {
int& number = short_name_to_number_map[used_layout->short_name]; int& number = short_name_to_number_map[used_layout->short_name];
used_layout->short_name = used_layout->short_name = used_layout->short_name + std::to_string(number);
used_layout->short_name + std::to_string(number); used_layout->short_description = used_layout->short_description + std::to_string(number);
used_layout->short_description =
used_layout->short_description + std::to_string(number);
++number; ++number;
} }
} }
@ -205,7 +199,8 @@ auto Language::XKBContext::next_layout() -> Layout* {
base_layouts_by_name_.emplace(name, xkb_layout_); base_layouts_by_name_.emplace(name, xkb_layout_);
} else { } else {
auto base_layout = base_layouts_by_name_[name]; auto base_layout = base_layouts_by_name_[name];
short_description = base_layout == nullptr ? "" : std::string(rxkb_layout_get_brief(base_layout)); short_description =
base_layout == nullptr ? "" : std::string(rxkb_layout_get_brief(base_layout));
} }
delete layout_; delete layout_;
layout_ = new Layout{description, name, variant, short_description}; layout_ = new Layout{description, name, variant, short_description};

View File

@ -1,4 +1,5 @@
#include "modules/sway/mode.hpp" #include "modules/sway/mode.hpp"
#include <spdlog/spdlog.h> #include <spdlog/spdlog.h>
namespace waybar::modules::sway { namespace waybar::modules::sway {

View File

@ -70,11 +70,11 @@ std::optional<Glib::ustring> getIconName(const std::string& app_id) {
} }
return icon_name; return icon_name;
} catch (Glib::FileError& error) { } catch (Glib::FileError& error) {
spdlog::warn( spdlog::warn("Error while loading desktop file {}: {}", desktop_file_path.value(),
"Error while loading desktop file {}: {}", desktop_file_path.value(), error.what().c_str()); error.what().c_str());
} catch (Glib::KeyFileError& error) { } catch (Glib::KeyFileError& error) {
spdlog::warn( spdlog::warn("Error while loading desktop file {}: {}", desktop_file_path.value(),
"Error while loading desktop file {}: {}", desktop_file_path.value(), error.what().c_str()); error.what().c_str());
} }
return {}; return {};
} }
@ -114,8 +114,8 @@ auto Window::update() -> void {
bar_.window.get_style_context()->remove_class("solo"); bar_.window.get_style_context()->remove_class("solo");
bar_.window.get_style_context()->remove_class("empty"); bar_.window.get_style_context()->remove_class("empty");
} }
label_.set_markup(fmt::format(format_, fmt::arg("title", rewriteTitle(window_)), label_.set_markup(
fmt::arg("app_id", app_id_))); fmt::format(format_, fmt::arg("title", rewriteTitle(window_)), fmt::arg("app_id", app_id_)));
if (tooltipEnabled()) { if (tooltipEnabled()) {
label_.set_tooltip_text(window_); label_.set_tooltip_text(window_);
} }
@ -134,19 +134,17 @@ int leafNodesInWorkspace(const Json::Value& node) {
} }
int sum = 0; int sum = 0;
if (!nodes.empty()) { if (!nodes.empty()) {
for(auto const& node : nodes) for (auto const& node : nodes) sum += leafNodesInWorkspace(node);
sum += leafNodesInWorkspace(node);
} }
if (!floating_nodes.empty()) { if (!floating_nodes.empty()) {
for(auto const& node : floating_nodes) for (auto const& node : floating_nodes) sum += leafNodesInWorkspace(node);
sum += leafNodesInWorkspace(node);
} }
return sum; return sum;
} }
std::tuple<std::size_t, int, std::string, std::string> gfnWithWorkspace( std::tuple<std::size_t, int, std::string, std::string> gfnWithWorkspace(
const Json::Value& nodes, std::string& output, const Json::Value& config_, const Json::Value& nodes, std::string& output, const Json::Value& config_, const Bar& bar_,
const Bar& bar_, Json::Value& parentWorkspace) { Json::Value& parentWorkspace) {
for (auto const& node : nodes) { for (auto const& node : nodes) {
if (node["output"].isString()) { if (node["output"].isString()) {
output = node["output"].asString(); output = node["output"].asString();
@ -158,23 +156,20 @@ std::tuple<std::size_t, int, std::string, std::string> gfnWithWorkspace(
auto app_id = node["app_id"].isString() ? node["app_id"].asString() auto app_id = node["app_id"].isString() ? node["app_id"].asString()
: node["window_properties"]["instance"].asString(); : node["window_properties"]["instance"].asString();
int nb = node.size(); int nb = node.size();
if(parentWorkspace != 0) if (parentWorkspace != 0) nb = leafNodesInWorkspace(parentWorkspace);
nb = leafNodesInWorkspace(parentWorkspace); return {nb, node["id"].asInt(), Glib::Markup::escape_text(node["name"].asString()), app_id};
return {nb,
node["id"].asInt(),
Glib::Markup::escape_text(node["name"].asString()),
app_id};
} }
} }
// iterate // iterate
if(node["type"] == "workspace") if (node["type"] == "workspace") parentWorkspace = node;
parentWorkspace = node; auto [nb, id, name, app_id] =
auto [nb, id, name, app_id] = gfnWithWorkspace(node["nodes"], output, config_, bar_, parentWorkspace); gfnWithWorkspace(node["nodes"], output, config_, bar_, parentWorkspace);
if (id > -1 && !name.empty()) { if (id > -1 && !name.empty()) {
return {nb, id, name, app_id}; return {nb, id, name, app_id};
} }
// Search for floating node // Search for floating node
std::tie(nb, id, name, app_id) = gfnWithWorkspace(node["floating_nodes"], output, config_, bar_, parentWorkspace); std::tie(nb, id, name, app_id) =
gfnWithWorkspace(node["floating_nodes"], output, config_, bar_, parentWorkspace);
if (id > -1 && !name.empty()) { if (id > -1 && !name.empty()) {
return {nb, id, name, app_id}; return {nb, id, name, app_id};
} }

View File

@ -67,9 +67,7 @@ void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
std::lock_guard<std::mutex> lock(mutex_); std::lock_guard<std::mutex> lock(mutex_);
auto payload = parser_.parse(res.payload); auto payload = parser_.parse(res.payload);
workspaces_.clear(); workspaces_.clear();
std::copy_if(payload.begin(), std::copy_if(payload.begin(), payload.end(), std::back_inserter(workspaces_),
payload.end(),
std::back_inserter(workspaces_),
[&](const auto &workspace) { [&](const auto &workspace) {
return !config_["all-outputs"].asBool() return !config_["all-outputs"].asBool()
? workspace["output"].asString() == bar_.output->name ? workspace["output"].asString() == bar_.output->name
@ -144,8 +142,7 @@ void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
workspace["sort"] = ++max_num; workspace["sort"] = ++max_num;
} }
} }
std::sort(workspaces_.begin(), std::sort(workspaces_.begin(), workspaces_.end(),
workspaces_.end(),
[](const Json::Value &lhs, const Json::Value &rhs) { [](const Json::Value &lhs, const Json::Value &rhs) {
auto lname = lhs["name"].asString(); auto lname = lhs["name"].asString();
auto rname = rhs["name"].asString(); auto rname = rhs["name"].asString();
@ -161,7 +158,6 @@ void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
return l < r; return l < r;
}); });
} }
dp.emit(); dp.emit();
} catch (const std::exception &e) { } catch (const std::exception &e) {
@ -173,9 +169,8 @@ void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
bool Workspaces::filterButtons() { bool Workspaces::filterButtons() {
bool needReorder = false; bool needReorder = false;
for (auto it = buttons_.begin(); it != buttons_.end();) { for (auto it = buttons_.begin(); it != buttons_.end();) {
auto ws = std::find_if(workspaces_.begin(), workspaces_.end(), [it](const auto &node) { auto ws = std::find_if(workspaces_.begin(), workspaces_.end(),
return node["name"].asString() == it->first; [it](const auto &node) { return node["name"].asString() == it->first; });
});
if (ws == workspaces_.end() || if (ws == workspaces_.end() ||
(!config_["all-outputs"].asBool() && (*ws)["output"].asString() != bar_.output->name)) { (!config_["all-outputs"].asBool() && (*ws)["output"].asString() != bar_.output->name)) {
it = buttons_.erase(it); it = buttons_.erase(it);
@ -231,10 +226,8 @@ auto Workspaces::update() -> void {
std::string output = (*it)["name"].asString(); std::string output = (*it)["name"].asString();
if (config_["format"].isString()) { if (config_["format"].isString()) {
auto format = config_["format"].asString(); auto format = config_["format"].asString();
output = fmt::format(format, output = fmt::format(format, fmt::arg("icon", getIcon(output, *it)),
fmt::arg("icon", getIcon(output, *it)), fmt::arg("value", output), fmt::arg("name", trimWorkspaceName(output)),
fmt::arg("value", output),
fmt::arg("name", trimWorkspaceName(output)),
fmt::arg("index", (*it)["num"].asString())); fmt::arg("index", (*it)["num"].asString()));
} }
if (!config_["disable-markup"].asBool()) { if (!config_["disable-markup"].asBool()) {
@ -258,18 +251,14 @@ Gtk::Button &Workspaces::addButton(const Json::Value &node) {
button.signal_pressed().connect([this, node] { button.signal_pressed().connect([this, node] {
try { try {
if (node["target_output"].isString()) { if (node["target_output"].isString()) {
ipc_.sendCmd( ipc_.sendCmd(IPC_COMMAND,
IPC_COMMAND, fmt::format(workspace_switch_cmd_ + "; move workspace to output \"{}\"; " +
fmt::format(workspace_switch_cmd_ + "; move workspace to output \"{}\"; " + workspace_switch_cmd_, workspace_switch_cmd_,
"--no-auto-back-and-forth", "--no-auto-back-and-forth", node["name"].asString(),
node["name"].asString(), node["target_output"].asString(), "--no-auto-back-and-forth",
node["target_output"].asString(),
"--no-auto-back-and-forth",
node["name"].asString())); node["name"].asString()));
} else { } else {
ipc_.sendCmd( ipc_.sendCmd(IPC_COMMAND, fmt::format("workspace {} \"{}\"",
IPC_COMMAND,
fmt::format("workspace {} \"{}\"",
config_["disable-auto-back-and-forth"].asBool() config_["disable-auto-back-and-forth"].asBool()
? "--no-auto-back-and-forth" ? "--no-auto-back-and-forth"
: "", : "",
@ -316,9 +305,8 @@ bool Workspaces::handleScroll(GdkEventScroll *e) {
std::string name; std::string name;
{ {
std::lock_guard<std::mutex> lock(mutex_); std::lock_guard<std::mutex> lock(mutex_);
auto it = std::find_if(workspaces_.begin(), workspaces_.end(), [](const auto &workspace) { auto it = std::find_if(workspaces_.begin(), workspaces_.end(),
return workspace["focused"].asBool(); [](const auto &workspace) { return workspace["focused"].asBool(); });
});
if (it == workspaces_.end()) { if (it == workspaces_.end()) {
return true; return true;
} }
@ -334,9 +322,7 @@ bool Workspaces::handleScroll(GdkEventScroll *e) {
} }
} }
try { try {
ipc_.sendCmd( ipc_.sendCmd(IPC_COMMAND, fmt::format(workspace_switch_cmd_, "--no-auto-back-and-forth", name));
IPC_COMMAND,
fmt::format(workspace_switch_cmd_, "--no-auto-back-and-forth", name));
} catch (const std::exception &e) { } catch (const std::exception &e) {
spdlog::error("Workspaces: {}", e.what()); spdlog::error("Workspaces: {}", e.what());
} }

View File

@ -1,4 +1,5 @@
#include "modules/temperature.hpp" #include "modules/temperature.hpp"
#include <filesystem> #include <filesystem>
waybar::modules::Temperature::Temperature(const std::string& id, const Json::Value& config) waybar::modules::Temperature::Temperature(const std::string& id, const Json::Value& config)
@ -6,7 +7,10 @@ waybar::modules::Temperature::Temperature(const std::string& id, const Json::Val
if (config_["hwmon-path"].isString()) { if (config_["hwmon-path"].isString()) {
file_path_ = config_["hwmon-path"].asString(); file_path_ = config_["hwmon-path"].asString();
} else if (config_["hwmon-path-abs"].isString() && config_["input-filename"].isString()) { } else if (config_["hwmon-path-abs"].isString() && config_["input-filename"].isString()) {
file_path_ = (*std::filesystem::directory_iterator(config_["hwmon-path-abs"].asString())).path().string() + "/" + config_["input-filename"].asString(); file_path_ = (*std::filesystem::directory_iterator(config_["hwmon-path-abs"].asString()))
.path()
.string() +
"/" + config_["input-filename"].asString();
} else { } 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); file_path_ = fmt::format("/sys/class/thermal/thermal_zone{}/temp", zone);
@ -43,8 +47,7 @@ auto waybar::modules::Temperature::update() -> void {
} }
auto max_temp = config_["critical-threshold"].isInt() ? config_["critical-threshold"].asInt() : 0; auto max_temp = config_["critical-threshold"].isInt() ? config_["critical-threshold"].asInt() : 0;
label_.set_markup(fmt::format(format, label_.set_markup(fmt::format(format, fmt::arg("temperatureC", temperature_c),
fmt::arg("temperatureC", temperature_c),
fmt::arg("temperatureF", temperature_f), fmt::arg("temperatureF", temperature_f),
fmt::arg("temperatureK", temperature_k), fmt::arg("temperatureK", temperature_k),
fmt::arg("icon", getIcon(temperature_c, "", max_temp)))); fmt::arg("icon", getIcon(temperature_c, "", max_temp))));
@ -53,8 +56,7 @@ auto waybar::modules::Temperature::update() -> void {
if (config_["tooltip-format"].isString()) { if (config_["tooltip-format"].isString()) {
tooltip_format = config_["tooltip-format"].asString(); tooltip_format = config_["tooltip-format"].asString();
} }
label_.set_tooltip_text(fmt::format(tooltip_format, label_.set_tooltip_text(fmt::format(tooltip_format, fmt::arg("temperatureC", temperature_c),
fmt::arg("temperatureC", temperature_c),
fmt::arg("temperatureF", temperature_f), fmt::arg("temperatureF", temperature_f),
fmt::arg("temperatureK", temperature_k))); fmt::arg("temperatureK", temperature_k)));
} }

View File

@ -68,13 +68,9 @@ UPower::UPower(const std::string& id, const Json::Value& config)
box_.signal_query_tooltip().connect(sigc::mem_fun(*this, &UPower::show_tooltip_callback)); box_.signal_query_tooltip().connect(sigc::mem_fun(*this, &UPower::show_tooltip_callback));
} }
upowerWatcher_id = g_bus_watch_name(G_BUS_TYPE_SYSTEM, upowerWatcher_id = g_bus_watch_name(G_BUS_TYPE_SYSTEM, "org.freedesktop.UPower",
"org.freedesktop.UPower", G_BUS_NAME_WATCHER_FLAGS_AUTO_START, upowerAppear,
G_BUS_NAME_WATCHER_FLAGS_AUTO_START, upowerDisappear, this, NULL);
upowerAppear,
upowerDisappear,
this,
NULL);
GError* error = NULL; GError* error = NULL;
client = up_client_new_full(NULL, &error); client = up_client_new_full(NULL, &error);
@ -87,16 +83,10 @@ UPower::UPower(const std::string& id, const Json::Value& config)
if (!login1_connection) { if (!login1_connection) {
throw std::runtime_error("Unable to connect to the SYSTEM Bus!..."); throw std::runtime_error("Unable to connect to the SYSTEM Bus!...");
} else { } else {
login1_id = g_dbus_connection_signal_subscribe(login1_connection, login1_id = g_dbus_connection_signal_subscribe(
"org.freedesktop.login1", login1_connection, "org.freedesktop.login1", "org.freedesktop.login1.Manager",
"org.freedesktop.login1.Manager", "PrepareForSleep", "/org/freedesktop/login1", NULL, G_DBUS_SIGNAL_FLAGS_NONE,
"PrepareForSleep", prepareForSleep_cb, this, NULL);
"/org/freedesktop/login1",
NULL,
G_DBUS_SIGNAL_FLAGS_NONE,
prepareForSleep_cb,
this,
NULL);
} }
event_box_.signal_button_press_event().connect(sigc::mem_fun(*this, &UPower::handleToggle)); event_box_.signal_button_press_event().connect(sigc::mem_fun(*this, &UPower::handleToggle));
@ -291,19 +281,8 @@ auto UPower::update() -> void {
gint64 time_full; gint64 time_full;
gchar* icon_name; gchar* icon_name;
g_object_get(displayDevice, g_object_get(displayDevice, "kind", &kind, "state", &state, "percentage", &percentage,
"kind", "icon-name", &icon_name, "time-to-empty", &time_empty, "time-to-full", &time_full,
&kind,
"state",
&state,
"percentage",
&percentage,
"icon-name",
&icon_name,
"time-to-empty",
&time_empty,
"time-to-full",
&time_full,
NULL); NULL);
bool displayDeviceValid = bool displayDeviceValid =
@ -357,8 +336,8 @@ auto UPower::update() -> void {
default: default:
break; break;
} }
std::string label_format = fmt::format(showAltText ? format_alt : format, std::string label_format =
fmt::arg("percentage", percentString), fmt::format(showAltText ? format_alt : format, fmt::arg("percentage", percentString),
fmt::arg("time", time_format)); fmt::arg("time", time_format));
// Only set the label text if it doesn't only contain spaces // Only set the label text if it doesn't only contain spaces
bool onlySpaces = true; bool onlySpaces = true;

View File

@ -48,18 +48,8 @@ uint UPowerTooltip::updateTooltip(Devices& devices) {
gchar* model; gchar* model;
gchar* icon_name; gchar* icon_name;
g_object_get(device, g_object_get(device, "kind", &kind, "percentage", &percentage, "native-path", &native_path,
"kind", "model", &model, "icon-name", &icon_name, NULL);
&kind,
"percentage",
&percentage,
"native-path",
&native_path,
"model",
&model,
"icon-name",
&icon_name,
NULL);
// Skip Line_Power and BAT0 devices // Skip Line_Power and BAT0 devices
if (kind == UP_DEVICE_KIND_LINE_POWER || native_path == NULL || strlen(native_path) == 0 || if (kind == UP_DEVICE_KIND_LINE_POWER || native_path == NULL || strlen(native_path) == 0 ||

View File

@ -1,10 +1,11 @@
#include "modules/wlr/taskbar.hpp" #include "modules/wlr/taskbar.hpp"
#include "glibmm/error.h" #include <fmt/core.h>
#include "glibmm/fileutils.h" #include <gdkmm/monitor.h>
#include "glibmm/refptr.h" #include <gio/gdesktopappinfo.h>
#include "util/format.hpp" #include <giomm/desktopappinfo.h>
#include "util/string.hpp" #include <gtkmm/icontheme.h>
#include <spdlog/spdlog.h>
#include <algorithm> #include <algorithm>
#include <cctype> #include <cctype>
@ -14,22 +15,16 @@
#include <sstream> #include <sstream>
#include <utility> #include <utility>
#include <fmt/core.h> #include "glibmm/error.h"
#include <gdkmm/monitor.h> #include "glibmm/fileutils.h"
#include "glibmm/refptr.h"
#include <gtkmm/icontheme.h> #include "util/format.hpp"
#include "util/string.hpp"
#include <giomm/desktopappinfo.h>
#include <gio/gdesktopappinfo.h>
#include <spdlog/spdlog.h>
namespace waybar::modules::wlr { namespace waybar::modules::wlr {
/* Icon loading functions */ /* Icon loading functions */
static std::vector<std::string> search_prefix() static std::vector<std::string> search_prefix() {
{
std::vector<std::string> prefixes = {""}; std::vector<std::string> prefixes = {""};
auto xdg_data_dirs = std::getenv("XDG_DATA_DIRS"); auto xdg_data_dirs = std::getenv("XDG_DATA_DIRS");
@ -52,14 +47,12 @@ static std::vector<std::string> search_prefix()
std::string home_dir = std::getenv("HOME"); std::string home_dir = std::getenv("HOME");
prefixes.push_back(home_dir + "/.local/share/"); prefixes.push_back(home_dir + "/.local/share/");
for (auto& p : prefixes) for (auto &p : prefixes) spdlog::debug("Using 'desktop' search path prefix: {}", p);
spdlog::debug("Using 'desktop' search path prefix: {}", p);
return prefixes; return prefixes;
} }
static Glib::RefPtr<Gdk::Pixbuf> load_icon_from_file(std::string icon_path, int size) static Glib::RefPtr<Gdk::Pixbuf> load_icon_from_file(std::string icon_path, int size) {
{
try { try {
auto pb = Gdk::Pixbuf::create_from_file(icon_path, size, size); auto pb = Gdk::Pixbuf::create_from_file(icon_path, size, size);
return pb; return pb;
@ -68,26 +61,19 @@ static Glib::RefPtr<Gdk::Pixbuf> load_icon_from_file(std::string icon_path, int
} }
} }
static Glib::RefPtr<Gio::DesktopAppInfo> get_app_info_by_name(const std::string& app_id) static Glib::RefPtr<Gio::DesktopAppInfo> get_app_info_by_name(const std::string &app_id) {
{
static std::vector<std::string> prefixes = search_prefix(); static std::vector<std::string> prefixes = search_prefix();
std::vector<std::string> app_folders = { std::vector<std::string> app_folders = {"", "applications/", "applications/kde/",
"", "applications/org.kde."};
"applications/",
"applications/kde/",
"applications/org.kde."
};
std::vector<std::string> suffixes = { std::vector<std::string> suffixes = {"", ".desktop"};
"",
".desktop"
};
for (auto &prefix : prefixes) { for (auto &prefix : prefixes) {
for (auto &folder : app_folders) { for (auto &folder : app_folders) {
for (auto &suffix : suffixes) { for (auto &suffix : suffixes) {
auto app_info_ = Gio::DesktopAppInfo::create_from_filename(prefix + folder + app_id + suffix); auto app_info_ =
Gio::DesktopAppInfo::create_from_filename(prefix + folder + app_id + suffix);
if (!app_info_) { if (!app_info_) {
continue; continue;
} }
@ -100,8 +86,7 @@ static Glib::RefPtr<Gio::DesktopAppInfo> get_app_info_by_name(const std::string&
return {}; return {};
} }
Glib::RefPtr<Gio::DesktopAppInfo> get_desktop_app_info(const std::string &app_id) Glib::RefPtr<Gio::DesktopAppInfo> get_desktop_app_info(const std::string &app_id) {
{
auto app_info = get_app_info_by_name(app_id); auto app_info = get_app_info_by_name(app_id);
if (app_info) { if (app_info) {
return app_info; return app_info;
@ -137,8 +122,7 @@ void Task::set_app_info_from_app_id_list(const std::string& app_id_list) {
/* Wayfire sends a list of app-id's in space separated format, other compositors /* Wayfire sends a list of app-id's in space separated format, other compositors
* send a single app-id, but in any case this works fine */ * send a single app-id, but in any case this works fine */
while (stream >> app_id) while (stream >> app_id) {
{
app_info_ = get_desktop_app_info(app_id); app_info_ = get_desktop_app_info(app_id);
if (app_info_) { if (app_info_) {
return; return;
@ -167,19 +151,18 @@ void Task::set_app_info_from_app_id_list(const std::string& app_id_list) {
} }
static std::string get_icon_name_from_icon_theme(const Glib::RefPtr<Gtk::IconTheme> &icon_theme, static std::string get_icon_name_from_icon_theme(const Glib::RefPtr<Gtk::IconTheme> &icon_theme,
const std::string &app_id) const std::string &app_id) {
{ if (icon_theme->lookup_icon(app_id, 24)) return app_id;
if (icon_theme->lookup_icon(app_id, 24))
return app_id;
return ""; return "";
} }
bool Task::image_load_icon(Gtk::Image& image, const Glib::RefPtr<Gtk::IconTheme>& icon_theme, Glib::RefPtr<Gio::DesktopAppInfo> app_info, int size) bool Task::image_load_icon(Gtk::Image &image, const Glib::RefPtr<Gtk::IconTheme> &icon_theme,
{ Glib::RefPtr<Gio::DesktopAppInfo> app_info, int size) {
std::string ret_icon_name = "unknown"; std::string ret_icon_name = "unknown";
if (app_info) { if (app_info) {
std::string icon_name = get_icon_name_from_icon_theme(icon_theme, app_info->get_startup_wm_class()); std::string icon_name =
get_icon_name_from_icon_theme(icon_theme, app_info->get_startup_wm_class());
if (!icon_name.empty()) { if (!icon_name.empty()) {
ret_icon_name = icon_name; ret_icon_name = icon_name;
} else { } else {
@ -212,48 +195,40 @@ bool Task::image_load_icon(Gtk::Image& image, const Glib::RefPtr<Gtk::IconTheme>
uint32_t Task::global_id = 0; uint32_t Task::global_id = 0;
static void tl_handle_title(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle, static void tl_handle_title(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle,
const char *title) const char *title) {
{
return static_cast<Task *>(data)->handle_title(title); return static_cast<Task *>(data)->handle_title(title);
} }
static void tl_handle_app_id(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle, static void tl_handle_app_id(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle,
const char *app_id) const char *app_id) {
{
return static_cast<Task *>(data)->handle_app_id(app_id); return static_cast<Task *>(data)->handle_app_id(app_id);
} }
static void tl_handle_output_enter(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle, static void tl_handle_output_enter(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle,
struct wl_output *output) struct wl_output *output) {
{
return static_cast<Task *>(data)->handle_output_enter(output); return static_cast<Task *>(data)->handle_output_enter(output);
} }
static void tl_handle_output_leave(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle, static void tl_handle_output_leave(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle,
struct wl_output *output) struct wl_output *output) {
{
return static_cast<Task *>(data)->handle_output_leave(output); return static_cast<Task *>(data)->handle_output_leave(output);
} }
static void tl_handle_state(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle, static void tl_handle_state(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle,
struct wl_array *state) struct wl_array *state) {
{
return static_cast<Task *>(data)->handle_state(state); return static_cast<Task *>(data)->handle_state(state);
} }
static void tl_handle_done(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle) static void tl_handle_done(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle) {
{
return static_cast<Task *>(data)->handle_done(); return static_cast<Task *>(data)->handle_done();
} }
static void tl_handle_parent(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle, static void tl_handle_parent(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle,
struct zwlr_foreign_toplevel_handle_v1 *parent) struct zwlr_foreign_toplevel_handle_v1 *parent) {
{
/* This is explicitly left blank */ /* This is explicitly left blank */
} }
static void tl_handle_closed(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle) static void tl_handle_closed(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle) {
{
return static_cast<Task *>(data)->handle_closed(); return static_cast<Task *>(data)->handle_closed();
} }
@ -269,11 +244,14 @@ static const struct zwlr_foreign_toplevel_handle_v1_listener toplevel_handle_imp
}; };
Task::Task(const waybar::Bar &bar, const Json::Value &config, Taskbar *tbar, Task::Task(const waybar::Bar &bar, const Json::Value &config, Taskbar *tbar,
struct zwlr_foreign_toplevel_handle_v1 *tl_handle, struct wl_seat *seat) : struct zwlr_foreign_toplevel_handle_v1 *tl_handle, struct wl_seat *seat)
bar_{bar}, config_{config}, tbar_{tbar}, handle_{tl_handle}, seat_{seat}, : bar_{bar},
config_{config},
tbar_{tbar},
handle_{tl_handle},
seat_{seat},
id_{global_id++}, id_{global_id++},
content_{bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0} content_{bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0} {
{
zwlr_foreign_toplevel_handle_v1_add_listener(handle_, &toplevel_handle_impl, this); zwlr_foreign_toplevel_handle_v1_add_listener(handle_, &toplevel_handle_impl, this);
button_.set_relief(Gtk::RELIEF_NONE); button_.set_relief(Gtk::RELIEF_NONE);
@ -321,16 +299,14 @@ Task::Task(const waybar::Bar &bar, const Json::Value &config, Taskbar *tbar,
} }
/* Handle click events if configured */ /* Handle click events if configured */
if (config_["on-click"].isString() || config_["on-click-middle"].isString() if (config_["on-click"].isString() || config_["on-click-middle"].isString() ||
|| config_["on-click-right"].isString()) { config_["on-click-right"].isString()) {
button_.add_events(Gdk::BUTTON_PRESS_MASK); button_.add_events(Gdk::BUTTON_PRESS_MASK);
button_.signal_button_press_event().connect( button_.signal_button_press_event().connect(sigc::mem_fun(*this, &Task::handle_clicked), false);
sigc::mem_fun(*this, &Task::handle_clicked), false);
} }
} }
Task::~Task() Task::~Task() {
{
if (handle_) { if (handle_) {
zwlr_foreign_toplevel_handle_v1_destroy(handle_); zwlr_foreign_toplevel_handle_v1_destroy(handle_);
handle_ = nullptr; handle_ = nullptr;
@ -341,25 +317,19 @@ Task::~Task()
} }
} }
std::string Task::repr() const std::string Task::repr() const {
{
std::stringstream ss; std::stringstream ss;
ss << "Task (" << id_ << ") " << title_ << " [" << app_id_ << "] <" ss << "Task (" << id_ << ") " << title_ << " [" << app_id_ << "] <" << (active() ? "A" : "a")
<< (active() ? "A" : "a") << (maximized() ? "M" : "m") << (minimized() ? "I" : "i") << (fullscreen() ? "F" : "f") << ">";
<< (maximized() ? "M" : "m")
<< (minimized() ? "I" : "i")
<< (fullscreen() ? "F" : "f")
<< ">";
return ss.str(); return ss.str();
} }
std::string Task::state_string(bool shortened) const std::string Task::state_string(bool shortened) const {
{
std::stringstream ss; std::stringstream ss;
if (shortened) if (shortened)
ss << (minimized() ? "m" : "") << (maximized() ? "M" : "") ss << (minimized() ? "m" : "") << (maximized() ? "M" : "") << (active() ? "A" : "")
<< (active() ? "A" : "") << (fullscreen() ? "F" : ""); << (fullscreen() ? "F" : "");
else else
ss << (minimized() ? "minimized " : "") << (maximized() ? "maximized " : "") ss << (minimized() ? "minimized " : "") << (maximized() ? "maximized " : "")
<< (active() ? "active " : "") << (fullscreen() ? "fullscreen " : ""); << (active() ? "active " : "") << (fullscreen() ? "fullscreen " : "");
@ -371,14 +341,12 @@ std::string Task::state_string(bool shortened) const
return res.substr(0, res.size() - 1); return res.substr(0, res.size() - 1);
} }
void Task::handle_title(const char *title) void Task::handle_title(const char *title) {
{
title_ = title; title_ = title;
hide_if_ignored(); hide_if_ignored();
} }
void Task::hide_if_ignored() void Task::hide_if_ignored() {
{
if (tbar_->ignore_list().count(app_id_) || tbar_->ignore_list().count(title_)) { if (tbar_->ignore_list().count(app_id_) || tbar_->ignore_list().count(title_)) {
ignored_ = true; ignored_ = true;
if (button_visible_) { if (button_visible_) {
@ -395,15 +363,15 @@ void Task::hide_if_ignored()
} }
} }
void Task::handle_app_id(const char *app_id) void Task::handle_app_id(const char *app_id) {
{
app_id_ = app_id; app_id_ = app_id;
hide_if_ignored(); hide_if_ignored();
auto ids_replace_map = tbar_->app_ids_replace_map(); auto ids_replace_map = tbar_->app_ids_replace_map();
if (ids_replace_map.count(app_id_)) { if (ids_replace_map.count(app_id_)) {
auto replaced_id = ids_replace_map[app_id_]; auto replaced_id = ids_replace_map[app_id_];
spdlog::debug(fmt::format("Task ({}) [{}] app_id was replaced with {}", id_, app_id_, replaced_id)); spdlog::debug(
fmt::format("Task ({}) [{}] app_id was replaced with {}", id_, app_id_, replaced_id));
app_id_ = replaced_id; app_id_ = replaced_id;
} }
@ -433,8 +401,7 @@ void Task::handle_app_id(const char *app_id)
spdlog::debug("Couldn't find icon for {}", app_id_); spdlog::debug("Couldn't find icon for {}", app_id_);
} }
void Task::handle_output_enter(struct wl_output *output) void Task::handle_output_enter(struct wl_output *output) {
{
if (ignored_) { if (ignored_) {
spdlog::debug("{} is ignored", repr()); spdlog::debug("{} is ignored", repr());
return; return;
@ -451,8 +418,7 @@ void Task::handle_output_enter(struct wl_output *output)
} }
} }
void Task::handle_output_leave(struct wl_output *output) void Task::handle_output_leave(struct wl_output *output) {
{
spdlog::debug("{} left output {}", repr(), (void *)output); spdlog::debug("{} left output {}", repr(), (void *)output);
if (button_visible_ && !tbar_->all_outputs() && tbar_->show_output(output)) { if (button_visible_ && !tbar_->all_outputs() && tbar_->show_output(output)) {
@ -464,25 +430,19 @@ void Task::handle_output_leave(struct wl_output *output)
} }
} }
void Task::handle_state(struct wl_array *state) void Task::handle_state(struct wl_array *state) {
{
state_ = 0; state_ = 0;
size_t size = state->size / sizeof(uint32_t); size_t size = state->size / sizeof(uint32_t);
for (size_t i = 0; i < size; ++i) { for (size_t i = 0; i < size; ++i) {
auto entry = static_cast<uint32_t *>(state->data)[i]; auto entry = static_cast<uint32_t *>(state->data)[i];
if (entry == ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_MAXIMIZED) if (entry == ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_MAXIMIZED) state_ |= MAXIMIZED;
state_ |= MAXIMIZED; if (entry == ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_MINIMIZED) state_ |= MINIMIZED;
if (entry == ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_MINIMIZED) if (entry == ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_ACTIVATED) state_ |= ACTIVE;
state_ |= MINIMIZED; if (entry == ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_FULLSCREEN) state_ |= FULLSCREEN;
if (entry == ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_ACTIVATED)
state_ |= ACTIVE;
if (entry == ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_FULLSCREEN)
state_ |= FULLSCREEN;
} }
} }
void Task::handle_done() void Task::handle_done() {
{
spdlog::debug("{} changed", repr()); spdlog::debug("{} changed", repr());
if (state_ & MAXIMIZED) { if (state_ & MAXIMIZED) {
@ -515,8 +475,7 @@ void Task::handle_done()
tbar_->dp.emit(); tbar_->dp.emit();
} }
void Task::handle_closed() void Task::handle_closed() {
{
spdlog::debug("{} closed", repr()); spdlog::debug("{} closed", repr());
zwlr_foreign_toplevel_handle_v1_destroy(handle_); zwlr_foreign_toplevel_handle_v1_destroy(handle_);
handle_ = nullptr; handle_ = nullptr;
@ -527,8 +486,7 @@ void Task::handle_closed()
tbar_->remove_task(id_); tbar_->remove_task(id_);
} }
bool Task::handle_clicked(GdkEventButton *bt) bool Task::handle_clicked(GdkEventButton *bt) {
{
std::string action; std::string action;
if (config_["on-click"].isString() && bt->button == 1) if (config_["on-click"].isString() && bt->button == 1)
action = config_["on-click"].asString(); action = config_["on-click"].asString();
@ -550,8 +508,7 @@ bool Task::handle_clicked(GdkEventButton *bt)
minimize(true); minimize(true);
else else
activate(); activate();
} } else if (action == "maximize")
else if (action == "maximize")
maximize(!maximized()); maximize(!maximized());
else if (action == "fullscreen") else if (action == "fullscreen")
fullscreen(!fullscreen()); fullscreen(!fullscreen());
@ -563,18 +520,11 @@ bool Task::handle_clicked(GdkEventButton *bt)
return true; return true;
} }
bool Task::operator==(const Task &o) const bool Task::operator==(const Task &o) const { return o.id_ == id_; }
{
return o.id_ == id_;
}
bool Task::operator!=(const Task &o) const bool Task::operator!=(const Task &o) const { return o.id_ != id_; }
{
return o.id_ != id_;
}
void Task::update() void Task::update() {
{
bool markup = config_["markup"].isBool() ? config_["markup"].asBool() : false; bool markup = config_["markup"].isBool() ? config_["markup"].asBool() : false;
std::string title = title_; std::string title = title_;
std::string name = name_; std::string name = name_;
@ -585,13 +535,9 @@ void Task::update()
app_id = Glib::Markup::escape_text(app_id); app_id = Glib::Markup::escape_text(app_id);
} }
if (!format_before_.empty()) { if (!format_before_.empty()) {
auto txt = fmt::format(format_before_, auto txt = fmt::format(format_before_, fmt::arg("title", title), fmt::arg("name", name),
fmt::arg("title", title), fmt::arg("app_id", app_id), fmt::arg("state", state_string()),
fmt::arg("name", name), fmt::arg("short_state", state_string(true)));
fmt::arg("app_id", app_id),
fmt::arg("state", state_string()),
fmt::arg("short_state", state_string(true))
);
if (markup) if (markup)
text_before_.set_markup(txt); text_before_.set_markup(txt);
else else
@ -599,13 +545,9 @@ void Task::update()
text_before_.show(); text_before_.show();
} }
if (!format_after_.empty()) { if (!format_after_.empty()) {
auto txt = fmt::format(format_after_, auto txt = fmt::format(format_after_, fmt::arg("title", title), fmt::arg("name", name),
fmt::arg("title", title), fmt::arg("app_id", app_id), fmt::arg("state", state_string()),
fmt::arg("name", name), fmt::arg("short_state", state_string(true)));
fmt::arg("app_id", app_id),
fmt::arg("state", state_string()),
fmt::arg("short_state", state_string(true))
);
if (markup) if (markup)
text_after_.set_markup(txt); text_after_.set_markup(txt);
else else
@ -614,13 +556,9 @@ void Task::update()
} }
if (!format_tooltip_.empty()) { if (!format_tooltip_.empty()) {
auto txt = fmt::format(format_tooltip_, auto txt = fmt::format(format_tooltip_, fmt::arg("title", title), fmt::arg("name", name),
fmt::arg("title", title), fmt::arg("app_id", app_id), fmt::arg("state", state_string()),
fmt::arg("name", name), fmt::arg("short_state", state_string(true)));
fmt::arg("app_id", app_id),
fmt::arg("state", state_string()),
fmt::arg("short_state", state_string(true))
);
if (markup) if (markup)
button_.set_tooltip_markup(txt); button_.set_tooltip_markup(txt);
else else
@ -628,30 +566,25 @@ void Task::update()
} }
} }
void Task::maximize(bool set) void Task::maximize(bool set) {
{
if (set) if (set)
zwlr_foreign_toplevel_handle_v1_set_maximized(handle_); zwlr_foreign_toplevel_handle_v1_set_maximized(handle_);
else else
zwlr_foreign_toplevel_handle_v1_unset_maximized(handle_); zwlr_foreign_toplevel_handle_v1_unset_maximized(handle_);
} }
void Task::minimize(bool set) void Task::minimize(bool set) {
{
if (set) if (set)
zwlr_foreign_toplevel_handle_v1_set_minimized(handle_); zwlr_foreign_toplevel_handle_v1_set_minimized(handle_);
else else
zwlr_foreign_toplevel_handle_v1_unset_minimized(handle_); zwlr_foreign_toplevel_handle_v1_unset_minimized(handle_);
} }
void Task::activate() void Task::activate() { zwlr_foreign_toplevel_handle_v1_activate(handle_, seat_); }
{
zwlr_foreign_toplevel_handle_v1_activate(handle_, seat_);
}
void Task::fullscreen(bool set) void Task::fullscreen(bool set) {
{ if (zwlr_foreign_toplevel_handle_v1_get_version(handle_) <
if (zwlr_foreign_toplevel_handle_v1_get_version(handle_) < ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_SET_FULLSCREEN_SINCE_VERSION) { ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_SET_FULLSCREEN_SINCE_VERSION) {
spdlog::warn("Foreign toplevel manager server does not support for set/unset fullscreen."); spdlog::warn("Foreign toplevel manager server does not support for set/unset fullscreen.");
return; return;
} }
@ -662,16 +595,11 @@ void Task::fullscreen(bool set)
zwlr_foreign_toplevel_handle_v1_unset_fullscreen(handle_); zwlr_foreign_toplevel_handle_v1_unset_fullscreen(handle_);
} }
void Task::close() void Task::close() { zwlr_foreign_toplevel_handle_v1_close(handle_); }
{
zwlr_foreign_toplevel_handle_v1_close(handle_);
}
/* Taskbar class implementation */ /* Taskbar class implementation */
static void handle_global(void *data, struct wl_registry *registry, uint32_t name, static void handle_global(void *data, struct wl_registry *registry, uint32_t name,
const char *interface, uint32_t version) const char *interface, uint32_t version) {
{
if (std::strcmp(interface, zwlr_foreign_toplevel_manager_v1_interface.name) == 0) { if (std::strcmp(interface, zwlr_foreign_toplevel_manager_v1_interface.name) == 0) {
static_cast<Taskbar *>(data)->register_manager(registry, name, version); static_cast<Taskbar *>(data)->register_manager(registry, name, version);
} else if (std::strcmp(interface, wl_seat_interface.name) == 0) { } else if (std::strcmp(interface, wl_seat_interface.name) == 0) {
@ -679,22 +607,19 @@ static void handle_global(void *data, struct wl_registry *registry, uint32_t nam
} }
} }
static void handle_global_remove(void *data, struct wl_registry *registry, uint32_t name) static void handle_global_remove(void *data, struct wl_registry *registry, uint32_t name) {
{
/* Nothing to do here */ /* Nothing to do here */
} }
static const wl_registry_listener registry_listener_impl = { static const wl_registry_listener registry_listener_impl = {.global = handle_global,
.global = handle_global, .global_remove = handle_global_remove};
.global_remove = handle_global_remove
};
Taskbar::Taskbar(const std::string &id, const waybar::Bar &bar, const Json::Value &config) Taskbar::Taskbar(const std::string &id, const waybar::Bar &bar, const Json::Value &config)
: waybar::AModule(config, "taskbar", id, false, false), : waybar::AModule(config, "taskbar", id, false, false),
bar_(bar), bar_(bar),
box_{bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0}, box_{bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0},
manager_{nullptr}, seat_{nullptr} manager_{nullptr},
{ seat_{nullptr} {
box_.set_name("taskbar"); box_.set_name("taskbar");
if (!id.empty()) { if (!id.empty()) {
box_.get_style_context()->add_class(id); box_.get_style_context()->add_class(id);
@ -756,8 +681,7 @@ Taskbar::Taskbar(const std::string &id, const waybar::Bar &bar, const Json::Valu
icon_themes_.push_back(Gtk::IconTheme::get_default()); icon_themes_.push_back(Gtk::IconTheme::get_default());
} }
Taskbar::~Taskbar() Taskbar::~Taskbar() {
{
if (manager_) { if (manager_) {
struct wl_display *display = Client::inst()->wl_display; struct wl_display *display = Client::inst()->wl_display;
/* /*
@ -776,8 +700,7 @@ Taskbar::~Taskbar()
} }
} }
void Taskbar::update() void Taskbar::update() {
{
for (auto &t : tasks_) { for (auto &t : tasks_) {
t->update(); t->update();
} }
@ -786,13 +709,11 @@ void Taskbar::update()
} }
static void tm_handle_toplevel(void *data, struct zwlr_foreign_toplevel_manager_v1 *manager, static void tm_handle_toplevel(void *data, struct zwlr_foreign_toplevel_manager_v1 *manager,
struct zwlr_foreign_toplevel_handle_v1 *tl_handle) struct zwlr_foreign_toplevel_handle_v1 *tl_handle) {
{
return static_cast<Taskbar *>(data)->handle_toplevel_create(tl_handle); return static_cast<Taskbar *>(data)->handle_toplevel_create(tl_handle);
} }
static void tm_handle_finished(void *data, struct zwlr_foreign_toplevel_manager_v1 *manager) static void tm_handle_finished(void *data, struct zwlr_foreign_toplevel_manager_v1 *manager) {
{
return static_cast<Taskbar *>(data)->handle_finished(); return static_cast<Taskbar *>(data)->handle_finished();
} }
@ -801,22 +722,23 @@ static const struct zwlr_foreign_toplevel_manager_v1_listener toplevel_manager_i
.finished = tm_handle_finished, .finished = tm_handle_finished,
}; };
void Taskbar::register_manager(struct wl_registry *registry, uint32_t name, uint32_t version) void Taskbar::register_manager(struct wl_registry *registry, uint32_t name, uint32_t version) {
{
if (manager_) { if (manager_) {
spdlog::warn("Register foreign toplevel manager again although already existing!"); spdlog::warn("Register foreign toplevel manager again although already existing!");
return; return;
} }
if (version < ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_SET_FULLSCREEN_SINCE_VERSION) { if (version < ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_SET_FULLSCREEN_SINCE_VERSION) {
spdlog::warn("Foreign toplevel manager server does not have the appropriate version." spdlog::warn(
" To be able to use all features, you need at least version 2, but server is version {}", version); "Foreign toplevel manager server does not have the appropriate version."
" To be able to use all features, you need at least version 2, but server is version {}",
version);
} }
// limit version to a highest supported by the client protocol file // limit version to a highest supported by the client protocol file
version = std::min<uint32_t>(version, zwlr_foreign_toplevel_manager_v1_interface.version); version = std::min<uint32_t>(version, zwlr_foreign_toplevel_manager_v1_interface.version);
manager_ = static_cast<struct zwlr_foreign_toplevel_manager_v1 *>(wl_registry_bind(registry, name, manager_ = static_cast<struct zwlr_foreign_toplevel_manager_v1 *>(
&zwlr_foreign_toplevel_manager_v1_interface, version)); wl_registry_bind(registry, name, &zwlr_foreign_toplevel_manager_v1_interface, version));
if (manager_) if (manager_)
zwlr_foreign_toplevel_manager_v1_add_listener(manager_, &toplevel_manager_impl, this); zwlr_foreign_toplevel_manager_v1_add_listener(manager_, &toplevel_manager_impl, this);
@ -824,8 +746,7 @@ void Taskbar::register_manager(struct wl_registry *registry, uint32_t name, uint
spdlog::debug("Failed to register manager"); spdlog::debug("Failed to register manager");
} }
void Taskbar::register_seat(struct wl_registry *registry, uint32_t name, uint32_t version) void Taskbar::register_seat(struct wl_registry *registry, uint32_t name, uint32_t version) {
{
if (seat_) { if (seat_) {
spdlog::warn("Register seat again although already existing!"); spdlog::warn("Register seat again although already existing!");
return; return;
@ -835,34 +756,22 @@ void Taskbar::register_seat(struct wl_registry *registry, uint32_t name, uint32_
seat_ = static_cast<wl_seat *>(wl_registry_bind(registry, name, &wl_seat_interface, version)); seat_ = static_cast<wl_seat *>(wl_registry_bind(registry, name, &wl_seat_interface, version));
} }
void Taskbar::handle_toplevel_create(struct zwlr_foreign_toplevel_handle_v1 *tl_handle) void Taskbar::handle_toplevel_create(struct zwlr_foreign_toplevel_handle_v1 *tl_handle) {
{
tasks_.push_back(std::make_unique<Task>(bar_, config_, this, tl_handle, seat_)); tasks_.push_back(std::make_unique<Task>(bar_, config_, this, tl_handle, seat_));
} }
void Taskbar::handle_finished() void Taskbar::handle_finished() {
{
zwlr_foreign_toplevel_manager_v1_destroy(manager_); zwlr_foreign_toplevel_manager_v1_destroy(manager_);
manager_ = nullptr; manager_ = nullptr;
} }
void Taskbar::add_button(Gtk::Button &bt) void Taskbar::add_button(Gtk::Button &bt) { box_.pack_start(bt, false, false); }
{
box_.pack_start(bt, false, false);
}
void Taskbar::move_button(Gtk::Button &bt, int pos) void Taskbar::move_button(Gtk::Button &bt, int pos) { box_.reorder_child(bt, pos); }
{
box_.reorder_child(bt, pos);
}
void Taskbar::remove_button(Gtk::Button &bt) void Taskbar::remove_button(Gtk::Button &bt) { box_.remove(bt); }
{
box_.remove(bt);
}
void Taskbar::remove_task(uint32_t id) void Taskbar::remove_task(uint32_t id) {
{
auto it = std::find_if(std::begin(tasks_), std::end(tasks_), auto it = std::find_if(std::begin(tasks_), std::end(tasks_),
[id](const TaskPtr &p) { return p->id() == id; }); [id](const TaskPtr &p) { return p->id() == id; });
@ -874,20 +783,22 @@ void Taskbar::remove_task(uint32_t id)
tasks_.erase(it); tasks_.erase(it);
} }
bool Taskbar::show_output(struct wl_output *output) const bool Taskbar::show_output(struct wl_output *output) const {
{
return output == gdk_wayland_monitor_get_wl_output(bar_.output->monitor->gobj()); return output == gdk_wayland_monitor_get_wl_output(bar_.output->monitor->gobj());
} }
bool Taskbar::all_outputs() const bool Taskbar::all_outputs() const {
{
return config_["all-outputs"].isBool() && config_["all-outputs"].asBool(); return config_["all-outputs"].isBool() && config_["all-outputs"].asBool();
} }
const std::vector<Glib::RefPtr<Gtk::IconTheme>>& Taskbar::icon_themes() const { return icon_themes_; } const std::vector<Glib::RefPtr<Gtk::IconTheme>> &Taskbar::icon_themes() const {
return icon_themes_;
}
const std::unordered_set<std::string> &Taskbar::ignore_list() const { return ignore_list_; } const std::unordered_set<std::string> &Taskbar::ignore_list() const { return ignore_list_; }
const std::map<std::string, std::string>& Taskbar::app_ids_replace_map() const { return app_ids_replace_map_; } const std::map<std::string, std::string> &Taskbar::app_ids_replace_map() const {
return app_ids_replace_map_;
}
} /* namespace waybar::modules::wlr */ } /* namespace waybar::modules::wlr */

View File

@ -156,8 +156,7 @@ WorkspaceManager::~WorkspaceManager() {
} }
auto WorkspaceManager::remove_workspace_group(uint32_t id) -> void { auto WorkspaceManager::remove_workspace_group(uint32_t id) -> void {
auto it = std::find_if(groups_.begin(), auto it = std::find_if(groups_.begin(), groups_.end(),
groups_.end(),
[id](const std::unique_ptr<WorkspaceGroup> &g) { return g->id() == id; }); [id](const std::unique_ptr<WorkspaceGroup> &g) { return g->id() == id; });
if (it == groups_.end()) { if (it == groups_.end()) {
@ -257,8 +256,7 @@ auto WorkspaceGroup::update() -> void {
} }
auto WorkspaceGroup::remove_workspace(uint32_t id) -> void { auto WorkspaceGroup::remove_workspace(uint32_t id) -> void {
auto it = std::find_if(workspaces_.begin(), auto it = std::find_if(workspaces_.begin(), workspaces_.end(),
workspaces_.end(),
[id](const std::unique_ptr<Workspace> &w) { return w->id() == id; }); [id](const std::unique_ptr<Workspace> &w) { return w->id() == id; });
if (it == workspaces_.end()) { if (it == workspaces_.end()) {
@ -353,8 +351,8 @@ Workspace::~Workspace() {
} }
auto Workspace::update() -> void { auto Workspace::update() -> void {
label_.set_markup(fmt::format( label_.set_markup(fmt::format(format_, fmt::arg("name", name_),
format_, fmt::arg("name", name_), fmt::arg("icon", with_icon_ ? get_icon() : ""))); fmt::arg("icon", with_icon_ ? get_icon() : "")));
} }
auto Workspace::handle_state(const std::vector<uint32_t> &state) -> void { auto Workspace::handle_state(const std::vector<uint32_t> &state) -> void {

View File

@ -1,6 +1,7 @@
#include "modules/wlr/workspace_manager_binding.hpp" #include "modules/wlr/workspace_manager_binding.hpp"
#include <spdlog/spdlog.h> #include <spdlog/spdlog.h>
#include <cstdint> #include <cstdint>
#include "client.hpp" #include "client.hpp"

View File

@ -39,8 +39,8 @@ waybar::util::Rfkill::Rfkill(const enum rfkill_type rfkill_type) : rfkill_type_(
fd_ = -1; fd_ = -1;
return; return;
} }
Glib::signal_io().connect( Glib::signal_io().connect(sigc::mem_fun(*this, &Rfkill::on_event), fd_,
sigc::mem_fun(*this, &Rfkill::on_event), fd_, Glib::IO_IN | Glib::IO_ERR | Glib::IO_HUP); Glib::IO_IN | Glib::IO_ERR | Glib::IO_HUP);
} }
waybar::util::Rfkill::~Rfkill() { waybar::util::Rfkill::~Rfkill() {