fix(policy): 新增窗口后通知原焦点窗口状态变更

新增 window_get_showing_title，按 title → instance_name →
class_name → app_id 优先级取显示标题，窗口快照改用该函数，
避免标题缺失时显示为空。

.clang-format

@@ -6,12 +6,6 @@ IndentWidth: 2
 ConstructorInitializerIndentWidth: 2
 ContinuationIndentWidth: 2
 
-AlignConsecutiveAssignments:
-  Enabled: true
-  AcrossEmptyLines: false
-  AcrossComments: false
-  AlignCompound: true
-  PadOperators: true
 AlignConsecutiveBitFields:
   Enabled: true
 

.clangd

@@ -2,3 +2,4 @@
 
 Completion:
   ArgumentLists: None
+  HeaderInsertion: Never

CMakeLists.txt

@@ -29,12 +29,14 @@ add_executable(${APP_NAME}
     ${SOURCE_DIR}/backend/x11/common.c
     ${SOURCE_DIR}/backend/x11/cursor.c
     ${SOURCE_DIR}/backend/x11/event.c
+    ${SOURCE_DIR}/backend/x11/tray.c
     ${SOURCE_DIR}/backend/x11/window.c
 
     ${SOURCE_DIR}/bar/bar.c
     ${SOURCE_DIR}/bar/binding.c
     ${SOURCE_DIR}/bar/cell.c
     ${SOURCE_DIR}/bar/text.c
+    ${SOURCE_DIR}/bar/tray.c
     ${SOURCE_DIR}/bar/windows.c
     ${SOURCE_DIR}/bar/workspaces.c
 
@@ -42,15 +44,18 @@ add_executable(${APP_NAME}
     ${SOURCE_DIR}/base/log.c
     ${SOURCE_DIR}/base/process.c
     ${SOURCE_DIR}/base/time.c
-    ${SOURCE_DIR}/base/window_list.c
 
     ${SOURCE_DIR}/config/defaults.c
     ${SOURCE_DIR}/config/loader.c
     ${SOURCE_DIR}/config/runtime_config.c
 
+    ${SOURCE_DIR}/common/event.c
+    ${SOURCE_DIR}/common/listeners.c
+    ${SOURCE_DIR}/common/window.c
+    ${SOURCE_DIR}/common/workspace.c
+
     ${SOURCE_DIR}/core/binding.c
     ${SOURCE_DIR}/core/command_buffer.c
-    ${SOURCE_DIR}/core/event.c
     ${SOURCE_DIR}/core/layer.c
     ${SOURCE_DIR}/core/layout.c
     ${SOURCE_DIR}/core/listeners.c

Makefile

@@ -1,16 +1,11 @@
 MAKEFILE_ABS_PATH := $(abspath $(lastword $(MAKEFILE_LIST)))
 MAKEFILE_DIR := $(dir $(MAKEFILE_ABS_PATH))
-PWD_DIR := $(CURDIR)/
 BUILD_DIR := $(addprefix $(MAKEFILE_DIR),build)
 SRC_DIR := $(addprefix $(MAKEFILE_DIR),/)
 
 TARGET_NAME := zdwm
 TARGET := $(addprefix $(MAKEFILE_DIR),$(TARGET_NAME))
 
-ifneq ($(PWD_DIR),$(MAKEFILE_DIR))
-	TARGET := $(addprefix $(MAKEFILE_DIR),$(TARGET_NAME))
-endif
-
 
 $(TARGET_NAME): build
 
@@ -19,10 +14,10 @@ clean:
 	${RM} -r $(BUILD_DIR)
 
 run:
-	-$(shell Xephyr :3 -screen 1920x1080 -dpi `xrdb -get Xft.dpi` &)
+	Xephyr :3 -screen 1920x1080 -dpi `xrdb -get Xft.dpi`
 
 run_multiple_screen:
-	-$(shell Xephyr :3 -screen 1920x1080 -screen 1920x1080 +xinerama -dpi `xrdb -get Xft.dpi` &)
+	Xephyr :3 -screen 1920x1080 -screen 1920x1080 +xinerama -dpi `xrdb -get Xft.dpi`
 
 wm: $(TARGET_NAME)
 	DISPLAY=:3 $(TARGET)

docs/module-layering.org

@@ -0,0 +1,136 @@
+#+title: ZDWM 模块分层与依赖方向
+#+OPTIONS: toc:2
+
+* 动机
+
+随着模块增加，跨模块的"契约"和"共享数据结构"开始散落：有的进了 =core/=（和窗口管理逻辑混在一起），有的不得不靠依赖倒置塞进消费方目录（如 tray 契约放 =bar/= 导致 backend 反向依赖 bar）。结果是 core 职责不清、=bar ↔ backend= 出现交叉依赖、依赖方向不再单向。
+
+本文档定义一套分层约定，把"跨模块共享的东西"从具体实现里抽出来，集中到两个目录，使依赖方向回到干净的单向。
+
+* 核心标准：按"谁直接消费类型"归类
+
+判断一个跨模块的东西进哪个目录，不看它"属于哪个模块"，也不只看"是声明还是实现"，而是看**它的类型被哪些层直接消费**：
+
+- 类型被**两个或以上对等的实现层**直接消费 → 类型放 =interface/=（跨模块声明）
+- 只有**操作函数**被多个实现层共用、且这些层不该互相依赖 → 操作放 =common/=
+- 类型 + 操作都只被一个实现层（及其依赖者）用 → 整个 ADT 放 =common/=，或就近放该实现层
+
+关键推论：**只需消费"类型"的层，不该被迫背上"操作函数"的依赖**。这是把类型和操作分到两个目录的根本理由。
+
+* 目录的定位
+
+先明确三层关系：=base/= 是**项目无关**的通用底层（任何 C 项目都能直接用），=interface/= 和 =common/= 是**项目业务相关**的通用内容。后两者依赖前者（业务依赖基础设施）。
+
+** =src/base/=       ：项目无关的通用底层，零业务依赖
+
+放任何 C 项目都能直接用的纯工具（=memory= / =array= / =macros= / =color= / =log= / =time= / =process=）。不依赖 interface/common/任何实现层——它根本不知道 ZDWM 的业务。=interface/= 和 =common/= 都可以依赖它。
+
+** =src/interface/=  ：跨模块共享的【声明】，零 .c
+
+只放类型定义、多态接口的函数声明。绝对不放假装、零实现代码。被所有实现层依赖，自身不依赖任何实现层（可依赖 =base/= 的纯类型）。
+
+** =src/common/=     ：被多实现层共用的【操作函数】，.h + .c
+
+放自包含的 ADT 操作（构造/清理/查询）。操作只依赖 =interface/= 里的类型（和 =base/= 工具），不依赖任何实现层的内部状态。被"需要这些操作的层"依赖。
+
+注意：=common/= 不是"什么都往里塞的杂物间"。只有当操作被**多个不该互相依赖的实现层**共用时，才进 =common/=；只被单一实现层用的操作，就近放该层。
+
+* 依赖方向
+
+#+begin_example
+base/         ← 项目无关的通用底层（任何 C 项目可用），零业务依赖
+   ↑
+interface/    ← 零业务依赖（纯类型声明，含 backend 抽象接口）；可依赖 base
+   ↑
+common/       ← 项目业务通用的共享 ADT 操作；依赖 interface + base
+   ↑
+core/  runtime/  backend/  bar/   ← 实现层，都依赖 common + interface（+ base）
+#+end_example
+
+注意：没有实现层"只依赖 interface"——所有实现层都用 =common/= 的业务通用操作。interface 的纯净性约束的是 interface *内部*（含 backend 抽象接口不依赖 interface 之外的任何东西），不是约束某个实现层的依赖深度。
+
+不变量：
+- =base/= 不依赖任何业务层（interface/common/实现层），是项目无关的纯工具。
+- =interface/=（含 backend 抽象接口）不依赖 =interface/= 之外的任何业务内容；可依赖 =base/= 的纯类型（业务层依赖基础设施，合理）。
+- =common/= 只依赖 =interface/= 和 =base/=，不依赖任何实现层。
+- 所有实现层（core/runtime/backend/bar）都依赖 =common/= + =interface/=（+ =base/=）；它们之间不直接相互依赖跨模块契约，都经由 =interface/= 或 =common/=。
+- 因此 =bar ↔ backend= 这类对等层之间不再有交叉依赖：都通过 =interface/tray.h= 通信。
+
+* 判定示例：effect / plan / event / listeners
+
+用上面的标准，逐个判定现有跨模块类型：
+
+** =effect_t=  →  interface（类型），无 .c
+
+消费方：core（policy/plan 产生 =effect_t=）+ backend（执行 =effect_t=）。两个对等层直接消费类型，所以类型进 =interface/effect.h=。=effect_t= 是纯数据，构造它的活（=plan_push_*=）属于 plan 的操作，所以 effect 在 interface 里只有类型、没有 .c。
+
+#+begin_src c
+  /* backend 只消费展开后的 effect 数组，从不碰 plan_t */
+  bool backend_apply_effect(backend_t *backend, const effect_t *effects, size_t effect_count);
+#+end_src
+
+** =plan_t=  →  留 core（完整 ADT：类型 + 操作）
+
+消费方：只 core（policy 产生、收集 effect）和 runtime（提交后 reset/cleanup）。两者之间是 *runtime→core 的天然单向依赖*（runtime 是桥接层，本就依赖 core 的 policy/state 等）。把 =plan_t= 放 =core/plan.h= + =core/plan.c=，runtime 正向 include 即可，不破坏任何方向——所以它*不必*进 common。
+
+这把 common 的门槛精确化：common 是为"对等、无天然依赖"的消费者中立化（见下文 =listeners_t=）；若消费者之间已有单向依赖（如 plan 的 core+runtime），共享操作放被依赖方（core）即可，不必上浮 common。
+
+** =event_t=  →  interface（类型）+ common（操作）
+
+=event_t= 类型进 =interface/event.h= 的关键理由：interface 内的 =backend.h= 契约直接 *#include 了 event.h*——=backend_poll_event= / =backend_next_event= 的参数是 =event_t *=，且契约注释讨论 event 的所有权与 =event_cleanup= 语义。一份完整的后端契约要让读者看到 event_t 全貌（字段、联合、生命周期责任），而非甩一个前向声明。所以 event_t 必须在 interface：若放 common，=backend.h= 要么退化为前向声明（契约不完整），要么 interface 反向依赖 common（破坏零依赖）。
+
+=event_reset= / =event_cleanup= 这些操作被 backend 和 runtime 共用，两者对等、不该互相依赖 → 操作落 =common/event.h= + =common/event.c=。于是 event 是"类型在 interface、操作在 common"的典型。
+
+** =listeners_t=  →  common（类型 + 维护）+ core（notify）
+
+=listeners_t= 类型被 bar（订阅）、core（发布）、runtime（生命周期）消费，但 **backend 完全不碰它**。判定关键：它的消费者（bar/config/runtime）都*既用类型又用维护操作*（=add_*= / =cleanup=），没有哪个层"只需类型、不需操作"——按核心推论（只有"只需消费类型"的层才迫使类型单独上提 interface），类型不必进 interface。与 =event_t= 的对照就在这里：=event_t= 因被 interface 内的 =backend.h= 契约需要完整定义而必须留 interface；=listeners_t= 则*不被 interface 内任何契约依赖*（=backend.h= 完全不碰它），所以能整个进 common：
+
+- 类型 =listeners_t= + 维护操作 =add_*= / =cleanup=：自包含容器操作，被 bar/config/runtime 多个对等层共用 → 整个 ADT 进 =common/listeners.{h,c}=。
+- =notify_*=（触发）：单消费者（只 core/runtime 发布侧调用），且依赖 core 内部（把 =state_t= 翻译成 =zdwm_window_t= 等 DTO）→ 声明 + 实现都留 =core/listeners=。
+
+真正的跨层契约（回调签名 =zdwm_window_added= 等 + DTO）已在 =include/zdwm/listeners.h=（比 interface 更公开的那层），=listeners_t= 只是这些回调的容器，所以它整个待在 common 自洽，不必单独占一个 interface 头。
+
+* 汇总表
+
+| 东西                         | 类型在哪              | 操作在哪                                  | 判定理由                                                                 |
+|------------------------------+-----------------------+-------------------------------------------+--------------------------------------------------------------------------|
+| =effect_t=                   | =interface/effect.h=  | （无，构造归 plan 操作）                  | 类型跨模块（core 产 + backend 执行），纯数据                             |
+| =plan_t=                     | =core/plan.h=         | =core/plan.c=                             | 消费者 runtime→core 单向，放 core 不破坏方向，不必 common                |
+| =event_t=                    | =interface/event.h=   | =common/event.h= + =common/event.c=       | 类型跨模块；操作对等共用                                                 |
+| 后端接口（=backend_t= 等）   | =interface/backend.h= | =backend/x11/*.c=                         | 多态接口：声明在 interface，实现在具体后端                               |
+| tray 契约（=tray_t= 等）     | =interface/tray.h=    | =backend/x11/tray.c=                      | 多态接口：bar 用、backend 实现，声明在 interface 消除 =bar↔backend= 交叉 |
+| 通知协议（listeners）        | =common/listeners.h=  | =common/listeners.c= + =core/listeners.c= | 消费者 bar↔core 对等，必须 common 中立化；notify 依赖 core 留 core        |
+| 基础类型（=window_id_t= 等） | =interface/types.h=   | （按需）                                  | 所有层共用                                                               |
+
+* 多态接口 vs 共享 ADT：.c 归属的不同
+
+=interface/= 里有两类声明，它们的 .c 归属不同，务必区分：
+
+- **多态接口**（=backend.h=、=tray.h=）：声明一组"由谁来实现"的函数，实现依赖具体实现层（xcb / 未来 wayland）。这类 .c **必须在实现层**（=backend/x11/=、=core/=），不能在 interface——否则 interface 就"知道"了具体实现。
+- **共享 ADT 的操作**（event 的操作）：实现自包含、不依赖任何实现层。这类 .c 进 =common/=。
+
+换句话说：=interface/= 永远零 .c。多态接口的 .c 在实现层，共享操作的 .c 在 =common/=。
+
+* 和 include/zdwm/ 的区别
+
+- =include/zdwm/= 是**对外公共 API**（给用户配置、插件使用）。
+- =src/interface/= 是**内部跨模块契约**（给各子系统互相通信）。
+
+两者职责不同，不合并。像 =backend.h=、=event.h=、=effect.h= 是内部的，不该进 =include/zdwm/= 暴露给外部。
+
+* 迁移指引
+
+把现有代码按本分层整理时，建议顺序：
+
+1. 建 =src/interface/= 和 =src/common/= 目录，加入 CMakeLists。
+2. 先迁移"纯类型、零依赖"的声明进 =interface/=：=types.h=、=effect.h=（从 =core/plan.h= 抽出 =effect_t=）、=event.h= 的类型部分。
+3. 多态接口声明迁移：=backend.h= 进 =interface/=（=.c= 留原处）。=listeners= 走共享 ADT、不进 interface：=listeners_t= 类型 + =add_*= / =cleanup= 整体进 =common/listeners.{h,c}=，=notify_*= 留 =core/listeners=（详见上方判定示例）。
+4. 共享 ADT 迁移：=event.h= 操作部分 + =event.c= 进 =common/=。（=plan= 留 core：消费者 runtime→core 单向，不必上浮。）
+5. 更新全项目 include 路径（="core/types.h"= → ="interface/types.h"= 等）。
+6. 每步后编译验证，确保依赖方向单向、无循环。
+
+注意边界：遇到"看起来该进 interface、但其类型依赖还在 core"的情况（如某个 event 子结构引用了 =core/window.h= 的类型），要么把那个被引用的类型也提到 =interface/=，要么承认它暂不进 interface——**进 interface 的前提是它的所有依赖都在 interface**，不能硬塞。
+
+* tray 的落点
+
+tray 的契约（=tray_t= / =tray_api_t=）是 bar 与 backend 之间的多态接口，按本分层落 =interface/tray.h=（声明），实现在 =backend/x11/tray.c=。这样 bar 和 backend 都只依赖 =interface/tray.h=，彻底消除 =bar ↔ backend= 交叉依赖——这正是引入这套分层的最初动机之一。详见 [[file:tray-design.org][tray-design.org]]。

docs/tray-design.org

@@ -0,0 +1,256 @@
+#+title: ZDWM Tray 系统托盘设计
+#+OPTIONS: toc:2
+
+* 背景与动机
+
+ZDWM 当前没有系统托盘（system tray / systray）功能。本文档描述如何在 bar 中实现 X11 系统托盘，让外部应用（输入法、音量、蓝牙、网络等）的托盘图标显示在状态栏右侧并正常交互，同时保持现有前后端分离架构，为未来 Wayland 后端预留扩展空间。
+
+* 设计目标与约束
+
+** 前后端分离
+
+tray 协议（=_NET_SYSTEM_TRAY= + XEMBED）必须*闭环在后端内部*。core 的 =event_t= / =policy= / =plan= 完全不感知 tray——tray 不产生 =event_t=、不进 policy 路由、不进 plan/effect。
+
+这与现有架构的三条解耦通道一致：
+- =backend -> core=：后端把平台原始事件归一化为 =event_t=
+- =core -> backend=：core 产出 =effect_t=，后端执行
+- =runtime= 作为唯一桥接点：bar 模块本身拿不到 backend，所有平台访问经 runtime 中转
+
+** Wayland 预留
+
+bar 与 runtime 层必须后端无关、零 xcb。未来加 Wayland 后端时，只需新增一个后端实现——Wayland 用 StatusNotifierItem（SNI）over D-Bus，icon 是像素数据而非真实窗口，由前端 cairo 绘制。只要后端接口形状不变，上层（bar/runtime）零改动。
+
+** tray 是 bar 的附属组件
+
+没有 bar 就没有 tray。tray 的生命周期随 bar 窗口，*不*作为独立公共接口（不进 =include/zdwm/=）。tray 能力内嵌在 bar 窗口的创建/销毁里。
+
+* 方案选型：嵌入式容器子窗口（A'）
+
+X11 系统托盘协议只要求：tray 创建一个 window 成为 =_NET_SYSTEM_TRAY_S<n>= 的 selection owner，客户端向 owner 发 =_NET_SYSTEM_TRAY_REQUEST_DOCK= 请求，tray 用 XEMBED reparent icon。协议本身*不*规定 icon reparent 到 bar 窗口还是独立窗口。
+
+** 为何不用独立 top-level 窗口
+
+完全独立的 top-level tray 窗口（如 stalonetray）是为*没有状态栏*的环境设计的。ZDWM 已有 bar，用独立窗口会引入"两个窗口的几何/对齐同步"问题（tray 窗口要贴 bar 右端、随 icon 数动态 resize、跟随 bar 移动），且无功能收益。
+
+** 为何用专门的容器子窗口
+
+虽然直接 reparent 到 bar 的 cairo 绘制窗口技术上可行（bar 已是 ARGB，子窗口叠加在 cairo 内容之上），但用一个*专门的 tray 容器子窗口*做 selection owner 更正统、更干净：
+
+1. *职责分离*：bar 窗口专注 cairo 绘制，tray 容器专注 XEMBED / icon 管理。dock 请求和 =_XEMBED= 消息定向到容器，不进 bar 的 =handle_client_message=。
+2. *事件隔离*：tray 协议事件在容器窗口闭环，bar 的窗口管理事件流零污染。
+3. *视觉不变*：容器是 bar 窗口的子窗口，位于 tray region 内，icon 跟随 bar 移动/resize（X 子窗口语义），不占额外屏幕空间。
+
+* 后端接口设计
+
+tray 契约独立成头 =interface/tray.h= —— 落 interface 层：不放 core（tray 与 core 无关），也不放 bar（backend 也要实现它）。bar 和 backend 作为两个对等实现层，都依赖 =interface/tray.h= 来解耦——这正是分层消除 bar↔backend 交叉依赖的落点（详见 [[file:module-layering.org][module-layering.org]] 的 tray 落点）。它只依赖 =interface/types.h=（=window_id_t=），不含 =backend_t=，所以 bar include 它而不碰 =interface/backend.h= 的内部。=interface/backend.h= 反过来 include =interface/tray.h=，让 =backend_bar_window_t= 内嵌 =tray_t=。
+
+#+begin_src c
+typedef void (*tray_icons_change_cb_t)(void *user_data);
+
+typedef struct tray_api_t {
+  /* 返回 tray 当前挂载的 bar window_id；invalid 表示无 tray 挂载 */
+  window_id_t (*host_window)(void *handle);
+  /* 当前 icon 数量 */
+  size_t      (*icon_count)(void *handle);
+  /* icon 边长（= bar height），bar 据此算 cell 宽度 */
+  int32_t     (*icon_size)(void *handle);
+  /* 把容器 + icon 摆到 region 起点 x */
+  void        (*place)(void *handle, int32_t x);
+  /* 注册 icon 数量变化回调 */
+  void        (*set_listener)(void *handle,
+                              tray_icons_change_cb_t cb,
+                              void *user_data);
+} tray_api_t;
+
+typedef struct tray_t {
+  tray_api_t api;    /* 值类型，后端总填充，一直可用 */
+  void      *handle; /* 指向 backend（bar 不知其类型） */
+} tray_t;
+
+typedef struct backend_bar_window_t {
+  window_id_t    window_id;
+  cairo_t       *cr;
+  tray_t         tray;
+} backend_bar_window_t;
+
+/* 扩展：加 enable_tray；icon_size 直接用 geometry.height */
+backend_bar_window_t backend_create_bar_window(
+  backend_t *backend, rect_t geometry, uint32_t bg_pixel, bool enable_tray);
+#+end_src
+
+** 关键设计点
+
+- *api 是值类型*：后端用一个全局 =static const= vtable 填充，保证一直可用，bar 不需判 NULL。这与项目现有 =zdwm_bar_item_type_t=（纯 vtable）+ =zdwm_bar_item_t=（实例持有 api + state）的模式一致。
+- *handle 总有效*：实际指向 =backend_t*=（tray api 函数内用 =backend->conn=、=backend->tray= host），对 bar 透明（=void*=）。有无 tray 统一由 =host_window()= 返回值判断（invalid = 无），不靠 api 是否 NULL，避免"先判 api、再判 host_window"两个判断点。
+- *icon_size 来自 handle*（单一数据源）：后端 configure icon 用的尺寸 = bar 查布局用的尺寸，杜绝两边各算导致 icon 错位/溢出。这比在 =tray_t= 冗余存一份快照更纯粹。
+- *生命周期随 bar/backend*：=backend_create_bar_window(enable_tray=true)= 时创建/迁移 host；=backend_destroy= 释放。无 =tray_host_create/destroy= 独立入口，体现"tray 是 bar 附属"。
+
+** 挂载语义
+
+X11 的 =_NET_SYSTEM_TRAY_S0= selection owner *整个 display 只能有一个*，但 =backend_create_bar_window= 是 per-output 调用的。处理方式：
+
+- tray host 是后端单例（内联在 =backend_t=）。
+- 每次传 =enable_tray=true= 的 =create_bar_window= 把容器 reparent 到本次 bar 窗口，最终挂在*最后一个* true 的 output 上。
+- =host_window()= 返回当前挂载的 bar window_id，bar 据此决定哪个 output 渲染 tray。
+
+** 为何 set_listener 不配 remove_listener
+
+tray icon 变化的唯一消费者是 bar 的 tray item，且其生命周期 = host 生命周期（=backend_destroy= 时自然消失）。与 core 的 =listeners= 模块一致（listener 跟宿主容器走，靠容器销毁回收），不引入 =remove_listener=。
+
+* bar item 框架扩展
+
+tray 作为 right-side 的普通 item，复用 =zdwm_bar_item_type_t= 框架。为支持 tray 的两个本质差异（cell 无文本 + 需要在 layout 后把结果同步到后端真实窗口），对框架做最小*通用*扩展——不为 tray 特例化。
+
+** cell_api 全包 cell 相关（不引入 item_api）
+
+=set_cell_count= / =get_cell_count= 本质是 *cell 集合的管理*（类比 =std::vector= 的 =size()/resize()= 与 =operator[]= 同属 vector），留在 =zdwm_bar_cell_api_t=。
+
+新增两个 cell 级接口：
+
+#+begin_src c
+/* 固定宽度：>0 = 固定宽度，0 = 走文本测量（零值默认），<0 = 隐藏 */
+void cell_set_fixed_width(zdwm_bar_item_t *, size_t index, int32_t width);
+/* 单个 cell 的 region（layout 后的坐标） */
+bar_x_region_t cell_get_region(zdwm_bar_item_t *, size_t index);
+#+end_src
+
+=bar_cell_t= 加 =int32_t fixed_width=，默认 =0=（走文本测量）。把零值留给最常见的默认行为（测量），=p_clear= 清零后新 cell 天然正确，=set_cell_count= 无需补初始化；=-1= 当"隐藏"哨兵（负数宽度本就无意义），与 =0=（测量）明确区分，没有歧义。
+
+=bar_output_layout= 改一处：
+
+#+begin_src c
+int32_t width;
+if (cell->fixed_width > 0)       width = cell->fixed_width;   /* 固定 */
+else if (cell->fixed_width == 0) width = 文本测量;            /* 测量（默认）*/
+else                             width = 0;                   /* 隐藏 */
+#+end_src
+
+** after_layout / after_draw 钩子
+
+普通 item 是 cairo 绘制；tray 是"layout 后把 region 应用到后端真实窗口"。给 =zdwm_bar_item_type_t= 加两个*可空*通用钩子，参数打包（仿现有 =zdwm_bar_click_params_t= 先例）：
+
+#+begin_src c
+typedef struct zdwm_bar_item_layout_params_t {
+  zdwm_bar_item_t *item;
+  const zdwm_bar_cell_api_t *cell_api;
+  bar_x_region_t region;
+  void *state;
+} zdwm_bar_item_layout_params_t;
+
+void (*after_layout)(const zdwm_bar_item_layout_params_t *);  /* 可空 */
+void (*after_draw)(const zdwm_bar_item_layout_params_t *);    /* 可空 */
+#+end_src
+
+设计要点：
+- 钩子为 NULL 则跳过，普通 item 零影响。
+- =after_layout= / =after_draw= 比 =update= 多一个 =region=（它们在 layout 之后调用），且通过 =cell_api= 可调 =cell_get_region= 取 per-cell 位置。
+- =update= 不打包参数（3 个参数不多，保持现有 =workspaces= / =binding= / =windows= 三个 item 零改动）。
+
+=bar_draw= 流程：
+
+#+begin_src c
+bar_output_layout(bo, ctx);
+for each item: if (after_layout) after_layout(params);   /* params 含 region */
+bar_output_draw(bo, ctx, bg);
+for each item: if (after_draw) after_draw(params);
+#+end_src
+
+* bar tray item
+
+新增 =src/bar/tray.c=，作为普通 right-side item（参考 [[file:../src/bar/workspaces.c][workspaces.c]] 的实现模式）：
+
+#+begin_src c
+zdwm_bar_item_type_t bar_tray = {
+  .create_state  = bar_tray_create_state,
+  .update        = bar_tray_update,
+  .on_click      = bar_tray_on_click,    /* 返回 NONE：icon 真实子窗口自收点击 */
+  .after_layout  = bar_tray_after_layout,
+  .destroy_state = bar_tray_destroy_state,
+};
+#+end_src
+
+- =create_state=：拷贝 =tray_t=，调 =set_listener= 注册回调（回调置 =state->dirty = true=）。
+- =update=：=dirty= 时 =set_cell_count(icon_count)= + 循环 =cell_set_fixed_width(i, icon_size)=。
+- =after_layout=：=place(handle, params->region.start)=。
+
+tray cell 不画 cairo 内容（text 为空，=bar_item_draw= 只画融入 bar 的背景色块，被真实 icon 窗口盖住）。
+
+* runtime 桥接
+
+=runtime_init_bar=（=src/runtime/runtime.c=）的 create 循环：
+
+#+begin_src c
+for (size_t i = 0; i < count; ++i) {
+  bool enable_tray = ((int32_t)i == runtime->bar.config.tray_output_index);
+  auto bar_window = backend_create_bar_window(backend, bar_rect, color, enable_tray);
+  ...
+  runtime->bar.tray = bar_window.tray;   /* 每个返回都一样，存一份 */
+}
+bar_init(&runtime->bar, &runtime->listeners);
+#+end_src
+
+=bar_init= 遍历 =bar_output=，对 =host_window()= 匹配自身 =window_id= 的那个 output 调 =bar_output_add_tray=（right side），其余不加。tray 生命周期随 =backend_destroy=，runtime 无特殊清理。
+
+* 配置
+
+=zdwm_bar_config_t=（=include/zdwm/config.h=）加：
+
+#+begin_src c
+int32_t tray_output_index;   /* 默认 0 = 第一个 output */
+#+end_src
+
+配置 setup 中可通过 output 信息确定具体 index。
+
+* 数据流（触发链）
+
+#+begin_example
+icon 增删
+  -> 后端 set_listener 回调 -> state->dirty = true
+  -> 下个 timerfd tick -> bar_update -> bar_tray_update
+  -> set_cell_count + cell_set_fixed_width -> item 标 dirty
+  -> bar_draw -> bar_output_layout 重算 region（cell 数变了）
+  -> tray 的 after_layout -> backend place(handle, region.start)
+  -> 后端 move 容器 + configure 每个 icon 到 (region.start + i*icon_size, 0)
+#+end_example
+
+bar 重绘是 timerfd（fps）驱动，非事件驱动。tray icon 是真实窗口，X server 自管绘制，不依赖 cairo 重绘。
+
+* 实现范围（第一版）
+
+第一版做*基础可用*：
+
+- =_NET_SYSTEM_TRAY_S0= selection owner + MANAGER 广播
+- 基础 XEMBED（reparent 容器、=_XEMBED_EMBEDDED_NOTIFY=）
+- icon 显示与点击
+- icon 尺寸 = bar 高度（统一，不缩放）
+
+放后续迭代：
+- 完整 XEMBED 焦点 / 激活转发
+- icon 尺寸协商与缩放
+- 客户端异常断开的清理
+
+*透明背景*第一版基本白送——bar 窗口已是 ARGB visual（见 =backend_create_bar_window= 调用 =window_get_visual(backend, true)=），tray 容器作为子窗口继承。
+
+* 关键文件清单
+
+| 文件                         | 改动                                                                                                                   |
+|------------------------------+------------------------------------------------------------------------------------------------------------------------|
+| =interface/tray.h=           | **新增** tray 契约：=tray_t= / =tray_api_t= / =tray_icons_change_cb_t=（bar 与 backend 共享，落 interface 解耦）       |
+| =interface/backend.h=        | include =interface/tray.h=；=backend_bar_window_t= 内嵌 =tray_t=；扩展 =backend_create_bar_window=（加 =enable_tray=） |
+| =src/backend/x11/tray.c=     | *新增*：selection / MANAGER / 基础 XEMBED / icon 管理 / =place=                                                        |
+| =src/backend/x11/internal.h= | =ATOM_LIST= 追加 tray/XEMBED atoms；=backend_t= 加 =tray= 字段                                                         |
+| =src/backend/x11/event.c=    | 消化 tray 相关 client message（不产 =event_t=）                                                                        |
+| =src/backend/x11/backend.c=  | =backend_create_bar_window= 实现 enable_tray 分支；=backend_destroy= 释放 tray                                         |
+| =src/bar/types.h=            | =bar_cell_t= 加 =fixed_width=；=bar_t= 加 =tray=                                                                       |
+| =src/bar/cell.h= / =cell.c=  | =cell_api= 加 =cell_set_fixed_width= / =cell_get_region=                                                               |
+| =src/bar/bar.c=              | layout 支持 =fixed_width=；=bar_draw= 调 after 钩子；=bar_init= 加 tray item；新增 layout params 类型                  |
+| =src/bar/tray.c=             | *新增*：tray item 实现                                                                                                 |
+| =src/runtime/runtime.c=      | =runtime_init_bar= 传 =enable_tray=、存 =bar->tray=                                                                    |
+| =include/zdwm/config.h=      | =zdwm_bar_config_t= 加 =tray_output_index=                                                                             |
+
+* 复用现有
+
+- =backend_create_bar_window=（=src/backend/x11/backend.c=）：bar 窗口已是 ARGB，tray 容器继承透明。
+- =zdwm_bar_item_type_t= vtable 框架 + [[file:../src/bar/workspaces.c][workspaces.c]]：tray item 同模式落地。
+- =zdwm_bar_click_params_t=：=after_layout= / =after_draw= 的 params 打包仿此先例。
+- =cell_api= 机制：tray =update= 通过它操作 cell（与 workspaces 一致）。

docs/tray-implementation-plan.org

@@ -0,0 +1,91 @@
+#+title: ZDWM Tray 系统托盘实现计划
+#+OPTIONS: toc:2
+
+* 背景
+
+bar 当前没有系统托盘。目标是让外部应用（输入法、音量、蓝牙、网络等）的 tray icon 显示在 bar 右侧并正常交互。
+
+设计文档 [[file:tray-design.org][tray-design.org]] 已把方案定死。刚完成的模块分层重构（[[file:module-layering.org][module-layering.org]]）为 tray 铺了路——=interface/= 层让 bar 与 backend 经契约解耦，tray 契约落 =interface/tray.h= 消除 =bar↔backend= 交叉依赖（分层的核心动机之一）。
+
+* 关键决策
+
+- *契约落 =interface/tray.h=*（分层后的位置，非设计文档旧版的 =src/bar/tray.h=）。
+- *tray 闭环后端*：core 的 =event_t= / =policy= / =plan= 完全不感知；tray 消息在 =event.c= 拦截后 =return false=，不进 policy 路由。
+- *tray 是 bar 附属 + 后端单例*：生命周期随 bar 窗口；=_NET_SYSTEM_TRAY_S0= selection owner 全 display 唯一，挂到最后一个 =enable_tray=true= 的 output。
+- *第一版范围*：selection owner + MANAGER 广播 + 基础 XEMBED（reparent + =_XEMBED_EMBEDDED_NOTIFY=）+ icon 显示与点击 + icon 尺寸 = bar 高度（不缩放）。焦点/激活转发、尺寸协商、客户端异常断开清理放后续迭代。
+- *tray 存 =bar_t.tray=（一份）*：单例语义，=bar_init= 时用 =host_window()= 匹配决定哪个 output 渲染。
+
+* 实现步骤
+
+每步可独立编译，建议每步一个提交。
+
+** 步骤 1：契约层 + 调用点占位
+
+签名变更与唯一调用点耦合，必须一起改才能编译。
+
+- *新增 =src/interface/tray.h=*（纯声明，零 .c）：=tray_icons_change_cb_t=、=tray_api_t=（=host_window= / =icon_count= / =icon_size= / =place= / =set_listener=）、=tray_t=（=api= + =handle=）。只依赖 =interface/types.h=。
+- *=src/interface/backend.h=*：=#include "interface/tray.h"=；=backend_bar_window_t= 内嵌 =tray_t tray=；=backend_create_bar_window= 加 =bool enable_tray=。
+- *=src/runtime/runtime.c=*：临时传 =enable_tray=false=。
+- *=src/backend/x11/backend.c=*：签名加参数，函数体先忽略，返回 =.tray = {0}=。
+- 验证：编译通过，bar 行为不变。
+
+** 步骤 2：bar 框架扩展（零影响现有 3 个 item）
+
+为 tray item 铺路；钩子可空、=fixed_width= 默认 0，现有 item 走原路径。
+
+- *=include/zdwm/bar.h=*：=zdwm_bar_item_type_t= 加可空钩子 =after_layout= / =after_draw=；新增 =zdwm_bar_item_layout_params_t=（仿 =zdwm_bar_click_params_t=：=item= / =cell_api= / =region= / =state=）；=zdwm_bar_cell_api_t= 加 =cell_set_fixed_width=、=cell_get_region=。
+- *=src/bar/types.h=*：=bar_cell_t= 加 =int32_t fixed_width=（默认 0 = 走文本测量，=p_clear= 后天然正确；<0 = 隐藏哨兵）。
+- *=src/bar/cell.c=*：实现 =bar_cell_set_fixed_width= / =bar_cell_get_region=，注册进 =bar_cell_api=。
+- *=src/bar/bar.c=*：=bar_output_layout= 三处宽度计算加 =fixed_width= 分支（>0 固定 / ==0 测量 / <0 隐藏）；=bar_draw= 在 layout 后遍历调 =after_layout=、draw 后调 =after_draw=（NULL 跳过）。
+- 验证：编译 + 运行，*workspaces/binding/windows 三个 item 视觉与点击零变化*（关键回归点）。
+
+** 步骤 3：后端协议层（核心）
+
+tray 能力全部 X11 细节，"已实现但未启用"。
+
+- *新增 =src/backend/x11/tray.c=*：tray host 状态 + 成为 =_NET_SYSTEM_TRAY_S0= owner + 广播 MANAGER + 容器子窗口（reparent 到当前 bar）+ 基础 XEMBED（reparent icon + =_XEMBED_EMBEDDED_NOTIFY=）+ dock 请求处理 + =place(handle,x)=（move 容器、configure 每个 icon 到 =x + i*icon_size=）+ 填充 =static const tray_api_t=（=handle= 实际是 =backend_t*=）。=icon_size= 用 bar 窗口高度（单一数据源）。
+- *=src/backend/x11/internal.h=*：=ATOM_LIST= 追加 =_NET_SYSTEM_TRAY_S0= / =_NET_SYSTEM_TRAY_OPCODE= / =_NET_SYSTEM_TRAY_MESSAGE_DATA= / =_XEMBED= / =_XEMBED_INFO= / =Manager=；=backend_t= 加 tray host 字段（单例：host_window、icon 列表、listener、enabled）。
+- *=src/backend/x11/event.c=*（=handle_client_message=）：开头拦截 tray 消息（=Manager= 且 =data.data32[1]==_NET_SYSTEM_TRAY_S0=；=_NET_SYSTEM_TRAY_OPCODE= 的 =REQUEST_DOCK=），处理后 =return false=（不产 =event_t=）。
+- *=src/backend/x11/backend.c=*：=backend_create_bar_window= 的 =enable_tray=true= 分支（创建/迁移 host 容器到此 bar 窗口，返回 =tray= 填 backend 的 api + =handle=backend=）；=backend_destroy= 释放 tray（selection、容器、icon 列表）。
+- *=CMakeLists.txt=*：加 =src/backend/x11/tray.c=。
+- 验证：编译通过。runtime 仍传 false，行为不变。
+
+** 步骤 4：bar tray item
+
+消费步骤 2 的框架 + 步骤 3 的契约，tray 作为 right-side item 接入。
+
+- *新增 =src/bar/tray.c=*（参考 =workspaces.c= 模式）：=bar_tray= vtable = =create_state= / =update= / =on_click= / =after_layout= / =destroy_state=。=create_state= 拷贝 =tray_t= + =set_listener= 注册回调（置 dirty）；=update= 在 dirty 时 =set_cell_count(icon_count)= + 循环 =cell_set_fixed_width(i, icon_size)=；=on_click= 返回 =ACTION_NONE=（icon 真实子窗口自收点击）；=after_layout= 调 =place(handle, region.start)=。cell 不画 cairo（text 空，被真实 icon 窗口盖住）。
+- *=src/bar/bar.h=*：=bar_t= 加 =tray_t tray=（一份，单例）。
+- *=src/bar/bar.c=*（=bar_init=）：遍历 output，对 =bar->tray.host_window()= 匹配自身 =window_id= 的 output 调 =bar_output_add_tray=（right side），其余不加。
+- *=CMakeLists.txt=*：加 =src/bar/tray.c=。
+- 验证：编译通过。right side 仍空（runtime 未注入 tray）。
+
+** 步骤 5：runtime/配置串起来（启用）
+
+- *=include/zdwm/bar.h=*（=zdwm_bar_config_t=）：加 =int32_t tray_output_index=（默认 0 = 第一个 output）。
+- *=src/runtime/runtime.c=*（=runtime_init_bar=）：=bool enable_tray = ((int32_t)i == runtime->bar.config.tray_output_index);= 传给 =backend_create_bar_window=；=runtime->bar.tray = bar_window.tray;=（每个返回都一样，存一份）。
+- *=src/config/defaults.c=*：=tray_output_index= 默认 0。
+- 验证：编译 + 运行，tray 启用。
+
+* 风险点
+
+- *after 钩子对现有 item*：现有三个 item 的 vtable 不显式初始化新钩子 → NULL（C 部分初始化保证）；=bar_draw= 调用前判 NULL。=fixed_width= 默认 0 走原测量路径。步骤 2 后必须确认三个 item 零变化。
+- *selection owner 单例 vs per-output create*：host 是 backend 单例；每次 =enable_tray=true= 把容器 reparent 到本次 bar 窗口，最终挂最后一个 true 的 output；=host_window()= 返回当前挂载 window_id。
+- *XEMBED 第一版只做基础*：reparent + =EMBEDDED_NOTIFY=；不做焦点/激活/缩放。某些高级 applet（要求焦点的输入法）可能受限，基础音量/网络 icon 无影响。
+- *core 零感知*：tray 消息在 =event.c= 拦截 =return false=，不进 policy/plan。icon 增删不触发 core 重排——icon 是真实 X 子窗口，X server 自管绘制，bar 重绘靠 timerfd 驱动，region 变化经 =after_layout= → =place= 同步。
+- *tray cell padding*：=fixed_width = icon_size=，确保 tray item 的 cell padding 为 0，避免 icon 间额外间距。
+- *透明背景*：bar 窗口已 ARGB（=backend.c= 用 =window_get_visual(true)=），tray 容器子窗口继承，第一版白送。
+
+* 端到端验证
+
+1. *每步编译*：=cmake --build build=，零 warning（项目 =-Wall=）。
+2. *步骤 5 后运行*：=./build/zdwm=。
+3. *tray icon 验证*：启动一个提供 tray icon 的 app（=volumeicon= / =nm-applet= / =fcitx5= 等，不要用 stalonetray——它会抢 selection owner）。验证：icon 显示在 bar *右侧*、尺寸 = bar 高度无溢出、多 icon 横向无重叠、点击有响应、透明背景融入 bar。
+4. *动态增删*：启动/退出 tray app，观察 icon 实时增删 + 布局重排（经 =set_listener= 回调 → dirty → 下个 timerfd tick → =update= 重算 → =after_layout= 重排），无残留空位。
+5. *回归*（每步都做，重点步骤 2）：workspaces tag 切换、binding 模式、windows 标题、bar 点击命中全部不变。
+
+* 关键文件
+
+- *新增*：=src/interface/tray.h=（契约）、=src/backend/x11/tray.c=（协议核心）、=src/bar/tray.c=（bar item）。
+- *修改*：=src/interface/backend.h=、=src/backend/x11/{internal.h,event.c,backend.c}=、=include/zdwm/bar.h=、=src/bar/{types.h,cell.c,bar.c,bar.h}=、=src/runtime/runtime.c=、=src/config/defaults.c=、=CMakeLists.txt=。
+- *复用*：=workspaces.c=（item 模板）、=zdwm_bar_click_params_t=（layout params 打包先例）、=ATOM_LIST= 宏（atom 注册）、=window_get_visual(true)=（ARGB）、=bar_cell_api= vtable 机制。

include/zdwm/bar.h

@@ -39,6 +39,8 @@ typedef struct zdwm_bar_config_t {
   const char *binding_mode_bg;
   const char *binding_mode_fg;
 
+  int32_t tray_output_index;
+
   uint32_t window_padding_x;
   const char *window_bg;
   const char *window_fg;
@@ -48,6 +50,11 @@ typedef struct zdwm_bar_config_t {
 
 typedef struct zdwm_bar_item_t zdwm_bar_item_t;
 
+typedef struct zdwm_bar_x_region_t {
+  int32_t start;
+  int32_t end;
+} zdwm_bar_x_region_t;
+
 typedef struct zdwm_bar_cell_api_t {
   size_t (*get_cell_count)(zdwm_bar_item_t *item);
   void (*set_cell_count)(zdwm_bar_item_t *item, size_t count);
@@ -57,8 +64,31 @@ typedef struct zdwm_bar_cell_api_t {
   void (*cell_set_fg)(zdwm_bar_item_t *item, size_t index, const char *color);
   void (*cell_set_icon)(zdwm_bar_item_t *item, size_t index, zdwm_icon_t icon);
   void (*cell_set_indicator)(zdwm_bar_item_t *item, size_t index, bool show);
+  void (*cell_set_fixed_width)(
+    zdwm_bar_item_t *item,
+    size_t index,
+    int32_t width
+  );
+
+  zdwm_bar_x_region_t (*cell_get_region)(zdwm_bar_item_t *item, size_t index);
 } zdwm_bar_cell_api_t;
 
+typedef struct zdwm_bar_click_params_t {
+  zdwm_bar_item_t *item;
+  size_t cell_index;
+  int32_t x;
+  zdwm_modifier_mask_t modifiers;
+  zdwm_button_t button;
+  void *state;
+} zdwm_bar_click_params_t;
+
+typedef struct zdwm_bar_item_hook_params_t {
+  zdwm_bar_item_t *item;
+  const zdwm_bar_cell_api_t *cell_api;
+  zdwm_bar_x_region_t region;
+  void *state;
+} zdwm_bar_item_hook_params_t;
+
 typedef struct zdwm_bar_item_type_t {
   void *(*create_state)(zdwm_output_id_t output_id, void *config);
   void (*update)(
@@ -66,12 +96,9 @@ typedef struct zdwm_bar_item_type_t {
     const zdwm_bar_cell_api_t *cells,
     void *state
   );
-  zdwm_action_t (*on_click)(
+  void (*after_layout)(const zdwm_bar_item_hook_params_t *params);
-    zdwm_bar_item_t *item,
+  void (*after_draw)(const zdwm_bar_item_hook_params_t *params);
-    size_t cell_index,
+  zdwm_action_t (*on_click)(zdwm_bar_click_params_t *params);
-    int32_t x,
-    void *state
-  );
   void (*destroy_state)(void *state);
   zdwm_bar_item_t *instance;
   uint32_t update_interval_ms;

include/zdwm/types.h

@@ -18,6 +18,28 @@ typedef uint32_t zdwm_binding_mode_id_t;
 #define ZDWM_WORKSPACE_ID_INVALID    ((zdwm_workspace_id_t)UINT32_MAX)
 #define ZDWM_BINDING_MODE_ID_INVALID ((zdwm_binding_mode_id_t)UINT32_MAX)
 
+typedef enum zdwm_button_t {
+  ZDWM_BUTTON_NONE,
+  ZDWM_BUTTON_LEFT,
+  ZDWM_BUTTON_RIGHT,
+  ZDWM_BUTTON_MIDDLE,
+} zdwm_button_t;
+
+/* clang-format off */
+typedef enum zdwm_modifier_bit_t {
+  ZDWM_MOD_NONE    = 0u,
+  ZDWM_MOD_SHIFT   = 1u << 0,
+  ZDWM_MOD_CONTROL = 1u << 1,
+  ZDWM_MOD_1       = 1u << 2,
+  ZDWM_MOD_2       = 1u << 3,
+  ZDWM_MOD_3       = 1u << 4,
+  ZDWM_MOD_4       = 1u << 5,
+  ZDWM_MOD_5       = 1u << 6,
+} zdwm_modifier_bit_t;
+/* clang-format on */
+
+typedef uint32_t zdwm_modifier_mask_t;
+
 typedef struct zdwm_rect_t {
   int32_t x;
   int32_t y;

src/backend/output_utils.c

@@ -4,8 +4,8 @@
 #include <stdint.h>
 
 #include "base/memory.h"
-#include "core/backend.h"
+#include "interface/backend.h"
-#include "core/types.h"
+#include "interface/types.h"
 
 static inline int32_t right(rect_t a) { return a.x + a.width; }
 static inline int32_t bottom(rect_t a) { return a.y + a.height; }

src/backend/output_utils.h

@@ -2,8 +2,7 @@
 
 #include <stddef.h>
 
-#include "core/backend.h"
+#include "interface/backend.h"
-#include "core/types.h"
 
 backend_detect_t *
 output_remove_duplication(const output_info_t *output, const size_t count);

src/backend/x11/backend.c

@@ -1,4 +1,4 @@
-#include "core/backend.h"
+#include "interface/backend.h"
 
 #include <cairo-xcb.h>
 #include <cairo.h>
@@ -19,17 +19,14 @@
 
 #include "backend/output_utils.h"
 #include "backend/x11/cursor.h"
+#include "backend/x11/tray.h"
 #include "backend/x11/window.h"
 #include "base/app.h"
 #include "base/array.h"
 #include "base/log.h"
 #include "base/macros.h"
 #include "base/memory.h"
-#include "base/window_list.h"
+#include "common/window.h"
-#include "core/event.h"
-#include "core/plan.h"
-#include "core/types.h"
-#include "core/window.h"
 #include "internal.h"
 
 typedef struct atom_item_t {
@@ -198,6 +195,8 @@ backend_t *backend_create(const char *display_name) {
 void backend_destroy(backend_t *backend) {
   if (!backend) return;
 
+  tray_cleanup(backend);
+
   p_delete(&backend->config_list.cfgs);
   p_clear(&backend->config_list, 1);
 
@@ -559,6 +558,7 @@ static void backend_merge_effects(
     switch (e->type) {
     case ZDWM_EFFECT_MAP_WINDOW:
       window_list_push(&backend->map, e->as.map.window);
+      window_list_push(&backend->configure, e->as.map.window);
       break;
     case ZDWM_EFFECT_UNMAP_WINDOW:
       window_list_push(&backend->unmap, e->as.unmap.window);
@@ -613,6 +613,9 @@ static void backend_merge_effects(
     case ZDWM_EFFECT_CONFIGURE_WINDOW:
       merge_window_configure_params(backend, &e->as.configure);
       break;
+    case ZDWM_EFFECT_CONFIGURE_NOTIFY:
+      window_list_push(&backend->configure, e->as.configure_notify.window);
+      break;
     case ZDWM_EFFECT_CHANGE_BORDER_COLOR: {
       xcb_change_window_attributes_value_list_t value = {
         .border_pixel = e->as.change_border_color.color->argb
@@ -644,6 +647,46 @@ static void backend_merge_effects(
   }
 }
 
+static void batch_send_configure_notify(
+  xcb_connection_t *conn,
+  xcb_window_t *windows,
+  size_t count
+) {
+  if (count == 0) return;
+
+  auto cookie_list = p_new(xcb_get_geometry_cookie_t, count);
+
+  for (size_t i = 0; i < count; ++i) {
+    auto window = windows[i];
+    cookie_list[i] = xcb_get_geometry(conn, window);
+  }
+
+  uint32_t event_mask = XCB_EVENT_MASK_STRUCTURE_NOTIFY;
+  for (size_t i = 0; i < count; ++i) {
+    auto window = windows[i];
+    auto cookie = cookie_list[i];
+    auto reply = xcb_get_geometry_reply(conn, cookie, nullptr);
+    if (!reply) continue;
+
+    xcb_configure_notify_event_t ev = {
+      .response_type = XCB_CONFIGURE_NOTIFY,
+      .event = window,
+      .window = window,
+      .above_sibling = XCB_WINDOW_NONE,
+      .x = reply->x,
+      .y = reply->y,
+      .width = reply->width,
+      .height = reply->height,
+      .border_width = reply->border_width,
+      .override_redirect = false,
+    };
+    xcb_send_event(conn, false, window, event_mask, (char *)&ev);
+    p_delete(&reply);
+  }
+
+  p_delete(&cookie_list);
+}
+
 static void backend_batch_apply_effects(backend_t *backend) {
   xcb_connection_t *conn = backend->conn;
   if (backend->unmap.count) {
@@ -673,6 +716,12 @@ static void backend_batch_apply_effects(backend_t *backend) {
 
   backend_apply_window_configure_list(backend);
 
+  {
+    auto windows = backend->configure.windows;
+    auto count = backend->configure.count;
+    batch_send_configure_notify(conn, windows, count);
+  }
+
   if (backend->update_focus) {
     backend_focus_window(backend, backend->focus_window);
   }
@@ -688,6 +737,7 @@ bool backend_apply_effect(
   window_list_reset(&backend->unmap);
   window_list_reset(&backend->map);
   window_list_reset(&backend->kill);
+  window_list_reset(&backend->configure);
 
   backend_merge_effects(backend, effects, effect_count);
   backend_batch_apply_effects(backend);
@@ -734,8 +784,9 @@ backend_scan_result_t *backend_scan_windows(backend_t *backend) {
     auto transient_for = window_get_transient_for(backend, window);
     auto r = transient_for == XCB_WINDOW_NONE ? result : sub_result;
     auto slot = array_push(r->windows, r->count, r->capacity);
-    if (!populate_window_event(backend, list[i], slot) ||
+    if (
-        slot->override_redirect) {
+      !populate_window_event(backend, list[i], slot) || slot->override_redirect
+    ) {
       window_layer_props_cleanup(&slot->props);
       window_metadata_cleanup(&slot->metadata);
       r->count--;
@@ -777,7 +828,8 @@ void backend_scan_result_destroy(backend_scan_result_t *result) {
 backend_bar_window_t backend_create_bar_window(
   backend_t *backend,
   rect_t geometry,
-  uint32_t bg_pixel
+  uint32_t bg_pixel,
+  bool enable_tray
 ) {
   auto conn = backend->conn;
   auto root = backend->screen->root;
@@ -847,7 +899,24 @@ backend_bar_window_t backend_create_bar_window(
     fatal("cannot create cairo context: %s", cairo_status_to_string(statue));
   }
 
-  return (backend_bar_window_t){.window_id = window_id, .cr = cr};
+  if (enable_tray) {
+    tray_host_window_t host_window = {
+      .window = window_id,
+      .width = width,
+      .height = height,
+      .bg_pixel = bg_pixel,
+    };
+    tray_init(backend, host_window);
+  }
+
+  return (backend_bar_window_t){
+    .window_id = window_id,
+    .cr = cr,
+    .tray = {
+      .api = tray_api,
+      .handle = backend,
+    },
+  };
 }
 
 void backend_flush(backend_t *backend) { xcb_flush(backend->conn); }

src/backend/x11/common.c

@@ -5,7 +5,7 @@
 #include <xcb/xproto.h>
 
 #include "base/macros.h"
-#include "core/types.h"
+#include "interface/types.h"
 
 typedef struct modifier_map_t {
   modifier_bit_t modifier;

src/backend/x11/common.h

@@ -3,7 +3,7 @@
 #include <stdint.h>
 #include <xcb/xproto.h>
 
-#include "core/types.h"
+#include "interface/types.h"
 
 modifier_mask_t modifiers_xcb_to_zdwm(uint16_t mask);
 uint16_t modifiers_zdwm_to_xcb(modifier_mask_t mask);

src/backend/x11/event.c

@@ -1,4 +1,4 @@
-#include "core/event.h"
+#include "common/event.h"
 
 #include <assert.h>
 #include <stdint.h>
@@ -10,11 +10,11 @@
 #include <xcb/xproto.h>
 
 #include "backend/x11/common.h"
+#include "backend/x11/tray.h"
 #include "backend/x11/window.h"
 #include "base/memory.h"
-#include "core/backend.h"
+#include "interface/backend.h"
-#include "core/types.h"
+#include "interface/event.h"
-#include "core/window.h"
 #include "internal.h"
 
 static window_state_t *derive_window_states(
@@ -58,8 +58,10 @@ static bool maximized_from_states(
   uint32_t state_count
 ) {
   for (uint32_t i = 0; i < state_count; i++) {
-    if (state_atoms[i] == atoms->_NET_WM_STATE_MAXIMIZED_VERT ||
+    if (
-        state_atoms[i] == atoms->_NET_WM_STATE_MAXIMIZED_HORZ)
+      state_atoms[i] == atoms->_NET_WM_STATE_MAXIMIZED_VERT ||
+      state_atoms[i] == atoms->_NET_WM_STATE_MAXIMIZED_HORZ
+    )
       return true;
   }
   return false;
@@ -188,6 +190,8 @@ static bool handle_map_request(
   event_t *event,
   const xcb_map_request_event_t *xcb_event
 ) {
+  if (tray_handle_map_request(backend, xcb_event)) return false;
+
   event->type = ZDWM_EVENT_WINDOW_MAP_REQUEST;
   return populate_window_event(
     backend,
@@ -201,6 +205,8 @@ static bool handle_unmap_notify(
   event_t *event,
   const xcb_unmap_notify_event_t *xcb_event
 ) {
+  if (tray_handle_unmap_notify(backend, xcb_event)) return false;
+
   event->type = ZDWM_EVENT_WINDOW_REMOVE;
   event->as.window_remove.window = xcb_event->window;
   if (XCB_EVENT_SENT(xcb_event)) {
@@ -217,6 +223,8 @@ static bool handle_destroy_notify(
   event_t *event,
   const xcb_destroy_notify_event_t *xcb_event
 ) {
+  if (tray_handle_destroy_notify(backend, xcb_event)) return false;
+
   event->type = ZDWM_EVENT_WINDOW_REMOVE;
   event->as.window_remove.window = xcb_event->window;
   event->as.window_remove.reason = ZDWM_WINDOW_REMOVE_DESTROY;
@@ -229,6 +237,8 @@ static bool handle_configure_request(
   event_t *event,
   const xcb_configure_request_event_t *xcb_event
 ) {
+  if (tray_handle_configure_request(backend, xcb_event)) return false;
+
   event->type = ZDWM_EVENT_CONFIGURE_REQUEST;
   auto data = &event->as.configure_request;
   data->window = xcb_event->window;
@@ -340,9 +350,13 @@ static bool handle_property_notify(
   event_t *event,
   const xcb_property_notify_event_t *xcb_event
 ) {
+  if (tray_handle_property_notify(backend, xcb_event)) return false;
+
   auto window_id = xcb_event->window;
-  if (xcb_event->atom == backend->atoms.WM_NAME ||
+  if (
-      xcb_event->atom == backend->atoms._NET_WM_NAME) {
+    xcb_event->atom == backend->atoms.WM_NAME ||
+    xcb_event->atom == backend->atoms._NET_WM_NAME
+  ) {
     event->type = ZDWM_EVENT_WINDOW_METADATA_CHANGED;
 
     auto data = &event->as.window_metadata_change;
@@ -416,6 +430,8 @@ static bool handle_client_message(
   event_t *event,
   const xcb_client_message_event_t *xcb_event
 ) {
+  if (tray_handle_client_message(backend, xcb_event)) return false;
+
   auto atoms = &backend->atoms;
 
   if (xcb_event->type == atoms->_NET_ACTIVE_WINDOW) {

src/backend/x11/internal.h

@@ -7,8 +7,8 @@
 #include <xcb/xcb_keysyms.h>
 #include <xcb/xproto.h>
 
-#include "base/window_list.h"
+#include "common/window.h"
-#include "core/event.h"
+#include "interface/event.h"
 
 #define EWMH_ATOMS(X)                  \
   X(_NET_WM_NAME)                      \
@@ -46,6 +46,10 @@
   X(_NET_WM_WINDOW_TYPE_NOTIFICATION)
 
 #define ATOM_LIST(X)          \
+  X(MANAGER)                  \
+  X(_NET_SYSTEM_TRAY_OPCODE)  \
+  X(_XEMBED)                  \
+                              \
   X(COMPOUND_TEXT)            \
   X(UTF8_STRING)              \
                               \
@@ -86,6 +90,8 @@ typedef enum cursor_t {
   ZDWM_CURSOR_COUNT,
 } cursor_t;
 
+typedef struct tray_host_t tray_host_t;
+
 typedef struct backend_t {
   xcb_key_symbols_t *key_symbols;
   xcb_connection_t *conn;
@@ -109,6 +115,9 @@ typedef struct backend_t {
   window_list_t unmap;
   window_list_t map;
   window_list_t kill;
+  window_list_t configure;
+
+  tray_host_t *tray;
 } backend_t;
 
 bool populate_window_event(

src/backend/x11/tray.c

@@ -0,0 +1,606 @@
+#include "backend/x11/tray.h"
+
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <xcb/xcb.h>
+#include <xcb/xcb_aux.h>
+#include <xcb/xproto.h>
+#include <zdwm/types.h>
+
+#include "backend/x11/window.h"
+#include "base/array.h"
+#include "base/log.h"
+#include "base/macros.h"
+#include "base/memory.h"
+#include "interface/tray.h"
+#include "interface/types.h"
+#include "internal.h"
+
+typedef enum tray_opcode_t {
+  SYSTEM_TRAY_REQUEST_DOCK = 0,
+  SYSTEM_TRAY_BEGIN_MESSAGE = 1,
+  SYSTEM_TRAY_CANCEL_MESSAGE = 2,
+} tray_opcode_t;
+
+typedef enum xembed_message_t {
+  XEMBED_EMBEDDED_NOTIFY = 0,
+} xembed_message_t;
+
+static constexpr auto XEMBED_VERSION = 0;
+
+typedef struct tray_icon_t {
+  xcb_window_t window;
+  int32_t natural_width;
+  int32_t natural_height;
+} tray_icon_t;
+
+typedef struct tray_host_t {
+  bool enabled;
+  bool initialized;
+  xcb_atom_t selection_atom;
+  xcb_window_t host_window;
+  xcb_window_t container;
+  int32_t icon_size;
+
+  tray_icon_t *icons;
+  size_t icon_count;
+  size_t icon_capacity;
+
+  tray_icons_change_cb_t icon_change_cb;
+  void *cb_user_data;
+} tray_host_t;
+
+static tray_host_t *get_tray_host(void *handle) {
+  backend_t *backend = handle;
+  if (!backend) return nullptr;
+
+  auto tray = backend->tray;
+  if (!tray || !tray->enabled) return nullptr;
+
+  return tray;
+}
+
+static size_t tray_find_icon(tray_host_t *tray, xcb_window_t window) {
+  for (size_t i = 0; i < tray->icon_count; ++i) {
+    if (tray->icons[i].window == window) return i;
+  }
+
+  return SIZE_MAX;
+}
+
+static tray_icon_t *tray_get_icon(tray_host_t *tray, xcb_window_t window) {
+  for (size_t i = 0; i < tray->icon_count; ++i) {
+    auto icon = &tray->icons[i];
+    if (icon->window == window) return icon;
+  }
+
+  return nullptr;
+}
+
+static inline void tray_dispatch_callback(tray_host_t *tray) {
+  assert(tray);
+  if (tray->icon_change_cb) tray->icon_change_cb(tray->cb_user_data);
+}
+
+static void tray_release_icon_window(backend_t *backend, tray_icon_t *icon) {
+  if (!icon || icon->window == XCB_WINDOW_NONE) return;
+
+  auto tray = get_tray_host(backend);
+  if (!tray || !tray->initialized) return;
+
+  auto conn = backend->conn;
+  auto root = backend->screen->root;
+  auto window = icon->window;
+  auto mask = XCB_CW_EVENT_MASK;
+  xcb_params_cw_t params = {.event_mask = XCB_EVENT_MASK_NO_EVENT};
+  xcb_change_save_set(conn, XCB_SET_MODE_DELETE, window);
+  xcb_aux_change_window_attributes(conn, window, mask, &params);
+  xcb_reparent_window(conn, window, root, 0, 0);
+}
+
+static void tray_remove_icon_by_index(
+  backend_t *backend,
+  size_t index,
+  bool release_window
+) {
+  auto tray = backend->tray;
+  if (index >= tray->icon_count) return;
+
+  auto icon = &tray->icons[index];
+  if (release_window) tray_release_icon_window(backend, icon);
+
+  array_erase(tray->icons, tray->icon_count, index);
+  tray_dispatch_callback(tray);
+}
+
+static zdwm_size_t tray_get_icon_size(tray_host_t *tray, size_t index) {
+  auto target_size = MAX(tray->icon_size, (int32_t)1);
+  auto natural_width = tray->icons[index].natural_width;
+  auto natural_height = tray->icons[index].natural_height;
+
+  if (natural_width == 0) natural_width = target_size;
+  if (natural_height == 0) natural_height = target_size;
+
+  double width_scale = (double)target_size / (double)natural_width;
+  double height_scale = (double)target_size / (double)natural_height;
+  auto scale = MIN(width_scale, height_scale);
+  zdwm_size_t size = {
+    .width = (int32_t)(natural_width * scale),
+    .height = (int32_t)(natural_height * scale),
+  };
+  return size;
+}
+
+static void tray_layout_icons(backend_t *backend, int32_t start_x) {
+  auto tray = get_tray_host(backend);
+  if (!tray || !tray->initialized) return;
+  if (tray->container == XCB_WINDOW_NONE) return;
+
+  auto conn = backend->conn;
+  if (tray->icon_count == 0) {
+    xcb_unmap_window(conn, tray->container);
+    return;
+  }
+
+  auto height = tray->icon_size;
+  auto width = height * (int32_t)tray->icon_count;
+  xcb_configure_window_value_list_t value_list = {
+    .x = start_x,
+    .y = 0,
+    .width = (uint32_t)width,
+    .height = (uint32_t)height,
+  };
+  uint16_t value_mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
+                        XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
+  xcb_configure_window_aux(conn, tray->container, value_mask, &value_list);
+  xcb_map_window(conn, tray->container);
+
+  for (size_t i = 0; i < tray->icon_count; ++i) {
+    auto window = tray->icons[i].window;
+    auto icon_size = tray_get_icon_size(tray, i);
+    value_mask |= XCB_CONFIG_WINDOW_BORDER_WIDTH;
+    auto offset_x = height * (int32_t)i;
+    value_list = (xcb_configure_window_value_list_t){
+      .x = offset_x + (icon_size.width - height) / 2,
+      .y = (icon_size.height - height) / 2,
+      .width = icon_size.width,
+      .height = icon_size.height,
+      .border_width = 0,
+    };
+    xcb_configure_window_aux(conn, window, value_mask, &value_list);
+    xcb_map_window(conn, window);
+  }
+}
+
+static window_id_t tray_host_window(void *handle) {
+  auto tray = get_tray_host(handle);
+  if (!tray) return ZDWM_WINDOW_ID_INVALID;
+
+  return tray->host_window;
+}
+
+static size_t tray_icon_count(void *handle) {
+  auto tray = get_tray_host(handle);
+
+  return tray ? tray->icon_count : 0;
+}
+
+static int32_t tray_icon_size(void *handle) {
+  auto tray = get_tray_host(handle);
+
+  return tray ? tray->icon_size : 0;
+}
+
+static void tray_place(void *handle, int32_t x) {
+  auto tray = get_tray_host(handle);
+  if (!tray) return;
+
+  tray_layout_icons((backend_t *)handle, x);
+}
+
+static void
+tray_set_listeners(void *handle, tray_icons_change_cb_t cb, void *user_data) {
+  auto tray = get_tray_host(handle);
+  if (!tray) return;
+
+  tray->icon_change_cb = cb;
+  tray->cb_user_data = user_data;
+}
+
+const tray_api_t tray_api = {
+  .host_window = tray_host_window,
+  .icon_count = tray_icon_count,
+  .icon_size = tray_icon_size,
+  .place = tray_place,
+  .set_listener = tray_set_listeners,
+};
+
+static bool tray_intern_selection_atom(tray_host_t *tray, backend_t *backend) {
+  auto conn = backend->conn;
+  auto screenp = backend->screenp;
+
+  char selection_name[64] = {0};
+  auto atom_name_format = "_NET_SYSTEM_TRAY_S%d";
+  snprintf(selection_name, sizeof(selection_name), atom_name_format, screenp);
+
+  uint16_t name_length = strlen(selection_name);
+  auto cookie = xcb_intern_atom(conn, false, name_length, selection_name);
+  auto reply = xcb_intern_atom_reply(conn, cookie, nullptr);
+  if (!reply) {
+    warn("cannot intern tray selection atom: %s", selection_name);
+    return false;
+  }
+
+  tray->selection_atom = reply->atom;
+  p_delete(&reply);
+  return true;
+}
+
+static bool tray_create_container_window(
+  tray_host_t *tray,
+  backend_t *backend,
+  tray_host_window_t host_window
+) {
+  auto conn = backend->conn;
+  auto window_id = xcb_generate_id(conn);
+  auto depth = backend->screen->root_depth;
+  auto visual_id = backend->screen->root_visual;
+
+  static xcb_colormap_t colormap = XCB_NONE;
+  if (colormap == XCB_NONE) {
+    colormap = xcb_generate_id(conn);
+    auto root = backend->screen->root;
+    uint8_t alloc = XCB_COLORMAP_ALLOC_NONE;
+    xcb_create_colormap(conn, alloc, colormap, root, visual_id);
+  }
+
+  uint32_t value_mask = XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL |
+                        XCB_CW_OVERRIDE_REDIRECT | XCB_CW_EVENT_MASK |
+                        XCB_CW_COLORMAP;
+  xcb_create_window_value_list_t value_list = {
+    .background_pixel = host_window.bg_pixel,
+    .border_pixel = 0,
+    .override_redirect = true,
+    .event_mask =
+      XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | XCB_EVENT_MASK_STRUCTURE_NOTIFY,
+    .colormap = colormap,
+  };
+  auto cookie = xcb_create_window_aux_checked(
+    conn,
+    depth,
+    window_id,
+    host_window.window,
+    (int16_t)host_window.width,
+    0,
+    1,
+    (uint16_t)MAX(1, host_window.height),
+    0,
+    XCB_WINDOW_CLASS_INPUT_OUTPUT,
+    visual_id,
+    value_mask,
+    &value_list
+  );
+
+  if (xcb_request_check(conn, cookie)) {
+    warn("cannot create system tray container window: 0x%x", window_id);
+    return false;
+  }
+
+  tray->container = window_id;
+
+  window_set_class_instance(conn, window_id);
+
+#define TRAY_CONTAINER_WINDOW_NAME APP_NAME "_tray"
+  window_set_name_static(conn, window_id, TRAY_CONTAINER_WINDOW_NAME);
+  auto name = TRAY_CONTAINER_WINDOW_NAME;
+  auto name_len = sizeof(TRAY_CONTAINER_WINDOW_NAME) - 1;
+#undef TRAY_CONTAINER_WINDOW_NAME
+
+  uint8_t mode = XCB_PROP_MODE_REPLACE;
+  auto atoms = &backend->atoms;
+  auto prop = atoms->_NET_WM_NAME;
+  auto type = atoms->UTF8_STRING;
+  xcb_change_property(conn, mode, window_id, prop, type, 8, name_len, name);
+
+  return true;
+}
+
+static bool tray_take_selection_owner(tray_host_t *tray, backend_t *backend) {
+  auto conn = backend->conn;
+  auto atom = tray->selection_atom;
+  auto cookie = xcb_get_selection_owner(conn, atom);
+  auto reply = xcb_get_selection_owner_reply(conn, cookie, nullptr);
+  if (reply && reply->owner != XCB_WINDOW_NONE) {
+    warn(
+      "system tray selection is already owned by window: 0x%x",
+      reply->owner
+    );
+    p_delete(&reply);
+    return false;
+  }
+
+  p_delete(&reply);
+
+  auto owner = tray->container;
+  xcb_set_selection_owner(conn, owner, atom, XCB_CURRENT_TIME);
+
+  cookie = xcb_get_selection_owner(conn, atom);
+  reply = xcb_get_selection_owner_reply(conn, cookie, nullptr);
+  bool success = reply && reply->owner == owner;
+  p_delete(&reply);
+
+  if (!success) warn("cannot acquire system tray selection");
+  return success;
+}
+
+static void tray_broadcast_manager(tray_host_t *tray, backend_t *backend) {
+  auto conn = backend->conn;
+  auto root = backend->screen->root;
+
+  xcb_client_message_event_t event = {
+    .response_type = XCB_CLIENT_MESSAGE,
+    .window = root,
+    .format = 32,
+    .type = backend->atoms.MANAGER,
+    .data.data32 = {
+      [0] = XCB_CURRENT_TIME,
+      [1] = tray->selection_atom,
+      [2] = tray->container,
+    },
+  };
+  uint32_t event_mask = XCB_EVENT_MASK_STRUCTURE_NOTIFY;
+  xcb_send_event(conn, false, root, event_mask, (char *)&event);
+}
+
+void tray_init(backend_t *backend, tray_host_window_t host_window) {
+  auto tray = get_tray_host(backend);
+  if (!tray) {
+    tray = p_new(tray_host_t, 1);
+    backend->tray = tray;
+  }
+
+  if (tray->initialized) return;
+
+  if (!tray_intern_selection_atom(tray, backend)) return;
+
+  if (!tray_create_container_window(tray, backend, host_window)) return;
+  if (!tray_take_selection_owner(tray, backend)) {
+    tray_cleanup(backend);
+    return;
+  }
+
+  tray->enabled = true;
+  tray->initialized = true;
+  tray->host_window = host_window.window;
+  tray->icon_size = host_window.height;
+
+  tray_broadcast_manager(tray, backend);
+  tray_layout_icons(backend, host_window.width);
+  xcb_flush(backend->conn);
+}
+
+void tray_cleanup(backend_t *backend) {
+  auto tray = backend->tray;
+  if (!tray) return;
+
+  for (size_t i = 0; i < tray->icon_count; ++i) {
+    tray_release_icon_window(backend, &tray->icons[i]);
+  }
+  p_delete(&tray->icons);
+  tray->icon_count = 0;
+  tray->icon_capacity = 0;
+
+  auto conn = backend->conn;
+
+  auto atom = tray->selection_atom;
+  if (atom != XCB_ATOM_NONE) {
+    xcb_set_selection_owner(conn, XCB_WINDOW_NONE, atom, XCB_CURRENT_TIME);
+  }
+
+  if (tray->container != XCB_WINDOW_NONE) {
+    xcb_destroy_window(conn, tray->container);
+  }
+
+  p_clear(backend->tray, 1);
+  p_delete(&backend->tray);
+}
+
+static void
+tray_select_icon_events(xcb_connection_t *conn, xcb_window_t window) {
+  xcb_params_cw_t params = {
+    .event_mask =
+      XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_PROPERTY_CHANGE,
+  };
+  uint32_t mask = XCB_CW_EVENT_MASK;
+  xcb_aux_change_window_attributes(conn, window, mask, &params);
+  xcb_clear_area(conn, false, window, 0, 0, 0, 0);
+}
+
+/* reference:
+ * https://specifications.freedesktop.org/xembed/latest-single/#id-1.7.4 */
+typedef struct xembed_message_data_t {
+  uint32_t message; /* message opcode */
+  uint32_t detail;  /* message detail */
+  uint32_t data1;   /* message data 1 */
+  uint32_t data2;   /* message data 2 */
+} xembed_message_data_t;
+
+static void tray_send_xembed_message(
+  backend_t *backend,
+  xcb_window_t window,
+  xembed_message_data_t message
+) {
+  auto conn = backend->conn;
+  auto message_type = backend->atoms._XEMBED;
+
+  xcb_client_message_event_t event = {
+    .response_type = XCB_CLIENT_MESSAGE,
+    .format = 32,
+    .window = window,
+    .type = message_type,
+    .data.data32 = {
+      [0] = XCB_CURRENT_TIME,
+      [1] = message.message,
+      [2] = message.detail,
+      [3] = message.data1,
+      [4] = message.data2,
+    },
+  };
+  uint32_t event_mask = XCB_EVENT_MASK_NO_EVENT;
+  xcb_send_event(conn, false, window, event_mask, (char *)&event);
+}
+
+static void tray_add_icon(backend_t *backend, xcb_window_t window) {
+  if (window == XCB_WINDOW_NONE) return;
+
+  auto tray = get_tray_host(backend);
+  if (!tray || !tray->initialized || tray_get_icon(tray, window)) return;
+
+  rect_t geometry = {0};
+  if (!window_get_geometry(backend, window, &geometry)) return;
+
+  auto icon = array_push(tray->icons, tray->icon_count, tray->icon_capacity);
+  *icon = (tray_icon_t){
+    .window = window,
+    .natural_width = geometry.width,
+    .natural_height = geometry.height,
+  };
+
+  auto conn = backend->conn;
+  auto container = tray->container;
+  xembed_message_data_t message = {
+    .message = XEMBED_EMBEDDED_NOTIFY,
+    .detail = 0,
+    .data1 = container,
+    .data2 = XEMBED_VERSION,
+  };
+  xcb_change_save_set(conn, XCB_SET_MODE_INSERT, window);
+  xcb_reparent_window(conn, window, tray->container, 0, 0);
+  tray_select_icon_events(conn, window);
+  tray_send_xembed_message(backend, window, message);
+  xcb_map_window(conn, window);
+  tray_dispatch_callback(tray);
+}
+
+bool tray_handle_client_message(
+  backend_t *backend,
+  const xcb_client_message_event_t *ev
+) {
+  auto tray = get_tray_host(backend);
+  if (!tray || !tray->enabled || !tray->initialized) return false;
+  if (ev->window != tray->container && ev->window != backend->screen->root) {
+    return false;
+  }
+
+  auto opcode = ev->data.data32[1];
+  switch (opcode) {
+  case SYSTEM_TRAY_REQUEST_DOCK:
+    auto window = ev->data.data32[2];
+    tray_add_icon(backend, window);
+    break;
+  case SYSTEM_TRAY_BEGIN_MESSAGE:
+  case SYSTEM_TRAY_CANCEL_MESSAGE:
+  default:
+    break;
+  }
+
+  xcb_flush(backend->conn);
+
+  return true;
+}
+
+bool tray_handle_configure_request(
+  backend_t *backend,
+  const xcb_configure_request_event_t *ev
+) {
+  auto tray = get_tray_host(backend);
+  if (!tray || !tray->initialized) return false;
+
+  if (ev->window == tray->container) {
+    tray_dispatch_callback(tray);
+    return true;
+  }
+
+  auto icon = tray_get_icon(tray, ev->window);
+  if (!icon) return false;
+
+  if ((ev->value_mask & XCB_CONFIG_WINDOW_WIDTH) && ev->width > 0) {
+    icon->natural_width = (int32_t)ev->width;
+  }
+  if ((ev->value_mask & XCB_CONFIG_WINDOW_HEIGHT) && ev->height > 0) {
+    icon->natural_height = (int32_t)ev->height;
+  }
+
+  tray_dispatch_callback(tray);
+  return true;
+}
+
+bool tray_handle_map_request(
+  backend_t *backend,
+  const xcb_map_request_event_t *ev
+) {
+  auto tray = get_tray_host(backend);
+  if (!tray || !tray->initialized) return false;
+
+  auto conn = backend->conn;
+  if (ev->window == tray->container) {
+    tray_dispatch_callback(tray);
+    return true;
+  }
+
+  auto icon = tray_get_icon(tray, ev->window);
+  if (!icon && ev->parent != tray->container) return false;
+
+  xcb_map_window(conn, ev->window);
+  xcb_flush(conn);
+
+  tray_dispatch_callback(tray);
+  return true;
+}
+
+bool tray_handle_property_notify(
+  backend_t *backend,
+  const xcb_property_notify_event_t *ev
+) {
+  auto tray = get_tray_host(backend);
+  if (!tray || !tray->initialized) return false;
+
+  if (ev->window == XCB_WINDOW_NONE) return false;
+  if (ev->window == tray->container) return true;
+  return tray_get_icon(tray, ev->window) != nullptr;
+}
+
+bool tray_handle_unmap_notify(
+  backend_t *backend,
+  const xcb_unmap_notify_event_t *ev
+) {
+  auto tray = get_tray_host(backend);
+  if (!tray || !tray->initialized) return false;
+
+  auto index = tray_find_icon(tray, ev->window);
+  if (index == SIZE_MAX) return ev->window == tray->container;
+
+  tray_remove_icon_by_index(backend, index, true);
+  return true;
+}
+
+bool tray_handle_destroy_notify(
+  backend_t *backend,
+  const xcb_destroy_notify_event_t *ev
+) {
+  auto tray = get_tray_host(backend);
+  if (!tray || !tray->initialized) return false;
+
+  if (ev->window == tray->container) {
+    tray_cleanup(backend);
+    return true;
+  }
+
+  auto index = tray_find_icon(tray, ev->window);
+  if (index == SIZE_MAX) return false;
+
+  tray_remove_icon_by_index(backend, index, false);
+  return true;
+}

src/backend/x11/tray.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <stdint.h>
+#include <xcb/xproto.h>
+
+#include "interface/tray.h"
+
+extern const tray_api_t tray_api;
+
+typedef struct backend_t backend_t;
+
+typedef struct tray_host_window_t {
+  xcb_window_t window;
+  int32_t width;
+  int32_t height;
+  uint32_t bg_pixel;
+} tray_host_window_t;
+
+void tray_init(backend_t *backend, tray_host_window_t host_window);
+void tray_cleanup(backend_t *backend);
+
+bool tray_handle_client_message(
+  backend_t *backend,
+  const xcb_client_message_event_t *ev
+);
+bool tray_handle_configure_request(
+  backend_t *backend,
+  const xcb_configure_request_event_t *ev
+);
+bool tray_handle_map_request(
+  backend_t *backend,
+  const xcb_map_request_event_t *ev
+);
+bool tray_handle_property_notify(
+  backend_t *backend,
+  const xcb_property_notify_event_t *ev
+);
+bool tray_handle_unmap_notify(
+  backend_t *backend,
+  const xcb_unmap_notify_event_t *ev
+);
+bool tray_handle_destroy_notify(
+  backend_t *backend,
+  const xcb_destroy_notify_event_t *ev
+);

src/backend/x11/window.c

@@ -12,8 +12,6 @@
 #include "backend/x11/cursor.h"
 #include "base/macros.h"
 #include "base/memory.h"
-#include "core/backend.h"
-#include "core/types.h"
 #include "internal.h"
 
 static char *window_get_text_property(
@@ -38,10 +36,12 @@ static char *window_get_text_property(
   char *value = (char *)xcb_get_property_value(reply);
 
   char *text = nullptr;
-  if (length && reply->format == 8 &&
+  if (
+    length && reply->format == 8 &&
     (reply->type == XCB_ATOM_STRING ||
      reply->type == backend->atoms.UTF8_STRING ||
-       reply->type == backend->atoms.COMPOUND_TEXT)) {
+     reply->type == backend->atoms.COMPOUND_TEXT)
+  ) {
     text = p_strndup(value, (size_t)length);
   }
 

src/backend/x11/window.h

@@ -8,7 +8,7 @@
 #include <xcb/xproto.h>
 
 #include "base/app.h"
-#include "core/backend.h"
+#include "interface/backend.h"
 #include "internal.h"
 
 typedef struct atoms_t atoms_t;

src/bar/bar.c

@@ -12,6 +12,7 @@
 #include "bar/binding.h"
 #include "bar/cell.h"
 #include "bar/text.h"
+#include "bar/tray.h"
 #include "bar/types.h"
 #include "bar/windows.h"
 #include "bar/workspaces.h"
@@ -20,7 +21,6 @@
 #include "base/macros.h"
 #include "base/memory.h"
 #include "base/time.h"
-#include "core/listeners.h"
 
 static zdwm_bar_item_t *bar_add_item(
   zdwm_output_id_t output_id,
@@ -131,9 +131,14 @@ static void bar_output_add_windows(
   bar_windows_add_listeners(listeners, item->state);
 }
 
+static inline void bar_output_add_tray(bar_output_t *bar_output, tray_t *tray) {
+  bar_add_item(bar_output->output_id, &bar_output->right, bar_tray, tray);
+}
+
 void bar_init(bar_t *bar, listeners_t *listeners) {
   auto c = &bar->config;
   bar->ctx = text_context_create(c->font_family, c->font_size, c->dpi);
+  auto tray = &bar->tray;
 
   for (size_t i = 0; i < bar->count; ++i) {
     auto bar_output = &bar->bars[i];
@@ -142,6 +147,10 @@ void bar_init(bar_t *bar, listeners_t *listeners) {
     bar_output_add_workspace(bar_output, &bar->config, listeners);
     bar_output_add_binding(bar_output, &bar->config, listeners);
     bar_output_add_windows(bar_output, &bar->config, listeners);
+
+    if (tray->api.host_window(tray->handle) == bar_output->window_id) {
+      bar_output_add_tray(bar_output, &bar->tray);
+    }
   }
 
   bar->timerfd = time_create_monotonic_timerfd_by_fps(bar->config.fps);
@@ -213,14 +222,16 @@ static void bar_output_layout(bar_output_t *bar_output, text_context_t *ctx) {
     item->region.start = start;
     for (size_t j = 0; j < item->count; ++j) {
       auto cell = &item->cells[j];
+      auto fixed_width = cell->fixed_width;
 
+      bar_x_region_t region = {.start = start, .end = start};
+      if (fixed_width == 0) {
         int32_t width = 0;
         text_context_get_text_size(ctx, cell->text, &width, nullptr);
-
+        region.end += width + 2 * item->cell_padding;
-      bar_x_region_t region = {
+      } else if (fixed_width > 0) {
-        .start = start,
+        region.end += fixed_width;
-        .end   = start + width + item->cell_padding * 2,
+      }
-      };
       bar_cell_set_region(item, j, region);
 
       start = region.end;
@@ -241,14 +252,16 @@ static void bar_output_layout(bar_output_t *bar_output, text_context_t *ctx) {
     for (size_t j = item->count; j > 0; --j) {
       auto cell_index = j - 1;
       auto cell = &item->cells[cell_index];
+      auto fixed_width = cell->fixed_width;
 
+      bar_x_region_t region = {.start = end, .end = end};
+      if (fixed_width == 0) {
         int32_t width = 0;
         text_context_get_text_size(ctx, cell->text, &width, nullptr);
-
+        region.start -= width + item->cell_padding * 2;
-      bar_x_region_t region = {
+      } else if (fixed_width > 0) {
-        .start = end - width - item->cell_padding * 2,
+        region.start -= fixed_width;
-        .end   = end,
+      }
-      };
       bar_cell_set_region(item, cell_index, region);
 
       end = region.start;
@@ -264,12 +277,30 @@ static void bar_output_layout(bar_output_t *bar_output, text_context_t *ctx) {
   if (center->count == 0) return;
   center->region = (bar_x_region_t){.start = start, .end = end};
 
-  auto width = (end - start) / (int32_t)center->count;
+  auto center_width = end - start;
+  auto center_count = center->count;
   for (size_t i = 0; i < center->count; ++i) {
-    bar_x_region_t region = {
+    auto cell = &center->cells[i];
-      .start = start,
+    auto fixed_width = cell->fixed_width;
-      .end   = start + width + center->cell_padding * 2,
+    if (fixed_width > 0) {
-    };
+      center_width -= fixed_width;
+    } else if (fixed_width < 0) {
+      /* 隐藏的 cell 不占任何空间，平分宽度时不参与 */
+      --center_count;
+    }
+  }
+
+  auto width = center_width / (int32_t)center_count;
+  for (size_t i = 0; i < center->count; ++i) {
+    auto cell = &center->cells[i];
+    auto fixed_width = cell->fixed_width;
+
+    bar_x_region_t region = {.start = start, .end = start};
+    if (fixed_width == 0) {
+      region.end += width + center->cell_padding * 2;
+    } else if (fixed_width > 0) {
+      region.end += fixed_width;
+    }
     start = region.end;
     bar_cell_set_region(center, i, region);
   }
@@ -387,6 +418,42 @@ bar_output_draw(bar_output_t *bar_output, text_context_t *ctx, color_t *bg) {
   bar_item_draw(cr, &bar_output->center, ctx, bar_output->height);
 }
 
+static inline void bar_item_run_hook(
+  zdwm_bar_item_t *item,
+  void (*hook)(const zdwm_bar_item_hook_params_t *params)
+) {
+  if (!hook) return;
+
+  zdwm_bar_item_hook_params_t params = {
+    .item = item,
+    .cell_api = &bar_cell_api,
+    .region = item->region,
+    .state = item->state
+  };
+  hook(&params);
+}
+
+static void visitor_after_layout(zdwm_bar_item_t *item) {
+  bar_item_run_hook(item, item->api.after_layout);
+}
+
+static void visitor_after_draw(zdwm_bar_item_t *item) {
+  bar_item_run_hook(item, item->api.after_draw);
+}
+
+typedef void (*bar_item_visitor_t)(zdwm_bar_item_t *item);
+
+static void
+bar_output_foreach_item(bar_output_t *bar_output, bar_item_visitor_t visit) {
+  for (size_t i = 0; i < bar_output->left.count; ++i) {
+    visit(&bar_output->left.items[i]);
+  }
+  visit(&bar_output->center);
+  for (size_t i = 0; i < bar_output->right.count; ++i) {
+    visit(&bar_output->right.items[i]);
+  }
+}
+
 bool bar_draw(bar_t *bar) {
   auto ctx = bar->ctx;
 
@@ -397,15 +464,21 @@ bool bar_draw(bar_t *bar) {
     if (!bar_output_is_dirty(bar_output)) continue;
 
     bar_output_layout(bar_output, ctx);
+    bar_output_foreach_item(bar_output, visitor_after_layout);
     bar_output_draw(bar_output, ctx, &bar->palette.bg);
+    bar_output_foreach_item(bar_output, visitor_after_draw);
     changed = true;
   }
 
   return changed;
 }
 
-static inline bool
+static inline bool bar_item_click(
-bar_item_click(zdwm_bar_item_t *item, int32_t x, zdwm_action_t *action) {
+  zdwm_bar_item_t *item,
+  bar_click_info_t info,
+  zdwm_action_t *action
+) {
+  auto x = info.x;
   if (!(item->region.start <= x && item->region.end >= x)) return false;
 
   if (!item->api.on_click) return true;
@@ -413,7 +486,15 @@ bar_item_click(zdwm_bar_item_t *item, int32_t x, zdwm_action_t *action) {
   for (size_t i = 0; i < item->count; ++i) {
     auto cell = &item->cells[i];
     if (cell->region.start <= x && cell->region.end >= x) {
-      *action = item->api.on_click(item, i, x, item->state);
+      zdwm_bar_click_params_t params = {
+        .item = item,
+        .cell_index = i,
+        .x = x,
+        .modifiers = info.modifiers,
+        .button = info.button,
+        .state = item->state,
+      };
+      *action = item->api.on_click(&params);
       return true;
     }
   }
@@ -422,29 +503,24 @@ bar_item_click(zdwm_bar_item_t *item, int32_t x, zdwm_action_t *action) {
 }
 
 static inline bool
-bar_side_click(bar_side_t *side, int32_t x, zdwm_action_t *action) {
+bar_side_click(bar_side_t *side, bar_click_info_t info, zdwm_action_t *action) {
-  if (side->region.start > x || side->region.end < x) return false;
+  if (side->region.start > info.x || side->region.end < info.x) return false;
 
   for (size_t i = 0; i < side->count; ++i) {
-    if (bar_item_click(&side->items[i], x, action)) return true;
+    if (bar_item_click(&side->items[i], info, action)) return true;
   }
 
   return true;
 }
 
-bool bar_click(
+bool bar_click(bar_t *bar, bar_click_info_t info, zdwm_action_t *action) {
-  bar_t *bar,
-  zdwm_window_id_t window,
-  int32_t x,
-  zdwm_action_t *action
-) {
   for (size_t i = 0; i < bar->count; ++i) {
     auto bar_output = &bar->bars[i];
-    if (bar_output->window_id != window) continue;
+    if (bar_output->window_id != info.window) continue;
 
-    if (bar_side_click(&bar_output->left, x, action)) return true;
+    if (bar_side_click(&bar_output->left, info, action)) return true;
-    if (bar_item_click(&bar_output->center, x, action)) return true;
+    if (bar_item_click(&bar_output->center, info, action)) return true;
-    if (bar_side_click(&bar_output->right, x, action)) return true;
+    if (bar_side_click(&bar_output->right, info, action)) return true;
   }
 
   return false;

src/bar/bar.h

@@ -10,7 +10,8 @@
 #include "bar/text.h"
 #include "bar/types.h"
 #include "base/color.h"
-#include "core/listeners.h"
+#include "common/listeners.h"
+#include "interface/tray.h"
 
 typedef struct bar_output_t {
   cairo_t *cr;
@@ -37,15 +38,18 @@ typedef struct bar_t {
   zdwm_bar_config_t config;
   bar_palette_t palette;
   text_context_t *ctx;
+  tray_t tray;
 } bar_t;
 
 void bar_init(bar_t *bar, listeners_t *listeners);
 void bar_cleanup(bar_t *bar);
 void bar_update(bar_t *bar);
 bool bar_draw(bar_t *bar);
-bool bar_click(
+
-  bar_t *bar,
+typedef struct bar_click_info_t {
-  zdwm_window_id_t window,
+  zdwm_window_id_t window;
-  int32_t x,
+  int32_t x;
-  zdwm_action_t *action
+  zdwm_modifier_mask_t modifiers;
-);
+  zdwm_button_t button;
+} bar_click_info_t;
+bool bar_click(bar_t *bar, bar_click_info_t info, zdwm_action_t *action);

src/bar/binding.c

@@ -9,7 +9,7 @@
 #include <zdwm/types.h>
 
 #include "base/memory.h"
-#include "core/listeners.h"
+#include "common/listeners.h"
 
 typedef struct bar_binding_state_t {
   zdwm_binding_mode_notify_t mode;
@@ -55,12 +55,7 @@ static void bar_binding_update(
   data->dirty = false;
 }
 
-static zdwm_action_t bar_binding_on_click(
+static zdwm_action_t bar_binding_on_click(zdwm_bar_click_params_t *params) {
-  zdwm_bar_item_t *item,
-  size_t cell_index,
-  int32_t x,
-  void *state
-) {
   return (zdwm_action_t){
     .type = ZDWM_ACTION_BINDING_MODE_CYCLE,
     .as.binding_mode_cycle = {.delta = 1},

src/bar/binding.h

@@ -3,7 +3,7 @@
 #include <stdint.h>
 #include <zdwm/bar.h>
 
-#include "core/listeners.h"
+#include "common/listeners.h"
 
 typedef struct bar_binding_config_t {
   bool show_default;

src/bar/cell.c

@@ -2,6 +2,7 @@
 
 #include <assert.h>
 #include <stddef.h>
+#include <stdint.h>
 #include <string.h>
 #include <strings.h>
 #include <zdwm/types.h>
@@ -84,13 +85,17 @@ bar_cell_set_icon(zdwm_bar_item_t *item, size_t index, zdwm_icon_t icon) {
   if (icon_ptr->type == icon.type) {
     switch (icon.type) {
     case ZDWM_ICON_TEXT:
-      if (icon_ptr->as.text == icon.as.text ||
+      if (
-          strcmp(icon_ptr->as.text, icon.as.text) == 0) {
+        icon_ptr->as.text == icon.as.text ||
+        strcmp(icon_ptr->as.text, icon.as.text) == 0
+      ) {
         return;
       }
     case ZDWM_ICON_IMAGE:
-      if (icon_ptr->as.image_path == icon.as.image_path ||
+      if (
-          strcmp(icon_ptr->as.image_path, icon.as.image_path) == 0) {
+        icon_ptr->as.image_path == icon.as.image_path ||
+        strcmp(icon_ptr->as.image_path, icon.as.image_path) == 0
+      ) {
         return;
       }
     }
@@ -115,7 +120,28 @@ bar_cell_set_indicator(zdwm_bar_item_t *item, size_t index, bool show) {
   item->dirty = true;
 }
 
-zdwm_bar_cell_api_t bar_cell_api = {
+static void
+bar_cell_set_fixed_width(zdwm_bar_item_t *item, size_t index, int32_t width) {
+  if (index >= item->count) return;
+
+  auto cell = &item->cells[index];
+  if (cell->fixed_width == width) return;
+
+  cell->fixed_width = width;
+
+  cell->dirty = true;
+  item->dirty = true;
+}
+
+static bar_x_region_t bar_cell_get_region(zdwm_bar_item_t *item, size_t index) {
+  if (index >= item->count) return (bar_x_region_t){0};
+
+  auto cell = &item->cells[index];
+  return cell->region;
+}
+
+/* clang-format off */
+const zdwm_bar_cell_api_t bar_cell_api = {
   .get_cell_count       = bar_cell_get_count,
   .set_cell_count       = bar_cell_set_count,
   .cell_set_text        = bar_cell_set_text,
@@ -123,7 +149,10 @@ zdwm_bar_cell_api_t bar_cell_api = {
   .cell_set_fg          = bar_cell_set_fg,
   .cell_set_icon        = bar_cell_set_icon,
   .cell_set_indicator   = bar_cell_set_indicator,
+  .cell_set_fixed_width = bar_cell_set_fixed_width,
+  .cell_get_region      = bar_cell_get_region,
 };
+/* clang-format on */
 
 void bar_cell_set_region(
   zdwm_bar_item_t *item,

src/bar/cell.h

@@ -12,4 +12,4 @@ void bar_cell_set_region(
   bar_x_region_t region
 );
 
-extern zdwm_bar_cell_api_t bar_cell_api;
+extern const zdwm_bar_cell_api_t bar_cell_api;

src/bar/tray.c

@@ -0,0 +1,78 @@
+#include "bar/tray.h"
+
+#include <assert.h>
+#include <stddef.h>
+#include <zdwm/bar.h>
+#include <zdwm/types.h>
+
+#include "base/memory.h"
+#include "interface/tray.h"
+
+typedef struct bar_tray_state_t {
+  tray_t tray;
+  bool dirty;
+} bar_tray_state_t;
+
+static void bar_tray_icons_changed(void *user_data) {
+  bar_tray_state_t *state = user_data;
+  state->dirty = true;
+}
+
+static void *bar_tray_create_state(zdwm_output_id_t output_id, void *config) {
+  tray_t *tray = config;
+  assert(tray != nullptr);
+
+  auto state = p_new(bar_tray_state_t, 1);
+  state->tray = *tray;
+  tray->api.set_listener(tray->handle, bar_tray_icons_changed, state);
+
+  return state;
+}
+
+static void bar_tray_update(
+  zdwm_bar_item_t *item,
+  const zdwm_bar_cell_api_t *cell_api,
+  void *state
+) {
+  bar_tray_state_t *data = state;
+  if (!data->dirty) return;
+
+  auto tray_handle = data->tray.handle;
+  auto tray_api = &data->tray.api;
+  auto icon_count = tray_api->icon_count(tray_handle);
+  auto cell_count = cell_api->get_cell_count(item);
+  if (cell_count == icon_count) {
+    data->dirty = false;
+    return;
+  }
+
+  cell_api->set_cell_count(item, icon_count);
+  auto cell_width = tray_api->icon_size(tray_handle);
+  for (size_t i = 0; i < icon_count; ++i) {
+    cell_api->cell_set_fixed_width(item, i, cell_width);
+  }
+
+  data->dirty = false;
+}
+
+static void bar_tray_after_layout(const zdwm_bar_item_hook_params_t *params) {
+  bar_tray_state_t *state = params->state;
+  auto tray_handle = state->tray.handle;
+  auto tray_api = &state->tray.api;
+  tray_api->place(tray_handle, params->region.start);
+}
+
+static void bar_tray_destroy_state(void *state) {
+  if (!state) return;
+
+  bar_tray_state_t *data = state;
+  p_delete(&data);
+}
+
+zdwm_bar_item_type_t bar_tray = {
+  .create_state = bar_tray_create_state,
+  .update = bar_tray_update,
+  .after_layout = bar_tray_after_layout,
+  .destroy_state = bar_tray_destroy_state,
+  .update_interval_ms = 0,
+};

src/bar/tray.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <zdwm/bar.h>
+
+extern zdwm_bar_item_type_t bar_tray;

src/bar/types.h

@@ -7,10 +7,7 @@
 
 #include "base/color.h"
 
-typedef struct bar_x_region_t {
+typedef struct zdwm_bar_x_region_t bar_x_region_t;
-  int32_t start;
-  int32_t end;
-} bar_x_region_t;
 
 typedef struct bar_cell_t {
   zdwm_icon_t icon;
@@ -20,6 +17,7 @@ typedef struct bar_cell_t {
   color_t fg;
   color_t bg;
   bar_x_region_t region;
+  int32_t fixed_width;
   bool show_indicator;
   bool dirty;
 } bar_cell_t;

src/bar/windows.c

@@ -8,7 +8,7 @@
 
 #include "base/array.h"
 #include "base/memory.h"
-#include "core/listeners.h"
+#include "common/listeners.h"
 
 typedef struct bar_windows_state_t {
   zdwm_output_id_t output_id;

src/bar/windows.h

@@ -3,7 +3,7 @@
 #include <stdint.h>
 #include <zdwm/bar.h>
 
-#include "core/listeners.h"
+#include "common/listeners.h"
 
 typedef struct bar_windows_config_t {
   uint32_t cell_padding;

src/bar/workspaces.c

@@ -10,7 +10,7 @@
 
 #include "base/array.h"
 #include "base/memory.h"
-#include "core/listeners.h"
+#include "common/listeners.h"
 
 typedef struct bar_workspace_t {
   zdwm_workspace_t info;
@@ -143,13 +143,10 @@ static void bar_workspaces_update(
   data->dirty = false;
 }
 
-static zdwm_action_t bar_workspace_on_click(
+static zdwm_action_t bar_workspace_on_click(zdwm_bar_click_params_t *params) {
-  zdwm_bar_item_t *item,
+  auto cell_index = params->cell_index;
-  size_t cell_index,
+  auto data = (bar_workspace_state_t *)params->state;
-  int32_t x,
+
-  void *state
-) {
-  auto data = (bar_workspace_state_t *)state;
   if (cell_index == data->count) {
     return (zdwm_action_t){
       .type = ZDWM_ACTION_LAYOUT_CYCLE,

src/bar/workspaces.h

@@ -3,7 +3,7 @@
 #include <stdint.h>
 #include <zdwm/bar.h>
 
-#include "core/listeners.h"
+#include "common/listeners.h"
 
 typedef struct bar_workspace_config_t {
   uint32_t cell_padding;

src/base/array.h

@@ -98,11 +98,11 @@ array_erase_impl(void *items, size_t item_size, size_t *count, size_t index) {
 #define array_reserve(items, capacity, need) \
   array_reserve_impl((void **)&(items), sizeof(*(items)), &(capacity), (need))
 
+/* clang-format off */
 /** @brief 为具体类型数组追加一个槽位。 */
 #define array_push(items, count, capacity)\
-  (                                        \
+(typeof(items))array_push_impl((void **)&(items), sizeof(*(items)), &(count), &(capacity))
-    typeof(items)                          \
+/* clang-format on */
-  )array_push_impl((void **)&(items), sizeof(*(items)), &(count), &(capacity))
 
 /** @brief 删除具体类型数组中指定下标的元素。 */
 #define array_erase(items, count, index) \

src/base/color.c

@@ -56,7 +56,7 @@ bool hex_color_to_rgba(const char *hex, uint32_t *rgba) {
 
   size_t len = strlen(hex);
   char extended[9] = {0};
-  uint32_t color   = 0x00000000;
+  uint32_t color = 0x00'00'00'00;
 
   if (len == 3 || len == 4) {
     extended[0] = extended[1] = hex[0];
@@ -76,7 +76,7 @@ bool hex_color_to_rgba(const char *hex, uint32_t *rgba) {
     return false;
   }
 
-  color = strtoul(extended, nullptr, 16) & 0xffffffff;
+  color = strtoul(extended, nullptr, 16) & 0xff'ff'ff'ff;
   *rgba = color;
   return true;
 }

src/base/time.c

@@ -1,7 +1,5 @@
 #include "base/time.h"
 
-#include <bits/time.h>
-#include <bits/types/struct_itimerspec.h>
 #include <errno.h>
 #include <stdint.h>
 #include <string.h>

src/base/window_list.c

@@ -1,26 +0,0 @@
-#include "base/window_list.h"
-
-#include <zdwm/types.h>
-
-#include "base/array.h"
-#include "base/memory.h"
-
-void window_list_push(
-  window_list_t *window_list,
-  zdwm_window_id_t window_id
-) {
-  zdwm_window_id_t *window =
-    array_push(window_list->windows, window_list->count, window_list->capacity);
-  *window = window_id;
-}
-
-void window_list_reset(window_list_t *window_list) {
-  p_clear(window_list->windows, window_list->capacity);
-  window_list->count = 0;
-}
-
-void window_list_cleanup(window_list_t *window_list) {
-  p_delete(&window_list->windows);
-  window_list->count    = 0;
-  window_list->capacity = 0;
-}

src/common/event.c

@@ -1,7 +1,7 @@
-#include "core/event.h"
+#include "interface/event.h"
 
 #include "base/memory.h"
-#include "core/window.h"
+#include "common/window.h"
 
 void event_cleanup(event_t *event) {
   if (!event || event->type == ZDWM_EVENT_NONE) return;

src/common/event.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include "interface/event.h"
+
+void event_cleanup(event_t *event);
+void event_reset(event_t *event);

src/common/listeners.c

@@ -0,0 +1,107 @@
+#include "common/listeners.h"
+
+#include <zdwm/listeners.h>
+
+#include "base/array.h"
+#include "base/memory.h"
+
+#define ADD_LISTENER(FIELD)                                         \
+  auto list = &listeners->FIELD;                                    \
+  auto item = array_push(list->items, list->count, list->capacity); \
+  item->fn = fn;                                                    \
+  item->user_data = user_data
+
+void listeners_add_output_listener(
+  listeners_t *listeners,
+  zdwm_current_output_id_listener fn,
+  void *user_data
+) {
+  ADD_LISTENER(output_listeners);
+}
+
+void listeners_add_initial_workspace_listener(
+  listeners_t *listeners,
+  zdwm_initial_workspace_list fn,
+  void *user_data
+) {
+  ADD_LISTENER(initial_workspace_listeners);
+}
+
+void listeners_add_active_workspace_listener(
+  listeners_t *listeners,
+  zdwm_workspace_active_updated fn,
+  void *user_data
+) {
+  ADD_LISTENER(active_workspace_listeners);
+}
+
+void listeners_add_layout_notify(
+  listeners_t *listeners,
+  zdwm_layout_notify fn,
+  void *user_data
+) {
+  ADD_LISTENER(layout_listeners);
+}
+
+void listeners_add_binding_mode_notify(
+  listeners_t *listeners,
+  zdwm_binding_mode_notify fn,
+  void *user_data
+) {
+  ADD_LISTENER(binding_mode_listeners);
+}
+
+void listeners_add_initial_window_listener(
+  listeners_t *listeners,
+  zdwm_initial_window_list fn,
+  void *user_data
+) {
+  ADD_LISTENER(initial_window_listeners);
+}
+
+void listeners_add_window_added_listener(
+  listeners_t *listeners,
+  zdwm_window_added fn,
+  void *user_data
+) {
+  ADD_LISTENER(window_added_listeners);
+}
+
+void listeners_add_window_updated_listener(
+  listeners_t *listeners,
+  zdwm_window_updated fn,
+  void *user_data
+) {
+  ADD_LISTENER(window_updated_listeners);
+}
+
+void listeners_add_window_removed_listener(
+  listeners_t *listeners,
+  zdwm_window_removed fn,
+  void *user_data
+) {
+  ADD_LISTENER(window_removed_listeners);
+}
+
+#undef ADD_LISTENER
+
+#define CLEANUP_LIST(FIELD)          \
+  p_delete(&listeners->FIELD.items); \
+  listeners->FIELD.count = 0;        \
+  listeners->FIELD.capacity = 0
+
+void listeners_cleanup(listeners_t *listeners) {
+  if (!listeners) return;
+
+  CLEANUP_LIST(output_listeners);
+  CLEANUP_LIST(initial_workspace_listeners);
+  CLEANUP_LIST(active_workspace_listeners);
+  CLEANUP_LIST(layout_listeners);
+  CLEANUP_LIST(binding_mode_listeners);
+  CLEANUP_LIST(initial_window_listeners);
+  CLEANUP_LIST(window_added_listeners);
+  CLEANUP_LIST(window_updated_listeners);
+  CLEANUP_LIST(window_removed_listeners);
+}
+
+#undef CLEANUP_LIST

src/common/listeners.h

@@ -0,0 +1,94 @@
+#pragma once
+
+#include <zdwm/listeners.h>
+
+typedef struct binding_table_t binding_table_t;
+typedef struct layout_registry_t layout_registry_t;
+typedef struct state_t state_t;
+
+#define ITEM(NAME, FN_TYPE)               \
+  typedef struct NAME##_listener_item_t { \
+    FN_TYPE *fn;                          \
+    void *user_data;                      \
+  } NAME##_listener_item_t
+
+#define LISTENERS(NAME, FN_TYPE)      \
+  ITEM(NAME, FN_TYPE);                \
+  typedef struct NAME##_listeners_t { \
+    NAME##_listener_item_t *items;    \
+    size_t count;                     \
+    size_t capacity;                  \
+  } NAME##_listeners_t
+
+LISTENERS(output, zdwm_current_output_id_listener);
+LISTENERS(initial_workspace_list, zdwm_initial_workspace_list);
+LISTENERS(workspace_active, zdwm_workspace_active_updated);
+LISTENERS(layout, zdwm_layout_notify);
+LISTENERS(binding_mode, zdwm_binding_mode_notify);
+LISTENERS(initial_window_list, zdwm_initial_window_list);
+LISTENERS(window_added, zdwm_window_added);
+LISTENERS(window_updated, zdwm_window_updated);
+LISTENERS(window_removed, zdwm_window_removed);
+
+#undef ITEM
+#undef LISTENERS
+
+typedef struct listeners_t {
+  output_listeners_t output_listeners;
+  initial_workspace_list_listeners_t initial_workspace_listeners;
+  workspace_active_listeners_t active_workspace_listeners;
+  layout_listeners_t layout_listeners;
+  binding_mode_listeners_t binding_mode_listeners;
+  initial_window_list_listeners_t initial_window_listeners;
+  window_added_listeners_t window_added_listeners;
+  window_updated_listeners_t window_updated_listeners;
+  window_removed_listeners_t window_removed_listeners;
+} listeners_t;
+
+void listeners_add_output_listener(
+  listeners_t *listeners,
+  zdwm_current_output_id_listener fn,
+  void *user_data
+);
+void listeners_add_initial_workspace_listener(
+  listeners_t *listeners,
+  zdwm_initial_workspace_list fn,
+  void *user_data
+);
+void listeners_add_active_workspace_listener(
+  listeners_t *listeners,
+  zdwm_workspace_active_updated fn,
+  void *user_data
+);
+void listeners_add_layout_notify(
+  listeners_t *listeners,
+  zdwm_layout_notify fn,
+  void *user_data
+);
+void listeners_add_binding_mode_notify(
+  listeners_t *listeners,
+  zdwm_binding_mode_notify fn,
+  void *user_data
+);
+void listeners_add_initial_window_listener(
+  listeners_t *listeners,
+  zdwm_initial_window_list fn,
+  void *user_data
+);
+void listeners_add_window_added_listener(
+  listeners_t *listeners,
+  zdwm_window_added fn,
+  void *user_data
+);
+void listeners_add_window_updated_listener(
+  listeners_t *listeners,
+  zdwm_window_updated fn,
+  void *user_data
+);
+void listeners_add_window_removed_listener(
+  listeners_t *listeners,
+  zdwm_window_removed fn,
+  void *user_data
+);
+
+void listeners_cleanup(listeners_t *listeners);

src/common/window.c

@@ -0,0 +1,55 @@
+#include "common/window.h"
+
+#include "base/array.h"
+#include "base/memory.h"
+#include "interface/types.h"
+
+window_layer_type_t window_classify_layer(const window_layer_props_t *props) {
+  for (size_t i = 0; i < props->type_count; ++i) {
+    window_type_t type = props->types[i];
+    if (type == ZDWM_WINDOW_TYPE_NOTIFICATION) return ZDWM_WINDOW_LAYER_OVERLAY;
+  }
+
+  for (size_t i = 0; i < props->state_count; ++i) {
+    window_state_t state = props->states[i];
+    if (state == ZDWM_WINDOW_STATE_ABOVE) return ZDWM_WINDOW_LAYER_TOP;
+  }
+
+  return ZDWM_WINDOW_LAYER_NORMAL;
+}
+
+void window_layer_props_cleanup(window_layer_props_t *props) {
+  if (!props) return;
+
+  p_delete(&props->types);
+  props->type_count = 0;
+  p_delete(&props->states);
+  props->state_count = 0;
+}
+
+void window_metadata_cleanup(window_metadata_t *metadata) {
+  if (!metadata) return;
+
+  p_delete(&metadata->title);
+  p_delete(&metadata->app_id);
+  p_delete(&metadata->role);
+  p_delete(&metadata->class_name);
+  p_delete(&metadata->instance_name);
+}
+
+void window_list_push(window_list_t *window_list, zdwm_window_id_t window_id) {
+  zdwm_window_id_t *window =
+    array_push(window_list->windows, window_list->count, window_list->capacity);
+  *window = window_id;
+}
+
+void window_list_reset(window_list_t *window_list) {
+  p_clear(window_list->windows, window_list->capacity);
+  window_list->count = 0;
+}
+
+void window_list_cleanup(window_list_t *window_list) {
+  p_delete(&window_list->windows);
+  window_list->count = 0;
+  window_list->capacity = 0;
+}

src/common/window.h

@@ -1,7 +1,10 @@
 #pragma once
 
-#include <stddef.h>
+#include "interface/types.h"
-#include <zdwm/types.h>
+
+window_layer_type_t window_classify_layer(const window_layer_props_t *props);
+void window_layer_props_cleanup(window_layer_props_t *props);
+void window_metadata_cleanup(window_metadata_t *metadata);
 
 typedef struct window_list_t {
   zdwm_window_id_t *windows;

src/common/workspace.c

@@ -0,0 +1,46 @@
+#include "common/workspace.h"
+
+#include "base/memory.h"
+
+void workspace_desc_cleanup(workspace_desc_t *workspace) {
+  if (!workspace) return;
+
+  p_delete(&workspace->name);
+  p_delete(&workspace->layout_ids);
+  workspace->output_index = 0;
+  workspace->layout_count = 0;
+  workspace->initial_layout_id = ZDWM_LAYOUT_ID_INVALID;
+}
+
+void workspace_desc_list_cleanup(workspace_desc_t **list, size_t *count) {
+  if (!list || !count) return;
+
+  for (size_t i = 0; i < *count; i++) {
+    workspace_desc_cleanup(&(*list)[i]);
+  }
+
+  p_delete(list);
+  *count = 0;
+}
+
+bool workspace_desc_layouts_valid(const workspace_desc_t *workspace) {
+  if (!workspace || !workspace->layout_count || !workspace->layout_ids) {
+    return false;
+  }
+
+  for (size_t i = 0; i < workspace->layout_count; i++) {
+    if (workspace->layout_ids[i] == workspace->initial_layout_id) return true;
+  }
+
+  return false;
+}
+
+bool workspace_desc_valid(
+  const workspace_desc_t *workspace,
+  size_t output_count
+) {
+  if (!workspace || !workspace->name) return false;
+  if (workspace->output_index >= output_count) return false;
+
+  return workspace_desc_layouts_valid(workspace);
+}

src/common/workspace.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <stddef.h>
+
+#include "interface/types.h"
+
+typedef struct workspace_desc_t {
+  size_t output_index; /* 对应 state_init() 中 outputs[] 的索引 */
+  const char *name;
+  const layout_id_t *layout_ids;
+  size_t layout_count;
+  layout_id_t initial_layout_id;
+} workspace_desc_t;
+
+void workspace_desc_cleanup(workspace_desc_t *workspace);
+void workspace_desc_list_cleanup(workspace_desc_t **list, size_t *count);
+bool workspace_desc_layouts_valid(const workspace_desc_t *workspace);
+bool workspace_desc_valid(
+  const workspace_desc_t *workspace,
+  size_t output_count
+);

src/config/defaults.c

@@ -9,7 +9,7 @@
 
 #include "base/log.h"
 #include "base/macros.h"
-#include "core/types.h"
+#include "interface/types.h"
 
 static constexpr char launcher[] =
   "rofi -show combi -modes combi -combi-modes window,drun,run,ssh,windowcd";
@@ -52,10 +52,12 @@ bool config_defaults_build(
   );
   zdwm_layout_id_t floating_id =
     api->register_layout(builder, "floating", "><>", "floating", nullptr);
-  if (fair_id == ZDWM_LAYOUT_ID_INVALID ||
+  if (
+    fair_id == ZDWM_LAYOUT_ID_INVALID ||
     maximize_id == ZDWM_LAYOUT_ID_INVALID ||
     fullscreen_id == ZDWM_LAYOUT_ID_INVALID ||
-      floating_id == ZDWM_LAYOUT_ID_INVALID) {
+    floating_id == ZDWM_LAYOUT_ID_INVALID
+  ) {
     return false;
   }
 
@@ -120,7 +122,7 @@ bool config_defaults_build(
   RAISE_OR_RUN(default_mode, Super("e"), editor);
   RAISE_OR_RUN(default_mode, Super("q"), browser);
   RAISE_OR_RUN(default_mode, Super("a"), chrome);
-  BIND_DEFAULT(Super("f"), {.type = ZDWM_ACTION_WINDOW_TOGGLE_FLOATING});
+  BIND_DEFAULT(Super("f"), {.type = ZDWM_ACTION_WINDOW_TOGGLE_FULLSCREEN});
   BIND_DEFAULT(Super("m"), {.type = ZDWM_ACTION_WINDOW_TOGGLE_MAXIMIZE});
   BIND_DEFAULT(
     Super("Control+space"),

src/config/runtime_config.c

@@ -5,18 +5,19 @@
 #include <stdint.h>
 #include <zdwm/bar.h>
 #include <zdwm/config.h>
+#include <zdwm/listeners.h>
 
 #include "base/array.h"
 #include "base/color.h"
 #include "base/memory.h"
+#include "common/listeners.h"
+#include "common/workspace.h"
 #include "config/defaults.h"
 #include "config/loader.h"
 #include "core/binding.h"
 #include "core/layout.h"
-#include "core/listeners.h"
 #include "core/rules.h"
-#include "core/types.h"
+#include "interface/types.h"
-#include "core/wm_desc.h"
 #include "layouts/fair.h"
 #include "layouts/fullscreen.h"
 #include "layouts/maximize.h"
@@ -38,8 +39,10 @@ struct zdwm_config_builder_t {
 void runtime_config_cleanup(runtime_init_desc_t *desc) {
   if (!desc) return;
 
-  if (desc->layouts.slots || desc->layouts.slot_count ||
+  if (
-      desc->layouts.slot_capacity) {
+    desc->layouts.slots || desc->layouts.slot_count ||
+    desc->layouts.slot_capacity
+  ) {
     layout_registry_cleanup(&desc->layouts);
   }
   binding_table_destroy(desc->binding_table);
@@ -53,8 +56,10 @@ void runtime_config_cleanup(runtime_init_desc_t *desc) {
 static void config_builder_cleanup(zdwm_config_builder_t *builder) {
   if (!builder) return;
 
-  if (builder->layouts.slots || builder->layouts.slot_count ||
+  if (
-      builder->layouts.slot_capacity) {
+    builder->layouts.slots || builder->layouts.slot_count ||
+    builder->layouts.slot_capacity
+  ) {
     layout_registry_cleanup(&builder->layouts);
   }
   workspace_desc_list_cleanup(&builder->workspaces, &builder->workspace_count);
@@ -336,10 +341,10 @@ static bool runtime_config_build(
   builder.output_count = output_count;
   builder.binding_table = binding_table_create();
 
+  /* clang-format off */
   zdwm_api_t api = {
     .abi_version = ZDWM_CONFIG_ABI_VERSION,
-    .builtin_layouts =
+    .builtin_layouts = {
-      {
       .fair       = fair,
       .fullscreen = fullscreen,
       .maximize   = maximize,
@@ -356,19 +361,18 @@ static bool runtime_config_build(
     .set_interaction_fps = runtime_config_set_interaction_fps,
 
     .subscribe_current_output         = runtime_config_subscribe_current_output,
-    .subscribe_initial_workspace_list =
+    .subscribe_initial_workspace_list = runtime_config_subscribe_initial_workspace_list,
-      runtime_config_subscribe_initial_workspace_list,
     .subscribe_workspace_active       = runtime_config_subscribe_workspace_active,
     .subscribe_layout                 = runtime_config_subscribe_layout,
     .subscribe_binding_mode           = runtime_config_subscribe_binding_mode,
-    .subscribe_initial_window_list =
+    .subscribe_initial_window_list    = runtime_config_subscribe_initial_window_list,
-      runtime_config_subscribe_initial_window_list,
     .subscribe_window_added           = runtime_config_subscribe_window_added,
     .subscribe_window_updated         = runtime_config_subscribe_window_updated,
     .subscribe_window_removed         = runtime_config_subscribe_window_removed,
 
     .set_bar_config = runtime_config_set_bar_config,
   };
+  /* clang-format on */
   bool ok = setup(&api, &builder, outputs, output_count) &&
             config_builder_finish(&builder, out);
   config_builder_cleanup(&builder);

src/config/runtime_config.h

@@ -5,13 +5,12 @@
 #include <zdwm/bar.h>
 #include <zdwm/types.h>
 
-#include "core/backend.h"
+#include "common/listeners.h"
+#include "common/workspace.h"
 #include "core/binding.h"
 #include "core/layout.h"
-#include "core/listeners.h"
 #include "core/rules.h"
-#include "core/types.h"
+#include "interface/backend.h"
-#include "core/wm_desc.h"
 
 typedef struct runtime_init_desc_t {
   backend_t *backend;

src/core/binding.c

@@ -12,7 +12,7 @@
 #include "base/array.h"
 #include "base/macros.h"
 #include "base/memory.h"
-#include "core/types.h"
+#include "interface/types.h"
 
 typedef struct binding_mode_t {
   zdwm_binding_mode_id_t id;
@@ -82,8 +82,10 @@ static const mod_entry_t mod_table[] = {
 
 static modifier_mask_t lookup_modifier(const char *name, size_t len) {
   for (size_t i = 0; i < countof(mod_table); ++i) {
-    if (strlen(mod_table[i].name) == len &&
+    if (
-        strncmp(name, mod_table[i].name, len) == 0) {
+      strlen(mod_table[i].name) == len &&
+      strncmp(name, mod_table[i].name, len) == 0
+    ) {
       return mod_table[i].mask;
     }
   }

src/core/binding.h

@@ -5,7 +5,7 @@
 #include <zdwm/action.h>
 #include <zdwm/types.h>
 
-#include "core/types.h"
+#include "interface/types.h"
 
 typedef struct binding_table_t binding_table_t;
 

src/core/command.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "core/types.h"
+#include "core/window_info.h"
-#include "core/wm_desc.h"
+#include "interface/types.h"
 
 typedef enum command_type_t {
   ZDWM_COMMAND_MANAGE_WINDOW,
@@ -11,6 +11,7 @@ typedef enum command_type_t {
   ZDWM_COMMAND_RAISE_WINDOW,
   ZDWM_COMMAND_WITHDRAW_WINDOW,
   ZDWM_COMMAND_CONFIGURE_WINDOW,
+  ZDWM_COMMAND_NOTIFY_CONFIGURE,
   ZDWM_COMMAND_CHANGE_WINDOW_STATE,
   ZDWM_COMMAND_START_MOVE_WINDOW,
   ZDWM_COMMAND_STOP_MOVE_WINDOW,
@@ -102,6 +103,7 @@ typedef struct command_t {
     only_window_data_t raise;
     only_window_data_t withdraw;
     configure_data_t configure;
+    only_window_data_t notify_configure;
     window_state_change_command_t state_change;
     start_interaction_command_t move;
     start_interaction_command_t resize;

src/core/layer.c

@@ -4,7 +4,7 @@
 
 #include "base/array.h"
 #include "base/memory.h"
-#include "core/types.h"
+#include "interface/types.h"
 
 void layer_stack_cleanup(layer_stack_t *layer) {
   p_delete(&layer->order);

src/core/layer.h

@@ -2,7 +2,7 @@
 
 #include <stddef.h>
 
-#include "core/types.h"
+#include "interface/types.h"
 
 typedef struct layer_stack_t {
   window_id_t *order;

src/core/layout.c

@@ -6,7 +6,7 @@
 
 #include "base/array.h"
 #include "base/memory.h"
-#include "core/types.h"
+#include "interface/types.h"
 
 void layout_result_cleanup(layout_result_t *result) {
   p_delete(&result->items);

src/core/layout.h

@@ -3,7 +3,7 @@
 #include <stddef.h>
 #include <zdwm/layout.h>
 
-#include "core/types.h"
+#include "interface/types.h"
 
 typedef zdwm_layout_ctx_t layout_ctx_t;
 typedef zdwm_layout_item_t layout_item_t;

src/core/listeners.c

@@ -1,111 +1,11 @@
 #include "core/listeners.h"
 
-#include "base/array.h"
 #include "base/memory.h"
+#include "common/listeners.h"
 #include "core/binding.h"
 #include "core/layout.h"
 #include "core/state.h"
-
+#include "core/window.h"
-#define ADD_LISTENER(FIELD)                                               \
-  auto list       = &listeners->FIELD;                                    \
-  auto item       = array_push(list->items, list->count, list->capacity); \
-  item->fn        = fn;                                                   \
-  item->user_data = user_data
-
-void listeners_add_output_listener(
-  listeners_t *listeners,
-  zdwm_current_output_id_listener fn,
-  void *user_data
-) {
-  ADD_LISTENER(output_listeners);
-}
-
-void listeners_add_initial_workspace_listener(
-  listeners_t *listeners,
-  zdwm_initial_workspace_list fn,
-  void *user_data
-) {
-  ADD_LISTENER(initial_workspace_listeners);
-}
-
-void listeners_add_active_workspace_listener(
-  listeners_t *listeners,
-  zdwm_workspace_active_updated fn,
-  void *user_data
-) {
-  ADD_LISTENER(active_workspace_listeners);
-}
-
-void listeners_add_layout_notify(
-  listeners_t *listeners,
-  zdwm_layout_notify fn,
-  void *user_data
-) {
-  ADD_LISTENER(layout_listeners);
-}
-
-void listeners_add_binding_mode_notify(
-  listeners_t *listeners,
-  zdwm_binding_mode_notify fn,
-  void *user_data
-) {
-  ADD_LISTENER(binding_mode_listeners);
-}
-
-void listeners_add_initial_window_listener(
-  listeners_t *listeners,
-  zdwm_initial_window_list fn,
-  void *user_data
-) {
-  ADD_LISTENER(initial_window_listeners);
-}
-
-void listeners_add_window_added_listener(
-  listeners_t *listeners,
-  zdwm_window_added fn,
-  void *user_data
-) {
-  ADD_LISTENER(window_added_listeners);
-}
-
-void listeners_add_window_updated_listener(
-  listeners_t *listeners,
-  zdwm_window_updated fn,
-  void *user_data
-) {
-  ADD_LISTENER(window_updated_listeners);
-}
-
-void listeners_add_window_removed_listener(
-  listeners_t *listeners,
-  zdwm_window_removed fn,
-  void *user_data
-) {
-  ADD_LISTENER(window_removed_listeners);
-}
-
-#undef ADD_LISTENER
-
-#define CLEANUP_LIST(FIELD)          \
-  p_delete(&listeners->FIELD.items); \
-  listeners->FIELD.count    = 0;     \
-  listeners->FIELD.capacity = 0
-
-void listeners_cleanup(listeners_t *listeners) {
-  if (!listeners) return;
-
-  CLEANUP_LIST(output_listeners);
-  CLEANUP_LIST(initial_workspace_listeners);
-  CLEANUP_LIST(active_workspace_listeners);
-  CLEANUP_LIST(layout_listeners);
-  CLEANUP_LIST(binding_mode_listeners);
-  CLEANUP_LIST(initial_window_listeners);
-  CLEANUP_LIST(window_added_listeners);
-  CLEANUP_LIST(window_updated_listeners);
-  CLEANUP_LIST(window_removed_listeners);
-}
-
-#undef CLEANUP_LIST
 
 #define FOR_EACH_LISTENER(FIELD, BODY)         \
   do {                                         \
@@ -218,7 +118,7 @@ static bool listeners_window_snapshot(
   *out = (zdwm_window_t){
     .workspace = window->workspace_id,
     .id = window->id,
-    .title        = window->title,
+    .title = window_get_showing_title(window),
     .focused = workspace->focused_window_id == window->id,
     .urgent = window->urgent,
     .skip_taskbar = window->skip_taskbar,

src/core/listeners.h

@@ -3,98 +3,8 @@
 #include <stddef.h>
 #include <zdwm/listeners.h>
 
-#include "core/types.h"
+#include "common/listeners.h"
-
+#include "interface/types.h"
-typedef struct binding_table_t binding_table_t;
-typedef struct layout_registry_t layout_registry_t;
-typedef struct state_t state_t;
-
-#define ITEM(NAME, FN_TYPE)               \
-  typedef struct NAME##_listener_item_t { \
-    FN_TYPE *fn;                          \
-    void *user_data;                      \
-  } NAME##_listener_item_t
-
-#define LISTENERS(NAME, FN_TYPE)      \
-  ITEM(NAME, FN_TYPE);                \
-  typedef struct NAME##_listeners_t { \
-    NAME##_listener_item_t *items;    \
-    size_t count;                     \
-    size_t capacity;                  \
-  } NAME##_listeners_t
-
-LISTENERS(output, zdwm_current_output_id_listener);
-LISTENERS(initial_workspace_list, zdwm_initial_workspace_list);
-LISTENERS(workspace_active, zdwm_workspace_active_updated);
-LISTENERS(layout, zdwm_layout_notify);
-LISTENERS(binding_mode, zdwm_binding_mode_notify);
-LISTENERS(initial_window_list, zdwm_initial_window_list);
-LISTENERS(window_added, zdwm_window_added);
-LISTENERS(window_updated, zdwm_window_updated);
-LISTENERS(window_removed, zdwm_window_removed);
-
-#undef ITEM
-#undef LISTENERS
-
-typedef struct listeners_t {
-  output_listeners_t output_listeners;
-  initial_workspace_list_listeners_t initial_workspace_listeners;
-  workspace_active_listeners_t active_workspace_listeners;
-  layout_listeners_t layout_listeners;
-  binding_mode_listeners_t binding_mode_listeners;
-  initial_window_list_listeners_t initial_window_listeners;
-  window_added_listeners_t window_added_listeners;
-  window_updated_listeners_t window_updated_listeners;
-  window_removed_listeners_t window_removed_listeners;
-} listeners_t;
-
-void listeners_add_output_listener(
-  listeners_t *listeners,
-  zdwm_current_output_id_listener fn,
-  void *user_data
-);
-void listeners_add_initial_workspace_listener(
-  listeners_t *listeners,
-  zdwm_initial_workspace_list fn,
-  void *user_data
-);
-void listeners_add_active_workspace_listener(
-  listeners_t *listeners,
-  zdwm_workspace_active_updated fn,
-  void *user_data
-);
-void listeners_add_layout_notify(
-  listeners_t *listeners,
-  zdwm_layout_notify fn,
-  void *user_data
-);
-void listeners_add_binding_mode_notify(
-  listeners_t *listeners,
-  zdwm_binding_mode_notify fn,
-  void *user_data
-);
-void listeners_add_initial_window_listener(
-  listeners_t *listeners,
-  zdwm_initial_window_list fn,
-  void *user_data
-);
-void listeners_add_window_added_listener(
-  listeners_t *listeners,
-  zdwm_window_added fn,
-  void *user_data
-);
-void listeners_add_window_updated_listener(
-  listeners_t *listeners,
-  zdwm_window_updated fn,
-  void *user_data
-);
-void listeners_add_window_removed_listener(
-  listeners_t *listeners,
-  zdwm_window_removed fn,
-  void *user_data
-);
-
-void listeners_cleanup(listeners_t *listeners);
 
 /**
  * @brief 通知当前 output 信息

src/core/plan.c

@@ -4,7 +4,8 @@
 
 #include "base/array.h"
 #include "base/memory.h"
-#include "core/types.h"
+#include "interface/effect.h"
+#include "interface/types.h"
 
 static void free_memory_hold_by_effects(effect_t *effects, size_t count) {
   for (size_t i = 0; i < count; ++i) {
@@ -120,6 +121,16 @@ void plan_push_resize_effect(plan_t *plan, window_id_t window_id) {
   plan_push_effect(plan, &effect);
 }
 
+void plan_push_configure_notify_effect(plan_t *plan, window_id_t window_id) {
+  if (window_id_invalid(window_id)) return;
+
+  effect_t effect = {
+    .type = ZDWM_EFFECT_CONFIGURE_NOTIFY,
+    .as.configure_notify.window = window_id,
+  };
+  plan_push_effect(plan, &effect);
+}
+
 void plan_push_fullscreen_effect(
   plan_t *plan,
   window_id_t window_id,

src/core/plan.h

@@ -1,89 +1,10 @@
 #pragma once
 
 #include <stddef.h>
-#include <stdint.h>
 
 #include "base/color.h"
-#include "core/types.h"
+#include "interface/effect.h"
-
+#include "interface/types.h"
-typedef enum effect_type_t {
-  ZDWM_EFFECT_MAP_WINDOW = 1,
-  ZDWM_EFFECT_UNMAP_WINDOW,
-  ZDWM_EFFECT_FOCUS_WINDOW,
-  ZDWM_EFFECT_KILL_WINDOW,
-  ZDWM_EFFECT_WITHDRAW_WINDOW,
-  ZDWM_EFFECT_START_MOVE_WINDOW,
-  ZDWM_EFFECT_START_RESIZE_WINDOW,
-  ZDWM_EFFECT_MINIMIZE_WINDOW,
-  ZDWM_EFFECT_MAXIMIZE_WINDOW,
-  ZDWM_EFFECT_FULLSCREEN_WINDOW,
-  ZDWM_EFFECT_CONFIGURE_WINDOW,
-  ZDWM_EFFECT_CHANGE_BORDER_COLOR,
-  ZDWM_EFFECT_CHANGE_WINDOW_LIST,
-  ZDWM_EFFECT_RESTACK_WINDOWS,
-  ZDWM_EFFECT_BIND_KEY,
-  ZDWM_EFFECT_GRAB_BUTTON,
-  ZDWM_EFFECT_UNGRAB_POINTER,
-} effect_type_t;
-
-typedef struct effect_move_window_t {
-  window_id_t window;
-  point_t left_top_point;
-} effect_move_window_t;
-
-typedef struct effect_resize_window_t {
-  window_id_t window;
-  int32_t width;
-  int32_t height;
-} effect_resize_window_t;
-
-typedef struct effect_change_border_color_t {
-  window_id_t window;
-  const color_t *color;
-} effect_change_border_color_t;
-
-typedef struct effect_window_list_t {
-  const window_id_t *windows;
-  size_t count;
-} effect_window_list_t;
-
-typedef struct effect_bind_key_t {
-  const key_bind_t *keys;
-  size_t count;
-} effect_bind_key_t;
-
-typedef struct effect_grab_button_t {
-  window_id_t window;
-  const grab_button_t *buttons;
-  size_t count;
-} effect_grab_button_t;
-
-typedef struct effect_bool_window_t {
-  window_id_t window;
-  bool value;
-} effect_bool_window_t;
-
-typedef struct effect_t {
-  effect_type_t type;
-  union {
-    only_window_data_t map;
-    only_window_data_t unmap;
-    only_window_data_t focus;
-    only_window_data_t kill;
-    only_window_data_t withdraw;
-    only_window_data_t move;
-    only_window_data_t resize;
-    effect_bool_window_t minimize;
-    effect_bool_window_t maximize;
-    effect_bool_window_t fullscreen;
-    configure_data_t configure;
-    effect_change_border_color_t change_border_color;
-    effect_window_list_t change_window_list;
-    effect_window_list_t restack_windows;
-    effect_bind_key_t bind_key;
-    effect_grab_button_t grab_button;
-  } as;
-} effect_t;
 
 typedef struct plan_t {
   effect_t *effects;
@@ -105,6 +26,7 @@ void plan_push_kill_effect(plan_t *plan, window_id_t window_id);
 void plan_push_withdraw_effect(plan_t *plan, window_id_t window_id);
 void plan_push_move_effect(plan_t *plan, window_id_t window_id);
 void plan_push_resize_effect(plan_t *plan, window_id_t window_id);
+void plan_push_configure_notify_effect(plan_t *plan, window_id_t window_id);
 void plan_push_fullscreen_effect(
   plan_t *plan,
   window_id_t window_id,

src/core/policy.c

@@ -10,19 +10,19 @@
 #include "base/memory.h"
 #include "base/process.h"
 #include "base/time.h"
-#include "base/window_list.h"
+#include "common/listeners.h"
+#include "common/window.h"
 #include "core/binding.h"
 #include "core/command.h"
 #include "core/command_buffer.h"
-#include "core/event.h"
 #include "core/layout.h"
 #include "core/listeners.h"
 #include "core/plan.h"
 #include "core/rules.h"
 #include "core/state.h"
-#include "core/types.h"
 #include "core/window.h"
-#include "core/wm_desc.h"
+#include "interface/event.h"
+#include "interface/types.h"
 
 static void quit(bool restart, command_buffer_t *command_buffer) {
   command_t quit_command = {
@@ -609,6 +609,7 @@ static void route_map_request(
     if (window) layer_type = MAX(window->layer, layer_type);
   }
 
+  /* clang-format off */
   command_t manage_window_cmd = {
     .type = ZDWM_COMMAND_MANAGE_WINDOW,
     .as.manage_window = {
@@ -635,6 +636,7 @@ static void route_map_request(
       },
     },
   };
+  /* clang-format on */
 
   rule_action_t action = {.workspace = ZDWM_WORKSPACE_ID_INVALID};
   bool have_rule_match = rules_resolve(rules, &e->metadata, &action);
@@ -769,6 +771,15 @@ static void route_window_state_request(
   command_buffer_push(out, &change_window_state_cmd);
 }
 
+static void
+add_notify_configure_command(command_buffer_t *out, window_id_t window) {
+  command_t notify_cmd = {
+    .type = ZDWM_COMMAND_NOTIFY_CONFIGURE,
+    .as.notify_configure = {.window = window},
+  };
+  command_buffer_push(out, &notify_cmd);
+}
+
 static void route_configure_request(
   state_t *state,
   const configure_data_t *data,
@@ -786,6 +797,7 @@ static void route_configure_request(
   }
 
   if (!state_workspace_show(state, window->workspace_id)) return;
+  add_notify_configure_command(out, data->window);
   if (window_need_layout(window)) return;
   auto workspace = state_workspace_get(state, window->workspace_id);
   if (layout_get(layouts, workspace->layout_id)) return;
@@ -936,10 +948,13 @@ static void manage_window(
   auto window = state_window_add(state, &command->info);
   auto window_id = window->id;
   auto workspace_id = command->workspace;
+  auto workspace = state_workspace_get(state, workspace_id);
+  auto old_focused_window = workspace->focused_window_id;
   state_window_set_workspace(state, window_id, workspace_id);
   set_foucs_window(ctx, workspace_id, window_id, plan);
   plan_push_grab_button_effect(plan, window_id);
   push_window_list_effect(state, plan);
+  listeners_notify_window_updated(ctx->listeners, state, old_focused_window);
   listeners_notify_window_added(ctx->listeners, state, window_id);
 
   if (window_should_fix_size(window)) {
@@ -948,7 +963,6 @@ static void manage_window(
     state_window_set_floating(state, window_id, command->floating);
   }
 
-  auto workspace   = state_workspace_get(state, workspace_id);
   auto need_layout = window_need_layout(window);
   auto layout_func = layout_get(ctx->layouts, workspace->layout_id);
 
@@ -1431,16 +1445,20 @@ static void send_window_to_workspace(
 
   if (src_visible) {
     if (src_ws && src_ws->focused_window_id != src_old_focused) {
-      if (!window_id_invalid(src_old_focused) &&
+      if (
-          state_window_get(state, src_old_focused)) {
+        !window_id_invalid(src_old_focused) &&
+        state_window_get(state, src_old_focused)
+      ) {
         plan_push_change_border_color_effect(
           plan,
           src_old_focused,
           &ctx->border->normal_color
         );
       }
-      if (!window_id_invalid(src_ws->focused_window_id) &&
+      if (
-          state_window_get(state, src_ws->focused_window_id)) {
+        !window_id_invalid(src_ws->focused_window_id) &&
+        state_window_get(state, src_ws->focused_window_id)
+      ) {
         plan_push_focus_effect(plan, src_ws->focused_window_id);
         plan_push_change_border_color_effect(
           plan,
@@ -1469,8 +1487,10 @@ static void send_window_to_workspace(
 
   auto listeners = ctx->listeners;
   listeners_notify_window_updated(listeners, state, command->window);
-  if (src_ws && src_ws->focused_window_id != src_old_focused &&
+  if (
-      !window_id_invalid(src_ws->focused_window_id)) {
+    src_ws && src_ws->focused_window_id != src_old_focused &&
+    !window_id_invalid(src_ws->focused_window_id)
+  ) {
     listeners_notify_window_updated(
       listeners,
       state,
@@ -1555,12 +1575,14 @@ static void switch_workspace(
   auto output_id = workspace->output_id;
   workspace_id_t old_workspace = ZDWM_WORKSPACE_ID_INVALID;
 
-  if (state_output_set_current_workspace(
+  if (
+    state_output_set_current_workspace(
       state,
       output_id,
       workspace_id,
       &old_workspace
-      )) {
+    )
+  ) {
     plan->need_relayout = true;
     add_switch_workspace_effects(state, old_workspace, workspace_id, plan);
     listeners_notify_workspace_active(listeners, output_id, workspace_id);
@@ -1680,6 +1702,9 @@ void policy_apply_command(
     case ZDWM_COMMAND_CONFIGURE_WINDOW:
       configure_window(state, &cmd->as.configure, plan);
       break;
+    case ZDWM_COMMAND_NOTIFY_CONFIGURE:
+      plan_push_configure_notify_effect(plan, cmd->as.notify_configure.window);
+      break;
     case ZDWM_COMMAND_CHANGE_WINDOW_STATE:
       change_window_state(ctx, &cmd->as.state_change, plan);
       break;

src/core/policy.h

@@ -3,16 +3,29 @@
 #include <stdint.h>
 #include <zdwm/action.h>
 
-#include "base/window_list.h"
+#include "common/listeners.h"
+#include "common/window.h"
 #include "core/binding.h"
 #include "core/command_buffer.h"
-#include "core/event.h"
 #include "core/layout.h"
-#include "core/listeners.h"
 #include "core/plan.h"
 #include "core/rules.h"
 #include "core/state.h"
-#include "core/types.h"
+#include "interface/event.h"
+
+typedef enum window_interaction_mode_t {
+  ZDWM_WINDOW_INTERACTION_NONE,
+  ZDWM_WINDOW_INTERACTION_MOVE,
+  ZDWM_WINDOW_INTERACTION_RESIZE,
+} window_interaction_mode_t;
+
+typedef struct window_interaction_state_t {
+  window_interaction_mode_t mode;
+  window_id_t window;
+  point_t start_coordinate;
+  rect_t origin_rect;
+  uint64_t last_change_time;
+} window_interaction_state_t;
 
 typedef struct policy_bar_t {
   bool *visible;

src/core/rules.c

@@ -5,7 +5,7 @@
 #include <zdwm/types.h>
 
 #include "base/memory.h"
-#include "core/types.h"
+#include "interface/types.h"
 
 bool rules_move(rules_t *src, rules_t *dest) {
   if (!dest || !src) return false;

src/core/rules.h

@@ -2,8 +2,7 @@
 
 #include <stddef.h>
 
-#include "core/types.h"
+#include "interface/types.h"
-#include "core/window.h"
 
 typedef struct rule_item_t {
   rule_match_t match;

src/core/state.c

@@ -8,11 +8,12 @@
 #include "base/array.h"
 #include "base/log.h"
 #include "base/memory.h"
-#include "base/window_list.h"
+#include "common/window.h"
+#include "common/workspace.h"
 #include "core/layer.h"
-#include "core/types.h"
 #include "core/window.h"
-#include "core/wm_desc.h"
+#include "core/window_info.h"
+#include "interface/types.h"
 
 void state_init(
   state_t *state,

src/core/state.h

@@ -3,11 +3,12 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include "base/window_list.h"
+#include "common/window.h"
+#include "common/workspace.h"
 #include "core/layer.h"
-#include "core/types.h"
 #include "core/window.h"
-#include "core/wm_desc.h"
+#include "core/window_info.h"
+#include "interface/types.h"
 
 typedef struct workspace_t {
   workspace_id_t id;

src/core/window.c

@@ -1,40 +1,7 @@
 #include "core/window.h"
 
 #include "base/memory.h"
-#include "core/types.h"
+#include "interface/types.h"
-
-window_layer_type_t window_classify_layer(const window_layer_props_t *props) {
-  for (size_t i = 0; i < props->type_count; ++i) {
-    window_type_t type = props->types[i];
-    if (type == ZDWM_WINDOW_TYPE_NOTIFICATION) return ZDWM_WINDOW_LAYER_OVERLAY;
-  }
-
-  for (size_t i = 0; i < props->state_count; ++i) {
-    window_state_t state = props->states[i];
-    if (state == ZDWM_WINDOW_STATE_ABOVE) return ZDWM_WINDOW_LAYER_TOP;
-  }
-
-  return ZDWM_WINDOW_LAYER_NORMAL;
-}
-
-void window_layer_props_cleanup(window_layer_props_t *props) {
-  if (!props) return;
-
-  p_delete(&props->types);
-  props->type_count = 0;
-  p_delete(&props->states);
-  props->state_count = 0;
-}
-
-void window_metadata_cleanup(window_metadata_t *metadata) {
-  if (!metadata) return;
-
-  p_delete(&metadata->title);
-  p_delete(&metadata->app_id);
-  p_delete(&metadata->role);
-  p_delete(&metadata->class_name);
-  p_delete(&metadata->instance_name);
-}
 
 void window_set_fullscreen(window_t *window, bool fullscreen) {
   window->fullscreen = fullscreen;
@@ -178,3 +145,11 @@ bool window_can_resize(const window_t *window) {
 
   return true;
 }
+
+const char *window_get_showing_title(const window_t *window) {
+  if (window->title) return window->title;
+  if (window->instance_name) return window->instance_name;
+  if (window->class_name) return window->class_name;
+  if (window->app_id) return window->app_id;
+  return nullptr;
+}

src/core/window.h

@@ -3,66 +3,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include "core/types.h"
+#include "interface/types.h"
-
-/* Internal semantic window types mapped from backend-specific protocols. */
-typedef enum window_type_t {
-  ZDWM_WINDOW_TYPE_NORMAL = 0,
-  ZDWM_WINDOW_TYPE_DESKTOP,
-  ZDWM_WINDOW_TYPE_DOCK,
-  ZDWM_WINDOW_TYPE_TOOLBAR,
-  ZDWM_WINDOW_TYPE_DIALOG,
-  ZDWM_WINDOW_TYPE_UTILITY,
-  ZDWM_WINDOW_TYPE_SPLASH,
-  ZDWM_WINDOW_TYPE_MENU,
-  ZDWM_WINDOW_TYPE_DROPDOWN_MENU,
-  ZDWM_WINDOW_TYPE_POPUP_MENU,
-  ZDWM_WINDOW_TYPE_TOOLTIP,
-  ZDWM_WINDOW_TYPE_COMBO,
-  ZDWM_WINDOW_TYPE_DND,
-  ZDWM_WINDOW_TYPE_NOTIFICATION,
-} window_type_t;
-
-/* Internal semantic window states mapped from backend-specific protocols. */
-typedef enum window_state_t {
-  ZDWM_WINDOW_STATE_ABOVE = 0,
-  ZDWM_WINDOW_STATE_FULLSCREEN,
-  ZDWM_WINDOW_STATE_MODAL,
-  ZDWM_WINDOW_STATE_STICKY,
-} window_state_t;
-
-/* 层级从低到高 */
-typedef enum window_layer_type_t {
-  ZDWM_WINDOW_LAYER_DESKTOP = 0,
-  ZDWM_WINDOW_LAYER_NORMAL,
-  ZDWM_WINDOW_LAYER_TOP,
-  ZDWM_WINDOW_LAYER_OVERLAY,
-  ZDWM_WINDOW_LAYER_COUNT,
-} window_layer_type_t;
-
-typedef enum window_metadata_change_flags_t {
-  ZDWM_WINDOW_METADATA_CHANGE_TITLE    = 1u << 0,
-  ZDWM_WINDOW_METADATA_CHANGE_APP_ID   = 1u << 1,
-  ZDWM_WINDOW_METADATA_CHANGE_ROLE     = 1u << 2,
-  ZDWM_WINDOW_METADATA_CHANGE_CLASS    = 1u << 3,
-  ZDWM_WINDOW_METADATA_CHANGE_INSTANCE = 1u << 4,
-} window_metadata_change_flags_t;
-
-typedef struct window_layer_props_t {
-  window_type_t *types;
-  size_t type_count;
-
-  window_state_t *states;
-  size_t state_count;
-} window_layer_props_t;
-
-typedef struct window_metadata_t {
-  char *title;
-  char *app_id;
-  char *role;
-  char *class_name;
-  char *instance_name;
-} window_metadata_t;
 
 typedef struct window_t {
   window_id_t id;
@@ -95,11 +36,6 @@ typedef struct window_t {
   uint32_t border_width;
 } window_t;
 
-window_layer_type_t window_classify_layer(const window_layer_props_t *props);
-
-void window_layer_props_cleanup(window_layer_props_t *props);
-void window_metadata_cleanup(window_metadata_t *metadata);
-
 void window_set_fullscreen(window_t *window, bool fullscreen);
 void window_set_maximized(window_t *window, bool maximized);
 void window_set_minimized(window_t *window, bool minimized);
@@ -131,3 +67,4 @@ bool window_need_resize(const window_t *window, int32_t width, int32_t height);
 bool window_should_has_border(const window_t *window);
 bool window_should_fix_size(const window_t *window);
 bool window_can_resize(const window_t *window);
+const char *window_get_showing_title(const window_t *window);

src/core/window_info.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "interface/types.h"
+
+/*
+ * 由 backend 提供的窗口基础信息。
+ *
+ * 这些字符串由调用方提供；state 如需长期持有，应自行复制。
+ */
+typedef struct window_info_t {
+  window_id_t id;
+  window_id_t transient_for;
+  rect_t frame_rect;
+
+  const char *title;
+  const char *app_id;
+  const char *role;
+  const char *class_name;
+  const char *instance_name;
+
+  window_layer_type_t layer_type;
+  bool fullscreen;
+  bool maximized;
+  bool minimized;
+  bool urgent;
+  bool skip_taskbar;
+
+  zdwm_size_t min_size;
+  zdwm_size_t max_size;
+} window_info_t;

src/core/wm_desc.h

@@ -1,91 +0,0 @@
-#pragma once
-
-#include <stddef.h>
-
-#include "base/memory.h"
-#include "core/types.h"
-#include "core/window.h"
-
-/*
- * 由 backend 提供的窗口基础信息。
- *
- * 这些字符串由调用方提供；state 如需长期持有，应自行复制。
- */
-typedef struct window_info_t {
-  window_id_t id;
-  window_id_t transient_for;
-  rect_t frame_rect;
-
-  const char *title;
-  const char *app_id;
-  const char *role;
-  const char *class_name;
-  const char *instance_name;
-
-  window_layer_type_t layer_type;
-  bool fullscreen;
-  bool maximized;
-  bool minimized;
-  bool urgent;
-  bool skip_taskbar;
-
-  zdwm_size_t min_size;
-  zdwm_size_t max_size;
-} window_info_t;
-
-typedef struct workspace_desc_t {
-  size_t output_index; /* 对应 state_init() 中 outputs[] 的索引 */
-  const char *name;
-  const layout_id_t *layout_ids;
-  size_t layout_count;
-  layout_id_t initial_layout_id;
-} workspace_desc_t;
-
-static inline void workspace_desc_cleanup(workspace_desc_t *workspace) {
-  if (!workspace) return;
-
-  p_delete(&workspace->name);
-  p_delete(&workspace->layout_ids);
-  workspace->output_index      = 0;
-  workspace->layout_count      = 0;
-  workspace->initial_layout_id = ZDWM_LAYOUT_ID_INVALID;
-}
-
-static inline void
-workspace_desc_list_cleanup(workspace_desc_t **list, size_t *count) {
-  if (!list || !count) return;
-
-  for (size_t i = 0; i < *count; i++) {
-    workspace_desc_cleanup(&(*list)[i]);
-  }
-
-  p_delete(list);
-  *count = 0;
-}
-
-/*
- * workspace 描述校验接口。
- *
- * 这组接口只校验描述表自身的一致性，不访问 state。
- */
-static inline bool workspace_desc_layouts_valid(
-  const workspace_desc_t *workspace
-) {
-  if (!workspace || !workspace->layout_count || !workspace->layout_ids) {
-    return false;
-  }
-
-  for (size_t i = 0; i < workspace->layout_count; i++) {
-    if (workspace->layout_ids[i] == workspace->initial_layout_id) return true;
-  }
-
-  return false;
-}
-
-static inline bool
-workspace_desc_valid(const workspace_desc_t *workspace, size_t output_count) {
-  if (!workspace || !workspace->name) return false;
-  if (workspace->output_index >= output_count) return false;
-
-  return workspace_desc_layouts_valid(workspace);
-}

src/interface/backend.h

@@ -3,9 +3,10 @@
 #include <cairo.h>
 #include <stddef.h>
 
-#include "core/event.h"
+#include "interface/effect.h"
-#include "core/plan.h"
+#include "interface/event.h"
-#include "core/types.h"
+#include "interface/tray.h"
+#include "interface/types.h"
 
 typedef struct backend_t backend_t;
 
@@ -69,11 +70,13 @@ void backend_scan_result_destroy(backend_scan_result_t *result);
 typedef struct backend_bar_window_t {
   window_id_t window_id;
   cairo_t *cr;
+  tray_t tray;
 } backend_bar_window_t;
 
 backend_bar_window_t backend_create_bar_window(
   backend_t *backend,
   rect_t geometry,
-  uint32_t bg_pixel
+  uint32_t bg_pixel,
+  bool enable_tray
 );
 void backend_flush(backend_t *backend);

src/interface/effect.h

@@ -0,0 +1,97 @@
+#pragma once
+
+#include <stddef.h>
+
+#include "base/color.h"
+#include "interface/types.h"
+
+typedef enum effect_type_t {
+  ZDWM_EFFECT_MAP_WINDOW = 1,
+  ZDWM_EFFECT_UNMAP_WINDOW,
+  ZDWM_EFFECT_FOCUS_WINDOW,
+  ZDWM_EFFECT_KILL_WINDOW,
+  ZDWM_EFFECT_WITHDRAW_WINDOW,
+  ZDWM_EFFECT_START_MOVE_WINDOW,
+  ZDWM_EFFECT_START_RESIZE_WINDOW,
+  ZDWM_EFFECT_MINIMIZE_WINDOW,
+  ZDWM_EFFECT_MAXIMIZE_WINDOW,
+  ZDWM_EFFECT_FULLSCREEN_WINDOW,
+  ZDWM_EFFECT_CONFIGURE_WINDOW,
+  ZDWM_EFFECT_CONFIGURE_NOTIFY,
+  ZDWM_EFFECT_CHANGE_BORDER_COLOR,
+  ZDWM_EFFECT_CHANGE_WINDOW_LIST,
+  ZDWM_EFFECT_RESTACK_WINDOWS,
+  ZDWM_EFFECT_BIND_KEY,
+  ZDWM_EFFECT_GRAB_BUTTON,
+  ZDWM_EFFECT_UNGRAB_POINTER,
+} effect_type_t;
+
+typedef struct effect_move_window_t {
+  window_id_t window;
+  point_t left_top_point;
+} effect_move_window_t;
+
+typedef struct effect_resize_window_t {
+  window_id_t window;
+  int32_t width;
+  int32_t height;
+} effect_resize_window_t;
+
+typedef struct effect_change_border_color_t {
+  window_id_t window;
+  const color_t *color;
+} effect_change_border_color_t;
+
+typedef struct effect_window_list_t {
+  const window_id_t *windows;
+  size_t count;
+} effect_window_list_t;
+
+typedef struct key_bind_t {
+  modifier_mask_t modifiers;
+  keysym_t keysym;
+} key_bind_t;
+
+typedef struct effect_bind_key_t {
+  const key_bind_t *keys;
+  size_t count;
+} effect_bind_key_t;
+
+typedef struct grab_button_t {
+  modifier_mask_t modifiers;
+  button_t button;
+} grab_button_t;
+
+typedef struct effect_grab_button_t {
+  window_id_t window;
+  const grab_button_t *buttons;
+  size_t count;
+} effect_grab_button_t;
+
+typedef struct effect_bool_window_t {
+  window_id_t window;
+  bool value;
+} effect_bool_window_t;
+
+typedef struct effect_t {
+  effect_type_t type;
+  union {
+    only_window_data_t map;
+    only_window_data_t unmap;
+    only_window_data_t focus;
+    only_window_data_t kill;
+    only_window_data_t withdraw;
+    only_window_data_t move;
+    only_window_data_t resize;
+    effect_bool_window_t minimize;
+    effect_bool_window_t maximize;
+    effect_bool_window_t fullscreen;
+    configure_data_t configure;
+    only_window_data_t configure_notify;
+    effect_change_border_color_t change_border_color;
+    effect_window_list_t change_window_list;
+    effect_window_list_t restack_windows;
+    effect_bind_key_t bind_key;
+    effect_grab_button_t grab_button;
+  } as;
+} effect_t;

src/interface/event.h

@@ -2,8 +2,7 @@
 
 #include <stdint.h>
 
-#include "core/types.h"
+#include "interface/types.h"
-#include "core/window.h"
 
 typedef enum event_type_t {
   ZDWM_EVENT_NONE,
@@ -75,11 +74,13 @@ typedef struct window_metadata_change_event_t {
   window_metadata_t metadata;
 } window_metadata_change_event_t;
 
+/* clang-format off */
 typedef enum window_activation_source_t {
   ZDWM_WINDOW_ACTIVATION_SOURCE_LEGACY      = 0,
   ZDWM_WINDOW_ACTIVATION_SOURCE_APPLICATION = 1,
   ZDWM_WINDOW_ACTIVATION_SOURCE_PAGER       = 2,
 } window_activation_source_t;
+/* clang-format on */
 
 typedef struct window_activate_request_event_t {
   window_id_t window;
@@ -109,6 +110,3 @@ typedef struct event_t {
     configure_data_t configure_request;
   } as;
 } event_t;
-
-void event_cleanup(event_t *event);
-void event_reset(event_t *event);

src/interface/tray.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "interface/types.h"
+
+typedef void (*tray_icons_change_cb_t)(void *user_data);
+
+typedef struct tray_api_t {
+  /**
+   * @brief 获取 tray 当前挂载的 bar window id
+   *
+   * @detail    如果返回的 window_id 是 ZDWM_WINDOW_ID_INVALID 则表示 tray
+   *            功能未开启，无 tray 需要挂载
+   */
+  window_id_t (*host_window)(void *handle);
+  /* 获取当前 icon 数量 */
+  size_t (*icon_count)(void *handle);
+  /* 获取每个 icon 的边长， icon 长宽一样，都等于 bar_height */
+  int32_t (*icon_size)(void *handle);
+  /* 将 tray 的 icon 容器窗口起点放到 bar 中 x 这个位置 */
+  void (*place)(void *handle, int32_t x);
+  /* 设置 icon 数量变化回调 */
+  void (*set_listener)(
+    void *handle,
+    tray_icons_change_cb_t cb,
+    void *user_data
+  );
+} tray_api_t;
+
+typedef struct tray_t {
+  tray_api_t api;
+  void *handle;
+} tray_t;

src/interface/types.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <stddef.h>
 #include <stdint.h>
 #include <zdwm/rules.h>
 #include <zdwm/types.h>
@@ -17,9 +18,12 @@ typedef zdwm_output_info_t      output_info_t;
 
 typedef zdwm_rule_match_t       rule_match_t;
 typedef zdwm_rule_action_t      rule_action_t;
+
+typedef enum zdwm_button_t          button_t;
+typedef enum zdwm_modifier_bit_t    modifier_bit_t;
+typedef zdwm_modifier_mask_t        modifier_mask_t;
 /* clang-format on */
 
-typedef uint32_t modifier_mask_t;
 typedef uint32_t keysym_t;
 
 #define ZDWM_OUTPUT_ID_INVALID ((output_id_t)UINT32_MAX)
@@ -29,43 +33,64 @@ typedef struct point_t {
   int32_t y;
 } point_t;
 
-typedef enum focus_direction_t {
+typedef struct zdwm_size_t {
-  ZDWM_FOCUS_PREV,
+  int32_t width;
-  ZDWM_FOCUS_NEXT,
+  int32_t height;
-} focus_direction_t;
+} zdwm_size_t;
 
-typedef enum cross_output_policy_t {
+typedef struct only_window_data_t {
-  ZDWM_CROSS_OUTPUT_KEEP_WORKSPACE,
+  window_id_t window;
-  ZDWM_CROSS_OUTPUT_MOVE_TO_TARGET_WORKSPACE,
+} only_window_data_t;
-} cross_output_policy_t;
 
-typedef enum modifier_bit_t {
+/* clang-format off */
-  ZDWM_MOD_NONE    = 0u,
+typedef enum configure_field_t {
-  ZDWM_MOD_SHIFT   = 1u << 0,
+  ZDWM_CONFIGURE_FIELD_X            = 1u << 0,
-  ZDWM_MOD_CONTROL = 1u << 1,
+  ZDWM_CONFIGURE_FIELD_Y            = 1u << 1,
-  ZDWM_MOD_1       = 1u << 2,
+  ZDWM_CONFIGURE_FIELD_WIDTH        = 1u << 2,
-  ZDWM_MOD_2       = 1u << 3,
+  ZDWM_CONFIGURE_FIELD_HEIGHT       = 1u << 3,
-  ZDWM_MOD_3       = 1u << 4,
+  ZDWM_CONFIGURE_FIELD_BORDER_WIDTH = 1u << 4,
-  ZDWM_MOD_4       = 1u << 5,
+  ZDWM_CONFIGURE_FIELD_SIBLING      = 1u << 5,
-  ZDWM_MOD_5       = 1u << 6,
+  ZDWM_CONFIGURE_FIELD_STACK_MODE   = 1u << 6,
-} modifier_bit_t;
+} configure_field_t;
+/* clang-format on */
 
-typedef struct key_bind_t {
+typedef struct configure_data_t {
-  modifier_mask_t modifiers;
+  window_id_t window;
-  keysym_t keysym;
+  uint32_t changed_fields;
-} key_bind_t;
+  int32_t x;
+  int32_t y;
+  int32_t width;
+  int32_t height;
+  uint32_t border_width;
+  window_id_t sibling;
+  uint32_t stack_mode;
+} configure_data_t;
 
-typedef enum button_t {
+/* Internal semantic window types mapped from backend-specific protocols. */
-  ZDWM_BUTTON_NONE,
+typedef enum window_type_t {
-  ZDWM_BUTTON_LEFT,
+  ZDWM_WINDOW_TYPE_NORMAL = 0,
-  ZDWM_BUTTON_RIGHT,
+  ZDWM_WINDOW_TYPE_DESKTOP,
-  ZDWM_BUTTON_MIDDLE,
+  ZDWM_WINDOW_TYPE_DOCK,
-} button_t;
+  ZDWM_WINDOW_TYPE_TOOLBAR,
+  ZDWM_WINDOW_TYPE_DIALOG,
+  ZDWM_WINDOW_TYPE_UTILITY,
+  ZDWM_WINDOW_TYPE_SPLASH,
+  ZDWM_WINDOW_TYPE_MENU,
+  ZDWM_WINDOW_TYPE_DROPDOWN_MENU,
+  ZDWM_WINDOW_TYPE_POPUP_MENU,
+  ZDWM_WINDOW_TYPE_TOOLTIP,
+  ZDWM_WINDOW_TYPE_COMBO,
+  ZDWM_WINDOW_TYPE_DND,
+  ZDWM_WINDOW_TYPE_NOTIFICATION,
+} window_type_t;
 
-typedef struct grab_button_t {
+/* Internal semantic window states mapped from backend-specific protocols. */
-  modifier_mask_t modifiers;
+typedef enum window_state_t {
-  button_t button;
+  ZDWM_WINDOW_STATE_ABOVE = 0,
-} grab_button_t;
+  ZDWM_WINDOW_STATE_FULLSCREEN,
+  ZDWM_WINDOW_STATE_MODAL,
+  ZDWM_WINDOW_STATE_STICKY,
+} window_state_t;
 
 typedef enum window_state_request_type_t {
   ZDWM_WINDOW_STATE_REQUEST_FULLSCREEN,
@@ -80,48 +105,46 @@ typedef enum window_state_request_action_t {
   ZDWM_WINDOW_STATE_ACTION_TOGGLE,
 } window_state_request_action_t;
 
-typedef enum configure_field_t {
+/* 层级从低到高 */
-  ZDWM_CONFIGURE_FIELD_X            = 1u << 0,
+typedef enum window_layer_type_t {
-  ZDWM_CONFIGURE_FIELD_Y            = 1u << 1,
+  ZDWM_WINDOW_LAYER_DESKTOP = 0,
-  ZDWM_CONFIGURE_FIELD_WIDTH        = 1u << 2,
+  ZDWM_WINDOW_LAYER_NORMAL,
-  ZDWM_CONFIGURE_FIELD_HEIGHT       = 1u << 3,
+  ZDWM_WINDOW_LAYER_TOP,
-  ZDWM_CONFIGURE_FIELD_BORDER_WIDTH = 1u << 4,
+  ZDWM_WINDOW_LAYER_OVERLAY,
-  ZDWM_CONFIGURE_FIELD_SIBLING      = 1u << 5,
+  ZDWM_WINDOW_LAYER_COUNT,
-  ZDWM_CONFIGURE_FIELD_STACK_MODE   = 1u << 6,
+} window_layer_type_t;
-} configure_field_t;
 
-typedef struct configure_data_t {
+typedef struct window_layer_props_t {
-  window_id_t window;
+  window_type_t *types;
-  uint32_t changed_fields;
+  size_t type_count;
-  int32_t x;
-  int32_t y;
-  int32_t width;
-  int32_t height;
-  uint32_t border_width;
-  window_id_t sibling;
-  uint32_t stack_mode;
-} configure_data_t;
 
-typedef struct border_config_t {
+  window_state_t *states;
-  uint32_t width;
+  size_t state_count;
-  color_t normal_color;
+} window_layer_props_t;
-  color_t focused_color;
-} border_config_t;
 
-typedef struct only_window_data_t {
+/* clang-format off */
-  window_id_t window;
+typedef enum window_metadata_change_flags_t {
-} only_window_data_t;
+  ZDWM_WINDOW_METADATA_CHANGE_TITLE    = 1u << 0,
+  ZDWM_WINDOW_METADATA_CHANGE_APP_ID   = 1u << 1,
+  ZDWM_WINDOW_METADATA_CHANGE_ROLE     = 1u << 2,
+  ZDWM_WINDOW_METADATA_CHANGE_CLASS    = 1u << 3,
+  ZDWM_WINDOW_METADATA_CHANGE_INSTANCE = 1u << 4,
+} window_metadata_change_flags_t;
+/* clang-format on */
+
+typedef struct window_metadata_t {
+  char *title;
+  char *app_id;
+  char *role;
+  char *class_name;
+  char *instance_name;
+} window_metadata_t;
 
 typedef enum hint_field_t {
   ZDWM_HINT_FIELD_URGENT,
   ZDWM_HINT_FIELD_SIZE,
 } hint_field_t;
 
-typedef struct zdwm_size_t {
-  int32_t width;
-  int32_t height;
-} zdwm_size_t;
-
 typedef struct hints_data_t {
   window_id_t window;
   uint32_t changed_fields;
@@ -130,19 +153,11 @@ typedef struct hints_data_t {
   zdwm_size_t max_size;
 } hints_data_t;
 
-typedef enum window_interaction_mode_t {
+typedef struct border_config_t {
-  ZDWM_WINDOW_INTERACTION_NONE,
+  uint32_t width;
-  ZDWM_WINDOW_INTERACTION_MOVE,
+  color_t normal_color;
-  ZDWM_WINDOW_INTERACTION_RESIZE,
+  color_t focused_color;
-} window_interaction_mode_t;
+} border_config_t;
-
-typedef struct window_interaction_state_t {
-  window_interaction_mode_t mode;
-  window_id_t window;
-  point_t start_coordinate;
-  rect_t origin_rect;
-  uint64_t last_change_time;
-} window_interaction_state_t;
 
 static inline bool window_id_invalid(window_id_t window_id) {
   return window_id == ZDWM_WINDOW_ID_INVALID;

src/runtime/runtime.c

@@ -1,6 +1,5 @@
 #include "runtime/runtime.h"
 
-#include <bits/types/sigset_t.h>
 #include <dlfcn.h>
 #include <signal.h>
 #include <stddef.h>
@@ -17,21 +16,23 @@
 #include "base/log.h"
 #include "base/macros.h"
 #include "base/memory.h"
-#include "base/window_list.h"
+#include "common/event.h"
+#include "common/listeners.h"
+#include "common/window.h"
+#include "common/workspace.h"
 #include "config/runtime_config.h"
-#include "core/backend.h"
 #include "core/binding.h"
 #include "core/command_buffer.h"
-#include "core/event.h"
 #include "core/layout.h"
 #include "core/listeners.h"
 #include "core/plan.h"
 #include "core/policy.h"
 #include "core/rules.h"
 #include "core/state.h"
-#include "core/types.h"
 #include "core/window.h"
-#include "core/wm_desc.h"
+#include "interface/backend.h"
+#include "interface/event.h"
+#include "interface/types.h"
 
 typedef struct runtime_t {
   bool running;
@@ -119,7 +120,10 @@ static void runtime_init_bar(runtime_t *runtime) {
       .height = bar_height,
     };
     auto color = bar->palette.bg.argb;
-    auto bar_window       = backend_create_bar_window(backend, bar_rect, color);
+    bool enable_tray = (int32_t)i == bar->config.tray_output_index;
+    auto bar_window =
+      backend_create_bar_window(backend, bar_rect, color, enable_tray);
+    bar->tray = bar_window.tray;
     auto bar_output = &bar->bars[i];
     bar_output->cr = bar_window.cr;
     bar_output->window_id = bar_window.window_id;
@@ -178,8 +182,10 @@ static void runtime_init_desc_cleanup(runtime_init_desc_t *desc) {
     desc->backend = nullptr;
   }
 
-  if (desc->layouts.slots || desc->layouts.slot_count ||
+  if (
-      desc->layouts.slot_capacity) {
+    desc->layouts.slots || desc->layouts.slot_count ||
+    desc->layouts.slot_capacity
+  ) {
     layout_registry_cleanup(&desc->layouts);
   }
 
@@ -468,7 +474,13 @@ static bool runtime_handle_bar_click(
   auto data = &event->as.pointer_button_press;
 
   zdwm_action_t action = {.type = ZDWM_ACTION_NONE};
-  if (bar_click(bar, data->window, data->local.x, &action)) {
+  bar_click_info_t info = {
+    .window = data->window,
+    .x = data->local.x,
+    .modifiers = data->modifiers,
+    .button = data->button,
+  };
+  if (bar_click(bar, info, &action)) {
     policy_resolve_action(ctx, &action, command_buffer);
     return true;
   }