/* SwBr (swbr) — a floating layer-shell bar for Sway
 *
 * Sits on top of the tiled windows at the screen edge, does not steal space
 * from them. Hover it and press space to fold it into a thin signal strip.
 *
 * Dependencies:
 *   - libwayland-client   (the only library you link)
 *   - stb_truetype.h      (vendored single-header — smooth fonts)
 * The wlr-layer-shell protocol glue is vendored below, so there is no
 * wayland-scanner step and nothing else to install.
 *
 * Build:
 *   cc -std=c11 -O2 -Wall -Wextra -o swbr swbr.c -lwayland-client -lm
 *
 * Runtime deps: a running Sway session ($SWAYSOCK). No jq, no shell-outs:
 * the program talks to the Sway IPC socket directly. fontconfig (fc-match)
 * is used if present to pick a font, otherwise known paths are tried.
 *
 * See --help for every option (all config keys also work on the command line).
 */

/* ---------------------------------------------------------------------------
 * How this file is laid out (top to bottom):
 *   1. small helpers        colors, string trim, hex-color + tilde parsing
 *   2. layer-shell glue     vendored wlr-layer-shell-unstable-v1 marshalling
 *   3. JSON                 the tiny parser used for sway's replies
 *   4. sway ipc             request/subscribe socket, workspaces, mode
 *   5. Config               the struct, defaults, key=value setter, file loader
 *   6. text (Font)          stb_truetype glyph cache, software blitting
 *   7. paint                ARGB32 buffer, rounded rectangles, clipping
 *   8. markup               the pango subset (<span foreground=..>, <b>, &amp;)
 *   9. status               the status_command child process and its lines
 *  10. wayland              globals, one Bar per output, shm, pointer, keys
 *  11. render               the expanded bar and the collapsed signal strip
 *  12. usage()/dump_config  --help text and the default config generator
 *  13. main()               setup, then the poll loop
 * ------------------------------------------------------------------------- */

#define _POSIX_C_SOURCE 200809L
#define _GNU_SOURCE

#include <wayland-client.h>

#define STB_TRUETYPE_IMPLEMENTATION
#include "stb_truetype.h"

#include <ctype.h>
#include <errno.h>
#include <dirent.h>
#include <fcntl.h>
#include <limits.h>
#include <math.h>
#include <poll.h>
#include <signal.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/un.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>

#include "sw_theme.h"

#define APP_ID          "swbr"
#define SWBR_VERSION  "0.11.0"
#ifndef SWBR_BUILD                 /* set by the Makefile: md5 of this file */
#define SWBR_BUILD "unknown"
#endif
#define MAX_WORKSPACES  64
#define MAX_OUTPUTS     8
#define MAX_RUNS        128
#define MAX_BINDS       10
#define MAX_CELLS       24

enum { SLIM_AUTO, SLIM_TICK, SLIM_BAR, SLIM_CLOCK, SLIM_PRESENCE,
       SLIM_MEDIA, SLIM_OFF };

/* ------------------------------------------------------------------ util */

static void die(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    fputs("swbr: ", stderr);
    vfprintf(stderr, fmt, ap);
    va_end(ap);
    fputc('\n', stderr);
    exit(1);
}

static void *xmalloc(size_t n)
{
    void *p = malloc(n ? n : 1);
    if (!p) die("out of memory");
    return p;
}

static void *xrealloc(void *p, size_t n)
{
    void *q = realloc(p, n ? n : 1);
    if (!q) die("out of memory");
    return q;
}

static void str_set(char *dst, size_t cap, const char *src)
{
    if (!cap) return;
    size_t n = strlen(src);
    if (n >= cap) n = cap - 1;
    memcpy(dst, src, n);
    dst[n] = 0;
}

static char *trim(char *s)
{
    while (*s && isspace((unsigned char)*s)) s++;
    if (!*s) return s;
    char *e = s + strlen(s) - 1;
    while (e > s && isspace((unsigned char)*e)) *e-- = 0;
    return s;
}

static bool file_exists(const char *p)
{
    struct stat st;
    return stat(p, &st) == 0 && S_ISREG(st.st_mode);
}

static float clampf(float v, float lo, float hi) { return v < lo ? lo : (v > hi ? hi : v); }
static int   clampi(int v, int lo, int hi)       { return v < lo ? lo : (v > hi ? hi : v); }

static uint32_t now_ms(void)
{
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return (uint32_t)(ts.tv_sec * 1000u + ts.tv_nsec / 1000000u);
}

typedef struct { uint8_t r, g, b, a; } Col;

static void parse_color(const char *s, Col *out)
{
    if (*s == '#') s++;
    unsigned r, g, b, a = 255;
    if (strlen(s) >= 8 && sscanf(s, "%2x%2x%2x%2x", &r, &g, &b, &a) == 4) { }
    else if (sscanf(s, "%2x%2x%2x", &r, &g, &b) == 3) { }
    else return;
    out->r = (uint8_t)r; out->g = (uint8_t)g; out->b = (uint8_t)b; out->a = (uint8_t)a;
}

/* expand a leading ~/ to $HOME (no shell involved) */
static void expand_tilde(const char *in, char *out, size_t n)
{
    if (in[0] == '~' && (in[1] == '/' || in[1] == 0)) {
        const char *home = getenv("HOME");
        if (home) { snprintf(out, n, "%s%s", home, in + 1); return; }
    }
    snprintf(out, n, "%s", in);
}

/* ----------------------------------------------- cursor-shape-v1 glue */
/* Vendored equivalent of what wayland-scanner emits for
 * cursor-shape-v1.xml. Two interfaces and two requests: ask the compositor
 * for a named cursor over our surface, rather than shipping a cursor theme
 * and drawing one ourselves. Absent on an older compositor, in which case
 * nothing here runs and the pointer keeps whatever shape it had. */

struct wp_cursor_shape_manager_v1;
struct wp_cursor_shape_device_v1;

extern const struct wl_interface wp_cursor_shape_device_v1_interface;

static const struct wl_interface *swbr_cs_types[] = {
    NULL, NULL,
    &wp_cursor_shape_device_v1_interface,
    &wl_pointer_interface,
    NULL, NULL,
};

static const struct wl_message wp_cursor_shape_manager_v1_requests[] = {
    { "destroy", "", swbr_cs_types + 0 },
    { "get_pointer", "no", swbr_cs_types + 2 },
    { "get_tablet_tool_v2", "no", swbr_cs_types + 4 },
};
static const struct wl_interface wp_cursor_shape_manager_v1_interface = {
    "wp_cursor_shape_manager_v1", 1, 3, wp_cursor_shape_manager_v1_requests, 0, NULL,
};

static const struct wl_message wp_cursor_shape_device_v1_requests[] = {
    { "destroy", "", swbr_cs_types + 0 },
    { "set_shape", "uu", swbr_cs_types + 0 },
};
const struct wl_interface wp_cursor_shape_device_v1_interface = {
    "wp_cursor_shape_device_v1", 1, 2, wp_cursor_shape_device_v1_requests, 0, NULL,
};

enum wp_cursor_shape_device_v1_shape {
    WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_DEFAULT = 1,
    WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_POINTER = 4,
};

static struct wp_cursor_shape_device_v1 *
wp_cursor_shape_manager_v1_get_pointer(struct wp_cursor_shape_manager_v1 *m,
                                       struct wl_pointer *p)
{
    struct wl_proxy *id = wl_proxy_marshal_flags(
        (struct wl_proxy *)m, 1, &wp_cursor_shape_device_v1_interface,
        wl_proxy_get_version((struct wl_proxy *)m), 0, NULL, p);
    return (struct wp_cursor_shape_device_v1 *)id;
}

static void wp_cursor_shape_device_v1_set_shape(struct wp_cursor_shape_device_v1 *d,
                                                uint32_t serial, uint32_t shape)
{
    wl_proxy_marshal_flags((struct wl_proxy *)d, 1, NULL,
                           wl_proxy_get_version((struct wl_proxy *)d), 0,
                           serial, shape);
}

/* ------------------------------------------------- wlr-layer-shell glue */
/* Vendored equivalent of what wayland-scanner emits for
 * wlr-layer-shell-unstable-v1.xml (Copyright (c) 2017 Drew DeVault, MIT-ish;
 * see the protocol file for the full notice). Only the requests and events
 * swbr actually uses are wrapped; get_popup is present in the table so the
 * opcodes line up, but is never called, hence its NULL type entry. */

enum zwlr_layer_shell_v1_layer {
    ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND = 0,
    ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM     = 1,
    ZWLR_LAYER_SHELL_V1_LAYER_TOP        = 2,
    ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY    = 3
};
enum zwlr_layer_surface_v1_anchor {
    ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP    = 1,
    ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM = 2,
    ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT   = 4,
    ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT  = 8
};
enum zwlr_layer_surface_v1_keyboard_interactivity {
    ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE      = 0,
    ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE = 1,
    ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND = 2
};

struct zwlr_layer_shell_v1;
struct zwlr_layer_surface_v1;

extern const struct wl_interface zwlr_layer_surface_v1_interface;

static const struct wl_interface *swbr_ls_types[] = {
    NULL, NULL, NULL, NULL,
    &zwlr_layer_surface_v1_interface,
    &wl_surface_interface,
    &wl_output_interface,
    NULL, NULL, NULL,
};

static const struct wl_message zwlr_layer_shell_v1_requests[] = {
    { "get_layer_surface", "no?ous", swbr_ls_types + 4 },
    { "destroy", "3", swbr_ls_types + 0 },
};
static const struct wl_interface zwlr_layer_shell_v1_interface = {
    "zwlr_layer_shell_v1", 4, 2, zwlr_layer_shell_v1_requests, 0, NULL,
};

static const struct wl_message zwlr_layer_surface_v1_requests[] = {
    { "set_size", "uu", swbr_ls_types + 0 },
    { "set_anchor", "u", swbr_ls_types + 0 },
    { "set_exclusive_zone", "i", swbr_ls_types + 0 },
    { "set_margin", "iiii", swbr_ls_types + 0 },
    { "set_keyboard_interactivity", "u", swbr_ls_types + 0 },
    { "get_popup", "o", swbr_ls_types + 9 },
    { "ack_configure", "u", swbr_ls_types + 0 },
    { "destroy", "", swbr_ls_types + 0 },
    { "set_layer", "2u", swbr_ls_types + 0 },
};
static const struct wl_message zwlr_layer_surface_v1_events[] = {
    { "configure", "uuu", swbr_ls_types + 0 },
    { "closed", "", swbr_ls_types + 0 },
};
const struct wl_interface zwlr_layer_surface_v1_interface = {
    "zwlr_layer_surface_v1", 4, 9, zwlr_layer_surface_v1_requests,
    2, zwlr_layer_surface_v1_events,
};

struct zwlr_layer_surface_v1_listener {
    void (*configure)(void *data, struct zwlr_layer_surface_v1 *s,
                      uint32_t serial, uint32_t width, uint32_t height);
    void (*closed)(void *data, struct zwlr_layer_surface_v1 *s);
};

#define LS_REQ_SET_SIZE        0
#define LS_REQ_SET_ANCHOR      1
#define LS_REQ_SET_EXCLUSIVE   2
#define LS_REQ_SET_MARGIN      3
#define LS_REQ_SET_KBD         4
#define LS_REQ_ACK_CONFIGURE   6
#define LS_REQ_DESTROY         7

static struct zwlr_layer_surface_v1 *
zwlr_layer_shell_v1_get_layer_surface(struct zwlr_layer_shell_v1 *shell,
                                      struct wl_surface *surface,
                                      struct wl_output *output,
                                      uint32_t layer, const char *ns)
{
    struct wl_proxy *id = wl_proxy_marshal_flags(
        (struct wl_proxy *)shell, 0, &zwlr_layer_surface_v1_interface,
        wl_proxy_get_version((struct wl_proxy *)shell), 0,
        NULL, surface, output, layer, ns);
    return (struct zwlr_layer_surface_v1 *)id;
}

static int zwlr_layer_surface_v1_add_listener(struct zwlr_layer_surface_v1 *s,
                                              const struct zwlr_layer_surface_v1_listener *l,
                                              void *data)
{
    return wl_proxy_add_listener((struct wl_proxy *)s, (void (**)(void))l, data);
}

static void ls_set_size(struct zwlr_layer_surface_v1 *s, uint32_t w, uint32_t h)
{ wl_proxy_marshal_flags((struct wl_proxy *)s, LS_REQ_SET_SIZE, NULL,
                         wl_proxy_get_version((struct wl_proxy *)s), 0, w, h); }
static void ls_set_anchor(struct zwlr_layer_surface_v1 *s, uint32_t a)
{ wl_proxy_marshal_flags((struct wl_proxy *)s, LS_REQ_SET_ANCHOR, NULL,
                         wl_proxy_get_version((struct wl_proxy *)s), 0, a); }
static void ls_set_exclusive_zone(struct zwlr_layer_surface_v1 *s, int32_t z)
{ wl_proxy_marshal_flags((struct wl_proxy *)s, LS_REQ_SET_EXCLUSIVE, NULL,
                         wl_proxy_get_version((struct wl_proxy *)s), 0, z); }
static void ls_set_margin(struct zwlr_layer_surface_v1 *s, int32_t t, int32_t r,
                          int32_t b, int32_t l)
{ wl_proxy_marshal_flags((struct wl_proxy *)s, LS_REQ_SET_MARGIN, NULL,
                         wl_proxy_get_version((struct wl_proxy *)s), 0, t, r, b, l); }
static void ls_set_keyboard(struct zwlr_layer_surface_v1 *s, uint32_t k)
{ wl_proxy_marshal_flags((struct wl_proxy *)s, LS_REQ_SET_KBD, NULL,
                         wl_proxy_get_version((struct wl_proxy *)s), 0, k); }
static void ls_ack_configure(struct zwlr_layer_surface_v1 *s, uint32_t serial)
{ wl_proxy_marshal_flags((struct wl_proxy *)s, LS_REQ_ACK_CONFIGURE, NULL,
                         wl_proxy_get_version((struct wl_proxy *)s), 0, serial); }
static void ls_destroy(struct zwlr_layer_surface_v1 *s)
{ wl_proxy_marshal_flags((struct wl_proxy *)s, LS_REQ_DESTROY, NULL,
                         wl_proxy_get_version((struct wl_proxy *)s),
                         WL_MARSHAL_FLAG_DESTROY); }

/* ------------------------------------------------------------------ json */

typedef enum { J_NULL, J_BOOL, J_NUM, J_STR, J_ARR, J_OBJ } JType;

typedef struct JV {
    JType type;
    bool b;
    double num;
    char *str;
    struct JV **items;
    char **keys;
    int count, cap;
} JV;

static JV *jnew(JType t)
{
    JV *v = (JV *)xmalloc(sizeof(JV));
    memset(v, 0, sizeof(*v));
    v->type = t;
    return v;
}

static void jfree(JV *v)
{
    if (!v) return;
    for (int i = 0; i < v->count; ++i) {
        if (v->keys) free(v->keys[i]);
        jfree(v->items[i]);
    }
    free(v->items);
    free(v->keys);
    free(v->str);
    free(v);
}

static void jpush(JV *v, char *key, JV *child)
{
    if (v->count == v->cap) {
        v->cap = v->cap ? v->cap * 2 : 8;
        v->items = (JV **)xrealloc(v->items, (size_t)v->cap * sizeof(JV *));
        v->keys  = (char **)xrealloc(v->keys, (size_t)v->cap * sizeof(char *));
    }
    v->keys[v->count] = key;
    v->items[v->count++] = child;
}

static const char *jskip_ws(const char *p)
{
    while (*p && (unsigned char)*p <= ' ') p++;
    return p;
}

static void utf8_append(char **s, int *len, int *cap, unsigned cp)
{
    char tmp[4];
    int n = 0;
    if (cp < 0x80) { tmp[n++] = (char)cp; }
    else if (cp < 0x800) { tmp[n++] = (char)(0xC0 | (cp >> 6)); tmp[n++] = (char)(0x80 | (cp & 0x3F)); }
    else if (cp < 0x10000) {
        tmp[n++] = (char)(0xE0 | (cp >> 12));
        tmp[n++] = (char)(0x80 | ((cp >> 6) & 0x3F));
        tmp[n++] = (char)(0x80 | (cp & 0x3F));
    } else {
        tmp[n++] = (char)(0xF0 | (cp >> 18));
        tmp[n++] = (char)(0x80 | ((cp >> 12) & 0x3F));
        tmp[n++] = (char)(0x80 | ((cp >> 6) & 0x3F));
        tmp[n++] = (char)(0x80 | (cp & 0x3F));
    }
    while (*len + n + 1 > *cap) { *cap *= 2; *s = (char *)xrealloc(*s, (size_t)*cap); }
    memcpy(*s + *len, tmp, (size_t)n);
    *len += n;
    (*s)[*len] = 0;
}

static const char *jparse_string(const char *p, char **out)
{
    p++;                                  /* opening quote */
    int cap = 32, len = 0;
    char *s = (char *)xmalloc((size_t)cap);
    s[0] = 0;
    while (*p && *p != '"') {
        if (*p == '\\') {
            p++;
            unsigned cp;
            switch (*p++) {
            case 'n': cp = '\n'; break;
            case 't': cp = '\t'; break;
            case 'r': cp = '\r'; break;
            case 'b': cp = '\b'; break;
            case 'f': cp = '\f'; break;
            case '/': cp = '/';  break;
            case '\\': cp = '\\'; break;
            case '"': cp = '"';  break;
            case 'u': {
                unsigned v = 0;
                for (int i = 0; i < 4 && isxdigit((unsigned char)*p); ++i) {
                    char c = *p++;
                    v = v * 16 + (unsigned)(isdigit((unsigned char)c) ? c - '0'
                                            : (tolower(c) - 'a' + 10));
                }
                cp = v;
                if (cp >= 0xD800 && cp <= 0xDBFF && p[0] == '\\' && p[1] == 'u') {
                    p += 2;
                    unsigned lo = 0;
                    for (int i = 0; i < 4 && isxdigit((unsigned char)*p); ++i) {
                        char c = *p++;
                        lo = lo * 16 + (unsigned)(isdigit((unsigned char)c) ? c - '0'
                                                  : (tolower(c) - 'a' + 10));
                    }
                    cp = 0x10000 + ((cp - 0xD800) << 10) + (lo - 0xDC00);
                }
                break;
            }
            default:
                if (!p[-1]) { free(s); *out = NULL; return NULL; }
                cp = (unsigned char)p[-1];
                break;
            }
            utf8_append(&s, &len, &cap, cp);
        } else {
            if (len + 2 > cap) { cap *= 2; s = (char *)xrealloc(s, (size_t)cap); }
            s[len++] = *p++;
            s[len] = 0;
        }
    }
    if (*p != '"') { free(s); *out = NULL; return NULL; }
    *out = s;
    return p + 1;
}

static const char *jparse_value(const char *p, JV **out);

static const char *jparse_container(const char *p, JV **out, bool is_obj)
{
    JV *v = jnew(is_obj ? J_OBJ : J_ARR);
    p = jskip_ws(p + 1);
    char close = is_obj ? '}' : ']';
    if (*p == close) { *out = v; return p + 1; }

    for (;;) {
        char *key = NULL;
        if (is_obj) {
            p = jskip_ws(p);
            if (*p != '"') { jfree(v); return NULL; }
            p = jparse_string(p, &key);
            if (!p) { jfree(v); return NULL; }
            p = jskip_ws(p);
            if (*p != ':') { free(key); jfree(v); return NULL; }
            p++;
        }
        JV *child = NULL;
        p = jparse_value(jskip_ws(p), &child);
        if (!p) { free(key); jfree(v); return NULL; }
        jpush(v, key, child);

        p = jskip_ws(p);
        if (*p == ',') { p++; continue; }
        if (*p == close) { p++; break; }
        jfree(v);
        return NULL;
    }
    *out = v;
    return p;
}

static const char *jparse_value(const char *p, JV **out)
{
    p = jskip_ws(p);
    switch (*p) {
    case '{': return jparse_container(p, out, true);
    case '[': return jparse_container(p, out, false);
    case '"': {
        JV *v = jnew(J_STR);
        p = jparse_string(p, &v->str);
        if (!p) { jfree(v); return NULL; }
        *out = v;
        return p;
    }
    case 't':
        if (strncmp(p, "true", 4)) return NULL;
        *out = jnew(J_BOOL); (*out)->b = true; return p + 4;
    case 'f':
        if (strncmp(p, "false", 5)) return NULL;
        *out = jnew(J_BOOL); (*out)->b = false; return p + 5;
    case 'n':
        if (strncmp(p, "null", 4)) return NULL;
        *out = jnew(J_NULL); return p + 4;
    default: {
        char *end = NULL;
        double d = strtod(p, &end);
        if (end == p) return NULL;
        JV *v = jnew(J_NUM);
        v->num = d;
        *out = v;
        return end;
    }
    }
}

static JV *jparse(const char *text)
{
    JV *v = NULL;
    const char *p = jparse_value(text, &v);
    if (!p) { jfree(v); return NULL; }
    return v;
}

static JV *jget(const JV *o, const char *key)
{
    if (!o || o->type != J_OBJ) return NULL;
    for (int i = 0; i < o->count; ++i)
        if (o->keys[i] && strcmp(o->keys[i], key) == 0) return o->items[i];
    return NULL;
}

static const char *jstr(const JV *o, const char *key, const char *def)
{
    JV *v = jget(o, key);
    return (v && v->type == J_STR) ? v->str : def;
}

static int jint(const JV *o, const char *key, int def)
{
    JV *v = jget(o, key);
    return (v && v->type == J_NUM) ? (int)v->num : def;
}

static bool jbool(const JV *o, const char *key, bool def)
{
    JV *v = jget(o, key);
    return (v && v->type == J_BOOL) ? v->b : def;
}

/* -------------------------------------------------------------- sway ipc */

enum {
    IPC_RUN_COMMAND    = 0,
    IPC_GET_WORKSPACES = 1,
    IPC_SUBSCRIBE      = 2,
    IPC_GET_OUTPUTS    = 3,
    IPC_GET_TREE       = 4
};

static int sway_fd = -1;      /* request socket */
static int sway_evt_fd = -1;  /* event socket   */

static int sway_connect(void)
{
    const char *path = getenv("SWAYSOCK");
    if (!path || !*path) path = getenv("I3SOCK");
    if (!path || !*path) return -1;

    int fd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (fd < 0) return -1;

    struct sockaddr_un addr;
    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;
    str_set(addr.sun_path, sizeof(addr.sun_path), path);
    if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        close(fd);
        return -1;
    }
    return fd;
}

static bool write_all(int fd, const void *buf, size_t n)
{
    const char *p = (const char *)buf;
    while (n) {
        ssize_t w = write(fd, p, n);
        if (w < 0) { if (errno == EINTR) continue; return false; }
        p += w;
        n -= (size_t)w;
    }
    return true;
}

static bool read_all(int fd, void *buf, size_t n)
{
    char *p = (char *)buf;
    while (n) {
        ssize_t r = read(fd, p, n);
        if (r < 0) { if (errno == EINTR) continue; return false; }
        if (r == 0) return false;
        p += r;
        n -= (size_t)r;
    }
    return true;
}

/* Returns a malloc'ed, NUL-terminated payload (caller frees), or NULL. */
static char *sway_request(uint32_t type, const char *payload)
{
    if (sway_fd < 0) return NULL;

    size_t plen = payload ? strlen(payload) : 0;
    char hdr[14];
    memcpy(hdr, "i3-ipc", 6);
    uint32_t l = (uint32_t)plen, t = type;
    memcpy(hdr + 6, &l, 4);
    memcpy(hdr + 10, &t, 4);

    if (!write_all(sway_fd, hdr, sizeof(hdr))) return NULL;
    if (plen && !write_all(sway_fd, payload, plen)) return NULL;

    char rhdr[14];
    if (!read_all(sway_fd, rhdr, sizeof(rhdr))) return NULL;
    if (memcmp(rhdr, "i3-ipc", 6) != 0) return NULL;

    uint32_t rlen = 0;
    memcpy(&rlen, rhdr + 6, 4);
    if (rlen > (64u << 20)) return NULL;

    char *body = (char *)xmalloc(rlen + 1);
    if (rlen && !read_all(sway_fd, body, rlen)) { free(body); return NULL; }
    body[rlen] = 0;
    return body;
}

/* Everything swbr asks the compositor to do, counted. Sway allocates for
 * each of these, so if its heap is growing while swbr runs, the answer is in
 * these numbers. SWBR_TRACE=1 prints them every five seconds. */
static struct {
    unsigned commit, resize, pool, region, ack;
    unsigned ipc_tree, ipc_ws, ipc_other;
    unsigned long ipc_bytes;
} wl_count;
static bool wl_trace;

static void wl_trace_tick(void)
{
    if (!wl_trace) return;
    static uint32_t next;
    uint32_t now = now_ms();
    if (next && (int32_t)(now - next) < 0) return;
    next = now + 5000;
    fprintf(stderr, "swbr: per 5s — commits %u, resizes %u, pools %u, "
                    "regions %u, configures %u\n"
                    "swbr:           ipc: %u tree, %u workspaces, %u other, "
                    "%lu KiB back\n",
            wl_count.commit, wl_count.resize, wl_count.pool,
            wl_count.region, wl_count.ack,
            wl_count.ipc_tree, wl_count.ipc_ws, wl_count.ipc_other,
            wl_count.ipc_bytes / 1024);
    memset(&wl_count, 0, sizeof(wl_count));
}

static JV *sway_query(uint32_t type);

/* The whole tree is the most expensive thing swbr asks sway for — it builds
 * and serialises the lot every time. The cpu sampler wants it, and so does
 * every window cell, so they share one for a couple of seconds rather than
 * each asking. Fewer, larger allocations on the compositor's side, and less
 * of swbr's own time spent parsing the same JSON twice. */
static int      no_tree_flag;      /* mirrors cfg.no_tree, set once config
                                     parsing is done                       */
static int      tree_min_ms = 5000;   /* never more often than this */
static JV      *tree_cache;
static uint32_t tree_cache_at;

/* Polling this every couple of seconds made sway grow by roughly six times
 * the size of each reply and never give it back — a compositor bug, but one
 * swbr was leaning on twenty thousand times a night. It is asked for only
 * when sway has said something changed, and never more often than
 * tree_min_s. An idle session fetches it once, at startup, and then not
 * again. */
static bool     tree_dirty = true;

static const JV *sway_tree_cached(void)
{
    if (no_tree_flag) return NULL;     /* for finding out whether it is us */

    uint32_t now = now_ms();
    if (tree_cache && !tree_dirty) return tree_cache;
    if (tree_cache && (int32_t)(now - tree_cache_at) < tree_min_ms) return tree_cache;

    jfree(tree_cache);
    tree_cache = sway_query(IPC_GET_TREE);
    tree_cache_at = now;
    tree_dirty = false;
    return tree_cache;
}

static void sway_tree_forget(void) { tree_dirty = true; }

static JV *sway_query(uint32_t type)
{
    char *body = sway_request(type, NULL);
    if (!body) return NULL;

    if (type == IPC_GET_TREE)            wl_count.ipc_tree++;
    else if (type == IPC_GET_WORKSPACES) wl_count.ipc_ws++;
    else                                 wl_count.ipc_other++;
    wl_count.ipc_bytes += strlen(body);

    JV *v = jparse(body);
    free(body);
    return v;
}

static bool sway_cmd(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    int n = vsnprintf(NULL, 0, fmt, ap);
    va_end(ap);
    if (n < 0) return false;

    char *cmd = (char *)xmalloc((size_t)n + 1);
    va_start(ap, fmt);
    vsnprintf(cmd, (size_t)n + 1, fmt, ap);
    va_end(ap);

    char *reply = sway_request(IPC_RUN_COMMAND, cmd);
    free(cmd);
    if (!reply) return false;

    bool ok = true;
    JV *v = jparse(reply);
    if (v && v->type == J_ARR)
        for (int i = 0; i < v->count; ++i)
            if (!jbool(v->items[i], "success", true)) ok = false;
    jfree(v);
    free(reply);
    return ok;
}

/* A second socket carries workspace/mode events, so the bar repaints when
 * sway says something changed instead of polling the tree. */
static bool sway_subscribe_events(void)
{
    sway_evt_fd = sway_connect();
    if (sway_evt_fd < 0) return false;

    const char *payload = "[\"workspace\",\"mode\",\"window\"]";
    char hdr[14];
    memcpy(hdr, "i3-ipc", 6);
    uint32_t l = (uint32_t)strlen(payload), t = IPC_SUBSCRIBE;
    memcpy(hdr + 6, &l, 4);
    memcpy(hdr + 10, &t, 4);

    if (!write_all(sway_evt_fd, hdr, sizeof(hdr)) ||
        !write_all(sway_evt_fd, payload, l)) {
        close(sway_evt_fd);
        sway_evt_fd = -1;
        return false;
    }
    char rhdr[14];
    uint32_t rlen = 0;
    if (!read_all(sway_evt_fd, rhdr, sizeof(rhdr))) {
        close(sway_evt_fd); sway_evt_fd = -1; return false;
    }
    memcpy(&rlen, rhdr + 6, 4);
    if (rlen && rlen < (1u << 20)) {
        char *body = (char *)xmalloc(rlen + 1);
        read_all(sway_evt_fd, body, rlen);
        free(body);
    }
    int flags = fcntl(sway_evt_fd, F_GETFL, 0);
    if (flags >= 0) fcntl(sway_evt_fd, F_SETFL, flags | O_NONBLOCK);
    return true;
}

/* true when sway reported at least one change since the last call. The mode
 * name is picked out of "mode" events on the way past. */
static char sway_mode[128] = "default";

static bool ws_stale;            /* an event changed the set, not just the focus */
static bool ws_apply_event(const JV *cur);

/* The focus order, most recent first, left where swov can find it. Small
 * enough that writing it on every focus change costs nothing worth counting;
 * it is one line per window and never more than a few dozen. */
#define FOCUS_MAX 32
static int focus_ring[FOCUS_MAX];
static int focus_n;

static void focus_seen(int con_id)
{
    for (int i = 0; i < focus_n; ++i)             /* already known: move up */
        if (focus_ring[i] == con_id) {
            memmove(focus_ring + 1, focus_ring, (size_t)i * sizeof(int));
            focus_ring[0] = con_id;
            goto write;
        }
    if (focus_n < FOCUS_MAX) focus_n++;
    memmove(focus_ring + 1, focus_ring, (size_t)(focus_n - 1) * sizeof(int));
    focus_ring[0] = con_id;

write:;
    const char *rt = getenv("XDG_RUNTIME_DIR");
    if (!rt || !*rt) return;
    char path[512], tmp[540];
    snprintf(path, sizeof(path), "%s/swbr-focus", rt);
    snprintf(tmp, sizeof(tmp), "%s.tmp", path);
    FILE *f = fopen(tmp, "w");
    if (!f) return;
    for (int i = 0; i < focus_n; ++i) fprintf(f, "%d\n", focus_ring[i]);
    fclose(f);
    if (rename(tmp, path) != 0) unlink(tmp);
}

static bool sway_events_pending(void)
{
    if (sway_evt_fd < 0) return false;
    bool any = false;

    for (;;) {
        char hdr[14];
        ssize_t r = recv(sway_evt_fd, hdr, sizeof(hdr), MSG_DONTWAIT);
        if (r <= 0) break;
        if ((size_t)r < sizeof(hdr) &&
            !read_all(sway_evt_fd, hdr + r, sizeof(hdr) - (size_t)r)) break;

        uint32_t rlen = 0, rtype = 0;
        memcpy(&rlen, hdr + 6, 4);
        memcpy(&rtype, hdr + 10, 4);
        if (rlen > (16u << 20)) break;

        char *body = (char *)xmalloc(rlen + 1);
        if (rlen && !read_all(sway_evt_fd, body, rlen)) { free(body); break; }
        body[rlen] = 0;

        /* 0x80000002 = mode, 0x80000000 = workspace, 0x80000003 = window */
        if (rtype == 0x80000002u) {
            JV *v = jparse(body);
            if (v) str_set(sway_mode, sizeof(sway_mode), jstr(v, "change", "default"));
            jfree(v);
        }

        if (rtype == 0x80000000u) {                       /* workspace */
            tree_dirty = true;
            JV *v = jparse(body);
            const char *ch = v ? jstr(v, "change", "") : "";
            /* A switch only moves the highlight, so it can be applied from
             * the event. Anything else changes the set of workspaces and
             * needs a fresh list — and once one event in a batch has said
             * so, a later focus must not talk us out of it. Switching to a
             * brand new workspace arrives as init and then focus: believing
             * the focus left the new workspace out of the list entirely and
             * lit up whichever one happened to match. */
            if (!(!strcmp(ch, "focus") || !strcmp(ch, "urgent")) ||
                !ws_apply_event(jget(v, "current")))
                ws_stale = true;
            jfree(v);
        }

        if (rtype == 0x80000003u) {
            /* Which window was last focused, and the one before that. swbr
             * is the only thing here that watches all day, so it is the only
             * thing that can know; swov reads the list to offer "the app you
             * were just in". */
            JV *fv = jparse(body);
            if (fv && !strcmp(jstr(fv, "change", ""), "focus")) {
                int id = jint(jget(fv, "container"), "id", 0);
                if (id > 0) focus_seen(id);
            }
            jfree(fv);
        }

        if (rtype == 0x80000003u) {
            /* Only the changes that move a window between workspaces matter
             * here. A title change does not — and a terminal retitling
             * itself on every prompt would otherwise keep asking sway for
             * the tree, which is the thing worth not doing. */
            JV *v = jparse(body);
            const char *ch = v ? jstr(v, "change", "") : "";
            if (!strcmp(ch, "new") || !strcmp(ch, "close") ||
                !strcmp(ch, "move") || !strcmp(ch, "floating"))
                tree_dirty = true;
            jfree(v);
        }

        /* a window event on its own does not redraw the workspace buttons */
        if (rtype != 0x80000003u) any = true;
        free(body);
    }
    return any;
}

/* ---------------------------------------------------------- workspaces */

typedef struct {
    int  num;
    char name[128];      /* full name, e.g. "3:web" */
    char label[128];     /* what we draw: number only, or the full name */
    char output[64];
    bool focused, visible, urgent;
} Ws;

static Ws  ws_list[MAX_WORKSPACES];
static int ws_count = 0;
static int ws_sort_flag = 1;    /* mirrors cfg.ws_sort, which is declared later */

/* "3:web" -> "3" ; a name without a leading number keeps the name */
static void ws_make_label(Ws *w, bool full_names)
{
    if (full_names) { str_set(w->label, sizeof(w->label), w->name); return; }
    const char *colon = strchr(w->name, ':');
    if (colon && colon != w->name) {
        size_t n = (size_t)(colon - w->name);
        if (n >= sizeof(w->label)) n = sizeof(w->label) - 1;
        memcpy(w->label, w->name, n);
        w->label[n] = 0;
        return;
    }
    if (w->num >= 0) snprintf(w->label, sizeof(w->label), "%d", w->num);
    else             str_set(w->label, sizeof(w->label), w->name);
}

/* Every IPC reply costs the compositor roughly twelve times its own size,
 * and never gives it back. A workspace switch does not need a new list: the
 * event says which one is current, and that is enough to move the focus and
 * the visible flag about. Only a change in the set of workspaces — one
 * created, emptied, renamed — needs asking again. */
static bool ws_apply_event(const JV *cur)
{
    if (!cur || cur->type != J_OBJ || !ws_count) return false;

    const char *name = jstr(cur, "name", "");
    const char *out  = jstr(cur, "output", "");
    if (!*name) return false;

    int hit = -1;
    for (int i = 0; i < ws_count; ++i)
        if (!strcmp(ws_list[i].name, name)) { hit = i; break; }
    if (hit < 0) return false;                   /* new to us: ask properly */

    if (!*out) out = ws_list[hit].output;

    for (int i = 0; i < ws_count; ++i) {
        ws_list[i].focused = (i == hit);
        if (!strcmp(ws_list[i].output, out)) ws_list[i].visible = (i == hit);
    }
    ws_list[hit].urgent = jbool(cur, "urgent", false);
    return true;
}

