fix(hyprland): support additional v2 events

Author: matt-fff

src/modules/hyprland/workspaces.cpp

@@ -12,6 +12,8 @@
 
 namespace waybar::modules::hyprland {
 
+constexpr int INVALID_WORKSPACE_ID = -100;
+
 Workspaces::Workspaces(const std::string &id, const Bar &bar, const Json::Value &config)
     : AModule(config, "workspaces", id, false, false), m_bar(bar), m_box(bar.orientation, 0) {
   modulesReady = true;
@@ -50,13 +52,12 @@ Json::Value Workspaces::createMonitorWorkspaceData(std::string const &name,
                                                    std::string const &monitor) {
   spdlog::trace("Creating persistent workspace: {} on monitor {}", name, monitor);
   Json::Value workspaceData;
-  try {
-    // numbered persistent workspaces get the name as ID
-    workspaceData["id"] = name == "special" ? -99 : std::stoi(name);
-  } catch (const std::exception &e) {
-    // named persistent workspaces start with ID=0
-    workspaceData["id"] = 0;
+
+  auto workspaceId = getWorkspaceId(name);
+  if (workspaceId == INVALID_WORKSPACE_ID) {
+    workspaceId = 0
   }
+  workspaceData["id"] = workspaceId
   workspaceData["name"] = name;
   workspaceData["monitor"] = monitor;
   workspaceData["windows"] = 0;
@@ -67,6 +68,7 @@ void Workspaces::createWorkspace(Json::Value const &workspace_data,
                                  Json::Value const &clients_data) {
   auto workspaceName = workspace_data["name"].asString();
   spdlog::debug("Creating workspace {}", workspaceName);
+  
 
   // avoid recreating existing workspaces
   auto workspace = std::find_if(
@@ -325,21 +327,21 @@ void Workspaces::onEvent(const std::string &ev) {
     onWorkspaceDestroyed(payload);
   } else if (eventName == "createworkspacev2") {
     onWorkspaceCreated(payload);
-  } else if (eventName == "focusedmon") {
+  } else if (eventName == "focusedmonv2") {
     onMonitorFocused(payload);
-  } else if (eventName == "moveworkspace") {
+  } else if (eventName == "moveworkspacev2") {
     onWorkspaceMoved(payload);
   } else if (eventName == "openwindow") {
     onWindowOpened(payload);
   } else if (eventName == "closewindow") {
     onWindowClosed(payload);
-  } else if (eventName == "movewindow") {
+  } else if (eventName == "movewindowv2") {
     onWindowMoved(payload);
   } else if (eventName == "urgent") {
     setUrgentWorkspace(payload);
   } else if (eventName == "renameworkspace") {
     onWorkspaceRenamed(payload);
-  } else if (eventName == "windowtitle") {
+  } else if (eventName == "windowtitlev2") {
     onWindowTitleEvent(payload);
   } else if (eventName == "configreloaded") {
     onConfigReloaded();
@@ -349,8 +351,11 @@ void Workspaces::onEvent(const std::string &ev) {
 }
 
 void Workspaces::onWorkspaceActivated(std::string const &payload) {
-  std::string workspaceIdStr = payload.substr(0, payload.find(','));
-  m_activeWorkspaceId = std::stoi(workspaceIdStr);
+  auto [workspaceIdStr, _] = splitDoublePayload(payload);
+  auto workspaceId = getWorkspaceId(workspaceIdStr);
+  if (workspaceId != INVALID_WORKSPACE_ID) {
+    m_activeWorkspaceId = workspaceId;
+  }
 }
 
 void Workspaces::onSpecialWorkspaceActivated(std::string const &payload) {
@@ -359,18 +364,22 @@ void Workspaces::onSpecialWorkspaceActivated(std::string const &payload) {
 }
 
 void Workspaces::onWorkspaceDestroyed(std::string const &payload) {
-  std::string workspaceIdStr = payload.substr(0, payload.find(','));
-  std::string workspaceName = payload.substr(workspaceIdStr.size() + 1);
+  auto [workspaceId, workspaceName] = splitDoublePayload(payload);
   if (!isDoubleSpecial(workspaceName)) {
-    m_workspacesToRemove.push_back(workspaceIdStr);
+    m_workspacesToRemove.push_back(workspaceId);
   }
 }
 
 void Workspaces::onWorkspaceCreated(std::string const &payload,
                                     Json::Value const &clientsData) {
   spdlog::debug("Workspace created: {}", payload);
-  std::string workspaceIdStr = payload.substr(0, payload.find(','));
-  int workspaceId = std::stoi(workspaceIdStr);
+
+  auto [workspaceIdStr, _] = splitDoublePayload(payload);
+
+  auto workspaceId = getWorkspaceId(workspaceIdStr);
+  if (workspaceId == INVALID_WORKSPACE_ID) {
+    return;
+  }
 
   auto const workspaceRules = gIPC->getSocket1JsonReply("workspacerules");
   auto const workspacesJson = gIPC->getSocket1JsonReply("workspaces");
@@ -412,23 +421,26 @@ void Workspaces::onWorkspaceMoved(std::string const &payload) {
 
   if (allOutputs()) return;
 
-  std::string workspaceName = payload.substr(0, payload.find(','));
-  std::string monitorName = payload.substr(payload.find(',') + 1);
+  auto [workspaceIdStr, workspaceName, monitorName] = splitTriplePayload(payload);
+
+  auto subPayload = joinDoublePayload(workspaceIdStr, workspaceName);
 
   if (m_bar.output->name == monitorName) {
     Json::Value clientsData = gIPC->getSocket1JsonReply("clients");
-    onWorkspaceCreated(workspaceName, clientsData);
+    onWorkspaceCreated(subPayload, clientsData);
   } else {
-    spdlog::debug("Removing workspace because it was moved to another monitor: {}");
-    onWorkspaceDestroyed(workspaceName);
+    spdlog::debug("Removing workspace because it was moved to another monitor: {}", subPayload);
+    onWorkspaceDestroyed(subPayload);
   }
 }
 
 void Workspaces::onWorkspaceRenamed(std::string const &payload) {
   spdlog::debug("Workspace renamed: {}", payload);
-  std::string workspaceIdStr = payload.substr(0, payload.find(','));
-  int workspaceId = workspaceIdStr == "special" ? -99 : std::stoi(workspaceIdStr);
-  std::string newName = payload.substr(payload.find(',') + 1);
+  auto [workspaceIdStr, newName] = splitDoublePayload(payload);
+
+  auto workspaceId = getWorkspaceId(workspaceIdStr);
+  if (workspaceId == INVALID_WORKSPACE_ID) return;
+
   for (auto &workspace : m_workspaces) {
     if (workspace->id() == workspaceId) {
       workspace->setName(newName);
@@ -441,18 +453,15 @@ void Workspaces::onWorkspaceRenamed(std::string const &payload) {
 void Workspaces::onMonitorFocused(std::string const &payload) {
   spdlog::trace("Monitor focused: {}", payload);
 
-  std::string workspaceName = payload.substr(payload.find(',') + 1);
+  auto [monitorName, workspaceIdStr] = splitDoublePayload(payload);
 
-  // TODO this will be in the payload when we upgrade to focusedmonv2
-  for (auto &workspace : m_workspaces) {
-    if (workspace->name() == workspaceName) {
-      m_activeWorkspaceId = workspace->id();
-      break;
-    }
-  }
+  auto workspaceId = getWorkspaceId(workspaceIdStr);
+  if (workspaceId == INVALID_WORKSPACE_ID) return;
+
+  m_activeWorkspaceId = workspaceId;
 
   for (Json::Value &monitor : gIPC->getSocket1JsonReply("monitors")) {
-    if (monitor["name"].asString() == payload.substr(0, payload.find(','))) {
+    if (monitor["name"].asString() == monitorName) {
       auto name = monitor["specialWorkspace"]["name"].asString();
       m_activeSpecialWorkspaceName = !name.starts_with("special:") ? name : name.substr(8);
     }
@@ -492,13 +501,7 @@ void Workspaces::onWindowClosed(std::string const &addr) {
 void Workspaces::onWindowMoved(std::string const &payload) {
   spdlog::trace("Window moved: {}", payload);
   updateWindowCount();
-  size_t lastCommaIdx = 0;
-  size_t nextCommaIdx = payload.find(',');
-  std::string windowAddress = payload.substr(lastCommaIdx, nextCommaIdx - lastCommaIdx);
-
-  std::string workspaceName = payload.substr(nextCommaIdx + 1, payload.length() - nextCommaIdx);
-
-  std::string windowRepr;
+  auto [windowAddress, _, workspaceName] = splitTriplePayload(payload);
 
   // If the window was still queued to be created, just change its destination
   // and exit
@@ -532,13 +535,15 @@ void Workspaces::onWindowTitleEvent(std::string const &payload) {
   spdlog::trace("Window title changed: {}", payload);
   std::optional<std::function<void(WindowCreationPayload)>> inserter;
 
+  auto [windowAddress, _] = splitDoublePayload(payload);
+
   // If the window was an orphan, rename it at the orphan's vector
-  if (m_orphanWindowMap.contains(payload)) {
+  if (m_orphanWindowMap.contains(windowAddress)) {
     inserter = [this](WindowCreationPayload wcp) { this->registerOrphanWindow(std::move(wcp)); };
   } else {
     auto windowWorkspace =
         std::find_if(m_workspaces.begin(), m_workspaces.end(),
-                     [payload](auto &workspace) { return workspace->containsWindow(payload); });
+                     [windowAddress](auto &workspace) { return workspace->containsWindow(windowAddress); });
 
     // If the window exists on a workspace, rename it at the workspace's window
     // map
@@ -681,20 +686,20 @@ auto Workspaces::registerIpc() -> void {
   gIPC->registerForIPC("activespecial", this);
   gIPC->registerForIPC("createworkspacev2", this);
   gIPC->registerForIPC("destroyworkspacev2", this);
-  gIPC->registerForIPC("focusedmon", this);
-  gIPC->registerForIPC("moveworkspace", this);
+  gIPC->registerForIPC("focusedmonv2", this);
+  gIPC->registerForIPC("moveworkspacev2", this);
   gIPC->registerForIPC("renameworkspace", this);
   gIPC->registerForIPC("openwindow", this);
   gIPC->registerForIPC("closewindow", this);
-  gIPC->registerForIPC("movewindow", this);
+  gIPC->registerForIPC("movewindowv2", this);
   gIPC->registerForIPC("urgent", this);
   gIPC->registerForIPC("configreloaded", this);
 
   if (windowRewriteConfigUsesTitle()) {
     spdlog::info(
-        "Registering for Hyprland's 'windowtitle' events because a user-defined window "
+        "Registering for Hyprland's 'windowtitlev2' events because a user-defined window "
         "rewrite rule uses the 'title' field.");
-    gIPC->registerForIPC("windowtitle", this);
+    gIPC->registerForIPC("windowtitlev2", this);
   }
 }
 
@@ -708,31 +713,29 @@ void Workspaces::removeWorkspacesToRemove() {
 void Workspaces::removeWorkspace(std::string const &workspaceString) {
   spdlog::debug("Removing workspace {}", workspaceString);
 
-  int id;
-  std::string name;
 
-  try {
-    // If this succeeds, we have a workspace ID.
-    id = std::stoi(workspaceString);
-  } catch (const std::exception &e) {
-    // TODO: At some point we want to support all workspace selectors
-    // This is just a subset.
-    // https://wiki.hyprland.org/Configuring/Workspace-Rules/#workspace-selectors
-    if (workspaceString.starts_with("special:")) {
-      name = workspaceString.substr(8);
-    } else if (workspaceString.starts_with("name:")) {
-      name = workspaceString.substr(5);
-    } else {
-      name = workspaceString;
-    }
+  // If this succeeds, we have a workspace ID.
+  int id = getWorkspaceId(workspaceString);
+  auto matchByName = id == INVALID_WORKSPACE_ID;
+
+  std::string name;
+  // TODO: At some point we want to support all workspace selectors
+  // This is just a subset.
+  // https://wiki.hyprland.org/Configuring/Workspace-Rules/#workspace-selectors
+  if (workspaceString.starts_with("special:")) {
+    name = workspaceString.substr(8);
+  } else if (workspaceString.starts_with("name:")) {
+    name = workspaceString.substr(5);
+  } else {
+    name = workspaceString;
   }
 
   auto workspace =
       std::find_if(m_workspaces.begin(), m_workspaces.end(), [&](std::unique_ptr<Workspace> &x) {
-        if (name.empty()) {
-          return id == x->id();
+        if (matchByName) {
+          return name == x->name();
         }
-        return name == x->name();
+        return id == x->id();
       });
 
   if (workspace == m_workspaces.end()) {
@@ -945,4 +948,34 @@ int Workspaces::windowRewritePriorityFunction(std::string const &window_rule) {
   return 0;
 }
 
+std::string Workspaces::joinDoublePayload(std::string const &part1, std::string const &part2) {
+  return part1 + "," + part2;
+}
+
+std::pair<std::string, std::string> Workspaces::splitDoublePayload(std::string const &payload) {
+  std::string part1 = payload.substr(0, payload.find(','));
+  std::string part2 = payload.substr(part1.size() + 1);
+  return {part1, part2};
+}
+
+std::tuple<std::string, std::string, std::string> Workspaces::splitTriplePayload(std::string const &payload) {
+  size_t firstComma = payload.find(',');
+  size_t secondComma = payload.find(',', firstComma + 1);
+  
+  std::string part1 = payload.substr(0, firstComma);
+  std::string part2 = payload.substr(firstComma + 1, secondComma - (firstComma + 1));
+  std::string part3 = payload.substr(secondComma + 1);
+  
+  return {part1, part2, part3};
+}
+
+std::int Workspaces::getWorkspaceId(std::string const &workspaceIdStr) {
+  try {
+    return workspaceIdStr == "special" ? -99 : std::stoi(workspaceIdStr);
+  } catch (std::exception const &e) {
+    spdlog::error("Failed to parse workspace ID: {}", e.what());
+    return INVALID_WORKSPACE_ID;
+  }
+}
+
 }  // namespace waybar::modules::hyprland