Merge branch 'master' into river-tags-monitor-focus

include/modules/cava.hpp

@@ -23,11 +23,11 @@ class Cava final : public ALabel {
   util::SleeperThread thread_;
   util::SleeperThread thread_fetch_input_;
 
-  struct cava::error_s error_ {};          // cava errors
-  struct cava::config_params prm_ {};      // cava parameters
-  struct cava::audio_raw audio_raw_ {};    // cava handled raw audio data(is based on audio_data)
-  struct cava::audio_data audio_data_ {};  // cava audio data
-  struct cava::cava_plan* plan_;           //{new cava_plan{}};
+  struct cava::error_s error_{};          // cava errors
+  struct cava::config_params prm_{};      // cava parameters
+  struct cava::audio_raw audio_raw_{};    // cava handled raw audio data(is based on audio_data)
+  struct cava::audio_data audio_data_{};  // cava audio data
+  struct cava::cava_plan* plan_;          //{new cava_plan{}};
   // Cava API to read audio source
   cava::ptr input_source_;
   // Delay to handle audio source
@@ -39,11 +39,12 @@ class Cava final : public ALabel {
   std::chrono::seconds suspend_silence_delay_{0};
   bool silence_{false};
   bool hide_on_silence_{false};
+  std::string format_silent_{""};
   int sleep_counter_{0};
   // Cava method
   void pause_resume();
   // ModuleActionMap
-  static inline std::map<const std::string, void (waybar::modules::Cava::*const)()> actionMap_{
+  static inline std::map<const std::string, void (waybar::modules::Cava::* const)()> actionMap_{
       {"mode", &waybar::modules::Cava::pause_resume}};
 };
 }  // namespace waybar::modules

include/modules/clock.hpp

@@ -79,7 +79,7 @@ class Clock final : public ALabel {
   void tz_up();
   void tz_down();
   // Module Action Map
-  static inline std::map<const std::string, void (waybar::modules::Clock::*const)()> actionMap_{
+  static inline std::map<const std::string, void (waybar::modules::Clock::* const)()> actionMap_{
       {"mode", &waybar::modules::Clock::cldModeSwitch},
       {"shift_up", &waybar::modules::Clock::cldShift_up},
       {"shift_down", &waybar::modules::Clock::cldShift_down},

include/modules/hyprland/backend.hpp

@@ -2,9 +2,9 @@
 
 #include <filesystem>
 #include <list>
-#include <memory>
 #include <mutex>
 #include <string>
+#include <thread>
 #include <utility>
 
 #include "util/json.hpp"
@@ -19,7 +19,9 @@ class EventHandler {
 
 class IPC {
  public:
-  IPC() { startIPC(); }
+  IPC();
+  ~IPC();
+  static IPC& inst();
 
   void registerForIPC(const std::string& ev, EventHandler* ev_handler);
   void unregisterForIPC(EventHandler* handler);
@@ -32,14 +34,16 @@ class IPC {
   static std::filesystem::path socketFolder_;
 
  private:
-  void startIPC();
+  void socketListener();
   void parseIPC(const std::string&);
 
+  std::thread ipcThread_;
   std::mutex callbackMutex_;
   util::JsonParser parser_;
   std::list<std::pair<std::string, EventHandler*>> callbacks_;
+  int socketfd_;  // the hyprland socket file descriptor
+  bool running_ = true;
 };
 
-inline std::unique_ptr<IPC> gIPC;
 inline bool modulesReady = false;
 };  // namespace waybar::modules::hyprland

include/modules/hyprland/language.hpp

@@ -37,6 +37,8 @@ class Language : public waybar::ALabel, public EventHandler {
   util::JsonParser parser_;
 
   Layout layout_;
+
+  IPC& m_ipc;
 };
 
 }  // namespace waybar::modules::hyprland

include/modules/hyprland/submap.hpp

@@ -28,6 +28,8 @@ class Submap : public waybar::ALabel, public EventHandler {
   std::string submap_;
   bool always_on_ = false;
   std::string default_submap_ = "Default";
+
+  IPC& m_ipc;
 };
 
 }  // namespace waybar::modules::hyprland

include/modules/hyprland/window.hpp

@@ -60,6 +60,8 @@ class Window : public waybar::AAppIconLabel, public EventHandler {
   bool swallowing_;
   bool fullscreen_;
   bool focused_;
+
+  IPC& m_ipc;
 };
 
 }  // namespace waybar::modules::hyprland

include/modules/hyprland/workspace.hpp

@@ -83,6 +83,7 @@ class Workspace {
   Gtk::Button m_button;
   Gtk::Box m_content;
   Gtk::Label m_label;
+  IPC& m_ipc;
 };
 
 }  // namespace waybar::modules::hyprland

include/modules/hyprland/workspaces.hpp

@@ -7,6 +7,7 @@
 #include <cstdint>
 #include <map>
 #include <memory>
+#include <optional>
 #include <regex>
 #include <string>
 #include <vector>
@@ -55,7 +56,7 @@ class Workspaces : public AModule, public EventHandler {
 
   static Json::Value createMonitorWorkspaceData(std::string const& name,
                                                 std::string const& monitor);
-  void removeWorkspace(std::string const& name);
+  void removeWorkspace(std::string const& workspaceString);
   void setUrgentWorkspace(std::string const& windowaddress);
 
   // Config
@@ -74,10 +75,11 @@ class Workspaces : public AModule, public EventHandler {
   void onWorkspaceActivated(std::string const& payload);
   void onSpecialWorkspaceActivated(std::string const& payload);
   void onWorkspaceDestroyed(std::string const& payload);
-  void onWorkspaceCreated(std::string const& workspaceName,
+  void onWorkspaceCreated(std::string const& payload,
                           Json::Value const& clientsData = Json::Value::nullRef);
   void onWorkspaceMoved(std::string const& payload);
   void onWorkspaceRenamed(std::string const& payload);
+  static std::optional<int> parseWorkspaceId(std::string const& workspaceIdStr);
 
   // monitor events
   void onMonitorFocused(std::string const& payload);
@@ -93,11 +95,18 @@ class Workspaces : public AModule, public EventHandler {
 
   int windowRewritePriorityFunction(std::string const& window_rule);
 
+  // event payload management
+  template <typename... Args>
+  static std::string makePayload(Args const&... args);
+  static std::pair<std::string, std::string> splitDoublePayload(std::string const& payload);
+  static std::tuple<std::string, std::string, std::string> splitTriplePayload(
+      std::string const& payload);
+
   // Update methods
   void doUpdate();
   void removeWorkspacesToRemove();
   void createWorkspacesToCreate();
-  static std::vector<std::string> getVisibleWorkspaces();
+  static std::vector<int> getVisibleWorkspaces();
   void updateWorkspaceStates();
   bool updateWindowsToCreate();
 
@@ -138,7 +147,7 @@ class Workspaces : public AModule, public EventHandler {
 
   bool m_withIcon;
   uint64_t m_monitorId;
-  std::string m_activeWorkspaceName;
+  int m_activeWorkspaceId;
   std::string m_activeSpecialWorkspaceName;
   std::vector<std::unique_ptr<Workspace>> m_workspaces;
   std::vector<std::pair<Json::Value, Json::Value>> m_workspacesToCreate;
@@ -150,6 +159,7 @@ class Workspaces : public AModule, public EventHandler {
   std::mutex m_mutex;
   const Bar& m_bar;
   Gtk::Box m_box;
+  IPC& m_ipc;
 };
 
 }  // namespace waybar::modules::hyprland

include/modules/network.hpp

@@ -16,6 +16,8 @@
 #include "util/rfkill.hpp"
 #endif
 
+enum ip_addr_pref : uint8_t { IPV4, IPV6, IPV4_6 };
+
 namespace waybar::modules {
 
 class Network : public ALabel {
@@ -40,6 +42,7 @@ class Network : public ALabel {
   void parseEssid(struct nlattr**);
   void parseSignal(struct nlattr**);
   void parseFreq(struct nlattr**);
+  void parseBssid(struct nlattr**);
   bool associatedOrJoined(struct nlattr**);
   bool checkInterface(std::string name);
   auto getInfo() -> void;
@@ -49,7 +52,7 @@ class Network : public ALabel {
   std::optional<std::pair<unsigned long long, unsigned long long>> readBandwidthUsage();
 
   int ifid_;
-  sa_family_t family_;
+  ip_addr_pref addr_pref_;
   struct sockaddr_nl nladdr_ = {0};
   struct nl_sock* sock_ = nullptr;
   struct nl_sock* ev_sock_ = nullptr;
@@ -69,12 +72,16 @@ class Network : public ALabel {
 
   std::string state_;
   std::string essid_;
+  std::string bssid_;
   bool carrier_;
   std::string ifname_;
   std::string ipaddr_;
+  std::string ipaddr6_;
   std::string gwaddr_;
   std::string netmask_;
+  std::string netmask6_;
   int cidr_;
+  int cidr6_;
   int32_t signal_strength_dbm_;
   uint8_t signal_strength_;
   std::string signal_strength_app_;

include/modules/niri/backend.hpp

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <list>
+#include <mutex>
+#include <string>
+#include <utility>
+
+#include "util/json.hpp"
+
+namespace waybar::modules::niri {
+
+class EventHandler {
+ public:
+  virtual void onEvent(const Json::Value& ev) = 0;
+  virtual ~EventHandler() = default;
+};
+
+class IPC {
+ public:
+  IPC() { startIPC(); }
+
+  void registerForIPC(const std::string& ev, EventHandler* ev_handler);
+  void unregisterForIPC(EventHandler* handler);
+
+  static Json::Value send(const Json::Value& request);
+
+  // The data members are only safe to access while dataMutex_ is locked.
+  std::lock_guard<std::mutex> lockData() { return std::lock_guard(dataMutex_); }
+  const std::vector<Json::Value>& workspaces() const { return workspaces_; }
+  const std::vector<Json::Value>& windows() const { return windows_; }
+  const std::vector<std::string>& keyboardLayoutNames() const { return keyboardLayoutNames_; }
+  unsigned keyboardLayoutCurrent() const { return keyboardLayoutCurrent_; }
+
+ private:
+  void startIPC();
+  static int connectToSocket();
+  void parseIPC(const std::string&);
+
+  std::mutex dataMutex_;
+  std::vector<Json::Value> workspaces_;
+  std::vector<Json::Value> windows_;
+  std::vector<std::string> keyboardLayoutNames_;
+  unsigned keyboardLayoutCurrent_;
+
+  util::JsonParser parser_;
+  std::mutex callbackMutex_;
+  std::list<std::pair<std::string, EventHandler*>> callbacks_;
+};
+
+inline std::unique_ptr<IPC> gIPC;
+
+};  // namespace waybar::modules::niri

include/modules/niri/language.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <string>
+
+#include "ALabel.hpp"
+#include "bar.hpp"
+#include "modules/niri/backend.hpp"
+
+namespace waybar::modules::niri {
+
+class Language : public ALabel, public EventHandler {
+ public:
+  Language(const std::string &, const Bar &, const Json::Value &);
+  ~Language() override;
+  void update() override;
+
+ private:
+  void updateFromIPC();
+  void onEvent(const Json::Value &ev) override;
+  void doUpdate();
+
+  struct Layout {
+    std::string full_name;
+    std::string short_name;
+    std::string variant;
+    std::string short_description;
+  };
+
+  static Layout getLayout(const std::string &fullName);
+
+  std::mutex mutex_;
+  const Bar &bar_;
+
+  std::vector<Layout> layouts_;
+  unsigned current_idx_;
+};
+
+}  // namespace waybar::modules::niri

include/modules/niri/window.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <gtkmm/button.h>
+#include <json/value.h>
+
+#include "AAppIconLabel.hpp"
+#include "bar.hpp"
+#include "modules/niri/backend.hpp"
+
+namespace waybar::modules::niri {
+
+class Window : public AAppIconLabel, public EventHandler {
+ public:
+  Window(const std::string &, const Bar &, const Json::Value &);
+  ~Window() override;
+  void update() override;
+
+ private:
+  void onEvent(const Json::Value &ev) override;
+  void doUpdate();
+  void setClass(const std::string &className, bool enable);
+
+  const Bar &bar_;
+
+  std::string oldAppId_;
+};
+
+}  // namespace waybar::modules::niri

include/modules/niri/workspaces.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <gtkmm/button.h>
+#include <json/value.h>
+
+#include "AModule.hpp"
+#include "bar.hpp"
+#include "modules/niri/backend.hpp"
+
+namespace waybar::modules::niri {
+
+class Workspaces : public AModule, public EventHandler {
+ public:
+  Workspaces(const std::string &, const Bar &, const Json::Value &);
+  ~Workspaces() override;
+  void update() override;
+
+ private:
+  void onEvent(const Json::Value &ev) override;
+  void doUpdate();
+  Gtk::Button &addButton(const Json::Value &ws);
+  std::string getIcon(const std::string &value, const Json::Value &ws);
+
+  const Bar &bar_;
+  Gtk::Box box_;
+  // Map from niri workspace id to button.
+  std::unordered_map<uint64_t, Gtk::Button> buttons_;
+};
+
+}  // namespace waybar::modules::niri

include/modules/privacy/privacy.hpp

@@ -13,7 +13,7 @@ namespace waybar::modules::privacy {
 
 class Privacy : public AModule {
  public:
-  Privacy(const std::string &, const Json::Value &, const std::string &pos);
+  Privacy(const std::string &, const Json::Value &, Gtk::Orientation, const std::string &pos);
   auto update() -> void override;
 
   void onPrivacyNodesChanged();

include/modules/privacy/privacy_item.hpp

@@ -17,8 +17,8 @@ namespace waybar::modules::privacy {
 class PrivacyItem : public Gtk::Revealer {
  public:
   PrivacyItem(const Json::Value &config_, enum PrivacyNodeType privacy_type_,
-              std::list<PrivacyNodeInfo *> *nodes, const std::string &pos, const uint icon_size,
-              const uint transition_duration);
+              std::list<PrivacyNodeInfo *> *nodes, Gtk::Orientation orientation,
+              const std::string &pos, const uint icon_size, const uint transition_duration);
 
   enum PrivacyNodeType privacy_type;
 

include/modules/sni/icon_manager.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <json/json.h>
+#include <spdlog/spdlog.h>
+
+#include <string>
+#include <unordered_map>
+
+class IconManager {
+ public:
+  static IconManager& instance() {
+    static IconManager instance;
+    return instance;
+  }
+
+  void setIconsConfig(const Json::Value& icons_config) {
+    if (icons_config.isObject()) {
+      for (const auto& key : icons_config.getMemberNames()) {
+        std::string app_name = key;
+        const Json::Value& icon_value = icons_config[key];
+
+        if (icon_value.isString()) {
+          std::string icon_path = icon_value.asString();
+          icons_map_[app_name] = icon_path;
+        }
+      }
+    } else {
+      spdlog::warn("Invalid icon config format.");
+    }
+  }
+
+  std::string getIconForApp(const std::string& app_name) const {
+    auto it = icons_map_.find(app_name);
+    if (it != icons_map_.end()) {
+      return it->second;
+    }
+    return "";
+  }
+
+ private:
+  IconManager() = default;
+  std::unordered_map<std::string, std::string> icons_map_;
+};

include/modules/sni/item.hpp

@@ -62,6 +62,7 @@ class Item : public sigc::trackable {
   void proxyReady(Glib::RefPtr<Gio::AsyncResult>& result);
   void setProperty(const Glib::ustring& name, Glib::VariantBase& value);
   void setStatus(const Glib::ustring& value);
+  void setCustomIcon(const std::string& id);
   void getUpdatedProperties();
   void processUpdatedProperties(Glib::RefPtr<Gio::AsyncResult>& result);
   void onSignal(const Glib::ustring& sender_name, const Glib::ustring& signal_name,

include/modules/sway/workspaces.hpp

@@ -19,7 +19,7 @@ namespace waybar::modules::sway {
 class Workspaces : public AModule, public sigc::trackable {
  public:
   Workspaces(const std::string&, const waybar::Bar&, const Json::Value&);
-  virtual ~Workspaces() = default;
+  ~Workspaces() override = default;
   auto update() -> void override;
 
  private:
@@ -38,10 +38,10 @@ class Workspaces : public AModule, public sigc::trackable {
   Gtk::Button& addButton(const Json::Value&);
   void onButtonReady(const Json::Value&, Gtk::Button&);
   std::string getIcon(const std::string&, const Json::Value&);
-  const std::string getCycleWorkspace(std::vector<Json::Value>::iterator, bool prev) const;
+  std::string getCycleWorkspace(std::vector<Json::Value>::iterator, bool prev) const;
   uint16_t getWorkspaceIndex(const std::string& name) const;
-  std::string trimWorkspaceName(std::string);
-  bool handleScroll(GdkEventScroll*) override;
+  static std::string trimWorkspaceName(std::string);
+  bool handleScroll(GdkEventScroll* /*unused*/) override;
 
   const Bar& bar_;
   std::vector<Json::Value> workspaces_;
@@ -49,7 +49,6 @@ class Workspaces : public AModule, public sigc::trackable {
   std::vector<std::string> workspaces_order_;
   Gtk::Box box_;
   std::string m_formatWindowSeperator;
-  std::string m_windowRewriteDefault;
   util::RegexCollection m_windowRewriteRules;
   util::JsonParser parser_;
   std::unordered_map<std::string, Gtk::Button> buttons_;

include/modules/temperature.hpp

@@ -18,6 +18,7 @@ class Temperature : public ALabel {
  private:
   float getTemperature();
   bool isCritical(uint16_t);
+  bool isWarning(uint16_t);
 
   std::string file_path_;
   util::SleeperThread thread_;

include/modules/wireplumber.hpp

@@ -18,7 +18,7 @@ class Wireplumber : public ALabel {
 
  private:
   void asyncLoadRequiredApiModules();
-  void prepare();
+  void prepare(waybar::modules::Wireplumber* self);
   void activatePlugins();
   static void updateVolume(waybar::modules::Wireplumber* self, uint32_t id);
   static void updateNodeName(waybar::modules::Wireplumber* self, uint32_t id);
@@ -32,6 +32,8 @@ class Wireplumber : public ALabel {
 
   bool handleScroll(GdkEventScroll* e) override;
 
+  static std::list<waybar::modules::Wireplumber*> modules;
+
   WpCore* wp_core_;
   GPtrArray* apis_;
   WpObjectManager* om_;
@@ -44,6 +46,7 @@ class Wireplumber : public ALabel {
   double min_step_;
   uint32_t node_id_{0};
   std::string node_name_;
+  gchar* type_;
 };
 
 }  // namespace waybar::modules

include/modules/wlr/taskbar.hpp

@@ -24,6 +24,10 @@
 
 namespace waybar::modules::wlr {
 
+struct widget_geometry {
+  int x, y, w, h;
+};
+
 class Taskbar;
 
 class Task {
@@ -42,6 +46,7 @@ class Task {
   };
   // made public so TaskBar can reorder based on configuration.
   Gtk::Button button;
+  struct widget_geometry minimize_hint;
 
  private:
   static uint32_t global_id;
@@ -82,6 +87,8 @@ class Task {
  private:
   std::string repr() const;
   std::string state_string(bool = false) const;
+  void set_minimize_hint();
+  void on_button_size_allocated(Gtk::Allocation &alloc);
   void set_app_info_from_app_id_list(const std::string &app_id_list);
   bool image_load_icon(Gtk::Image &image, const Glib::RefPtr<Gtk::IconTheme> &icon_theme,
                        Glib::RefPtr<Gio::DesktopAppInfo> app_info, int size);