static void ws_reload(bool full_names)
{
    JV *r = sway_query(IPC_GET_WORKSPACES);
    if (!r || r->type != J_ARR) { jfree(r); return; }

    ws_count = 0;
    for (int i = 0; i < r->count && ws_count < MAX_WORKSPACES; ++i) {
        JV *o = r->items[i];
        Ws *w = &ws_list[ws_count++];
        memset(w, 0, sizeof(*w));
        w->num = jint(o, "num", -1);
        str_set(w->name, sizeof(w->name), jstr(o, "name", "?"));
        str_set(w->output, sizeof(w->output), jstr(o, "output", ""));
        w->focused = jbool(o, "focused", false);
        w->visible = jbool(o, "visible", false);
        w->urgent  = jbool(o, "urgent", false);
        ws_make_label(w, full_names);
    }
    jfree(r);

    /* sway lists them by output, so with a second monitor the numbers come
     * out interleaved — 1 2 5 on one, 3 4 on the other — and which order
     * depends on which cable went in first. Sort by number, so 3 is always
     * after 2 wherever it lives. */
    if (ws_sort_flag)
        for (int i = 1; i < ws_count; ++i)
            for (int j = i; j > 0; --j) {
                Ws *a = &ws_list[j - 1], *b = &ws_list[j];
                bool swap = a->num > b->num ||
                            (a->num == b->num && strcmp(a->name, b->name) > 0);
                if (!swap) break;
                Ws t = *a; *a = *b; *b = t;
            }
}

/* ------------------------------------------------------ cpu per workspace
 *
 * Who is working, and where. sway knows which pid each window belongs to and
 * which workspace that window is on; /proc knows how much processor time each
 * process has used. Put the two together and a workspace has a load.
 *
 * A process is credited to the nearest ancestor that owns a window, so a
 * compiler started in a terminal counts towards the workspace that terminal
 * is on. Anything with no window above it — daemons, the session itself —
 * belongs to no workspace and is left out.
 *
 * swbr is the one that measures, because a rate needs two samples a few
 * seconds apart and only a program that stays running has those. It writes
 * the answer where swov can read it, so swov does not have to measure
 * anything to draw the same numbers.
 */

typedef struct { int pid; int ws; } PidWs;      /* window pid -> ws_list index */

static PidWs  cpu_win[512];
static int    cpu_nwin;
static double cpu_ws_cores[MAX_WORKSPACES];    /* by ws_list index */
static char   cpu_ws_name[MAX_WORKSPACES][128];
static int    cpu_ws_n;
static double cpu_last_at;

typedef struct {
    int pid, ppid, ws;
    unsigned long long own, chld;
} ProcSample;
static ProcSample *cpu_prev;
static int         cpu_prev_n;

typedef struct { int pid, ws; unsigned long long delta; } CpuTop;
static CpuTop cpu_top[5];      /* the busiest of the last sample, for --probe */
static int    cpu_top_n;

/* own = this process's own cpu time, chld = the time of the children it has
 * already reaped. The second one is what makes a build visible: every cc1
 * lives for a moment and is gone long before the next sample, and its time
 * lands in make's cutime rather than anywhere we could see it directly. */
static bool proc_stat_of(int pid, int *ppid,
                         unsigned long long *own, unsigned long long *chld)
{
    char path[64], buf[1024];
    snprintf(path, sizeof(path), "/proc/%d/stat", pid);
    FILE *f = fopen(path, "r");
    if (!f) return false;
    size_t got = fread(buf, 1, sizeof(buf) - 1, f);
    fclose(f);
    buf[got] = 0;

    char *close = strrchr(buf, ')');            /* comm can hold anything */
    if (!close) return false;

    unsigned long long ut = 0, st = 0;
    long long cut = 0, cst = 0;
    int pp = 0;
    /* after "): state ppid pgrp session tty tpgid flags min_flt cmin_flt
       maj_flt cmaj_flt utime stime cutime cstime" */
    if (sscanf(close + 1, " %*c %d %*d %*d %*d %*d %*u %*u %*u %*u %*u %llu %llu %lld %lld",
               &pp, &ut, &st, &cut, &cst) != 5) return false;
    if (cut < 0) cut = 0;
    if (cst < 0) cst = 0;
    *ppid = pp;
    *own  = ut + st;
    if (chld) *chld = (unsigned long long)(cut + cst);
    return true;
}

/* The walk used to stop after twelve hops and re-read /proc at every one. A
 * real build is deeper than that — cc1 < gcc < make < make < make < bash <
 * bash < helper < helper < bash < python3 < terminal is twelve on its own —
 * so the compiler was declared homeless while the make above it was found,
 * and the workspace flickered between the truth and nothing. The sample we
 * have already read holds every pid and ppid, so the walk is done in memory,
 * as deep as it needs, and each answer is remembered. */
static int  *cpu_ws_memo;                       /* per index in the sample */

static int cpu_sample_index(const ProcSample *v, int n, int pid)
{
    int lo = 0, hi = n - 1;
    while (lo <= hi) {
        int mid = (lo + hi) / 2;
        if (v[mid].pid == pid) return mid;
        if (v[mid].pid < pid) lo = mid + 1;
        else                  hi = mid - 1;
    }
    return -1;
}

static int cpu_ws_of_index(const ProcSample *v, int n, int idx)
{
    int chain[64], depth = 0;
    int ws = -1;

    while (idx >= 0 && depth < (int)(sizeof chain / sizeof *chain)) {
        if (cpu_ws_memo[idx] != -2) { ws = cpu_ws_memo[idx]; break; }
        chain[depth++] = idx;

        int pid = v[idx].pid;
        bool found = false;
        for (int i = 0; i < cpu_nwin; ++i)
            if (cpu_win[i].pid == pid) { ws = cpu_win[i].ws; found = true; break; }
        if (found) break;

        if (v[idx].ppid <= 1) break;
        idx = cpu_sample_index(v, n, v[idx].ppid);
    }
    for (int i = 0; i < depth; ++i) cpu_ws_memo[chain[i]] = ws;
    return ws;
}


/* every view in sway's tree, as pid -> the workspace it sits on */
static void cpu_collect_windows(const JV *node, int ws_idx)
{
    if (!node || node->type != J_OBJ) return;

    const char *type = jstr(node, "type", "");
    if (!strcmp(type, "workspace")) {
        const char *name = jstr(node, "name", "");
        ws_idx = -1;
        for (int i = 0; i < ws_count; ++i)
            if (!strcmp(ws_list[i].name, name)) { ws_idx = i; break; }
    }
    int pid = jint(node, "pid", -1);
    if (pid > 0 && ws_idx >= 0 && cpu_nwin < (int)(sizeof cpu_win / sizeof *cpu_win)) {
        cpu_win[cpu_nwin].pid = pid;
        cpu_win[cpu_nwin].ws  = ws_idx;
        cpu_nwin++;
    }
    for (int i = 0; i < node->count; ++i) {
        JV *kid = node->items[i];
        if (!kid) continue;
        if (kid->type == J_ARR)
            for (int j = 0; j < kid->count; ++j) cpu_collect_windows(kid->items[j], ws_idx);
        else if (kid->type == J_OBJ)
            cpu_collect_windows(kid, ws_idx);
    }
}

static void cpu_write_cache(void)
{
    const char *dir = getenv("XDG_RUNTIME_DIR");
    char path[512], tmp[540];
    if (dir && *dir) snprintf(path, sizeof(path), "%s/swbr-cpu", dir);
    else {
        const char *home = getenv("HOME");
        if (!home) return;
        snprintf(path, sizeof(path), "%s/.cache/swbr-cpu", home);
    }
    snprintf(tmp, sizeof(tmp), "%s.new", path);

    FILE *f = fopen(tmp, "w");
    if (!f) return;
    for (int i = 0; i < cpu_ws_n; ++i)
        fprintf(f, "%s\t%.2f\n", cpu_ws_name[i], cpu_ws_cores[i]);
    fclose(f);
    if (rename(tmp, path) != 0) unlink(tmp);
}

/* one sample; the first call only records, the ones after it measure */
static void cpu_sample(void)
{
    const JV *tree = sway_tree_cached();
    if (!tree) return;
    cpu_nwin = 0;
    cpu_collect_windows(tree, -1);

    DIR *d = opendir("/proc");
    if (!d) return;

    int cap = 1024, n = 0;
    ProcSample *now = (ProcSample *)xmalloc((size_t)cap * sizeof *now);
    struct dirent *e;
    while ((e = readdir(d)) != NULL) {
        const char *p = e->d_name;
        bool digits = *p != 0;
        for (const char *q = p; *q; ++q) if (*q < '0' || *q > '9') { digits = false; break; }
        if (!digits) continue;
        if (n == cap) { cap *= 2; now = (ProcSample *)xrealloc(now, (size_t)cap * sizeof *now); }
        int pid = atoi(p), ppid; unsigned long long own, chld;
        if (!proc_stat_of(pid, &ppid, &own, &chld)) continue;
        now[n].pid = pid; now[n].ppid = ppid;
        now[n].own = own; now[n].chld = chld; now[n].ws = -1;
        n++;
    }
    closedir(d);

    for (int i = 1; i < n; ++i) {                /* insertion sort: /proc is
                                                    nearly ordered already */
        ProcSample tmp = now[i];
        int j = i - 1;
        while (j >= 0 && now[j].pid > tmp.pid) { now[j + 1] = now[j]; --j; }
        now[j + 1] = tmp;
    }

    double at = now_ms() / 1000.0;
    double dt = at - cpu_last_at;

    if (cpu_prev && dt > 0.2) {
        long hz = sysconf(_SC_CLK_TCK);
        if (hz <= 0) hz = 100;
        long ncpu = sysconf(_SC_NPROCESSORS_ONLN);
        if (ncpu <= 0) ncpu = 1;

        double used[MAX_WORKSPACES] = { 0 };
        cpu_top_n = 0;

        free(cpu_ws_memo);
        cpu_ws_memo = (int *)xmalloc((size_t)n * sizeof *cpu_ws_memo);
        for (int i = 0; i < n; ++i) cpu_ws_memo[i] = -2;

        for (int i = 0; i < n; ++i) {
            int pj = cpu_sample_index(cpu_prev, cpu_prev_n, now[i].pid);
            const ProcSample *was = pj >= 0 ? &cpu_prev[pj] : NULL;

            unsigned long long total = now[i].own + now[i].chld, before = 0;
            if (was && was->own + was->chld <= total) before = was->own + was->chld;
            /* no `was` means it was born inside this window, so all of its
               time belongs to this window */
            unsigned long long delta = total - before;

            int ws = cpu_ws_of_index(now, n, i);
            now[i].ws = ws;
            if (!delta) continue;
            if (ws >= 0 && ws < MAX_WORKSPACES)
                used[ws] += (double)delta / (double)hz;

            /* keep the five busiest, wherever they went */
            int slot = cpu_top_n < 5 ? cpu_top_n : -1;
            if (slot < 0) {
                unsigned long long worst = delta;
                for (int j = 0; j < 5; ++j)
                    if (cpu_top[j].delta < worst) { worst = cpu_top[j].delta; slot = j; }
            } else {
                cpu_top_n++;
            }
            if (slot >= 0) {
                cpu_top[slot].pid = now[i].pid;
                cpu_top[slot].ws = ws;
                cpu_top[slot].delta = delta;
            }
        }
        /* A process that died since the last sample had its whole lifetime
         * added to its parent's reaped-children total, and we already counted
         * the part of it that ran before the last sample. Take that back, or
         * every exit is counted twice. */
        for (int j = 0; j < cpu_prev_n; ++j) {
            if (cpu_sample_index(now, n, cpu_prev[j].pid) >= 0) continue;
            int ws = cpu_prev[j].ws;
            if (ws >= 0 && ws < MAX_WORKSPACES)
                used[ws] -= (double)(cpu_prev[j].own + cpu_prev[j].chld) / (double)hz;
        }

        cpu_ws_n = 0;
        for (int i = 0; i < ws_count && i < MAX_WORKSPACES; ++i) {
            if (used[i] < 0) used[i] = 0;
            /* core-seconds per second: 1.0 is one core kept busy. A share of
             * the whole machine was the wrong unit — on sixteen threads a
             * compiler pinning two cores is twelve percent, which rounds to
             * nothing, and nobody thinks about their machine that way. */
            double cores = used[i] / dt;
            if (cores < 0) cores = 0;
            if (cores > (double)ncpu) cores = (double)ncpu;
            cpu_ws_cores[i] = cores;
            str_set(cpu_ws_name[cpu_ws_n], sizeof(cpu_ws_name[0]), ws_list[i].name);
            cpu_ws_n++;
        }
        cpu_write_cache();
    }

    free(cpu_prev);
    cpu_prev = now;
    cpu_prev_n = n;
    cpu_last_at = at;
}

/* ---------------------------------------------------------------- config */

/* A cell is one command whose output is drawn on the right hand side.
 * Declared with `cell=NAME`, configured with `NAME.field=value`.
 *
 * `NAME.source=cmus` is the exception: swbr runs cmus-remote itself and reads
 * the answer, so whether something is playing is a fact rather than a guess
 * at what a script happened to print. */
enum { SRC_CMD, SRC_CMUS, SRC_BATTERY, SRC_WINDOW };
enum { PS_UNKNOWN = -1, PS_STOPPED = 0, PS_PAUSED = 1, PS_PLAYING = 2 };
typedef struct {
    char  name[32];
    char  cmd[2048];
    int   interval;              /* seconds; 0 = run once; -1 = keep streaming */
    char  fmt[128];              /* %s is replaced by the output */
    char  empty[128];            /* drawn when the command prints nothing */
    char  slim_on[64];           /* output containing this = the "on" state */
    int   source;                /* SRC_CMD, or a player swbr knows itself   */
    char  src_fmt[128];          /* how a known player is laid out           */
    char  src_path[256];         /* where to read it from, when that varies  */
    char  hover_fmt[192];        /* what to show while the pointer is on it  */
    char  hover_cmd[256];        /* ...or the output of this, run on hover   */
    int   hover_cal;             /* ...or a month, with today marked         */
    int   hover_click;           /* opened by clicking, not by pointing      */

    /* Shouting when the battery is going flat: a level is armed until it is
     * crossed on the way down, and rearms when the charge comes back up past
     * it or the cable goes in. */
    int   alert_lv[8], alert_n, alert_fired;
    char  alert_msg[192], alert_cmd[256], alert_play[128];
    int   alert_tone, alert_ms, alert_beeps, alert_escalate;
    int   alert_gain;            /* loudness of the tone itself, percent */
    int   alert_vol_min;         /* lift the mixer to this for the alert  */
    char  alert_vol_get[160], alert_vol_set[160];
    int   cal_off;               /* months away from this one, from the arrows */
    char  out_hover[512];        /* that, already filled in                  */
    int   hover_slim;            /* folded, hovering it opens the bar        */
    int   state;                 /* what that player is doing: PS_*          */
    int   gap;                   /* -1 = cell_gap */
    int   pad;                   /* inner padding, left and right */
    int   slim;                  /* how it shows in the folded strip */
    float slim_min, slim_max;    /* value range a gauge maps, default 0..100 */
    int   slim_w;                /* custom width in the folded strip */
    Col   slim_color, slim_color2;   /* strip colour, and the minute colour */
    bool  has_slim_color, has_slim_color2;
    Col   color, bg;
    bool  has_color, has_bg;
    Col   warn_col, crit_col;
    float warn_th, crit_th;
    int   warn_dir, crit_dir;    /* +1 = at or above, -1 = at or below */
    bool  has_warn, has_crit;
    int   min_w, max_w;
    char  align[8];
    int   sep, hide_empty, markup;
    char  pos[8];                /* which group: left | center | right */
    int   scroll;                /* too long -> ".." , and scroll while hovered */
    float scroll_px;
    uint32_t scroll_t;
    char  bind[MAX_BINDS][256];

    /* runtime */
    pid_t pid;
    int   fd;
    char  out[1024];             /* the last complete output */
    char  buf[2048];
    size_t len;
    uint32_t next_run;
} Cell;

typedef struct {
    /* placement */
    char layer[16], position[16];
    int  height, exclusive, margin, side_margin, min_width;
    char align_x[8];
    float radius;
    char outputs[512];

    /* workspaces */
    int  ws_names, ws_pad, ws_gap, ws_min_w, ws_click, scroll_workspace, ws_inset;
    int  ws_border;              /* outline thickness in px, 0 = none        */
    int  ws_slots;               /* show this many numbers, used or not      */
    int  ws_empty_alpha;         /* how visible a free number is, percent    */
    int  slim_bar_segs;          /* folded gauges: this many segments, 0 = solid */
    int  slim_bar_gap;           /* px between those segments                */
    int  slim_bar_pad;           /* px either side of a folded gauge         */
    int  slim_ws_w;              /* folded slot width, 0 = the widest button */
    int  shrink_px, shrink_s;    /* when a floating bar may get narrower    */
    float ws_radius;
    int  mode_show;

    /* text */
    char font[PATH_MAX], font_alt[PATH_MAX];
    float ui_scale, text_px, ws_px, text_y;
    int  pad_x, pad_right, markup;
    int  scroll_speed, scroll_pause;
    char layout[1024];

    /* status */
    char status_command[4096];
    int  interval;
    Cell cell[MAX_CELLS];
    int  cell_count;
    char msg_fifo[PATH_MAX], msg_target[32];
    int  msg_timeout, msg_flash, msg_panel;
    int  redraw_ms;              /* cell updates are held this long and
                                    merged into one frame                 */
    Col  msg_info, msg_warn, msg_error;
    int  cell_gap, cell_inset, slim_ws_slots;
    float cell_radius;
    char separator[16];
    Col  separator_color;

    /* collapse */
    char hide_key[32];
    int  hide_keycode, hover_keys, collapsed_px, anim_ms, signals, start_collapsed;

    /* mouse bindings, index = button number (1..9) */
    char bind[MAX_BINDS][512];

    /* colors */
    Col bg, text, dim, accent, hl, urgent, outline, running, slim_warm;
    int ws_other;                /* show other monitors' workspaces too  */
    int ws_sort;                 /* by number, not in sway's output order */
    int slim_align;              /* folded marks sit under their full-bar
                                    positions, rather than packed right   */
    int no_tree;                 /* never ask sway for the whole tree    */
    int tree_min_s;              /* and never more often than this       */
    int ws_cpu;                  /* the load dot on a workspace button   */
    int ws_cpu_interval;         /* seconds between samples              */
    float ws_cpu_idle;           /* under this, nothing is happening at all */
    float ws_cpu_min, ws_cpu_full;  /* the scale, in cores                  */
    Col ws_bg, ws_fg, ws_focused_bg, ws_focused_fg;
    Col ws_visible_bg, ws_visible_fg, ws_urgent_bg, ws_urgent_fg;
    Col mode_bg, mode_fg, ws_border_col;
} Config;

static void config_defaults(Config *c)
{
    memset(c, 0, sizeof(*c));
    str_set(c->layer, sizeof(c->layer), "top");
    str_set(c->position, sizeof(c->position), "top");
    c->height = 0;                 /* 0 = derive from the font size */
    c->exclusive = 0;
    c->margin = 0;
    c->side_margin = 0;
    c->min_width = 800;
    str_set(c->align_x, sizeof(c->align_x), "center");
    c->radius = 10.0f;

    c->ws_names = 0;
    c->ws_pad = 11;
    c->ws_gap = 4;
    c->ws_inset = 0;
    c->ws_border = 0;            /* off: the bar looked busier, not clearer */
    c->ws_slots = 10;
    c->ws_empty_alpha = 35;
    c->slim_bar_segs = 10;
    c->slim_bar_gap = 2;
    c->slim_bar_pad = 3;
    c->slim_ws_w = 0;
    c->shrink_px = 24;
    c->shrink_s = 30;
    c->ws_min_w = 0;
    c->ws_click = 1;
    c->scroll_workspace = 0;
    c->ws_radius = 0.0f;           /* square: the button spans the full height */
    c->mode_show = 1;

    c->ui_scale = 1.0f;
    c->text_px = 19.0f;
    c->ws_px = 19.0f;
    c->text_y = -2.0f;
    c->pad_x = 12;
    c->pad_right = 20;
    c->scroll_speed = 45;
    c->scroll_pause = 900;
    c->markup = 1;

    c->interval = 1;
    c->cell_gap = 14;
    c->cell_inset = 3;
    c->slim_ws_slots = 10;
    c->cell_radius = 5.0f;
    c->msg_timeout = 8;
    c->msg_flash = 1;
    c->msg_panel = 3;
    c->redraw_ms = 250;
    c->msg_info  = (Col){ 0x89, 0xaf, 0xc4, 0xff };
    c->msg_warn  = (Col){ 0xcb, 0x9b, 0x00, 0xff };
    c->msg_error = (Col){ 0xe0, 0x53, 0x3c, 0xff };
    str_set(c->separator, sizeof(c->separator), "");
    c->separator_color = (Col){ 0x5a, 0x6b, 0x7a, 0xff };

    str_set(c->hide_key, sizeof(c->hide_key), "space");
    c->hide_keycode = 0;
    c->hover_keys = 1;
    c->collapsed_px = 5;
    c->anim_ms = 120;
    c->signals = 1;
    c->start_collapsed = 0;

    c->bg            = (Col){ 0x26, 0x31, 0x3f, 0xe6 };
    c->text          = (Col){ 0xe8, 0xe8, 0xe8, 0xff };
    c->dim           = (Col){ 0x5a, 0x6b, 0x7a, 0xff };
    c->accent        = (Col){ 0x89, 0xaf, 0xc4, 0xff };
    c->hl            = (Col){ 0xcb, 0x9b, 0x00, 0xff };
    c->urgent        = (Col){ 0xe0, 0x53, 0x3c, 0xff };
    c->running       = (Col){ 0x3d, 0xdc, 0x84, 0xff };
    c->slim_warm     = (Col){ 0xe8, 0x96, 0x3c, 0xff };
    c->outline       = (Col){ 0x0a, 0x0e, 0x14, 0x99 };
    c->ws_bg         = (Col){ 0x1e, 0x27, 0x33, 0x00 };
    c->ws_border_col = (Col){ 0x4a, 0x58, 0x6a, 0x9a };
    c->ws_fg         = (Col){ 0xb3, 0xc0, 0xcd, 0xff };
    c->ws_other        = 0;
    c->ws_sort         = 1;
    c->slim_align      = 1;
    c->tree_min_s      = 5;
    c->ws_cpu          = 1;
    c->ws_cpu_interval = 3;
    c->ws_cpu_idle     = 0.01f;   /* one percent of one core */
    c->ws_cpu_min      = 0.25f;   /* a quarter of one core */
    c->ws_cpu_full     = 4.0f;    /* four cores fills the column */
    c->ws_focused_bg = (Col){ 0xcb, 0x9b, 0x00, 0xff };
    c->ws_focused_fg = (Col){ 0x14, 0x14, 0x14, 0xff };
    c->ws_visible_bg = (Col){ 0x3c, 0x4a, 0x5c, 0xff };
    c->ws_visible_fg = (Col){ 0xe1, 0xee, 0xff, 0xff };
    c->ws_urgent_bg  = (Col){ 0xe0, 0x53, 0x3c, 0xff };
    c->ws_urgent_fg  = (Col){ 0x14, 0x14, 0x14, 0xff };
    c->mode_bg       = (Col){ 0xcb, 0x9b, 0x00, 0xff };
    c->mode_fg       = (Col){ 0x14, 0x14, 0x14, 0xff };
}

/* ------------------------------------------------------------------ cells */

static Cell *cell_find(Config *c, const char *name)
{
    for (int i = 0; i < c->cell_count; ++i)
        if (!strcmp(c->cell[i].name, name)) return &c->cell[i];
    return NULL;
}

static Cell *cell_add(Config *c, const char *name)
{
    Cell *e = cell_find(c, name);
    if (e) return e;
    if (c->cell_count >= MAX_CELLS) return NULL;
    e = &c->cell[c->cell_count++];
    memset(e, 0, sizeof(*e));
    str_set(e->name, sizeof(e->name), name);
    e->interval = 2;
    e->hide_empty = 1;
    e->gap = -1;
    e->slim_min = 0.0f;
    e->slim_max = 100.0f;
    e->markup = 1;
    e->sep = 1;
    e->fd = -1;
    e->pid = -1;
    e->alert_tone = 250;         /* the low one: it carries without startling */
    e->alert_ms = 1050;
    e->alert_beeps = 2;
    e->alert_escalate = 1;
    e->alert_gain = 35;
    e->alert_vol_min = 0;        /* nobody's mixer is touched unless asked */
    str_set(e->alert_play, sizeof(e->alert_play), "aplay -q -f cd -");
    str_set(e->alert_vol_get, sizeof(e->alert_vol_get),
            "amixer -M get Master | grep -o '[0-9]*%' | head -1");
    str_set(e->alert_vol_set, sizeof(e->alert_vol_set), "amixer -M -q set Master %v%");
    str_set(e->align, sizeof(e->align), "right");
    str_set(e->pos, sizeof(e->pos), "right");
    return e;
}

/* "70:cecb00" or "<30:ff2222" — direction, threshold, colour */
static void cell_threshold(const char *v, float *th, int *dir, Col *col, bool *has)
{
    *dir = 1;
    if (*v == '<') { *dir = -1; v++; }
    else if (*v == '>') { *dir = 1; v++; }
    *th = (float)atof(v);
    const char *colon = strchr(v, ':');
    if (colon) parse_color(colon + 1, col);
    *has = true;
}

static void cell_set(Config *c, const char *name, const char *k, const char *v)
{
    Cell *e = cell_add(c, name);
    if (!e) return;
    if (!strcmp(k, "cmd") || !strcmp(k, "command")) {
        str_set(e->cmd, sizeof(e->cmd), v);
        e->source = SRC_CMD;          /* your command prints, swbr shows it */
    }
    else if (!strcmp(k, "interval")) e->interval = atoi(v);
    else if (!strcmp(k, "fmt") || !strcmp(k, "format")) str_set(e->fmt, sizeof(e->fmt), v);
    else if (!strcmp(k, "empty")) str_set(e->empty, sizeof(e->empty), v);
    else if (!strcmp(k, "slim_on")) str_set(e->slim_on, sizeof(e->slim_on), v);
    else if (!strcmp(k, "src_fmt") || !strcmp(k, "cmus_fmt"))
        str_set(e->src_fmt, sizeof(e->src_fmt), v);
    else if (!strcmp(k, "src_path") || !strcmp(k, "bat_path") ||
             !strcmp(k, "program"))
        str_set(e->src_path, sizeof(e->src_path), v);
    else if (!strcmp(k, "hover")) str_set(e->hover_fmt, sizeof(e->hover_fmt), v);
    else if (!strcmp(k, "hover_cmd")) str_set(e->hover_cmd, sizeof(e->hover_cmd), v);
    else if (!strcmp(k, "hover_cal")) e->hover_cal = atoi(v);
    else if (!strcmp(k, "hover_click")) e->hover_click = atoi(v);
    else if (!strcmp(k, "alert")) {
        e->alert_n = 0;
        char tmp[128];
        str_set(tmp, sizeof(tmp), v);
        for (char *tok = strtok(tmp, ","); tok && e->alert_n < 8; tok = strtok(NULL, ",")) {
            char *t = trim(tok);
            if (*t == '<') ++t;
            if (*t) e->alert_lv[e->alert_n++] = atoi(t);
        }
        for (int i = 1; i < e->alert_n; ++i)          /* highest first */
            for (int j = i; j > 0 && e->alert_lv[j] > e->alert_lv[j - 1]; --j) {
                int t2 = e->alert_lv[j]; e->alert_lv[j] = e->alert_lv[j - 1];
                e->alert_lv[j - 1] = t2;
            }
        e->alert_fired = 0;
    }
    else if (!strcmp(k, "alert_msg")) str_set(e->alert_msg, sizeof(e->alert_msg), v);
    else if (!strcmp(k, "alert_cmd")) str_set(e->alert_cmd, sizeof(e->alert_cmd), v);
    else if (!strcmp(k, "alert_play")) str_set(e->alert_play, sizeof(e->alert_play), v);
    else if (!strcmp(k, "alert_tone")) e->alert_tone = atoi(v);
    else if (!strcmp(k, "alert_ms")) e->alert_ms = atoi(v);
    else if (!strcmp(k, "alert_beeps")) e->alert_beeps = atoi(v);
    else if (!strcmp(k, "alert_escalate")) e->alert_escalate = atoi(v);
    else if (!strcmp(k, "alert_gain")) e->alert_gain = atoi(v);
    else if (!strcmp(k, "alert_vol_min")) e->alert_vol_min = atoi(v);
    else if (!strcmp(k, "alert_vol_get")) str_set(e->alert_vol_get, sizeof(e->alert_vol_get), v);
    else if (!strcmp(k, "alert_vol_set")) str_set(e->alert_vol_set, sizeof(e->alert_vol_set), v);
    else if (!strcmp(k, "hover_slim")) e->hover_slim = atoi(v);
    else if (!strcmp(k, "source")) {
        if (!strcasecmp(v, "cmus")) {
            e->source = SRC_CMUS;
            /* everything a cmus cell needs, so the config line is enough.
             * The command is not optional: swbr parses cmus-remote's own
             * output, so a leftover cmd from a script would leave the cell
             * with nothing it can read. */
            str_set(e->cmd, sizeof(e->cmd), "cmus-remote -Q 2>/dev/null");
            if (!e->interval) e->interval = 2;
            if (e->slim == SLIM_AUTO) e->slim = SLIM_MEDIA;
            if (!*e->bind[1])  str_set(e->bind[1], sizeof(e->bind[1]), "cmus-remote -u");
            if (!*e->bind[2])  str_set(e->bind[2], sizeof(e->bind[2]), "cmus-remote -n");
            if (!*e->bind[3])  str_set(e->bind[3], sizeof(e->bind[3]), "cmus-remote -r");
        } else if (!strcasecmp(v, "window") || !strcasecmp(v, "program")) {
            e->source = SRC_WINDOW;
            e->cmd[0] = 0;                       /* it asks sway, not a shell */
            if (!e->interval) e->interval = 3;
            if (e->slim == SLIM_AUTO) e->slim = SLIM_PRESENCE;
            if (!*e->src_path) str_set(e->src_path, sizeof(e->src_path), e->name);
        } else if (!strcasecmp(v, "battery") || !strcasecmp(v, "bat")) {
            e->source = SRC_BATTERY;
            /* no command: spawning /bin/true every twenty seconds just to
             * pace a pair of file reads is silly. cells_tick calls the
             * reader straight. */
            e->cmd[0] = 0;
            if (!e->interval) e->interval = 20;
            if (e->slim == SLIM_AUTO) e->slim = SLIM_BAR;
            if (e->slim_max <= e->slim_min) { e->slim_min = 0; e->slim_max = 100; }
        } else {
            e->source = SRC_CMD;
        }
    }
    else if (!strcmp(k, "gap")) e->gap = atoi(v);
    else if (!strcmp(k, "pad")) e->pad = atoi(v);
    else if (!strcmp(k, "slim_min")) e->slim_min = (float)atof(v);
    else if (!strcmp(k, "slim_max")) e->slim_max = (float)atof(v);
    else if (!strcmp(k, "slim_w")) e->slim_w = atoi(v);
    else if (!strcmp(k, "slim_color")) {
        e->slim_color.a = 255;
        parse_color(v, &e->slim_color);
        e->has_slim_color = true;
    }
    else if (!strcmp(k, "slim_color2")) {
        e->slim_color2.a = 255;
        parse_color(v, &e->slim_color2);
        e->has_slim_color2 = true;
    }
    else if (!strcmp(k, "slim")) {
        if (!strcasecmp(v, "bar")) e->slim = SLIM_BAR;
        else if (!strcasecmp(v, "clock")) e->slim = SLIM_CLOCK;
        else if (!strcasecmp(v, "tick")) e->slim = SLIM_TICK;
        else if (!strcasecmp(v, "presence") || !strcasecmp(v, "running") ||
                 !strcasecmp(v, "app")) e->slim = SLIM_PRESENCE;
        else if (!strcasecmp(v, "media") || !strcasecmp(v, "play")) e->slim = SLIM_MEDIA;
        else if (!strcasecmp(v, "off") || !strcmp(v, "0")) e->slim = SLIM_OFF;
        else e->slim = SLIM_AUTO;
    }
    else if (!strcmp(k, "color") || !strcmp(k, "fg")) { parse_color(v, &e->color); e->has_color = true; }
    else if (!strcmp(k, "bg")) { e->bg.a = 255; parse_color(v, &e->bg); e->has_bg = true; }
    else if (!strcmp(k, "warn")) cell_threshold(v, &e->warn_th, &e->warn_dir, &e->warn_col, &e->has_warn);
    else if (!strcmp(k, "crit")) cell_threshold(v, &e->crit_th, &e->crit_dir, &e->crit_col, &e->has_crit);
    else if (!strcmp(k, "min_w") || !strcmp(k, "width")) e->min_w = atoi(v);
    else if (!strcmp(k, "max_w")) e->max_w = atoi(v);
    else if (!strcmp(k, "align")) str_set(e->align, sizeof(e->align), v);
    else if (!strcmp(k, "pos") || !strcmp(k, "place")) str_set(e->pos, sizeof(e->pos), v);
    else if (!strcmp(k, "scroll") || !strcmp(k, "text")) e->scroll = atoi(v);
    else if (!strcmp(k, "sep") || !strcmp(k, "separator")) e->sep = atoi(v);
    else if (!strcmp(k, "hide_empty")) e->hide_empty = atoi(v);
    else if (!strcmp(k, "markup")) e->markup = atoi(v);
    else if (!strncmp(k, "button", 6) && isdigit((unsigned char)k[6]) && !k[7]) {
        int b = k[6] - '0';
        if (b >= 1 && b < MAX_BINDS) str_set(e->bind[b], sizeof(e->bind[b]), v);
    }
    else fprintf(stderr, "swbr: unknown cell key '%s.%s'\n", name, k);
}

