(sni) Be able to control order for system tray items.

Author: yangyingchao

include/modules/sni/host.hpp

@@ -14,16 +14,18 @@ namespace waybar::modules::SNI {
 
 class Host {
  public:
-  Host(const std::size_t id, const Json::Value&, const Bar&,
+  Host(std::size_t id, const Json::Value&, const Bar&,
        const std::function<void(std::unique_ptr<Item>&)>&,
        const std::function<void(std::unique_ptr<Item>&)>&, const std::function<void()>&);
   ~Host();
 
+  void reorderItems();
+
  private:
-  void busAcquired(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring);
-  void nameAppeared(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring,
+  void busAcquired(const Glib::RefPtr<Gio::DBus::Connection>&, const Glib::ustring&);
+  void nameAppeared(const Glib::RefPtr<Gio::DBus::Connection>&, const Glib::ustring&,
                     const Glib::ustring&);
-  void nameVanished(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring);
+  void nameVanished(const Glib::RefPtr<Gio::DBus::Connection>&, const Glib::ustring&);
   static void proxyReady(GObject*, GAsyncResult*, gpointer);
   static void registerHost(GObject*, GAsyncResult*, gpointer);
   static void itemRegistered(SnWatcher*, const gchar*, gpointer);
@@ -33,7 +35,7 @@ class Host {
   void removeItem(std::vector<std::unique_ptr<Item>>::iterator);
   void clearItems();
 
-  std::tuple<std::string, std::string> getBusNameAndObjectPath(const std::string);
+  static std::tuple<std::string, std::string> getBusNameAndObjectPath(const std::string&);
   void addRegisteredItem(const std::string& service);
 
   std::vector<std::unique_ptr<Item>> items_;
@@ -47,6 +49,8 @@ class Host {
   const Bar& bar_;
   const std::function<void(std::unique_ptr<Item>&)> on_add_;
   const std::function<void(std::unique_ptr<Item>&)> on_remove_;
+
+  ItemOrderMap orders_;
   const std::function<void()> on_update_;
 };
 

include/modules/sni/item.hpp

@@ -24,11 +24,15 @@ struct ToolTip {
   Glib::ustring text;
 };
 
+class Host;
+
+using ItemOrderMap = std::unordered_map<std::string, int>;
+
 class Item : public sigc::trackable {
  public:
   Item(const std::string&, const std::string&, const Json::Value&, const Bar&,
        const std::function<void(Item&)>&, const std::function<void(Item&)>&,
-       const std::function<void()>&);
+       const std::function<void()>&, Host&, const ItemOrderMap&);
   ~Item();
 
   bool isReady() const;
@@ -63,6 +67,7 @@ class Item : public sigc::trackable {
    * while compliant SNI implementation would always reset the flag to desired value.
    */
   bool item_is_menu = true;
+  int order_ = -1;  // -1 means not set
 
  private:
   void onConfigure(GdkEventConfigure* ev);
@@ -111,6 +116,9 @@ class Item : public sigc::trackable {
   Glib::RefPtr<Gio::DBus::Proxy> proxy_;
   Glib::RefPtr<Gio::Cancellable> cancellable_;
   std::set<std::string_view> update_pending_;
+
+  Host& host_;
+  const ItemOrderMap& orders_;
 };
 
 }  // namespace waybar::modules::SNI

include/modules/sni/tray.hpp

@@ -13,7 +13,7 @@ namespace waybar::modules::SNI {
 class Tray : public AModule {
  public:
   Tray(const std::string&, const Bar&, const Json::Value&);
-  virtual ~Tray() = default;
+  ~Tray() override = default ;
   auto update() -> void override;
 
  private:

man/waybar-tray.5.scd

@@ -42,6 +42,13 @@ Addressed by *tray*
 	default: false ++
 	Enables this module to consume all left over space dynamically.
 
+*orders*: ++
+	typeof: object ++
+	Ordres for items to be placed in tray. When not set, orders are controlled by DBus.
+	Key: name of item.
+	Value: integer, higher value means to place this item to the right.
+
+
 # EXAMPLES
 
 ```
@@ -51,6 +58,9 @@ Addressed by *tray*
   "icons": {
     "blueman": "bluetooth",
     "TelegramDesktop": "$HOME/.local/share/icons/hicolor/16x16/apps/telegram.png"
+  },
+    "orders" : {
+    "wechat" : 99
   }
 }
 

src/modules/sni/host.cpp

@@ -2,11 +2,14 @@
 
 #include <spdlog/spdlog.h>
 
+#include <algorithm>
+
+#include "modules/sni/item.hpp"
 #include "util/scope_guard.hpp"
 
 namespace waybar::modules::SNI {
 
-Host::Host(const std::size_t id, const Json::Value& config, const Bar& bar,
+Host::Host(std::size_t id, const Json::Value& config, const Bar& bar,
            const std::function<void(std::unique_ptr<Item>&)>& on_add,
            const std::function<void(std::unique_ptr<Item>&)>& on_remove,
            const std::function<void()>& on_update)
@@ -19,7 +22,18 @@ Host::Host(const std::size_t id, const Json::Value& config, const Bar& bar,
       bar_(bar),
       on_add_(on_add),
       on_remove_(on_remove),
-      on_update_(on_update) {}
+      on_update_(on_update) {
+  auto orders = config["orders"];
+  if (!orders.isNull()) {
+    for (auto itr = orders.begin(); itr != orders.end(); ++itr) {
+      auto key = itr.name();
+      auto& value = *itr;
+      assert(value.isInt());
+
+      orders_[key] = value.asInt();
+    }
+  }
+}
 
 Host::~Host() {
   if (bus_name_id_ > 0) {
@@ -35,13 +49,13 @@ Host::~Host() {
   g_clear_object(&watcher_);
 }
 
-void Host::busAcquired(const Glib::RefPtr<Gio::DBus::Connection>& conn, Glib::ustring name) {
+void Host::busAcquired(const Glib::RefPtr<Gio::DBus::Connection>& conn, const Glib::ustring& name) {
   watcher_id_ = Gio::DBus::watch_name(conn, "org.kde.StatusNotifierWatcher",
                                       sigc::mem_fun(*this, &Host::nameAppeared),
                                       sigc::mem_fun(*this, &Host::nameVanished));
 }
 
-void Host::nameAppeared(const Glib::RefPtr<Gio::DBus::Connection>& conn, const Glib::ustring name,
+void Host::nameAppeared(const Glib::RefPtr<Gio::DBus::Connection>& conn, const Glib::ustring& name,
                         const Glib::ustring& name_owner) {
   if (cancellable_ != nullptr) {
     // TODO
@@ -52,7 +66,8 @@ void Host::nameAppeared(const Glib::RefPtr<Gio::DBus::Connection>& conn, const G
                        "/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) {
   g_cancellable_cancel(cancellable_);
   g_clear_object(&cancellable_);
   g_clear_object(&watcher_);
@@ -67,11 +82,11 @@ void Host::proxyReady(GObject* src, GAsyncResult* res, gpointer data) {
     }
   });
   SnWatcher* watcher = sn_watcher_proxy_new_finish(res, &error);
-  if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
+  if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED) != 0) {
     spdlog::error("Host: {}", error->message);
     return;
   }
-  auto host = static_cast<SNI::Host*>(data);
+  auto* host = static_cast<SNI::Host*>(data);
   host->watcher_ = watcher;
   if (error != nullptr) {
     spdlog::error("Host: {}", error->message);
@@ -89,18 +104,18 @@ void Host::registerHost(GObject* src, GAsyncResult* res, gpointer data) {
     }
   });
   sn_watcher_call_register_host_finish(SN_WATCHER(src), res, &error);
-  if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
+  if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED) != 0) {
     spdlog::error("Host: {}", error->message);
     return;
   }
-  auto host = static_cast<SNI::Host*>(data);
+  auto* host = static_cast<SNI::Host*>(data);
   if (error != nullptr) {
     spdlog::error("Host: {}", error->message);
     return;
   }
   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_);
+  auto* items = sn_watcher_dup_registered_items(host->watcher_);
   if (items != nullptr) {
     for (uint32_t i = 0; items[i] != nullptr; i += 1) {
       host->addRegisteredItem(items[i]);
@@ -110,13 +125,13 @@ void Host::registerHost(GObject* src, GAsyncResult* res, gpointer data) {
 }
 
 void Host::itemRegistered(SnWatcher* watcher, const gchar* service, gpointer data) {
-  auto host = static_cast<SNI::Host*>(data);
+  auto* host = static_cast<SNI::Host*>(data);
   host->addRegisteredItem(service);
 }
 
 void Host::itemUnregistered(SnWatcher* watcher, const gchar* service, gpointer data) {
-  auto host = static_cast<SNI::Host*>(data);
-  auto [bus_name, object_path] = host->getBusNameAndObjectPath(service);
+  auto* host = static_cast<SNI::Host*>(data);
+  auto [bus_name, object_path] = waybar::modules::SNI::Host::getBusNameAndObjectPath(service);
   for (auto it = host->items_.begin(); it != host->items_.end(); ++it) {
     if ((*it)->bus_name == bus_name && (*it)->object_path == object_path) {
       host->removeItem(it);
@@ -163,7 +178,7 @@ void Host::clearItems() {
   }
 }
 
-std::tuple<std::string, std::string> Host::getBusNameAndObjectPath(const std::string service) {
+std::tuple<std::string, std::string> Host::getBusNameAndObjectPath(const std::string& service) {
   auto it = service.find('/');
   if (it != std::string::npos) {
     return {service.substr(0, it), service.substr(it)};
@@ -172,16 +187,25 @@ std::tuple<std::string, std::string> Host::getBusNameAndObjectPath(const std::st
 }
 
 void Host::addRegisteredItem(const std::string& service) {
-  std::string bus_name, object_path;
+  std::string bus_name;
+  std::string object_path;
   std::tie(bus_name, object_path) = getBusNameAndObjectPath(service);
-  auto it = std::find_if(items_.begin(), items_.end(), [&bus_name, &object_path](const auto& item) {
+  auto it = std::ranges::find_if(items_, [&bus_name, &object_path](const auto& item) {
     return bus_name == item->bus_name && object_path == item->object_path;
   });
   if (it == items_.end()) {
     items_.emplace_back(new Item(
         bus_name, object_path, config_, bar_, [this](Item& item) { itemReady(item); },
-        [this](Item& item) { itemInvalidated(item); }, on_update_));
+        [this](Item& item) { itemInvalidated(item); }, on_update_,  *this, orders_));
   }
 }
 
+void Host::reorderItems() {
+  std::ranges::for_each(items_, on_remove_);
+  std::ranges::sort(items_, [](std::unique_ptr<Item>& item1, std::unique_ptr<Item>& item2) {
+    return item1->order_ < item2->order_;
+  });
+  std::ranges::for_each(items_, on_add_);
+}
+
 }  // namespace waybar::modules::SNI

src/modules/sni/item.cpp

@@ -5,14 +5,17 @@
 #include <gtkmm/tooltip.h>
 #include <spdlog/spdlog.h>
 
+#include <cassert>
 #include <algorithm>
 #include <filesystem>
 #include <fstream>
 #include <map>
+#include <unordered_map>
 
 #include "gdk/gdk.h"
+#include "modules/sni/host.hpp"
 #include "modules/sni/icon_manager.hpp"
-#include "util/format.hpp"
+#include "util/format.hpp"  // IWYU pragma: keep
 #include "util/gtk_icon.hpp"
 
 template <>
@@ -40,7 +43,8 @@ static const unsigned UPDATE_DEBOUNCE_TIME = 10;
 
 Item::Item(const std::string& bn, const std::string& op, const Json::Value& config, const Bar& bar,
            const std::function<void(Item&)>& on_ready,
-           const std::function<void(Item&)>& on_invalidate, const std::function<void()>& on_updated)
+           const std::function<void(Item&)>& on_invalidate, const std::function<void()>& on_updated,
+           Host& host, const ItemOrderMap& orders)
     : bus_name(bn),
       object_path(op),
       icon_size(16),
@@ -49,7 +53,9 @@ Item::Item(const std::string& bn, const std::string& op, const Json::Value& conf
       bar_(bar),
       on_ready_(on_ready),
       on_invalidate_(on_invalidate),
-      on_updated_(on_updated) {
+      on_updated_(on_updated),
+      host_(host),
+      orders_(orders) {
   if (config["icon-size"].isUInt()) {
     icon_size = config["icon-size"].asUInt();
   }
@@ -263,6 +269,17 @@ void Item::invalidate() {
 void Item::setCustomIcon(const std::string& id) {
   spdlog::debug("SNI tray id: {}", id);
 
+  if (order_ == -1) {
+    auto iter = orders_.find(id);
+    if (iter != orders_.end()) {
+      order_ = iter->second;
+      spdlog::debug("reordering tray item {}, order: {}", id, order_);
+    } else {
+      order_ = 0;
+    }
+    host_.reorderItems();
+  }
+
   std::string custom_icon = IconManager::instance().getIconForApp(id);
   if (!custom_icon.empty()) {
     if (std::filesystem::exists(custom_icon)) {

src/modules/sni/tray.cpp

@@ -56,7 +56,7 @@ auto Tray::update() -> void {
   if (show_passive_) {
     event_box_.set_visible(!children.empty());
   } else {
-    event_box_.set_visible(!std::all_of(children.begin(), children.end(), [](Gtk::Widget* child) {
+    event_box_.set_visible(!std::ranges::all_of(children, [](Gtk::Widget* child) {
       return child->get_style_context()->has_class("passive");
     }));
   }