Enhancement/Taskbar

include/factory.hpp

@@ -4,6 +4,7 @@
 #include "modules/clock.hpp"
 #ifdef HAVE_SWAY
 #include "modules/sway/mode.hpp"
+#include "modules/sway/taskbar.hpp"
 #include "modules/sway/window.hpp"
 #include "modules/sway/workspaces.hpp"
 #endif

include/modules/sway/taskbar.hpp

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <fmt/format.h>
+#include <gtkmm/button.h>
+#include <gtkmm/image.h>
+#include <gtkmm/label.h>
+#include "IModule.hpp"
+#include "bar.hpp"
+#include "client.hpp"
+#include "modules/sway/ipc/client.hpp"
+#include "util/json.hpp"
+#include "util/sleeper_thread.hpp"
+#include <algorithm>
+#include <functional>
+
+namespace waybar::modules::sway {
+
+class TaskBar : public IModule, public sigc::trackable {
+ public:
+  TaskBar(const std::string&, const waybar::Bar&, const Json::Value&);
+  ~TaskBar() = default;
+  auto update() -> void;
+       operator Gtk::Widget&();
+
+ private:
+  void onCmd(const struct Ipc::ipc_response&);
+  void onEvent(const struct Ipc::ipc_response&);
+  void worker();
+  bool filterButtons();
+  void updateButtons();
+  struct Application {
+    int         id;
+    std::string display_name;
+    std::string instance_name;
+  };
+  Gtk::Button& addButton(const Application&);
+
+  void        onButtonReady(Gtk::Button&);
+  std::string getIcon(const std::string&);
+  const int   getCycleTasks(int current_focus, bool prev);
+  bool        handleScroll(GdkEventScroll*);
+  void        parseTree(const Json::Value&);
+  void        parseWorkspaceTree(const std::string& workspace_name, const Json::Value&);
+  void        parseWorkspaceTreeEntry(const std::string& workspace_name, const Json::Value&);
+  void        parseCurrentWorkspace(const Json::Value&);
+
+  struct WorkspaceMap {
+    int                      focused_num = 0;
+    std::vector<Application> applications;
+  };
+
+  const Bar&                           bar_;
+  const Json::Value&                   config_;
+  waybar::util::SleeperThread          thread_;
+  std::mutex                           mutex_;
+  Gtk::Box                             box_;
+  Ipc                                  ipc_;
+  util::JsonParser                     parser_;
+  bool                                 scrolling_;
+  std::unordered_map<int, Gtk::Button> buttons_;
+  std::string                          current_workspace;
+  std::map<std::string, WorkspaceMap>  taskMap_;
+};
+
+}  // namespace waybar::modules::sway

meson.build

@@ -84,7 +84,8 @@ if true # find_program('sway', required : false).found()
         'src/modules/sway/ipc/client.cpp',
         'src/modules/sway/mode.cpp',
         'src/modules/sway/window.cpp',
-        'src/modules/sway/workspaces.cpp'
+        'src/modules/sway/workspaces.cpp',
+        'src/modules/sway/taskbar.cpp'
     ]
 endif
 

src/factory.cpp