static void config_set(Config *c, const char *k, const char *v)
{
    const char *dot = strchr(k, '.');
    if (dot && dot != k) {                       /* NAME.field=value */
        char name[32];
        size_t n = (size_t)(dot - k);
        if (n >= sizeof(name)) n = sizeof(name) - 1;
        memcpy(name, k, n);
        name[n] = 0;
        cell_set(c, name, dot + 1, v);
        return;
    }
    if (!strcmp(k, "cell")) { cell_add(c, v); return; }
    if (!strcmp(k, "cell_gap")) { c->cell_gap = atoi(v); return; }
    if (!strcmp(k, "cell_inset")) { c->cell_inset = atoi(v); return; }
    if (!strcmp(k, "slim_ws_slots")) { c->slim_ws_slots = atoi(v); return; }
    if (!strcmp(k, "slim_bar_segs")) { c->slim_bar_segs = atoi(v); return; }
    if (!strcmp(k, "slim_bar_gap")) { c->slim_bar_gap = atoi(v); return; }
    if (!strcmp(k, "slim_bar_pad")) { c->slim_bar_pad = atoi(v); return; }
    if (!strcmp(k, "slim_ws_w")) { c->slim_ws_w = atoi(v); return; }
    if (!strcmp(k, "shrink_px")) { c->shrink_px = atoi(v); return; }
    if (!strcmp(k, "shrink_s")) { c->shrink_s = atoi(v); return; }
    if (!strcmp(k, "cell_radius")) { c->cell_radius = (float)atof(v); return; }
    if (!strcmp(k, "separator")) { str_set(c->separator, sizeof(c->separator), v); return; }
    if (!strcmp(k, "separator_color")) { parse_color(v, &c->separator_color); return; }

    if (!strcmp(k, "layer")) str_set(c->layer, sizeof(c->layer), v);
    else if (!strcmp(k, "position")) str_set(c->position, sizeof(c->position), v);
    else if (!strcmp(k, "height")) c->height = atoi(v);
    else if (!strcmp(k, "exclusive") || !strcmp(k, "reserve_space")) c->exclusive = atoi(v);
    else if (!strcmp(k, "margin")) c->margin = atoi(v);
    else if (!strcmp(k, "side_margin")) c->side_margin = atoi(v);
    else if (!strcmp(k, "min_width") || !strcmp(k, "width") ||
             !strcmp(k, "max_width")) c->min_width = atoi(v);
    else if (!strcmp(k, "align_x")) str_set(c->align_x, sizeof(c->align_x), v);
    else if (!strcmp(k, "radius")) c->radius = (float)atof(v);
    else if (!strcmp(k, "outputs")) str_set(c->outputs, sizeof(c->outputs), v);
    else if (!strcmp(k, "ws_names") || !strcmp(k, "workspace_names")) c->ws_names = atoi(v);
    else if (!strcmp(k, "ws_pad")) c->ws_pad = atoi(v);
    else if (!strcmp(k, "ws_gap")) c->ws_gap = atoi(v);
    else if (!strcmp(k, "ws_min_w")) c->ws_min_w = atoi(v);
    else if (!strcmp(k, "ws_inset")) c->ws_inset = atoi(v);
    else if (!strcmp(k, "ws_border")) c->ws_border = atoi(v);
    else if (!strcmp(k, "ws_slots")) c->ws_slots = atoi(v);
    else if (!strcmp(k, "ws_empty_alpha")) c->ws_empty_alpha = atoi(v);
    else if (!strcmp(k, "ws_click")) c->ws_click = atoi(v);
    else if (!strcmp(k, "ws_radius")) c->ws_radius = (float)atof(v);
    else if (!strcmp(k, "scroll_workspace")) c->scroll_workspace = atoi(v);
    else if (!strcmp(k, "mode_show")) c->mode_show = atoi(v);
    else if (!strcmp(k, "font")) str_set(c->font, sizeof(c->font), v);
    else if (!strcmp(k, "font_alt")) str_set(c->font_alt, sizeof(c->font_alt), v);
    else if (!strcmp(k, "ui_scale") || !strcmp(k, "font_scale") || !strcmp(k, "text_scale"))
        c->ui_scale = (float)atof(v);
    else if (!strcmp(k, "text_px")) c->text_px = (float)atof(v);
    else if (!strcmp(k, "ws_px")) c->ws_px = (float)atof(v);
    else if (!strcmp(k, "pad_x")) c->pad_x = atoi(v);
    else if (!strcmp(k, "pad_right")) c->pad_right = atoi(v);
    else if (!strcmp(k, "scroll_speed")) c->scroll_speed = atoi(v);
    else if (!strcmp(k, "scroll_pause")) c->scroll_pause = atoi(v);
    else if (!strcmp(k, "text_y")) c->text_y = (float)atof(v);
    else if (!strcmp(k, "markup")) c->markup = atoi(v);
    else if (!strcmp(k, "status_command")) str_set(c->status_command, sizeof(c->status_command), v);
    else if (!strcmp(k, "interval")) c->interval = atoi(v);
    else if (!strcmp(k, "bar") || !strcmp(k, "layout"))
        str_set(c->layout, sizeof(c->layout), v);
    else if (!strcmp(k, "msg_fifo")) str_set(c->msg_fifo, sizeof(c->msg_fifo), v);
    else if (!strcmp(k, "msg_target")) str_set(c->msg_target, sizeof(c->msg_target), v);
    else if (!strcmp(k, "msg_timeout")) c->msg_timeout = atoi(v);
    else if (!strcmp(k, "msg_flash")) c->msg_flash = atoi(v);
    else if (!strcmp(k, "msg_panel")) c->msg_panel = atoi(v);
    else if (!strcmp(k, "redraw_ms")) c->redraw_ms = atoi(v);
    else if (!strcmp(k, "refresh")) c->redraw_ms = (int)(atof(v) * 1000.0);
    else if (!strcmp(k, "msg_info")) parse_color(v, &c->msg_info);
    else if (!strcmp(k, "msg_warn")) parse_color(v, &c->msg_warn);
    else if (!strcmp(k, "msg_error")) parse_color(v, &c->msg_error);
    else if (!strcmp(k, "hide_key")) str_set(c->hide_key, sizeof(c->hide_key), v);
    else if (!strcmp(k, "hide_keycode")) c->hide_keycode = atoi(v);
    else if (!strcmp(k, "hover_keys")) c->hover_keys = atoi(v);
    else if (!strcmp(k, "collapsed_px")) c->collapsed_px = atoi(v);
    else if (!strcmp(k, "anim_ms")) c->anim_ms = atoi(v);
    else if (!strcmp(k, "signals")) c->signals = atoi(v);
    else if (!strcmp(k, "start_collapsed")) c->start_collapsed = atoi(v);
    else if (!strncmp(k, "button", 6) && isdigit((unsigned char)k[6]) && !k[7]) {
        int b = k[6] - '0';
        if (b >= 1 && b < MAX_BINDS) str_set(c->bind[b], sizeof(c->bind[b]), v);
    }
    else if (!strcmp(k, "bg") || !strcmp(k, "background")) parse_color(v, &c->bg);
    else if (!strcmp(k, "text") || !strcmp(k, "statusline")) parse_color(v, &c->text);
    else if (!strcmp(k, "dim")) parse_color(v, &c->dim);
    else if (!strcmp(k, "accent")) parse_color(v, &c->accent);
    else if (!strcmp(k, "hl")) parse_color(v, &c->hl);
    else if (!strcmp(k, "urgent")) parse_color(v, &c->urgent);
    else if (!strcmp(k, "running")) parse_color(v, &c->running);
    else if (!strcmp(k, "slim_warm")) parse_color(v, &c->slim_warm);
    else if (!strcmp(k, "outline")) parse_color(v, &c->outline);
    else if (!strcmp(k, "ws_bg")) parse_color(v, &c->ws_bg);
    else if (!strcmp(k, "ws_border_col")) parse_color(v, &c->ws_border_col);
    else if (!strcmp(k, "ws_fg")) parse_color(v, &c->ws_fg);
    else if (!strcmp(k, "ws_other")) c->ws_other = atoi(v);
    else if (!strcmp(k, "ws_sort")) c->ws_sort = atoi(v);
    else if (!strcmp(k, "slim_align")) c->slim_align = atoi(v);
    else if (!strcmp(k, "no_tree")) c->no_tree = atoi(v);
    else if (!strcmp(k, "tree_min_s")) c->tree_min_s = atoi(v);
    else if (!strcmp(k, "ws_cpu")) c->ws_cpu = atoi(v);
    else if (!strcmp(k, "ws_cpu_interval")) c->ws_cpu_interval = atoi(v);
    else if (!strcmp(k, "ws_cpu_idle")) c->ws_cpu_idle = (float)atof(v);
    else if (!strcmp(k, "ws_cpu_min")) c->ws_cpu_min = (float)atof(v);
    else if (!strcmp(k, "ws_cpu_full")) c->ws_cpu_full = (float)atof(v);
    else if (!strcmp(k, "ws_focused_bg")) parse_color(v, &c->ws_focused_bg);
    else if (!strcmp(k, "ws_focused_fg")) parse_color(v, &c->ws_focused_fg);
    else if (!strcmp(k, "ws_visible_bg")) parse_color(v, &c->ws_visible_bg);
    else if (!strcmp(k, "ws_visible_fg")) parse_color(v, &c->ws_visible_fg);
    else if (!strcmp(k, "ws_urgent_bg")) parse_color(v, &c->ws_urgent_bg);
    else if (!strcmp(k, "ws_urgent_fg")) parse_color(v, &c->ws_urgent_fg);
    else if (!strcmp(k, "mode_bg")) parse_color(v, &c->mode_bg);
    else if (!strcmp(k, "mode_fg")) parse_color(v, &c->mode_fg);
    else fprintf(stderr, "swbr: unknown key '%s'\n", k);
}

/* Cut a trailing "  # comment" off a value. Quotes are respected, so the
 * '#' inside  foreground="#19cb00"  or inside a quoted sed script survives.
 * Only a '#'
 * that follows whitespace starts a comment, so  fmt=%s#  is safe too. */
static void strip_comment(char *v)
{
    char q = 0;
    for (char *p = v; *p; ++p) {
        if (q) { if (*p == q) q = 0; continue; }
        if (*p == '\'' || *p == '"') { q = *p; continue; }
        if (*p == '#' && p > v && isspace((unsigned char)p[-1])) { *p = 0; return; }
    }
}

/* the shared ~/.config/sw/config, translated into swbr's own keys */
static void config_set_shared(void *ud, const char *k, const char *v)
{
    config_set((Config *)ud, k, v);
}

static void config_load(Config *c, const char *path)
{
    FILE *f = fopen(path, "r");
    if (!f) { fprintf(stderr, "swbr: no config at %s\n", path); return; }
    char line[8192];
    while (fgets(line, sizeof(line), f)) {
        char *s = trim(line);
        if (!*s || *s == '#' || *s == ';') continue;
        char *eq = strchr(s, '=');
        if (!eq) continue;
        *eq = 0;
        char *v = eq + 1;
        strip_comment(v);
        config_set(c, trim(s), trim(v));
    }
    fclose(f);
}

static Config cfg;

/* ------------------------------------------------------------------ text */
/* stb_truetype, rasterised straight into our own ARGB buffer. Glyphs are
 * cached per size on first use, so any codepoint works — the status line is
 * full of box drawing characters and symbols. */

typedef struct {
    unsigned char *data;
    stbtt_fontinfo info;
    bool ok;
} FontFile;

static FontFile font_pri, font_alt;

typedef struct {
    unsigned cp;                 /* 0 = free slot */
    int w, h, x0, y0;
    float adv;
    unsigned char *bmp;
} Glyph;

typedef struct {
    int px;
    float sc_pri, sc_alt, ascent, lineh;
    Glyph *tab;
    int cap, n;
    bool used;
} Font;

#define FONT_CACHE 12
static Font font_cache[FONT_CACHE];

static bool font_file_load(FontFile *ff, const char *path)
{
    memset(ff, 0, sizeof(*ff));
    FILE *f = fopen(path, "rb");
    if (!f) return false;
    fseek(f, 0, SEEK_END);
    long sz = ftell(f);
    fseek(f, 0, SEEK_SET);
    if (sz <= 0) { fclose(f); return false; }
    ff->data = (unsigned char *)xmalloc((size_t)sz);
    if (fread(ff->data, 1, (size_t)sz, f) != (size_t)sz) {
        fclose(f); free(ff->data); ff->data = NULL; return false;
    }
    fclose(f);
    if (!stbtt_InitFont(&ff->info, ff->data, stbtt_GetFontOffsetForIndex(ff->data, 0))) {
        free(ff->data); ff->data = NULL; return false;
    }
    ff->ok = true;
    return true;
}

static bool try_font_paths(char *out, size_t n)
{
    const char *cand[] = {
        "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf",
        "/usr/share/fonts/dejavu/DejaVuSansMono.ttf",
        "/usr/share/fonts/TTF/DejaVuSansMono.ttf",
        "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
        "/usr/share/fonts/truetype/liberation/LiberationMono-Regular.ttf",
        "/usr/share/fonts/noto/NotoSansMono-Regular.ttf",
        "/usr/share/fonts/truetype/freefont/FreeMono.ttf", NULL
    };
    for (int i = 0; cand[i]; ++i)
        if (file_exists(cand[i])) { snprintf(out, n, "%s", cand[i]); return true; }
    return false;
}

/* Ask fontconfig (via its fc-match CLI) to resolve a family or pattern to an
 * actual .ttf path. No library is linked; if fc-match is missing we fall back
 * to the known paths above. */
static bool fc_match(const char *pattern, char *out, size_t n)
{
    if (!pattern || !*pattern) pattern = "monospace";
    char safe[256];
    size_t j = 0;
    for (size_t i = 0; pattern[i] && j < sizeof(safe) - 1; ++i) {
        char ch = pattern[i];
        if (ch == '"' || ch == '`' || ch == '$' || ch == '\\' || ch == ';' ||
            ch == '|' || ch == '&' || ch == '\n' || ch == '\r') continue;
        safe[j++] = ch;
    }
    safe[j] = 0;
    char cmd[512];
    snprintf(cmd, sizeof(cmd), "fc-match --format=%%{file} \"%s\" 2>/dev/null", safe);
    FILE *p = popen(cmd, "r");
    if (!p) return false;
    char buf[PATH_MAX];
    size_t r = fread(buf, 1, sizeof(buf) - 1, p);
    buf[r] = 0;
    pclose(p);
    char *s = trim(buf);
    if (*s && file_exists(s)) { snprintf(out, n, "%s", s); return true; }
    return false;
}

static char font_path_used[PATH_MAX];
static char font_alt_used[PATH_MAX];
static void fonts_init(void)
{
    char path[PATH_MAX] = "";
    if (*cfg.font) {
        expand_tilde(cfg.font, path, sizeof(path));
        if (!file_exists(path)) fc_match(cfg.font, path, sizeof(path));
    }
    if (!*path || !file_exists(path)) fc_match("monospace", path, sizeof(path));
    if (!*path || !file_exists(path)) try_font_paths(path, sizeof(path));
    if (*path) { font_file_load(&font_pri, path); str_set(font_path_used, PATH_MAX, path); }
    if (!font_pri.ok) fprintf(stderr, "swbr: no usable font found\n");

    char alt[PATH_MAX] = "";
    if (*cfg.font_alt) {
        expand_tilde(cfg.font_alt, alt, sizeof(alt));
        if (!file_exists(alt)) fc_match(cfg.font_alt, alt, sizeof(alt));
    } else {
        /* a symbol font, if the desktop has one — covers glyphs a mono font
         * usually lacks. Silently skipped when absent. */
        if (!fc_match("Noto Sans Symbols 2", alt, sizeof(alt)))
            fc_match("Noto Sans Symbols2", alt, sizeof(alt));
    }
    if (*alt && file_exists(alt) && (!*path || strcmp(alt, path))) {
        font_file_load(&font_alt, alt);
        str_set(font_alt_used, PATH_MAX, alt);
    }
}

static void glyph_tab_init(Font *f, int cap)
{
    f->cap = cap;
    f->n = 0;
    f->tab = (Glyph *)xmalloc((size_t)cap * sizeof(Glyph));
    memset(f->tab, 0, (size_t)cap * sizeof(Glyph));
}

static Glyph *glyph_slot(Font *f, unsigned cp)
{
    unsigned h = cp * 2654435761u;
    for (;;) {
        unsigned i = h & (unsigned)(f->cap - 1);
        for (int probe = 0; probe < f->cap; ++probe) {
            Glyph *g = &f->tab[(i + (unsigned)probe) & (unsigned)(f->cap - 1)];
            if (g->cp == cp) return g;
            if (g->cp == 0) return g;
        }
        /* full: grow and rehash */
        Glyph *old = f->tab;
        int oldcap = f->cap;
        glyph_tab_init(f, oldcap * 2);
        for (int k = 0; k < oldcap; ++k) {
            if (!old[k].cp) continue;
            Glyph *g = glyph_slot(f, old[k].cp);
            *g = old[k];
            f->n++;
        }
        free(old);
    }
}

static Glyph *glyph_get(Font *f, unsigned cp)
{
    Glyph *g = glyph_slot(f, cp);
    if (g->cp == cp) return g;

    FontFile *ff = &font_pri;
    float sc = f->sc_pri;
    int gi = font_pri.ok ? stbtt_FindGlyphIndex(&font_pri.info, (int)cp) : 0;
    if (!gi && font_alt.ok) {
        int gi2 = stbtt_FindGlyphIndex(&font_alt.info, (int)cp);
        if (gi2) { ff = &font_alt; sc = f->sc_alt; gi = gi2; }
    }
    memset(g, 0, sizeof(*g));
    g->cp = cp;
    f->n++;
    if (!ff->ok || !gi) {
        g->adv = (float)f->px * 0.5f;      /* missing: leave a blank */
        return g;
    }
    int aw, lsb;
    stbtt_GetGlyphHMetrics(&ff->info, gi, &aw, &lsb);
    g->adv = (float)aw * sc;
    int x0, y0, x1, y1;
    stbtt_GetGlyphBitmapBox(&ff->info, gi, sc, sc, &x0, &y0, &x1, &y1);
    int w = x1 - x0, h = y1 - y0;
    if (w > 0 && h > 0 && w < 512 && h < 512) {
        g->bmp = (unsigned char *)xmalloc((size_t)w * (size_t)h);
        stbtt_MakeGlyphBitmap(&ff->info, g->bmp, w, h, w, sc, sc, gi);
        g->w = w; g->h = h; g->x0 = x0; g->y0 = y0;
    }
    return g;
}

/* One Font per pixel size (and therefore per output scale). */
static Font *font_get(int px)
{
    if (px < 4) px = 4;
    for (int i = 0; i < FONT_CACHE; ++i)
        if (font_cache[i].used && font_cache[i].px == px) return &font_cache[i];

    int slot = -1;
    for (int i = 0; i < FONT_CACHE; ++i) if (!font_cache[i].used) { slot = i; break; }
    if (slot < 0) slot = 0;                       /* recycle the first one */
    Font *f = &font_cache[slot];
    if (f->used) {
        for (int k = 0; k < f->cap; ++k) free(f->tab[k].bmp);
        free(f->tab);
        memset(f, 0, sizeof(*f));
    }
    f->used = true;
    f->px = px;
    f->sc_pri = font_pri.ok ? stbtt_ScaleForPixelHeight(&font_pri.info, (float)px) : 1.0f;
    f->sc_alt = font_alt.ok ? stbtt_ScaleForPixelHeight(&font_alt.info, (float)px) : 1.0f;
    int asc = 0, desc = 0, gap = 0;
    if (font_pri.ok) stbtt_GetFontVMetrics(&font_pri.info, &asc, &desc, &gap);
    f->ascent = (float)asc * f->sc_pri;
    f->lineh = (float)(asc - desc) * f->sc_pri;
    if (f->ascent <= 0) { f->ascent = (float)px * 0.8f; f->lineh = (float)px; }
    glyph_tab_init(f, 256);
    return f;
}

static unsigned utf8_next(const char **p)
{
    const unsigned char *s = (const unsigned char *)*p;
    unsigned cp;
    int n;
    if (s[0] < 0x80) { cp = s[0]; n = 1; }
    else if ((s[0] & 0xE0) == 0xC0) { cp = s[0] & 0x1Fu; n = 2; }
    else if ((s[0] & 0xF0) == 0xE0) { cp = s[0] & 0x0Fu; n = 3; }
    else if ((s[0] & 0xF8) == 0xF0) { cp = s[0] & 0x07u; n = 4; }
    else { *p = (const char *)(s + 1); return 0xFFFD; }
    for (int i = 1; i < n; ++i) {
        if ((s[i] & 0xC0) != 0x80) { n = i; break; }
        cp = (cp << 6) | (s[i] & 0x3Fu);
    }
    *p = (const char *)(s + n);
    return cp;
}

static float text_width(Font *f, const char *s)
{
    float w = 0;
    const char *p = s;
    while (*p) {
        unsigned cp = utf8_next(&p);
        if (cp == 0xFE0F || cp == 0x200D) continue;   /* variation selectors */
        w += glyph_get(f, cp)->adv;
    }
    return w;
}

/* ----------------------------------------------------------------- paint */
/* ARGB8888, premultiplied — that is what wl_shm wants. */

typedef struct {
    uint32_t *px;
    int w, h;
    int cx0, cy0, cx1, cy1;      /* clip rectangle */
} Canvas;

static void canvas_clip(Canvas *cv, int x0, int y0, int x1, int y1)
{
    cv->cx0 = clampi(x0, 0, cv->w);
    cv->cy0 = clampi(y0, 0, cv->h);
    cv->cx1 = clampi(x1, 0, cv->w);
    cv->cy1 = clampi(y1, 0, cv->h);
}

static void canvas_clip_all(Canvas *cv) { canvas_clip(cv, 0, 0, cv->w, cv->h); }

static inline void blend(Canvas *cv, int x, int y, Col c, float cov)
{
    if (x < cv->cx0 || x >= cv->cx1 || y < cv->cy0 || y >= cv->cy1) return;
    float a = (float)c.a / 255.0f * cov;
    if (a <= 0.0f) return;
    uint32_t d = cv->px[y * cv->w + x];
    float da = (float)((d >> 24) & 0xff) / 255.0f;
    float dr = (float)((d >> 16) & 0xff) / 255.0f;
    float dg = (float)((d >> 8) & 0xff) / 255.0f;
    float db = (float)(d & 0xff) / 255.0f;
    float sr = (float)c.r / 255.0f * a;
    float sg = (float)c.g / 255.0f * a;
    float sb = (float)c.b / 255.0f * a;
    float ia = 1.0f - a;
    float orr = sr + dr * ia, og = sg + dg * ia, ob = sb + db * ia, oa = a + da * ia;
    cv->px[y * cv->w + x] =
        ((uint32_t)(orr * 255.0f + 0.5f) << 16) |
        ((uint32_t)(og  * 255.0f + 0.5f) << 8)  |
        ((uint32_t)(ob  * 255.0f + 0.5f))       |
        ((uint32_t)(oa  * 255.0f + 0.5f) << 24);
}

static void fill_rect(Canvas *cv, float x, float y, float w, float h, Col c)
{
    if (w <= 0 || h <= 0 || !c.a) return;
    int x0 = (int)floorf(x), y0 = (int)floorf(y);
    int x1 = (int)ceilf(x + w), y1 = (int)ceilf(y + h);
    for (int yy = y0; yy < y1; ++yy)
        for (int xx = x0; xx < x1; ++xx) {
            float cxs = clampf(x + w, (float)xx, (float)xx + 1) - clampf(x, (float)xx, (float)xx + 1);
            float cys = clampf(y + h, (float)yy, (float)yy + 1) - clampf(y, (float)yy, (float)yy + 1);
            blend(cv, xx, yy, c, cxs * cys);
        }
}

/* Rounded box with a radius per corner (tl, tr, br, bl), anti-aliased through
 * the usual signed distance trick. A corner radius of 0 is a square corner —
 * that is how the bar stays flush with the screen edge. */
static void fill_round(Canvas *cv, float x, float y, float w, float h,
                       float rtl, float rtr, float rbr, float rbl, Col c)
{
    if (w <= 0 || h <= 0 || !c.a) return;
    float hw = w * 0.5f, hh = h * 0.5f;
    float ccx = x + hw, ccy = y + hh;
    float cap = fminf(hw, hh);
    rtl = clampf(rtl, 0, cap); rtr = clampf(rtr, 0, cap);
    rbr = clampf(rbr, 0, cap); rbl = clampf(rbl, 0, cap);

    int x0 = (int)floorf(x) - 1, y0 = (int)floorf(y) - 1;
    int x1 = (int)ceilf(x + w) + 1, y1 = (int)ceilf(y + h) + 1;
    for (int yy = y0; yy < y1; ++yy) {
        if (yy < cv->cy0 || yy >= cv->cy1) continue;
        for (int xx = x0; xx < x1; ++xx) {
            if (xx < cv->cx0 || xx >= cv->cx1) continue;
            float px = (float)xx + 0.5f - ccx, py = (float)yy + 0.5f - ccy;
            float r = px < 0 ? (py < 0 ? rtl : rbl) : (py < 0 ? rtr : rbr);
            float qx = fabsf(px) - (hw - r), qy = fabsf(py) - (hh - r);
            float mx = fmaxf(qx, 0.0f), my = fmaxf(qy, 0.0f);
            float d = sqrtf(mx * mx + my * my) + fminf(fmaxf(qx, qy), 0.0f) - r;
            float cov = clampf(0.5f - d, 0.0f, 1.0f);
            if (cov > 0) blend(cv, xx, yy, c, cov);
        }
    }
}

/* The same distance field kept to a ring: an outline that follows the corner
 * radius and stays inside the box, so a button with no fill still has an edge. */
static void stroke_round(Canvas *cv, float x, float y, float w, float h,
                         float rtl, float rtr, float rbr, float rbl,
                         float t, Col c)
{
    if (w <= 0 || h <= 0 || t <= 0 || !c.a) return;
    float hw = w * 0.5f, hh = h * 0.5f;
    float ccx = x + hw, ccy = y + hh;
    float cap = fminf(hw, hh);
    rtl = clampf(rtl, 0, cap); rtr = clampf(rtr, 0, cap);
    rbr = clampf(rbr, 0, cap); rbl = clampf(rbl, 0, cap);

    int x0 = (int)floorf(x) - 1, y0 = (int)floorf(y) - 1;
    int x1 = (int)ceilf(x + w) + 1, y1 = (int)ceilf(y + h) + 1;
    for (int yy = y0; yy < y1; ++yy) {
        if (yy < cv->cy0 || yy >= cv->cy1) continue;
        for (int xx = x0; xx < x1; ++xx) {
            if (xx < cv->cx0 || xx >= cv->cx1) continue;
            float px = (float)xx + 0.5f - ccx, py = (float)yy + 0.5f - ccy;
            float r = px < 0 ? (py < 0 ? rtl : rbl) : (py < 0 ? rtr : rbr);
            float qx = fabsf(px) - (hw - r), qy = fabsf(py) - (hh - r);
            float mx = fmaxf(qx, 0.0f), my = fmaxf(qy, 0.0f);
            float d = sqrtf(mx * mx + my * my) + fminf(fmaxf(qx, qy), 0.0f) - r;
            float cov = clampf(0.5f - fabsf(d + t * 0.5f) + t * 0.5f, 0.0f, 1.0f);
            if (cov > 0) blend(cv, xx, yy, c, cov);
        }
    }
}

static void text_draw(Canvas *cv, Font *f, float x, float baseline, Col c, const char *s)
{
    const char *p = s;
    float pen = x;
    while (*p) {
        unsigned cp = utf8_next(&p);
        if (cp == 0xFE0F || cp == 0x200D) continue;
        Glyph *g = glyph_get(f, cp);
        if (g->bmp) {
            int gx = (int)lroundf(pen) + g->x0;
            int gy = (int)lroundf(baseline) + g->y0;
            for (int yy = 0; yy < g->h; ++yy) {
                int ty = gy + yy;
                if (ty < cv->cy0 || ty >= cv->cy1) continue;
                const unsigned char *row = g->bmp + (size_t)yy * (size_t)g->w;
                for (int xx = 0; xx < g->w; ++xx) {
                    unsigned char a = row[xx];
                    if (a) blend(cv, gx + xx, ty, c, (float)a / 255.0f);
                }
            }
        }
        pen += g->adv;
    }
}

/* ---------------------------------------------------------------- markup */
/* The subset of pango markup swaybar users actually write:
 *   <span foreground="#rrggbb" background="#..">..</span>, <b>, <i>, <u>, <tt>
 *   and the five XML entities. Anything else is passed through as text. */

typedef struct {
    char text[512];
    Col  fg, bg;
    bool has_fg, has_bg;
} Run;

typedef struct {
    Run v[MAX_RUNS];
    int n;
} Runs;

typedef struct { Col fg, bg; bool has_fg, has_bg; } Style;

static void runs_push(Runs *rs, const char *buf, int len, Style *st)
{
    if (len <= 0 || rs->n >= MAX_RUNS) return;
    Run *r = &rs->v[rs->n++];
    memset(r, 0, sizeof(*r));
    if (len > (int)sizeof(r->text) - 1) len = (int)sizeof(r->text) - 1;
    memcpy(r->text, buf, (size_t)len);
    r->text[len] = 0;
    r->fg = st->fg; r->bg = st->bg;
    r->has_fg = st->has_fg; r->has_bg = st->has_bg;
}

static void entity_append(char *buf, int *len, int cap, const char *ent, int elen)
{
    char tmp[8];
    const char *out = NULL;
    if (elen == 3 && !strncmp(ent, "amp", 3)) out = "&";
    else if (elen == 2 && !strncmp(ent, "lt", 2)) out = "<";
    else if (elen == 2 && !strncmp(ent, "gt", 2)) out = ">";
    else if (elen == 4 && !strncmp(ent, "quot", 4)) out = "\"";
    else if (elen == 4 && !strncmp(ent, "apos", 4)) out = "'";
    else if (elen > 1 && ent[0] == '#') {
        bool hex = (ent[1] == 'x' || ent[1] == 'X');
        unsigned cp = (unsigned)strtoul(ent + (hex ? 2 : 1), NULL, hex ? 16 : 10);
        int n = 0;
        if (cp && cp < 0x110000) {
            if (cp < 0x80) tmp[n++] = (char)cp;
            else if (cp < 0x800) {
                tmp[n++] = (char)(0xC0 | (cp >> 6));
                tmp[n++] = (char)(0x80 | (cp & 0x3F));
            } else if (cp < 0x10000) {
                tmp[n++] = (char)(0xE0 | (cp >> 12));
                tmp[n++] = (char)(0x80 | ((cp >> 6) & 0x3F));
                tmp[n++] = (char)(0x80 | (cp & 0x3F));
            } else {
                tmp[n++] = (char)(0xF0 | (cp >> 18));
                tmp[n++] = (char)(0x80 | ((cp >> 12) & 0x3F));
                tmp[n++] = (char)(0x80 | ((cp >> 6) & 0x3F));
                tmp[n++] = (char)(0x80 | (cp & 0x3F));
            }
        }
        tmp[n] = 0;
        out = tmp;
    }
    if (!out) return;
    int n = (int)strlen(out);
    if (*len + n < cap) { memcpy(buf + *len, out, (size_t)n); *len += n; }
}

static void tag_attr(const char *tag, const char *name, char *out, size_t cap)
{
    *out = 0;
    size_t nl = strlen(name);
    for (const char *p = tag; *p; ++p) {
        if (strncasecmp(p, name, nl)) continue;
        const char *q = p + nl;
        while (*q == ' ') q++;
        if (*q != '=') continue;
        q++;
        while (*q == ' ') q++;
        char quote = 0;
        if (*q == '"' || *q == '\'') quote = *q++;
        size_t j = 0;
        while (*q && j + 1 < cap && (quote ? *q != quote : (*q != ' ' && *q != '>')))
            out[j++] = *q++;
        out[j] = 0;
        return;
    }
}

static void markup_parse(const char *s, Runs *rs, Col def_fg)
{
    rs->n = 0;
    Style stack[16];
    int sp = 0;
    stack[0] = (Style){ def_fg, def_fg, false, false };

    char buf[512];
    int len = 0;

    if (!cfg.markup) {
        Style st = stack[0];
        runs_push(rs, s, (int)strlen(s), &st);
        return;
    }

    for (const char *p = s; *p; ) {
        if (*p == '<') {
            const char *end = strchr(p, '>');
            if (!end) { if (len < (int)sizeof(buf) - 1) buf[len++] = *p++; continue; }
            char tag[512];
            size_t tl = (size_t)(end - p - 1);
            if (tl >= sizeof(tag)) tl = sizeof(tag) - 1;
            memcpy(tag, p + 1, tl);
            tag[tl] = 0;
            p = end + 1;

            runs_push(rs, buf, len, &stack[sp]);
            len = 0;

            if (tag[0] == '/') {
                if (sp > 0) sp--;
            } else if (!strncasecmp(tag, "span", 4)) {
                Style st = stack[sp];
                char val[64];
                tag_attr(tag, "foreground", val, sizeof(val));
                if (!*val) tag_attr(tag, "fgcolor", val, sizeof(val));
                if (!*val) tag_attr(tag, "color", val, sizeof(val));
                if (*val) { st.fg = def_fg; st.fg.a = 255; parse_color(val, &st.fg); st.has_fg = true; }
                tag_attr(tag, "background", val, sizeof(val));
                if (!*val) tag_attr(tag, "bgcolor", val, sizeof(val));
                if (*val) { st.bg.a = 255; parse_color(val, &st.bg); st.has_bg = true; }
                if (sp < 15) stack[++sp] = st;
            } else {
                if (sp < 15) stack[sp + 1] = stack[sp], sp++;   /* <b>, <i>, .. */
            }
            continue;
        }
        if (*p == '&') {
            const char *semi = strchr(p, ';');
            if (semi && semi - p < 12) {
                entity_append(buf, &len, (int)sizeof(buf), p + 1, (int)(semi - p - 1));
                p = semi + 1;
                continue;
            }
        }
        if (len < (int)sizeof(buf) - 1) buf[len++] = *p;
        p++;
    }
    runs_push(rs, buf, len, &stack[sp]);
}

/* ---------------------------------------------------------------- status */
/* status_command runs under sh. Every line it prints replaces the status
 * text. If the command exits (a one-shot script), it is started again after
 * `interval` seconds — so both styles work: a script that loops forever, and
 * a script that prints once and quits. */

static pid_t   status_pid = -1;
static int     status_fd = -1;
static char    status_line[4096] = "";
static char    status_buf[8192];
static size_t  status_len = 0;
static uint32_t status_next_spawn = 0;

static void status_spawn(void)
{
    if (!*cfg.status_command) return;
    int fds[2];
    if (pipe(fds) < 0) return;

    pid_t pid = fork();
    if (pid < 0) { close(fds[0]); close(fds[1]); return; }
    if (pid == 0) {
        close(fds[0]);
        dup2(fds[1], STDOUT_FILENO);
        if (fds[1] != STDOUT_FILENO) close(fds[1]);
        setsid();
        signal(SIGPIPE, SIG_DFL);
        execl("/bin/sh", "sh", "-c", cfg.status_command, (char *)NULL);
        _exit(127);
    }
    close(fds[1]);
    int fl = fcntl(fds[0], F_GETFL, 0);
    if (fl >= 0) fcntl(fds[0], F_SETFL, fl | O_NONBLOCK);
    status_fd = fds[0];
    status_pid = pid;
    status_len = 0;
}

static void status_stop(void)
{
    if (status_pid > 0) { kill(-status_pid, SIGTERM); waitpid(status_pid, NULL, WNOHANG); }
    if (status_fd >= 0) close(status_fd);
    status_pid = -1;
    status_fd = -1;
}

/* true when a new complete line arrived */
static bool status_read(void)
{
    if (status_fd < 0) return false;
    bool got = false;
    for (;;) {
        ssize_t r = read(status_fd, status_buf + status_len,
                         sizeof(status_buf) - status_len - 1);
        if (r < 0) {
            if (errno == EINTR) continue;
            break;                                   /* EAGAIN */
        }
        if (r == 0) {                                /* child closed stdout */
            close(status_fd);
            status_fd = -1;
            if (status_pid > 0) { waitpid(status_pid, NULL, 0); status_pid = -1; }
            status_next_spawn = now_ms() + (uint32_t)(cfg.interval > 0 ? cfg.interval * 1000 : 1000);
            break;
        }
        status_len += (size_t)r;
        status_buf[status_len] = 0;

        char *nl;
        while ((nl = memchr(status_buf, '\n', status_len)) != NULL) {
            *nl = 0;
            str_set(status_line, sizeof(status_line), status_buf);
            got = true;
            size_t used = (size_t)(nl - status_buf) + 1;
            memmove(status_buf, status_buf + used, status_len - used);
            status_len -= used;
            status_buf[status_len] = 0;
        }
        if (status_len >= sizeof(status_buf) - 1) status_len = 0;   /* runaway line */
    }
    return got;
}

/* run a mouse binding, detached */
static void run_command(const char *cmd)
{
    if (!cmd || !*cmd) return;
    pid_t pid = fork();
    if (pid < 0) return;
    if (pid == 0) {
        setsid();
        if (fork() != 0) _exit(0);
        execl("/bin/sh", "sh", "-c", cmd, (char *)NULL);
        _exit(127);
    }
    waitpid(pid, NULL, 0);
}




/* ---------------------------------------------------------------- layout */
/* One line decides what sits where:
 *
 *     bar={workspaces||cmus,volume,(clock,date)}
 *
 * "||" splits groups — one part is left only, two are left and right, three
 * are left, centre and right. "," separates items. Parentheses glue items
 * together with no separator between them. Names are cell names plus the two
 * built-ins, "workspaces" and "mode". Because it assigns position, order and
 * separators, put this line last in the config. */

enum { IT_CELL, IT_WS, IT_MODE };
enum { G_LEFT, G_CENTER, G_RIGHT, G_COUNT };

typedef struct { int kind, cell, sep; } Item;

static Item layout_item[G_COUNT][MAX_CELLS + 4];
static int  layout_n[G_COUNT];

static void layout_push(int g, int kind, int cell, int sep)
{
    if (layout_n[g] >= MAX_CELLS + 4) return;
    Item *it = &layout_item[g][layout_n[g]++];
    it->kind = kind;
    it->cell = cell;
    it->sep = sep;
}

static void layout_default(void)
{
    for (int g = 0; g < G_COUNT; ++g) layout_n[g] = 0;
    layout_push(G_LEFT, IT_WS, -1, 0);
    layout_push(G_LEFT, IT_MODE, -1, 0);
    for (int i = 0; i < cfg.cell_count; ++i) {
        int g = !strcmp(cfg.cell[i].pos, "left") ? G_LEFT
              : !strcmp(cfg.cell[i].pos, "center") ? G_CENTER : G_RIGHT;
        layout_push(g, IT_CELL, i, cfg.cell[i].sep);
    }
}

