Merge pull request #1145 from alebastr/sni-enhancements

tray module enhancements

include/modules/sni/item.hpp

@@ -11,8 +11,16 @@
 #include <libdbusmenu-gtk/dbusmenu-gtk.h>
 #include <sigc++/trackable.h>
 
+#include <set>
+#include <string_view>
+
 namespace waybar::modules::SNI {
 
+struct ToolTip {
+  Glib::ustring icon_name;
+  Glib::ustring text;
+};
+
 class Item : public sigc::trackable {
  public:
   Item(const std::string&, const std::string&, const Json::Value&);
@@ -27,10 +35,8 @@ class Item : public sigc::trackable {
   Gtk::EventBox event_box;
   std::string   category;
   std::string   id;
-  std::string   status;
 
   std::string                  title;
-  int32_t                      window_id;
   std::string                  icon_name;
   Glib::RefPtr<Gdk::Pixbuf>    icon_pixmap;
   Glib::RefPtr<Gtk::IconTheme> icon_theme;
@@ -39,6 +45,7 @@ class Item : public sigc::trackable {
   std::string                  attention_movie_name;
   std::string                  icon_theme_path;
   std::string                  menu;
+  ToolTip                      tooltip;
   DbusmenuGtkMenu*             dbus_menu = nullptr;
   Gtk::Menu*                   gtk_menu = nullptr;
   /**
@@ -51,6 +58,7 @@ class Item : public sigc::trackable {
  private:
   void proxyReady(Glib::RefPtr<Gio::AsyncResult>& result);
   void setProperty(const Glib::ustring& name, Glib::VariantBase& value);
+  void setStatus(const Glib::ustring& value);
   void getUpdatedProperties();
   void processUpdatedProperties(Glib::RefPtr<Gio::AsyncResult>& result);
   void onSignal(const Glib::ustring& sender_name, const Glib::ustring& signal_name,
@@ -62,10 +70,18 @@ class Item : public sigc::trackable {
   static void               onMenuDestroyed(Item* self, GObject* old_menu_pointer);
   void                      makeMenu();
   bool                      handleClick(GdkEventButton* const& /*ev*/);
+  bool                      handleScroll(GdkEventScroll* const&);
+
+  // smooth scrolling threshold
+  gdouble scroll_threshold_ = 0;
+  gdouble distance_scrolled_x_ = 0;
+  gdouble distance_scrolled_y_ = 0;
+  // visibility of items with Status == Passive
+  bool show_passive_ = false;
 
   Glib::RefPtr<Gio::DBus::Proxy> proxy_;
   Glib::RefPtr<Gio::Cancellable> cancellable_;
-  bool                           update_pending_;
+  std::set<std::string_view>     update_pending_;
 };
 
 }  // namespace waybar::modules::SNI

man/waybar-tray.5.scd

@@ -16,6 +16,15 @@ Addressed by *tray*
     typeof: integer ++
     Defines the size of the tray icons.
 
+*show-passive-items*: ++
+    typeof: bool ++
+    default: false ++
+    Defines visibility of the tray icons with *Passive* status.
+
+*smooth-scrolling-threshold*: ++
+	typeof: double ++
+	Threshold to be used when scrolling.
+
 *spacing*: ++
     typeof: integer ++
     Defines the spacing between the tray icons.
@@ -37,3 +46,6 @@ Addressed by *tray*
 # STYLE
 
 - *#tray*
+- *#tray > .passive*
+- *#tray > .active*
+- *#tray > .needs-attention*

resources/style.css

@@ -195,6 +195,15 @@ label:focus {
     background-color: #2980b9;
 }
 
+#tray > .passive {
+    -gtk-icon-effect: dim;
+}
+
+#tray > .needs-attention {
+    -gtk-icon-effect: highlight;
+    background-color: #eb4d4b;
+}
+
 #idle_inhibitor {
     background-color: #2d3436;
 }

src/modules/sni/item.cpp

@@ -1,8 +1,12 @@
 #include "modules/sni/item.hpp"
+
 #include <gdkmm/general.h>
 #include <glibmm/main.h>
+#include <gtkmm/tooltip.h>
 #include <spdlog/spdlog.h>
+
 #include <fstream>
