Merge remote-tracking branch 'origin/master' into pr-4685

# Conflicts:
#	src/modules/sway/workspaces.cpp

src/modules/sway/bar.cpp

@@ -60,7 +60,7 @@ BarIpcClient::BarIpcClient(waybar::Bar& bar) : bar_{bar} {
   });
 }
 
-bool BarIpcClient::isModuleEnabled(std::string name) {
+bool BarIpcClient::isModuleEnabled(const std::string& name) {
   for (const auto& section : {"modules-left", "modules-center", "modules-right"}) {
     if (const auto& modules = bar_.config.get(section, {}); modules.isArray()) {
       for (const auto& module : modules) {

src/modules/sway/ipc/client.cpp

@@ -2,15 +2,48 @@
 
 #include <fcntl.h>
 #include <spdlog/spdlog.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <unistd.h>
 
+#include <cerrno>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <limits>
 #include <stdexcept>
+#include <string_view>
+#include <utility>
+
+#include "modules/sway/ipc/ipc.hpp"
 
 namespace waybar::modules::sway {
+namespace {
+
+void sendAll(int fd, const char* data, size_t size, const char* what) {
+  size_t total = 0;
+  while (total < size) {
+    const auto res = ::send(fd, data + total, size - total, 0);
+    if (res < 0) {
+      if (errno == EINTR || errno == EAGAIN) {
+        continue;
+      }
+      throw std::runtime_error(what);
+    }
+    if (res == 0) {
+      throw std::runtime_error(what);
+    }
+    total += static_cast<size_t>(res);
+  }
+}
+
+}  // namespace
 
 Ipc::Ipc() {
-  const std::string& socketPath = getSocketPath();
-  fd_ = open(socketPath);
-  fd_event_ = open(socketPath);
+  const std::string socketPath = getSocketPath();
+  fd_ = util::ScopedFd(open(socketPath));
+  fd_event_ = util::ScopedFd(open(socketPath));
 }
 
 Ipc::~Ipc() {
@@ -21,118 +54,129 @@ Ipc::~Ipc() {
     if (write(fd_, "close-sway-ipc", 14) == -1) {
       spdlog::error("Failed to close sway IPC");
     }
-    close(fd_);
-    fd_ = -1;
   }
   if (fd_event_ > 0) {
     if (write(fd_event_, "close-sway-ipc", 14) == -1) {
       spdlog::error("Failed to close sway IPC event handler");
     }
-    close(fd_event_);
-    fd_event_ = -1;
   }
 }
 
-void Ipc::setWorker(std::function<void()>&& func) { thread_ = func; }
+void Ipc::setWorker(std::function<void()>&& func) { thread_ = std::move(func); }
 
-const std::string Ipc::getSocketPath() const {
+std::string Ipc::getSocketPath() {
   const char* env = getenv("SWAYSOCK");
-  if (env != nullptr) {
-    return std::string(env);
+  if (env != nullptr && env[0] != '\0') {
+    return {env};
   }
+
+  FILE* in = popen("sway --get-socketpath 2>/dev/null", "r");
+  if (in == nullptr) {
+    throw std::runtime_error("Failed to get socket path");
+  }
+
   std::string str;
-  {
-    std::string str_buf;
-    FILE* in;
-    char buf[512] = {0};
-    if ((in = popen("sway --get-socketpath 2>/dev/null", "r")) == nullptr) {
-      throw std::runtime_error("Failed to get socket path");
-    }
-    while (fgets(buf, sizeof(buf), in) != nullptr) {
-      str_buf.append(buf, sizeof(buf));
-    }
-    pclose(in);
-    str = str_buf;
-    if (str.empty()) {
-      throw std::runtime_error("Socket path is empty");
-    }
+  char buf[512] = {0};
+  while (fgets(buf, sizeof(buf), in) != nullptr) {
+    str.append(buf);
   }
-  if (str.back() == '\n') {
+
+  if (pclose(in) == -1) {
+    throw std::runtime_error("Failed to get socket path");
+  }
+
+  if (str.ends_with('\n')) {
     str.pop_back();
   }
+  if (str.empty()) {
+    throw std::runtime_error("Socket path is empty");
+  }
+
   return str;
 }
 
-int Ipc::open(const std::string& socketPath) const {
-  int32_t fd = socket(AF_UNIX, SOCK_STREAM, 0);
+int Ipc::open(const std::string& socketPath) {
+  util::ScopedFd fd(socket(AF_UNIX, SOCK_STREAM, 0));
   if (fd == -1) {
     throw std::runtime_error("Unable to open Unix socket");
   }
   (void)fcntl(fd, F_SETFD, FD_CLOEXEC);
-  struct sockaddr_un addr;
-  memset(&addr, 0, sizeof(struct sockaddr_un));
-  addr.sun_family = AF_UNIX;
+  struct sockaddr_un addr{.sun_family = AF_UNIX};
   strncpy(addr.sun_path, socketPath.c_str(), sizeof(addr.sun_path) - 1);
   addr.sun_path[sizeof(addr.sun_path) - 1] = 0;
-  int l = sizeof(struct sockaddr_un);
-  if (::connect(fd, reinterpret_cast<struct sockaddr*>(&addr), l) == -1) {
+  if (::connect(fd, reinterpret_cast<struct sockaddr*>(&addr), sizeof addr) == -1) {
     throw std::runtime_error("Unable to connect to Sway");
   }
-  return fd;
+  return fd.release();
 }
 
 struct Ipc::ipc_response Ipc::recv(int fd) {
   std::string header;
   header.resize(ipc_header_size_);
-  auto data32 = reinterpret_cast<uint32_t*>(header.data() + ipc_magic_.size());
-  size_t total = 0;
 
+  size_t total = 0;
   while (total < ipc_header_size_) {
-    auto res = ::recv(fd, header.data() + total, ipc_header_size_ - total, 0);
+    const ssize_t res = ::recv(fd, header.data() + total, ipc_header_size_ - total, 0);
     if (fd_event_ == -1 || fd_ == -1) {
       // IPC is closed so just return an empty response
-      return {0, 0, ""};
+      return {.size = 0, .type = 0, .payload = ""};
     }
-    if (res <= 0) {
+    if (res < 0) {
+      if (errno == EINTR || errno == EAGAIN) {
+        continue;
+      }
       throw std::runtime_error("Unable to receive IPC header");
     }
-    total += res;
+    if (res == 0) {
+      throw std::runtime_error("Unable to receive IPC header");
+    }
+    total += static_cast<size_t>(res);
   }
-  auto magic = std::string(header.data(), header.data() + ipc_magic_.size());
-  if (magic != ipc_magic_) {
+  if (std::string_view(header.data(), ipc_magic_.size()) != ipc_magic_) {
     throw std::runtime_error("Invalid IPC magic");
   }
 
-  total = 0;
+  uint32_t payload_size = 0;
+  uint32_t payload_type = 0;
+  memcpy(&payload_size, header.data() + ipc_magic_.size(), sizeof payload_size);
+  memcpy(&payload_type, header.data() + ipc_magic_.size() + sizeof payload_size,
+         sizeof payload_type);
+
   std::string payload;
-  payload.resize(data32[0]);
-  while (total < data32[0]) {
-    auto res = ::recv(fd, payload.data() + total, data32[0] - total, 0);
+  payload.resize(payload_size);
+
+  total = 0;
+  while (total < payload_size) {
+    const ssize_t res = ::recv(fd, payload.data() + total, payload_size - total, 0);
     if (res < 0) {
       if (errno == EINTR || errno == EAGAIN) {
         continue;
       }
       throw std::runtime_error("Unable to receive IPC payload");
     }
-    total += res;
+    if (res == 0) {
+      throw std::runtime_error("Unable to receive IPC payload");
+    }
+    total += static_cast<size_t>(res);
   }
-  return {data32[0], data32[1], &payload.front()};
+
+  return {.size = payload_size, .type = payload_type, .payload = std::move(payload)};
 }
 
 struct Ipc::ipc_response Ipc::send(int fd, uint32_t type, const std::string& payload) {
   std::string header;
   header.resize(ipc_header_size_);
-  auto data32 = reinterpret_cast<uint32_t*>(header.data() + ipc_magic_.size());
-  memcpy(header.data(), ipc_magic_.c_str(), ipc_magic_.size());
-  data32[0] = payload.size();
-  data32[1] = type;
+  memcpy(header.data(), ipc_magic_.data(), ipc_magic_.size());
+  if (payload.size() > std::numeric_limits<uint32_t>::max()) {
+    throw std::runtime_error("IPC payload is too large");
+  }
+  const auto payload_size = static_cast<uint32_t>(payload.size());
+  memcpy(header.data() + ipc_magic_.size(), &payload_size, sizeof payload_size);
+  memcpy(header.data() + ipc_magic_.size() + sizeof payload_size, &type, sizeof type);
+
+  sendAll(fd, header.data(), ipc_header_size_, "Unable to send IPC header");
+  sendAll(fd, payload.data(), payload.size(), "Unable to send IPC payload");
 
-  if (::send(fd, header.data(), ipc_header_size_, 0) == -1) {
-    throw std::runtime_error("Unable to send IPC header");
-  }
-  if (::send(fd, payload.c_str(), payload.size(), 0) == -1) {
-    throw std::runtime_error("Unable to send IPC payload");
-  }
   return Ipc::recv(fd);
 }
 

src/modules/sway/language.cpp

@@ -54,21 +54,28 @@ void Language::onCmd(const struct Ipc::ipc_response& res) {
     std::lock_guard<std::mutex> lock(mutex_);
     auto payload = parser_.parse(res.payload);
     std::vector<std::string> used_layouts;
-    // Display current layout of a device with a maximum count of layouts, expecting that all will
-    // be OK
+    // Union layout names across every keyboard input so hot-plugged devices contribute their
+    // layouts to the map. Track the device with the most layouts to seed the initially displayed
+    // layout, matching the previous behaviour at startup.
     Json::ArrayIndex max_id = 0, max = 0;
     for (Json::ArrayIndex i = 0; i < payload.size(); i++) {
-      auto size = payload[i][XKB_LAYOUT_NAMES_KEY].size();
-      if (size > max) {
-        max = size;
+      if (payload[i]["type"].asString() != "keyboard") continue;
+      const auto& names = payload[i][XKB_LAYOUT_NAMES_KEY];
+      if (names.size() > max) {
+        max = names.size();
         max_id = i;
       }
+      for (const auto& layout : names) {
+        const auto name = layout.asString();
+        if (std::find(used_layouts.begin(), used_layouts.end(), name) == used_layouts.end()) {
+          used_layouts.push_back(name);
+        }
+      }
     }
 
-    for (const auto& layout : payload[max_id][XKB_LAYOUT_NAMES_KEY]) {
-      used_layouts.push_back(layout.asString());
-    }
-
+    // Rebuild from scratch so init_layouts_map's duplicate-suffix pass doesn't compound across
+    // refreshes (e.g. "us" -> "us1" -> "us11").
+    layouts_map_.clear();
     init_layouts_map(used_layouts);
     set_current_layout(payload[max_id][XKB_ACTIVE_LAYOUT_NAME_KEY].asString());
     dp.emit();
@@ -82,13 +89,26 @@ void Language::onEvent(const struct Ipc::ipc_response& res) {
     return;
   }
 
+  bool refresh_inputs = false;
   try {
-    std::lock_guard<std::mutex> lock(mutex_);
-    auto payload = parser_.parse(res.payload)["input"];
-    if (payload["type"].asString() == "keyboard") {
-      set_current_layout(payload[XKB_ACTIVE_LAYOUT_NAME_KEY].asString());
+    {
+      std::lock_guard<std::mutex> lock(mutex_);
+      auto root = parser_.parse(res.payload);
+      auto change = root["change"].asString();
+      auto payload = root["input"];
+      if (payload["type"].asString() == "keyboard") {
+        // A device was added or its keymap changed - the layout set may have grown, so refresh
+        // layouts_map_ via IPC_GET_INPUTS once we've released mutex_.
+        refresh_inputs = (change == "added" || change == "xkb_keymap");
+        set_current_layout(payload[XKB_ACTIVE_LAYOUT_NAME_KEY].asString());
+      }
+      dp.emit();
+    }
+    // sendCmd is synchronous: it blocks on the IPC reply and then emits signal_cmd on this same
+    // thread, which lands in onCmd and re-locks mutex_. Must call it with mutex_ released.
+    if (refresh_inputs) {
+      ipc_.sendCmd(IPC_GET_INPUTS);
     }
-    dp.emit();
   } catch (const std::exception& e) {
     spdlog::error("Language: {}", e.what());
   }
@@ -104,7 +124,7 @@ auto Language::update() -> void {
       fmt::runtime(format_), fmt::arg("short", layout_.short_name),
       fmt::arg("shortDescription", layout_.short_description), fmt::arg("long", layout_.full_name),
       fmt::arg("variant", layout_.variant), fmt::arg("flag", layout_.country_flag())));
-  label_.set_markup(display_layout);
+  setLabelMarkup(display_layout);
   if (tooltipEnabled()) {
     if (tooltip_format_ != "") {
       auto tooltip_display_layout = trim(
@@ -112,9 +132,9 @@ auto Language::update() -> void {
                       fmt::arg("shortDescription", layout_.short_description),
                       fmt::arg("long", layout_.full_name), fmt::arg("variant", layout_.variant),
                       fmt::arg("flag", layout_.country_flag())));
-      label_.set_tooltip_markup(tooltip_display_layout);
+      setTooltipMarkup(tooltip_display_layout);
     } else {
-      label_.set_tooltip_markup(display_layout);
+      setTooltipMarkup(display_layout);
     }
   }
 
@@ -124,9 +144,16 @@ auto Language::update() -> void {
   ALabel::update();
 }
 
-auto Language::set_current_layout(std::string current_layout) -> void {
+auto Language::set_current_layout(const std::string& current_layout) -> void {
+  // Guard against unknown / empty layout names: transient virtual keyboards (e.g. wtype) and
+  // hot-plugged devices whose layouts haven't made it into the map yet would otherwise blank out
+  // layout_ via map::operator[]'s default-construct-on-miss.
+  auto it = layouts_map_.find(current_layout);
+  if (it == layouts_map_.end()) {
+    return;
+  }
   label_.get_style_context()->remove_class(layout_.short_name);
-  layout_ = layouts_map_[current_layout];
+  layout_ = it->second;
   label_.get_style_context()->add_class(layout_.short_name);
 }
 

src/modules/sway/mode.cpp

@@ -44,7 +44,7 @@ auto Mode::update() -> void {
   } else {
     label_.set_markup(fmt::format(fmt::runtime(format_), mode_));
     if (tooltipEnabled()) {
-      label_.set_tooltip_text(mode_);
+      label_.set_tooltip_markup(mode_);
     }
     event_box_.show();
   }

src/modules/sway/scratchpad.cpp

@@ -31,12 +31,12 @@ Scratchpad::Scratchpad(const std::string& id, const Json::Value& config)
 auto Scratchpad::update() -> void {
   if (count_ || show_empty_) {
     event_box_.show();
-    label_.set_markup(
+    setLabelMarkup(
         fmt::format(fmt::runtime(format_),
                     fmt::arg("icon", getIcon(count_, "", config_["format-icons"].size())),
                     fmt::arg("count", count_)));
     if (tooltip_enabled_) {
-      label_.set_tooltip_markup(tooltip_text_);
+      setTooltipMarkup(tooltip_text_);
     }
   } else {
     event_box_.hide();

src/modules/sway/window.cpp

@@ -94,12 +94,12 @@ auto Window::update() -> void {
     old_app_id_ = app_id_;
   }
 
-  label_.set_markup(waybar::util::rewriteString(
+  setLabelMarkup(waybar::util::rewriteString(
       fmt::format(fmt::runtime(format_), fmt::arg("title", window_), fmt::arg("app_id", app_id_),
                   fmt::arg("shell", shell_), fmt::arg("marks", marks_)),
       config_["rewrite"]));
   if (tooltipEnabled()) {
-    label_.set_tooltip_text(window_);
+    setTooltipMarkup(window_);
   }
 
   updateAppIcon();
@@ -184,9 +184,9 @@ std::tuple<std::string, std::string, std::string, std::string> getWindowInfo(
         continue;
       }
       if (!marks.empty()) {
-        marks += ',';
+        marks.append(",");
       }
-      marks += m.asString();
+      marks.append(m.asString());
     }
   }
   return {app_id, app_class, shell, marks};

src/modules/sway/workspaces.cpp

@@ -10,10 +10,10 @@ namespace waybar::modules::sway {
 
 // Helper function to assign a number to a workspace, just like sway. In fact
 // this is taken quite verbatim from `sway/ipc-json.c`.
-int Workspaces::convertWorkspaceNameToNum(std::string name) {
+int Workspaces::convertWorkspaceNameToNum(const std::string& name) {
   if (isdigit(name[0]) != 0) {
     errno = 0;
-    char *endptr = nullptr;
+    char* endptr = nullptr;
     long long parsed_num = strtoll(name.c_str(), &endptr, 10);
     if (errno != 0 || parsed_num > INT32_MAX || parsed_num < 0 || endptr == name.c_str()) {
       return -1;
@@ -23,7 +23,7 @@ int Workspaces::convertWorkspaceNameToNum(std::string name) {
   return -1;
 }
 
-int Workspaces::windowRewritePriorityFunction(std::string const &window_rule) {
+int Workspaces::windowRewritePriorityFunction(std::string const& window_rule) {
   // Rules that match against title are prioritized
   // Rules that don't specify if they're matching against either title or class are deprioritized
   bool const hasTitle = window_rule.find("title") != std::string::npos;
@@ -41,12 +41,12 @@ int Workspaces::windowRewritePriorityFunction(std::string const &window_rule) {
   return 0;
 }
 
-Workspaces::Workspaces(const std::string &id, const Bar &bar, const Json::Value &config)
+Workspaces::Workspaces(const std::string& id, const Bar& bar, const Json::Value& config)
     : AModule(config, "workspaces", id, false, !config["disable-scroll"].asBool()),
       bar_(bar),
       box_(bar.orientation, 0) {
   if (config["format-icons"]["high-priority-named"].isArray()) {
-    for (const auto &it : config["format-icons"]["high-priority-named"]) {
+    for (const auto& it : config["format-icons"]["high-priority-named"]) {
       high_priority_named_.push_back(it.asString());
     }
   }
@@ -61,21 +61,22 @@ Workspaces::Workspaces(const std::string &id, const Bar &bar, const Json::Value
   } else {
     m_formatWindowSeparator = " ";
   }
-  const Json::Value &windowRewrite = config["window-rewrite"];
+  const Json::Value& windowRewrite = config["window-rewrite"];
   if (windowRewrite.isObject()) {
-    const Json::Value &windowRewriteDefaultConfig = config["window-rewrite-default"];
+    const Json::Value& windowRewriteDefaultConfig = config["window-rewrite-default"];
     std::string windowRewriteDefault =
         windowRewriteDefaultConfig.isString() ? windowRewriteDefaultConfig.asString() : "?";
     m_windowRewriteRules = waybar::util::RegexCollection(
         windowRewrite, std::move(windowRewriteDefault), windowRewritePriorityFunction);
   }
+  populateIgnoreWorkspacesConfig(config);
   ipc_.subscribe(R"(["workspace"])");
   ipc_.subscribe(R"(["window"])");
   ipc_.signal_event.connect(sigc::mem_fun(*this, &Workspaces::onEvent));
   ipc_.signal_cmd.connect(sigc::mem_fun(*this, &Workspaces::onCmd));
   ipc_.sendCmd(IPC_GET_TREE);
   if (config["enable-bar-scroll"].asBool()) {
-    auto &window = const_cast<Bar &>(bar_).window;
+    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, &Workspaces::handleScroll));
   }
@@ -83,21 +84,51 @@ Workspaces::Workspaces(const std::string &id, const Bar &bar, const Json::Value
   ipc_.setWorker([this] {
     try {
       ipc_.handleEvent();
-    } catch (const std::exception &e) {
+    } catch (const std::exception& e) {
       spdlog::error("Workspaces: {}", e.what());
     }
   });
 }
 
-void Workspaces::onEvent(const struct Ipc::ipc_response &res) {
+void Workspaces::onEvent(const struct Ipc::ipc_response& res) {
   try {
     ipc_.sendCmd(IPC_GET_TREE);
-  } catch (const std::exception &e) {
+  } catch (const std::exception& e) {
     spdlog::error("Workspaces: {}", e.what());
   }
 }
 
-void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
+auto Workspaces::populateIgnoreWorkspacesConfig(const Json::Value& config) -> void {
+  auto ignoreWorkspaces = config["ignore-workspaces"];
+  if (ignoreWorkspaces.isArray()) {
+    for (const auto& workspaceRegex : ignoreWorkspaces) {
+      if (workspaceRegex.isString()) {
+        std::string ruleString = workspaceRegex.asString();
+        try {
+          const std::regex rule{ruleString, std::regex_constants::icase};
+          m_ignoreWorkspaces.emplace_back(rule);
+        } catch (const std::regex_error& e) {
+          spdlog::error("Invalid rule {}: {}", ruleString, e.what());
+        }
+      } else {
+        spdlog::error("Not a string: '{}'", workspaceRegex);
+      }
+    }
+  }
+}
+
+bool Workspaces::isWorkspaceIgnored(std::string const& name) {
+  for (auto& rule : m_ignoreWorkspaces) {
+    if (std::regex_match(name, rule)) {
+      return true;
+      break;
+    }
+  }
+
+  return false;
+}
+
+void Workspaces::onCmd(const struct Ipc::ipc_response& res) {
   if (res.type == IPC_GET_TREE) {
     try {
       {
@@ -107,7 +138,7 @@ void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
         std::vector<Json::Value> outputs;
         bool alloutputs = config_["all-outputs"].asBool();
         std::copy_if(payload["nodes"].begin(), payload["nodes"].end(), std::back_inserter(outputs),
-                     [&](const auto &output) {
+                     [&](const auto& output) {
                        if (alloutputs && output["name"].asString() != "__i3") {
                          return true;
                        }
@@ -117,22 +148,23 @@ void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
                        return false;
                      });
 
-        for (auto &output : outputs) {
-          std::copy(output["nodes"].begin(), output["nodes"].end(),
-                    std::back_inserter(workspaces_));
+        for (auto& output : outputs) {
+          std::copy_if(
+              output["nodes"].begin(), output["nodes"].end(), std::back_inserter(workspaces_),
+              [&](const auto& node) { return !(isWorkspaceIgnored(node["name"].asString())); });
           std::copy(output["floating_nodes"].begin(), output["floating_nodes"].end(),
                     std::back_inserter(workspaces_));
         }
 
         // adding persistent workspaces (as per the config file)
         if (config_["persistent-workspaces"].isObject()) {
-          const Json::Value &p_workspaces = config_["persistent-workspaces"];
+          const Json::Value& p_workspaces = config_["persistent-workspaces"];
           const std::vector<std::string> p_workspaces_names = p_workspaces.getMemberNames();
 
-          for (const std::string &p_w_name : p_workspaces_names) {
-            const Json::Value &p_w = p_workspaces[p_w_name];
+          for (const std::string& p_w_name : p_workspaces_names) {
+            const Json::Value& p_w = p_workspaces[p_w_name];
             auto it = std::find_if(workspaces_.begin(), workspaces_.end(),
-                                   [&p_w_name](const Json::Value &node) {
+                                   [&p_w_name](const Json::Value& node) {
                                      return node["name"].asString() == p_w_name;
                                    });
 
@@ -142,8 +174,9 @@ void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
 
             if (p_w.isArray() && !p_w.empty()) {
               // Adding to target outputs
-              for (const Json::Value &output : p_w) {
-                if (output.asString() == bar_.output->name) {
+              for (const Json::Value& output : p_w) {
+                auto output_name = output.asString();
+                if (output_name == bar_.output->name || output_name == bar_.output->identifier) {
                   Json::Value v;
                   v["name"] = p_w_name;
                   v["target_output"] = bar_.output->name;
@@ -185,10 +218,10 @@ void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
         // agreement that the "workspace prev/next" commands may not follow
         // the order displayed in Waybar.
         int max_num = -1;
-        for (auto &workspace : workspaces_) {
+        for (auto& workspace : workspaces_) {
           max_num = std::max(workspace["num"].asInt(), max_num);
         }
-        for (auto &workspace : workspaces_) {
+        for (auto& workspace : workspaces_) {
           auto workspace_num = workspace["num"].asInt();
           if (workspace_num > -1) {
             workspace["sort"] = workspace_num;
@@ -197,7 +230,7 @@ void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
           }
         }
         std::sort(workspaces_.begin(), workspaces_.end(),
-                  [this](const Json::Value &lhs, const Json::Value &rhs) {
+                  [this](const Json::Value& lhs, const Json::Value& rhs) {
                     auto lname = lhs["name"].asString();
                     auto rname = rhs["name"].asString();
                     int l = lhs["sort"].asInt();
@@ -217,7 +250,7 @@ void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
                   });
       }
       dp.emit();
-    } catch (const std::exception &e) {
+    } catch (const std::exception& e) {
       spdlog::error("Workspaces: {}", e.what());
     }
   }
@@ -227,9 +260,12 @@ bool Workspaces::filterButtons() {
   bool needReorder = false;
   for (auto it = buttons_.begin(); it != buttons_.end();) {
     auto ws = std::find_if(workspaces_.begin(), workspaces_.end(),
-                           [it](const auto &node) { return node["name"].asString() == it->first; });
+                           [it](const auto& node) { return node["name"].asString() == it->first; });
     if (ws == workspaces_.end() ||
-        (!config_["all-outputs"].asBool() && (*ws)["output"].asString() != bar_.output->name)) {
+        ((*ws).isMember("target_output") ? (*ws)["target_output"].asString() != bar_.output->name &&
+                                               (*ws)["target_output"].asString() != ""
+                                         : !config_["all-outputs"].asBool() &&
+                                               (*ws)["output"].asString() != bar_.output->name)) {
       it = buttons_.erase(it);
       needReorder = true;
     } else {
@@ -239,23 +275,23 @@ bool Workspaces::filterButtons() {
   return needReorder;
 }
 
-bool Workspaces::hasFlag(const Json::Value &node, const std::string &flag) {
+bool Workspaces::hasFlag(const Json::Value& node, const std::string& flag) {
   if (node[flag].asBool()) {
     return true;
   }
 
   if (std::any_of(node["nodes"].begin(), node["nodes"].end(),
-                  [&](auto const &e) { return hasFlag(e, flag); })) {
+                  [&](auto const& e) { return hasFlag(e, flag); })) {
     return true;
   }
   if (std::any_of(node["floating_nodes"].begin(), node["floating_nodes"].end(),
-                  [&](auto const &e) { return hasFlag(e, flag); })) {
+                  [&](auto const& e) { return hasFlag(e, flag); })) {
     return true;
   }
   return false;
 }
 
-void Workspaces::updateWindows(const Json::Value &node, std::string &windows) {
+void Workspaces::updateWindows(const Json::Value& node, std::string& windows) {
   if ((node["type"].asString() == "con" || node["type"].asString() == "floating_con") &&
       node["name"].isString()) {
     std::string title = g_markup_escape_text(node["name"].asString().c_str(), -1);
@@ -274,10 +310,10 @@ void Workspaces::updateWindows(const Json::Value &node, std::string &windows) {
       windows.append(m_formatWindowSeparator);
     }
   }
-  for (const Json::Value &child : node["nodes"]) {
+  for (const Json::Value& child : node["nodes"]) {
     updateWindows(child, windows);
   }
-  for (const Json::Value &child : node["floating_nodes"]) {
+  for (const Json::Value& child : node["floating_nodes"]) {
     updateWindows(child, windows);
   }
 }
@@ -290,7 +326,7 @@ auto Workspaces::update() -> void {
     if (bit == buttons_.end()) {
       needReorder = true;
     }
-    auto &button = bit == buttons_.end() ? addButton(*it) : bit->second;
+    auto& button = bit == buttons_.end() ? addButton(*it) : bit->second;
     if (needReorder) {
       box_.reorder_child(button, it - workspaces_.begin());
     }
@@ -321,6 +357,18 @@ auto Workspaces::update() -> void {
       button.get_style_context()->remove_class("empty");
     }
     if ((*it)["output"].isString()) {
+      // Simply attempt to remove all output classes every time to reset output classes. This works
+      // even if a class has not been previously added to the style context.
+      for (const auto& oclass : config_["output-classes"]) {
+        button.get_style_context()->remove_class(oclass.asString());
+      }
+      // If output-classes contains a class for output associated with current workspace button, add
+      // the class to its style context.
+      std::string output_name = (*it)["output"].asString();
+      if (config_["output-classes"].isMember(output_name) &&
+          config_["output-classes"][output_name].isString()) {
+        button.get_style_context()->add_class(config_["output-classes"][output_name].asString());
+      }
       if (((*it)["output"].asString()) == bar_.output->name) {
         button.get_style_context()->add_class("current_output");
       } else {
@@ -329,24 +377,44 @@ auto Workspaces::update() -> void {
     } else {
       button.get_style_context()->remove_class("current_output");
     }
-    std::string output = (*it)["name"].asString();
+    std::string full_name;
+    if (!config_["disable-markup"].asBool()) {
+      full_name = g_markup_escape_text((*it)["name"].asString().c_str(), -1);
+    } else {
+      full_name = (*it)["name"].asString();
+    }
+
     std::string windows = "";
-    if (config_["window-format"].isString()) {
+    if (config_["window-rewrite"].isObject()) {
       updateWindows((*it), windows);
     }
+
+    auto index = (*it)["num"].asInt();
+
     if (config_["format"].isString()) {
-      auto format = config_["format"].asString();
-      output = fmt::format(
-          fmt::runtime(format), fmt::arg("icon", getIcon(output, *it)), fmt::arg("value", output),
-          fmt::arg("name", trimWorkspaceName(output)), fmt::arg("index", (*it)["num"].asString()),
-          fmt::arg("windows",
-                   windows.substr(0, windows.length() - m_formatWindowSeparator.length())),
-          fmt::arg("output", (*it)["output"].asString()));
+      std::string format;
+      if (config_["format-for-negative-index"].isString() && index < 0) {
+        format = config_["format-for-negative-index"].asString();
+      } else {
+        format = config_["format"].asString();
+      }
+
+      auto name = trimWorkspaceName(full_name);
+      auto output = (*it)["output"].asString();
+      auto icon = getIcon(full_name, *it);
+      auto separated_windows =
+          windows.substr(0, windows.length() - m_formatWindowSeparator.length());
+
+      full_name =
+          fmt::format(fmt::runtime(format), fmt::arg("index", index), fmt::arg("name", name),
+                      fmt::arg("value", full_name), fmt::arg("output", output),
+                      fmt::arg("icon", icon), fmt::arg("windows", separated_windows));
     }
+
     if (!config_["disable-markup"].asBool()) {
-      static_cast<Gtk::Label *>(button.get_children()[0])->set_markup(output);
+      static_cast<Gtk::Label*>(button.get_children()[0])->set_markup(full_name);
     } else {
-      button.set_label(output);
+      button.set_label(full_name);
     }
     onButtonReady(*it, button);
   }
@@ -354,9 +422,9 @@ auto Workspaces::update() -> void {
   AModule::update();
 }
 
-Gtk::Button &Workspaces::addButton(const Json::Value &node) {
+Gtk::Button& Workspaces::addButton(const Json::Value& node) {
   auto pair = buttons_.emplace(node["name"].asString(), node["name"].asString());
-  auto &&button = pair.first->second;
+  auto&& button = pair.first->second;
   box_.pack_start(button, false, false, 0);
   button.set_name("sway-workspace-" + node["name"].asString());
   button.set_relief(Gtk::RELIEF_NONE);
@@ -369,22 +437,22 @@ Gtk::Button &Workspaces::addButton(const Json::Value &node) {
                                    node["name"].asString(), node["target_output"].asString(),
                                    "--no-auto-back-and-forth", node["name"].asString()));
         } else {
+          std::string flag =
+              config_["disable-auto-back-and-forth"].asBool() ? "--no-auto-back-and-forth" : "";
           if (config_["no-switch-output"].asBool()) {
-            ipc_.sendCmd(IPC_COMMAND, fmt::format("[workspace=\"^{}$\"] move workspace to output current; workspace number {} \"{}\"",
-                                                  node["name"].asString(),
-                                                  config_["disable-auto-back-and-forth"].asBool()
-                                                      ? "--no-auto-back-and-forth"
-                                                      : "",
-                                                  node["name"].asString()));
+            ipc_.sendCmd(IPC_COMMAND,
+                         fmt::format("[workspace=\"^{}$\"] move workspace to output current; "
+                                     "workspace number {} \"{}\"",
+                                     node["name"].asString(), flag, node["name"].asString()));
+          } else if (node["num"].asInt() >= 0) {
+            ipc_.sendCmd(IPC_COMMAND,
+                         fmt::format(workspace_switch_number_cmd_, flag, node["num"].asInt()));
           } else {
-            ipc_.sendCmd(IPC_COMMAND, fmt::format("workspace {} \"{}\"",
-                                                  config_["disable-auto-back-and-forth"].asBool()
-                                                      ? "--no-auto-back-and-forth"
-                                                      : "",
-                                                  node["name"].asString()));
+            ipc_.sendCmd(IPC_COMMAND,
+                         fmt::format(workspace_switch_cmd_, flag, node["name"].asString()));
           }
         }
-      } catch (const std::exception &e) {
+      } catch (const std::exception& e) {
         spdlog::error("Workspaces: {}", e.what());
       }
     });
@@ -392,18 +460,18 @@ Gtk::Button &Workspaces::addButton(const Json::Value &node) {
   return button;
 }
 
-std::string Workspaces::getIcon(const std::string &name, const Json::Value &node) {
+std::string Workspaces::getIcon(const std::string& name, const Json::Value& node) {
   std::vector<std::string> keys = {"high-priority-named", "urgent", "focused", name, "default"};
-  for (auto const &key : keys) {
+  for (auto const& key : keys) {
     if (key == "high-priority-named") {
       auto it = std::find_if(high_priority_named_.begin(), high_priority_named_.end(),
-                             [&](const std::string &member) { return member == name; });
+                             [&](const std::string& member) { return member == name; });
       if (it != high_priority_named_.end()) {
         return config_["format-icons"][name].asString();
       }
 
       it = std::find_if(high_priority_named_.begin(), high_priority_named_.end(),
-                        [&](const std::string &member) {
+                        [&](const std::string& member) {
                           return trimWorkspaceName(member) == trimWorkspaceName(name);
                         });
       if (it != high_priority_named_.end()) {
@@ -426,8 +494,8 @@ std::string Workspaces::getIcon(const std::string &name, const Json::Value &node
   return name;
 }
 
-bool Workspaces::handleScroll(GdkEventScroll *e) {
-  if (gdk_event_get_pointer_emulated((GdkEvent *)e) != 0) {
+bool Workspaces::handleScroll(GdkEventScroll* e) {
+  if (gdk_event_get_pointer_emulated((GdkEvent*)e) != 0) {
     /**
      * Ignore emulated scroll events on window
      */
@@ -442,7 +510,7 @@ bool Workspaces::handleScroll(GdkEventScroll *e) {
     bool alloutputs = config_["all-outputs"].asBool();
     std::lock_guard<std::mutex> lock(mutex_);
     auto it =
-        std::find_if(workspaces_.begin(), workspaces_.end(), [alloutputs](const auto &workspace) {
+        std::find_if(workspaces_.begin(), workspaces_.end(), [alloutputs](const auto& workspace) {
           if (alloutputs) {
             return hasFlag(workspace, "focused");
           }
@@ -469,7 +537,7 @@ bool Workspaces::handleScroll(GdkEventScroll *e) {
   }
   try {
     ipc_.sendCmd(IPC_COMMAND, fmt::format(workspace_switch_cmd_, "--no-auto-back-and-forth", name));
-  } catch (const std::exception &e) {
+  } catch (const std::exception& e) {
     spdlog::error("Workspaces: {}", e.what());
   }
   if (!config_["warp-on-scroll"].isNull() && !config_["warp-on-scroll"].asBool()) {
@@ -496,7 +564,7 @@ std::string Workspaces::getCycleWorkspace(std::vector<Json::Value>::iterator it,
   return (*it)["name"].asString();
 }
 
-std::string Workspaces::trimWorkspaceName(std::string name) {
+std::string Workspaces::trimWorkspaceName(const std::string& name) {
   std::size_t found = name.find(':');
   if (found != std::string::npos) {
     return name.substr(found + 1);
@@ -504,7 +572,7 @@ std::string Workspaces::trimWorkspaceName(std::string name) {
   return name;
 }
 
-bool is_focused_recursive(const Json::Value &node) {
+bool is_focused_recursive(const Json::Value& node) {
   // If a workspace has a focused container then get_tree will say
   // that the workspace itself isn't focused.  Therefore we need to
   // check if any of its nodes are focused as well.
@@ -514,13 +582,13 @@ bool is_focused_recursive(const Json::Value &node) {
     return true;
   }
 
-  for (const auto &child : node["nodes"]) {
+  for (const auto& child : node["nodes"]) {
     if (is_focused_recursive(child)) {
       return true;
     }
   }
 
-  for (const auto &child : node["floating_nodes"]) {
+  for (const auto& child : node["floating_nodes"]) {
     if (is_focused_recursive(child)) {
       return true;
     }
@@ -529,7 +597,7 @@ bool is_focused_recursive(const Json::Value &node) {
   return false;
 }
 
-void Workspaces::onButtonReady(const Json::Value &node, Gtk::Button &button) {
+void Workspaces::onButtonReady(const Json::Value& node, Gtk::Button& button) {
   if (config_["current-only"].asBool()) {
     if (is_focused_recursive(node)) {
       button.show();