static void layout_name(int g, char *name, bool joined)
{
    char *n = trim(name);
    if (!*n) return;
    if (!strcasecmp(n, "workspaces") || !strcasecmp(n, "ws")) {
        layout_push(g, IT_WS, -1, joined ? 0 : 1);
        return;
    }
    if (!strcasecmp(n, "mode")) { layout_push(g, IT_MODE, -1, joined ? 0 : 1); return; }
    for (int i = 0; i < cfg.cell_count; ++i)
        if (!strcmp(cfg.cell[i].name, n)) {
            cfg.cell[i].sep = joined ? 0 : 1;
            layout_push(g, IT_CELL, i, cfg.cell[i].sep);
            return;
        }
    fprintf(stderr, "swbr: bar= names unknown item '%s'\n", n);
}

static void layout_parse(const char *spec)
{
    if (!*spec) { layout_default(); return; }
    for (int g = 0; g < G_COUNT; ++g) layout_n[g] = 0;

    char buf[1024];
    str_set(buf, sizeof(buf), spec);
    char *p = trim(buf);
    if (*p == '{') p++;
    char *end = p + strlen(p);
    while (end > p && (end[-1] == '}' || isspace((unsigned char)end[-1]))) *--end = 0;

    /* split the groups on "||" */
    char *parts[G_COUNT] = { NULL, NULL, NULL };
    int np = 0;
    parts[np++] = p;
    for (char *q = p; *q && np < G_COUNT; ++q)
        if (q[0] == '|' && q[1] == '|') { *q = 0; parts[np++] = q + 2; }

    int gmap1[1] = { G_LEFT };
    int gmap2[2] = { G_LEFT, G_RIGHT };
    int gmap3[3] = { G_LEFT, G_CENTER, G_RIGHT };
    int *gmap = np == 1 ? gmap1 : (np == 2 ? gmap2 : gmap3);

    for (int i = 0; i < np; ++i) {
        int g = gmap[i];
        char name[64];
        int nl = 0;
        bool joined = false;
        for (char *q = parts[i]; ; ++q) {
            if (*q == '(') { joined = true; nl = 0; continue; }
            if (*q == ',' || *q == ')' || *q == 0) {
                name[nl < (int)sizeof(name) ? nl : (int)sizeof(name) - 1] = 0;
                bool last_of_group = (*q == ')');
                if (nl) layout_name(g, name, joined && !last_of_group);
                nl = 0;
                if (*q == ')') joined = false;
                if (*q == 0) break;
                continue;
            }
            if (nl < (int)sizeof(name) - 1) name[nl++] = *q;
        }
    }
}

/* ---------------------------------------------------------------- message */
/* A named pipe the rest of the system can shout into:
 *     echo "warn: backup is running" > $XDG_RUNTIME_DIR/swbr.fifo
 *     swbr --msg "error: disk full"
 *     swbr --msg clear
 * The pipe is opened read-write so it never reports end of file when the
 * writer goes away. A message can take over a cell (msg_target), which is how
 * the music title turns into the warning while one is active. */

static char msg_text[512] = "";
static int  msg_level = 0;                    /* 0 info, 1 warn, 2 error */
static uint32_t msg_until = 0;                /* 0 = stays until cleared */
static uint32_t msg_at = 0;                   /* when it arrived */
static char msg_path[PATH_MAX] = "";
static int  msg_fd = -1;
static char msg_buf[1024];
static size_t msg_len = 0;

static void msg_resolve_path(void)
{
    if (*cfg.msg_fifo) { expand_tilde(cfg.msg_fifo, msg_path, sizeof(msg_path)); return; }
    const char *rd = getenv("XDG_RUNTIME_DIR");
    if (rd && *rd) snprintf(msg_path, sizeof(msg_path), "%s/swbr.fifo", rd);
    else snprintf(msg_path, sizeof(msg_path), "/tmp/swbr-%d.fifo", (int)getuid());
}

static bool msg_active(void)
{
    if (!*msg_text) return false;
    if (msg_until && (int32_t)(now_ms() - msg_until) >= 0) return false;
    return true;
}

static Col msg_color(void)
{
    return msg_level >= 2 ? cfg.msg_error : (msg_level == 1 ? cfg.msg_warn : cfg.msg_info);
}

static int ctrl_req = 0;          /* 1 toggle, 2 fold, 3 unfold */

static bool msg_control(const char *t)
{
    if (*t != ':') return false;
    t++;
    if (!strcasecmp(t, "toggle")) ctrl_req = 1;
    else if (!strcasecmp(t, "fold") || !strcasecmp(t, "slim")) ctrl_req = 2;
    else if (!strcasecmp(t, "unfold") || !strcasecmp(t, "full")) ctrl_req = 3;
    else fprintf(stderr, "swbr: unknown control ':%s'\n", t);
    return true;
}

static void msg_set(const char *line)
{
    if (msg_control(line)) return;
    const char *t = line;
    int lvl = 0;
    if (!strncasecmp(t, "error:", 6))        { lvl = 2; t += 6; }
    else if (!strncasecmp(t, "err:", 4))     { lvl = 2; t += 4; }
    else if (!strncasecmp(t, "warning:", 8)) { lvl = 1; t += 8; }
    else if (!strncasecmp(t, "warn:", 5))    { lvl = 1; t += 5; }
    else if (!strncasecmp(t, "info:", 5))    { lvl = 0; t += 5; }
    while (*t == ' ' || *t == '\t') t++;

    if (!*t || !strcasecmp(t, "clear") || !strcasecmp(t, "-")) {
        msg_text[0] = 0;
        msg_until = 0;
        return;
    }
    str_set(msg_text, sizeof(msg_text), t);
    msg_level = lvl;
    msg_until = cfg.msg_timeout > 0 ? now_ms() + (uint32_t)cfg.msg_timeout * 1000u : 0;
    msg_at = now_ms();
}

/* Take over from a bar that is already running.
 *
 * `pkill swbr` in the sway config does not work reliably: sway forks each
 * exec_always without waiting for it, so the kill and the new bar race, and
 * the kill often wins — it terminates the instance that was just started. A
 * bar that clears the way for itself has nothing to race against.
 */
static void replace_running(void)
{
    DIR *d = opendir("/proc");
    if (!d) return;

    pid_t me = getpid(), victims[32];
    int   n = 0;
    struct dirent *e;
    while ((e = readdir(d)) && n < (int)(sizeof victims / sizeof *victims)) {
        bool digits = e->d_name[0] != 0;
        for (const char *q = e->d_name; *q; ++q)
            if (*q < '0' || *q > '9') { digits = false; break; }
        if (!digits) continue;

        pid_t pid = (pid_t)atoi(e->d_name);
        if (pid == me || pid <= 1) continue;

        char path[64], comm[64] = "";
        snprintf(path, sizeof(path), "/proc/%d/comm", (int)pid);
        FILE *f = fopen(path, "r");
        if (!f) continue;                       /* gone, or not ours to read */
        if (fgets(comm, sizeof(comm), f)) {
            char *nl = strchr(comm, '\n');
            if (nl) *nl = 0;
        }
        fclose(f);
        if (strcmp(comm, APP_ID)) continue;

        struct stat st;
        snprintf(path, sizeof(path), "/proc/%d", (int)pid);
        if (stat(path, &st) != 0 || st.st_uid != getuid()) continue;

        victims[n++] = pid;
    }
    closedir(d);

    for (int i = 0; i < n; ++i) kill(victims[i], SIGTERM);

    for (int wait = 0; wait < 40 && n; ++wait) {   /* up to two seconds */
        usleep(50000);
        int left = 0;
        for (int i = 0; i < n; ++i)
            if (kill(victims[i], 0) == 0) victims[left++] = victims[i];
        n = left;
    }
    for (int i = 0; i < n; ++i) kill(victims[i], SIGKILL);   /* stubborn */
}

static void msg_open(void)
{
    msg_resolve_path();
    struct stat st;
    if (stat(msg_path, &st) == 0 && !S_ISFIFO(st.st_mode)) {
        fprintf(stderr, "swbr: %s exists and is not a fifo\n", msg_path);
        return;
    }
    if (mkfifo(msg_path, 0600) < 0 && errno != EEXIST) {
        fprintf(stderr, "swbr: cannot create %s: %s\n", msg_path, strerror(errno));
        return;
    }
    msg_fd = open(msg_path, O_RDWR | O_NONBLOCK | O_CLOEXEC);
}

static bool msg_read(void)
{
    if (msg_fd < 0) return false;
    bool got = false;
    for (;;) {
        ssize_t r = read(msg_fd, msg_buf + msg_len, sizeof(msg_buf) - msg_len - 1);
        if (r < 0) { if (errno == EINTR) continue; break; }
        if (r == 0) break;
        msg_len += (size_t)r;
        msg_buf[msg_len] = 0;
        char *nl;
        while ((nl = memchr(msg_buf, '\n', msg_len)) != NULL) {
            size_t used = (size_t)(nl - msg_buf) + 1;
            *nl = 0;
            msg_set(trim(msg_buf));
            memmove(msg_buf, msg_buf + used, msg_len - used);
            msg_len -= used;
            msg_buf[msg_len] = 0;
            got = true;
        }
        if (msg_len >= sizeof(msg_buf) - 1) msg_len = 0;
    }
    return got;
}

/* swbr --msg TEXT : hand the line to the running bar and exit */
static int msg_send(const char *text)
{
    msg_resolve_path();
    int fd = open(msg_path, O_WRONLY | O_NONBLOCK);
    if (fd < 0) {
        fprintf(stderr, "swbr: no bar listening on %s (%s)\n", msg_path, strerror(errno));
        return 1;
    }
    char line[600];
    snprintf(line, sizeof(line), "%s\n", text);
    ssize_t w = write(fd, line, strlen(line));
    close(fd);
    return w > 0 ? 0 : 1;
}

/* ------------------------------------------------------------ cell runtime */
/* Every cell is its own little process on its own schedule. They are read
 * without blocking, so a slow command never stalls the bar — its old value
 * just stays on screen until the new one arrives. */

static void cell_spawn(Cell *e)
{
    if (!*e->cmd || e->pid > 0) return;
    int fds[2];
    if (pipe(fds) < 0) return;
    pid_t pid = fork();
    if (pid < 0) { close(fds[0]); close(fds[1]); return; }
    if (pid == 0) {
        close(fds[0]);
        dup2(fds[1], STDOUT_FILENO);
        if (fds[1] != STDOUT_FILENO) close(fds[1]);
        setsid();
        signal(SIGPIPE, SIG_DFL);
        execl("/bin/sh", "sh", "-c", e->cmd, (char *)NULL);
        _exit(127);
    }
    close(fds[1]);
    int fl = fcntl(fds[0], F_GETFL, 0);
    if (fl >= 0) fcntl(fds[0], F_SETFL, fl | O_NONBLOCK);
    e->fd = fds[0];
    e->pid = pid;
    e->len = 0;
}

/* %x substitution, shared by the sources. `keys` is a string of the letters,
 * `vals` the matching texts. */
static void expand_fmt(char *out, size_t cap, const char *fmt,
                       const char *keys, const char *const *vals)
{
    size_t o = 0;
    for (const char *p = fmt; *p && o < cap - 1; ++p) {
        const char *ins = NULL;
        if (*p == '%' && p[1]) {
            if (p[1] == '%') ins = "%";
            else {
                const char *at = strchr(keys, p[1]);
                if (at) ins = vals[at - keys];
            }
        }
        if (!ins) { out[o++] = *p; continue; }
        ++p;
        size_t l = strlen(ins);
        if (o + l >= cap) l = cap - 1 - o;
        memcpy(out + o, ins, l);
        o += l;
    }
    out[o] = 0;
}

/* `cmus-remote -Q` prints one key per line:
 *     status playing
 *     file /music/x.flac
 *     tag artist Boards of Canada
 *     tag title Roygbiv
 * Nothing at all means cmus is not running. */
static void cmus_parse(Cell *e)
{
    char status[32] = "", artist[256] = "", title[256] = "", file[512] = "";

    for (char *line = e->buf; line && *line; ) {
        char *nl = strchr(line, '\n');
        if (nl) *nl = 0;
        char *v;
        if (!strncmp(line, "status ", 7))
            str_set(status, sizeof(status), trim(line + 7));
        else if (!strncmp(line, "file ", 5))
            str_set(file, sizeof(file), trim(line + 5));
        else if (!strncmp(line, "tag artist ", 11))
            str_set(artist, sizeof(artist), trim(line + 11));
        else if (!strncmp(line, "tag title ", 10))
            str_set(title, sizeof(title), trim(line + 10));
        else if (!strncmp(line, "tag albumartist ", 16) && !*artist)
            str_set(artist, sizeof(artist), trim(line + 16));
        (void)v;
        line = nl ? nl + 1 : NULL;
    }

    e->state = !*status                      ? PS_UNKNOWN
             : !strcmp(status, "playing")    ? PS_PLAYING
             : !strcmp(status, "paused")     ? PS_PAUSED
                                             : PS_STOPPED;

    if (e->state == PS_UNKNOWN || e->state == PS_STOPPED) { e->out[0] = 0; return; }

    if (!*title && *file) {                              /* fall back to the name */
        const char *base = strrchr(file, '/');
        str_set(title, sizeof(title), base ? base + 1 : file);
        char *dot = strrchr(title, '.');
        if (dot && dot != title) *dot = 0;
    }

    /* ▶ while playing, ⏸ while paused — the icon is the state, so it is right
     * whether or not the player prints one */
    const char *icon = e->state == PS_PLAYING ? "\xe2\x96\xb6" : "\xe2\x8f\xb8";

    char name[600];
    if (*artist && *title) snprintf(name, sizeof(name), "%s — %s", artist, title);
    else                   snprintf(name, sizeof(name), "%s", title);

    /* %i icon  %n artist — title  %a artist  %t title  %s playing|paused
     * so one cell can be just the icon and another just the name */
    const char *vals[] = { icon, name, artist, title,
                           e->state == PS_PLAYING ? "playing" : "paused" };
    expand_fmt(e->out, sizeof(e->out), *e->src_fmt ? e->src_fmt : "%i %n",
               "inats", vals);
    if (*e->hover_fmt)
        expand_fmt(e->out_hover, sizeof(e->out_hover), e->hover_fmt, "inats", vals);
    char *t = trim(e->out);
    if (t != e->out) memmove(e->out, t, strlen(t) + 1);
}

/* a leaf with a pid is a window; containers and workspaces are not */
static bool node_is_view(const JV *n)
{
    if (!n || n->type != J_OBJ) return false;
    if (jint(n, "pid", -1) <= 0) return false;
    const JV *kids = jget(n, "nodes");
    if (kids && kids->type == J_ARR && kids->count > 0) return false;
    return true;
}

/* Which workspaces a program has a window on. sway knows; this is the same
 * question the old shell one-liner asked of swaymsg and jq, without either. */
static void window_scan(const JV *node, const char *want, const char *ws,
                        char *out, size_t cap, int *found)
{
    if (!node || node->type != J_OBJ) return;

    const char *type = jstr(node, "type", "");
    if (!strcmp(type, "workspace")) ws = jstr(node, "name", "");

    if (node_is_view(node)) {
        const char *id  = jstr(node, "app_id", "");
        const char *cls = jstr(jget(node, "window_properties"), "class", "");
        const char *nm  = jstr(node, "name", "");
        if (strcasestr(id, want) || strcasestr(cls, want) || strcasestr(nm, want)) {
            if (ws && *ws) {
                char one[80];
                snprintf(one, sizeof(one), "%s%s", *out ? "|" : "", ws);
                if (strlen(out) + strlen(one) < cap - 1 && !strstr(out, ws))
                    strcat(out, one);
            }
            (*found)++;
        }
    }
    for (int i = 0; i < node->count; ++i) {
        const JV *kid = node->items[i];
        if (!kid) continue;
        if (kid->type == J_ARR)
            for (int j = 0; j < kid->count; ++j)
                window_scan(kid->items[j], want, ws, out, cap, found);
        else if (kid->type == J_OBJ)
            window_scan(kid, want, ws, out, cap, found);
    }
}

static void window_read(Cell *e)
{
    e->out[0] = 0;
    e->state = PS_STOPPED;
    if (!*e->src_path) return;                   /* nothing to look for */

    const JV *tree = sway_tree_cached();
    if (!tree) return;

    char list[256] = "";
    int  found = 0;
    window_scan(tree, e->src_path, NULL, list, sizeof(list), &found);

    if (!found) return;                          /* not running: no cell */
    e->state = PS_PLAYING;

    char cnt[16];
    snprintf(cnt, sizeof(cnt), "%d", found);
    const char *vals[] = { e->name, list, cnt };
    expand_fmt(e->out, sizeof(e->out), *e->src_fmt ? e->src_fmt : "%n [%w]",
               "nwc", vals);
    if (*e->hover_fmt)
        expand_fmt(e->out_hover, sizeof(e->out_hover), e->hover_fmt, "nwc", vals);
}

/* capacity and status under /sys/class/power_supply: "83+" while it is
 * filling, "83-" while it is not. The sign says the direction, the number says the
 * charge, and neither needs a script. */
/* one number out of a sysfs file, or -1 */
static double bat_num(const char *base, const char *leaf)
{
    char path[420], buf[64] = "";
    snprintf(path, sizeof(path), "%s/%s", base, leaf);
    FILE *f = fopen(path, "r");
    if (!f) return -1.0;
    if (!fgets(buf, sizeof(buf), f)) { fclose(f); return -1.0; }
    fclose(f);
    char *t = trim(buf);
    if (!*t) return -1.0;
    return atof(t);
}

/* A note, written as raw PCM into whatever plays it.
 *
 * A sine with a raised-cosine edge either side, so it starts and stops
 * without the click a square burst makes — `speaker-test` is a test tone, not
 * a notification. Everything happens in a detached child: a battery warning
 * must never hold up the bar. */
/* urgency 0 is an ordinary level, 1 the one before last, 2 the last: longer
 * and more of them, so the difference is audible from the next room without
 * having to count. */
/* What the tone is piped into. Normally just alert_play. With alert_vol_min
 * set it is wrapped in a few lines of shell: read the mixer, and only if it is
 * below the floor, raise it, arrange to put it back, then hand over to the
 * player. The restore is the shell's own EXIT trap, so it runs even if the
 * alert is killed half way through — nothing should be able to leave the
 * volume up. ALSA has no per-stream level, so this is the master control and
 * it does move other audio for the second or two the tone lasts; alert_gain
 * is the knob that touches nothing at all. A muted output stays muted: swbr
 * cannot tell deliberate silence from an accident, and unmuting someone's
 * speakers is the worse mistake. Add `unmute` to alert_vol_set to override
 * that. */
static void alert_player_cmd(const Cell *e, char *out, size_t cap)
{
    if (e->alert_vol_min <= 0 || !*e->alert_vol_get || !*e->alert_vol_set) {
        snprintf(out, cap, "%s", e->alert_play);
        return;
    }
    char lo[16];
    snprintf(lo, sizeof(lo), "%d", e->alert_vol_min);
    char up[256], back[256];
    const char *vmin[] = { lo }, *vold[] = { "$_v" };
    expand_fmt(up,   sizeof(up),   e->alert_vol_set, "v", vmin);
    expand_fmt(back, sizeof(back), e->alert_vol_set, "v", vold);
    snprintf(out, cap,
             "_v=$(%s 2>/dev/null | tr -cs '0-9' ' ' | awk '{print $1; exit}'); "
             "case \"$_v\" in ''|*[!0-9]*) _v= ;; esac; "
             "if [ -n \"$_v\" ] && [ \"$_v\" -lt %d ]; then "
             "_back() { %s; }; trap _back EXIT INT TERM HUP; %s; fi; "
             /* not exec: that replaces the shell and takes the EXIT trap with
              * it, so the volume was raised and never put back */
             "%s",
             e->alert_vol_get, e->alert_vol_min, back, up, e->alert_play);
}

/* In the detached grandchild, so it cannot use msg_set: it goes back in
 * through the bar's own fifo, the same way `swbr --msg` does. */
static void alert_player_failed(const Cell *e, int status)
{
    char line[400];
    if (status == -1)
        snprintf(line, sizeof(line), "error: %s alert: cannot run '%s'",
                 e->name, e->alert_play);
    else
        snprintf(line, sizeof(line), "error: %s alert: '%s' exited %d",
                 e->name, e->alert_play, WIFEXITED(status) ? WEXITSTATUS(status) : status);
    msg_send(line);
}

static void alert_play_tone(const Cell *e, int urgency)
{
    if (e->alert_tone <= 0 || !*e->alert_play) return;

    pid_t p = fork();
    if (p < 0) return;
    if (p > 0) { waitpid(p, NULL, 0); return; }

    if (fork() > 0) _exit(0);                    /* orphan it, no zombie */

    char player[1024];
    alert_player_cmd(e, player, sizeof(player));
    FILE *out = popen(player, "w");
    if (!out) { alert_player_failed(e, -1); _exit(0); }

    const int rate = 44100;
    int ms = e->alert_ms > 0 ? e->alert_ms : 1050;
    int beeps = e->alert_beeps > 0 ? e->alert_beeps : 1;
    if (e->alert_escalate && urgency == 1) { beeps += 1; ms = ms * 6 / 5; }
    if (e->alert_escalate && urgency >= 2) { beeps += 3; ms = ms * 8 / 5; }

    int n  = rate * ms / 1000;
    int edge = rate * 15 / 1000;                 /* 15 ms in and out */
    int gap = rate * 130 / 1000;
    double gain = clampf((float)e->alert_gain / 100.0f, 0.02f, 1.0f);

    for (int b = 0; b < beeps; ++b) {
        for (int i = 0; i < n; ++i) {
            double env = 1.0;
            if (i < edge)          env = 0.5 - 0.5 * cos(M_PI * i / edge);
            else if (i > n - edge) env = 0.5 - 0.5 * cos(M_PI * (n - i) / edge);
            double v = sin(2.0 * M_PI * e->alert_tone * i / rate) * env * gain;
            int16_t sm = (int16_t)(v * 32767.0);
            if (fwrite(&sm, 2, 1, out) != 1) { b = beeps; break; }  /* it died */
            fwrite(&sm, 2, 1, out);              /* both ears */
        }
        if (b + 1 < beeps) {
            int16_t z = 0;
            for (int i = 0; i < gap; ++i) { fwrite(&z, 2, 1, out); fwrite(&z, 2, 1, out); }
        }
    }
    int st = pclose(out);
    /* A tone nobody hears is indistinguishable from an alert that never
     * fired, and the player's own error goes nowhere when the bar was started
     * by sway. So say it on the bar. */
    if (st != 0 && st != -1) alert_player_failed(e, st);
    _exit(0);
}

static void alert_fire(Cell *e, int level, const char *cap, bool last,
                       int urgency)
{
    if (*e->alert_msg) {
        char line[320], body[256];
        const char *vals[] = { cap };
        expand_fmt(body, sizeof(body), e->alert_msg, "c", vals);
        snprintf(line, sizeof(line), "%s %s", last ? "error:" : "warning:", body);
        msg_set(line);
    }
    if (*e->alert_cmd) {
        char cmd[320];
        const char *vals[] = { cap };
        expand_fmt(cmd, sizeof(cmd), e->alert_cmd, "c", vals);
        run_command(cmd);
    }
    alert_play_tone(e, urgency);
    (void)level;
}

/* Levels are crossed on the way down, once each, and rearm on the way back
 * up — the same idea as the shell script's counter file, without the file. */
static void alert_check(Cell *e, int cap, bool discharging)
{
    if (!e->alert_n) return;

    if (!discharging) { e->alert_fired = 0; return; }

    for (int i = 0; i < e->alert_n; ++i)
        if (cap > e->alert_lv[i] + 2 && (e->alert_fired & (1 << i)))
            e->alert_fired &= ~(1 << i);         /* charge came back */

    for (int i = 0; i < e->alert_n; ++i) {
        if (cap > e->alert_lv[i] || (e->alert_fired & (1 << i))) continue;
        e->alert_fired |= 1 << i;
        char c[16];
        snprintf(c, sizeof(c), "%d", cap);
        int urgency = i == e->alert_n - 1 ? 2 : i == e->alert_n - 2 ? 1 : 0;
        alert_fire(e, e->alert_lv[i], c, i == e->alert_n - 1, urgency);
        break;                                   /* one level per sample */
    }
}

static void battery_read(Cell *e)
{
    char base[320] = "";

    if (*e->src_path) {
        /* Whatever you point it at. Not every machine calls it BAT0 — some
         * name it CMB0 or macsmc-battery, and a laptop with two has to be
         * told which one. */
        str_set(base, sizeof(base), e->src_path);
    } else {
        DIR *d = opendir("/sys/class/power_supply");
        if (!d) { e->out[0] = 0; return; }
        struct dirent *de;
        while ((de = readdir(d)) != NULL) {
            char probe[400];
            snprintf(probe, sizeof(probe), "/sys/class/power_supply/%s/capacity",
                     de->d_name);
            if (access(probe, R_OK) != 0) continue;   /* not a battery */
            snprintf(base, sizeof(base), "/sys/class/power_supply/%s", de->d_name);
            if (!strncasecmp(de->d_name, "BAT", 3)) break;   /* prefer a BAT* */
        }
        closedir(d);
    }
    if (!*base) { e->out[0] = 0; return; }

    char path[400], cap[32] = "", status[32] = "";
    snprintf(path, sizeof(path), "%s/capacity", base);
    FILE *f = fopen(path, "r");
    if (f) { if (fgets(cap, sizeof(cap), f)) {} fclose(f); }
    snprintf(path, sizeof(path), "%s/status", base);
    f = fopen(path, "r");
    if (f) { if (fgets(status, sizeof(status), f)) {} fclose(f); }

    char *c = trim(cap), *st = trim(status);
    if (!*c) { e->out[0] = 0; return; }

    /* What it is doing right now, in watts, and how long that leaves. Some
     * kernels report energy and power, others charge and current; either pair
     * gives both numbers. */
    double now_u = bat_num(base, "energy_now"), full_u = bat_num(base, "energy_full");
    double rate_u = bat_num(base, "power_now"), volt = bat_num(base, "voltage_now");
    if (now_u < 0) {                              /* the charge/current pair */
        now_u  = bat_num(base, "charge_now");
        full_u = bat_num(base, "charge_full");
        double cur = bat_num(base, "current_now");
        if (cur >= 0 && volt >= 0) rate_u = cur * volt / 1e6;   /* to µW */
        if (now_u >= 0 && volt >= 0) { now_u  = now_u  * volt / 1e6;
                                       full_u = full_u * volt / 1e6; }
    }

    char watts[32] = "", hours[32] = "";
    if (rate_u > 0) snprintf(watts, sizeof(watts), "%.1fW", rate_u / 1e6);

    bool full = !strcasecmp(st, "Full");
    bool up   = full || !strcasecmp(st, "Charging");
    e->state  = up ? PS_PLAYING : PS_PAUSED;     /* reused: filling or not */

    alert_check(e, atoi(c), !up);

    if (rate_u > 0 && now_u >= 0) {
        double left_u = up ? (full_u > now_u ? full_u - now_u : 0) : now_u;
        double h = left_u / rate_u;
        if (h > 0 && h < 100) snprintf(hours, sizeof(hours), "%.1fh", h);
    }

    /* %c capacity, %i the sign, %w watts, %h hours left, %s the word.
     * Full gets no sign at all: nothing is happening, so nothing is said. */
    const char *sign = full ? "" : up ? "+" : "-";
    /* Half an hour means nothing on its own: on the cable it is time to
     * full, off it is time to empty, and those are opposite news. */
    const char *ends = !*hours ? "" : up ? "to full" : "left";

    const char *vals[] = { c, sign, watts, hours, st, ends };
    expand_fmt(e->out, sizeof(e->out), *e->src_fmt ? e->src_fmt : "%c%i",
               "ciwhse", vals);
    if (*e->hover_fmt) {
        expand_fmt(e->out_hover, sizeof(e->out_hover), e->hover_fmt, "ciwhse", vals);
        /* Full, or a kernel that reports no rate: the format collapses to
         * blanks, and a panel with nothing in it is worse than the word. */
        const char *p = e->out_hover;
        while (*p == ' ') ++p;
        if (!*p) str_set(e->out_hover, sizeof(e->out_hover), st);
    }
}

static void cell_finish(Cell *e)
{
    e->buf[e->len] = 0;

    if (e->source == SRC_CMUS)    { cmus_parse(e);  e->len = 0; return; }
    if (e->source == SRC_BATTERY) { battery_read(e); e->len = 0; return; }
    if (e->source == SRC_WINDOW)  { window_read(e);  e->len = 0; return; }

    char *t = trim(e->buf);
    for (char *q = t; *q; ++q) if (*q == '\n' || *q == '\r' || *q == '\t') *q = ' ';
    str_set(e->out, sizeof(e->out), t);
    if (*e->hover_fmt) {
        const char *vals[] = { e->out };
        expand_fmt(e->out_hover, sizeof(e->out_hover), e->hover_fmt, "s", vals);
    }
    e->len = 0;
}

/* true when a cell got a new value */
static bool cells_read(void)
{
    bool got = false;
    for (int i = 0; i < cfg.cell_count; ++i) {
        Cell *e = &cfg.cell[i];
        if (e->fd < 0) continue;
        for (;;) {
            ssize_t r = read(e->fd, e->buf + e->len, sizeof(e->buf) - e->len - 1);
            if (r < 0) { if (errno == EINTR) continue; break; }
            if (r == 0) {                                   /* command finished */
                cell_finish(e);
                close(e->fd);
                e->fd = -1;
                if (e->pid > 0) { waitpid(e->pid, NULL, 0); e->pid = -1; }
                e->next_run = now_ms() +
                    (uint32_t)(e->interval > 0 ? e->interval * 1000 : 1000);
                got = true;
                break;
            }
            e->len += (size_t)r;
            e->buf[e->len] = 0;

            if (e->interval < 0) {                          /* streaming */
                char *nl;
                while ((nl = memchr(e->buf, '\n', e->len)) != NULL) {
                    size_t used = (size_t)(nl - e->buf) + 1;
                    *nl = 0;
                    str_set(e->out, sizeof(e->out), trim(e->buf));
                    memmove(e->buf, e->buf + used, e->len - used);
                    e->len -= used;
                    e->buf[e->len] = 0;
                    got = true;
                }
            }
            if (e->len >= sizeof(e->buf) - 1) { cell_finish(e); got = true; }
        }
    }
    return got;
}

static bool cells_dirty;         /* something changed without a process */

static void cells_tick(void)
{
    uint32_t t = now_ms();
    for (int i = 0; i < cfg.cell_count; ++i) {
        Cell *e = &cfg.cell[i];
        if (e->pid > 0) continue;
        if (e->interval == 0 && e->next_run) continue;       /* run once */
        if (e->next_run && (int32_t)(t - e->next_run) < 0) continue;

        if ((e->source == SRC_BATTERY || e->source == SRC_WINDOW) && !*e->cmd) {
            if (e->source == SRC_WINDOW) window_read(e);   /* no process */
            else                         battery_read(e);
            e->next_run = t + (uint32_t)(e->interval > 0 ? e->interval * 1000 : 5000);
            cells_dirty = true;
            continue;
        }
        if (!*e->cmd) continue;
        e->next_run = t + 1;
        cell_spawn(e);
    }
}

static void cells_stop(void)
{
    for (int i = 0; i < cfg.cell_count; ++i) {
        Cell *e = &cfg.cell[i];
        if (e->pid > 0) { kill(-e->pid, SIGTERM); waitpid(e->pid, NULL, WNOHANG); }
        if (e->fd >= 0) close(e->fd);
        e->pid = -1;
        e->fd = -1;
    }
}

/* the text a cell draws: its output run through fmt */
static void cell_text(Cell *e, char *out, size_t cap)
{
    if (!*e->fmt) { str_set(out, cap, e->out); return; }
    const char *pc = strstr(e->fmt, "%s");
    if (!pc) { str_set(out, cap, e->fmt); return; }
    size_t head = (size_t)(pc - e->fmt);
    if (head >= cap) head = cap - 1;
    memcpy(out, e->fmt, head);
    out[head] = 0;
    size_t n = strlen(out);
    if (n < cap - 1) str_set(out + n, cap - n, e->out);
    n = strlen(out);
    if (n < cap - 1) str_set(out + n, cap - n, pc + 2);
}

/* the first number in the output, ignoring markup tags */
static bool cell_number(const char *s, float *out)
{
    bool in_tag = false;
    for (const char *p = s; *p; ++p) {
        if (*p == '<') { in_tag = true; continue; }
        if (*p == '>') { in_tag = false; continue; }
        if (in_tag) continue;
        if (isdigit((unsigned char)*p) ||
            ((*p == '-' || *p == '.') && isdigit((unsigned char)p[1]))) {
            *out = (float)atof(p);
            return true;
        }
    }
    return false;
}

static Col cell_color(Cell *e)
{
    Col base = e->has_color ? e->color : cfg.text;
    float n;
    if ((e->has_warn || e->has_crit) && cell_number(e->out, &n)) {
        if (e->has_warn && (e->warn_dir > 0 ? n >= e->warn_th : n <= e->warn_th))
            base = e->warn_col;
        if (e->has_crit && (e->crit_dir > 0 ? n >= e->crit_th : n <= e->crit_th))
            base = e->crit_col;
    }
    return base;
}

static bool cell_is_msg(Cell *e)
{
    return *cfg.msg_target && !strcmp(cfg.msg_target, e->name) && msg_active();
}

static bool cell_visible(Cell *e)
{
    if (cell_is_msg(e)) return true;
    if (!*e->cmd && !*e->fmt && !*e->empty && e->source == SRC_CMD) return false;
    if (*e->out) return true;
    return *e->empty || !e->hide_empty;      /* a placeholder stays clickable */
}

/* what a cell draws right now, and in which colour */

static void cell_display(Cell *e, char *out, size_t cap, Col *col)
{
    if (cell_is_msg(e)) { str_set(out, cap, msg_text); *col = msg_color(); return; }


    if (!*e->out && *e->empty) { str_set(out, cap, e->empty); *col = cell_color(e); return; }
    cell_text(e, out, cap);
    *col = cell_color(e);
}

/* --------------------------------------------------------------- wayland */

struct zwlr_layer_shell_v1;

typedef struct Bar Bar;

typedef struct {
    uint32_t id;
    struct wl_output *wl;
    char name[64];
    int scale, mode_w, mode_h;
    Bar *bar;
    bool alive;
} Output;

struct Bar {
    Output *out;
    struct wl_surface *surf;
    struct zwlr_layer_surface_v1 *ls;
    struct wl_callback *frame;

    int w, h, want_w;            /* logical surface size */
    int scale;
    bool configured, dirty, closed;

    /* shm: one pool, two buffers */
    struct wl_shm_pool *pool;
    void *pool_data;
    size_t pool_size;
    struct wl_buffer *buf[2];
    void *bufmem[2];
    bool busy[2];
    int stride, bw, bh;

    /* collapse state */
    bool collapsed;
    float vis, anim_from, anim_to;
    uint32_t anim_start;

    /* pointer */
    bool hovered, kbd_grab;
    double px, py;

    /* workspace hit boxes, rebuilt on every render */
    struct { float x0, x1; char name[128]; } hit[MAX_WORKSPACES];
    int hits;
    bool hover_open;            /* opened by a hover, folds back on leave */
    bool measured_full;         /* the open layout has been worked out once */
    int  tip_showing;           /* the cell whose panel is open, or -1      */
    int  tip_pinned;            /* ...and it was opened by a click          */
    bool tip_msg;               /* the panel is showing a message           */
    float tip_cx;               /* the middle of that cell, logical px      */
    uint32_t tip_at;            /* when it opened, for the slide            */
    int reg_w, reg_y, reg_h;    /* the input region as the compositor has it */
    int tip_edge;               /* -1 the panel is flush left, +1 right, 0 no */
    uint32_t last_fit;          /* when we last asked for a new size         */
    uint32_t last_commit;       /* ...and when we last committed a frame     */
    int  last_slot;             /* the buffer currently on screen            */
    float cal_x0, cal_x1, cal_x2, cal_x3, cal_y0, cal_y1;  /* the ‹ › boxes */
    int  tip_h;                 /* extra surface for the hover text, logical */
    int  tip_cell;              /* which cell it belongs to, or -1          */
    float cellx0[MAX_CELLS], cellx1[MAX_CELLS];  /* where each cell sat in the
                                                    full bar, so the folded
                                                    strip can line up with it */
    float wsx0[MAX_WORKSPACES], wsx1[MAX_WORKSPACES];   /* and each workspace */
    float wsbx0, wsbx1, wsbw;    /* the block: left, right, widest button  */
    float wsnx0[MAX_WORKSPACES + 1], wsnx1[MAX_WORKSPACES + 1];
                                 /* and by number, ghosts included       */
    struct { float x0, x1; int num; char name[128]; } wsbtn[MAX_WORKSPACES * 2];
    int   wsbtn_n;               /* every button, in the order drawn     */
    bool  soon;                  /* this frame skips the redraw_ms hold    */
    uint32_t shrink_since;       /* content has been narrower since then   */
    struct { float x0, x1; int cell; } chit[MAX_CELLS];
    int chits;
};