+#include <map>
 
 template <>
 struct fmt::formatter<Glib::ustring> : formatter<std::string> {
@@ -40,14 +44,22 @@ Item::Item(const std::string& bn, const std::string& op, const Json::Value& conf
       object_path(op),
       icon_size(16),
       effective_icon_size(0),
-      icon_theme(Gtk::IconTheme::create()),
+      icon_theme(Gtk::IconTheme::create()) {
-      update_pending_(false) {
   if (config["icon-size"].isUInt()) {
     icon_size = config["icon-size"].asUInt();
   }
+  if (config["smooth-scrolling-threshold"].isNumeric()) {
+    scroll_threshold_ = config["smooth-scrolling-threshold"].asDouble();
+  }
+  if (config["show-passive-items"].isBool()) {
+    show_passive_ = config["show-passive-items"].asBool();
+  }
   event_box.add(image);
-  event_box.add_events(Gdk::BUTTON_PRESS_MASK);
+  event_box.add_events(Gdk::BUTTON_PRESS_MASK | Gdk::SCROLL_MASK | Gdk::SMOOTH_SCROLL_MASK);
   event_box.signal_button_press_event().connect(sigc::mem_fun(*this, &Item::handleClick));
+  event_box.signal_scroll_event().connect(sigc::mem_fun(*this, &Item::handleScroll));
+  // initial visibility
+  event_box.set_visible(show_passive_);
 
   cancellable_ = Gio::Cancellable::create();
 
@@ -74,12 +86,11 @@ void Item::proxyReady(Glib::RefPtr<Gio::AsyncResult>& result) {
 
     this->proxy_->signal_signal().connect(sigc::mem_fun(*this, &Item::onSignal));
 
-    if (this->id.empty() || this->category.empty() || this->status.empty()) {
+    if (this->id.empty() || this->category.empty()) {
       spdlog::error("Invalid Status Notifier Item: {}, {}", bus_name, object_path);
       return;
     }
     this->updateImage();
-    // this->event_box.set_tooltip_text(this->title);
 
   } catch (const Glib::Error& err) {
     spdlog::error("Failed to create DBus Proxy for {} {}: {}", bus_name, object_path, err.what());
@@ -89,10 +100,24 @@ void Item::proxyReady(Glib::RefPtr<Gio::AsyncResult>& result) {
 }
 
 template <typename T>
-T get_variant(Glib::VariantBase& value) {
+T get_variant(const Glib::VariantBase& value) {
   return Glib::VariantBase::cast_dynamic<Glib::Variant<T>>(value).get();
 }
 
+template <>
+ToolTip get_variant<ToolTip>(const Glib::VariantBase& value) {
+  ToolTip result;
+  // Unwrap (sa(iiay)ss)
+  auto container = value.cast_dynamic<Glib::VariantContainerBase>(value);
+  result.icon_name = get_variant<Glib::ustring>(container.get_child(0));
+  result.text = get_variant<Glib::ustring>(container.get_child(2));
+  auto description = get_variant<Glib::ustring>(container.get_child(3));
+  if (!description.empty()) {
+    result.text = fmt::format("<b>{}</b>\n{}", result.text, description);
+  }
+  return result;
+}
+
 void Item::setProperty(const Glib::ustring& name, Glib::VariantBase& value) {
   try {
     spdlog::trace("Set tray item property: {}.{} = {}", id.empty() ? bus_name : id, name, value);
@@ -103,10 +128,11 @@ void Item::setProperty(const Glib::ustring& name, Glib::VariantBase& value) {
       id = get_variant<std::string>(value);
     } else if (name == "Title") {
       title = get_variant<std::string>(value);
+      if (tooltip.text.empty()) {
+        event_box.set_tooltip_markup(title);
+      }
     } else if (name == "Status") {
-      status = get_variant<std::string>(value);
+      setStatus(get_variant<Glib::ustring>(value));
-    } else if (name == "WindowId") {
-      window_id = get_variant<int32_t>(value);
     } else if (name == "IconName") {
       icon_name = get_variant<std::string>(value);
     } else if (name == "IconPixmap") {
@@ -122,7 +148,10 @@ void Item::setProperty(const Glib::ustring& name, Glib::VariantBase& value) {
     } else if (name == "AttentionMovieName") {
       attention_movie_name = get_variant<std::string>(value);
     } else if (name == "ToolTip") {
-      // TODO: tooltip
+      tooltip = get_variant<ToolTip>(value);
+      if (!tooltip.text.empty()) {
+        event_box.set_tooltip_markup(tooltip.text);
+      }
     } else if (name == "IconThemePath") {
       icon_theme_path = get_variant<std::string>(value);
       if (!icon_theme_path.empty()) {
@@ -149,9 +178,22 @@ void Item::setProperty(const Glib::ustring& name, Glib::VariantBase& value) {
   }
 }
 
-void Item::getUpdatedProperties() {
+void Item::setStatus(const Glib::ustring& value) {
-  update_pending_ = false;
+  Glib::ustring lower = value.lowercase();
+  event_box.set_visible(show_passive_ || lower.compare("passive") != 0);
 
+  auto style = event_box.get_style_context();
+  for (const auto& class_name : style->list_classes()) {
+    style->remove_class(class_name);
+  }
+  if (lower.compare("needsattention") == 0) {
+    // convert status to dash-case for CSS
+    lower = "needs-attention";
+  }
+  style->add_class(lower);
+}
+
+void Item::getUpdatedProperties() {
   auto params = Glib::VariantContainerBase::create_tuple(
       {Glib::Variant<Glib::ustring>::create(SNI_INTERFACE_NAME)});
   proxy_->call("org.freedesktop.DBus.Properties.GetAll",
@@ -168,34 +210,49 @@ void Item::processUpdatedProperties(Glib::RefPtr<Gio::AsyncResult>& _result) {
     auto properties = properties_variant.get();
 
     for (const auto& [name, value] : properties) {
-      Glib::VariantBase old_value;
+      if (update_pending_.count(name.raw())) {
-      proxy_->get_cached_property(old_value, name);
-      if (!old_value || !value.equal(old_value)) {
-        proxy_->set_cached_property(name, value);
         setProperty(name, const_cast<Glib::VariantBase&>(value));
       }
     }
 
     this->updateImage();
-    // this->event_box.set_tooltip_text(this->title);
   } catch (const Glib::Error& err) {
     spdlog::warn("Failed to update properties: {}", err.what());
   } catch (const std::exception& err) {
     spdlog::warn("Failed to update properties: {}", err.what());
   }
+  update_pending_.clear();
 }
 
+/**
+ * Mapping from a signal name to a set of possibly changed properties.
+ * Commented signals are not handled by the tray module at the moment.
+ */
+static const std::map<std::string_view, std::set<std::string_view>> signal2props = {
+    {"NewTitle", {"Title"}},
+    {"NewIcon", {"IconName", "IconPixmap"}},
+    // {"NewAttentionIcon", {"AttentionIconName", "AttentionIconPixmap", "AttentionMovieName"}},
+    // {"NewOverlayIcon", {"OverlayIconName", "OverlayIconPixmap"}},
+    {"NewIconThemePath", {"IconThemePath"}},
+    {"NewToolTip", {"ToolTip"}},
+    {"NewStatus", {"Status"}},
+    // {"XAyatanaNewLabel", {"XAyatanaLabel"}},
+};
+
 void Item::onSignal(const Glib::ustring& sender_name, const Glib::ustring& signal_name,
                     const Glib::VariantContainerBase& arguments) {
   spdlog::trace("Tray item '{}' got signal {}", id, signal_name);
-  if (!update_pending_ && signal_name.compare(0, 3, "New") == 0) {
+  auto changed = signal2props.find(signal_name.raw());
+  if (changed != signal2props.end()) {
+    if (update_pending_.empty()) {
       /* Debounce signals and schedule update of all properties.
        * Based on behavior of Plasma dataengine for StatusNotifierItem.
        */
-    update_pending_ = true;
       Glib::signal_timeout().connect_once(sigc::mem_fun(*this, &Item::getUpdatedProperties),
                                           UPDATE_DEBOUNCE_TIME);
     }
+    update_pending_.insert(changed->second.begin(), changed->second.end());
+  }
 }
 
 static void pixbuf_data_deleter(const guint8* data) { g_free((void*)data); }
@@ -370,4 +427,52 @@ bool Item::handleClick(GdkEventButton* const& ev) {
   return false;
 }
 
+bool Item::handleScroll(GdkEventScroll* const& ev) {
+  int dx = 0, dy = 0;
+  switch (ev->direction) {
+    case GDK_SCROLL_UP:
+      dy = -1;
+      break;
+    case GDK_SCROLL_DOWN:
+      dy = 1;
+      break;
+    case GDK_SCROLL_LEFT:
+      dx = -1;
+      break;
+    case GDK_SCROLL_RIGHT:
+      dx = 1;
+      break;
+    case GDK_SCROLL_SMOOTH:
+      distance_scrolled_x_ += ev->delta_x;
+      distance_scrolled_y_ += ev->delta_y;
+      // check against the configured threshold and ensure that the absolute value >= 1
+      if (distance_scrolled_x_ > scroll_threshold_) {
+        dx = (int)lround(std::max(distance_scrolled_x_, 1.0));
+        distance_scrolled_x_ = 0;
+      } else if (distance_scrolled_x_ < -scroll_threshold_) {
+        dx = (int)lround(std::min(distance_scrolled_x_, -1.0));
+        distance_scrolled_x_ = 0;
+      }
+      if (distance_scrolled_y_ > scroll_threshold_) {
+        dy = (int)lround(std::max(distance_scrolled_y_, 1.0));
+        distance_scrolled_y_ = 0;
+      } else if (distance_scrolled_y_ < -scroll_threshold_) {
+        dy = (int)lround(std::min(distance_scrolled_y_, -1.0));
+        distance_scrolled_y_ = 0;
+      }
+      break;
+  }
+  if (dx != 0) {
+    auto parameters = Glib::VariantContainerBase::create_tuple(
+        {Glib::Variant<int>::create(dx), Glib::Variant<Glib::ustring>::create("horizontal")});
+    proxy_->call("Scroll", parameters);
+  }
+  if (dy != 0) {
+    auto parameters = Glib::VariantContainerBase::create_tuple(
+        {Glib::Variant<int>::create(dy), Glib::Variant<Glib::ustring>::create("vertical")});
+    proxy_->call("Scroll", parameters);
+  }
+  return true;
+}
+
 }  // namespace waybar::modules::SNI