@@ -22,6 +22,9 @@ waybar::IModule* waybar::Factory::makeModule(const std::string& name) const {
     if (ref == "sway/window") {
       return new waybar::modules::sway::Window(id, bar_, config_[name]);
     }
+    if (ref == "sway/taskbar") {
+      return new waybar::modules::sway::TaskBar(id, bar_, config_[name]);
+    }
 #endif
     if (ref == "idle_inhibitor") {
       return new waybar::modules::IdleInhibitor(id, bar_, config_[name]);

src/modules/sway/taskbar.cpp

@@ -0,0 +1,277 @@
+#include "modules/sway/taskbar.hpp"
+#include <spdlog/spdlog.h>
+
+namespace waybar::modules::sway {
+
+TaskBar::TaskBar(const std::string& id, const Bar& bar, const Json::Value& config)
+    : bar_(bar),
+      config_(config),
+      box_(bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0),
+      scrolling_(false) {
+  box_.set_name("taskbar");
+  if (!id.empty()) {
+    box_.get_style_context()->add_class(id);
+  }
+  ipc_.subscribe(R"(["workspace", "window"])");
+  ipc_.signal_event.connect(sigc::mem_fun(*this, &TaskBar::onEvent));
+  ipc_.signal_cmd.connect(sigc::mem_fun(*this, &TaskBar::onCmd));
+  ipc_.sendCmd(IPC_GET_TREE);
+  if (!config["disable-bar-scroll"].asBool()) {
+    auto& window = const_cast<Bar&>(bar_).window;
+    window.add_events(Gdk::SCROLL_MASK | Gdk::SMOOTH_SCROLL_MASK);
+    window.signal_scroll_event().connect(sigc::mem_fun(*this, &TaskBar::handleScroll));
+  }
+  dp.emit();
+  worker();
+}
+
+void TaskBar::onEvent(const struct Ipc::ipc_response& res) {
+  try {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (static_cast<int>(res.type) == IPC_EVENT_WORKSPACE) {
+      auto payload = parser_.parse(res.payload);
+      if (taskMap_.empty()) {
+        ipc_.sendCmd(IPC_GET_TREE);
+      }
+      ipc_.sendCmd(IPC_GET_WORKSPACES);
+    } else if (static_cast<int>(res.type) == IPC_EVENT_WINDOW) {
+      ipc_.sendCmd(IPC_GET_TREE);
+    }
+
+    dp.emit();
+  } catch (const std::exception& e) {
+    spdlog::error("TaskBar: {}", e.what());
+  }
+}
+
+void TaskBar::onCmd(const struct Ipc::ipc_response& res) {
+  try {
+    auto payload = parser_.parse(res.payload);
+    if (res.type == IPC_GET_TREE) {
+      taskMap_.clear();
+      parseTree(payload);
+    }
+    if (res.type == IPC_GET_WORKSPACES) {
+      parseCurrentWorkspace(payload);
+    }
+
+  } catch (const std::exception& e) {
+    spdlog::error("TaskBar: {}", e.what());
+  }
+}
+
+void TaskBar::worker() {
+  thread_ = [this] {
+    try {
+      ipc_.handleEvent();
+    } catch (const std::exception& e) {
+      spdlog::error("TaskBar: {}", e.what());
+    }
+  };
+}
+bool TaskBar::filterButtons() {
+  bool needReorder = false;
+  for (auto it = buttons_.begin(); it != buttons_.end();) {
+    auto ws = std::find_if(taskMap_[current_workspace].applications.begin(),
+                           taskMap_[current_workspace].applications.end(),
+                           [it](const auto& value) { return value.id == it->first; });
+    if (ws == taskMap_[current_workspace].applications.end()) {
+      it = buttons_.erase(it);
+      needReorder = true;
+    } else {
+      ++it;
+    }
+  }
+  return needReorder;
+}
+
+auto TaskBar::update() -> void {
+  std::lock_guard<std::mutex> lock(mutex_);
+  bool                        needReorder = filterButtons();
+  if (current_workspace == "") current_workspace = taskMap_.begin()->first;
+  for (auto it = taskMap_[current_workspace].applications.begin();
+       it != taskMap_[current_workspace].applications.end();
+       ++it) {
+    auto bit = buttons_.find(it->id);
+    if (bit == buttons_.end()) {
+      needReorder = true;
+    }
+    auto& button = bit == buttons_.end() ? addButton(*it) : bit->second;
+    if (it - taskMap_[current_workspace].applications.begin() ==
+        taskMap_[current_workspace].focused_num) {
+      button.get_style_context()->add_class("focused");
+    } else {
+      button.get_style_context()->remove_class("focused");
+    }
+    if (needReorder) {
+      box_.reorder_child(button, it - taskMap_[current_workspace].applications.begin());
+    }
+    std::string output = "";
+    if (config_["format"].isString()) {
+      auto format = config_["format"].asString();
+      output = fmt::format(format, fmt::arg("name", it->display_name), fmt::arg("icon", ""));
+    }
+    if (!config_["disable-markup"].asBool()) {
+      if (!button.get_image()) {
+        static_cast<Gtk::Label*>(button.get_child())->set_markup(output);
+      } else {
+        auto button_inner_container = static_cast<Gtk::Container*>(button.get_child());
+        auto label_and_icon_container =
+            static_cast<Gtk::Container*>(button_inner_container->get_children()[0]);
+
+        // Here 1 is index of Gtk::Label, while 0 is index of Gtk::Image
+        // It's undocumented, but behaviour is pretty stable during significant amount of testing
+        auto label_of_button =
+            static_cast<Gtk::Label*>(label_and_icon_container->get_children()[1]);
+        label_of_button->set_markup(output);
+      }
+
+    } else {
+      button.set_label(output);
+    }
+
+    onButtonReady(button);
+  }
+}
+
+Gtk::Button& TaskBar::addButton(const Application& application) {
+  auto  pair = buttons_.emplace(application.id, application.display_name);
+  auto& button = pair.first->second;
+  if (config_["format"].asString().find("{icon}") != std::string::npos) {
+    button.set_image_from_icon_name(application.instance_name);
+  }
+  box_.pack_start(button, false, false, 0);
+  button.set_relief(Gtk::RELIEF_NONE);
+  button.signal_clicked().connect([this, pair] {
+    try {
+      ipc_.sendCmd(IPC_COMMAND,
+                   fmt::format("[con_id={}] focus", std::to_string(pair.first->first)));
+    } catch (const std::exception& e) {
+      spdlog::error("TaskBar: {}", e.what());
+    }
+  });
+  if (!config_["disable-scroll"].asBool()) {
+    button.add_events(Gdk::SCROLL_MASK | Gdk::SMOOTH_SCROLL_MASK);
+    button.signal_scroll_event().connect(sigc::mem_fun(*this, &TaskBar::handleScroll));
+  }
+  return button;
+}
+
+bool TaskBar::handleScroll(GdkEventScroll* e) {
+  // Avoid concurrent scroll event
+  if (scrolling_) {
+    return false;
+  }
+  int new_focus = 0;
+  scrolling_ = true;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    int                         current_focus = taskMap_[current_workspace].focused_num;
+
+    switch (e->direction) {
+      case GDK_SCROLL_DOWN:
+      case GDK_SCROLL_RIGHT:
+        new_focus = getCycleTasks(current_focus, false);
+        break;
+      case GDK_SCROLL_UP:
+      case GDK_SCROLL_LEFT:
+        new_focus = getCycleTasks(current_focus, true);
+        break;
+      case GDK_SCROLL_SMOOTH:
+        gdouble delta_x, delta_y;
+        gdk_event_get_scroll_deltas(reinterpret_cast<const GdkEvent*>(e), &delta_x, &delta_y);
+        if (delta_y < 0) {
+          new_focus = getCycleTasks(current_focus, true);
+        } else if (delta_y > 0) {
+          new_focus = getCycleTasks(current_focus, false);
+        }
+        break;
+      default:
+        break;
+    }
+    if (new_focus == current_focus) {
+      scrolling_ = false;
+      return false;
+    }
+    taskMap_[current_workspace].focused_num = new_focus;
+  }
+  try {
+    ipc_.sendCmd(
+        IPC_COMMAND,
+        fmt::format("[con_id={}] focus", taskMap_[current_workspace].applications[new_focus].id));
+    scrolling_ = false;
+  } catch (const std::exception& e) {
+    spdlog::error("TaskBar: {}", e.what());
+  }
+  return true;
+}
+const int TaskBar::getCycleTasks(int current_focus, bool prev) {
+  int application_max_index = taskMap_[current_workspace].applications.size() - 1;
+  if (prev && !current_focus) {
+    return application_max_index;
+  } else if (prev && current_focus)
+    return --current_focus;
+  else if (!prev && current_focus != application_max_index)
+    return ++current_focus;
+  else
+    return 0;
+}
+void     TaskBar::onButtonReady(Gtk::Button& button) { button.show(); }
+TaskBar::operator Gtk::Widget&() { return box_; }
+
+void TaskBar::parseTree(const Json::Value& nodes) {
+  for (auto const& node : nodes["nodes"]) {
+    std::cout << node << std::endl;
+    if (node["type"] == "workspace") {
+      parseWorkspaceTree(node["name"].asString(), node);
+    } else {
+      parseTree(node);
+    }
+  }
+}
+
+void TaskBar::parseWorkspaceTree(const std::string& workspace_name, const Json::Value& node) {
+  auto functorGoDeeper =
+      std::bind(&TaskBar::parseWorkspaceTreeEntry, this, workspace_name, std::placeholders::_1);
+  for_each(node["nodes"].begin(), node["nodes"].end(), functorGoDeeper);
+  for_each(node["floating_nodes"].begin(), node["floating_nodes"].end(), functorGoDeeper);
+}
+
+void TaskBar::parseWorkspaceTreeEntry(const std::string& workspace_name, const Json::Value& node) {
+  // By documentation, only actual view has member "pid1"
+  if (node.isMember("pid")) {
+    // Yeah, it's window
+    if (!taskMap_.count(workspace_name)) {
+      WorkspaceMap wp;
+      taskMap_.emplace(workspace_name, wp);
+    }
+    size_t      max_length = config_["max_length"].isUInt() ? config_["max_length"].asUInt() : 0;
+    std::string window_name = max_length && node["name"].asString().length() > max_length
+                                  ? std::string(node["name"].asString(), 0, max_length)
+                                  : node["name"].asString();
+    std::string instance_name = "terminal";  // TODO remove
+    if (!node["window_properties"].isNull()) {
+      instance_name = node["window_properties"]["class"].asString();
+      std::transform(instance_name.begin(), instance_name.end(), instance_name.begin(), ::tolower);
+      if (instance_name == "pcmanfm") {  // TODO why only pcmanfm?.. Need full list here
+        instance_name = "system-file-manager";
+      }
+    }
+    taskMap_[workspace_name].applications.push_back(
+        {node["id"].asInt(), window_name, instance_name});
+    if (node["focused"].asBool())
+      taskMap_[workspace_name].focused_num = taskMap_.at(workspace_name).applications.size() - 1;
+  } else {
+    // It's not window, parse further
+    parseWorkspaceTree(workspace_name, node);
+  }
+}
+
+void TaskBar::parseCurrentWorkspace(const Json::Value& nodes) {
+  for (auto const& node : nodes) {
+    if (node["focused"].isBool() && node["focused"].asBool())
+      current_workspace = node["name"].asString();
+  }
+}
+}  // namespace waybar::modules::sway

src/modules/sway/workspaces.cpp

@@ -166,7 +166,7 @@ auto Workspaces::update() -> void {
                            fmt::arg("index", (*it)["num"].asString()));
     }
     if (!config_["disable-markup"].asBool()) {
-      static_cast<Gtk::Label *>(button.get_children()[0])->set_markup(output);
+      static_cast<Gtk::Label *>(button.get_child())->set_markup(output);
     } else {
       button.set_label(output);
     }