static struct wl_display    *dpy;
static struct wl_registry   *registry;
static struct wl_compositor *compositor;
static struct wl_shm        *shm;
static struct wl_seat       *seat;
static struct wl_pointer    *pointer;
static struct wl_keyboard   *keyboard;
static struct zwlr_layer_shell_v1 *layer_shell;

static Output outputs[MAX_OUTPUTS];
static int    output_count = 0;
static Bar   *pointer_bar = NULL;
static bool   running = true;

static void bar_render(Bar *b);
static bool bar_animating(Bar *b);
static void bar_damage(Bar *b) { if (b) { b->dirty = true; } }

/* Some frames must not wait for redraw_ms. A clock a quarter of a second late
 * is nothing; the workspace you just switched to lighting up a quarter of a
 * second late is the bar feeling broken, and switching back inside that window
 * showed nothing at all because the two frames merged into one. */
static void bar_damage_now(Bar *b) { if (b) { b->dirty = true; b->soon = true; } }

static void damage_all(void)
{
    for (int i = 0; i < output_count; ++i)
        if (outputs[i].bar) bar_damage(outputs[i].bar);
}

static void damage_all_now(void)
{
    for (int i = 0; i < output_count; ++i)
        if (outputs[i].bar) bar_damage_now(outputs[i].bar);
}

static bool output_wanted(const char *name)
{
    if (!*cfg.outputs) return true;
    char tmp[512];
    str_set(tmp, sizeof(tmp), cfg.outputs);
    for (char *tok = strtok(tmp, ","); tok; tok = strtok(NULL, ",")) {
        char *t = trim(tok);
        if (!strcasecmp(t, name) || !strcmp(t, "*")) return true;
    }
    return false;
}

/* -------- sizes (logical pixels, multiplied by the output scale) -------- */

static int bar_height_logical(void)
{
    if (cfg.height > 0) return cfg.height;
    float base = fmaxf(cfg.text_px, cfg.ws_px) * cfg.ui_scale;
    int h = (int)lroundf(base * 1.35f) + 4;
    return h < 10 ? 10 : h;
}

static float bar_visible_logical(Bar *b)
{
    float full = (float)bar_height_logical();
    float col = (float)clampi(cfg.collapsed_px, 1, (int)full);
    return col + (full - col) * clampf(b->vis, 0.0f, 1.0f);
}

/* -------------------------------------------------------------- buffers */

static void buffer_release(void *data, struct wl_buffer *wl_buffer)
{
    Bar *b = (Bar *)data;
    for (int i = 0; i < 2; ++i)
        if (b->buf[i] == wl_buffer) b->busy[i] = false;
}
static const struct wl_buffer_listener buffer_listener = { buffer_release };

static void bar_free_buffers(Bar *b)
{
    for (int i = 0; i < 2; ++i) {
        if (b->buf[i]) wl_buffer_destroy(b->buf[i]);
        b->buf[i] = NULL;
        b->busy[i] = false;
        b->bufmem[i] = NULL;
    }
    if (b->pool) wl_shm_pool_destroy(b->pool);
    b->pool = NULL;
    if (b->pool_data) munmap(b->pool_data, b->pool_size);
    b->pool_data = NULL;
    b->pool_size = 0;
}

static int anon_shm(size_t size)
{
    int fd = memfd_create("swbr", MFD_CLOEXEC);
    if (fd < 0) return -1;
    if (ftruncate(fd, (off_t)size) < 0) { close(fd); return -1; }
    return fd;
}

static bool bar_alloc(Bar *b)
{
    int bw = b->w * b->scale, bh = b->h * b->scale;
    if (bw <= 0 || bh <= 0) return false;
    if (b->pool && b->bw == bw && b->bh == bh) return true;

    bar_free_buffers(b);
    b->last_slot = -1;
    b->bw = bw;
    b->bh = bh;
    b->stride = bw * 4;
    size_t one = (size_t)b->stride * (size_t)bh;
    size_t total = one * 2;

    int fd = anon_shm(total);
    if (fd < 0) return false;
    void *mem = mmap(NULL, total, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (mem == MAP_FAILED) { close(fd); return false; }

    b->pool_data = mem;
    b->pool_size = total;
    wl_count.pool++;
    b->pool = wl_shm_create_pool(shm, fd, (int32_t)total);
    close(fd);
    for (int i = 0; i < 2; ++i) {
        b->buf[i] = wl_shm_pool_create_buffer(b->pool, (int32_t)(one * (size_t)i),
                                              bw, bh, b->stride, WL_SHM_FORMAT_ARGB8888);
        b->bufmem[i] = (char *)mem + one * (size_t)i;
        b->busy[i] = false;
        wl_buffer_add_listener(b->buf[i], &buffer_listener, b);
    }
    return true;
}

/* ---------------------------------------------------------------- render */

/* Baseline that puts the ink optically centred in a band: the em box is
 * centred, then nudged by text_y (logical px, negative = up). */
static float baseline_for(Font *f, float y0, float vis, float s)
{
    return y0 + vis * 0.5f + (f->ascent - f->lineh * 0.5f) + cfg.text_y * s;
}

static Col col_mix(Col a, Col b, float t)
{
    t = clampf(t, 0.0f, 1.0f);
    Col o;
    o.r = (uint8_t)((float)a.r + ((float)b.r - (float)a.r) * t);
    o.g = (uint8_t)((float)a.g + ((float)b.g - (float)a.g) * t);
    o.b = (uint8_t)((float)a.b + ((float)b.b - (float)a.b) * t);
    o.a = (uint8_t)((float)a.a + ((float)b.a - (float)a.a) * t);
    return o;
}

static Col col_scale_alpha(Col c, float f)
{
    c.a = (uint8_t)clampi((int)lroundf((float)c.a * clampf(f, 0.0f, 1.0f)), 0, 255);
    return c;
}

static bool ws_on_bar(Bar *b, Ws *w)
{
    if (!b->out || !*b->out->name || !*w->output) return true;
    return strcmp(w->output, b->out->name) == 0;
}

/* --------------------------------------------------------------- slim mode
 * Folded, the bar is a few pixels tall and still has to say something. Each
 * workspace keeps a fixed slot so its position never moves, the clock turns
 * into twelve dots, and anything with a percentage becomes a small gauge. */

static Ws *ws_by_num(Bar *b, int num)
{
    Ws *other = NULL;
    for (int i = 0; i < ws_count; ++i) {
        if (ws_list[i].num != num) continue;
        if (ws_on_bar(b, &ws_list[i])) return &ws_list[i];
        if (cfg.ws_other) other = &ws_list[i];     /* another screen's */
    }
    return other;
}

static int slim_mode(Cell *e)
{
    if (e->slim != SLIM_AUTO) return e->slim;
    if (!*e->out) return SLIM_TICK;              /* a placeholder is a button */
    if (strchr(e->out, '%')) return SLIM_BAR;
    float v;
    if ((e->has_warn || e->has_crit) && cell_number(e->out, &v)) return SLIM_BAR;
    return SLIM_TICK;
}

static float slim_width_of(Cell *e, int mode, float s)
{
    if (e && e->slim_w > 0) return (float)e->slim_w * s;
    switch (mode) {
    case SLIM_CLOCK: return 12.0f * 3.0f * s + 11.0f * 2.0f * s;
    case SLIM_BAR:   return 40.0f * s;
    case SLIM_PRESENCE: return 10.0f * s;
    case SLIM_MEDIA: return 26.0f * s;
    case SLIM_OFF:   return 0.0f;
    default:         return 12.0f * s;
    }
}


/* The colour a cell shows on the strip: its own slim_color, else the colour
 * it painted its own text with, so folding never changes what a thing looks
 * like. A cyan clock stays cyan. */
static Col slim_color_of(Cell *e)
{
    if (e->has_slim_color) return e->slim_color;
    char txt[1024];
    Col base;
    cell_display(e, txt, sizeof(txt), &base);
    if (e->markup) {
        Runs rs;
        int saved = cfg.markup;
        cfg.markup = 1;
        markup_parse(txt, &rs, base);
        cfg.markup = saved;
        for (int i = 0; i < rs.n; ++i)
            if (rs.v[i].has_fg) return rs.v[i].fg;
    }
    return base;
}

/* +, an up arrow or a bolt mean charging; -, a down arrow mean draining;
 * =, a tick mean full. Anything else: no direction shown. */
static int slim_direction(const char *s)
{
    if (strchr(s, '+') || strstr(s, "\xe2\x86\x91") || strstr(s, "\xe2\x9a\xa1")) return 1;
    if (strchr(s, '=') || strstr(s, "\xe2\x9c\x93")) return 0;
    if (strchr(s, '-') || strstr(s, "\xe2\x86\x93")) return -1;
    return 2;
}

/* 1 = playing, 0 = not, -1 = the cell has said nothing at all yet.
 *
 * `slim_on` is the reliable way: give it a word your command prints only while
 * something is playing. Without it we guess from the usual glyphs, which only
 * works if your player happens to print one of them. `swbr --probe` prints
 * what this decided for every cell, next to the text it decided it from. */
static int media_state(const Cell *e)
{
    /* A player swbr talks to itself has already said which it is. Paused is
     * not playing, and that is the distinction the strip is there to show. */
    if (e->source != SRC_CMD) {
        if (e->state == PS_UNKNOWN) return -1;
        return e->state == PS_PLAYING ? 1 : 0;
    }
    if (!e->out[0]) return -1;
    if (*e->slim_on) return strstr(e->out, e->slim_on) != NULL;

    /* Paused first: a bar showing "⏸ Artist — Title" is not playing, and
     * looking for the play glyph first would call it playing anyway. */
    static const char *PAUSED[] = {
        "\xe2\x8f\xb8",      /* ⏸ */
        "\xe2\x9d\x9a",      /* ❚ */
        "paused",
    };
    for (size_t i = 0; i < sizeof PAUSED / sizeof *PAUSED; ++i)
        if (strcasestr(e->out, PAUSED[i])) return 0;

    static const char *PLAYING[] = {
        "\xe2\x96\xb6",      /* ▶ */
        "\xf0\x9f\x8e\xb5", /* 🎵 */
        "\xe2\x99\xaa",      /* ♪ */
        "playing",
    };
    for (size_t i = 0; i < sizeof PLAYING / sizeof *PLAYING; ++i)
        if (strcasestr(e->out, PLAYING[i])) return 1;
    return 0;
}

static void slim_draw_one(Canvas *cv, Cell *e, int mode, float x, float y,
                          float w, float h, float s)
{
    Col c = slim_color_of(e);
    if (mode == SLIM_PRESENCE) {
        /* the cell only exists while its program does, so a block here means
         * "that one is up". It keeps the colour it has in the full bar —
         * painting it green regardless meant the same cell was two different
         * colours depending on whether the bar was folded. */
        fill_rect(cv, x, y, w, h, c);
        return;
    }
    if (mode == SLIM_CLOCK) {
        time_t t = time(NULL);
        struct tm tmv;
        localtime_r(&t, &tmv);
        int hour = (tmv.tm_hour + 11) % 12 + 1;    /* 1..12, 0:xx reads as 12 */
        float dot = 3.0f * s, gap = 2.0f * s;
        if (w > 12.0f * (dot + gap)) {             /* fill the width it was given */
            float pitch = w / 12.0f;
            dot = pitch * 0.62f;
            gap = pitch - dot;
        }
        /* Every bar up to the hour, so you count them instead of finding the
         * one lit position: 2 at 02:00, still 2 at 02:55.
         *
         * The hours are always the cell's own colour — the clock is cyan in
         * the bar, so it is cyan down here too. Before noon they are drawn a
         * little softer, which still separates 1:00 from 13:00 without
         * swapping to a colour that reads as something else entirely. */
        Col hc = c;
        if (tmv.tm_hour < 12) hc.a = (uint8_t)(hc.a * 0.62f);
        for (int i = 0; i < 12; ++i) {
            Col dc = cfg.dim;
            dc.a = 90;
            if (i < hour) dc = hc;
            fill_rect(cv, x + (float)i * (dot + gap), y, dot, h, dc);
        }
        /* the minutes run along the bottom half, in the second colour */
        Col mc = e->has_slim_color2 ? e->slim_color2 : cfg.accent;
        mc.a = 200;
        float span = 12.0f * dot + 11.0f * gap;
        float mh = clampf(h * 0.5f + 1.0f * s, 1.0f, h);   /* a pixel more */
        fill_rect(cv, x, y + h - mh, span * (float)tmv.tm_min / 60.0f, mh, mc);
        return;
    }
    if (mode == SLIM_BAR) {
        float v = 0;
        bool have = cell_number(e->out, &v);
        float lo = e->slim_min, hi = e->slim_max;
        float f = (hi > lo) ? (v - lo) / (hi - lo) : 0.0f;
        f = clampf(f, 0.0f, 1.0f);
        int dir = slim_direction(e->out);
        Col fillc = c;                             /* the fill keeps whatever
                                                    * warn/crit decided */
        Col track = cfg.dim;                       /* visible, or a part filled
                                                    * gauge just looks short */
        track.a = 110;
        /* Split into ten, and the gauge can be read as a number: four lit
         * blocks is forty percent without measuring it against anything. A
         * solid bar only ever said "about half". */
        int segs = cfg.slim_bar_segs;
        float sgap = fmaxf(1.0f, (float)cfg.slim_bar_gap * s);
        /* Ten blocks in a narrow cell came out under two pixels each and the
         * dividers vanished, so it read as one solid bar again. Halve the
         * count instead of giving up on it. */
        while (segs > 2 && (w - (float)(segs - 1) * sgap) / (float)segs < 2.0f * s)
            segs /= 2;
        float sw = segs > 1 ? (w - (float)(segs - 1) * sgap) / (float)segs : 0;
        if (segs > 1 && sw < 1.5f) segs = 0;       /* too narrow to read */
        if (segs > 1) {
            for (int i = 0; i < segs; ++i) {
                float bx = x + (float)i * (sw + sgap);
                fill_rect(cv, bx, y, sw, h, track);
                if (!have) continue;
                float f0 = (float)i / (float)segs, f1 = (float)(i + 1) / (float)segs;
                if (f >= f1)     fill_rect(cv, bx, y, sw, h, fillc);
                else if (f > f0) fill_rect(cv, bx, y, sw * (f - f0) * (float)segs, h, fillc);
            }
        } else {
            fill_rect(cv, x, y, w, h, track);
            if (have) fill_rect(cv, x, y, w * f, h, fillc);
        }
        if (dir == 2) return;

        /* The pips run a colour ramp away from the fill: warm into red while
         * it drains, warm into green while it fills. Direction and roughly
         * how hard it is working, in three dots. */
        Col far = dir > 0 ? cfg.running : (dir == 0 ? cfg.running : cfg.urgent);
        float edge = x + w * f, pip = 2.0f * s, step = 3.0f * s;
        for (int i = 0; i < 3; ++i) {
            /* Start most of the way to the far colour, not at the warm end:
             * ramping from 0 left the brightest pip orange and the green one
             * dim, so charging and draining looked much the same. */
            Col pc = col_mix(cfg.slim_warm, far, 0.45f + (float)i * 0.275f);
            pc.a = (uint8_t)(245 - i * 35);
            float px_ = dir > 0 ? edge + (float)i * step
                      : dir < 0 ? edge - (float)(i + 1) * step
                      : x + w - (float)(3 - i) * step;
            if (px_ < x || px_ + pip > x + w) continue;
            fill_rect(cv, px_, y, pip, h, pc);
        }
        return;
    }
    if (mode == SLIM_MEDIA) {
        /* Playing: two full-height bars, the pause glyph at five pixels, in
         * the cell's own colour. Not playing: one short stub at a third of
         * the height, well under half as bright. Same shape at two sizes read
         * as the same thing, so the two states differ in height as well. */
        /* One block, the full width of the slot. Two of them were meant to
         * echo a pause glyph, from when playing and paused were told apart by
         * shape; now that paused is short and dim and stopped is nothing at
         * all, the height says it, and one wide block is far easier to see
         * than two thin ones. */
        int st = media_state(e);
        if (st > 0) {                             /* playing */
            fill_rect(cv, x, y, w, h, c);
        } else if (st == 0) {                     /* paused: short and dim */
            Col d = c;
            d.a = 110;
            fill_rect(cv, x, y + h * 0.34f, w, h * 0.32f, d);
        }
        return;                                   /* st < 0: nothing to show */
    }
    fill_rect(cv, x, y, w, h, c);
}

/* A column of dots rising from the bottom, `frac` of them lit. Dots rather
 * than a solid fill so whatever is underneath — a workspace pill, the strip's
 * own colour — still reads through the gaps. */
static void dot_column(Canvas *cv, float x, float y, float w, float h,
                       float dot, float gap, float frac, Col c)
{
    /* square-ish, and centred in the slot: a dot as wide as the slot is a
     * stripe, and a column of stripes reads as one solid block */
    if (w > dot * 1.4f) { x += (w - dot) * 0.5f; w = dot; }

    int n = (int)((h + gap) / (dot + gap));
    if (n < 2) n = 2;
    if (n > 12) n = 12;

    int lit = frac <= 0.0f ? 0 : (int)ceilf(frac * (float)n);
    if (lit > n) lit = n;

    Col dim_c = c;
    dim_c.a = (uint8_t)(c.a * 0.38f);

    for (int i = 0; i < n; ++i) {
        float dy = y + h - (float)(i + 1) * dot - (float)i * gap;
        fill_rect(cv, x, dy, w, dot, i < lit ? c : dim_c);
    }
}

/* How busy, as a colour: quiet green through the accent into urgent. Nothing
 * at all below ws_cpu_min, so an idle bar stays clean. */
/* How busy, and whether it is only busy on one core.
 *
 * The scale is a share of the whole machine, so on sixteen threads a single
 * pinned core is six percent — real work that looks like idling. When that is
 * what is happening the bottom dot lights on its own, dimmer than a proper
 * load, which says "something is running here" without pretending the
 * workspace is hot. */
static bool cpu_load_col(int ws_idx, Col *out, float *frac, bool *faint)
{
    if (faint) *faint = false;
    if (!cfg.ws_cpu || ws_idx < 0 || ws_idx >= cpu_ws_n) return false;

    double cores = cpu_ws_cores[ws_idx];
    if (cores < cfg.ws_cpu_idle) return false;    /* genuinely nothing */

    /* Something is happening, but not enough to be worth a place on the
     * scale: a player decoding, a script waking up every second, a shell
     * running something small. The bottom dot on its own, faint — a terminal
     * sitting at a prompt gets nothing, this gets a hint. */
    if (cores < cfg.ws_cpu_min) {
        if (faint) *faint = true;
        *frac = 0.0f;
        *out = col_mix(cfg.dim, cfg.accent, 0.40f);
        out->a = 120;
        return true;
    }

    float f = cfg.ws_cpu_full > cfg.ws_cpu_min
            ? (float)(cores - cfg.ws_cpu_min) / (cfg.ws_cpu_full - cfg.ws_cpu_min)
            : 1.0f;
    f = clampf(f, 0.0f, 1.0f);
    *frac = f;
    /* One colour, not a ramp: how much is lit says how busy it is, and the
     * hue stays out of the way. Orange was a mistake — `hl` paints the
     * focused workspace, so a busy workspace looked like the current one.
     * Only a workspace that is really pinned tips towards urgent. */
    Col hot = f < 0.85f ? cfg.accent
                        : col_mix(cfg.accent, cfg.urgent, (f - 0.85f) / 0.15f);
    *out = col_mix(cfg.dim, hot, 0.7f + 0.3f * f);
    out->a = (uint8_t)(200 + 55 * f);
    return true;
}

static void draw_signals(Canvas *cv, Bar *b, float y, float h, float s, Runs *rs)
{
    if (!cfg.signals) return;
    float gap = 3.0f * s;
    float x = 4.0f * s;

    /* A message used to paint the whole strip its colour and leave it there,
     * which reads as "the bar is broken" rather than "look at this". It
     * pulses over the strip you already had instead, and the text itself
     * drops down in the panel for a few seconds. */
    float blink = 0.0f;
    if (msg_active() && cfg.msg_flash) {
        uint32_t ph = now_ms() % 900;
        blink = 0.18f + 0.50f *
                (0.5f - 0.5f * cosf(2.0f * (float)M_PI * (float)ph / 900.0f));
    }

    float tick = 14.0f * s;
    b->hits = 0;
    b->chits = 0;

    /* The workspace marks. Lined up (slim_align=1) they are the open bar's own
     * buttons, one for one — the same set, the same left edges, the same
     * widths — taken from the layout pass that ran just before this. So a
     * mark is exactly where its button is, and you click the same spot folded
     * or open. Letting the strip pick its own count (slim_ws_slots) could
     * never match: ten marks against five buttons had to land somewhere the
     * buttons were not. That count is only for the packed layout now.
     *
     * Packed (slim_align=0), one fixed slot per number, slot 3 always
     * workspace 3. */
    typedef struct { float x, w; Ws *ws; int num; const char *name; } Mark;
    Mark mk[MAX_WORKSPACES * 2];
    int nmk = 0;
    char ghostname[MAX_WORKSPACES * 2][8];

    if (cfg.slim_align && b->wsbtn_n > 0) {
        for (int k = 0; k < b->wsbtn_n && nmk < MAX_WORKSPACES * 2; ++k) {
            Mark *m = &mk[nmk];
            m->x = b->wsbtn[k].x0 * s;
            m->w = (b->wsbtn[k].x1 - b->wsbtn[k].x0) * s;
            if (cfg.slim_ws_w > 0) m->w = (float)cfg.slim_ws_w * s;
            m->num = b->wsbtn[k].num;
            m->ws = m->num >= 1 ? ws_by_num(b, m->num) : NULL;
            if (!m->ws)                            /* a named one: by name */
                for (int i = 0; i < ws_count; ++i)
                    if (!strcmp(ws_list[i].name, b->wsbtn[k].name)) { m->ws = &ws_list[i]; break; }
            snprintf(ghostname[nmk], sizeof ghostname[nmk], "%d", m->num);
            m->name = m->ws ? m->ws->name : ghostname[nmk];
            nmk++;
        }
    } else {
        int slots = cfg.slim_ws_slots;
        if (slots <= 0)
            for (int i = 0; i < ws_count; ++i)
                if ((ws_on_bar(b, &ws_list[i]) || cfg.ws_other) &&
                    ws_list[i].num > slots) slots = ws_list[i].num;
        if (slots > MAX_WORKSPACES) slots = MAX_WORKSPACES;
        float sw0 = cfg.slim_ws_w > 0 ? (float)cfg.slim_ws_w * s : tick;
        for (int i = 1; i <= slots; ++i) {
            Mark *m = &mk[nmk];
            m->x = x + (float)(i - 1) * (sw0 + gap);
            m->w = sw0;
            m->num = i;
            m->ws = ws_by_num(b, i);
            snprintf(ghostname[nmk], sizeof ghostname[nmk], "%d", i);
            m->name = m->ws ? m->ws->name : ghostname[nmk];
            nmk++;
        }
    }

    for (int k = 0; k < nmk; ++k) {
        Ws *w = mk[k].ws;
        float sx = mk[k].x, sw = mk[k].w;
        if (sw <= 0.0f) continue;
        /* Brightness says used from unused: a free number is barely a shadow,
         * one with a workspace on it is solid. */
        Col c = cfg.dim;
        c.a = 40;
        bool mine = w ? ws_on_bar(b, w) : true;
        if (w) {
            if (w->urgent) c = cfg.urgent;
            else if (w->focused) c = cfg.hl;
            else if (w->visible) c = cfg.accent;
            else { c = cfg.dim; c.a = 205; }

            /* Another screen's workspace is shown, but never with this
             * screen's emphasis: focused there is not focused here. */
            if (!mine) {
                if (w->focused || w->visible) { c = cfg.accent; c.a = 120; }
                else                          { c = cfg.dim;    c.a = 110; }
            }
        }
        fill_rect(cv, sx, y, sw, h, c);
        if (w) {
            int wi = (int)(w - ws_list);
            Col lc; float lf; bool faint;
            if (cpu_load_col(wi, &lc, &lf, &faint)) {
                /* Three or four dots up the slot. Filling it solid hid which
                 * workspace it was, which is the thing the slot is for. */
                dot_column(cv, sx, y, sw, h, 2.0f * s, 1.0f * s,
                           faint ? 0.001f : lf, lc);
            }
        }
        /* Every mark switches, a free one included — clicking it opens that
         * workspace, the same as its button does open. */
        if (b->hits < MAX_WORKSPACES) {
            b->hit[b->hits].x0 = sx / s;
            b->hit[b->hits].x1 = (sx + sw) / s;
            str_set(b->hit[b->hits].name, sizeof(b->hit[b->hits].name), mk[k].name);
            b->hits++;
        }
    }
    if (nmk > 0) x = mk[nmk - 1].x + mk[nmk - 1].w + gap;

    if (!cfg.cell_count) {                         /* status_command fallback */
        float rx = (float)cv->w - 4.0f * s;
        for (int i = rs->n - 1; i >= 0 && rx > x; --i) {
            if (!rs->v[i].has_fg) continue;
            float w = clampf((float)strlen(rs->v[i].text) * 2.0f * s, 6.0f * s, 40.0f * s);
            rx -= w;
            fill_rect(cv, rx, y, w, h, rs->v[i].fg);
            rx -= gap;
        }
        return;
    }

    /* the right hand group, in layout order */
    int idx[MAX_CELLS], mode[MAX_CELLS], n = 0;
    bool join[MAX_CELLS];
    float total = 0;
    for (int i = 0; i < layout_n[G_RIGHT] && n < MAX_CELLS; ++i) {
        Item *it = &layout_item[G_RIGHT][i];
        if (it->kind != IT_CELL) continue;
        Cell *e = &cfg.cell[it->cell];
        if (!cell_visible(e)) continue;
        int m = slim_mode(e);
        if (m == SLIM_OFF) continue;
        idx[n] = it->cell;
        mode[n] = m;
        join[n] = (n > 0 && !layout_item[G_RIGHT][i - 1].sep);
        total += slim_width_of(e, m, s) + (n ? (join[n] ? 1.0f * s : gap) : 0);
        n++;
    }
    float rx = (float)cv->w - 4.0f * s - total;
    if (rx < x + gap) rx = x + gap;

    /* Folded, a cell can sit under the middle of where it is in the full bar
     * instead of being packed against the right edge. Toggling then does not
     * move anything, so the clock is where the clock was and you can hit it
     * without looking. Falls back to packing until the full bar has been
     * drawn once, and wherever two marks would overlap. */
    /* Aligned, a mark takes its cell's whole place — same left edge, same
       width — so folding changes the height of the bar and nothing else. */
    float px[MAX_CELLS], pw[MAX_CELLS];
    bool  aligned = cfg.slim_align != 0;
    if (aligned) {
        for (int k = 0; k < n && aligned; ++k) {
            float c0 = b->cellx0[idx[k]] * s, c1 = b->cellx1[idx[k]] * s;
            if (c1 <= c0) { aligned = false; break; }        /* never measured */
            if (c0 < x + gap) c0 = x + gap;
            if (c1 > (float)cv->w - 3.0f * s) c1 = (float)cv->w - 3.0f * s;
            /* inset by the same padding the text has, so the mark lines up
               with the words that were there a moment ago. A gauge is the
               exception: it has ten segments to fit and a short cell like a
               battery percentage left it too cramped to read, so it takes the
               whole cell. */
            float cpad = mode[k] == SLIM_BAR ? (float)cfg.slim_bar_pad * s
                                             : (float)cfg.cell[idx[k]].pad * s;
            if (c1 - c0 - 2.0f * cpad < 4.0f * s) { aligned = false; break; }
            px[k] = c0 + cpad;
            pw[k] = c1 - c0 - 2.0f * cpad;
            /* A short cell — a two digit battery — leaves a gauge too small to
             * read ten blocks in. slim_w wins over the alignment when it is
             * set, growing about the cell's middle so the mark stays where the
             * text was. */
            if (cfg.cell[idx[k]].slim_w > 0) {
                float want = (float)cfg.cell[idx[k]].slim_w * s
                           - (mode[k] == SLIM_BAR ? 2.0f * cpad : 0.0f);
                if (want > pw[k]) {
                    px[k] -= (want - pw[k]) * 0.5f;
                    pw[k]  = want;
                    if (px[k] < x + gap) px[k] = x + gap;
                    if (px[k] + pw[k] > (float)cv->w - 3.0f * s)
                        px[k] = (float)cv->w - 3.0f * s - pw[k];
                }
            }
        }
    }

    /* A mark grown by slim_w can reach into the one beside it — the battery
     * sat right up against the temperature. Trim it back so there is always
     * a clear gap of slim_bar_pad on each side between two marks. */
    if (aligned) {
        float sep = fmaxf(2.0f * (float)cfg.slim_bar_pad * s, 2.0f * s);
        for (int k = 0; k < n; ++k) {
            if (k > 0) {
                float lim = px[k - 1] + pw[k - 1] + sep;
                if (px[k] < lim) { pw[k] -= lim - px[k]; px[k] = lim; }
            }
            if (k + 1 < n) {
                float lim = px[k + 1] - sep;
                if (px[k] + pw[k] > lim) pw[k] = lim - px[k];
            }
            if (pw[k] < 2.0f * s) pw[k] = 2.0f * s;
        }
    }

    for (int k = 0; k < n; ++k) {
        float w = aligned ? pw[k] : slim_width_of(&cfg.cell[idx[k]], mode[k], s);
        if (aligned) rx = px[k];
        else if (k)  rx += join[k] ? 1.0f * s : gap;
        if (rx + w > (float)cv->w - 3.0f * s) break;
        slim_draw_one(cv, &cfg.cell[idx[k]], mode[k], rx, y, w, h, s);
        if (b->chits < MAX_CELLS) {               /* buttons keep working */
            b->chit[b->chits].x0 = rx / s;
            b->chit[b->chits].x1 = (rx + w) / s;
            b->chit[b->chits].cell = idx[k];
            b->chits++;
        }
        rx += w;
    }

    if (blink > 0.0f)                            /* over the top, last */
        fill_rect(cv, x, y, (float)cv->w - 8.0f * s, h,
                  col_scale_alpha(msg_color(), blink));
}
/* --------------------------------------------------------------- workspaces
 * The buttons are a placeable item like any cell, so they are measured and
 * drawn through the same two-pass code. With ws_inset > 0 they float inside
 * the bar as their own pills instead of being as tall as the bar itself. */

/* A workspace from another screen is drawn smaller, so it has to be measured
 * smaller too, or the block comes out wider than what is in it. */
static Font *ws_font(Bar *b, Ws *w, Font *f)
{
    if (ws_on_bar(b, w)) return f;
    return font_get((int)((float)f->px * 0.78f + 0.5f));
}

static float ws_button_w(Font *f, Ws *w, float s)
{
    return fmaxf(text_width(f, w->label) + 2.0f * (float)cfg.ws_pad * s,
                 (float)cfg.ws_min_w * s);
}

/* The row the bar draws: with ws_slots set it is the numbers 1..n whether or
 * not they exist, then anything else that is open — a workspace numbered past
 * the end, or a named one. A free number is a button like any other, so it is
 * measured, placed and clicked like one; switching to it is what creates it.
 * Both the measuring and the drawing pass walk this, or the block comes out a
 * different width than what goes in it. */
typedef struct { Ws *w; bool ghost; } WsSlot;

static Ws ws_ghost[MAX_WORKSPACES];

static int ws_order(Bar *b, WsSlot *out, int max)
{
    int n = 0, lim = cfg.ws_slots;
    if (lim > MAX_WORKSPACES) lim = MAX_WORKSPACES;
    for (int k = 1; k <= lim && n < max; ++k) {
        Ws *w = ws_by_num(b, k);
        if (w) { out[n].w = w; out[n].ghost = false; }
        else {
            Ws *g = &ws_ghost[k - 1];
            memset(g, 0, sizeof(*g));
            g->num = k;
            snprintf(g->name, sizeof(g->name), "%d", k);
            str_set(g->label, sizeof(g->label), g->name);
            out[n].w = g; out[n].ghost = true;
        }
        n++;
    }
    for (int i = 0; i < ws_count && n < max; ++i) {
        Ws *w = &ws_list[i];
        if (!ws_on_bar(b, w) && !cfg.ws_other) continue;
        if (w->num >= 1 && w->num <= lim) continue;   /* already placed above */
        out[n].w = w; out[n].ghost = false; n++;
    }
    return n;
}

static float ws_block_w(Font *f, Bar *b, float s)
{
    WsSlot sl[MAX_WORKSPACES * 2];
    float w = 0;
    int n = ws_order(b, sl, MAX_WORKSPACES * 2);
    for (int i = 0; i < n; ++i)
        w += ws_button_w(ws_font(b, sl[i].w, f), sl[i].w, s);
    if (n > 1) w += (float)(n - 1) * (float)cfg.ws_gap * s;
    return w;
}

/* one pill, square on the screen edge only when it is flush with it */
static void pill(Canvas *cv, float x, float y0, float vis, float w, float s,
                 float rad, Col c)
{
    float in = (float)cfg.ws_inset * s;
    bool top = strcmp(cfg.position, "bottom") != 0;
    float y = y0 + in, h = vis - 2.0f * in;
    if (in <= 0) {
        if (top) fill_round(cv, x, y0, w, vis, 0, 0, rad, rad, c);
        else     fill_round(cv, x, y0, w, vis, rad, rad, 0, 0, c);
        return;
    }
    fill_round(cv, x, y, w, h, rad, rad, rad, rad, c);
}

static float ws_radius_px(float vis, float s)
{
    if (cfg.ws_radius >= 0) return cfg.ws_radius * s;
    if (cfg.ws_inset > 0) return vis;            /* capped to a full pill */
    return cfg.radius * s;
}

static void ws_block_draw(Canvas *cv, Bar *b, Font *f, float x, float y0,
                          float vis, float s, float fade)
{
    float rad = ws_radius_px(vis, s);
    float base = baseline_for(f, y0, vis, s);
    WsSlot sl[MAX_WORKSPACES * 2];
    int nsl = ws_order(b, sl, MAX_WORKSPACES * 2);
    b->wsbx0 = x / s;
    b->wsbw  = 0;
    for (int k = 0; k <= MAX_WORKSPACES; ++k) b->wsnx0[k] = b->wsnx1[k] = 0;
    b->wsbtn_n = 0;
    for (int k = 0; k < nsl; ++k) {
        Ws *w = sl[k].w;
        int i = sl[k].ghost ? -1 : (int)(w - ws_list);
        bool mine = ws_on_bar(b, w);

        Font *wf = ws_font(b, w, f);
        float bwid = ws_button_w(wf, w, s);
        float tw = text_width(wf, w->label);

        Col bg = cfg.ws_bg, fg = cfg.ws_fg;
        if (w->urgent)       { bg = cfg.ws_urgent_bg;  fg = cfg.ws_urgent_fg;  }
        else if (w->focused) { bg = cfg.ws_focused_bg; fg = cfg.ws_focused_fg; }
        else if (w->visible) { bg = cfg.ws_visible_bg; fg = cfg.ws_visible_fg; }

        /* A number nobody is using: the same button in the same place, just
         * faint, so the row is a fixed ten and clicking one opens it. */
        float ga = clampf((float)cfg.ws_empty_alpha / 100.0f, 0.0f, 1.0f);
        if (sl[k].ghost) {
            bg = col_scale_alpha(bg, ga);
            fg = col_scale_alpha(fg, ga);
        }

        /* A workspace on another monitor is drawn as a short pill sitting on
         * the baseline: still readable, still clickable, and obviously not
         * one of this screen's. */
        float bh = mine ? vis : vis * 0.55f;
        float by = mine ? y0  : y0 + (vis - bh);
        float bfade = mine ? fade : fade * 0.75f;

        pill(cv, x, by, bh, bwid, s, mine ? rad : rad * 0.6f,
             col_scale_alpha(bg, bfade));
        /* With ws_bg transparent an unused workspace was a bare number with no
         * edge, so the row read as loose text rather than buttons. The outline
         * gives every one the same cell, filled or not. */
        if (cfg.ws_border > 0) {
            float br = mine ? rad : rad * 0.6f, in = (float)cfg.ws_inset * s;
            float oy = by, oh = bh, t0 = br, t1 = br, b0 = br, b1 = br;
            if (in > 0) { oy += in; oh -= 2.0f * in; }
            else if (strcmp(cfg.position, "bottom") != 0) t0 = t1 = 0;
            else                                         b0 = b1 = 0;
            stroke_round(cv, x, oy, bwid, oh, t0, t1, b1, b0,
                         (float)cfg.ws_border * s,
                         col_scale_alpha(cfg.ws_border_col, bfade));
        }
        if (mine)
            text_draw(cv, f, x + (bwid - tw) * 0.5f, base,
                      col_scale_alpha(fg, fade), w->label);
        else {
            /* smaller type, lifted clear of the bottom edge, and a little
               see-through: it belongs to another screen */
            float base2 = baseline_for(wf, by, bh, s) - 1.5f * s;
            text_draw(cv, wf, x + (bwid - tw) * 0.5f, base2,
                      col_scale_alpha(fg, bfade * 0.72f), w->label);
        }

        Col lc; float lf; bool faint;
        if (cpu_load_col(i, &lc, &lf, &faint)) {
            /* Up the right edge of the button, the same dots as the folded
             * strip so the two read as one idea. */
            float dw  = clampf(2.0f * s, 1.0f, 3.0f);
            float pad = 3.0f * s;
            dot_column(cv, x + bwid - dw - pad, by + pad, dw, bh - 2.0f * pad,
                       2.0f * s, 2.0f * s, faint ? 0.001f : lf,
                       col_scale_alpha(lc, bfade));
        }

        if (b->hits < MAX_WORKSPACES) {
            b->hit[b->hits].x0 = x / s;
            b->hit[b->hits].x1 = (x + bwid) / s;
            str_set(b->hit[b->hits].name, sizeof(b->hit[b->hits].name), w->name);
            b->hits++;
        }
        if (i >= 0 && i < MAX_WORKSPACES) {       /* for the folded strip */
            b->wsx0[i] = x / s;
            b->wsx1[i] = (x + bwid) / s;
        }
        /* By number as well, ghosts included: that is what the folded strip
         * copies, so a slot is exactly its own button and not the widest
         * one. */
        if (w->num >= 1 && w->num <= MAX_WORKSPACES) {
            b->wsnx0[w->num] = x / s;
            b->wsnx1[w->num] = (x + bwid) / s;
        }
        if (b->wsbtn_n < MAX_WORKSPACES * 2) {
            int q = b->wsbtn_n++;
            b->wsbtn[q].x0 = x / s;
            b->wsbtn[q].x1 = (x + bwid) / s;
            b->wsbtn[q].num = w->num;
            str_set(b->wsbtn[q].name, sizeof(b->wsbtn[q].name), w->name);
        }
        if (bwid > b->wsbw) b->wsbw = bwid / s;
        x += bwid + (float)cfg.ws_gap * s;
        b->wsbx1 = (x - (float)cfg.ws_gap * s) / s;
    }
}

static bool mode_shown(void) { return cfg.mode_show && strcmp(sway_mode, "default"); }

static float mode_w(Font *f, float s)
{
    if (!mode_shown()) return 0;
    return text_width(f, sway_mode) + 2.0f * (float)cfg.ws_pad * s;
}

static void mode_draw(Canvas *cv, Font *f, float x, float y0, float vis, float s, float fade)
{
    if (!mode_shown()) return;
    pill(cv, x, y0, vis, mode_w(f, s), s, ws_radius_px(vis, s),
         col_scale_alpha(cfg.mode_bg, fade));
    text_draw(cv, f, x + (float)cfg.ws_pad * s, baseline_for(f, y0, vis, s),
              col_scale_alpha(cfg.mode_fg, fade), sway_mode);
}

/* ------------------------------------------------------------- text cells */
/* A cell with scroll=1 never pushes the layout around: too long and it ends
 * in "..", and it scrolls through the full text while the pointer is on it. */

static bool scroll_running = false;

static void runs_truncate(Font *f, Runs *rs, float maxw, float ellw)
{
    float w = 0;
    for (int i = 0; i < rs->n; ++i) {
        char *txt = rs->v[i].text;
        const char *p = txt;
        while (*p) {
            const char *prev = p;
            unsigned cp = utf8_next(&p);
            float aw = glyph_get(f, cp)->adv;
            if (w + aw > maxw - ellw) {
                size_t keep = (size_t)(prev - txt);
                txt[keep] = 0;
                if (keep + 3 < sizeof(rs->v[i].text)) strcat(txt, "..");
                rs->n = i + 1;
                return;
            }
            w += aw;
        }
    }
}

/* how far a hovered cell has scrolled: pause, glide, pause, jump back */
static float scroll_offset(Cell *e, float over, float s)
{
    uint32_t t = now_ms();
    if (!e->scroll_t) e->scroll_t = t;
    float speed = fmaxf((float)cfg.scroll_speed, 1.0f) * s;
    float pause = fmaxf((float)cfg.scroll_pause, 0.0f) / 1000.0f;
    float dur = over / speed;
    float cycle = pause + dur + pause;
    float el = (float)(t - e->scroll_t) / 1000.0f;
    float ph = cycle > 0 ? fmodf(el, cycle) : 0;
    scroll_running = true;
    if (ph < pause) return 0;
    if (ph < pause + dur) return (ph - pause) / dur * over;
    return over;
}

/* ------------------------------------------------------------------ groups */

/* space after an item: the cell may override the global cell_gap, which is
 * how two cells are pushed together into one visible box */
static float item_gap(Item *it, float s)
{
    int g = cfg.cell_gap;
    if (it->kind == IT_CELL && cfg.cell[it->cell].gap >= 0) g = cfg.cell[it->cell].gap;
    return (float)g * s;
}

static float item_width(Canvas *cv, Bar *b, Font *f, Item *it, float s,
                        char *txt, size_t cap, Col *col, float *tw)
{
    (void)cv;
    if (it->kind == IT_WS)   { *tw = 0; return ws_block_w(f, b, s); }
    if (it->kind == IT_MODE) { *tw = 0; return mode_w(f, s); }

    Cell *e = &cfg.cell[it->cell];
    cell_display(e, txt, cap, col);
    Runs rs;
    int saved = cfg.markup;
    cfg.markup = e->markup;
    markup_parse(txt, &rs, *col);
    cfg.markup = saved;
    float w = 0;
    for (int k = 0; k < rs.n; ++k) w += text_width(f, rs.v[k].text);
    *tw = w;
    float pad = 2.0f * (float)e->pad * s;
    float box = fmaxf(w + pad, (float)e->min_w * s);
    if (e->max_w > 0) box = fminf(box, (float)e->max_w * s);
    if (e->scroll && e->min_w > 0) box = (float)e->min_w * s;   /* fixed slot */
    return box;
}

/* Draws one group. Returns the left edge it occupies, so the next group in
 * from the right knows where it must stop. With measure = true nothing is
 * painted and the group's total width comes back instead — that is how the
 * left group reserves its space before the right one is placed. */
static float draw_group_(Canvas *cv, Bar *b, Font *f, int g, float y0, float vis,
                         float s, float fade, float left_limit, float right,
                         bool measure)
{
    static char txt[MAX_CELLS + 4][1024];
    float bw[MAX_CELLS + 4], tw[MAX_CELLS + 4];
    Col col[MAX_CELLS + 4];
    int idx[MAX_CELLS + 4], n = 0;

    float sep_w = *cfg.separator ? text_width(f, cfg.separator) : 0.0f;
    float total = 0;

    for (int i = 0; i < layout_n[g]; ++i) {
        Item *it = &layout_item[g][i];
        if (it->kind == IT_CELL && !cell_visible(&cfg.cell[it->cell])) continue;
        float w = item_width(cv, b, f, it, s, txt[n], sizeof(txt[n]), &col[n], &tw[n]);
        if (w <= 0) continue;
        bw[n] = w;
        idx[n] = i;
        total += w;
        n++;
    }
    if (!n) return measure ? 0.0f : right;
    for (int k = 0; k + 1 < n; ++k) {
        Item *it = &layout_item[g][idx[k]];
        float ig = item_gap(it, s);
        total += ig + (it->sep && sep_w > 0 ? ig + sep_w : 0.0f);
    }

    /* too wide: text cells give up their width first, that is what they are
     * for. Everything else keeps its size and the group clips at the edge. */
    float avail = right - left_limit;
    if (total > avail) {
        float excess = total - avail;
        float floor_w = 60.0f * s;
        for (int k = 0; k < n && excess > 0.5f; ++k) {
            Item *it = &layout_item[g][idx[k]];
            if (it->kind != IT_CELL || !cfg.cell[it->cell].scroll) continue;
            float can = bw[k] - floor_w;
            if (can <= 0) continue;
            float take = fminf(can, excess);
            bw[k] -= take;
            total -= take;
            excess -= take;
        }
    }
    if (measure) return total;

    float x;
    if (g == G_LEFT)        x = left_limit;
    else if (g == G_CENTER) x = ((float)cv->w - total) * 0.5f;
    else                    x = right - total;
    if (x + total > right) x = right - total;
    if (x < left_limit) x = left_limit;
    float origin = x;
    float base = baseline_for(f, y0, vis, s);

    /* where every item lands, so joined backgrounds can be merged into one
     * box instead of two rounded ones meeting in a notch */
    float xs[MAX_CELLS + 4];
    {
        float cx = x;
        for (int k = 0; k < n; ++k) {
            Item *it = &layout_item[g][idx[k]];
            xs[k] = cx;
            cx += bw[k];
            if (k + 1 < n) {
                float ig = item_gap(it, s);
                cx += ig + (it->sep && sep_w > 0 ? sep_w + ig : 0.0f);
            }
        }
    }
    for (int k = 0; k < n; ) {
        Item *it = &layout_item[g][idx[k]];
        if (it->kind != IT_CELL || !cfg.cell[it->cell].has_bg ||
            cell_is_msg(&cfg.cell[it->cell])) { k++; continue; }
        Col bgc = cfg.cell[it->cell].bg;
        int e2 = k;
        while (e2 + 1 < n) {                       /* extend over glued cells */
            Item *cur = &layout_item[g][idx[e2]];
            Item *nx = &layout_item[g][idx[e2 + 1]];
            if (cur->sep || item_gap(cur, s) > 0.5f) break;
            if (nx->kind != IT_CELL || !cfg.cell[nx->cell].has_bg) break;
            Col nc = cfg.cell[nx->cell].bg;
            if (nc.r != bgc.r || nc.g != bgc.g || nc.b != bgc.b || nc.a != bgc.a) break;
            e2++;
        }
        float in = (float)cfg.cell_inset * s;
        float r = cfg.cell_radius * s;
        fill_round(cv, xs[k], y0 + in, xs[e2] + bw[e2] - xs[k], vis - 2.0f * in,
                   r, r, r, r, col_scale_alpha(bgc, fade));
        k = e2 + 1;
    }

    for (int k = 0; k < n; ++k) {
        Item *it = &layout_item[g][idx[k]];
        x = xs[k];

        if (it->kind == IT_WS) {
            ws_block_draw(cv, b, f, x, y0, vis, s, fade);
        } else if (it->kind == IT_MODE) {
            mode_draw(cv, f, x, y0, vis, s, fade);
        } else {
            Cell *e = &cfg.cell[it->cell];
            bool hover = b->hovered && b->px * s >= x && b->px * s < x + bw[k];

            Runs rs;
            int saved = cfg.markup;
            cfg.markup = e->markup;
            markup_parse(txt[k], &rs, col[k]);
            cfg.markup = saved;

            float pad = (float)e->pad * s;
            float inner = bw[k] - 2.0f * pad;
            float tx = x + pad, over = tw[k] - inner;
            if (over > 0 && e->scroll) {
                if (hover) tx -= scroll_offset(e, over, s);
                else { e->scroll_t = 0; runs_truncate(f, &rs, inner, text_width(f, "..")); }
            } else if (over <= 0) {
                if (!strcmp(e->align, "right")) tx = x + bw[k] - pad - tw[k];
                else if (!strcmp(e->align, "center")) tx = x + (bw[k] - tw[k]) * 0.5f;
            }

            int ox0 = cv->cx0, ox1 = cv->cx1;
            canvas_clip(cv, (int)(x + pad), cv->cy0, (int)ceilf(x + bw[k] - pad), cv->cy1);
            for (int r = 0; r < rs.n; ++r) {
                float rw = text_width(f, rs.v[r].text);
                if (rs.v[r].has_bg)
                    fill_rect(cv, tx, y0 + 2.0f * s, rw, vis - 4.0f * s,
                              col_scale_alpha(rs.v[r].bg, fade));
                text_draw(cv, f, tx, base, col_scale_alpha(rs.v[r].fg, fade), rs.v[r].text);
                tx += rw;
            }
            canvas_clip(cv, ox0, cv->cy0, ox1, cv->cy1);

            if (it->cell >= 0 && it->cell < MAX_CELLS) {   /* for the strip */
                b->cellx0[it->cell] = x / s;
                b->cellx1[it->cell] = (x + bw[k]) / s;
            }
            if (b->chits < MAX_CELLS) {
                b->chit[b->chits].x0 = x / s;
                b->chit[b->chits].x1 = (x + bw[k]) / s;
                b->chit[b->chits].cell = it->cell;
                b->chits++;
            }
        }

        x += bw[k];
        if (k + 1 < n) {
            float ig = item_gap(it, s);
            x += ig;
            if (it->sep && sep_w > 0) {
                text_draw(cv, f, x, base, col_scale_alpha(cfg.separator_color, fade),
                          cfg.separator);
                x += sep_w + ig;
            }
        }
    }
    return origin;
}

/* A message with no cell to live in is drawn centred on its own. */
static float draw_message(Canvas *cv, Bar *b, Font *f, float y0, float vis,
                          float s, float fade, float left_limit, float right)
{
    if (!msg_active()) return right;
    for (int i = 0; i < cfg.cell_count; ++i)      /* a cell already shows it */
        if (cell_is_msg(&cfg.cell[i])) return right;

    Runs rs;
    markup_parse(msg_text, &rs, msg_color());
    float w = 0;
    for (int i = 0; i < rs.n; ++i) w += text_width(f, rs.v[i].text);
    float x = ((float)cv->w - w) * 0.5f;
    if (x + w > right) x = right - w;
    if (x < left_limit) x = left_limit;
    float origin = x;
    float base = baseline_for(f, y0, vis, s);
    int ox0 = cv->cx0, ox1 = cv->cx1;
    canvas_clip(cv, (int)x, cv->cy0, (int)ceilf(x + w), cv->cy1);
    for (int i = 0; i < rs.n; ++i) {
        float rw = text_width(f, rs.v[i].text);
        text_draw(cv, f, x, base, col_scale_alpha(rs.v[i].fg, fade), rs.v[i].text);
        x += rw;
    }
    canvas_clip(cv, ox0, cv->cy0, ox1, cv->cy1);
    (void)b;
    return origin;
}

static float draw_group(Canvas *cv, Bar *b, Font *f, int g, float y0, float vis,
                        float s, float fade, float left_limit, float right)
{
    return draw_group_(cv, b, f, g, y0, vis, s, fade, left_limit, right, false);
}

static float group_width(Canvas *cv, Bar *b, Font *f, int g, float vis, float s)
{
    return draw_group_(cv, b, f, g, 0, vis, s, 1.0f, 0, (float)cv->w, true);
}

/* what the group wants, with nothing squeezed */
static float group_natural(Canvas *cv, Bar *b, Font *f, int g, float vis, float s)
{
    return draw_group_(cv, b, f, g, 0, vis, s, 1.0f, 0, 1.0e6f, true);
}

/* The bar sizes itself: as wide as its content needs, never under min_width,
 * never wider than the output. Cells come and go (charging, docker, a longer
 * clock), so this is checked on every paint and the layer surface is only
 * resized when it actually changed. */
static int bar_natural_width(Bar *b, Canvas *cv, Font *f, float vis, float s)
{
    float lw = group_natural(cv, b, f, G_LEFT, vis, s);
    float cw = group_natural(cv, b, f, G_CENTER, vis, s);
    float rw = group_natural(cv, b, f, G_RIGHT, vis, s);
    float gap = (float)cfg.cell_gap * s;
    int groups = (lw > 0) + (cw > 0) + (rw > 0);
    float total = lw + cw + rw;
    if (groups > 1) total += (float)(groups - 1) * gap * 2.0f;
    total += (float)cfg.pad_x * s + (float)(cfg.pad_right >= 0 ? cfg.pad_right : cfg.pad_x) * s;

    /* The folded strip can need more room than the open bar — ten workspace
     * slots against however many are actually open. The surface is sized once
     * for both, so folding never has to ask the compositor for a new width
     * (and could not: the strip is drawn after the fitting). */
    /* Only the packed strip picks its own count; lined up it is the open
     * bar's buttons and needs no more room than they do. */
    if (cfg.signals && !cfg.slim_align && cfg.slim_ws_slots > 0 && b->wsbw > 0) {
        int n = cfg.slim_ws_slots;
        float strip = (float)n * (cfg.slim_ws_w > 0 ? (float)cfg.slim_ws_w : b->wsbw)
                    + (float)(n - 1) * (float)cfg.ws_gap;
        float have = b->wsbx1 - b->wsbx0;
        if (strip > have) total += (strip - have) * s;
    }

    int want = (int)ceilf(total / s);
    if (want < cfg.min_width) want = cfg.min_width;

    int limit = 0;
    if (b->out && b->out->mode_w > 0)
        limit = b->out->mode_w / (b->out->scale > 0 ? b->out->scale : 1) - 2 * cfg.side_margin;
    if (limit > 0 && want > limit) want = limit;
    return want;
}

/* How tall the surface has to be: the bar, plus a strip for the hover text
 * when there is one. Growing the cell instead pushed everything beside it
 * along and left a hole at the end of the row, which is not what a tooltip
 * should do to a bar. */
static int bar_wanted_h(Bar *b)
{
    return bar_height_logical() + b->tip_h;
}

/* one row per line, so `cal` gets its six weeks */
static int bar_tip_height(Bar *b, const char *txt)
{
    (void)b;
    int lines = 1;
    for (const char *p = txt; *p; ++p) if (*p == '\n') lines++;
    int row = (int)lroundf(cfg.text_px * cfg.ui_scale * 1.35f);
    if (row < 8) row = 8;
    return lines * row + 8;
}

static void bar_fit_height(Bar *b)
{
    if (!b->ls) return;
    int want = bar_wanted_h(b);
    if (want == b->h) return;

    /* Width 0 means "as wide as the output", which the protocol only allows
     * when anchored to both sides. A floating bar is not, so it has to send a
     * real width — and want_w is still zero until the width has been fitted
     * once, which since it stopped fitting during animations is exactly when
     * a fold would ask for a new height. */
    uint32_t now = now_ms();
    if (b->last_fit && (int32_t)(now - b->last_fit) < 100) return;
    b->last_fit = now;
    wl_count.resize++;

    uint32_t w = 0;
    if (cfg.min_width > 0) {
        w = (uint32_t)(b->want_w > 0 ? b->want_w : b->w);
        if (!w) return;                          /* nothing sensible to ask */
    }
    ls_set_size(b->ls, w, (uint32_t)want);
    wl_surface_commit(b->surf);
}

/* the text a hovered cell wants to show, or NULL */
/* A month grid, built here rather than shelled out to cal(1): that way today
 * can be marked, the columns line up whatever the font, and resting on the
 * clock spawns nothing. Weeks start on Monday. */
static void hover_cal_build(Cell *e)
{
    time_t now = time(NULL);
    struct tm t;
    localtime_r(&now, &t);

    struct tm first = t;
    first.tm_mday = 1;
    first.tm_mon += e->cal_off;                  /* the arrows move this */
    while (first.tm_mon > 11) { first.tm_mon -= 12; first.tm_year++; }
    while (first.tm_mon < 0)  { first.tm_mon += 12; first.tm_year--; }
    first.tm_hour = 12; first.tm_min = 0; first.tm_sec = 0;
    time_t ft = mktime(&first);
    localtime_r(&ft, &first);

    static const int LEN[] = { 31,28,31,30,31,30,31,31,30,31,30,31 };
    int year = first.tm_year + 1900, mon = first.tm_mon;
    int days = LEN[mon];
    if (mon == 1 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)) days = 29;

    int lead = (first.tm_wday + 6) % 7;          /* Monday first */
    static const char *MON[] = { "January","February","March","April","May",
                                 "June","July","August","September","October",
                                 "November","December" };

    char out[1024];
    size_t o = 0;
    o += (size_t)snprintf(out + o, sizeof(out) - o, "%s %d\n", MON[mon], year);
    o += (size_t)snprintf(out + o, sizeof(out) - o, "Mo Tu We Th Fr Sa Su\n");

    char hl[16];
    snprintf(hl, sizeof(hl), "%02x%02x%02x", cfg.hl.r, cfg.hl.g, cfg.hl.b);

    int col = 0;
    for (int i = 0; i < lead; ++i, ++col)
        o += (size_t)snprintf(out + o, sizeof(out) - o, "   ");
    for (int d = 1; d <= days && o < sizeof(out) - 64; ++d) {
        bool is_today = d == t.tm_mday && first.tm_mon == t.tm_mon &&
                        first.tm_year == t.tm_year;
        if (is_today)
            o += (size_t)snprintf(out + o, sizeof(out) - o,
                                  "<span foreground=\"%s\">%2d</span>%s", hl, d,
                                  col == 6 ? "" : " ");
        else
            o += (size_t)snprintf(out + o, sizeof(out) - o, "%2d%s", d,
                                  col == 6 ? "" : " ");
        if (++col == 7) { col = 0; if (d < days) o += (size_t)snprintf(out + o, sizeof(out) - o, "\n"); }
    }
    str_set(e->out_hover, sizeof(e->out_hover), out);
}

