zedhugh/zdwm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

调整数据类型和接口函数命名规范

Browse Source
This commit is contained in:
Zedhugh Chen
2026-03-23 12:42:19 +08:00
parent 38572bd5f7
commit 34017fb5da
18 changed files with 609 additions and 608 deletions
Download Patch File Download Diff File Expand all files Collapse all files

296
src/core/state.c
View File

@@ -7,59 +7,59 @@
#include "core/wm_desc.h"
#include "utils.h"
void wm_state_init(wm_state_t *state, const wm_output_info_t *outputs,
size_t output_count, const wm_workspace_desc_t *workspaces,
size_t workspace_count) {
void state_init(state_t *state, const output_info_t *outputs,
size_t output_count, const workspace_desc_t *workspaces,
size_t workspace_count) {
p_clear(state, 1);
state->outputs = p_new(wm_output_t, output_count);
state->outputs = p_new(output_t, output_count);
for (size_t i = 0; i < output_count; i++) {
const wm_output_info_t *output_info = &outputs[i];
wm_output_t *output = &state->outputs[i];
const output_info_t *output_info = &outputs[i];
output_t *output = &state->outputs[i];
output->id = (wm_output_id_t)i;
output->current_workspace_id = WM_WORKSPACE_ID_INVALID;
output->id = (output_id_t)i;
output->current_workspace_id = ZDWM_WORKSPACE_ID_INVALID;
output->name = p_strdup_nullable(output_info->name);
output->geometry = output_info->geometry;
output->workarea = output_info->geometry;
}
state->output_count = output_count;
state->workspaces = p_new(wm_workspace_t, workspace_count);
state->workspaces = p_new(workspace_t, workspace_count);
for (size_t i = 0; i < workspace_count; i++) {
const wm_workspace_desc_t *workspace_desc = &workspaces[i];
if (!wm_workspace_desc_valid(workspace_desc, output_count)) {
const workspace_desc_t *workspace_desc = &workspaces[i];
if (!workspace_desc_valid(workspace_desc, output_count)) {
fatal("workspace desc at index %zu invalid", i);
}
wm_output_t *output = &state->outputs[workspace_desc->output_index];
wm_workspace_t *workspace = &state->workspaces[i];
workspace->id = (wm_workspace_id_t)i;
output_t *output = &state->outputs[workspace_desc->output_index];
workspace_t *workspace = &state->workspaces[i];
workspace->id = (workspace_id_t)i;
workspace->output_id = output->id;
workspace->focused_window_id = WM_WINDOW_ID_INVALID;
workspace->focused_window_id = ZDWM_WINDOW_ID_INVALID;
workspace->available_layouts =
p_copy(workspace_desc->layout_ids, workspace_desc->layout_count);
workspace->layout_id = workspace_desc->initial_layout_id;
workspace->layout_count = workspace_desc->layout_count;
workspace->name = p_strdup(workspace_desc->name);
if (output->current_workspace_id == WM_WORKSPACE_ID_INVALID) {
if (output->current_workspace_id == ZDWM_WORKSPACE_ID_INVALID) {
output->current_workspace_id = workspace->id;
}
}
state->workspace_count = workspace_count;
for (size_t i = 0; i < state->output_count; i++) {
const wm_output_t *output = &state->outputs[i];
if (output->current_workspace_id == WM_WORKSPACE_ID_INVALID) {
const output_t *output = &state->outputs[i];
if (output->current_workspace_id == ZDWM_WORKSPACE_ID_INVALID) {
fatal("output at index %zu has no workspace", i);
}
}
}
void wm_state_cleanup(wm_state_t *state) {
void state_cleanup(state_t *state) {
for (size_t i = 0; i < state->window_count; i++) {
wm_window_t *window = &state->windows[i];
window_t *window = &state->windows[i];
p_delete(&window->title);
p_delete(&window->app_id);
p_delete(&window->class_name);
@@ -71,7 +71,7 @@ void wm_state_cleanup(wm_state_t *state) {
state->window_capacity = 0;
for (size_t i = 0; i < state->workspace_count; i++) {
wm_workspace_t *workspace = &state->workspaces[i];
workspace_t *workspace = &state->workspaces[i];
p_delete(&workspace->name);
p_delete(&workspace->available_layouts);
workspace->layout_count = 0;
@@ -80,7 +80,7 @@ void wm_state_cleanup(wm_state_t *state) {
state->workspace_count = 0;
for (size_t i = 0; i < state->output_count; i++) {
wm_output_t *output = &state->outputs[i];
output_t *output = &state->outputs[i];
p_delete(&output->name);
}
p_delete(&state->outputs);
@@ -89,44 +89,42 @@ void wm_state_cleanup(wm_state_t *state) {
p_clear(state, 1);
}
const wm_workspace_t *wm_state_workspace_get(const wm_state_t *state,
wm_workspace_id_t id) {
const workspace_t *state_workspace_get(const state_t *state,
workspace_id_t id) {
if (id < state->workspace_count) return &state->workspaces[id];
return nullptr;
}
const wm_workspace_t *wm_state_workspace_at(const wm_state_t *state,
size_t index) {
const workspace_t *state_workspace_at(const state_t *state, size_t index) {
if (index < state->workspace_count) return &state->workspaces[index];
return nullptr;
}
static void wm_state_workspace_adjust_focused_window(
const wm_state_t *state, wm_workspace_id_t workspace_id) {
wm_workspace_t *workspace =
(wm_workspace_t *)wm_state_workspace_get(state, workspace_id);
static void state_workspace_adjust_focused_window(const state_t *state,
workspace_id_t workspace_id) {
workspace_t *workspace =
(workspace_t *)state_workspace_get(state, workspace_id);
if (!workspace) return;
const wm_window_t *window =
wm_state_window_get(state, workspace->focused_window_id);
const window_t *window =
state_window_get(state, workspace->focused_window_id);
if (window && window->workspace_id == workspace_id) return;
for (size_t i = state->window_count; i > 0; i--) {
wm_window_id_t window_id = state->stack_order[i - 1];
const wm_window_t *window = wm_state_window_get(state, window_id);
window_id_t window_id = state->stack_order[i - 1];
const window_t *window = state_window_get(state, window_id);
if (window && window->workspace_id == workspace_id) {
workspace->focused_window_id = window_id;
return;
}
}
workspace->focused_window_id = WM_WINDOW_ID_INVALID;
workspace->focused_window_id = ZDWM_WINDOW_ID_INVALID;
}
bool wm_state_workspace_cycle_layout(wm_state_t *state,
wm_workspace_id_t workspace_id) {
wm_workspace_t *workspace =
(wm_workspace_t *)wm_state_workspace_get(state, workspace_id);
bool state_workspace_cycle_layout(state_t *state, workspace_id_t workspace_id) {
workspace_t *workspace =
(workspace_t *)state_workspace_get(state, workspace_id);
if (!workspace) return false;
size_t next_index = 0;
@@ -146,11 +144,11 @@ bool wm_state_workspace_cycle_layout(wm_state_t *state,
return true;
}
bool wm_state_workspace_set_layout_by_index(wm_state_t *state,
wm_workspace_id_t workspace_id,
size_t index) {
wm_workspace_t *workspace =
(wm_workspace_t *)wm_state_workspace_get(state, workspace_id);
bool state_workspace_set_layout_by_index(state_t *state,
workspace_id_t workspace_id,
size_t index) {
workspace_t *workspace =
(workspace_t *)state_workspace_get(state, workspace_id);
if (!workspace) return false;
if (index >= workspace->layout_count) return false;
@@ -158,11 +156,11 @@ bool wm_state_workspace_set_layout_by_index(wm_state_t *state,
return true;
}
bool wm_state_workspace_set_layout_by_id(wm_state_t *state,
wm_workspace_id_t workspace_id,
wm_layout_id_t layout_id) {
wm_workspace_t *workspace =
(wm_workspace_t *)wm_state_workspace_get(state, workspace_id);
bool state_workspace_set_layout_by_id(state_t *state,
workspace_id_t workspace_id,
layout_id_t layout_id) {
workspace_t *workspace =
(workspace_t *)state_workspace_get(state, workspace_id);
if (!workspace) return false;
for (size_t i = 0; i < workspace->layout_count; i++) {
if (workspace->available_layouts[i] == layout_id) {
@@ -174,29 +172,29 @@ bool wm_state_workspace_set_layout_by_id(wm_state_t *state,
return false;
}
void wm_state_workspace_set_focused_window(wm_state_t *state,
wm_workspace_id_t workspace_id,
wm_window_id_t window_id) {
wm_workspace_t *workspace =
(wm_workspace_t *)wm_state_workspace_get(state, workspace_id);
void state_workspace_set_focused_window(state_t *state,
workspace_id_t workspace_id,
window_id_t window_id) {
workspace_t *workspace =
(workspace_t *)state_workspace_get(state, workspace_id);
if (!workspace) return;
for (size_t i = 0; i < state->window_count; i++) {
wm_window_t *window = &state->windows[i];
window_t *window = &state->windows[i];
if (window->id == window_id && window->workspace_id == workspace_id) {
workspace->focused_window_id = window_id;
return;
}
}
wm_state_workspace_adjust_focused_window(state, workspace_id);
state_workspace_adjust_focused_window(state, workspace_id);
}
size_t wm_state_workspace_count(const wm_state_t *state) {
size_t state_workspace_count(const state_t *state) {
return state->workspace_count;
}
bool wm_state_workspace_valid(const wm_state_t *state, wm_workspace_id_t id) {
bool state_workspace_valid(const state_t *state, workspace_id_t id) {
return id < state->workspace_count;
/* 线性扫描作为备用 */
@@ -211,39 +209,35 @@ bool wm_state_workspace_valid(const wm_state_t *state, wm_workspace_id_t id) {
#endif
}
const wm_output_t *wm_state_output_get(const wm_state_t *state,
wm_output_id_t id) {
const output_t *state_output_get(const state_t *state, output_id_t id) {
if (id < state->output_count) return &state->outputs[id];
return nullptr;
}
const wm_output_t *wm_state_output_at(const wm_state_t *state, size_t index) {
const output_t *state_output_at(const state_t *state, size_t index) {
if (index < state->output_count) return &state->outputs[index];
return nullptr;
}
void wm_state_output_set_workarea(wm_state_t *state, wm_output_id_t output_id,
wm_rect_t workarea) {
wm_output_t *output = (wm_output_t *)wm_state_output_get(state, output_id);
void state_output_set_workarea(state_t *state, output_id_t output_id,
rect_t workarea) {
output_t *output = (output_t *)state_output_get(state, output_id);
if (output) output->workarea = workarea;
}
void wm_state_output_set_current_workspace(wm_state_t *state,
wm_output_id_t output_id,
wm_workspace_id_t workspace_id) {
wm_output_t *output = (wm_output_t *)wm_state_output_get(state, output_id);
void state_output_set_current_workspace(state_t *state, output_id_t output_id,
workspace_id_t workspace_id) {
output_t *output = (output_t *)state_output_get(state, output_id);
if (!output) return;
const wm_workspace_t *workspace = wm_state_workspace_get(state, workspace_id);
const workspace_t *workspace = state_workspace_get(state, workspace_id);
if (!workspace || workspace->output_id != output_id) return;
output->current_workspace_id = workspace_id;
}
size_t wm_state_output_count(const wm_state_t *state) {
return state->output_count;
}
size_t state_output_count(const state_t *state) { return state->output_count; }
bool wm_state_output_valid(const wm_state_t *state, wm_output_id_t id) {
bool state_output_valid(const state_t *state, output_id_t id) {
return id < state->output_count;
/* 线性扫描作为备用 */
@@ -258,10 +252,9 @@ bool wm_state_output_valid(const wm_state_t *state, wm_output_id_t id) {
#endif
}
const wm_window_t *wm_state_window_add(wm_state_t *state,
const wm_window_info_t *info) {
wm_window_id_t id = info->id;
wm_window_t *window = (wm_window_t *)wm_state_window_get(state, id);
const window_t *state_window_add(state_t *state, const window_info_t *info) {
window_id_t id = info->id;
window_t *window = (window_t *)state_window_get(state, id);
if (!window) {
if (state->window_count == state->window_capacity) {
size_t capacity = next_capacity(state->window_capacity);
@@ -272,27 +265,26 @@ const wm_window_t *wm_state_window_add(wm_state_t *state,
window = &state->windows[state->window_count];
p_clear(window, 1);
window->id = id;
window->workspace_id = WM_WORKSPACE_ID_INVALID;
window->workspace_id = ZDWM_WORKSPACE_ID_INVALID;
state->stack_order[state->window_count] = id;
state->window_count++;
}
wm_state_window_set_geometry_mode(state, id, info->geometry_mode);
wm_state_window_set_urgent(state, id, info->urgent);
wm_state_window_set_fixed_size(state, id, info->fixed_size);
wm_state_window_set_frame_rect(state, id, info->frame_rect);
wm_state_window_set_title(state, id, info->title);
wm_state_window_set_app_id(state, id, info->app_id);
wm_state_window_set_class(state, id, info->class_name);
wm_state_window_set_instance(state, id, info->instance_name);
wm_state_window_set_skip_taskbar(state, id, info->skip_taskbar);
state_window_set_geometry_mode(state, id, info->geometry_mode);
state_window_set_urgent(state, id, info->urgent);
state_window_set_fixed_size(state, id, info->fixed_size);
state_window_set_frame_rect(state, id, info->frame_rect);
state_window_set_title(state, id, info->title);
state_window_set_app_id(state, id, info->app_id);
state_window_set_class(state, id, info->class_name);
state_window_set_instance(state, id, info->instance_name);
state_window_set_skip_taskbar(state, id, info->skip_taskbar);
return window;
}
const wm_window_t *wm_state_window_get(const wm_state_t *state,
wm_window_id_t id) {
const window_t *state_window_get(const state_t *state, window_id_t id) {
for (size_t i = 0; i < state->window_count; i++) {
if (state->windows[i].id == id) return &state->windows[i];
}
@@ -300,13 +292,13 @@ const wm_window_t *wm_state_window_get(const wm_state_t *state,
return nullptr;
}
const wm_window_t *wm_state_window_at(const wm_state_t *state, size_t index) {
const window_t *state_window_at(const state_t *state, size_t index) {
if (index < state->window_count) return &state->windows[index];
return nullptr;
}
void wm_state_window_remove(wm_state_t *state, wm_window_id_t id) {
void state_window_remove(state_t *state, window_id_t id) {
bool matched = false;
size_t index = 0;
for (size_t i = 0; i < state->window_count; i++) {
@@ -318,8 +310,8 @@ void wm_state_window_remove(wm_state_t *state, wm_window_id_t id) {
}
if (!matched) return;
wm_window_t *window = &state->windows[index];
wm_workspace_id_t workspace_id = window->workspace_id;
window_t *window = &state->windows[index];
workspace_id_t workspace_id = window->workspace_id;
p_delete(&window->title);
p_delete(&window->app_id);
p_delete(&window->class_name);
@@ -330,8 +322,8 @@ void wm_state_window_remove(wm_state_t *state, wm_window_id_t id) {
}
window = &state->windows[state->window_count - 1];
p_clear(window, 1);
window->id = WM_WINDOW_ID_INVALID;
window->workspace_id = WM_WORKSPACE_ID_INVALID;
window->id = ZDWM_WINDOW_ID_INVALID;
window->workspace_id = ZDWM_WORKSPACE_ID_INVALID;
matched = false;
for (size_t i = 0; i < state->window_count; i++) {
@@ -345,109 +337,105 @@ void wm_state_window_remove(wm_state_t *state, wm_window_id_t id) {
for (size_t i = index + 1; i < state->window_count; i++) {
state->stack_order[i - 1] = state->stack_order[i];
}
state->stack_order[state->window_count - 1] = WM_WINDOW_ID_INVALID;
state->stack_order[state->window_count - 1] = ZDWM_WINDOW_ID_INVALID;
}
state->window_count--;
wm_workspace_t *workspace =
(wm_workspace_t *)wm_state_workspace_get(state, workspace_id);
workspace_t *workspace =
(workspace_t *)state_workspace_get(state, workspace_id);
if (workspace && workspace->focused_window_id == id) {
wm_state_workspace_adjust_focused_window(state, workspace_id);
state_workspace_adjust_focused_window(state, workspace_id);
}
}
size_t wm_state_window_count(const wm_state_t *state) {
return state->window_count;
}
size_t state_window_count(const state_t *state) { return state->window_count; }
void wm_state_window_set_workspace(wm_state_t *state, wm_window_id_t window_id,
wm_workspace_id_t workspace_id) {
const wm_workspace_t *workspace = wm_state_workspace_get(state, workspace_id);
wm_window_t *window = (wm_window_t *)wm_state_window_get(state, window_id);
void state_window_set_workspace(state_t *state, window_id_t window_id,
workspace_id_t workspace_id) {
const workspace_t *workspace = state_workspace_get(state, workspace_id);
window_t *window = (window_t *)state_window_get(state, window_id);
if (!workspace || !window || window->workspace_id == workspace_id) return;
workspace = wm_state_workspace_get(state, window->workspace_id);
workspace = state_workspace_get(state, window->workspace_id);
window->workspace_id = workspace_id;
if (workspace && workspace->focused_window_id == window_id) {
wm_state_workspace_adjust_focused_window(state, workspace->id);
state_workspace_adjust_focused_window(state, workspace->id);
}
wm_state_workspace_adjust_focused_window(state, workspace_id);
state_workspace_adjust_focused_window(state, workspace_id);
}
void wm_state_window_set_geometry_mode(
wm_state_t *state, wm_window_id_t window_id,
wm_window_geometry_mode_t geometry_mode) {
wm_window_t *window = (wm_window_t *)wm_state_window_get(state, window_id);
void state_window_set_geometry_mode(state_t *state, window_id_t window_id,
window_geometry_mode_t geometry_mode) {
window_t *window = (window_t *)state_window_get(state, window_id);
if (!window) return;
window->geometry_mode = geometry_mode;
}
void wm_state_window_set_floating(wm_state_t *state, wm_window_id_t window_id,
bool floating) {
wm_window_t *window = (wm_window_t *)wm_state_window_get(state, window_id);
void state_window_set_floating(state_t *state, window_id_t window_id,
bool floating) {
window_t *window = (window_t *)state_window_get(state, window_id);
if (!window) return;
window->floating = floating;
}
void wm_state_window_set_sticky(wm_state_t *state, wm_window_id_t window_id,
bool sticky) {
wm_window_t *window = (wm_window_t *)wm_state_window_get(state, window_id);
void state_window_set_sticky(state_t *state, window_id_t window_id,
bool sticky) {
window_t *window = (window_t *)state_window_get(state, window_id);
if (!window) return;
window->sticky = sticky;
if (window->sticky) wm_state_window_set_floating(state, window_id, true);
if (window->sticky) state_window_set_floating(state, window_id, true);
}
void wm_state_window_set_urgent(wm_state_t *state, wm_window_id_t window_id,
bool urgent) {
wm_window_t *window = (wm_window_t *)wm_state_window_get(state, window_id);
void state_window_set_urgent(state_t *state, window_id_t window_id,
bool urgent) {
window_t *window = (window_t *)state_window_get(state, window_id);
if (!window) return;
window->urgent = urgent;
}
void wm_state_window_set_fixed_size(wm_state_t *state, wm_window_id_t window_id,
bool fixed_size) {
wm_window_t *window = (wm_window_t *)wm_state_window_get(state, window_id);
void state_window_set_fixed_size(state_t *state, window_id_t window_id,
bool fixed_size) {
window_t *window = (window_t *)state_window_get(state, window_id);
if (!window) return;
window->fixed_size = fixed_size;
if (fixed_size) wm_state_window_set_floating(state, window_id, true);
if (fixed_size) state_window_set_floating(state, window_id, true);
}
void wm_state_window_set_skip_taskbar(wm_state_t *state,
wm_window_id_t window_id,
bool skip_taskbar) {
wm_window_t *window = (wm_window_t *)wm_state_window_get(state, window_id);
void state_window_set_skip_taskbar(state_t *state, window_id_t window_id,
bool skip_taskbar) {
window_t *window = (window_t *)state_window_get(state, window_id);
if (!window) return;
window->skip_taskbar = skip_taskbar;
}
void wm_state_window_set_float_rect(wm_state_t *state, wm_window_id_t window_id,
wm_rect_t float_rect) {
wm_window_t *window = (wm_window_t *)wm_state_window_get(state, window_id);
void state_window_set_float_rect(state_t *state, window_id_t window_id,
rect_t float_rect) {
window_t *window = (window_t *)state_window_get(state, window_id);
if (!window) return;
window->float_rect = float_rect;
}
void wm_state_window_set_frame_rect(wm_state_t *state, wm_window_id_t window_id,
wm_rect_t frame_rect) {
wm_window_t *window = (wm_window_t *)wm_state_window_get(state, window_id);
void state_window_set_frame_rect(state_t *state, window_id_t window_id,
rect_t frame_rect) {
window_t *window = (window_t *)state_window_get(state, window_id);
if (!window) return;
window->frame_rect = frame_rect;
}
bool wm_state_window_set_title(wm_state_t *state, wm_window_id_t window_id,
const char *title) {
wm_window_t *window = (wm_window_t *)wm_state_window_get(state, window_id);
bool state_window_set_title(state_t *state, window_id_t window_id,
const char *title) {
window_t *window = (window_t *)state_window_get(state, window_id);
if (!window) return false;
p_delete(&window->title);
@@ -456,9 +444,9 @@ bool wm_state_window_set_title(wm_state_t *state, wm_window_id_t window_id,
return true;
}
bool wm_state_window_set_app_id(wm_state_t *state, wm_window_id_t window_id,
const char *app_id) {
wm_window_t *window = (wm_window_t *)wm_state_window_get(state, window_id);
bool state_window_set_app_id(state_t *state, window_id_t window_id,
const char *app_id) {
window_t *window = (window_t *)state_window_get(state, window_id);
if (!window) return false;
p_delete(&window->app_id);
@@ -466,9 +454,9 @@ bool wm_state_window_set_app_id(wm_state_t *state, wm_window_id_t window_id,
return true;
}
bool wm_state_window_set_class(wm_state_t *state, wm_window_id_t window_id,
const char *class_name) {
wm_window_t *window = (wm_window_t *)wm_state_window_get(state, window_id);
bool state_window_set_class(state_t *state, window_id_t window_id,
const char *class_name) {
window_t *window = (window_t *)state_window_get(state, window_id);
if (!window) return false;
p_delete(&window->class_name);
@@ -476,9 +464,9 @@ bool wm_state_window_set_class(wm_state_t *state, wm_window_id_t window_id,
return true;
}
bool wm_state_window_set_instance(wm_state_t *state, wm_window_id_t window_id,
const char *instance_name) {
wm_window_t *window = (wm_window_t *)wm_state_window_get(state, window_id);
bool state_window_set_instance(state_t *state, window_id_t window_id,
const char *instance_name) {
window_t *window = (window_t *)state_window_get(state, window_id);
if (!window) return false;
p_delete(&window->instance_name);
@@ -487,16 +475,16 @@ bool wm_state_window_set_instance(wm_state_t *state, wm_window_id_t window_id,
return true;
}
const wm_window_id_t *wm_state_stack_order(const wm_state_t *state) {
const window_id_t *state_stack_order(const state_t *state) {
return state->stack_order;
}
wm_window_id_t wm_state_stack_at(const wm_state_t *state, size_t index) {
if (index >= state->window_count) return WM_WINDOW_ID_INVALID;
window_id_t state_stack_at(const state_t *state, size_t index) {
if (index >= state->window_count) return ZDWM_WINDOW_ID_INVALID;
return state->stack_order[index];
}
bool wm_state_stack_raise(wm_state_t *state, wm_window_id_t window_id) {
bool state_stack_raise(state_t *state, window_id_t window_id) {
bool matched = false;
size_t index = 0;
for (size_t i = 0; i < state->window_count; i++) {
@@ -517,7 +505,7 @@ bool wm_state_stack_raise(wm_state_t *state, wm_window_id_t window_id) {
return true;
}
bool wm_state_stack_lower(wm_state_t *state, wm_window_id_t window_id) {
bool state_stack_lower(state_t *state, window_id_t window_id) {
bool matched = false;
size_t index = 0;
for (size_t i = 0; i < state->window_count; i++) {