Show alerted workspace and app

config/config.lua

@@ -93,22 +93,35 @@ local function render_workspaces(displayName)
     local workspaces = {}
     for _, workspace in pairs(display.workspaces) do
         local app_name = ""
+        local app_alert = ""
         for _, app in pairs(workspace.applications) do
             if app.focus then app_name = app.name end
+            if app.alert then
+            end
+            if app.alert and app_alert == "" then 
+              app_alert = app.name
+            end
         end
         if #workspace.applications == 0 then app_name = "<desktop>" end
         boxcolor = BLACK_BR
+        if workspace.alert then
+            boxcolor = RED
+        end
         if workspace.focus then
             boxcolor = YELLOW
         end
+        local items = {
+            wsbox(label{label=" " .. zen.u.html_escape(workspace.name) .. " "}, boxcolor),
+            wsbox(label{label=zen.u.html_escape(app_name)}, boxcolor),
+        }
+        if app_alert ~= "" and app_alert ~= app_name then
+            table.insert(items, wsbox(label{label=zen.u.html_escape(app_alert)}, RED))
+        end
         local workspace = {
             type = "flex",
             direction = "row",
             padding = { right = 1 },
-            items = {
-                wsbox(label{label=" " .. zen.u.html_escape(workspace.name) .. " "}, boxcolor),
-                wsbox(label{label=zen.u.html_escape(app_name)}, boxcolor),
-            },
+            items = items,
             tag = workspace.name
         }
         table.insert(workspaces, workspace)

src/PowerSource.cpp

@@ -29,7 +29,12 @@ std::shared_ptr<PowerSource> PowerSource::Create(std::shared_ptr<MainLoop> mainl
 
 bool PowerSource::Initialize() {
     m_drawn = m_published = false;
-    m_sourceState = PowerState{.IsPluggedIn = false, .IsCharging = false, .Capacity = 0};
+    m_sourceState = PowerState{
+        .IsAlerted = false,
+        .IsPluggedIn = false,
+        .IsCharging = false,
+        .Capacity = 0,
+    };
     // TODO: Probe that these exists
     m_ac = "/sys/class/power_supply/AC/online";
     // TODO: Always BAT0?

src/ScriptContext.cpp

@@ -322,17 +322,20 @@ void ScriptContextImpl::Publish(const std::string_view name, const Displays& dis
                 auto applicationTable = m_lua.create_table();
                 applicationTable["name"] = application.name;
                 applicationTable["focus"] = application.isFocused;
+                applicationTable["alert"] = application.isAlerted;
                 applicationTable["appid"] = application.appId;
                 applicationsTable.add(applicationTable);
             }
             workspaceTable["name"] = workspace.name;
             workspaceTable["focus"] = workspace.isFocused;
+            workspaceTable["alert"] = workspace.isAlerted;
             workspaceTable["applications"] = applicationsTable;
             workspacesTable.add(workspaceTable);
         }
         displayTable["workspaces"] = workspacesTable;
         spdlog::debug("Display {} focus: {}", display.name, display.isFocused);
         displayTable["focus"] = display.isFocused;
+        displayTable["alert"] = display.isAlerted;
         displaysTable[display.name] = displayTable;
     }
     m_lua["zen"][name] = displaysTable;

src/ScriptContext.h

@@ -16,19 +16,22 @@ struct Application {
     std::string name;
     std::string appId;
     bool isFocused;
+    bool isAlerted;
 };
 
 struct Workspace {
-    Workspace(const std::string name_) : name(name_), isFocused(false) {}
+    Workspace(const std::string name_) : name(name_), isFocused(false), isAlerted(false) {}
     std::string name;
     bool isFocused;  // Has the focused application
+    bool isAlerted;  // Has an alerted application
     std::vector<Application> applications;
 };
 
 struct Display {
-    Display(const std::string& name_) : name(name_), isFocused(false) {}
+    Display(const std::string& name_) : name(name_), isFocused(false), isAlerted(false) {}
     std::string name;
     bool isFocused;  // Has the focused workspace
+    bool isAlerted;  // Has an alerted workspace (or application)
     std::vector<Workspace> workspaces;
 };
 

src/SwayCompositor.cpp

@@ -81,10 +81,19 @@ static std::string GetString(basic_json<> node, const char *attr) {
     return v.get<std::string>();
 }
 
+static bool GetBool(basic_json<> node, const char *attr, bool whenMissing) {
+    auto x = node[attr];
+    if (x.is_null()) return whenMissing;
+    if (!x.is_boolean()) return whenMissing;  // TODO: Warn
+    return x.get<bool>();
+}
+
 static std::string GetName(basic_json<> node) { return GetString(node, "name"); }
 
 static bool GetFocused(basic_json<> node) { return node["focused"].get<bool>(); }
 
+static bool GetUrgent(basic_json<> node) { return GetBool(node, "urgent", false); }
+
 static void ParseBarStateUpdateEvent(const std::string &payload, bool &visibleByModifier) {
     auto rootNode = json::parse(payload, Filter, false /*ignore exceptions*/);
     if (rootNode.is_discarded()) {
@@ -118,7 +127,8 @@ static void ParseApplication(Workspace &workspace, nlohmann::basic_json<> applic
     }
     auto application = Application{.name = GetName(applicationNode),
                                    .appId = GetString(applicationNode, "app_id"),
-                                   .isFocused = false};
+                                   .isFocused = false,
+                                   .isAlerted = false};
     int applicationId = applicationNode["id"].get<int>();
     // In sway the only focused app is the one in the focused workspace. When that app is focused
     // the workspace is not. To simplify usage this considers the focused app in a non focused
@@ -129,6 +139,8 @@ static void ParseApplication(Workspace &workspace, nlohmann::basic_json<> applic
     } else {
         application.isFocused = applicationId == nextFocusId;
     }
+    application.isAlerted = GetUrgent(applicationNode);
+    workspace.isAlerted = workspace.isAlerted || application.isAlerted;
     workspace.applications.push_back(std::move(application));
 }
 
@@ -171,6 +183,7 @@ static std::optional<Displays> ParseTree(const std::string &payload) {
                 continue;
             }
             auto workspace = Workspace(GetName(workspaceNode));
+            workspace.isAlerted = GetUrgent(workspaceNode);
             //   Better way?
             auto focusNode = workspaceNode["focus"];
             int nextFocusId = -1;
@@ -187,6 +200,7 @@ static std::optional<Displays> ParseTree(const std::string &payload) {
                 ParseApplication(workspace, applicationNode, nextFocusId);
             }
             display.isFocused = display.isFocused || workspace.isFocused;
+            display.isAlerted = display.isAlerted || workspace.isAlerted;
             display.workspaces.push_back(std::move(workspace));
         }
         displays.push_back(std::move(display));