/* `cal`, or anything else whose output is the panel. Run once when the hover
 * starts and kept until it ends, so resting on the clock does not spawn a
 * process every frame. */
/* Run it, but never wait on it for long: this happens on the frame the
 * pointer arrives, so a command that blocks blocks the whole bar — which is
 * what a frozen bar turns out to be. */
static void hover_cmd_run(Cell *e)
{
    e->out_hover[0] = 0;

    char guarded[320];
    snprintf(guarded, sizeof(guarded), "timeout 2 sh -c %c%s%c",
             '\'', e->hover_cmd, '\'');

    FILE *p = popen(guarded, "r");
    if (!p) return;
    size_t n = fread(e->out_hover, 1, sizeof(e->out_hover) - 1, p);
    pclose(p);
    e->out_hover[n] = 0;
    while (n && (e->out_hover[n - 1] == '\n' || e->out_hover[n - 1] == ' '))
        e->out_hover[--n] = 0;
}

static const char *bar_tip_text(Bar *b)
{
    /* A message says itself, for a few seconds, wherever the pointer is —
     * folded there is nowhere else for the words to go. */
    if (msg_active() && cfg.msg_panel > 0 && msg_at &&
        (int32_t)(now_ms() - msg_at) < cfg.msg_panel * 1000) {
        b->tip_msg  = true;
        b->tip_cell = -1;
        b->tip_cx   = (float)b->w * 0.5f;
        return msg_text;
    }
    b->tip_msg = false;

    if (!b->hovered) return NULL;

    /* A cell set to open on a click stays open until it is clicked again or
     * something else is, so you can read it without holding the pointer
     * still — and pointing at it does nothing. */
    if (b->tip_pinned >= 0 && b->tip_pinned < cfg.cell_count) {
        Cell *e = &cfg.cell[b->tip_pinned];
        if (e->out_hover[0]) {
            b->tip_cell = b->tip_pinned;
            /* where to hang it from. Without this the panel kept whatever
             * position it had — for a click-opened one, none at all, so it
             * went to the far left instead of under its cell. */
            for (int i = 0; i < b->chits; ++i)
                if (b->chit[i].cell == b->tip_pinned) {
                    b->tip_cx = (b->chit[i].x0 + b->chit[i].x1) * 0.5f;
                    break;
                }
            return e->out_hover;
        }
        b->tip_pinned = -1;
    }

    /* The panel is part of the bar's surface, so the pointer can be on it
     * rather than on the cell — keep it open while it is. */
    if (b->tip_showing >= 0 && b->tip_h > 0) {
        bool top = strcmp(cfg.position, "bottom") != 0;
        double t0 = top ? bar_visible_logical(b) : 0;
        double t1 = top ? (double)b->h : (double)b->tip_h;
        if (b->py >= t0 && b->py < t1) {
            b->tip_cell = b->tip_showing;
            for (int i = 0; i < b->chits; ++i)
                if (b->chit[i].cell == b->tip_cell) {
                    b->tip_cx = (b->chit[i].x0 + b->chit[i].x1) * 0.5f;
                    break;
                }
            return cfg.cell[b->tip_cell].out_hover;
        }
    }

    /* half the gap either side counts as the cell: the padding between two
     * cells belongs to whichever you are nearest, not to neither */
    float slack = (float)cfg.cell_gap * 0.5f;
    for (int i = 0; i < b->chits; ++i) {
        if (b->px < b->chit[i].x0 - slack || b->px >= b->chit[i].x1 + slack) continue;
        Cell *e = &cfg.cell[b->chit[i].cell];
        if (e->hover_click) return NULL;               /* it waits for a click */
        if (!e->out_hover[0] && !*e->hover_cmd && !e->hover_cal) return NULL;
        if (b->tip_showing != b->chit[i].cell) {
            if (e->hover_cal)        { e->cal_off = 0; hover_cal_build(e); }
            else if (*e->hover_cmd)  hover_cmd_run(e);
        }
        if (!e->out_hover[0]) return NULL;
        b->tip_cell = b->chit[i].cell;
        /* where the cell is, taken now: the hit areas are cleared before the
         * panel is painted, and falling back to the pointer made the panel
         * slide about under the cursor */
        b->tip_cx = (b->chit[i].x0 + b->chit[i].x1) * 0.5f;
        return e->out_hover;
    }
    return NULL;
}

/* Ask the compositor for a new size — sparingly.
 *
 * Every one of these is a round trip: set_size, a configure back, a fresh
 * pool of buffers, a transaction in the compositor. A bar whose content width
 * wobbles by a pixel — a gauge counting up, a cell scrolling — could ask
 * sixty times a second for hours, and nothing on this side would look wrong
 * while the compositor did all the work. So: not while anything is moving,
 * not more than four times a second, and not for differences too small to
 * see. */
static void bar_fit_width(Bar *b, Canvas *cv, Font *f, float vis, float s)
{
    if (cfg.min_width <= 0 || !b->ls) return;
    if (scroll_running || b->vis != b->anim_to) return;

    uint32_t now = now_ms();
    if (b->last_fit && (int32_t)(now - b->last_fit) < 250) return;

    int want = bar_natural_width(b, cv, f, vis, s);

    /* Growing happens at once — clipped text is worse than a bar that moves.
     * Shrinking waits. A floating bar is centred, so every change of width
     * moves everything on it, and most of them undo themselves: the battery
     * going from 100 to 99, a temperature losing a digit, a cell that blinks
     * empty for a second. A shrink smaller than shrink_px is ignored outright,
     * and a larger one has to hold for shrink_s before the bar follows. */
    if (want < b->w) {
        if (b->w - want < cfg.shrink_px) { b->shrink_since = 0; return; }
        if (!b->shrink_since) { b->shrink_since = now ? now : 1; return; }
        if ((int32_t)(now - b->shrink_since) < cfg.shrink_s * 1000) return;
    }
    b->shrink_since = 0;
    if (want == b->want_w || abs(want - b->w) < 4) return;

    b->want_w  = want;
    b->last_fit = now;
    wl_count.resize++;
    ls_set_size(b->ls, (uint32_t)want, (uint32_t)b->h);
    wl_surface_commit(b->surf);
}

/* Everything the bar paints, into a plain canvas. Split out of bar_render so
 * it can be exercised without a compositor. */
/* the hover text, in the strip of surface reserved under (or over) the bar */
static void bar_paint_tip(Bar *b, Canvas *cv, Font *f, float s, bool top,
                          float bar_y0, float bar_vis)
{
    const char *txt = b->tip_msg ? msg_text
                    : (b->tip_cell >= 0 && b->tip_cell < cfg.cell_count
                       ? cfg.cell[b->tip_cell].out_hover : NULL);
    if (!txt || !*txt || b->tip_h <= 0) return;

    float th = (float)b->tip_h * s;
    float ty = top ? bar_y0 + bar_vis : bar_y0 - th;

    /* The canvas is clipped to the bar's own rows by the time we get here,
     * and the panel is by definition outside them — so it was being drawn
     * and thrown away every frame. Open the clip to its strip, and put it
     * back for whatever the bar draws next. */
    canvas_clip(cv, 0, (int)floorf(ty), cv->w, (int)ceilf(ty + th));

    /* one Runs per line: `cal` is a block of text, not a sentence */
    char buf[1024];
    str_set(buf, sizeof(buf), txt);

    char *line[24];
    int   nlines = 0;
    for (char *p = buf; *p && nlines < (int)(sizeof line / sizeof *line); ) {
        line[nlines++] = p;
        char *nl = strchr(p, '\n');
        if (!nl) break;
        *nl = 0;
        p = nl + 1;
    }

    Runs rs[24];
    int saved = cfg.markup;
    cfg.markup = b->tip_msg ? 1 : cfg.cell[b->tip_cell].markup;
    Col tipcol = b->tip_msg ? msg_color() : cell_color(&cfg.cell[b->tip_cell]);
    float tw = 0;
    for (int i = 0; i < nlines; ++i) {
        markup_parse(line[i], &rs[i], tipcol);
        float lw = 0;
        for (int j = 0; j < rs[i].n; ++j) lw += text_width(f, rs[i].v[j].text);
        if (lw > tw) tw = lw;
    }
    cfg.markup = saved;

    /* the same breathing room a cell gives its text, so the panel does not
       look tighter than the thing it dropped out of */
    float pad = (float)(b->tip_msg ? 8 : cfg.cell[b->tip_cell].pad) * s;
    if (pad < 10.0f * s) pad = 10.0f * s;

    float pw  = tw + 2.0f * pad;
    float rad = clampf(cfg.radius * s, 0.0f, th * 0.5f);

    float bx = clampf(b->tip_cx * s - pw * 0.5f, 0.0f, (float)cv->w - pw);
    if (bx < 0.0f) bx = 0.0f;

    /* Hard against an end of the bar: line the panel up with it and square
       the corners that meet, so the outer edge is one straight line. */
    b->tip_edge = 0;
    float snap = rad + 6.0f * s;
    if (bx <= snap)                     { bx = 0.0f;              b->tip_edge = -1; }
    else if (bx + pw >= cv->w - snap)   { bx = (float)cv->w - pw;  b->tip_edge = +1; }

    /* Slide out and fade in: it should arrive rather than appear. */
    float k = cfg.anim_ms > 0
            ? clampf((float)(now_ms() - b->tip_at) / (float)cfg.anim_ms, 0.0f, 1.0f)
            : 1.0f;
    float e = k * k * (3.0f - 2.0f * k);
    float slide = (1.0f - e) * th * 0.45f;
    ty += top ? -slide : slide;

    /* Only the edge where the two meet is square. The far corners stay
       rounded: it is the bar that gives up its corner to the panel, not the
       other way round. */
    if (top) fill_round(cv, bx, ty, pw, th, 0, 0, rad, rad,
                        col_scale_alpha(cfg.bg, e));
    else     fill_round(cv, bx, ty, pw, th, rad, rad, 0, 0,
                        col_scale_alpha(cfg.bg, e));

    bool cal = !b->tip_msg && cfg.cell[b->tip_cell].hover_cal != 0;
    float row = (th - 8.0f * s) / (float)(nlines > 0 ? nlines : 1);
    for (int i = 0; i < nlines; ++i) {
        float ly = ty + 4.0f * s + (float)i * row;
        float base = baseline_for(f, ly, row, s);
        float x = bx + pad;
        if (cal && i == 0) {                     /* the month sits centred
                                                    between the two arrows */
            float lw = 0;
            for (int j = 0; j < rs[i].n; ++j) lw += text_width(f, rs[i].v[j].text);
            x = bx + (pw - lw) * 0.5f;
        }
        for (int j = 0; j < rs[i].n; ++j) {
            Col tc = rs[i].v[j].has_fg ? rs[i].v[j].fg : cfg.text;
            text_draw(cv, f, x, base, col_scale_alpha(tc, e), rs[i].v[j].text);
            x += text_width(f, rs[i].v[j].text);
        }
    }

    /* ‹ › on the title row, so the month can be paged. Their boxes are kept
       in logical pixels for the click handler. */
    b->cal_x0 = b->cal_x1 = b->cal_x2 = b->cal_x3 = 0;
    if (cal && nlines > 0) {
        const char *L = "\xe2\x80\xb9", *R = "\xe2\x80\xba";   /* ‹ › */
        float aw = text_width(f, L), ar = text_width(f, R);
        float base = baseline_for(f, ty + 4.0f * s, row, s);
        Col ac = col_scale_alpha(cfg.accent, e);
        float lx = bx + pad, rx2 = bx + pw - pad - ar;
        text_draw(cv, f, lx,  base, ac, L);
        text_draw(cv, f, rx2, base, ac, R);
        /* the whole end of the title row, padding included: a single glyph
           is a small thing to hit */
        b->cal_x0 = bx / s;                     b->cal_x1 = (lx + aw + pad) / s;
        b->cal_x2 = (rx2 - pad) / s;            b->cal_x3 = (bx + pw) / s;
        b->cal_y0 = ty / s;               b->cal_y1 = (ty + row + 8.0f * s) / s;
    }

    canvas_clip(cv, 0, (int)floorf(bar_y0), cv->w, (int)ceilf(bar_y0 + bar_vis));
}

/* the three groups, laid out and drawn. With the clip closed it draws
 * nothing and only records where things would go. */
static void bar_measure_layout(Canvas *cv, Bar *b, Font *f, float y0,
                               float vis, float s, float bw)
{
    if (!cfg.cell_count && !layout_n[G_LEFT]) return;
    float gap = (float)cfg.cell_gap * s;
    float left_limit = (float)cfg.pad_x * s;
    float right = bw - (float)(cfg.pad_right >= 0 ? cfg.pad_right : cfg.pad_x) * s;

    float lw = group_width(cv, b, f, G_LEFT, vis, s);
    float after_left = left_limit + (lw > 0 ? lw + gap : 0.0f);
    float rx = draw_group(cv, b, f, G_RIGHT, y0, vis, s, 1.0f, after_left, right);
    float mx = draw_message(cv, b, f, y0, vis, s, 1.0f, after_left, rx - gap);
    float cx = draw_group(cv, b, f, G_CENTER, y0, vis, s, 1.0f, after_left,
                          fminf(rx, mx) - gap);
    draw_group(cv, b, f, G_LEFT, y0, vis, s, 1.0f, left_limit, cx - gap);
}

