1231 lines
37 KiB
Org Mode
1231 lines
37 KiB
Org Mode
* ZDWM 窗口管理器完整抽象层设计方案
|
||
|
||
** 设计目标
|
||
|
||
创建一个清晰、实用、可落地的抽象层体系，解决当前项目的架构问题，提升可维护性和可扩展性，同时保持项目的简洁性和高性能。
|
||
|
||
** 当前架构优势保留
|
||
|
||
ZDWM 现有的优秀设计基础：
|
||
- ✅ 清晰的四层架构（UI/业务/数据/基础设施）
|
||
- ✅ 优秀的观察者模式（状态栏更新）
|
||
- ✅ 灵活的策略模式（布局系统）
|
||
- ✅ 高效的事件驱动模型
|
||
- ✅ 良好的资源管理
|
||
|
||
** 核心抽象层设计
|
||
|
||
*** 第一层：基础设施抽象层 (Infrastructure Layer)
|
||
|
||
**** 1.1 上下文管理器
|
||
*问题*: 当前全局 =wm= 对象导致所有模块紧密耦合
|
||
|
||
*解决方案*: 引入上下文对象，实现依赖注入
|
||
|
||
#+BEGIN_SRC c
|
||
// src/core/context.h
|
||
// 前向声明
|
||
typedef struct display_backend_t display_backend_t;
|
||
|
||
typedef struct wm_context_t {
|
||
// 显示后端（X11 或 Wayland）
|
||
display_backend_t *display_backend;
|
||
|
||
// 核心状态
|
||
monitor_t *monitor_list;
|
||
client_t *client_list;
|
||
tag_t *tag_list;
|
||
|
||
// 配置和状态
|
||
config_t *config;
|
||
status_t *status;
|
||
|
||
// 事件循环
|
||
GMainContext *main_context;
|
||
|
||
// 引用计数
|
||
atomic_int ref_count;
|
||
} wm_context_t;
|
||
|
||
// 上下文生命周期管理
|
||
wm_context_t *wm_context_create(display_backend_type_t backend_type);
|
||
wm_context_t *wm_context_ref(wm_context_t *ctx);
|
||
void wm_context_unref(wm_context_t *ctx);
|
||
|
||
// 获取全局上下文（向后兼容）
|
||
wm_context_t *wm_context_get_default(void);
|
||
|
||
// 显示后端访问（向后兼容）
|
||
static inline xcb_connection_t* context_get_xcb_conn(wm_context_t *ctx) {
|
||
return ctx->display_backend ?
|
||
(xcb_connection_t*)ctx->display_backend->get_platform_handle() : NULL;
|
||
}
|
||
#+END_SRC
|
||
|
||
*优势*:
|
||
- 支持多实例（测试环境）
|
||
- 清晰的生命周期管理
|
||
- 便于依赖注入
|
||
- 保持向后兼容
|
||
|
||
**** 1.2 日志系统
|
||
*问题*: 当前 =logger()= 输出简单，=fatal()= 直接退出
|
||
|
||
*解决方案*: 分级日志系统
|
||
|
||
#+BEGIN_SRC c
|
||
// src/core/log.h
|
||
typedef enum log_level_t {
|
||
LOG_LEVEL_DEBUG = 0,
|
||
LOG_LEVEL_INFO,
|
||
LOG_LEVEL_WARN,
|
||
LOG_LEVEL_ERROR,
|
||
LOG_LEVEL_FATAL
|
||
} log_level_t;
|
||
|
||
typedef struct log_handler_t {
|
||
void (*write)(log_level_t level, const char *file, int line,
|
||
const char *fmt, va_list args);
|
||
log_level_t min_level;
|
||
log_handler_t *next;
|
||
} log_handler_t;
|
||
|
||
// 日志API
|
||
void log_init(log_level_t default_level);
|
||
void log_cleanup(void);
|
||
void log_add_handler(log_handler_t *handler);
|
||
void log_remove_handler(log_handler_t *handler);
|
||
|
||
// 便捷宏
|
||
#define LOG_DEBUG(fmt, ...) log_write(LOG_LEVEL_DEBUG, __FILE__, __LINE__, fmt, ##__VA_ARGS__)
|
||
#define LOG_INFO(fmt, ...) log_write(LOG_LEVEL_INFO, __FILE__, __LINE__, fmt, ##__VA_ARGS__)
|
||
#define LOG_WARN(fmt, ...) log_write(LOG_LEVEL_WARN, __FILE__, __LINE__, fmt, ##__VA_ARGS__)
|
||
#define LOG_ERROR(fmt, ...) log_write(LOG_LEVEL_ERROR, __FILE__, __LINE__, fmt, ##__VA_ARGS__)
|
||
#define LOG_FATAL(fmt, ...) log_write(LOG_LEVEL_FATAL, __FILE__, __LINE__, fmt, ##__VA_ARGS__)
|
||
|
||
// 替代现有的 logger/fatal/warn
|
||
#define logger LOG_INFO
|
||
#define warn LOG_WARN
|
||
#define fatal LOG_FATAL
|
||
#+END_SRC
|
||
|
||
**** 1.3 错误处理机制
|
||
*问题*: GError 使用不当，错误信息丢失
|
||
|
||
*解决方案*: 统一错误处理接口
|
||
|
||
#+BEGIN_SRC c
|
||
// src/core/error.h
|
||
typedef enum error_code_t {
|
||
ERROR_NONE = 0,
|
||
ERROR_NOMEM,
|
||
ERROR_INVALID_ARG,
|
||
ERROR_XCB_FAILED,
|
||
ERROR_FILE_NOT_FOUND,
|
||
ERROR_PARSE_FAILED,
|
||
// ... 更多错误码
|
||
} error_code_t;
|
||
|
||
typedef struct error_t {
|
||
error_code_t code;
|
||
char message[256];
|
||
const char *file;
|
||
int line;
|
||
} error_t;
|
||
|
||
// 错误处理API
|
||
void error_set(error_t **err, error_code_t code, const char *fmt, ...);
|
||
void error_clear(error_t **err);
|
||
const char *error_get_message(const error_t *err);
|
||
|
||
// 错误传播宏
|
||
#define CHECK_ERROR(cond, err, code, fmt, ...) \
|
||
if (!(cond)) { \
|
||
error_set(err, code, fmt, ##__VA_ARGS__); \
|
||
return false; \
|
||
}
|
||
#+END_SRC
|
||
|
||
*** 第二层：数据抽象层 (Data Layer)
|
||
|
||
**** 2.1 状态管理器
|
||
*问题*: 状态散落在多个模块，难以同步
|
||
|
||
*解决方案*: 统一状态管理接口
|
||
|
||
#+BEGIN_SRC c
|
||
// src/core/state.h
|
||
typedef enum state_type_t {
|
||
STATE_MONITOR,
|
||
STATE_CLIENT,
|
||
STATE_TAG,
|
||
STATUS_LAYOUT,
|
||
STATE_CONFIG
|
||
} state_type_t;
|
||
|
||
typedef struct state_change_t {
|
||
state_type_t type;
|
||
void *old_state;
|
||
void *new_state;
|
||
} state_change_t;
|
||
|
||
typedef void (*state_change_callback)(const state_change_t *change, void *user_data);
|
||
|
||
typedef struct state_manager_t {
|
||
// 状态变更监听器
|
||
state_change_callback *listeners;
|
||
void **listener_data;
|
||
size_t listener_count;
|
||
|
||
// 状态存储
|
||
hash_table_t *states;
|
||
} state_manager_t;
|
||
|
||
// 状态管理API
|
||
state_manager_t *state_manager_create(void);
|
||
void state_manager_destroy(state_manager_t *mgr);
|
||
|
||
void state_manager_notify(state_manager_t *mgr, const state_change_t *change);
|
||
void state_manager_subscribe(state_manager_t *mgr,
|
||
state_change_callback callback,
|
||
void *user_data);
|
||
|
||
// 状态访问
|
||
void *state_get(state_manager_t *mgr, state_type_t type);
|
||
void state_set(state_manager_t *mgr, state_type_t type, void *data);
|
||
#+END_SRC
|
||
|
||
**** 2.2 配置抽象层
|
||
*问题*: 配置系统不统一，缺少热重载
|
||
|
||
*解决方案*: 分层配置系统
|
||
|
||
#+BEGIN_SRC c
|
||
// src/config/config_layer.h
|
||
typedef enum config_source_t {
|
||
CONFIG_SOURCE_DEFAULT, // 编译时默认值
|
||
CONFIG_SOURCE_FILE, // 配置文件
|
||
CONFIG_SOURCE_XRESOURCE, // X资源数据库
|
||
CONFIG_SOURCE_RUNTIME, // 运行时API（最高优先级）
|
||
} config_source_t;
|
||
|
||
typedef struct config_value_t {
|
||
config_source_t source;
|
||
union {
|
||
bool boolean;
|
||
int integer;
|
||
char *string;
|
||
void *pointer;
|
||
} value;
|
||
} config_value_t;
|
||
|
||
typedef struct config_layer_t {
|
||
hash_table_t *values; // key -> config_value_t
|
||
config_source_t source;
|
||
bool readonly;
|
||
} config_layer_t;
|
||
|
||
typedef struct config_stack_t {
|
||
config_layer_t **layers;
|
||
size_t layer_count;
|
||
} config_stack_t;
|
||
|
||
// 配置API
|
||
config_stack_t *config_stack_create(void);
|
||
void config_stack_destroy(config_stack_t *stack);
|
||
|
||
void config_stack_push_layer(config_stack_t *stack, config_source_t source);
|
||
void config_stack_pop_layer(config_stack_t *stack);
|
||
|
||
// 配置访问（自动从最高优先级层查找）
|
||
bool config_get_bool(config_stack_t *stack, const char *key, bool *value);
|
||
bool config_get_int(config_stack_t *stack, const char *key, int *value);
|
||
bool config_get_string(config_stack_t *stack, const char *key, char **value);
|
||
|
||
// 配置设置（总是设置到运行时层）
|
||
bool config_set_bool(config_stack_t *stack, const char *key, bool value);
|
||
bool config_set_int(config_stack_t *stack, const char *key, int value);
|
||
bool config_set_string(config_stack_t *stack, const char *key, const char *value);
|
||
|
||
// 配置热重载
|
||
bool config_reload_from_file(config_stack_t *stack, const char *filepath);
|
||
#+END_SRC
|
||
|
||
*** 第三层：服务抽象层 (Service Layer)
|
||
|
||
**** 3.1 显示后端抽象
|
||
*问题*: XCB调用散落各处，难以测试，且无法支持 Wayland
|
||
|
||
*解决方案*: 显示服务器无关的统一接口，支持 X11 和 Wayland
|
||
|
||
#+BEGIN_SRC c
|
||
// src/services/display_backend.h
|
||
|
||
// 显示后端类型
|
||
typedef enum display_backend_type_t {
|
||
DISPLAY_BACKEND_AUTO, // 自动检测
|
||
DISPLAY_BACKEND_X11,
|
||
DISPLAY_BACKEND_WAYLAND
|
||
} display_backend_type_t;
|
||
|
||
// 统一的窗口表示（跨平台）
|
||
typedef struct window_t {
|
||
uint64_t id; // 平台无关的窗口ID
|
||
void *platform_handle; // XCB window or wl_surface
|
||
} window_t;
|
||
|
||
// 几何信息
|
||
typedef struct rect_t {
|
||
int32_t x, y;
|
||
uint32_t width, height;
|
||
} rect_t;
|
||
|
||
// 输入事件
|
||
typedef struct input_event_t {
|
||
enum { INPUT_KEY, INPUT_BUTTON, INPUT_MOTION, INPUT_AXIS } type;
|
||
uint32_t time;
|
||
uint32_t detail; // keycode or button number
|
||
uint32_t state; // modifier state
|
||
int32_t x, y; // cursor position
|
||
int32_t axis; // scroll axis delta
|
||
} input_event_t;
|
||
|
||
// 渲染表面
|
||
typedef struct render_surface_t {
|
||
void *handle; // cairo_surface_t* for X11, EGLSurface for Wayland
|
||
uint32_t width, height;
|
||
} render_surface_t;
|
||
|
||
// 显示后端接口
|
||
typedef struct display_backend_t {
|
||
const char *name;
|
||
const char *version;
|
||
|
||
// 生命周期
|
||
bool (*init)(wm_context_t *ctx);
|
||
void (*cleanup)(void);
|
||
|
||
// 事件处理
|
||
int (*get_fd)(void); // 获取事件文件描述符
|
||
bool (*dispatch_event)(void); // 分发单个事件
|
||
void (*flush)(void); // 刷新请求
|
||
|
||
// 屏幕信息
|
||
bool (*get_screen_geometry)(size_t screen_index, rect_t *geometry);
|
||
size_t (*get_screen_count)(void);
|
||
|
||
// 窗口操作
|
||
window_t (*create_window)(const rect_t *geometry);
|
||
void (*destroy_window)(window_t window);
|
||
void (*map_window)(window_t window);
|
||
void (*unmap_window)(window_t window);
|
||
|
||
// 窗口属性
|
||
typedef enum {
|
||
WINDOW_PROPERTY_TITLE,
|
||
WINDOW_PROPERTY_CLASS,
|
||
WINDOW_PROPERTY_ROLE,
|
||
WINDOW_PROPERTY_PID,
|
||
WINDOW_PROPERTY_TYPE,
|
||
WINDOW_PROPERTY_TRANSIENT_FOR,
|
||
WINDOW_PROPERTY_SIZE_HINTS,
|
||
WINDOW_PROPERTY_MOTIF_HINTS,
|
||
WINDOW_PROPERTY_FULLSCREEN,
|
||
WINDOW_PROPERTY_OPACITY,
|
||
} window_property_t;
|
||
|
||
bool (*get_window_property)(window_t window, window_property_t prop,
|
||
void *data, size_t *size);
|
||
bool (*set_window_property)(window_t window, window_property_t prop,
|
||
const void *data, size_t size);
|
||
|
||
// 窗口几何
|
||
bool (*configure_window)(window_t window, const rect_t *geometry);
|
||
bool (*get_window_geometry)(window_t window, rect_t *geometry);
|
||
void (*raise_window)(window_t window);
|
||
void (*focus_window)(window_t window);
|
||
|
||
// 输入处理
|
||
bool (*grab_keyboard)(window_t window);
|
||
bool (*grab_pointer)(window_t window);
|
||
void (*ungrab_keyboard)(void);
|
||
void (*ungrab_pointer)(void);
|
||
|
||
// 渲染集成
|
||
render_surface_t (*create_render_surface)(window_t window,
|
||
uint32_t width, uint32_t height);
|
||
void (*destroy_render_surface)(render_surface_t surface);
|
||
cairo_t* (*create_cairo_context)(render_surface_t surface);
|
||
|
||
// Wayland 特定：窗口状态（用于 xdg-shell）
|
||
typedef enum {
|
||
STATE_FLAG_FULLSCREEN = (1 << 0),
|
||
STATE_FLAG_MAXIMIZED = (1 << 1),
|
||
STATE_FLAG_ RESIZING = (1 << 2),
|
||
STATE_FLAG_ACTIVATING = (1 << 3),
|
||
} state_flag_t;
|
||
|
||
bool (*set_window_state)(window_t window, uint32_t state_flags);
|
||
bool (*set_window_bounds)(window_t window, const rect_t *bounds);
|
||
|
||
// 平台特定扩展
|
||
void* (*get_platform_handle)(void); // xcb_connection_t* or wl_display*
|
||
} display_backend_t;
|
||
|
||
// 显示后端管理
|
||
display_backend_t *display_backend_create(display_backend_type_t type);
|
||
bool display_backend_init(wm_context_t *ctx, display_backend_type_t type);
|
||
void display_backend_cleanup(display_backend_t *backend);
|
||
|
||
// X11 后端声明
|
||
extern display_backend_t x11_backend;
|
||
|
||
// Wayland 后端声明（未来实现）
|
||
extern display_backend_t wayland_backend;
|
||
#+END_SRC
|
||
|
||
*优势*:
|
||
- 为 Wayland 移植奠定基础
|
||
- 显示逻辑与核心逻辑分离
|
||
- 便于使用 mock 后端进行测试
|
||
- 运行时可切换显示后端
|
||
|
||
*X11 后端实现*:
|
||
|
||
#+BEGIN_SRC c
|
||
// src/services/x11_backend.c
|
||
#include <xcb/xcb.h>
|
||
#include <xcb/xcb_aux.h>
|
||
#include <cairo-xcb.h>
|
||
|
||
typedef struct x11_backend_data_t {
|
||
xcb_connection_t *conn;
|
||
xcb_screen_t *screen;
|
||
xcb_window_t root_window;
|
||
xcb_atom_t wm_protocols;
|
||
xcb_atom_t wm_delete_window;
|
||
GHashTable *window_map; // uint64_t -> xcb_window_t
|
||
} x11_backend_data_t;
|
||
|
||
static bool x11_init(wm_context_t *ctx) {
|
||
x11_backend_data_t *data = calloc(1, sizeof(x11_backend_data_t));
|
||
|
||
data->conn = xcb_connect(NULL, NULL);
|
||
if (xcb_connection_has_error(data->conn)) {
|
||
free(data);
|
||
return false;
|
||
}
|
||
|
||
data->screen = xcb_setup_roots_iterator(xcb_get_setup(data->conn)).data;
|
||
data->root_window = data->screen->root;
|
||
|
||
// 初始化 atoms 和其他资源
|
||
// ...
|
||
|
||
return true;
|
||
}
|
||
|
||
static window_t x11_create_window(const rect_t *geometry) {
|
||
x11_backend_data_t *data = display_backend_get_data(&x11_backend);
|
||
|
||
xcb_window_t xcb_win = xcb_generate_id(data->conn);
|
||
// 创建窗口...
|
||
|
||
return (window_t){
|
||
.id = (uint64_t)xcb_win,
|
||
.platform_handle = (void *)(uintptr_t)xcb_win
|
||
};
|
||
}
|
||
|
||
// ... 其他 X11 实现
|
||
|
||
display_backend_t x11_backend = {
|
||
.name = "x11",
|
||
.version = "1.0",
|
||
.init = x11_init,
|
||
.cleanup = x11_cleanup,
|
||
.create_window = x11_create_window,
|
||
// ... 其他函数指针
|
||
};
|
||
#+END_SRC
|
||
|
||
*Wayland 后端框架*:
|
||
|
||
#+BEGIN_SRC c
|
||
// src/services/wayland_backend.c
|
||
#include <wayland-client.h>
|
||
|
||
typedef struct wayland_backend_data_t {
|
||
struct wl_display *display;
|
||
struct wl_compositor *compositor;
|
||
struct wl_seat *seat;
|
||
struct xdg_wm_base *xdg_wm_base;
|
||
GHashTable *window_map;
|
||
} wayland_backend_data_t;
|
||
|
||
static bool wayland_init(wm_context_t *ctx) {
|
||
wayland_backend_data_t *data = calloc(1, sizeof(wayland_backend_data_t));
|
||
|
||
data->display = wl_display_connect(NULL);
|
||
if (!data->display) {
|
||
free(data);
|
||
return false;
|
||
}
|
||
|
||
// 注册全局对象监听器
|
||
wl_display_roundtrip(data->display);
|
||
|
||
return true;
|
||
}
|
||
|
||
// ... 其他 Wayland 实现（未来工作）
|
||
|
||
display_backend_t wayland_backend = {
|
||
.name = "wayland",
|
||
.version = "1.0",
|
||
.init = wayland_init,
|
||
// ... 其他函数指针
|
||
};
|
||
#+END_SRC
|
||
|
||
**** 3.2 事件总线
|
||
*问题*: 事件处理直接耦合业务逻辑
|
||
|
||
*解决方案*: 发布-订阅事件系统
|
||
|
||
#+BEGIN_SRC c
|
||
// src/services/event_bus.h
|
||
typedef enum event_type_t {
|
||
// 窗口事件
|
||
EVENT_WINDOW_CREATE,
|
||
EVENT_WINDOW_DESTROY,
|
||
EVENT_WINDOW_CONFIGURE,
|
||
EVENT_WINDOW_FOCUS,
|
||
|
||
// 监视器事件
|
||
EVENT_MONITOR_ADD,
|
||
EVENT_MONITOR_REMOVE,
|
||
EVENT_MONITOR_CHANGE,
|
||
|
||
// 标签事件
|
||
EVENT_TAG_ADD,
|
||
EVENT_TAG_REMOVE,
|
||
EVENT_TAG_CHANGE,
|
||
|
||
// 用户事件
|
||
EVENT_KEY_PRESS,
|
||
EVENT_MOUSE_PRESS,
|
||
EVENT_COMMAND,
|
||
|
||
// 系统事件
|
||
EVENT_CONFIG_RELOAD,
|
||
EVENT_RESTART,
|
||
EVENT_EXIT
|
||
} event_type_t;
|
||
|
||
typedef struct event_t {
|
||
event_type_t type;
|
||
void *data; // 事件特定数据
|
||
void *source; // 事件源对象
|
||
} event_t;
|
||
|
||
typedef void (*event_callback)(const event_t *event, void *user_data);
|
||
|
||
typedef struct event_subscription_t {
|
||
event_type_t type;
|
||
event_callback callback;
|
||
void *user_data;
|
||
bool once; // 是否只触发一次
|
||
} event_subscription_t;
|
||
|
||
typedef struct event_bus_t {
|
||
event_subscription_t **subscriptions;
|
||
size_t subscription_count;
|
||
size_t capacity;
|
||
} event_bus_t;
|
||
|
||
// 事件总线API
|
||
event_bus_t *event_bus_create(void);
|
||
void event_bus_destroy(event_bus_t *bus);
|
||
|
||
// 订阅事件
|
||
event_subscription_t *event_bus_subscribe(event_bus_t *bus,
|
||
event_type_t type,
|
||
event_callback callback,
|
||
void *user_data);
|
||
void event_bus_unsubscribe(event_bus_t *bus, event_subscription_t *sub);
|
||
|
||
// 发布事件
|
||
void event_bus_publish(event_bus_t *bus, const event_t *event);
|
||
|
||
// 便捷宏
|
||
#define EVENT_SUBSCRIBE(bus, type, callback, data) \
|
||
event_bus_subscribe(bus, type, callback, data)
|
||
|
||
#define EVENT_PUBLISH(bus, type, data) \
|
||
event_bus_publish(bus, &(event_t){ .type = type, .data = data })
|
||
#+END_SRC
|
||
|
||
**** 3.3 插件系统
|
||
*问题*: 扩展功能需要修改核心代码
|
||
|
||
*解决方案*: 轻量级插件接口
|
||
|
||
#+BEGIN_SRC c
|
||
// src/services/plugin.h
|
||
typedef struct plugin_t {
|
||
char *name;
|
||
char *version;
|
||
void *handle; // dlopen句柄
|
||
|
||
// 生命周期
|
||
bool (*init)(wm_context_t *ctx);
|
||
void (*cleanup)(void);
|
||
|
||
// 事件处理
|
||
void (*on_event)(const event_t *event);
|
||
|
||
// 配置
|
||
bool (*set_config)(const char *key, const char *value);
|
||
} plugin_t;
|
||
|
||
typedef struct plugin_manager_t {
|
||
plugin_t **plugins;
|
||
size_t plugin_count;
|
||
event_bus_t *event_bus;
|
||
} plugin_manager_t;
|
||
|
||
// 插件管理API
|
||
plugin_manager_t *plugin_manager_create(event_bus_t *bus);
|
||
void plugin_manager_destroy(plugin_manager_t *mgr);
|
||
|
||
// 插件加载
|
||
bool plugin_manager_load(plugin_manager_t *mgr, const char *path);
|
||
bool plugin_manager_unload(plugin_manager_t *mgr, const char *name);
|
||
|
||
// 插件API（供插件实现者使用）
|
||
void plugin_register(plugin_t *plugin);
|
||
void plugin_unregister(const char *name);
|
||
|
||
// 插件宏（简化插件开发）
|
||
#define PLUGIN_EXPORT(name, version, init_fn, cleanup_fn) \
|
||
__attribute__((used)) plugin_t *_plugin_get_info(void) { \
|
||
static plugin_t plugin = { \
|
||
.name = name, \
|
||
.version = version, \
|
||
.init = init_fn, \
|
||
.cleanup = cleanup_fn \
|
||
}; \
|
||
return &plugin; \
|
||
}
|
||
#+END_SRC
|
||
|
||
*** 第四层：业务抽象层 (Business Layer)
|
||
|
||
**** 4.1 客户端抽象
|
||
*问题*: client.c 职责过多，难以维护
|
||
|
||
*解决方案*: 客户端接口抽象
|
||
|
||
#+BEGIN_SRC c
|
||
// src/business/client_interface.h
|
||
// 客户端状态机
|
||
typedef enum client_state_t {
|
||
CLIENT_STATE_NEW,
|
||
CLIENT_STATE_NORMAL,
|
||
CLIENT_STATE_FLOATING,
|
||
CLIENT_STATE_FULLSCREEN,
|
||
CLIENT_STATE_MAXIMIZED,
|
||
CLIENT_STATE_MINIMIZED,
|
||
CLIENT_STATE_DOCK,
|
||
CLIENT_STATE_DYING
|
||
} client_state_t;
|
||
|
||
// 客户端接口
|
||
typedef struct client_interface_t {
|
||
// 生命周期
|
||
client_t* (*create)(xcb_window_t window);
|
||
void (*destroy)(client_t *client);
|
||
|
||
// 状态管理
|
||
client_state_t (*get_state)(const client_t *client);
|
||
bool (*set_state)(client_t *client, client_state_t new_state);
|
||
|
||
// 几何管理
|
||
bool (*set_geometry)(client_t *client, const rect_t *geometry);
|
||
rect_t (*get_geometry)(const client_t *client);
|
||
|
||
// 焦点管理
|
||
bool (*focus)(client_t *client);
|
||
bool (*is_focused)(const client_t *client);
|
||
|
||
// 属性管理
|
||
bool (*set_property)(client_t *client, const char *key, void *value);
|
||
void* (*get_property)(const client_t *client, const char *key);
|
||
|
||
// 渲染
|
||
bool (*needs_redraw)(const client_t *client);
|
||
void (*draw)(client_t *client, cairo_t *cr);
|
||
} client_interface_t;
|
||
|
||
// 客户端管理器
|
||
typedef struct client_manager_t {
|
||
client_interface_t *iface;
|
||
list_t *clients; // 所有客户端
|
||
hash_table_t *window_map; // window -> client
|
||
} client_manager_t;
|
||
|
||
// 客户端管理API
|
||
client_manager_t *client_manager_create(client_interface_t *iface);
|
||
void client_manager_destroy(client_manager_t *mgr);
|
||
|
||
client_t *client_manager_add(client_manager_t *mgr, xcb_window_t window);
|
||
bool client_manager_remove(client_manager_t *mgr, client_t *client);
|
||
client_t *client_manager_find(client_manager_t *mgr, xcb_window_t window);
|
||
#+END_SRC
|
||
|
||
**** 4.2 布局引擎抽象
|
||
*问题*: 布局系统已经设计良好，但缺少插件化
|
||
|
||
*解决方案*: 布局插件接口
|
||
|
||
#+BEGIN_SRC c
|
||
// src/business/layout_engine.h
|
||
typedef struct layout_context_t {
|
||
tag_t *tag;
|
||
rect_t workarea;
|
||
client_t **clients;
|
||
size_t client_count;
|
||
} layout_context_t;
|
||
|
||
typedef struct layout_algorithm_t {
|
||
const char *name;
|
||
const char *symbol;
|
||
|
||
// 布局计算
|
||
void (*arrange)(const layout_context_t *ctx, rect_t *geometries);
|
||
|
||
// 可选：预览布局（不实际应用）
|
||
void (*preview)(const layout_context_t *ctx, rect_t *geometries);
|
||
|
||
// 可选：布局参数
|
||
bool (*set_param)(const char *key, void *value);
|
||
} layout_algorithm_t;
|
||
|
||
typedef struct layout_engine_t {
|
||
layout_algorithm_t **algorithms;
|
||
size_t algorithm_count;
|
||
layout_algorithm_t *default_algorithm;
|
||
} layout_engine_t;
|
||
|
||
// 布局引擎API
|
||
layout_engine_t *layout_engine_create(void);
|
||
void layout_engine_destroy(layout_engine_t *engine);
|
||
|
||
bool layout_engine_register(layout_engine_t *engine, layout_algorithm_t *algo);
|
||
bool layout_engine_unregister(layout_engine_t *engine, const char *name);
|
||
|
||
layout_algorithm_t *layout_engine_find(layout_engine_t *engine, const char *name);
|
||
void layout_engine_arrange(layout_engine_t *engine, const layout_context_t *ctx);
|
||
|
||
// 便捷宏：定义布局算法
|
||
#define LAYOUT_ALGORITHM(name, symbol, arrange_fn) \
|
||
static layout_algorithm_t _layout_##name = { \
|
||
.name = #name, \
|
||
.symbol = symbol, \
|
||
.arrange = arrange_fn \
|
||
}; \
|
||
__attribute__((constructor)) \
|
||
static void _layout_register_##name(void) { \
|
||
layout_engine_register(layout_engine_get_default(), &_layout_##name); \
|
||
}
|
||
#+END_SRC
|
||
|
||
**** 4.3 操作抽象
|
||
*问题*: 操作系统已经设计良好，可以增强
|
||
|
||
*解决方案*: 命令模式增强
|
||
|
||
#+BEGIN_SRC c
|
||
// src/business/command.h
|
||
typedef enum command_arg_type_t {
|
||
COMMAND_ARG_NONE,
|
||
COMMAND_ARG_INT,
|
||
COMMAND_ARG_STRING,
|
||
COMMAND_ARG_BOOLEAN
|
||
} command_arg_type_t;
|
||
|
||
typedef struct command_arg_t {
|
||
command_arg_type_t type;
|
||
union {
|
||
int integer;
|
||
char *string;
|
||
bool boolean;
|
||
} value;
|
||
} command_arg_t;
|
||
|
||
typedef struct command_result_t {
|
||
bool success;
|
||
char *message;
|
||
void *data; // 可选的返回数据
|
||
void (*data_cleanup)(void *data);
|
||
} command_result_t;
|
||
|
||
typedef struct command_t {
|
||
const char *name;
|
||
const char *description;
|
||
|
||
// 参数定义
|
||
command_arg_type_t *arg_types;
|
||
size_t arg_count;
|
||
|
||
// 执行函数
|
||
command_result_t (*execute)(wm_context_t *ctx,
|
||
const command_arg_t *args,
|
||
size_t arg_count);
|
||
|
||
// 可选：自动完成
|
||
char* (*complete)(const char *prefix, size_t arg_index);
|
||
} command_t;
|
||
|
||
typedef struct command_registry_t {
|
||
hash_table_t *commands; // name -> command_t
|
||
} command_registry_t;
|
||
|
||
// 命令注册API
|
||
command_registry_t *command_registry_create(void);
|
||
void command_registry_destroy(command_registry_t *registry);
|
||
|
||
bool command_registry_register(command_registry_t *registry, command_t *cmd);
|
||
bool command_registry_unregister(command_registry_t *registry, const char *name);
|
||
|
||
command_result_t command_execute(command_registry_t *registry,
|
||
wm_context_t *ctx,
|
||
const char *name,
|
||
const command_arg_t *args,
|
||
size_t arg_count);
|
||
|
||
// 便捷宏
|
||
#define COMMAND_REGISTER(registry, name, fn) \
|
||
command_registry_register(registry, &(command_t){ \
|
||
.name = name, \
|
||
.execute = fn \
|
||
})
|
||
#+END_SRC
|
||
|
||
*** 第五层：UI抽象层 (Presentation Layer)
|
||
|
||
**** 5.1 渲染器抽象
|
||
*问题*: 渲染逻辑散落各处，难以扩展
|
||
|
||
*解决方案*: 统一渲染接口
|
||
|
||
#+BEGIN_SRC c
|
||
// src/ui/renderer.h
|
||
typedef struct render_context_t {
|
||
cairo_t *cr;
|
||
rect_t viewport;
|
||
color_scheme_t *colors;
|
||
} render_context_t;
|
||
|
||
typedef struct renderer_t {
|
||
const char *name;
|
||
|
||
// 初始化
|
||
bool (*init)(wm_context_t *ctx);
|
||
|
||
// 清理
|
||
void (*cleanup)(void);
|
||
|
||
// 渲染
|
||
void (*render)(const render_context_t *ctx, void *data);
|
||
|
||
// 尺寸计算
|
||
void (*measure)(const render_context_t *ctx, void *data, size_t *width, size_t *height);
|
||
} renderer_t;
|
||
|
||
typedef struct renderer_manager_t {
|
||
renderer_t **renderers;
|
||
size_t renderer_count;
|
||
} renderer_manager_t;
|
||
|
||
// 渲染器管理API
|
||
renderer_manager_t *renderer_manager_create(void);
|
||
void renderer_manager_destroy(renderer_manager_t *mgr);
|
||
|
||
bool renderer_manager_register(renderer_manager_t *mgr, renderer_t *r);
|
||
bool renderer_manager_unregister(renderer_manager_t *mgr, const char *name);
|
||
|
||
renderer_t *renderer_manager_find(renderer_manager_t *mgr, const char *name);
|
||
void renderer_manager_render(renderer_manager_t *mgr, const char *name,
|
||
const render_context_t *ctx, void *data);
|
||
#+END_SRC
|
||
|
||
**** 5.2 状态栏组件系统
|
||
*问题*: 状态栏已经设计良好，可以组件化
|
||
|
||
*解决方案*: 组件化状态栏
|
||
|
||
#+BEGIN_SRC c
|
||
// src/ui/statusbar_component.h
|
||
typedef struct statusbar_component_t {
|
||
const char *name;
|
||
size_t preferred_width;
|
||
size_t preferred_height;
|
||
|
||
// 渲染
|
||
void (*render)(const render_context_t *ctx, void *data);
|
||
|
||
// 尺寸计算
|
||
void (*measure)(const render_context_t *ctx, void *data,
|
||
size_t *width, size_t *height);
|
||
|
||
// 事件处理
|
||
void (*on_click)(void *data, int x, int y);
|
||
void (*on_scroll)(void *data, int delta);
|
||
|
||
// 生命周期
|
||
void (*init)(wm_context_t *ctx, void **data);
|
||
void (*cleanup)(void *data);
|
||
} statusbar_component_t;
|
||
|
||
typedef struct statusbar_t {
|
||
statusbar_component_t **components;
|
||
void **component_data;
|
||
size_t component_count;
|
||
|
||
// 布局管理
|
||
enum {
|
||
STATUSBAR_LAYOUT_LEFT_TO_RIGHT,
|
||
STATUSBAR_LAYOUT_RIGHT_TO_LEFT
|
||
} layout_direction;
|
||
} statusbar_t;
|
||
|
||
// 状态栏组件API
|
||
statusbar_t *statusbar_create(void);
|
||
void statusbar_destroy(statusbar_t *bar);
|
||
|
||
bool statusbar_add_component(statusbar_t *bar, statusbar_component_t *comp);
|
||
bool statusbar_remove_component(statusbar_t *bar, const char *name);
|
||
|
||
void statusbar_render(statusbar_t *bar, const render_context_t *ctx);
|
||
void statusbar_handle_event(statusbar_t *bar, const event_t *event);
|
||
|
||
// 预定义组件
|
||
extern statusbar_component_t statusbar_clock_component;
|
||
extern statusbar_component_t statusbar_cpu_component;
|
||
extern statusbar_component_t statusbar_memory_component;
|
||
extern statusbar_component_t statusbar_network_component;
|
||
#+END_SRC
|
||
|
||
** 架构分层图
|
||
|
||
#+BEGIN_EXAMPLE
|
||
┌─────────────────────────────────────────────────────────────┐
|
||
│ UI 抽象层 │
|
||
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
|
||
│ │ 渲染器管理 │ │ 状态栏组件 │ │ 通知系统 │ │
|
||
│ └──────────────┘ └──────────────┘ └──────────────┘ │
|
||
└─────────────────────────────────────────────────────────────┘
|
||
▲
|
||
│
|
||
┌─────────────────────────────────────────────────────────────┐
|
||
│ 业务抽象层 │
|
||
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
|
||
│ │ 客户端接口 │ │ 布局引擎 │ │ 命令系统 │ │
|
||
│ └──────────────┘ └──────────────┘ └──────────────┘ │
|
||
└─────────────────────────────────────────────────────────────┘
|
||
▲
|
||
│
|
||
┌─────────────────────────────────────────────────────────────┐
|
||
│ 服务抽象层 │
|
||
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
|
||
│ │ 显示后端 │ │ 事件总线 │ │ 插件系统 │ │
|
||
│ │ (X11/Wayland)│ │ │ │ │ │
|
||
│ └──────────────┘ └──────────────┘ └──────────────┘ │
|
||
└─────────────────────────────────────────────────────────────┘
|
||
▲
|
||
│
|
||
┌─────────────────────────────────────────────────────────────┐
|
||
│ 数据抽象层 │
|
||
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
|
||
│ │ 状态管理器 │ │ 配置系统 │ │ 资源缓存 │ │
|
||
│ └──────────────┘ └──────────────┘ └──────────────┘ │
|
||
└─────────────────────────────────────────────────────────────┘
|
||
▲
|
||
│
|
||
┌─────────────────────────────────────────────────────────────┐
|
||
│ 基础设施抽象层 │
|
||
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
|
||
│ │ 上下文管理 │ │ 日志系统 │ │ 错误处理 │ │
|
||
│ └──────────────┘ └──────────────┘ └──────────────┘ │
|
||
└─────────────────────────────────────────────────────────────┘
|
||
#+END_EXAMPLE
|
||
|
||
** 实施路径
|
||
|
||
*** 阶段1：基础设施层 (2-3周)
|
||
1. *上下文管理器*
|
||
- 创建 =wm_context_t=
|
||
- 修改现有代码使用上下文
|
||
- 保持向后兼容宏
|
||
|
||
2. *日志系统*
|
||
- 实现 =log.h/c=
|
||
- 替换所有 =logger/fatal/warn=
|
||
- 添加文件输出 handler
|
||
|
||
3. *错误处理*
|
||
- 实现 =error.h/c=
|
||
- 修复 GError 使用
|
||
- 添加错误恢复机制
|
||
|
||
*** 阶段2：数据抽象层 (3-4周)
|
||
1. *状态管理器*
|
||
- 实现 =state_manager_t=
|
||
- 迁移关键状态到统一管理
|
||
- 添加状态变更监听
|
||
|
||
2. *配置系统*
|
||
- 实现配置栈
|
||
- 支持配置文件热重载
|
||
- 添加配置验证
|
||
|
||
*** 阶段3：服务抽象层 (4-6周)
|
||
1. *显示后端抽象*
|
||
- 定义显示后端统一接口
|
||
- 实现 X11 后端（迁移现有 XCB 调用）
|
||
- 创建 Wayland 后端框架（仅接口定义）
|
||
- 实现 Mock 后端用于单元测试
|
||
- 修改核心逻辑使用显示后端接口
|
||
- 添加后端自动检测和运行时切换
|
||
|
||
2. *事件总线*
|
||
- 实现发布-订阅系统
|
||
- 迁移现有事件处理
|
||
- 添加事件日志
|
||
|
||
3. *插件系统*
|
||
- 实现插件加载器
|
||
- 定义插件接口
|
||
- 创建示例插件
|
||
|
||
*** 阶段4：业务抽象层 (6-8周)
|
||
1. *客户端重构*
|
||
- 定义客户端接口
|
||
- 实现状态机
|
||
- 拆分 client.c
|
||
|
||
2. *布局引擎*
|
||
- 提取布局算法
|
||
- 支持动态注册
|
||
- 添加布局预览
|
||
|
||
3. *命令系统*
|
||
- 统一命令接口
|
||
- 支持参数验证
|
||
- 添加自动完成
|
||
|
||
*** 阶段5：UI抽象层 (4-6周)
|
||
1. *渲染器管理*
|
||
- 统一渲染接口
|
||
- 支持多种渲染器
|
||
- 添加渲染缓存
|
||
|
||
2. *状态栏组件化*
|
||
- 提取组件接口
|
||
- 实现预定义组件
|
||
- 支持自定义组件
|
||
|
||
** 向后兼容策略
|
||
|
||
1. *渐进式迁移*
|
||
- 新旧API并存
|
||
- 使用宏提供兼容层
|
||
- 标记旧API为deprecated
|
||
|
||
2. *编译时选项*
|
||
#+BEGIN_SRC c
|
||
#ifdef USE_NEW_ARCH
|
||
// 使用新API
|
||
#else
|
||
// 使用旧API
|
||
#endif
|
||
#+END_SRC
|
||
|
||
3. *运行时切换*
|
||
- 支持命令行参数选择架构
|
||
- 便于性能对比和问题定位
|
||
|
||
** 测试策略
|
||
|
||
1. *单元测试*
|
||
- 每个抽象层独立测试
|
||
- 使用mock对象隔离依赖
|
||
|
||
2. *集成测试*
|
||
- 测试层间交互
|
||
- 端到端场景测试
|
||
|
||
3. *性能测试*
|
||
- 对比新旧架构性能
|
||
- 内存使用分析
|
||
- 响应时间测试
|
||
|
||
** 预期收益
|
||
|
||
*** 可维护性提升
|
||
- 清晰的职责划分
|
||
- 松耦合的模块设计
|
||
- 易于定位和修复问题
|
||
|
||
*** 可扩展性提升
|
||
- 插件化架构
|
||
- 组件化UI
|
||
- 动态配置系统
|
||
|
||
*** 可测试性提升
|
||
- 依赖注入支持
|
||
- Mock对象友好
|
||
- 隔离测试环境
|
||
|
||
*** 用户体验提升
|
||
- 配置热重载
|
||
- 插件生态
|
||
- 更好的错误提示
|
||
|
||
这个抽象层设计既保持了ZDWM的简洁高效，又大幅提升了可维护性和可扩展性，为项目的长期发展奠定坚实基础。
|
||
|
||
** 显示后端抽象与 Wayland 支持
|
||
|
||
*** 设计目标
|
||
|
||
通过引入显示后端抽象层，实现以下目标：
|
||
- 为 Wayland 移植奠定基础，适应显示服务器技术演进
|
||
- 显示逻辑与核心业务逻辑完全分离
|
||
- 支持运行时后端切换，用户可选择 X11 或 Wayland
|
||
- 便于使用 Mock 后端进行单元测试
|
||
|
||
*** 架构优势
|
||
|
||
1. *显示服务器无关性*: 核心窗口管理逻辑不依赖特定显示服务器
|
||
2. *渐进式迁移*: 先完善 X11 后端，再逐步实现 Wayland 后端
|
||
3. *性能无损*: 通过编译时优化和内联函数保持高性能
|
||
4. *测试友好*: Mock 后端使单元测试更简单
|
||
|
||
*** X11 后端实现重点
|
||
|
||
#+BEGIN_SRC c
|
||
// X11 后端的核心职责
|
||
- 管理 xcb_connection_t 和 xcb_screen_t
|
||
- 窗口生命周期管理（创建、销毁、映射、取消映射）
|
||
- ICCCM/EWMH 协议实现
|
||
- 事件转换（XCB 事件 → 通用 display_event_t）
|
||
- Cairo 集成（cairo_xcb_surface_t）
|
||
- 输入设备抓取（键盘、鼠标）
|
||
#+END_SRC
|
||
|
||
*** Wayland 后端实现路线图
|
||
|
||
*阶段1：基础框架（未来 3-6 个月）*
|
||
- 实现 Wayland 客户端协议绑定
|
||
- 支持 wl_display, wl_compositor, wl_shm
|
||
- 实现 xdg-shell 基础功能
|
||
- 窗口创建和基本管理
|
||
|
||
*阶段2：核心功能（未来 6-12 个月）*
|
||
- 完整的 xdg-shell 支持
|
||
- 输入事件处理（wl_seat, wl_pointer, wl_keyboard）
|
||
- 表面和帧回调（wl_surface, wl_callback）
|
||
- EGL/渲染集成
|
||
|
||
*阶段3：高级特性（未来 12-18 个月）*
|
||
- xdg-activation 协议（焦点管理）
|
||
- xdg-decoration 协议（服务器端装饰）
|
||
- wl_output 多显示器支持
|
||
- Layer-shell 支持（面板、覆盖层）
|
||
|
||
*** 后端切换策略
|
||
|
||
1. *编译时选择*（零成本抽象）
|
||
#+BEGIN_SRC c
|
||
#if defined(DISPLAY_BACKEND_X11)
|
||
#define DISPLAY_CALL(func, ...) x11_##func(__VA_ARGS__)
|
||
#elif defined(DISPLAY_BACKEND_WAYLAND)
|
||
#define DISPLAY_CALL(func, ...) wayland_##func(__VA_ARGS__)
|
||
#endif
|
||
#+END_SRC
|
||
|
||
2. *运行时切换*（灵活性）
|
||
#+BEGIN_SRC c
|
||
// 通过环境变量选择
|
||
export ZDWM_BACKEND=x11 // 或 wayland
|
||
|
||
// 通过命令行参数选择
|
||
zdwm --backend=x11
|
||
zdwm --backend=wayland
|
||
|
||
// 自动检测
|
||
if (getenv("WAYLAND_DISPLAY")) {
|
||
backend = &wayland_backend;
|
||
} else if (getenv("DISPLAY")) {
|
||
backend = &x11_backend;
|
||
}
|
||
#+END_SRC
|
||
|
||
*** 配置示例
|
||
|
||
#+BEGIN_SRC c
|
||
// 配置文件支持
|
||
typedef struct display_config_t {
|
||
display_backend_type_t backend;
|
||
struct {
|
||
bool enable_ssd; // 服务器端装饰（X11）
|
||
bool enable_csd; // 客户端装饰（Wayland）
|
||
} decoration;
|
||
struct {
|
||
bool enable_vsync;
|
||
bool use_egl; // EGL vs SHM（Wayland）
|
||
} rendering;
|
||
} display_config_t;
|
||
#+END_SRC
|
||
|
||
*** 兼容性考虑
|
||
|
||
1. *向后兼容*: 保持现有 XCB 调用接口，通过宏迁移到新接口
|
||
2. *功能对等*: 确保 X11 和 Wayland 后端功能一致性
|
||
3. *性能保持*: Wayland 后端性能应不低于 X11 后端
|
||
|
||
*** 测试策略
|
||
|
||
1. *Mock 后端测试*
|
||
#+BEGIN_SRC c
|
||
// 用于单元测试的模拟后端
|
||
static display_backend_t mock_backend = {
|
||
.name = "mock",
|
||
.init = mock_init,
|
||
.create_window = mock_create_window,
|
||
// ... 其他实现
|
||
};
|
||
|
||
// 测试核心逻辑
|
||
void test_client_management_with_mock_backend() {
|
||
wm_context_t *ctx = wm_context_create(DISPLAY_BACKEND_MOCK);
|
||
// 测试逻辑...
|
||
}
|
||
#+END_SRC
|
||
|
||
2. *双后端集成测试*
|
||
- 使用相同测试用例验证 X11 和 Wayland 后端
|
||
- 确保行为一致性
|
||
|
||
*** 预期收益
|
||
|
||
1. *未来兼容性*: 为 Wayland 移植奠定基础
|
||
2. *架构清晰*: 显示逻辑与核心逻辑分离
|
||
3. *测试友好*: Mock 后端简化单元测试
|
||
4. *性能无损*: 通过编译时优化保持高性能
|
||
5. *用户选择*: 用户可根据需求选择 X11 或 Wayland
|
||
|
||
这个显示后端抽象设计确保了 ZDWM 能够适应显示服务器技术的演进，同时保持当前的优秀性能和稳定性。
|