blankie
/
Waybar
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

feat(Bar): handle widget size changes

This commit is contained in:
Alex 2019-04-24 12:37:24 +02:00
parent 90d89fe974
commit 311c34ecbc
28 changed files with 175 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/ALabel.hpp
View File

@ -10,7 +10,7 @@ namespace waybar {
class ALabel : public IModule {
public:
ALabel(const Json::Value &, const std::string format, uint16_t interval = 0);
ALabel(const Json::Value &, const std::string &format, uint16_t interval = 0);
virtual ~ALabel();
virtual auto update() -> void;
virtual std::string getIcon(uint16_t, const std::string &alt = "");

2
include/bar.hpp
View File

@ -56,7 +56,7 @@ class Bar {
void setupAltFormatKeyForModuleList(const char *module_list_name);
uint32_t width_ = 0;
uint32_t height_ = 30;
uint32_t height_ = 1;
Gtk::Box left_;
Gtk::Box center_;
Gtk::Box right_;

4
include/client.hpp
View File

@ -25,10 +25,10 @@ class Client {
std::vector<std::unique_ptr<Bar>> bars;
private:
Client();
Client() = default;
void setupConfigs(const std::string &config, const std::string &style);
void bindInterfaces();
const std::string getValidPath(std::vector<std::string> paths);
const std::string getValidPath(const std::vector<std::string> &paths);
void handleOutput(std::unique_ptr<struct waybar_output> &output);
bool isValidOutput(const Json::Value &config, std::unique_ptr<struct waybar_output> &output);
auto setupConfig() -> void;

4
include/modules/sni/item.hpp
View File

@ -20,7 +20,7 @@ namespace waybar::modules::SNI {
class Item : public sigc::trackable {
public:
Item(std::string, std::string, const Json::Value&);
Item(const std::string&, const std::string&, const Json::Value&);
~Item() = default;
std::string bus_name;
@ -58,7 +58,7 @@ class Item : public sigc::trackable {
void updateImage();
Glib::RefPtr<Gdk::Pixbuf> extractPixBuf(GVariant* variant);
Glib::RefPtr<Gdk::Pixbuf> getIconByName(std::string name, int size);
Glib::RefPtr<Gdk::Pixbuf> getIconByName(const std::string& name, int size);
static void onMenuDestroyed(Item* self);
bool makeMenu(GdkEventButton* const& ev);
bool handleClick(GdkEventButton* const& /*ev*/);

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

@ -24,8 +24,8 @@ class Ipc {
Json::Value payload;
};
sigc::signal<void, const struct ipc_response> signal_event;
sigc::signal<void, const struct ipc_response> signal_cmd;
sigc::signal<void, const struct ipc_response&> signal_event;
sigc::signal<void, const struct ipc_response&> signal_cmd;
void sendCmd(uint32_t type, const std::string &payload = "");
void subscribe(const std::string &payload);

2
include/modules/sway/mode.hpp
View File

@ -16,7 +16,7 @@ class Mode : public ALabel {
auto update() -> void;
private:
void onEvent(const struct Ipc::ipc_response);
void onEvent(const struct Ipc::ipc_response&);
void worker();
const Bar& bar_;

6
include/modules/sway/window.hpp
View File

@ -17,10 +17,10 @@ class Window : public ALabel {
auto update() -> void;
private:
void onEvent(const struct Ipc::ipc_response);
void onCmd(const struct Ipc::ipc_response);
void onEvent(const struct Ipc::ipc_response&);
void onCmd(const struct Ipc::ipc_response&);
void worker();
std::tuple<int, std::string> getFocusedNode(Json::Value nodes);
std::tuple<int, std::string> getFocusedNode(const Json::Value& nodes);
void getFocusedWindow();
const Bar& bar_;

4
include/modules/sway/workspaces.hpp
View File

@ -19,8 +19,8 @@ class Workspaces : public IModule {
operator Gtk::Widget&();
private:
void onCmd(const struct Ipc::ipc_response);
void onEvent(const struct Ipc::ipc_response);
void onCmd(const struct Ipc::ipc_response&);
void onEvent(const struct Ipc::ipc_response&);
void worker();
bool filterButtons();
Gtk::Button& addButton(const Json::Value&);

2
resources/config
View File

@ -1,7 +1,7 @@
{
"layer": "top", // Waybar at top layer
// "position": "bottom", // Waybar position (top|bottom|left|right)
// "height": 30, // Waybar height
"height": 30, // Waybar height (to be removed for auto height)
// "width": 1280, // Waybar width
// Choose the order of the modules
"modules-left": ["sway/workspaces", "sway/mode", "custom/media"],

6
src/ALabel.cpp
View File

@ -3,11 +3,11 @@
#include <iostream>
waybar::ALabel::ALabel(const Json::Value& config, const std::string format, uint16_t interval)
waybar::ALabel::ALabel(const Json::Value& config, const std::string& format, uint16_t interval)
: config_(config),
format_(config_["format"].isString() ? config_["format"].asString() : format),
interval_(config_["interval"] == "once"
? std::chrono::seconds(100000000)
? std::chrono::seconds(std::numeric_limits<int>::infinity())
: std::chrono::seconds(
config_["interval"].isUInt() ? config_["interval"].asUInt() : interval)),
default_format_(format_) {
@ -33,7 +33,7 @@ waybar::ALabel::ALabel(const Json::Value& config, const std::string format, uint
}
waybar::ALabel::~ALabel() {
for (const auto &pid : pid_) {
for (const auto& pid : pid_) {
if (pid != -1) {
kill(-pid, 9);
}

80
src/bar.cpp
View File

@ -17,7 +17,7 @@ waybar::Bar::Bar(struct waybar_output* w_output)
if (output->config["position"] == "right" || output->config["position"] == "left") {
height_ = 0;
width_ = 30;
width_ = 1;
}
window.set_size_request(width_, height_);
@ -42,6 +42,38 @@ waybar::Bar::Bar(struct waybar_output* w_output)
auto height = output->config["height"].isUInt() ? output->config["height"].asUInt() : height_;
auto width = output->config["width"].isUInt() ? output->config["width"].asUInt() : width_;
window.signal_configure_event().connect_notify([&](GdkEventConfigure* ev) {
auto tmp_height = height_;
auto tmp_width = width_;
if (ev->height > static_cast<int>(height_)) {
// Default minimal value
if (height_ != 1) {
std::cout << fmt::format(MIN_HEIGHT_MSG, height_, ev->height) << std::endl;
}
if (output->config["height"].isUInt()) {
std::cout << "Height size is defined in the config file so it will stay like that"
<< std::endl;
} else {
tmp_height = ev->height;
}
}
if (ev->width > static_cast<int>(width_)) {
// Default minimal value
if (width_ != 1) {
std::cout << fmt::format(MIN_WIDTH_MSG, width_, ev->width) << std::endl;
}
if (output->config["width"].isUInt()) {
std::cout << "Height size is defined in the config file so it will stay like that"
<< std::endl;
} else {
tmp_width = ev->width;
}
}
if (tmp_width != width_ || tmp_height != height_) {
zwlr_layer_surface_v1_set_size(layer_surface, tmp_width, tmp_height);
}
});
std::size_t anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP;
if (output->config["position"] == "bottom") {
anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
@ -83,21 +115,21 @@ void waybar::Bar::setupAltFormatKeyForModule(const std::string& module_name) {
std::string str_click = click.asString();
if (str_click == "click-right") {
module["format-alt-click"] = 3u;
module["format-alt-click"] = 3U;
} else if (str_click == "click-middle") {
module["format-alt-click"] = 2u;
module["format-alt-click"] = 2U;
} else if (str_click == "click-backward") {
module["format-alt-click"] = 8u;
module["format-alt-click"] = 8U;
} else if (str_click == "click-forward") {
module["format-alt-click"] = 9u;
module["format-alt-click"] = 9U;
} else {
module["format-alt-click"] = 1u; // default click-left
module["format-alt-click"] = 1U; // default click-left
}
} else {
module["format-alt-click"] = 1u;
module["format-alt-click"] = 1U;
}
} else {
module["format-alt-click"] = 1u;
module["format-alt-click"] = 1U;
}
}
}
@ -117,15 +149,21 @@ void waybar::Bar::setupAltFormatKeyForModuleList(const char* module_list_name) {
void waybar::Bar::handleSignal(int signal) {
for (auto& module : modules_left_) {
auto* custom = dynamic_cast<waybar::modules::Custom*>(module.get());
if (custom) custom->refresh(signal);
if (custom != nullptr) {
custom->refresh(signal);
}
}
for (auto& module : modules_center_) {
auto* custom = dynamic_cast<waybar::modules::Custom*>(module.get());
if (custom) custom->refresh(signal);
if (custom != nullptr) {
custom->refresh(signal);
}
}
for (auto& module : modules_right_) {
auto* custom = dynamic_cast<waybar::modules::Custom*>(module.get());
if (custom) custom->refresh(signal);
if (custom != nullptr) {
custom->refresh(signal);
}
}
}
@ -137,19 +175,13 @@ void waybar::Bar::layerSurfaceHandleConfigure(void* data, struct zwlr_layer_surf
o->height_ = height;
o->window.set_size_request(o->width_, o->height_);
o->window.resize(o->width_, o->height_);
int min_width, min_height;
o->window.get_size(min_width, min_height);
if (o->height_ < static_cast<uint32_t>(min_height)) {
std::cout << fmt::format(MIN_HEIGHT_MSG, o->height_, min_height) << std::endl;
o->height_ = min_height;
}
if (o->width_ < static_cast<uint32_t>(min_width)) {
std::cout << fmt::format(MIN_WIDTH_MSG, o->height_, min_width) << std::endl;
o->width_ = min_width;
}
std::cout << fmt::format(BAR_SIZE_MSG, o->width_, o->height_, o->output->name) << std::endl;
zwlr_layer_surface_v1_set_exclusive_zone(o->layer_surface,
o->vertical ? o->width_ : o->height_);
std::cout << fmt::format(BAR_SIZE_MSG,
o->width_ == 1 ? "auto" : std::to_string(o->width_),
o->height_ == 1 ? "auto" : std::to_string(o->height_),
o->output->name)
<< std::endl;
wl_surface_commit(o->surface);
}
zwlr_layer_surface_v1_ack_configure(surface, serial);

8
src/client.cpp
View File

@ -4,14 +4,12 @@
#include "util/clara.hpp"
#include "util/json.hpp"
waybar::Client::Client() {}
waybar::Client *waybar::Client::inst() {
static Client *c = new Client();
static auto c = new Client();
return c;
}
const std::string waybar::Client::getValidPath(std::vector<std::string> paths) {
const std::string waybar::Client::getValidPath(const std::vector<std::string> &paths) {
wordexp_t p;
for (const std::string &path : paths) {
@ -212,7 +210,7 @@ void waybar::Client::bindInterfaces() {
};
wl_registry_add_listener(registry, &registry_listener, this);
wl_display_roundtrip(wl_display);
if (!layer_shell || !xdg_output_manager) {
if (layer_shell == nullptr || xdg_output_manager == nullptr) {
throw std::runtime_error("Failed to acquire required resources.");
}
}

2
src/factory.cpp
View File

@ -4,7 +4,7 @@ waybar::Factory::Factory(const Bar& bar, const Json::Value& config) : bar_(bar),
waybar::IModule* waybar::Factory::makeModule(const std::string& name) const {
try {
auto hash_pos = name.find("#");
auto hash_pos = name.find('#');
auto ref = name.substr(0, hash_pos);
auto id = hash_pos != std::string::npos ? name.substr(hash_pos + 1) : "";
if (ref == "battery") {

4
src/modules/backlight.cpp
View File

@ -120,9 +120,9 @@ waybar::modules::Backlight::Backlight(const std::string &name, const Json::Value
auto udev_fd = udev_monitor_get_fd(mon.get());
auto epoll_fd = FileDescriptor{epoll_create1(0)};
auto epoll_fd = FileDescriptor{epoll_create1(EPOLL_CLOEXEC)};
check_neq(epoll_fd.get(), -1, "epoll init failed: ");
epoll_event ctl_event;
epoll_event ctl_event{};
ctl_event.events = EPOLLIN;
ctl_event.data.fd = udev_fd;

2
src/modules/battery.cpp
View File

@ -115,7 +115,7 @@ const std::string waybar::modules::Battery::getState(uint8_t capacity) const {
if (config_["states"].isObject()) {
for (auto it = config_["states"].begin(); it != config_["states"].end(); ++it) {
if (it->isUInt() && it.key().isString()) {
states.push_back({it.key().asString(), it->asUInt()});
states.emplace_back(it.key().asString(), it->asUInt());
}
}
}

5
src/modules/clock.cpp
View File

@ -14,10 +14,11 @@ waybar::modules::Clock::Clock(const std::string& id, const Json::Value& config)
auto sub_m =
std::chrono::duration_cast<std::chrono::seconds>(time_s.time_since_epoch()).count() %
interval_.count();
if (sub_m > 0)
if (sub_m > 0) {
thread_.sleep_until(timeout - std::chrono::seconds(sub_m - 1));
else
} else {
thread_.sleep_until(timeout - std::chrono::seconds(sub_m));
}
};
}

6
src/modules/cpu.cpp
View File

@ -25,7 +25,7 @@ auto waybar::modules::Cpu::update() -> void {
uint16_t waybar::modules::Cpu::getCpuLoad() {
struct sysinfo info = {0};
if (sysinfo(&info) == 0) {
float f_load = 1.f / (1u << SI_LOAD_SHIFT);
float f_load = 1.F / (1U << SI_LOAD_SHIFT);
uint16_t load = info.loads[0] * f_load * 100 / get_nprocs();
return load;
}
@ -70,7 +70,7 @@ std::vector<std::tuple<size_t, size_t>> waybar::modules::Cpu::parseCpuinfo() {
}
std::stringstream sline(line.substr(5));
std::vector<size_t> times;
for (size_t time; sline >> time; times.push_back(time))
for (size_t time = 0; sline >> time; times.push_back(time))
;
size_t idle_time = 0;
@ -79,7 +79,7 @@ std::vector<std::tuple<size_t, size_t>> waybar::modules::Cpu::parseCpuinfo() {
idle_time = times[3];
total_time = std::accumulate(times.begin(), times.end(), 0);
}
cpuinfo.push_back({idle_time, total_time});
cpuinfo.emplace_back(idle_time, total_time);
}
return cpuinfo;
}

4
src/modules/idle_inhibitor.cpp
View File

@ -19,7 +19,7 @@ waybar::modules::IdleInhibitor::IdleInhibitor(const std::string& id, const Bar&
}
waybar::modules::IdleInhibitor::~IdleInhibitor() {
if (idle_inhibitor_) {
if (idle_inhibitor_ != nullptr) {
zwp_idle_inhibitor_v1_destroy(idle_inhibitor_);
idle_inhibitor_ = nullptr;
}
@ -41,7 +41,7 @@ auto waybar::modules::IdleInhibitor::update() -> void {
bool waybar::modules::IdleInhibitor::handleToggle(GdkEventButton* const& e) {
if (e->button == 1) {
label_.get_style_context()->remove_class(status_);
if (idle_inhibitor_) {
if (idle_inhibitor_ != nullptr) {
zwp_idle_inhibitor_v1_destroy(idle_inhibitor_);
idle_inhibitor_ = nullptr;
status_ = "deactivated";

6
src/modules/memory.cpp
View File

@ -28,19 +28,19 @@ auto waybar::modules::Memory::update() -> void {
}
void waybar::modules::Memory::parseMeminfo() {
long memfree = -1, membuffer = -1, memcache = -1, memavail = -1;
int64_t memfree = -1, membuffer = -1, memcache = -1, memavail = -1;
std::ifstream info(data_dir_);
if (!info.is_open()) {
throw std::runtime_error("Can't open " + data_dir_);
}
std::string line;
while (getline(info, line)) {
auto posDelim = line.find(":");
auto posDelim = line.find(':');
if (posDelim == std::string::npos) {
continue;
}
std::string name = line.substr(0, posDelim);
long value = std::stol(line.substr(posDelim + 1));
int64_t value = std::stol(line.substr(posDelim + 1));
if (name.compare("MemTotal") == 0) {
memtotal_ = value;

4
src/modules/network.cpp
View File

@ -68,7 +68,7 @@ void waybar::modules::Network::createInfoSocket() {
nl_socket_disable_seq_check(info_sock_);
nl_socket_set_nonblocking(info_sock_);
nl_socket_modify_cb(info_sock_, NL_CB_VALID, NL_CB_CUSTOM, handleEvents, this);
efd_ = epoll_create1(0);
efd_ = epoll_create1(EPOLL_CLOEXEC);
if (efd_ < 0) {
throw std::runtime_error("Can't create epoll");
}
@ -114,7 +114,7 @@ void waybar::modules::Network::worker() {
}
thread_timer_.sleep_for(interval_);
};
std::array<struct epoll_event, EPOLL_MAX> events;
std::array<struct epoll_event, EPOLL_MAX> events{};
thread_ = [this, &events] {
int ec = epoll_wait(efd_, events.data(), EPOLL_MAX, -1);
if (ec > 0) {

23
src/modules/pulseaudio.cpp
View File

@ -99,9 +99,13 @@ bool waybar::modules::Pulseaudio::handleScroll(GdkEventScroll *e) {
}
if (direction_up) {
if (volume_ + 1 < 100) pa_cvolume_inc(&pa_volume, change);
if (volume_ + 1 < 100) {
pa_cvolume_inc(&pa_volume, change);
}
} else {
if (volume_ - 1 > 0) pa_cvolume_dec(&pa_volume, change);
if (volume_ - 1 > 0) {
pa_cvolume_dec(&pa_volume, change);
}
}
pa_context_set_sink_volume_by_index(context_, sink_idx_, &pa_volume, volumeModifyCb, this);
@ -116,13 +120,8 @@ void waybar::modules::Pulseaudio::subscribeCb(pa_context * conte
pa_subscription_event_type_t type, uint32_t idx,
void *data) {
unsigned facility = type & PA_SUBSCRIPTION_EVENT_FACILITY_MASK;
switch (facility) {
case PA_SUBSCRIPTION_EVENT_SINK:
pa_context_get_sink_info_by_index(context, idx, sinkInfoCb, data);
break;
default:
break;
if (facility == PA_SUBSCRIPTION_EVENT_SINK) {
pa_context_get_sink_info_by_index(context, idx, sinkInfoCb, data);
}
}
@ -131,7 +130,7 @@ void waybar::modules::Pulseaudio::subscribeCb(pa_context * conte
*/
void waybar::modules::Pulseaudio::volumeModifyCb(pa_context *c, int success, void *data) {
auto pa = static_cast<waybar::modules::Pulseaudio *>(data);
if (success) {
if (success != 0) {
pa_context_get_sink_info_by_index(pa->context_, pa->sink_idx_, sinkInfoCb, data);
}
}
@ -146,10 +145,10 @@ void waybar::modules::Pulseaudio::sinkInfoCb(pa_context * /*context*/, const pa_
pa->pa_volume_ = i->volume;
float volume = static_cast<float>(pa_cvolume_avg(&(pa->pa_volume_))) / float{PA_VOLUME_NORM};
pa->sink_idx_ = i->index;
pa->volume_ = std::round(volume * 100.0f);
pa->volume_ = std::round(volume * 100.0F);
pa->muted_ = i->mute != 0;
pa->desc_ = i->description;
pa->port_name_ = i->active_port ? i->active_port->name : "Unknown";
pa->port_name_ = i->active_port != nullptr ? i->active_port->name : "Unknown";
pa->dp.emit();
}
}

9
src/modules/sni/host.cpp
View File

@ -1,8 +1,7 @@
#include "modules/sni/host.hpp"
#include <iostream>
using namespace waybar::modules::SNI;
namespace waybar::modules::SNI {
Host::Host(const std::size_t id, const Json::Value& config,
const std::function<void(std::unique_ptr<Item>&)>& on_add,
@ -96,7 +95,7 @@ void Host::registerHost(GObject* src, GAsyncResult* res, gpointer data) {
g_signal_connect(host->watcher_, "item-registered", G_CALLBACK(&Host::itemRegistered), data);
g_signal_connect(host->watcher_, "item-unregistered", G_CALLBACK(&Host::itemUnregistered), data);
auto items = sn_watcher_dup_registered_items(host->watcher_);
if (items) {
if (items != nullptr) {
for (uint32_t i = 0; items[i] != nullptr; i += 1) {
host->addRegisteredItem(items[i]);
}
@ -122,7 +121,7 @@ void Host::itemUnregistered(SnWatcher* watcher, const gchar* service, gpointer d
}
std::tuple<std::string, std::string> Host::getBusNameAndObjectPath(const std::string service) {
auto it = service.find("/");
auto it = service.find('/');
if (it != std::string::npos) {
return {service.substr(0, it), service.substr(it)};
}
@ -134,3 +133,5 @@ void Host::addRegisteredItem(std::string service) {
items_.emplace_back(new Item(bus_name, object_path, config_));
on_add_(items_.back());
}
}

53
src/modules/sni/item.cpp
View File

@ -1,14 +1,13 @@
#include "modules/sni/item.hpp"
#include <glibmm/main.h>
#include <iostream>
using namespace Glib;
namespace waybar::modules::SNI {
static const ustring SNI_INTERFACE_NAME = sn_item_interface_info()->name;
static const unsigned UPDATE_DEBOUNCE_TIME = 10;
static const Glib::ustring SNI_INTERFACE_NAME = sn_item_interface_info()->name;
static const unsigned UPDATE_DEBOUNCE_TIME = 10;
waybar::modules::SNI::Item::Item(std::string bn, std::string op, const Json::Value& config)
Item::Item(const std::string& bn, const std::string& op, const Json::Value& config)
: bus_name(bn),
object_path(op),
icon_size(16),
@ -34,7 +33,7 @@ waybar::modules::SNI::Item::Item(std::string bn, std::string op, const Json::Val
interface);
}
void waybar::modules::SNI::Item::proxyReady(Glib::RefPtr<Gio::AsyncResult>& result) {
void Item::proxyReady(Glib::RefPtr<Gio::AsyncResult>& result) {
try {
this->proxy_ = Gio::DBus::Proxy::create_for_bus_finish(result);
/* Properties are already cached during object creation */
@ -69,11 +68,11 @@ void waybar::modules::SNI::Item::proxyReady(Glib::RefPtr<Gio::AsyncResult>& resu
}
template <typename T>
T get_variant(VariantBase& value) {
return VariantBase::cast_dynamic<Variant<T>>(value).get();
T get_variant(Glib::VariantBase& value) {
return Glib::VariantBase::cast_dynamic<Glib::Variant<T>>(value).get();
}
void waybar::modules::SNI::Item::setProperty(const ustring& name, VariantBase& value) {
void Item::setProperty(const Glib::ustring& name, Glib::VariantBase& value) {
if (name == "Category") {
category = get_variant<std::string>(value);
} else if (name == "Id") {
@ -112,29 +111,30 @@ void waybar::modules::SNI::Item::setProperty(const ustring& name, VariantBase& v
}
}
void waybar::modules::SNI::Item::getUpdatedProperties() {
void Item::getUpdatedProperties() {
update_pending_ = false;
auto params = VariantContainerBase::create_tuple({Variant<ustring>::create(SNI_INTERFACE_NAME)});
auto params = Glib::VariantContainerBase::create_tuple(
{Glib::Variant<Glib::ustring>::create(SNI_INTERFACE_NAME)});
proxy_->call("org.freedesktop.DBus.Properties.GetAll",
sigc::mem_fun(*this, &Item::processUpdatedProperties),
params);
};
void waybar::modules::SNI::Item::processUpdatedProperties(Glib::RefPtr<Gio::AsyncResult>& _result) {
void Item::processUpdatedProperties(Glib::RefPtr<Gio::AsyncResult>& _result) {
try {
auto result = proxy_->call_finish(_result);
// extract "a{sv}" from VariantContainerBase
Variant<std::map<ustring, VariantBase>> properties_variant;
Glib::Variant<std::map<Glib::ustring, Glib::VariantBase>> properties_variant;
result.get_child(properties_variant);
auto properties = properties_variant.get();
for (const auto& [name, value] : properties) {
VariantBase old_value;
Glib::VariantBase old_value;
proxy_->get_cached_property(old_value, name);
if (!value.equal(old_value)) {
proxy_->set_cached_property(name, value);
setProperty(name, const_cast<VariantBase&>(value));
setProperty(name, const_cast<Glib::VariantBase&>(value));
}
}
@ -147,8 +147,8 @@ void waybar::modules::SNI::Item::processUpdatedProperties(Glib::RefPtr<Gio::Asyn
}
}
void waybar::modules::SNI::Item::onSignal(const ustring& sender_name, const ustring& signal_name,
const VariantContainerBase& arguments) {
void Item::onSignal(const Glib::ustring& sender_name, const Glib::ustring& signal_name,
const Glib::VariantContainerBase& arguments) {
if (!update_pending_ && signal_name.compare(0, 3, "New") == 0) {
/* Debounce signals and schedule update of all properties.
* Based on behavior of Plasma dataengine for StatusNotifierItem.
@ -161,7 +161,7 @@ void waybar::modules::SNI::Item::onSignal(const ustring& sender_name, const ustr
static void pixbuf_data_deleter(const guint8* data) { g_free((void*)data); }
Glib::RefPtr<Gdk::Pixbuf> waybar::modules::SNI::Item::extractPixBuf(GVariant* variant) {
Glib::RefPtr<Gdk::Pixbuf> Item::extractPixBuf(GVariant* variant) {
GVariantIter* it;
g_variant_get(variant, "a(iiay)", &it);
if (it == nullptr) {
@ -213,7 +213,7 @@ Glib::RefPtr<Gdk::Pixbuf> waybar::modules::SNI::Item::extractPixBuf(GVariant* va
return Glib::RefPtr<Gdk::Pixbuf>{};
}
void waybar::modules::SNI::Item::updateImage() {
void Item::updateImage() {
image.set_from_icon_name("image-missing", Gtk::ICON_SIZE_MENU);
image.set_pixel_size(icon_size);
if (!icon_name.empty()) {
@ -244,8 +244,7 @@ void waybar::modules::SNI::Item::updateImage() {
}
}
Glib::RefPtr<Gdk::Pixbuf> waybar::modules::SNI::Item::getIconByName(std::string name,
int request_size) {
Glib::RefPtr<Gdk::Pixbuf> Item::getIconByName(const std::string& name, int request_size) {
int tmp_size = 0;
icon_theme->rescan_if_needed();
auto sizes = icon_theme->get_icon_sizes(name.c_str());
@ -277,12 +276,12 @@ Glib::RefPtr<Gdk::Pixbuf> waybar::modules::SNI::Item::getIconByName(std::string
name.c_str(), tmp_size, Gtk::IconLookupFlags::ICON_LOOKUP_FORCE_SIZE);
}
void waybar::modules::SNI::Item::onMenuDestroyed(Item* self) {
void Item::onMenuDestroyed(Item* self) {
self->gtk_menu = nullptr;
self->dbus_menu = nullptr;
}
bool waybar::modules::SNI::Item::makeMenu(GdkEventButton* const& ev) {
bool Item::makeMenu(GdkEventButton* const& ev) {
if (gtk_menu == nullptr) {
if (!menu.empty()) {
dbus_menu = dbusmenu_gtkmenu_new(bus_name.data(), menu.data());
@ -305,9 +304,9 @@ bool waybar::modules::SNI::Item::makeMenu(GdkEventButton* const& ev) {
return false;
}
bool waybar::modules::SNI::Item::handleClick(GdkEventButton* const& ev) {
auto parameters = VariantContainerBase::create_tuple(
{Variant<int>::create(ev->x), Variant<int>::create(ev->y)});
bool Item::handleClick(GdkEventButton* const& ev) {
auto parameters = Glib::VariantContainerBase::create_tuple(
{Glib::Variant<int>::create(ev->x), Glib::Variant<int>::create(ev->y)});
if ((ev->button == 1 && item_is_menu) || ev->button == 3) {
if (!makeMenu(ev)) {
proxy_->call("ContextMenu", parameters);
@ -322,3 +321,5 @@ bool waybar::modules::SNI::Item::handleClick(GdkEventButton* const& ev) {
}
return false;
}
} // namespace waybar::modules::SNI

28
src/modules/sni/tray.cpp
View File

@ -1,36 +1,42 @@
#include "modules/sni/tray.hpp"
#include <iostream>
waybar::modules::SNI::Tray::Tray(const std::string& id, const Bar& bar, const Json::Value& config)
namespace waybar::modules::SNI {
Tray::Tray(const std::string& id, const Bar& bar, const Json::Value& config)
: config_(config),
box_(bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0),
watcher_(),
host_(nb_hosts_, config, std::bind(&Tray::onAdd, this, std::placeholders::_1),
std::bind(&Tray::onRemove, this, std::placeholders::_1)) {
box_.set_name("tray");
if (!id.empty()) {
box_.get_style_context()->add_class(id);
}
if (config_["spacing"].isUInt()) {
box_.set_spacing(config_["spacing"].asUInt());
}
nb_hosts_ += 1;
dp.emit();
}
void waybar::modules::SNI::Tray::onAdd(std::unique_ptr<Item>& item) {
void Tray::onAdd(std::unique_ptr<Item>& item) {
box_.pack_start(item->event_box);
dp.emit();
}
void waybar::modules::SNI::Tray::onRemove(std::unique_ptr<Item>& item) {
void Tray::onRemove(std::unique_ptr<Item>& item) {
box_.remove(item->event_box);
dp.emit();
}
auto waybar::modules::SNI::Tray::update() -> void {
if (box_.get_children().size() > 0) {
box_.set_name("tray");
box_.show_all();
auto Tray::update() -> void {
if (box_.get_children().empty()) {
box_.hide();
} else {
box_.set_name("");
box_.show_all();
}
}
waybar::modules::SNI::Tray::operator Gtk::Widget&() { return box_; }
Tray::operator Gtk::Widget&() { return box_; }
}

22
src/modules/sni/watcher.cpp
View File

@ -19,14 +19,14 @@ Watcher::~Watcher() {
bus_name_id_ = 0;
}
if (hosts_ != NULL) {
if (hosts_ != nullptr) {
g_slist_free_full(hosts_, gfWatchFree);
hosts_ = NULL;
hosts_ = nullptr;
}
if (items_ != NULL) {
if (items_ != nullptr) {
g_slist_free_full(items_, gfWatchFree);
items_ = NULL;
items_ = nullptr;
}
g_dbus_interface_skeleton_unexport(G_DBUS_INTERFACE_SKELETON(watcher_));
}
@ -122,7 +122,7 @@ gboolean Watcher::handleRegisterItem(Watcher* obj, GDBusMethodInvocation* invoca
Watcher::GfWatch* Watcher::gfWatchFind(GSList* list, const gchar* bus_name,
const gchar* object_path) {
for (GSList* l = list; l != nullptr; l = g_slist_next(l)) {
GfWatch* watch = static_cast<GfWatch*>(l->data);
auto watch = static_cast<GfWatch*>(l->data);
if (g_strcmp0(watch->bus_name, bus_name) == 0 &&
g_strcmp0(watch->object_path, object_path) == 0) {
return watch;
@ -132,11 +132,11 @@ Watcher::GfWatch* Watcher::gfWatchFind(GSList* list, const gchar* bus_name,
}
void Watcher::gfWatchFree(gpointer data) {
GfWatch* watch;
auto watch = static_cast<GfWatch*>(data);
watch = (GfWatch*)data;
if (watch->watch_id > 0) g_bus_unwatch_name(watch->watch_id);
if (watch->watch_id > 0) {
g_bus_unwatch_name(watch->watch_id);
}
g_free(watch->service);
g_free(watch->bus_name);
@ -184,8 +184,8 @@ void Watcher::updateRegisteredItems(SnWatcher* obj) {
GVariantBuilder builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE("as"));
for (GSList* l = items_; l != nullptr; l = g_slist_next(l)) {
GfWatch* watch = static_cast<GfWatch*>(l->data);
gchar* item = g_strdup_printf("%s%s", watch->bus_name, watch->object_path);
auto watch = static_cast<GfWatch*>(l->data);
gchar* item = g_strdup_printf("%s%s", watch->bus_name, watch->object_path);
g_variant_builder_add(&builder, "s", item);
g_free(item);
}

4
src/modules/sway/mode.cpp
View File

@ -8,14 +8,14 @@ Mode::Mode(const std::string& id, const Bar& bar, const Json::Value& config)
if (!id.empty()) {
label_.get_style_context()->add_class(id);
}
ipc_.subscribe("[ \"mode\" ]");
ipc_.subscribe(R"(["mode"])");
ipc_.signal_event.connect(sigc::mem_fun(*this, &Mode::onEvent));
// Launch worker
worker();
dp.emit();
}
void Mode::onEvent(const struct Ipc::ipc_response res) {
void Mode::onEvent(const struct Ipc::ipc_response &res) {
if (res.payload["change"] != "default") {
mode_ = res.payload["change"].asString();
} else {

8
src/modules/sway/window.cpp
View File

@ -12,7 +12,7 @@ Window::Window(const std::string& id, const Bar& bar, const Json::Value& config)
label_.set_hexpand(true);
label_.set_ellipsize(Pango::EllipsizeMode::ELLIPSIZE_END);
}
ipc_.subscribe("[\"window\",\"workspace\"]");
ipc_.subscribe(R"(["window","workspace"])");
ipc_.signal_event.connect(sigc::mem_fun(*this, &Window::onEvent));
ipc_.signal_cmd.connect(sigc::mem_fun(*this, &Window::onCmd));
getFocusedWindow();
@ -20,7 +20,7 @@ Window::Window(const std::string& id, const Bar& bar, const Json::Value& config)
worker();
}
void Window::onEvent(const struct Ipc::ipc_response res) {
void Window::onEvent(const struct Ipc::ipc_response& res) {
auto data = res.payload;
// Check for waybar prevents flicker when hovering window module
if ((data["change"] == "focus" || data["change"] == "title") &&
@ -38,7 +38,7 @@ void Window::onEvent(const struct Ipc::ipc_response res) {
}
}
void Window::onCmd(const struct Ipc::ipc_response res) {
void Window::onCmd(const struct Ipc::ipc_response& res) {
auto [id, name] = getFocusedNode(res.payload["nodes"]);
windowId_ = id;
window_ = name;
@ -62,7 +62,7 @@ auto Window::update() -> void {
}
}
std::tuple<int, std::string> Window::getFocusedNode(Json::Value nodes) {
std::tuple<int, std::string> Window::getFocusedNode(const Json::Value& nodes) {
for (auto const& node : nodes) {
if (node["focused"].asBool() && node["type"] == "con") {
return {node["id"].asInt(), node["name"].asString()};

8
src/modules/sway/workspaces.cpp
View File

@ -11,7 +11,7 @@ Workspaces::Workspaces(const std::string &id, const Bar &bar, const Json::Value
if (!id.empty()) {
box_.get_style_context()->add_class(id);
}
ipc_.subscribe("[ \"workspace\" ]");
ipc_.subscribe(R"(["workspace"])");
ipc_.signal_event.connect(sigc::mem_fun(*this, &Workspaces::onEvent));
ipc_.signal_cmd.connect(sigc::mem_fun(*this, &Workspaces::onCmd));
ipc_.sendCmd(IPC_GET_WORKSPACES);
@ -19,9 +19,9 @@ Workspaces::Workspaces(const std::string &id, const Bar &bar, const Json::Value
worker();
}
void Workspaces::onEvent(const struct Ipc::ipc_response res) { ipc_.sendCmd(IPC_GET_WORKSPACES); }
void Workspaces::onEvent(const struct Ipc::ipc_response &res) { ipc_.sendCmd(IPC_GET_WORKSPACES); }
void Workspaces::onCmd(const struct Ipc::ipc_response res) {
void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
if (res.type == IPC_GET_WORKSPACES) {
if (res.payload.isArray()) {
std::lock_guard<std::mutex> lock(mutex_);
@ -209,7 +209,7 @@ const std::string Workspaces::getCycleWorkspace(std::vector<Json::Value>::iterat
}
std::string Workspaces::trimWorkspaceName(std::string name) {
std::size_t found = name.find(":");
std::size_t found = name.find(':');
if (found != std::string::npos) {
return name.substr(found + 1);
}