static void bar_paint(Bar *b, Canvas *cv, float visL, float s)
{
    bool top = strcmp(cfg.position, "bottom") != 0;
    float vis = visL * s;
    float tip = (float)b->tip_h * s;
    /* the bar stays flush with the screen edge; the tip takes the strip on
       the inward side of it */
    float y0 = top ? 0.0f : (float)cv->h - vis;
    (void)tip;
    float rad = cfg.radius * s;
    float bw = (float)cv->w;

    memset(cv->px, 0, (size_t)cv->w * (size_t)cv->h * 4);
    canvas_clip_all(cv);

    /* Flush with the screen edge: the two corners that touch it stay square.
     * A panel hanging off one end squares that corner too, so the edge runs
     * straight from the bar into the panel instead of pinching in and out
     * again around two facing curves. */
    float br_l = rad, br_r = rad;
    if (b->tip_h > 0 && b->tip_edge) {
        if (b->tip_edge < 0) br_l = 0.0f; else br_r = 0.0f;
    }
    if (top) fill_round(cv, 0, y0, bw, vis, 0, 0, br_r, br_l, cfg.bg);
    else     fill_round(cv, 0, y0, bw, vis, br_l, br_r, 0, 0, cfg.bg);


    Runs rs;
    markup_parse(status_line, &rs, cfg.text);

    float fade = clampf(b->vis * 1.6f - 0.25f, 0.0f, 1.0f);

    /* Which cell is under the pointer, and what it wants to say. It has to be
     * worked out here, before the hit areas are cleared for this frame —
     * asking afterwards found an empty list every time, which is why the
     * panel never appeared. */
    b->tip_cell = -1;
    const char *tiptxt = fade > 0.01f ? bar_tip_text(b) : NULL;
    int want_tip = tiptxt ? bar_tip_height(b, tiptxt) : 0;
    if (want_tip != b->tip_h) { b->tip_h = want_tip; bar_fit_height(b); }
    if (tiptxt && b->tip_showing != b->tip_cell) b->tip_at = now_ms();
    b->tip_showing = tiptxt ? b->tip_cell : -1;

    Font *f = font_get((int)lroundf(cfg.text_px * cfg.ui_scale * s));

    b->hits = 0;
    b->chits = 0;
    if (fade <= 0.01f) {
        /* Folded before the bar has ever been drawn open, the strip has no
         * positions to line up with. Run the full layout with the canvas
         * clipped to nothing: it draws no pixels and records where every cell
         * and workspace would sit. */
        /* Every folded frame lays the open bar out first, with the canvas
         * clipped to nothing: no pixels, just where every button and cell
         * would be right now. Doing it only once went stale — a workspace
         * opened while folded had no button to line up with, and started
         * folded the surface was not even its real width yet. The strip is
         * redrawn rarely, so the pass costs next to nothing. */
        {
            int sx0 = cv->cx0, sy0 = cv->cy0, sx1 = cv->cx1, sy1 = cv->cy1;
            canvas_clip(cv, 0, 0, 0, 0);
            bar_measure_layout(cv, b, f, y0, vis, s, bw);
            cv->cx0 = sx0; cv->cy0 = sy0; cv->cx1 = sx1; cv->cy1 = sy1;
            b->measured_full = true;
            b->hits = 0;
            b->chits = 0;
            bar_fit_width(b, cv, f, vis, s);
        }
        draw_signals(cv, b, y0, vis, s, &rs);
        return;
    }
    b->measured_full = true;

    canvas_clip(cv, 0, (int)floorf(y0), (int)bw, (int)ceilf(y0 + vis));

    bar_fit_width(b, cv, f, vis, s);
    bar_paint_tip(b, cv, f, s, top, y0, vis);

    float gap = (float)cfg.cell_gap * s;
    float left_limit = (float)cfg.pad_x * s;
    float right = bw - (float)(cfg.pad_right >= 0 ? cfg.pad_right : cfg.pad_x) * s;

    if (cfg.cell_count || layout_n[G_LEFT]) {
        float lw = group_width(cv, b, f, G_LEFT, vis, s);
        float after_left = left_limit + (lw > 0 ? lw + gap : 0.0f);
        float rx = draw_group(cv, b, f, G_RIGHT, y0, vis, s, fade, after_left, right);
        float mx = draw_message(cv, b, f, y0, vis, s, fade, after_left, rx - gap);
        float cx = draw_group(cv, b, f, G_CENTER, y0, vis, s, fade, after_left,
                              fminf(rx, mx) - gap);
        draw_group(cv, b, f, G_LEFT, y0, vis, s, fade, left_limit, cx - gap);
    }

    if (!cfg.cell_count && *status_line) {         /* status_command fallback */
        float total = 0;
        for (int i = 0; i < rs.n; ++i) total += text_width(f, rs.v[i].text);
        float sx = right - total;
        float base = baseline_for(f, y0, vis, s);
        for (int i = 0; i < rs.n; ++i) {
            float rw = text_width(f, rs.v[i].text);
            text_draw(cv, f, sx, base, col_scale_alpha(rs.v[i].fg, fade), rs.v[i].text);
            sx += rw;
        }
    }
    canvas_clip_all(cv);
}

static void bar_render(Bar *b)
{
    if (!b->configured || b->closed) return;

    /* A hard ceiling on how often the compositor is asked to do anything.
     * Whatever decides a frame is needed — an animation, a configure, a cell
     * whose width wobbles — it cannot turn into an unbounded stream of
     * commits, and sway cannot be made to allocate faster than it can free.
     * The frame is not lost, only deferred: dirty stays set. */
    /* Two floors on how often a frame goes out.
     *
     * The 8 ms one is a hard ceiling of ~120 fps for anything animating. The
     * other is for content: ten cells on their own timers wake the bar three
     * times a second, each with one number changed, and every one of those is
     * a full round trip through the compositor. Holding them for redraw_ms
     * merges whatever arrives in the same window into a single frame. A clock
     * a quarter of a second late is not a clock anyone notices. */
    uint32_t now = now_ms();
    if (b->last_commit && (int32_t)(now - b->last_commit) < 8) return;

    bool moving = bar_animating(b) || b->hovered || scroll_running || b->soon;
    if (!moving && cfg.redraw_ms > 0 && b->last_commit &&
        (int32_t)(now - b->last_commit) < cfg.redraw_ms) return;

    if (!bar_alloc(b)) return;

    int slot = -1;
    for (int i = 0; i < 2; ++i) if (!b->busy[i]) { slot = i; break; }
    if (slot < 0) return;                     /* both in flight: next frame */

    float s = (float)b->scale;
    float visL = bar_visible_logical(b);
    bool top = strcmp(cfg.position, "bottom") != 0;
    Canvas cv = { (uint32_t *)b->bufmem[slot], b->bw, b->bh, 0, 0, b->bw, b->bh };
    bar_paint(b, &cv, visL, s);

    /* Nothing to say? Then say nothing.
     *
     * Ten cells on two-to-ten second timers wake the bar a couple of times a
     * second, but most of those produce the same picture — the volume is
     * still 80%, the clock is still 12:41. Comparing the frame we just drew
     * against the one on screen costs a memcmp of the buffer and saves the
     * whole round trip: attach, damage, commit, and everything the
     * compositor does with it. */
    /* only the visible strip takes clicks — the rest of the surface is
     * transparent and must not swallow them */
    /* the bar, plus the panel while one is open: the pointer has to be able
     * to rest on the panel without the hover ending under it. Sent only when
     * it changes — the compositor allocates a region for every one of these —
     * but ahead of the skip below: a frame with nothing new to show is still a
     * frame whose region may have changed, and going without one is a bar the
     * pointer falls through. */
    int rv = (int)ceilf(visL) + (b->tip_h > 0 ? b->tip_h : 0);
    int ry = top ? 0 : b->h - rv;
    bool new_region = rv != b->reg_h || ry != b->reg_y || b->w != b->reg_w;
    if (new_region) {
        wl_count.region++;
        struct wl_region *reg = wl_compositor_create_region(compositor);
        wl_region_add(reg, 0, ry, b->w, rv);
        wl_surface_set_input_region(b->surf, reg);
        wl_region_destroy(reg);
        b->reg_h = rv; b->reg_y = ry; b->reg_w = b->w;
    }

    if (b->last_slot >= 0 && b->last_slot != slot &&
        memcmp(b->bufmem[slot], b->bufmem[b->last_slot],
               (size_t)b->stride * (size_t)b->bh) == 0) {
        /* Nothing new to show, but a region that was just set is only state
         * until something commits it. */
        if (new_region) wl_surface_commit(b->surf);
        b->dirty = false;
        b->soon = false;
        return;
    }

    /* hand the buffer over */
    b->last_slot = slot;
    b->busy[slot] = true;
    wl_surface_set_buffer_scale(b->surf, b->scale);
    wl_surface_attach(b->surf, b->buf[slot], 0, 0);
    wl_surface_damage_buffer(b->surf, 0, 0, b->bw, b->bh);

    if (cfg.exclusive)                       /* the panel must not reserve
                                                space: it is transient */
        ls_set_exclusive_zone(b->ls, (int)ceilf(visL) + cfg.margin);

    wl_count.commit++;
    b->last_commit = now_ms();
    wl_surface_commit(b->surf);
    b->dirty = false;
    b->soon = false;
}
/* ------------------------------------------------------------- animation */

static void bar_set_collapsed(Bar *b, bool c)
{
    b->collapsed = c;
    b->anim_from = b->vis;
    b->anim_to = c ? 0.0f : 1.0f;
    b->anim_start = now_ms();
    if (cfg.anim_ms <= 0) b->vis = b->anim_to;
    b->dirty = true;
}

static bool bar_animating(Bar *b)
{
    if (b->vis != b->anim_to) return true;
    if (b->tip_showing >= 0 && cfg.anim_ms > 0 &&
        (int32_t)(now_ms() - b->tip_at) < cfg.anim_ms) return true;   /* sliding */
    if (msg_active() && cfg.msg_flash) return true;                   /* pulsing */
    return false;
}

static void bar_anim_step(Bar *b, uint32_t t)
{
    if (!bar_animating(b)) return;
    if (cfg.anim_ms <= 0) { b->vis = b->anim_to; b->dirty = true; return; }
    float k = (float)(t - b->anim_start) / (float)cfg.anim_ms;
    if (k >= 1.0f) b->vis = b->anim_to;
    else b->vis = b->anim_from + (b->anim_to - b->anim_from) * (k * k * (3.0f - 2.0f * k));
    b->dirty = true;
}

/* Taking the grab is always re-sent, never skipped because we think we still
 * have it. The compositor can take it back without telling us — a leave that
 * never arrives because the surface moved or was remapped leaves kbd_grab
 * saying true while the keyboard is long gone, and every later enter then does
 * nothing, so keys go to the window underneath until the bar is restarted.
 * Dropping it is still only sent on a change; that one cannot go stale. */
static void bar_set_grab(Bar *b, bool on)
{
    if (!cfg.hover_keys || !b->ls) return;
    if (!on && !b->kbd_grab) return;
    b->kbd_grab = on;
    ls_set_keyboard(b->ls, on ? ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE
                              : ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE);
    wl_surface_commit(b->surf);
}

/* ---------------------------------------------------------- layer surface */

static void ls_configure(void *data, struct zwlr_layer_surface_v1 *s,
                         uint32_t serial, uint32_t w, uint32_t h)
{
    Bar *b = (Bar *)data;
    wl_count.ack++;
    ls_ack_configure(s, serial);

    bool changed = (w && (int)w != b->w) || (h && (int)h != b->h) || !b->configured;
    if (w) b->w = (int)w;
    if (h) b->h = (int)h;
    b->configured = true;
    if (!changed) return;            /* nothing to redraw, and no ping-pong */

    /* A different surface needs everything measured against it again, a fresh
     * input region, and the keyboard asked for again — none of that carries
     * over, and a stale input region is a bar the pointer goes straight
     * through. */
    b->measured_full = false;
    b->reg_w = -1;
    if (b->kbd_grab && cfg.hover_keys)
        ls_set_keyboard(b->ls, ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE);
    b->dirty = true;
    bar_render(b);
}

static void ls_closed(void *data, struct zwlr_layer_surface_v1 *s)
{
    (void)s;
    Bar *b = (Bar *)data;
    b->closed = true;
    b->configured = false;
}

static const struct zwlr_layer_surface_v1_listener ls_listener = { ls_configure, ls_closed };

static void bar_create(Output *o)
{
    if (o->bar || !layer_shell || !compositor || !shm) return;
    if (!output_wanted(o->name)) return;

    Bar *b = (Bar *)xmalloc(sizeof(Bar));
    memset(b, 0, sizeof(*b));
    b->out = o;
    b->scale = o->scale > 0 ? o->scale : 1;
    b->w = 0;
    b->h = bar_wanted_h(b);
    b->tip_pinned = -1;
    b->last_slot = -1;
    b->vis = cfg.start_collapsed ? 0.0f : 1.0f;
    b->anim_to = b->vis;
    b->collapsed = cfg.start_collapsed != 0;

    bool top = strcmp(cfg.position, "bottom") != 0;
    uint32_t layer = ZWLR_LAYER_SHELL_V1_LAYER_TOP;
    if (!strcmp(cfg.layer, "overlay")) layer = ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY;
    else if (!strcmp(cfg.layer, "bottom")) layer = ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM;
    else if (!strcmp(cfg.layer, "background")) layer = ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND;

    b->surf = wl_compositor_create_surface(compositor);
    b->ls = zwlr_layer_shell_v1_get_layer_surface(layer_shell, b->surf, o->wl, layer, APP_ID);
    zwlr_layer_surface_v1_add_listener(b->ls, &ls_listener, b);

    uint32_t anchor = top ? ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP
                          : ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
    if (cfg.min_width > 0) {
        /* a floating pill: anchored to one edge only, so the compositor
         * centres it — unless align_x pins it to a side. The width is not
         * fixed, bar_render grows it to whatever the content needs. */
        if (!strcmp(cfg.align_x, "left"))  anchor |= ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT;
        if (!strcmp(cfg.align_x, "right")) anchor |= ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
        b->w = cfg.min_width;
        ls_set_anchor(b->ls, anchor);
        ls_set_size(b->ls, (uint32_t)cfg.min_width, (uint32_t)b->h);
    } else {
        anchor |= ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
        ls_set_anchor(b->ls, anchor);
        ls_set_size(b->ls, 0, (uint32_t)b->h);
    }
    ls_set_margin(b->ls, top ? cfg.margin : 0, cfg.side_margin,
                  top ? 0 : cfg.margin, cfg.side_margin);
    ls_set_exclusive_zone(b->ls, cfg.exclusive ? b->h + cfg.margin : 0);
    ls_set_keyboard(b->ls, ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE);
    wl_surface_commit(b->surf);
    o->bar = b;
}

static void bar_destroy(Output *o)
{
    Bar *b = o->bar;
    if (!b) return;
    if (pointer_bar == b) pointer_bar = NULL;
    bar_free_buffers(b);
    if (b->ls) ls_destroy(b->ls);
    if (b->surf) wl_surface_destroy(b->surf);
    free(b);
    o->bar = NULL;
}

/* --------------------------------------------------------------- outputs */

static void out_geometry(void *d, struct wl_output *o, int32_t x, int32_t y,
                         int32_t pw, int32_t ph, int32_t sub, const char *make,
                         const char *model, int32_t tr)
{ (void)d;(void)o;(void)x;(void)y;(void)pw;(void)ph;(void)sub;(void)make;(void)model;(void)tr; }

static void out_mode(void *d, struct wl_output *wo, uint32_t f, int32_t w, int32_t h, int32_t r)
{
    (void)wo; (void)r;
    Output *o = (Output *)d;
    if (f & WL_OUTPUT_MODE_CURRENT) { o->mode_w = w; o->mode_h = h; }
}

static void out_scale(void *d, struct wl_output *wo, int32_t factor)
{
    (void)wo;
    Output *o = (Output *)d;
    o->scale = factor > 0 ? factor : 1;
    if (o->bar && o->bar->scale != o->scale) {
        o->bar->scale = o->scale;
        bar_free_buffers(o->bar);
        o->bar->dirty = true;
    }
}

static void out_name(void *d, struct wl_output *wo, const char *name)
{
    (void)wo;
    Output *o = (Output *)d;
    str_set(o->name, sizeof(o->name), name ? name : "");
}

static void out_description(void *d, struct wl_output *o, const char *desc)
{ (void)d;(void)o;(void)desc; }

static void out_done(void *d, struct wl_output *wo)
{
    (void)wo;
    Output *o = (Output *)d;
    if (!o->bar) bar_create(o);
    else o->bar->dirty = true;
}

static const struct wl_output_listener output_listener = {
    out_geometry, out_mode, out_done, out_scale, out_name, out_description
};

/* --------------------------------------------------------------- pointer */

/* What the pointer should look like where it is. Everything in the bar does
 * something when clicked, so it is a hand over a workspace, a cell or a
 * calendar arrow, and the ordinary arrow over the gaps. */
static struct wp_cursor_shape_manager_v1 *cursor_mgr;
static struct wp_cursor_shape_device_v1  *cursor_dev;
static uint32_t cursor_serial, cursor_now;

static void cursor_set(uint32_t shape)
{
    if (!cursor_dev || !cursor_serial || shape == cursor_now) return;
    wp_cursor_shape_device_v1_set_shape(cursor_dev, cursor_serial, shape);
    cursor_now = shape;
}

static bool bar_point_is_clickable(Bar *b)
{
    if (!b) return false;
    for (int i = 0; i < b->hits; ++i)                    /* a workspace */
        if (b->px >= b->hit[i].x0 && b->px < b->hit[i].x1) return true;

    if (b->tip_showing >= 0 && b->cal_x1 > b->cal_x0 &&  /* a calendar arrow */
        b->py >= b->cal_y0 && b->py < b->cal_y1 &&
        ((b->px >= b->cal_x0 && b->px < b->cal_x1) ||
         (b->px >= b->cal_x2 && b->px < b->cal_x3))) return true;

    for (int i = 0; i < b->chits; ++i) {                 /* a cell with a bind */
        if (b->px < b->chit[i].x0 || b->px >= b->chit[i].x1) continue;
        Cell *e = &cfg.cell[b->chit[i].cell];
        for (int n = 1; n < MAX_BINDS; ++n) if (*e->bind[n]) return true;
        return false;
    }
    return false;
}

static void cursor_update(Bar *b)
{
    cursor_set(bar_point_is_clickable(b) ? WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_POINTER
                                         : WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_DEFAULT);
}

static Bar *bar_of_surface(struct wl_surface *s)
{
    for (int i = 0; i < output_count; ++i)
        if (outputs[i].bar && outputs[i].bar->surf == s) return outputs[i].bar;
    return NULL;
}

static void ptr_enter(void *d, struct wl_pointer *p, uint32_t serial,
                      struct wl_surface *surf, wl_fixed_t sx, wl_fixed_t sy)
{
    (void)d; (void)p;
    Bar *b = bar_of_surface(surf);
    pointer_bar = b;
    if (!b) return;
    b->hovered = true;
    b->px = wl_fixed_to_double(sx);
    b->py = wl_fixed_to_double(sy);

    /* set_shape needs the serial of an enter, and the shape has to be set
     * again for every one of them or the compositor keeps the last cursor */
    cursor_serial = serial;
    cursor_now = 0;
    if (cursor_mgr && !cursor_dev && pointer)
        cursor_dev = wp_cursor_shape_manager_v1_get_pointer(cursor_mgr, pointer);
    cursor_update(b);

    bar_set_grab(b, true);
}

static void ptr_leave(void *d, struct wl_pointer *p, uint32_t serial, struct wl_surface *surf)
{
    (void)d; (void)p; (void)serial;
    Bar *b = bar_of_surface(surf);
    if (!b) return;
    if (pointer_bar && pointer_bar != b) {
        /* a leave for the bar we already left, arriving after the enter for
         * the one we are on: dropping the grab here would take it off the
         * wrong surface and lose the pointer with it */
        b->hovered = false;
        bar_set_grab(b, false);
        return;
    }
    b->hovered = false;
    b->tip_pinned = -1;
    b->dirty = true;
    if (b->hover_open) { b->hover_open = false; bar_set_collapsed(b, true); }
    bar_set_grab(b, false);
    if (pointer_bar == b) pointer_bar = NULL;
}

/* Folded, a cell is a few pixels wide and has nowhere to put a longer text.
 * With hover_slim set, resting on it opens the bar for as long as you stay,
 * and it folds itself back when you leave. */
static void hover_slim_check(Bar *b)
{
    int on = -1;
    if (b->hovered)
        for (int i = 0; i < b->chits; ++i)
            if (b->px >= b->chit[i].x0 && b->px < b->chit[i].x1 &&
                cfg.cell[b->chit[i].cell].hover_slim) { on = b->chit[i].cell; break; }

    if (on >= 0 && b->collapsed && !b->hover_open) {
        b->hover_open = true;
        bar_set_collapsed(b, false);
    } else if (on < 0 && b->hover_open) {
        b->hover_open = false;
        bar_set_collapsed(b, true);
    }
}

static void ptr_motion(void *d, struct wl_pointer *p, uint32_t t, wl_fixed_t sx, wl_fixed_t sy)
{
    (void)d; (void)p; (void)t;
    if (!pointer_bar) return;
    pointer_bar->px = wl_fixed_to_double(sx);
    pointer_bar->py = wl_fixed_to_double(sy);
    pointer_bar->dirty = true;
    hover_slim_check(pointer_bar);
    cursor_update(pointer_bar);
}

static void ws_switch(const char *name)
{
    char esc[256];
    size_t j = 0;
    for (const char *q = name; *q && j < sizeof(esc) - 2; ++q) {
        if (*q == '"' || *q == '\\') esc[j++] = '\\';
        esc[j++] = *q;
    }
    esc[j] = 0;
    sway_cmd("workspace --no-auto-back-and-forth \"%s\"", esc);
}

/* the calendar arrows, if that is what was clicked */
static bool cal_click(Bar *b, int button)
{
    if (button != 1 || b->tip_showing < 0 || b->cal_x1 <= b->cal_x0) return false;
    if (b->py < b->cal_y0 || b->py >= b->cal_y1) return false;

    Cell *e = &cfg.cell[b->tip_showing];
    if (!e->hover_cal) return false;

    if (b->px >= b->cal_x0 && b->px < b->cal_x1)      e->cal_off--;
    else if (b->px >= b->cal_x2 && b->px < b->cal_x3) e->cal_off++;
    else return false;

    if (e->cal_off < -600) e->cal_off = -600;      /* fifty years either way */
    if (e->cal_off >  600) e->cal_off =  600;
    hover_cal_build(e);
    b->dirty = true;
    return true;
}

static void bar_click(Bar *b, int button)
{
    if (cal_click(b, button)) return;

    /* opening and closing a click-panel, before anything else the click
     * might have meant */
    if (button == 1) {
        int on = -1;
        for (int i = 0; i < b->chits; ++i)
            if (b->px >= b->chit[i].x0 && b->px < b->chit[i].x1) { on = b->chit[i].cell; break; }

        if (on >= 0 && cfg.cell[on].hover_click) {
            Cell *e = &cfg.cell[on];
            if (b->tip_pinned == on) b->tip_pinned = -1;   /* clicked again */
            else {
                if (e->hover_cal)       { e->cal_off = 0; hover_cal_build(e); }
                else if (*e->hover_cmd) hover_cmd_run(e);
                b->tip_pinned = e->out_hover[0] ? on : -1;
            }
            b->dirty = true;
            return;
        }
        if (b->tip_pinned >= 0) { b->tip_pinned = -1; b->dirty = true; }
    }
    for (int i = 0; i < b->chits; ++i)
        if (b->px >= b->chit[i].x0 && b->px < b->chit[i].x1) {
            Cell *e = &cfg.cell[b->chit[i].cell];
            if (cell_is_msg(e)) { msg_text[0] = 0; msg_until = 0; damage_all(); return; }
            if (button >= 1 && button < MAX_BINDS && *e->bind[button]) {
                run_command(e->bind[button]);
                return;
            }
            break;
        }
    if (button == 1 && cfg.ws_click) {
        for (int i = 0; i < b->hits; ++i)
            if (b->px >= b->hit[i].x0 && b->px < b->hit[i].x1) {
                ws_switch(b->hit[i].name);
                return;
            }
    }
    if ((button == 4 || button == 5) && cfg.scroll_workspace) {
        sway_cmd("workspace %s_on_output", button == 4 ? "prev" : "next");
        return;
    }
    if (button >= 1 && button < MAX_BINDS && *cfg.bind[button])
        run_command(cfg.bind[button]);
}

static void ptr_button(void *d, struct wl_pointer *p, uint32_t serial, uint32_t t,
                       uint32_t button, uint32_t state)
{
    (void)d; (void)p; (void)serial; (void)t;
    if (state != WL_POINTER_BUTTON_STATE_PRESSED || !pointer_bar) return;
    int n = 0;
    switch (button) {
    case 272: n = 1; break;   /* BTN_LEFT   */
    case 274: n = 2; break;   /* BTN_MIDDLE */
    case 273: n = 3; break;   /* BTN_RIGHT  */
    case 275: n = 8; break;   /* BTN_SIDE   */
    case 276: n = 9; break;   /* BTN_EXTRA  */
    default: return;
    }
    bar_click(pointer_bar, n);
}

static void ptr_axis(void *d, struct wl_pointer *p, uint32_t t, uint32_t axis, wl_fixed_t value)
{
    (void)d; (void)p; (void)t;
    if (!pointer_bar) return;
    double v = wl_fixed_to_double(value);
    if (v == 0) return;
    int n;
    if (axis == WL_POINTER_AXIS_VERTICAL_SCROLL) n = v < 0 ? 4 : 5;
    else                                         n = v < 0 ? 6 : 7;
    bar_click(pointer_bar, n);
}

static void ptr_frame(void *d, struct wl_pointer *p) { (void)d; (void)p; }
static void ptr_axis_source(void *d, struct wl_pointer *p, uint32_t s) { (void)d;(void)p;(void)s; }
static void ptr_axis_stop(void *d, struct wl_pointer *p, uint32_t t, uint32_t a)
{ (void)d;(void)p;(void)t;(void)a; }
static void ptr_axis_discrete(void *d, struct wl_pointer *p, uint32_t a, int32_t v)
{ (void)d;(void)p;(void)a;(void)v; }

/* designated, so newer libwayland versions with extra axis events still
   compile against this without a warning — we bind wl_seat at version 5,
   where those events are never sent */
static const struct wl_pointer_listener pointer_listener = {
    .enter = ptr_enter, .leave = ptr_leave, .motion = ptr_motion,
    .button = ptr_button, .axis = ptr_axis, .frame = ptr_frame,
    .axis_source = ptr_axis_source, .axis_stop = ptr_axis_stop,
    .axis_discrete = ptr_axis_discrete
};

/* -------------------------------------------------------------- keyboard */
/* No libxkbcommon: the bar only ever looks for one key, so it compares the
 * raw evdev keycode. That makes the binding layout independent — the key in
 * the space bar's place, whatever your layout calls it. */

static struct { const char *name; int code; } keycodes[] = {
    { "space", 57 }, { "escape", 1 }, { "esc", 1 }, { "tab", 15 }, { "enter", 28 },
    { "backspace", 14 }, { "minus", 12 }, { "grave", 41 }, { "backslash", 43 },
    { "q", 16 }, { "w", 17 }, { "e", 18 }, { "r", 19 }, { "t", 20 }, { "y", 21 },
    { "u", 22 }, { "i", 23 }, { "o", 24 }, { "p", 25 }, { "a", 30 }, { "s", 31 },
    { "d", 32 }, { "f", 33 }, { "g", 34 }, { "h", 35 }, { "j", 36 }, { "k", 37 },
    { "l", 38 }, { "z", 44 }, { "x", 45 }, { "c", 46 }, { "v", 47 }, { "b", 48 },
    { "n", 49 }, { "m", 50 },
    { "1", 2 }, { "2", 3 }, { "3", 4 }, { "4", 5 }, { "5", 6 }, { "6", 7 },
    { "7", 8 }, { "8", 9 }, { "9", 10 }, { "0", 11 },
    { "f1", 59 }, { "f2", 60 }, { "f3", 61 }, { "f4", 62 }, { "f5", 63 },
    { "f6", 64 }, { "f7", 65 }, { "f8", 66 }, { "f9", 67 }, { "f10", 68 },
    { "f11", 87 }, { "f12", 88 }, { NULL, 0 }
};

static int hide_keycode(void)
{
    if (cfg.hide_keycode > 0) return cfg.hide_keycode;
    for (int i = 0; keycodes[i].name; ++i)
        if (!strcasecmp(keycodes[i].name, cfg.hide_key)) return keycodes[i].code;
    return 57;
}

static void kb_keymap(void *d, struct wl_keyboard *k, uint32_t fmt, int32_t fd, uint32_t sz)
{ (void)d; (void)k; (void)fmt; (void)sz; if (fd >= 0) close(fd); }
static void kb_enter(void *d, struct wl_keyboard *k, uint32_t s, struct wl_surface *su,
                     struct wl_array *keys)
{ (void)d;(void)k;(void)s;(void)su;(void)keys; }
static void kb_leave(void *d, struct wl_keyboard *k, uint32_t s, struct wl_surface *su)
{ (void)d;(void)k;(void)s;(void)su; }
static void kb_modifiers(void *d, struct wl_keyboard *k, uint32_t s, uint32_t dep,
                         uint32_t lat, uint32_t lock, uint32_t grp)
{ (void)d;(void)k;(void)s;(void)dep;(void)lat;(void)lock;(void)grp; }
static void kb_repeat(void *d, struct wl_keyboard *k, int32_t rate, int32_t delay)
{ (void)d;(void)k;(void)rate;(void)delay; }

static void kb_key(void *d, struct wl_keyboard *k, uint32_t serial, uint32_t t,
                   uint32_t key, uint32_t state)
{
    (void)d; (void)k; (void)serial; (void)t;
    if (state != WL_KEYBOARD_KEY_STATE_PRESSED) return;
    if ((int)key != hide_keycode()) return;
    Bar *b = pointer_bar;
    if (b) bar_set_collapsed(b, !b->collapsed);
}

static const struct wl_keyboard_listener keyboard_listener = {
    kb_keymap, kb_enter, kb_leave, kb_key, kb_modifiers, kb_repeat
};

static void seat_caps(void *d, struct wl_seat *s, uint32_t caps)
{
    (void)d;
    if ((caps & WL_SEAT_CAPABILITY_POINTER) && !pointer) {
        pointer = wl_seat_get_pointer(s);
        wl_pointer_add_listener(pointer, &pointer_listener, NULL);
    }
    if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !keyboard) {
        keyboard = wl_seat_get_keyboard(s);
        wl_keyboard_add_listener(keyboard, &keyboard_listener, NULL);
    }
}
static void seat_name(void *d, struct wl_seat *s, const char *n) { (void)d;(void)s;(void)n; }
static const struct wl_seat_listener seat_listener = { seat_caps, seat_name };

/* -------------------------------------------------------------- registry */

static uint32_t vmin(uint32_t a, uint32_t b) { return a < b ? a : b; }

static void reg_global(void *d, struct wl_registry *r, uint32_t id,
                       const char *iface, uint32_t ver)
{
    (void)d;
    if (!strcmp(iface, wl_compositor_interface.name)) {
        compositor = (struct wl_compositor *)wl_registry_bind(r, id, &wl_compositor_interface, vmin(ver, 4));
    } else if (!strcmp(iface, wl_shm_interface.name)) {
        shm = (struct wl_shm *)wl_registry_bind(r, id, &wl_shm_interface, 1);
    } else if (!strcmp(iface, wl_seat_interface.name)) {
        if (!seat) {
            seat = (struct wl_seat *)wl_registry_bind(r, id, &wl_seat_interface, vmin(ver, 5));
            wl_seat_add_listener(seat, &seat_listener, NULL);
        }
    } else if (!strcmp(iface, wp_cursor_shape_manager_v1_interface.name)) {
        cursor_mgr = (struct wp_cursor_shape_manager_v1 *)
            wl_registry_bind(r, id, &wp_cursor_shape_manager_v1_interface, 1);
    } else if (!strcmp(iface, zwlr_layer_shell_v1_interface.name)) {
        layer_shell = (struct zwlr_layer_shell_v1 *)
            wl_registry_bind(r, id, &zwlr_layer_shell_v1_interface, vmin(ver, 4));
    } else if (!strcmp(iface, wl_output_interface.name)) {
        Output *o = NULL;
        for (int i = 0; i < output_count; ++i)
            if (!outputs[i].alive) { o = &outputs[i]; break; }
        if (!o) {
            if (output_count >= MAX_OUTPUTS) return;
            o = &outputs[output_count++];
        }
        memset(o, 0, sizeof(*o));
        o->id = id;
        o->scale = 1;
        o->alive = true;
        o->wl = (struct wl_output *)wl_registry_bind(r, id, &wl_output_interface, vmin(ver, 4));
        wl_output_add_listener(o->wl, &output_listener, o);
    }
}

static void reg_remove(void *d, struct wl_registry *r, uint32_t id)
{
    (void)d; (void)r;
    for (int i = 0; i < output_count; ++i) {
        if (!outputs[i].alive || outputs[i].id != id) continue;
        bar_destroy(&outputs[i]);
        if (outputs[i].wl) wl_output_destroy(outputs[i].wl);
        outputs[i].alive = false;
        outputs[i].wl = NULL;
        outputs[i].name[0] = 0;
    }
}

static const struct wl_registry_listener registry_listener = { reg_global, reg_remove };

/* ------------------------------------------------------------------ help */

