diff --git a/.clang-format b/.clang-format index 4bd6b39..c428ccc 100644 --- a/.clang-format +++ b/.clang-format @@ -1,5 +1,6 @@ --- BasedOnStyle: Google -ColumnLimit: '100' - +AlignConsecutiveDeclarations: true +BinPackArguments: false +ColumnLimit: 100 ... diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..8c2ecb0 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,19 @@ +# EditorConfig configuration for Waybar +# http://EditorConfig.org + +# Top-most EditorConfig file +root = true + +[*] +end_of_line = lf +insert_final_newline = true +trim_trailing_whitespace = true +charset = utf-8 + +[*.{build,css}] +indent_style = space +indent_size = 4 + +[*.{hpp,cpp}] +indent_style = space +indent_size = 2 diff --git a/README.md b/README.md index 717c80c..e4464a2 100644 --- a/README.md +++ b/README.md @@ -14,6 +14,7 @@ - Memory - Cpu load average - Temperature +- MPD - Custom scripts - Multiple output configuration - And much more customizations @@ -49,6 +50,7 @@ libpulse [Pulseaudio module] libnl [Network module] sway [Sway modules] libdbusmenu-gtk3 [Tray module] +libmpdclient [MPD module] ``` Contributions welcome! - have fun :)
diff --git a/include/factory.hpp b/include/factory.hpp index f896d05..2f55046 100644 --- a/include/factory.hpp +++ b/include/factory.hpp @@ -23,6 +23,9 @@ #ifdef HAVE_LIBPULSE #include "modules/pulseaudio.hpp" #endif +#ifdef HAVE_LIBMPDCLIENT +#include "modules/mpd.hpp" +#endif #include "modules/temperature.hpp" #include "modules/custom.hpp" diff --git a/include/modules/mpd.hpp b/include/modules/mpd.hpp new file mode 100644 index 0000000..b3134f4 --- /dev/null +++ b/include/modules/mpd.hpp @@ -0,0 +1,67 @@ +#pragma once + +#include +#include +#include +#include +#include "ALabel.hpp" + +namespace waybar::modules { + +class MPD : public ALabel { + public: + MPD(const std::string&, const Json::Value&); + auto update() -> void; + + private: + std::thread periodic_updater(); + void setLabel(); + std::string getStateIcon(); + std::string getOptionIcon(std::string optionName, bool activated); + + std::thread event_listener(); + + // Assumes `connection_lock_` is locked + void tryConnect(); + // If checking errors on the main connection, make sure to lock it using + // `connection_lock_` before calling checkErrors + void checkErrors(mpd_connection* conn); + + // Assumes `connection_lock_` is locked + void fetchState(); + void waitForEvent(); + + bool handlePlayPause(GdkEventButton* const&); + + bool stopped(); + bool playing(); + + const std::string module_name_; + + using unique_connection = std::unique_ptr; + using unique_status = std::unique_ptr; + using unique_song = std::unique_ptr; + + // Not using unique_ptr since we don't manage the pointer + // (It's either nullptr, or from the config) + const char* server_; + const unsigned port_; + + // We need a mutex here because we can trigger updates from multiple thread: + // the event based updates, the periodic updates needed for the elapsed time, + // and the click play/pause feature + std::mutex connection_lock_; + unique_connection connection_; + // The alternate connection will be used to wait for events: since it will + // be blocking (idle) we can't send commands via this connection + // + // No lock since only used in the event listener thread + unique_connection alternate_connection_; + + // Protect them using the `connection_lock_` + unique_status status_; + mpd_state state_; + unique_song song_; +}; + +} // namespace waybar::modules diff --git a/meson.build b/meson.build index 9438518..2898e4e 100644 --- a/meson.build +++ b/meson.build @@ -56,6 +56,7 @@ libnl = dependency('libnl-3.0', required: get_option('libnl')) libnlgen = dependency('libnl-genl-3.0', required: get_option('libnl')) libpulse = dependency('libpulse', required: get_option('pulseaudio')) libudev = dependency('libudev', required: get_option('libudev')) +libmpdclient = dependency('libmpdclient', required: get_option('mpd')) src_files = files( 'src/factory.cpp', @@ -107,6 +108,11 @@ if libudev.found() src_files += 'src/modules/backlight.cpp' endif +if libmpdclient.found() + add_project_arguments('-DHAVE_LIBMPDCLIENT', language: 'cpp') + src_files += 'src/modules/mpd.cpp' +endif + subdir('protocol') executable( @@ -128,7 +134,8 @@ executable( libnl, libnlgen, libpulse, - libudev + libudev, + libmpdclient ], include_directories: [include_directories('include')], install: true, diff --git a/meson_options.txt b/meson_options.txt index 4c2f03a..f49d9c1 100644 --- a/meson_options.txt +++ b/meson_options.txt @@ -2,4 +2,5 @@ option('libnl', type: 'feature', value: 'auto', description: 'Enable libnl suppo option('libudev', type: 'feature', value: 'auto', description: 'Enable libudev support for udev related features') option('pulseaudio', type: 'feature', value: 'auto', description: 'Enable support for pulseaudio') option('dbusmenu-gtk', type: 'feature', value: 'auto', description: 'Enable support for tray') +option('mpd', type: 'feature', value: 'auto', description: 'Enable support for the Music Player Daemon') option('out', type: 'string', value : '/', description: 'output prefix directory') diff --git a/resources/config b/resources/config index 8b4a4be..c06ec1a 100644 --- a/resources/config +++ b/resources/config @@ -6,7 +6,7 @@ // Choose the order of the modules "modules-left": ["sway/workspaces", "sway/mode", "custom/media"], "modules-center": ["sway/window"], - "modules-right": ["idle_inhibitor", "pulseaudio", "network", "cpu", "memory", "temperature", "backlight", "battery", "battery#bat2", "clock", "tray"], + "modules-right": ["mpd", "idle_inhibitor", "pulseaudio", "network", "cpu", "memory", "temperature", "backlight", "battery", "battery#bat2", "clock", "tray"], // Modules configuration // "sway/workspaces": { // "disable-scroll": true, @@ -26,6 +26,31 @@ "sway/mode": { "format": "{}" }, + "mpd": { + "format": "{stateIcon} {consumeIcon}{randomIcon}{repeatIcon}{singleIcon}{artist} - {album} - {title} ({elapsedTime:%M:%S}/{totalTime:%M:%S}) ", + "format-disconnected": "Disconnected ", + "format-stopped": "{consumeIcon}{randomIcon}{repeatIcon}{singleIcon}Stopped ", + "interval": 2, + "consume-icons": { + "on": " " + }, + "random-icons": { + "off": " ", + "on": " " + }, + "repeat-icons": { + "on": " " + }, + "single-icons": { + "on": "1 " + }, + "state-icons": { + "paused": "", + "playing": "" + }, + "tooltip-format": "MPD (connected)", + "tooltip-format-disconnected": "MPD (disconnected)" + } "idle_inhibitor": { "format": "{icon}", "format-icons": { diff --git a/resources/style.css b/resources/style.css index 2a6f9be..c29569a 100644 --- a/resources/style.css +++ b/resources/style.css @@ -138,3 +138,20 @@ window#waybar.hidded { background-color: #ecf0f1; color: #2d3436; } + +#mpd { + background: #66cc99; + color: #2a5c45; +} + +#mpd.disconnected { + background: #f53c3c; +} + +#mpd.stopped { + background: #90b1b1; +} + +#mpd.paused { + background: #51a37a; +} diff --git a/src/factory.cpp b/src/factory.cpp index 11e3db2..067ecac 100644 --- a/src/factory.cpp +++ b/src/factory.cpp @@ -56,6 +56,11 @@ waybar::IModule* waybar::Factory::makeModule(const std::string &name) const return new waybar::modules::Pulseaudio(id, config_[name]); } #endif + #ifdef HAVE_LIBMPDCLIENT + if (ref == "mpd") { + return new waybar::modules::MPD(id, config_[name]); + } + #endif if (ref == "temperature") { return new waybar::modules::Temperature(id, config_[name]); } diff --git a/src/modules/mpd.cpp b/src/modules/mpd.cpp new file mode 100644 index 0000000..ae3ca47 --- /dev/null +++ b/src/modules/mpd.cpp @@ -0,0 +1,305 @@ +#include "modules/mpd.hpp" + +#include +#include + +waybar::modules::MPD::MPD(const std::string& id, const Json::Value& config) + : ALabel(config, "{album} - {artist} - {title}", 5), + module_name_(id.empty() ? "mpd" : "mpd#" + id), + server_(nullptr), + port_(config["port"].asUInt()), + connection_(nullptr, &mpd_connection_free), + alternate_connection_(nullptr, &mpd_connection_free), + status_(nullptr, &mpd_status_free), + song_(nullptr, &mpd_song_free) { + label_.set_name("mpd"); + if (!id.empty()) { + label_.get_style_context()->add_class(id); + } + + if (!config["server"].isNull()) { + server_ = config["server"].asCString(); + } + + event_listener().detach(); + + event_box_.add_events(Gdk::BUTTON_PRESS_MASK); + event_box_.signal_button_press_event().connect(sigc::mem_fun(*this, &MPD::handlePlayPause)); +} + +auto waybar::modules::MPD::update() -> void { + std::lock_guard guard(connection_lock_); + tryConnect(); + + if (connection_ != nullptr) { + try { + bool wasPlaying = playing(); + fetchState(); + if (!wasPlaying && playing()) { + periodic_updater().detach(); + } + } catch (const std::exception& e) { + std::cerr << module_name_ + ": " + e.what() << std::endl; + state_ = MPD_STATE_UNKNOWN; + } + } + + setLabel(); +} + +std::thread waybar::modules::MPD::event_listener() { + return std::thread([this] { + while (true) { + if (connection_ == nullptr) { + // Retry periodically if no connection + try { + update(); + } catch (const std::exception& e) { + std::cerr << module_name_ + ": " + e.what() << std::endl; + } + std::this_thread::sleep_for(interval_); + } else { + waitForEvent(); + dp.emit(); + } + } + }); +} + +std::thread waybar::modules::MPD::periodic_updater() { + return std::thread([this] { + while (connection_ != nullptr && playing()) { + dp.emit(); + std::this_thread::sleep_for(std::chrono::seconds(1)); + } + }); +} + +void waybar::modules::MPD::setLabel() { + if (connection_ == nullptr) { + label_.get_style_context()->add_class("disconnected"); + // In the case connection closed while MPD is stopped + label_.get_style_context()->remove_class("stopped"); + + auto format = config_["format-disconnected"].isString() + ? config_["format-disconnected"].asString() + : "disconnected"; + label_.set_markup(format); + + if (tooltipEnabled()) { + std::string tooltip_format; + tooltip_format = config_["tooltip-format-disconnected"].isString() + ? config_["tooltip-format-disconnected"].asString() + : "MPD (disconnected)"; + // Nothing to format + label_.set_tooltip_text(tooltip_format); + } + return; + } else { + label_.get_style_context()->remove_class("disconnected"); + } + + auto format = format_; + + std::string artist, album_artist, album, title, date; + std::chrono::seconds elapsedTime, totalTime; + + std::string stateIcon = ""; + if (stopped()) { + format = + config_["format-stopped"].isString() ? config_["format-stopped"].asString() : "stopped"; + label_.get_style_context()->add_class("stopped"); + label_.get_style_context()->remove_class("playing"); + label_.get_style_context()->remove_class("paused"); + } else { + label_.get_style_context()->remove_class("stopped"); + if (playing()) { + label_.get_style_context()->add_class("playing"); + label_.get_style_context()->remove_class("paused"); + } else { + label_.get_style_context()->add_class("paused"); + label_.get_style_context()->remove_class("playing"); + } + + stateIcon = getStateIcon(); + + artist = mpd_song_get_tag(song_.get(), MPD_TAG_ARTIST, 0); + album_artist = mpd_song_get_tag(song_.get(), MPD_TAG_ALBUM_ARTIST, 0); + album = mpd_song_get_tag(song_.get(), MPD_TAG_ALBUM, 0); + title = mpd_song_get_tag(song_.get(), MPD_TAG_TITLE, 0); + date = mpd_song_get_tag(song_.get(), MPD_TAG_DATE, 0); + elapsedTime = std::chrono::seconds(mpd_status_get_elapsed_time(status_.get())); + totalTime = std::chrono::seconds(mpd_status_get_total_time(status_.get())); + } + + bool consumeActivated = mpd_status_get_consume(status_.get()); + std::string consumeIcon = getOptionIcon("consume", consumeActivated); + bool randomActivated = mpd_status_get_random(status_.get()); + std::string randomIcon = getOptionIcon("random", randomActivated); + bool repeatActivated = mpd_status_get_repeat(status_.get()); + std::string repeatIcon = getOptionIcon("repeat", repeatActivated); + bool singleActivated = mpd_status_get_single(status_.get()); + std::string singleIcon = getOptionIcon("single", singleActivated); + + // TODO: format can fail + label_.set_markup(fmt::format(format, + fmt::arg("artist", artist), + fmt::arg("albumArtist", album_artist), + fmt::arg("album", album), + fmt::arg("title", title), + fmt::arg("date", date), + fmt::arg("elapsedTime", elapsedTime), + fmt::arg("totalTime", totalTime), + fmt::arg("stateIcon", stateIcon), + fmt::arg("consumeIcon", consumeIcon), + fmt::arg("randomIcon", randomIcon), + fmt::arg("repeatIcon", repeatIcon), + fmt::arg("singleIcon", singleIcon))); + + if (tooltipEnabled()) { + std::string tooltip_format; + tooltip_format = config_["tooltip-format"].isString() ? config_["tooltip-format"].asString() + : "MPD (connected)"; + auto tooltip_text = fmt::format(tooltip_format, + fmt::arg("artist", artist), + fmt::arg("albumArtist", album_artist), + fmt::arg("album", album), + fmt::arg("title", title), + fmt::arg("date", date), + 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); + } +} + +std::string waybar::modules::MPD::getStateIcon() { + if (!config_["state-icons"].isObject()) { + return ""; + } + + if (connection_ == nullptr) { + std::cerr << module_name_ << ": Trying to fetch state icon while disconnected" << std::endl; + return ""; + } + + if (stopped()) { + std::cerr << module_name_ << ": Trying to fetch state icon while stopped" << std::endl; + return ""; + } + + if (playing()) { + return config_["state-icons"]["playing"].asString(); + } else { + return config_["state-icons"]["paused"].asString(); + } +} + +std::string waybar::modules::MPD::getOptionIcon(std::string optionName, bool activated) { + if (!config_[optionName + "-icons"].isObject()) { + return ""; + } + + if (connection_ == nullptr) { + std::cerr << module_name_ << ": Trying to fetch option icon while disconnected" << std::endl; + return ""; + } + + if (activated) { + return config_[optionName + "-icons"]["on"].asString(); + } else { + return config_[optionName + "-icons"]["off"].asString(); + } +} + +void waybar::modules::MPD::tryConnect() { + if (connection_ != nullptr) { + return; + } + + connection_ = unique_connection(mpd_connection_new(server_, port_, 5'000), &mpd_connection_free); + + alternate_connection_ = + unique_connection(mpd_connection_new(server_, port_, 5'000), &mpd_connection_free); + + if (connection_ == nullptr || alternate_connection_ == nullptr) { + std::cerr << module_name_ << ": Failed to connect to MPD" << std::endl; + connection_.reset(); + alternate_connection_.reset(); + return; + } + + try { + checkErrors(connection_.get()); + } catch (std::runtime_error e) { + std::cerr << module_name_ << ": Failed to connect to MPD: " << e.what() << std::endl; + connection_.reset(); + alternate_connection_.reset(); + } +} + +void waybar::modules::MPD::checkErrors(mpd_connection* conn) { + switch (mpd_connection_get_error(conn)) { + case MPD_ERROR_SUCCESS: + return; + case MPD_ERROR_CLOSED: + std::cerr << module_name_ << ": Connection to MPD closed" << std::endl; + mpd_connection_clear_error(conn); + connection_.reset(); + alternate_connection_.reset(); + state_ = MPD_STATE_UNKNOWN; + return; + default: + auto error_message = mpd_connection_get_error_message(conn); + mpd_connection_clear_error(conn); + throw std::runtime_error(std::string(error_message)); + } +} + +void waybar::modules::MPD::fetchState() { + auto conn = connection_.get(); + status_ = unique_status(mpd_run_status(conn), &mpd_status_free); + checkErrors(conn); + state_ = mpd_status_get_state(status_.get()); + checkErrors(conn); + + song_ = unique_song(mpd_run_current_song(conn), &mpd_song_free); + checkErrors(conn); +} + +void waybar::modules::MPD::waitForEvent() { + auto conn = alternate_connection_.get(); + // Wait for a player (play/pause), option (random, shuffle, etc.), or playlist + // change + mpd_run_idle_mask(conn, + static_cast(MPD_IDLE_PLAYER | MPD_IDLE_OPTIONS | MPD_IDLE_PLAYLIST)); + checkErrors(conn); +} + +bool waybar::modules::MPD::handlePlayPause(GdkEventButton* const& e) { + if (e->type == GDK_2BUTTON_PRESS || e->type == GDK_3BUTTON_PRESS || connection_ == nullptr) { + return false; + } + + if (e->button == 1) { + std::lock_guard guard(connection_lock_); + if (stopped()) { + mpd_run_play(connection_.get()); + } else { + mpd_run_toggle_pause(connection_.get()); + } + } else if (e->button == 3) { + std::lock_guard guard(connection_lock_); + mpd_run_stop(connection_.get()); + } + + return true; +} + +bool waybar::modules::MPD::stopped() { + return connection_ == nullptr || state_ == MPD_STATE_UNKNOWN || state_ == MPD_STATE_STOP; +} + +bool waybar::modules::MPD::playing() { return connection_ != nullptr && state_ == MPD_STATE_PLAY; }