waybar/src/modules/hyprland/window.cpp

#include "modules/hyprland/window.hpp"

#include <spdlog/spdlog.h>

#include <regex>
#include <util/sanitize_str.hpp>

#include "modules/hyprland/backend.hpp"
#include "util/json.hpp"
#include "util/rewrite_string.hpp"

namespace waybar::modules::hyprland {

Window::Window(const std::string& id, const Bar& bar, const Json::Value& config)
    : ALabel(config, "window", id, "{}", 0, true), bar_(bar) {
  modulesReady = true;
  separate_outputs = config["separate-outputs"].as<bool>();

  if (!gIPC.get()) {
    gIPC = std::make_unique<IPC>();
  }

  queryActiveWorkspace();
  update();

  // register for hyprland ipc
  gIPC->registerForIPC("activewindow", this);
  gIPC->registerForIPC("closewindow", this);
  gIPC->registerForIPC("movewindow", this);
}

Window::~Window() {
  gIPC->unregisterForIPC(this);
  // wait for possible event handler to finish
  std::lock_guard<std::mutex> lg(mutex_);
}

auto Window::update() -> void {
  // fix ampersands
  std::lock_guard<std::mutex> lg(mutex_);

  std::string window_name = waybar::util::sanitize_string(workspace_.last_window_title);

  if (window_name != last_title_) {
    if (window_name.empty()) {
      label_.get_style_context()->add_class("empty");
    } else {
      label_.get_style_context()->remove_class("empty");
    }
    last_title_ = window_name;
  }


  if (!format_.empty()) {
    label_.show();
    label_.set_markup(fmt::format(fmt::runtime(format_),
                                  waybar::util::rewriteString(window_name, config_["rewrite"])));
  } else {
    label_.hide();
  }


  setClass("empty", workspace_.windows == 0);
  setClass("solo", workspace_.windows == 1);

  if (!last_solo_class_.empty() && solo_class_ != last_solo_class_) {
    if (bar_.window.get_style_context()->has_class(last_solo_class_)) {
      bar_.window.get_style_context()->remove_class(last_solo_class_);
      spdlog::trace("Removing solo class: {}", last_solo_class_);
    }
  }

  if (!solo_class_.empty() && solo_class_ != last_solo_class_) {
    last_solo_class_ = solo_class_;
    bar_.window.get_style_context()->add_class(solo_class_);
    spdlog::trace("Adding solo class: {}", solo_class_);
  }

  ALabel::update();
}

auto Window::getActiveWorkspace() -> Workspace {
  const auto workspace = gIPC->getSocket1Reply("j/activeworkspace");
  Json::Value json = parser_.parse(workspace);
  assert(json.isObject());
  return Workspace::parse(json);
}

auto Window::getActiveWorkspace(const std::string& monitorName) -> Workspace {
  const auto monitors = gIPC->getSocket1Reply("j/monitors");
  Json::Value json = parser_.parse(monitors);
  assert(json.isArray());
  auto monitor = std::find_if(json.begin(), json.end(),
                              [&](Json::Value monitor) { return monitor["name"] == monitorName; });
  if (monitor == std::end(json)) {
    spdlog::warn("Monitor not found: {}", monitorName);
    return Workspace{0, "", ""};
  }
  const int id = (*monitor)["activeWorkspace"]["id"].as<int>();

  const auto workspaces = gIPC->getSocket1Reply("j/workspaces");
  json = parser_.parse(workspaces);
  assert(json.isArray());
  auto workspace = std::find_if(json.begin(), json.end(),
                              [&](Json::Value workspace) { return workspace["id"] == id; });
  if (workspace == std::end(json)) {
    spdlog::warn("No workspace with id {}", id);
    return Workspace{0, "", ""};
  }
  return Workspace::parse(*workspace);
}

auto Window::Workspace::parse(const Json::Value& value) -> Window::Workspace {
  return Workspace{
    value["windows"].as<int>(),
    value["lastwindow"].as<std::string>(),
    value["lastwindowtitle"].as<std::string>()
  };
}

auto Window::getWindowClass(const std::string& address) -> std::string {
  const auto clients = gIPC->getSocket1Reply("j/clients");
  Json::Value json = parser_.parse(clients);
  assert(json.isArray());
  auto client = std::find_if(json.begin(), json.end(),
                              [&](Json::Value window) { return window["address"] == address; });
  if (client == std::end(json)) {
    return "";
  }
  return (*client)["class"].as<std::string>();
}

void Window::queryActiveWorkspace() {
  std::lock_guard<std::mutex> lg(mutex_);

  if (separate_outputs) {
    workspace_ = getActiveWorkspace(this->bar_.output->name);
  } else {
    workspace_ = getActiveWorkspace();
  }

  if (workspace_.windows == 1) {
    solo_class_ = getWindowClass(workspace_.last_window);
  } else {
    solo_class_ = "";
  }
}

void Window::onEvent(const std::string& ev) {
  queryActiveWorkspace();

  dp.emit();
}


void Window::setClass(const std::string& classname, bool enable) {
  if (enable) {
    if (!bar_.window.get_style_context()->has_class(classname)) {
      bar_.window.get_style_context()->add_class(classname);
    }
  } else {
    bar_.window.get_style_context()->remove_class(classname);
  }
}

}  // namespace waybar::modules::hyprland