static void usage(void)
{
    fputs(
"SwBr " SWBR_VERSION " (build " SWBR_BUILD ") — a floating layer-shell bar for Sway\n"
"\n"
"usage: swbr [key=value ...]\n"
"       every config key also works as key=value, --key=value or -s key=value\n"
"\n"
"  --config PATH       read this file instead of the default\n"
"  --dump-config       print a config file with all defaults, then exit\n"
"  --replace           terminate any swbr already running, then start. Use\n"
"                      this rather than `pkill swbr` in the sway config: sway\n"
"                      forks each exec_always without waiting, so a kill on\n"
"                      one line races the bar started on the next\n"
"  no_tree=0           1 = never ask sway for the tree (no load dots, no\n"
"                      source=window cells). tree_min_s=5 is how often it\n"
"                      may be asked for at most, and only after a change\n"
"  --minimal           a bare bar: workspaces only, no cells, no tree, no\n"
"                      keyboard grab, no fifo. For finding out which part of\n"
"                      swbr a compositor is unhappy about\n"
"  --probe             print outputs, sizes, font metrics and cell values\n"
"  --alert-test [CELL]  fire a cell's alert here and now: the tone through\n"
"                      its own player, and what alert_cmd would run\n"
"  --slim              start folded (same as start_collapsed=1)\n"
"  --toggle            fold or unfold the running bar. Also --fold/--unfold\n"
"                      bindsym $mod+b exec swbr --toggle\n"
"  --msg TEXT          send a message to the running bar, then exit\n"
"                      'warn: ..', 'error: ..', 'info: ..', or 'clear'\n"
"  --help, --version\n"
"\n"
"config file: ${XDG_CONFIG_HOME:-~/.config}/swbr/config\n"
"\n"
"placement\n"
"  layer=top           background | bottom | top | overlay\n"
"  position=top        top | bottom\n"
"  height=0            bar height in logical px, 0 = derive from the font\n"
"  exclusive=0         1 = reserve the space (windows tile below the bar)\n"
"                      0 = float above them\n"
"  margin=0            gap to the screen edge\n"
"  side_margin=0       gap left and right\n"
"  min_width=800       0 = span the whole output. Otherwise the bar floats\n"
"                      and sizes itself to its content: never narrower than\n"
"                      this, never wider than the screen. align_x places it\n"
"  radius=14           corner radius; the two corners at the screen edge\n"
"                      stay square\n"
"  outputs=            comma separated output names, empty = every output\n"
"\n"
"workspaces\n"
"  ws_names=0          0 = number only, 1 = the full workspace name\n"
"  ws_pad=11 ws_gap=4 ws_min_w=0 ws_border=0\n""  ws_slots=10         show the numbers 1..n whether or not they exist\n""  ws_empty_alpha=35   how visible a free number is, percent\n"
"  ws_inset=0          gap above and below the buttons; >0 makes them pills\n"
"  ws_radius=0         0 = square, the button spans the whole bar height\n"
"                      -1 = a full pill when inset, else follows radius\n"
"  ws_click=1          left click switches workspace\n"
"  scroll_workspace=0  1 = the wheel switches workspaces\n"
"  mode_show=1         show the binding mode (resize, ..)\n"
"\n"
"text\n"
"  font=               .ttf path or a fontconfig family. Default: monospace\n"
"  font_alt=           fallback font for glyphs the first one lacks\n"
"  ui_scale=1.0 text_px=19 ws_px=19 pad_x=12 pad_right=20\n"
"  text_y=-2           nudge every baseline, logical px, negative = up\n"
"  markup=1            parse the pango subset (<span foreground=..>, &amp;)\n"
"\n"
"cells — the right hand side, one command per cell\n"
"  cell=NAME           declare a cell; the order of these lines is the order\n"
"                      the cells are drawn in, left to right\n"
"  NAME.cmd=CMD        the shell command; its output is the cell text\n"
"  NAME.interval=2     seconds between runs. 0 = run once, -1 = keep the\n"
"                      command running and take every line it prints\n"
"  NAME.fmt=%s C       %s is replaced by the output\n"
"  NAME.color=b3c0cd   text colour\n"
"  NAME.bg=            cell background\n"
"  NAME.warn=>70:cecb00   recolour when the first number in the output is at\n"
"  NAME.crit=<12:ff2222   or above (>) / at or below (<) the threshold\n"
"  NAME.min_w=280      keep this width even when the text is shorter\n"
"  NAME.max_w=0        clip beyond this width\n"
"  NAME.align=right    left | center | right, inside min_w\n"
"  NAME.pos=right      which group the cell joins: left | center | right\n"
"  NAME.scroll=0       1 = a text cell: too long is cut with '..' and scrolls\n"
"                      through while the pointer is on it. Pair with min_w\n"
"  scroll_speed=45 scroll_pause=900\n"
"\n"
"layout — one line that places everything\n"
"  bar={workspaces||cmus,volume,(clock,date)}\n"
"    ||   splits groups: 1 = left, 2 = left+right, 3 = left+center+right\n"
"    ,    separates items    (..)  glues items with no separator between\n"
"    names are cell names plus the built-ins 'workspaces' and 'mode'\n"
"  It sets position, order and separators, so keep it last in the config.\n"
"  NAME.sep=1          draw the separator after this cell\n"
"  NAME.hide_empty=1   no output = the cell and its separator disappear\n"
"  NAME.empty=TEXT     drawn instead of hiding, so the area stays clickable\n"
"  NAME.slim_on=TEXT   output containing this counts as the 'on' state for\n"
"                      slim=media, e.g. the icon your player prints\n"
"  NAME.gap=           space after this cell; 0 glues it to the next one and\n"
"                      equal background colours merge into a single box\n"
"  NAME.pad=0          padding inside the cell, left and right\n"
"  NAME.slim=auto      folded strip: auto | tick | bar | clock | presence\n"
"                      | media | off. presence = a block in the running\n"
"                      colour, there only while the program is. media = two\n"
"                      bars while playing, one dim one when not\n"
"  NAME.slim_color=    override this cell's colour on the strip. Without it\n"
"                      the strip reuses the colour the cell's own text has\n"
"  NAME.source=window  asks sway which workspaces have a window of\n"
"                      NAME.program= and prints them: mpv [3|5]. %n the\n"
"                      name, %w the workspaces, %c the count\n"
"  NAME.source=battery reads capacity and status out of /sys itself and\n"
"                      prints 83+ while it is filling, 83- while it is not,\n"
"                      83= when it is full. NAME.bat_path= points it at a\n"
"                      particular one, NAME.src_fmt= lays it out (%c capacity,\n"
"                      %i sign, %s the word). NAME.cmd= goes back to your own\n"
"                      command for any of this\n"
"  NAME.source=cmus    swbr runs cmus-remote itself: playing and paused are\n"
"                      read from it rather than guessed from the text, and\n"
"                      the command, interval, slim=media and the mouse binds\n"
"                      are filled in for you\n"
"  NAME.cmus_fmt=%i %n how it is laid out: %i icon, %n artist — title, %a,\n"
"                      %t, %s playing|paused. One cell can be just the icon\n"
"                      and another just the name\n"
"  NAME.hover=         what to show while the pointer is on this cell. Same\n"
"                      placeholders as src_fmt, or %s for a command cell's\n"
"                      output. The cell is measured with it, so it grows to\n"
"                      fit rather than truncating\n"
"  NAME.hover_click=0  1 = the panel opens on a click and stays until you\n"
"                      click again, instead of following the pointer\n"
"  NAME.alert=30,20,10,5   percentages that fire once on the way down and\n"
"                      rearm on the way up. alert_msg= the text, alert_cmd=\n"
"                      a command (%c is the percentage), alert_tone= Hz,\n"
"                      alert_ms=, alert_beeps=, alert_play= the player,\n"
"                      alert_gain=35 how loud the tone itself is, and\n"
"                      alert_vol_min=0 a mixer floor just for the alert\n"
"  NAME.hover_slim=0   1 = folded, resting on this cell opens the bar for as\n"
"                      long as you stay on it\n"
"  NAME.slim_color2=   second colour: the minutes of a clock cell, and its\n"
"                      hour bars before noon. clock lights every bar up to\n"
"                      the hour, so 02:00 and 02:55 both show two\n"
"  NAME.slim_min=0 NAME.slim_max=100   the range a gauge maps\n"
"  NAME.slim_w=0       width in the folded strip, 0 = the mode's default\n"
"  NAME.markup=1       parse pango markup in this cell's output\n"
"  NAME.button1=CMD    click this cell\n"
"  cell_gap=14 cell_inset=3 cell_radius=5\n"
"  separator=  separator_color=5a6b7aff\n"
"\n"
"status (used only when no cells are configured)\n"
"  status_command=     shell command; every line it prints becomes the status\n"
"  interval=1          seconds before restarting a command that exited\n"
"\n"
"messages\n"
"  a fifo other programs can shout into, or `swbr --msg TEXT`\n"
"  msg_fifo=           default $XDG_RUNTIME_DIR/swbr.fifo\n"
"  msg_target=         name of the cell a message takes over while it lasts\n"
"  msg_timeout=8       seconds, 0 = until cleared. Click it to dismiss\n"
"  redraw_ms=250       cell updates are held this long and merged into one\n"
"                      frame; refresh=1 says the same in seconds. Anything\n"
"                      moving — an animation, a hover, a scrolling cell —\n"
"                      ignores it\n"
"  msg_flash=1         pulse the folded strip in the message colour\n"
"  msg_panel=3         seconds the message also drops into the panel\n"
"  msg_info= msg_warn= msg_error=\n"
"\n"
"folding\n"
"  hide_key=space      hover the bar and press this to fold it into a strip\n"
"  hide_keycode=0      raw evdev code, overrides hide_key\n"
"  hover_keys=1        grab the keyboard while the pointer is over the bar\n"
"  collapsed_px=6      height of the folded strip, logical px\n"
"  anim_ms=120         fold animation, 0 = instant\n"
"  signals=1           the folded strip keeps saying something: a fixed slot\n"
"                      per workspace, twelve dots for a clock cell, a gauge\n"
"                      for anything with a percentage\n"
"  slim_ws_slots=10    slots in the packed strip (slim_align=0); lined up, the\n"
"                      strip is the open bar's own buttons\n""  slim_bar_segs=10    folded gauges are split into this many blocks\n""  slim_bar_gap=2      px between those blocks\n""  slim_bar_pad=3      px either side of a folded gauge\n""  slim_ws_w=0         folded slot width, 0 = its own button\n""  shrink_px=24 shrink_s=30   a floating bar ignores narrowing by less than\n""                      shrink_px, and waits shrink_s before a bigger one\n"
"  start_collapsed=0\n"
"  SIGUSR1 folds or unfolds every bar:  pkill -USR1 swbr\n"
"\n"
"mouse\n"
"  button1..button9=CMD   shell command per button (1 left, 2 middle,\n"
"                         3 right, 4/5 wheel, 6/7 tilt, 8/9 side)\n"
"\n"
"colors (#rrggbb or #rrggbbaa)\n"
"  bg text dim accent hl urgent outline\n"
"  ws_bg ws_fg ws_focused_bg ws_focused_fg ws_visible_bg ws_visible_fg\n"
"  ws_urgent_bg ws_urgent_fg mode_bg mode_fg\n"
"  running             the folded strip's 'this program is up' colour\n"
"  slim_warm           where a gauge's direction pips start before they ramp\n"
"                      into running (charging) or urgent (draining)\n", stdout);
}

static void print_color(const char *k, Col c)
{
    printf("%s=%02x%02x%02x%02x\n", k, c.r, c.g, c.b, c.a);
}

static void dump_config(void)
{
    Config c;
    config_defaults(&c);
    printf("# SwBr config  —  ~/.config/swbr/config\n"
           "# One key=value per line. '#' starts a comment.\n"
           "# Every key also works on the command line; command line wins.\n\n");
    printf("# --- placement ---\n");
    printf("layer=%s\nposition=%s\nheight=%d\nexclusive=%d\nmargin=%d\nside_margin=%d\n"
           "min_width=%d\nalign_x=%s\nradius=%g\noutputs=%s\n",
           c.layer, c.position, c.height, c.exclusive, c.margin, c.side_margin,
           c.min_width, c.align_x, (double)c.radius, c.outputs);
    printf("\n# --- workspaces ---\n");
    printf("ws_names=%d\nws_pad=%d\nws_gap=%d\nws_min_w=%d\nws_inset=%d\nws_radius=%g\n"
           "ws_border=%d\nws_slots=%d\nws_empty_alpha=%d\n"
           "ws_click=%d\nscroll_workspace=%d\nmode_show=%d\n",
           c.ws_names, c.ws_pad, c.ws_gap, c.ws_min_w, c.ws_inset, (double)c.ws_radius,
           c.ws_border, c.ws_slots, c.ws_empty_alpha,
           c.ws_click, c.scroll_workspace, c.mode_show);
    printf("\n# --- text ---\n");
    printf("# font=\n# font_alt=\nui_scale=%g\ntext_px=%g\nws_px=%g\ntext_y=%g\n"
           "pad_x=%d\npad_right=%d\nmarkup=%d\nscroll_speed=%d\nscroll_pause=%d\n",
           (double)c.ui_scale, (double)c.text_px, (double)c.ws_px, (double)c.text_y,
           c.pad_x, c.pad_right, c.markup, c.scroll_speed, c.scroll_pause);
    printf("\n# --- cells (the right hand side) ---\n");
    printf("cell_gap=%d\ncell_inset=%d\ncell_radius=%g\nseparator=%s\n",
           c.cell_gap, c.cell_inset, (double)c.cell_radius, c.separator);
    print_color("separator_color", c.separator_color);
    printf("# cell=clock\n# clock.cmd=date '+%%H:%%M'\n# clock.interval=10\n");
    printf("\n# --- messages ---\n");
    printf("redraw_ms=%d\n", c.redraw_ms);
    printf("# msg_fifo=\n# msg_target=cmus\nmsg_timeout=%d\nmsg_flash=%d\n",
           c.msg_timeout, c.msg_flash);
    print_color("msg_info", c.msg_info);
    print_color("msg_warn", c.msg_warn);
    print_color("msg_error", c.msg_error);
    printf("\n# --- layout: keep this last, it places everything ---\n");
    printf("# bar={workspaces||cmus,volume,(clock,date)}\n");
    printf("\n# --- status (only when no cells are configured) ---\n");
    printf("# status_command=~/bin/sway_bar_status.sh\ninterval=%d\n", c.interval);
    printf("\n# --- folding ---\n");
    printf("hide_key=%s\nhover_keys=%d\ncollapsed_px=%d\nanim_ms=%d\nsignals=%d\n"
           "slim_ws_slots=%d\nslim_bar_segs=%d\nslim_bar_gap=%d\nslim_bar_pad=%d\n"
           "slim_ws_w=%d\nshrink_px=%d\nshrink_s=%d\n"
           "start_collapsed=%d\n",
           c.hide_key, c.hover_keys, c.collapsed_px, c.anim_ms, c.signals,
           c.slim_ws_slots, c.slim_bar_segs, c.slim_bar_gap, c.slim_bar_pad,
           c.slim_ws_w, c.shrink_px, c.shrink_s,
           c.start_collapsed);
    printf("\n# --- mouse ---\n# button2=cmus_control toggle\n");
    printf("\n# --- colors ---\n");
    print_color("bg", c.bg);
    print_color("text", c.text);
    print_color("dim", c.dim);
    print_color("accent", c.accent);
    print_color("hl", c.hl);
    print_color("urgent", c.urgent);
    print_color("running", c.running);
    print_color("slim_warm", c.slim_warm);
    print_color("outline", c.outline);
    print_color("ws_border_col", c.ws_border_col);
    print_color("ws_bg", c.ws_bg);
    print_color("ws_fg", c.ws_fg);
    print_color("ws_focused_bg", c.ws_focused_bg);
    print_color("ws_focused_fg", c.ws_focused_fg);
    print_color("ws_visible_bg", c.ws_visible_bg);
    print_color("ws_visible_fg", c.ws_visible_fg);
    print_color("ws_urgent_bg", c.ws_urgent_bg);
    print_color("ws_urgent_fg", c.ws_urgent_fg);
    print_color("mode_bg", c.mode_bg);
    print_color("mode_fg", c.mode_fg);
}

/* ------------------------------------------------------------------ main */

static int  probe = 0;
static int  alert_test_arg = 0;   /* argv index of --alert-test */
static int  do_replace = 0;
static int  minimal = 0;
static int  cfg_start_collapsed_arg = 0;

static void probe_report(void)
{
    printf("SwBr %s (build %s)\n", SWBR_VERSION, SWBR_BUILD);
    printf("font          %s\n", *font_path_used ? font_path_used : "(none found)");
    printf("font_alt      %s\n", *font_alt_used ? font_alt_used : "(none)");
    printf("bar height    %d logical px  (height=%d text_px=%g ui_scale=%g)\n",
           bar_height_logical(), cfg.height, (double)cfg.text_px, (double)cfg.ui_scale);
    printf("min_width     %d  (0 = full output width)\n", cfg.min_width);
    printf("outputs=      '%s'%s\n", cfg.outputs,
           *cfg.outputs ? "  (only these get a bar)" : "  (every output)");
    printf("position=%s layer=%s exclusive=%d cells=%d\n",
           cfg.position, cfg.layer, cfg.exclusive, cfg.cell_count);
    for (int i = 0; i < output_count; ++i) {
        Output *o = &outputs[i];
        if (!o->alive) continue;
        printf("output %-10s scale %d  wanted %d  bar %s\n",
               *o->name ? o->name : "(unnamed)", o->scale,
               (int)output_wanted(o->name), o->bar ? "yes" : "NO");
    }
    for (int i = 0; i < output_count; ++i) {
        Output *o = &outputs[i];
        if (!o->alive || !o->bar) continue;
        Bar *b = o->bar;
        Font *f = font_get((int)lroundf(cfg.text_px * cfg.ui_scale * b->scale));
        printf("bar %-10s surface %dx%d logical, %dx%d px, scale %d\n",
               o->name, b->w, b->h, b->bw, b->bh, b->scale);
        if (cfg.min_width > 0 && b->bw > 0) {
            Canvas probe_cv = { NULL, b->bw, b->bh, 0, 0, b->bw, b->bh };
            printf("            content wants %d logical px (min_width %d)\n",
                   bar_natural_width(b, &probe_cv, f,
                                     (float)bar_height_logical() * b->scale,
                                     (float)b->scale), cfg.min_width);
        }
        printf("            font px %d ascent %.1f lineh %.1f baseline %.1f of %d\n",
               f->px, (double)f->ascent, (double)f->lineh,
               (double)baseline_for(f, 0, (float)b->bh, (float)b->scale), b->bh);
    }
    if (cfg.ws_cpu) {
        printf("cpu per workspace, sampled every %ds (idle under %g, scale %g..%g cores)\n",
               cfg.ws_cpu_interval, (double)cfg.ws_cpu_idle,
               (double)cfg.ws_cpu_min, (double)cfg.ws_cpu_full);
        printf("            %d window(s) in sway's tree to attribute work to\n",
               cpu_nwin);
        for (int i = 0; i < cpu_nwin && i < 8; ++i)
            printf("            pid %-7d -> %s\n", cpu_win[i].pid,
                   cpu_win[i].ws >= 0 && cpu_win[i].ws < ws_count
                       ? ws_list[cpu_win[i].ws].name : "(no workspace)");

        printf("            busiest processes in that sample:\n");
        for (int i = 0; i < cpu_top_n; ++i) {
            char path[64], comm[64] = "?";
            snprintf(path, sizeof(path), "/proc/%d/comm", cpu_top[i].pid);
            FILE *cf = fopen(path, "r");
            if (cf) {
                if (fgets(comm, sizeof(comm), cf)) {
                    char *nl = strchr(comm, '\n');
                    if (nl) *nl = 0;
                }
                fclose(cf);
            }
            printf("            %-16s pid %-7d -> %s\n", comm, cpu_top[i].pid,
                   cpu_top[i].ws >= 0 && cpu_top[i].ws < ws_count
                       ? ws_list[cpu_top[i].ws].name : "no workspace");

            /* Where the trail leads, and where it stops. If a build shows no
             * workspace, this says which process broke the chain — a
             * multiplexer, a container or a service does not descend from any
             * window, so nothing can attribute it. */
            printf("                             ");
            int pid = cpu_top[i].pid;
            for (int hop = 0; hop < 8 && pid > 1; ++hop) {
                char c2[64] = "?";
                snprintf(path, sizeof(path), "/proc/%d/comm", pid);
                FILE *g = fopen(path, "r");
                if (g) {
                    if (fgets(c2, sizeof(c2), g)) {
                        char *nl = strchr(c2, '\n');
                        if (nl) *nl = 0;
                    }
                    fclose(g);
                }
                bool is_win = false;
                for (int w = 0; w < cpu_nwin; ++w)
                    if (cpu_win[w].pid == pid) { is_win = true; break; }
                printf("%s%d:%s", hop ? " < " : "", pid, c2);
                if (is_win) { printf(" [window]"); break; }

                int ppid; unsigned long long o, c3;
                if (!proc_stat_of(pid, &ppid, &o, &c3)) { printf(" (gone)"); break; }
                pid = ppid;
            }
            printf("\n");
        }
        if (!cpu_ws_n) printf("            no sample yet\n");
        for (int i = 0; i < cpu_ws_n; ++i)
            printf("            %-12s %5.2f cores\n", cpu_ws_name[i], cpu_ws_cores[i]);
    }
    static const char *SLIM_NAME[] = { "auto", "tick", "bar", "clock",
                                       "presence", "media", "off" };
    for (int i = 0; i < cfg.cell_count; ++i) {
        Cell *e = &cfg.cell[i];
        printf("cell %-10s iv=%-3d min_w=%-4d sep=%d  '%s'\n",
               e->name, e->interval, e->min_w, e->sep, e->out);

        int mode = slim_mode(e);
        printf("            slim=%s", SLIM_NAME[mode]);
        if (e->slim == SLIM_AUTO && mode != SLIM_AUTO) printf(" (auto)");
        if (mode == SLIM_MEDIA) {
            int st = media_state(e);
            printf("  playing=%s", st > 0 ? "yes" : st == 0 ? "no" : "(no output yet)");
            if (e->source == SRC_CMUS)
                printf("  from cmus-remote (%s)",
                       e->state == PS_PLAYING ? "playing" :
                       e->state == PS_PAUSED  ? "paused"  :
                       e->state == PS_STOPPED ? "stopped" : "not running");
            else if (*e->slim_on)
                printf("  slim_on='%s'%s", e->slim_on,
                       strstr(e->out, e->slim_on) ? " found" : " NOT in the output");
            else printf("  slim_on unset, guessing from the text");
        } else if (mode == SLIM_BAR) {
            float v = 0;
            printf("  value=%s  range %g..%g", cell_number(e->out, &v) ? "yes" : "no",
                   (double)e->slim_min, (double)e->slim_max);
        }
        printf("\n");
    }
    printf("folded strip (%d px), right side left to right:\n", cfg.collapsed_px);
    for (int i = 0; i < layout_n[G_RIGHT]; ++i) {
        Item *it = &layout_item[G_RIGHT][i];
        if (it->kind != IT_CELL) continue;
        Cell *e = &cfg.cell[it->cell];
        if (!cell_visible(e) || !*e->out) { printf("  %-10s hidden\n", e->name); continue; }
        int m = slim_mode(e);
        Col c = cell_color(e);
        float v = 0;
        bool have = cell_number(e->out, &v);
        const char *mn = m == SLIM_BAR ? "gauge" : m == SLIM_CLOCK ? "clock"
                       : m == SLIM_OFF ? "off"
                       : m == SLIM_PRESENCE ? "up"
                       : m == SLIM_MEDIA ? "media" : "tick";
        printf("  %-10s %-5s %3.0fpx %02x%02x%02x", e->name, mn,
               (double)slim_width_of(e, m, 1.0f), c.r, c.g, c.b);
        if (m == SLIM_MEDIA) {
            bool on = *e->slim_on ? strstr(e->out, e->slim_on) != NULL
                                  : (strstr(e->out, "\xe2\x9d\x9a") != NULL ||
                                     strcasestr(e->out, "playing") != NULL);
            printf("  %s (slim_on='%s')", on ? "PLAYING: two bars" : "not playing: one block",
                   *e->slim_on ? e->slim_on : "(guessing from the icon)");
        }
        if (m == SLIM_BAR && have)
            printf("  %.1f of %g..%g = %.0f%% full",
                   (double)v, (double)e->slim_min, (double)e->slim_max,
                   (double)(clampf((v - e->slim_min) / (e->slim_max - e->slim_min),
                                   0.0f, 1.0f) * 100.0f));
        printf("  '%s'\n", e->out);
    }
}

/* one redraw when a timed message runs out */
static bool msg_expiry_due(void)
{
    static bool was = false;
    bool now_on = msg_active();
    bool changed = was != now_on;
    was = now_on;
    return changed;
}

static volatile sig_atomic_t sig_toggle = 0, sig_quit = 0;

static void on_signal(int s)
{
    if (s == SIGUSR1) sig_toggle = 1;
    else sig_quit = 1;
}

/* `swbr --alert-test [cell]`: everything a level does except the command,
 * printed and played here and now, so you find out whether the player works
 * before the battery is flat. The command is only shown — a test that powers
 * the machine off is not a test. */
static int alert_test(const char *name)
{
    Cell *e = NULL;
    for (int i = 0; i < cfg.cell_count; ++i) {
        if (name && *name) { if (!strcmp(cfg.cell[i].name, name)) { e = &cfg.cell[i]; break; } }
        else if (cfg.cell[i].alert_n) { e = &cfg.cell[i]; break; }
    }
    if (!e) { fprintf(stderr, "swbr: no cell '%s' with alert= set\n", name ? name : ""); return 1; }
    if (!e->alert_n) { fprintf(stderr, "swbr: cell '%s' has no alert= levels\n", e->name); return 1; }
    signal(SIGPIPE, SIG_IGN);     /* a player that dies must not kill the test */

    printf("cell      %s\n", e->name);
    printf("levels    ");
    for (int i = 0; i < e->alert_n; ++i) printf("%d%s", e->alert_lv[i], i + 1 < e->alert_n ? "," : "\n");
    printf("message   %s\n", *e->alert_msg ? e->alert_msg : "(none)");
    printf("player    %s\n", *e->alert_play ? e->alert_play : "(none)");
    printf("tone      %d Hz, %d ms, %d beeps%s, gain %d%%\n", e->alert_tone,
           e->alert_ms, e->alert_beeps, e->alert_escalate ? ", escalating" : "",
           e->alert_gain);
    if (e->alert_vol_min > 0)
        printf("volume    lifted to at least %d%% for the tone, then put back\n",
               e->alert_vol_min);
    else
        puts("volume    the mixer is left alone (alert_vol_min=0)");

    if (*e->alert_cmd) {
        printf("\nalert_cmd runs at every level, and only at a level:\n");
        for (int i = 0; i < e->alert_n; ++i) {
            char buf[320], cs[16];
            snprintf(cs, sizeof(cs), "%d", e->alert_lv[i]);
            const char *vals[] = { cs };
            expand_fmt(buf, sizeof(buf), e->alert_cmd, "c", vals);
            printf("  %3d%%  sh -c \"%s\"\n", e->alert_lv[i], buf);
        }
        printf("  (not run by this test)\n");
    }

    if (e->alert_tone <= 0 || !*e->alert_play) { puts("\nno tone configured"); return 0; }

    /* Straight to the player, in this process, so its own errors land on the
     * terminal and the exit status is the answer. */
    char player[1024];
    alert_player_cmd(e, player, sizeof(player));
    if (e->alert_vol_min > 0) printf("\nplayer    %s\n", player);

    printf("\nplaying... ");
    fflush(stdout);
    FILE *out = popen(player, "w");
    if (!out) { printf("cannot run it: %s\n", strerror(errno)); return 1; }
    const int rate = 44100;
    int n = rate * (e->alert_ms > 0 ? e->alert_ms : 1050) / 1000;
    int edge = rate * 15 / 1000;
    double gain = clampf((float)e->alert_gain / 100.0f, 0.02f, 1.0f);
    for (int b = 0; b < (e->alert_beeps > 0 ? e->alert_beeps : 1); ++b) {
        for (int i = 0; i < n; ++i) {
            double env = 1.0;
            if (i < edge) env = 0.5 - 0.5 * cos(M_PI * i / edge);
            else if (i > n - edge) env = 0.5 - 0.5 * cos(M_PI * (n - i) / edge);
            double v = sin(2.0 * M_PI * e->alert_tone * i / rate) * env * gain;
            int16_t sm = (int16_t)(v * 32767.0);
            if (fwrite(&sm, 2, 1, out) != 1) break;
            fwrite(&sm, 2, 1, out);
        }
        if (ferror(out)) break;
    }
    int st = pclose(out);
    if (st == 0) { puts("done."); return 0; }
    printf("the player failed (exit %d). Heard nothing? That is why.\n",
           WIFEXITED(st) ? WEXITSTATUS(st) : st);
    return 1;
}

int main(int argc, char **argv)
{
    char cfgpath[PATH_MAX];
    const char *xdg = getenv("XDG_CONFIG_HOME"), *home = getenv("HOME");
    if (xdg && *xdg) snprintf(cfgpath, sizeof(cfgpath), "%s/swbr/config", xdg);
    else snprintf(cfgpath, sizeof(cfgpath), "%s/.config/swbr/config", home ? home : ".");

    for (int i = 1; i < argc; ++i) {
        if (!strcmp(argv[i], "--config") && i + 1 < argc)
            expand_tilde(argv[++i], cfgpath, sizeof(cfgpath));
        else if (!strcmp(argv[i], "--help") || !strcmp(argv[i], "-h")) { usage(); return 0; }
        else if (!strcmp(argv[i], "--version") || !strcmp(argv[i], "-v")) {
            printf("SwBr %s (build %s)\n", SWBR_VERSION, SWBR_BUILD); return 0;
        } else if (!strcmp(argv[i], "--dump-config")) { dump_config(); return 0; }
        else if (!strcmp(argv[i], "--probe")) probe = 1;
        else if (!strcmp(argv[i], "--alert-test")) alert_test_arg = i;
        else if (!strcmp(argv[i], "--replace")) do_replace = 1;
        else if (!strcmp(argv[i], "--minimal")) minimal = 1;
        else if (!strcmp(argv[i], "--slim") || !strcmp(argv[i], "--collapsed"))
            cfg_start_collapsed_arg = 1;
    }

    wl_trace = getenv("SWBR_TRACE") != NULL;
    if (do_replace) replace_running();   /* clear the way before asking for a surface */

    config_defaults(&cfg);
    sw_shared_apply("swbr", config_set_shared, &cfg);   /* shared first */
    config_load(&cfg, cfgpath);                         /* our own wins  */

    for (int i = 1; i < argc; ++i) {               /* talk to a running bar */
        if (!strcmp(argv[i], "--msg") || !strcmp(argv[i], "-m")) {
            if (i + 1 >= argc) die("--msg needs a text ('warn: ..', 'clear')");
            return msg_send(argv[i + 1]);
        }
        if (!strcmp(argv[i], "--toggle")) return msg_send(":toggle");
        if (!strcmp(argv[i], "--fold")) return msg_send(":fold");
        if (!strcmp(argv[i], "--unfold")) return msg_send(":unfold");
    }

    for (int i = 1; i < argc; ++i) {                 /* command line wins */
        const char *a = argv[i];
        if (!strcmp(a, "--config")) { i++; continue; }
        if (!strcmp(a, "--alert-test")) { if (i + 1 < argc && argv[i+1][0] != '-') i++; continue; }
        if (!strcmp(a, "--probe") || !strcmp(a, "--slim") ||
            !strcmp(a, "--replace") || !strcmp(a, "--minimal") ||
            !strcmp(a, "--collapsed")) continue;
        if (!strcmp(a, "-s") && i + 1 < argc) a = argv[++i];
        else if (!strncmp(a, "--", 2)) a += 2;
        char buf[4096];
        str_set(buf, sizeof(buf), a);
        char *eq = strchr(buf, '=');
        if (!eq) {
            /* A mistyped flag used to be swallowed in silence, so the test
             * you thought you were running was the one you were not. */
            if (!strncmp(argv[i], "-", 1))
                fprintf(stderr, "swbr: unknown option '%s' (see --help)\n", argv[i]);
            continue;
        }
        *eq = 0;
        config_set(&cfg, trim(buf), trim(eq + 1));
    }

    if (alert_test_arg) {
        const char *who = alert_test_arg + 1 < argc && argv[alert_test_arg + 1][0] != '-'
                        ? argv[alert_test_arg + 1] : NULL;
        return alert_test(who);
    }

    signal(SIGUSR1, on_signal);
    signal(SIGINT, on_signal);
    signal(SIGTERM, on_signal);
    signal(SIGPIPE, SIG_IGN);
    signal(SIGCHLD, SIG_IGN);

    sway_fd = sway_connect();
    if (sway_fd < 0) die("cannot reach sway (is SWAYSOCK set?)");
    sway_subscribe_events();
    ws_reload(cfg.ws_names != 0);

    if (cfg_start_collapsed_arg) cfg.start_collapsed = 1;
    layout_parse(cfg.layout);
    fonts_init();

    dpy = wl_display_connect(NULL);
    if (!dpy) die("cannot connect to the wayland display");
    registry = wl_display_get_registry(dpy);
    wl_registry_add_listener(registry, &registry_listener, NULL);
    wl_display_roundtrip(dpy);                       /* globals */
    wl_display_roundtrip(dpy);                       /* output names, seats */

    if (!compositor || !shm) die("compositor is missing wl_compositor/wl_shm");
    if (!layer_shell) die("compositor does not support wlr-layer-shell");

    no_tree_flag = cfg.no_tree;      /* the tree reader reads this, not cfg */
    ws_sort_flag = cfg.ws_sort;
    tree_min_ms  = cfg.tree_min_s > 0 ? cfg.tree_min_s * 1000 : 5000;

    if (minimal) {                   /* a bare bar, for bisecting */
        cfg.cell_count = 0;
        cfg.ws_cpu = 0;
        cfg.signals = 0;
        cfg.hover_keys = 0;
        cfg.msg_flash = 0;
        cfg.msg_panel = 0;
        cfg.status_command[0] = 0;
        no_tree_flag = 1;
        fprintf(stderr, "swbr: minimal — workspaces only, no cells, no tree,\n"
                        "swbr:           no keyboard grab, no message fifo\n");
    }

    for (int i = 0; i < output_count; ++i)
        if (outputs[i].alive && !outputs[i].bar) bar_create(&outputs[i]);

    if (*cfg.status_command && !cfg.cell_count) status_spawn();
    cells_tick();
    if (!minimal) msg_open();

    if (probe) {
        if (cfg.ws_cpu) cpu_sample();           /* the first of the two */
        for (int i = 0; i < 60; ++i) {          /* give the cells a moment */
            cells_read();
            usleep(20000);
        }
        if (cfg.ws_cpu) cpu_sample();           /* and the one that measures */
        wl_display_roundtrip(dpy);
        probe_report();
        cells_stop();
        return 0;
    }

    int wlfd = wl_display_get_fd(dpy);
    while (running && !sig_quit) {
        bool redraw = false;

        if (sig_toggle) {
            sig_toggle = 0;
            bool any_open = false;
            for (int i = 0; i < output_count; ++i)
                if (outputs[i].bar && !outputs[i].bar->collapsed) any_open = true;
            for (int i = 0; i < output_count; ++i)
                if (outputs[i].bar) bar_set_collapsed(outputs[i].bar, any_open);
            redraw = true;
        }

        bool redraw_now = false;
        if (sway_events_pending()) {          /* something moved: the cached
                                                 tree is stale */
            sway_tree_forget();
            if (ws_stale) ws_reload(cfg.ws_names != 0);   /* else: from the event */
            ws_stale = false;
            redraw_now = true;
        }
        if (status_read()) redraw = true;
        cells_tick();
        if (cells_read()) redraw = true;
        if (cells_dirty) { cells_dirty = false; redraw = true; }
        if (msg_read()) redraw = true;
        if (ctrl_req) {
            for (int i = 0; i < output_count; ++i) {
                Bar *b = outputs[i].bar;
                if (!b) continue;
                bar_set_collapsed(b, ctrl_req == 1 ? !b->collapsed : ctrl_req == 2);
            }
            ctrl_req = 0;
            redraw = true;
        }
        if (msg_expiry_due()) redraw = true;

        wl_trace_tick();

    if (cfg.ws_cpu && cfg.ws_cpu_interval > 0) {
            static uint32_t cpu_next;
            if (!cpu_next || (int32_t)(now_ms() - cpu_next) >= 0) {
                cpu_sample();
                cpu_next = now_ms() + (uint32_t)cfg.ws_cpu_interval * 1000u;
                redraw = true;
            }
        }

        if (status_fd < 0 && *cfg.status_command && status_next_spawn &&
            (int32_t)(now_ms() - status_next_spawn) >= 0) {
            status_next_spawn = 0;
            status_spawn();
        }

        uint32_t t = now_ms();
        bool animating = false;
        for (int i = 0; i < output_count; ++i) {
            Bar *b = outputs[i].bar;
            if (!b) continue;
            bar_anim_step(b, t);
            if (bar_animating(b)) animating = true;
        }
        if (redraw_now) damage_all_now();
        else if (redraw) damage_all();

        scroll_running = false;
        for (int i = 0; i < output_count; ++i) {
            Bar *b = outputs[i].bar;
            if (b && b->dirty) bar_render(b);
        }
        if (scroll_running) damage_all();

        while (wl_display_prepare_read(dpy) != 0) wl_display_dispatch_pending(dpy);
        wl_display_flush(dpy);

        struct pollfd pfd[4 + MAX_CELLS];
        int n = 0;
        pfd[n].fd = wlfd;        pfd[n].events = POLLIN; n++;
        pfd[n].fd = sway_evt_fd; pfd[n].events = POLLIN; n++;
        if (status_fd >= 0) { pfd[n].fd = status_fd; pfd[n].events = POLLIN; n++; }
        if (msg_fd >= 0) { pfd[n].fd = msg_fd; pfd[n].events = POLLIN; n++; }
        for (int i = 0; i < cfg.cell_count; ++i)
            if (cfg.cell[i].fd >= 0) { pfd[n].fd = cfg.cell[i].fd; pfd[n].events = POLLIN; n++; }

        bool any_dirty = false;
        for (int i = 0; i < output_count; ++i)
            if (outputs[i].bar && outputs[i].bar->dirty) any_dirty = true;

        int timeout = -1;
        /* A frame held back by redraw_ms has to be woken to go out. Waiting on
         * the 100 ms cell tick put it a further tenth of a second behind
         * whatever it was already late for. */
        if (animating || scroll_running || any_dirty) timeout = 16;
        else if (cfg.cell_count || msg_until || (cfg.ws_cpu && cfg.ws_cpu_interval > 0))
            timeout = 100;
        else if (status_fd < 0 && *cfg.status_command) timeout = 100;

        int pr = poll(pfd, (nfds_t)n, timeout);
        if (pr < 0 && errno != EINTR) { wl_display_cancel_read(dpy); break; }

        if (pfd[0].revents & POLLIN) {
            if (wl_display_read_events(dpy) < 0) break;
        } else {
            wl_display_cancel_read(dpy);
        }
        if (wl_display_dispatch_pending(dpy) < 0) break;
        if ((pfd[0].revents & (POLLERR | POLLHUP)) != 0) break;
    }

    status_stop();
    cells_stop();
    if (msg_fd >= 0) { close(msg_fd); unlink(msg_path); }
    for (int i = 0; i < output_count; ++i) bar_destroy(&outputs[i]);
    if (dpy) { wl_display_flush(dpy); wl_display_disconnect(dpy); }
    if (sway_fd >= 0) close(sway_fd);
    if (sway_evt_fd >= 0) close(sway_evt_fd);
    return 0;
}