mirrors/maomaowm
1
0
Fork 0
mirror of https://github.com/DreamMaoMao/maomaowm.git synced 2026-05-03 06:46:38 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Translate all Chinese comments to English in source files

Browse source 
- Translate comments in src/client/client.h
- Translate comments in src/config/parse_config.h
- Translate comments in src/data/static_keymap.h
- Translate comments in src/dispatch/bind_define.h
- Translate comments in src/ext-protocol/*.h
- Translate comments in src/fetch/*.h
- Translate comments in src/layout/*.h
- Translate comments in src/mango.c

All Chinese comments have been accurately translated to English
while preserving the technical meaning and context.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
copilot-swe-agent[bot] 2026-02-18 09:50:35 +00:00
parent 288710ad9e
commit 2c181fcb21
16 changed files with 396 additions and 396 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/client/client.h
View file

@ -427,7 +427,7 @@ static inline int32_t client_is_x11_popup(Client *c) {
#ifdef XWAYLAND #ifdef XWAYLAND
if (client_is_x11(c)) { if (client_is_x11(c)) {
struct wlr_xwayland_surface *surface = c->surface.xwayland; struct wlr_xwayland_surface *surface = c->surface.xwayland;
// 处理不需要焦点的窗口类型 // Handle window types that don't need focus
const uint32_t no_focus_types[] = { const uint32_t no_focus_types[] = {
WLR_XWAYLAND_NET_WM_WINDOW_TYPE_COMBO, WLR_XWAYLAND_NET_WM_WINDOW_TYPE_COMBO,
WLR_XWAYLAND_NET_WM_WINDOW_TYPE_DND, WLR_XWAYLAND_NET_WM_WINDOW_TYPE_DND,
@ -438,7 +438,7 @@ static inline int32_t client_is_x11_popup(Client *c) {
WLR_XWAYLAND_NET_WM_WINDOW_TYPE_SPLASH, WLR_XWAYLAND_NET_WM_WINDOW_TYPE_SPLASH,
WLR_XWAYLAND_NET_WM_WINDOW_TYPE_TOOLTIP, WLR_XWAYLAND_NET_WM_WINDOW_TYPE_TOOLTIP,
WLR_XWAYLAND_NET_WM_WINDOW_TYPE_UTILITY}; WLR_XWAYLAND_NET_WM_WINDOW_TYPE_UTILITY};
// 检查窗口类型是否需要禁止焦点 // Check if window type needs to disable focus
for (size_t i = 0; for (size_t i = 0;
i < sizeof(no_focus_types) / sizeof(no_focus_types[0]); ++i) { i < sizeof(no_focus_types) / sizeof(no_focus_types[0]); ++i) {
if (wlr_xwayland_surface_has_window_type(surface, if (wlr_xwayland_surface_has_window_type(surface,

220
src/config/parse_config.h
View file

@ -485,7 +485,7 @@ int32_t parse_circle_direction(const char *str) {
} }
lowerStr[i] = '\0'; lowerStr[i] = '\0';
// 根据转换后的小写字符串返回对应的枚举值 // Return corresponding enum value based on converted lowercase string
if (strcmp(lowerStr, "next") == 0) { if (strcmp(lowerStr, "next") == 0) {
return NEXT; return NEXT;
} else { } else {
@ -494,7 +494,7 @@ int32_t parse_circle_direction(const char *str) {
} }
int32_t parse_direction(const char *str) { int32_t parse_direction(const char *str) {
// 将输入字符串转换为小写 // Convert input string to lowercase
char lowerStr[10]; char lowerStr[10];
int32_t i = 0; int32_t i = 0;
while (str[i] && i < 9) { while (str[i] && i < 9) {
@ -503,7 +503,7 @@ int32_t parse_direction(const char *str) {
} }
lowerStr[i] = '\0'; lowerStr[i] = '\0';
// 根据转换后的小写字符串返回对应的枚举值 // Return corresponding enum value based on converted lowercase string
if (strcmp(lowerStr, "up") == 0) { if (strcmp(lowerStr, "up") == 0) {
return UP; return UP;
} else if (strcmp(lowerStr, "down") == 0) { } else if (strcmp(lowerStr, "down") == 0) {
@ -518,7 +518,7 @@ int32_t parse_direction(const char *str) {
} }
int32_t parse_fold_state(const char *str) { int32_t parse_fold_state(const char *str) {
// 将输入字符串转换为小写 // Convert input string to lowercase
char lowerStr[10]; char lowerStr[10];
int32_t i = 0; int32_t i = 0;
while (str[i] && i < 9) { while (str[i] && i < 9) {
@ -527,7 +527,7 @@ int32_t parse_fold_state(const char *str) {
} }
lowerStr[i] = '\0'; lowerStr[i] = '\0';
// 根据转换后的小写字符串返回对应的枚举值 // Return corresponding enum value based on converted lowercase string
if (strcmp(lowerStr, "fold") == 0) { if (strcmp(lowerStr, "fold") == 0) {
return FOLD; return FOLD;
} else if (strcmp(lowerStr, "unfold") == 0) { } else if (strcmp(lowerStr, "unfold") == 0) {
@ -554,7 +554,7 @@ int64_t parse_color(const char *hex_str) {
return (int64_t)hex_num; return (int64_t)hex_num;
} }
// 辅助函数：检查字符串是否以指定的前缀开头（忽略大小写） // Helper function: check if string starts with specified prefix (case insensitive)
static bool starts_with_ignore_case(const char *str, const char *prefix) { static bool starts_with_ignore_case(const char *str, const char *prefix) {
while (*prefix) { while (*prefix) {
if (tolower(*str) != tolower(*prefix)) { if (tolower(*str) != tolower(*prefix)) {
@ -632,22 +632,22 @@ uint32_t parse_mod(const char *mod_str) {
char *saveptr = NULL; char *saveptr = NULL;
bool match_success = false; bool match_success = false;
// 复制并转换为小写 // Copy and convert to lowercase
strncpy(input_copy, mod_str, sizeof(input_copy) - 1); strncpy(input_copy, mod_str, sizeof(input_copy) - 1);
input_copy[sizeof(input_copy) - 1] = '\0'; input_copy[sizeof(input_copy) - 1] = '\0';
for (char *p = input_copy; *p; p++) { for (char *p = input_copy; *p; p++) {
*p = tolower(*p); *p = tolower(*p);
} }
// 分割处理每个部分 // Split and process each part
token = strtok_r(input_copy, "+", &saveptr); token = strtok_r(input_copy, "+", &saveptr);
while (token != NULL) { while (token != NULL) {
// 去除空白 // Remove whitespace
while (*token == ' ' || *token == '\t') while (*token == ' ' || *token == '\t')
token++; token++;
if (strncmp(token, "code:", 5) == 0) { if (strncmp(token, "code:", 5) == 0) {
// 处理 code: 形式 // Handle code: format
char *endptr; char *endptr;
errno = 0; errno = 0;
long keycode = strtol(token + 5, &endptr, 10); long keycode = strtol(token + 5, &endptr, 10);
@ -678,7 +678,7 @@ uint32_t parse_mod(const char *mod_str) {
} }
} }
} else { } else {
// 完整的 modifier 检查（保留原始所有检查项） // Complete modifier check (preserve all original checks)
if (!strcmp(token, "super") || !strcmp(token, "super_l") || if (!strcmp(token, "super") || !strcmp(token, "super_l") ||
!strcmp(token, "super_r")) { !strcmp(token, "super_r")) {
mod |= WLR_MODIFIER_LOGO; mod |= WLR_MODIFIER_LOGO;
@ -723,7 +723,7 @@ uint32_t parse_mod(const char *mod_str) {
return mod; return mod;
} }
// 定义辅助函数：在 keymap 中查找 keysym 对应的多个 keycode // Define helper function: find multiple keycodes corresponding to keysym in keymap
static int32_t find_keycodes_for_keysym(struct xkb_keymap *keymap, static int32_t find_keycodes_for_keysym(struct xkb_keymap *keymap,
xkb_keysym_t sym, xkb_keysym_t sym,
MultiKeycode *multi_kc) { MultiKeycode *multi_kc) {
@ -738,7 +738,7 @@ static int32_t find_keycodes_for_keysym(struct xkb_keymap *keymap,
for (xkb_keycode_t keycode = min_keycode; for (xkb_keycode_t keycode = min_keycode;
keycode <= max_keycode && found_count < 3; keycode++) { keycode <= max_keycode && found_count < 3; keycode++) {
// 使用布局0和层级0 // Use layout 0 and level 0
const xkb_keysym_t *syms; const xkb_keysym_t *syms;
int32_t num_syms = int32_t num_syms =
xkb_keymap_key_get_syms_by_level(keymap, keycode, 0, 0, &syms); xkb_keymap_key_get_syms_by_level(keymap, keycode, 0, 0, &syms);
@ -777,7 +777,7 @@ void cleanup_config_keymap(void) {
} }
void create_config_keymap(void) { void create_config_keymap(void) {
// 初始化 xkb 上下文和 keymap // Initialize xkb context and keymap
if (config.ctx == NULL) { if (config.ctx == NULL) {
config.ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS); config.ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
@ -790,16 +790,16 @@ void create_config_keymap(void) {
} }
KeySymCode parse_key(const char *key_str, bool isbindsym) { KeySymCode parse_key(const char *key_str, bool isbindsym) {
KeySymCode kc = {0}; // 初始化为0 KeySymCode kc = {0}; // Initialize to 0
if (config.keymap == NULL || config.ctx == NULL) { if (config.keymap == NULL || config.ctx == NULL) {
// 处理错误 // Handle error
kc.type = KEY_TYPE_SYM; kc.type = KEY_TYPE_SYM;
kc.keysym = XKB_KEY_NoSymbol; kc.keysym = XKB_KEY_NoSymbol;
return kc; return kc;
} }
// 处理 code: 前缀的情况 // Handle code: prefix case
if (strncmp(key_str, "code:", 5) == 0) { if (strncmp(key_str, "code:", 5) == 0) {
char *endptr; char *endptr;
errno = 0; errno = 0;
@ -813,7 +813,7 @@ KeySymCode parse_key(const char *key_str, bool isbindsym) {
} }
kc.type = KEY_TYPE_CODE; kc.type = KEY_TYPE_CODE;
kc.keycode.keycode1 = keycode; // 只设置第一个 kc.keycode.keycode1 = keycode; // Only set the first one
kc.keycode.keycode2 = 0; kc.keycode.keycode2 = 0;
kc.keycode.keycode3 = 0; kc.keycode.keycode3 = 0;
return kc; return kc;
@ -830,42 +830,42 @@ KeySymCode parse_key(const char *key_str, bool isbindsym) {
} }
if (sym != XKB_KEY_NoSymbol) { if (sym != XKB_KEY_NoSymbol) {
// 尝试找到对应的多个 keycode // Try to find corresponding multiple keycodes
int32_t found_count = int32_t found_count =
find_keycodes_for_keysym(config.keymap, sym, &kc.keycode); find_keycodes_for_keysym(config.keymap, sym, &kc.keycode);
if (found_count > 0) { if (found_count > 0) {
kc.type = KEY_TYPE_CODE; kc.type = KEY_TYPE_CODE;
kc.keysym = sym; // 仍然保存 keysym 供参考 kc.keysym = sym; // Still save keysym for reference
} else { } else {
kc.type = KEY_TYPE_SYM; kc.type = KEY_TYPE_SYM;
kc.keysym = sym; kc.keysym = sym;
// keycode 字段保持为0 // keycode field remains 0
} }
} else { } else {
// 无法解析的键名 // Unable to parse key name
kc.type = KEY_TYPE_SYM; kc.type = KEY_TYPE_SYM;
kc.keysym = XKB_KEY_NoSymbol; kc.keysym = XKB_KEY_NoSymbol;
fprintf( fprintf(
stderr, stderr,
"\033[1m\033[31m[ERROR]:\033[33m Unknown key: \033[1m\033[31m%s\n", "\033[1m\033[31m[ERROR]:\033[33m Unknown key: \033[1m\033[31m%s\n",
key_str); key_str);
// keycode 字段保持为0 // keycode field remains 0
} }
return kc; return kc;
} }
uint32_t parse_button(const char *str) { uint32_t parse_button(const char *str) {
// 将输入字符串转换为小写 // Convert input string to lowercase
char lowerStr[20]; char lowerStr[20];
int32_t i = 0; int32_t i = 0;
while (str[i] && i < 19) { while (str[i] && i < 19) {
lowerStr[i] = tolower(str[i]); lowerStr[i] = tolower(str[i]);
i++; i++;
} }
lowerStr[i] = '\0'; // 确保字符串正确终止 lowerStr[i] = '\0'; // Ensure string terminates correctly
// 根据转换后的小写字符串返回对应的按钮编号 // Return corresponding button number based on converted lowercase string
if (strcmp(lowerStr, "btn_left") == 0) { if (strcmp(lowerStr, "btn_left") == 0) {
return BTN_LEFT; return BTN_LEFT;
} else if (strcmp(lowerStr, "btn_right") == 0) { } else if (strcmp(lowerStr, "btn_right") == 0) {
@ -892,16 +892,16 @@ uint32_t parse_button(const char *str) {
} }
int32_t parse_mouse_action(const char *str) { int32_t parse_mouse_action(const char *str) {
// 将输入字符串转换为小写 // Convert input string to lowercase
char lowerStr[20]; char lowerStr[20];
int32_t i = 0; int32_t i = 0;
while (str[i] && i < 19) { while (str[i] && i < 19) {
lowerStr[i] = tolower(str[i]); lowerStr[i] = tolower(str[i]);
i++; i++;
} }
lowerStr[i] = '\0'; // 确保字符串正确终止 lowerStr[i] = '\0'; // Ensure string terminates correctly
// 根据转换后的小写字符串返回对应的按钮编号 // Return corresponding button number based on converted lowercase string
if (strcmp(lowerStr, "curmove") == 0) { if (strcmp(lowerStr, "curmove") == 0) {
return CurMove; return CurMove;
} else if (strcmp(lowerStr, "curresize") == 0) { } else if (strcmp(lowerStr, "curresize") == 0) {
@ -1006,7 +1006,7 @@ FuncType parse_func_name(char *func_name, Arg *arg, char *arg_value,
(*arg).v = strdup(arg_value); (*arg).v = strdup(arg_value);
// 收集需要拼接的参数 // Collect parameters that need concatenation
const char *non_empty_params[4] = {NULL}; const char *non_empty_params[4] = {NULL};
int32_t param_index = 0; int32_t param_index = 0;
@ -1019,16 +1019,16 @@ FuncType parse_func_name(char *func_name, Arg *arg, char *arg_value,
if (arg_value5 && arg_value5[0] != '\0') if (arg_value5 && arg_value5[0] != '\0')
non_empty_params[param_index++] = arg_value5; non_empty_params[param_index++] = arg_value5;
// 处理拼接 // Handle concatenation
if (param_index == 0) { if (param_index == 0) {
(*arg).v2 = strdup(""); (*arg).v2 = strdup("");
} else { } else {
// 计算总长度 // Calculate total length
size_t len = 0; size_t len = 0;
for (int32_t i = 0; i < param_index; i++) { for (int32_t i = 0; i < param_index; i++) {
len += strlen(non_empty_params[i]); len += strlen(non_empty_params[i]);
} }
len += (param_index - 1) + 1; // 逗号数 + null终止符 len += (param_index - 1) + 1; // Number of commas + null terminator
char *temp = malloc(len); char *temp = malloc(len);
if (temp) { if (temp) {
@ -1104,7 +1104,7 @@ FuncType parse_func_name(char *func_name, Arg *arg, char *arg_value,
(*arg).v = combine_args_until_empty(values, 5); (*arg).v = combine_args_until_empty(values, 5);
} else if (strcmp(func_name, "spawn_on_empty") == 0) { } else if (strcmp(func_name, "spawn_on_empty") == 0) {
func = spawn_on_empty; func = spawn_on_empty;
(*arg).v = strdup(arg_value); // 注意：之后需要释放这个内存 (*arg).v = strdup(arg_value); // Note: need to release this memory later
(*arg).ui = 1 << (atoi(arg_value2) - 1); (*arg).ui = 1 << (atoi(arg_value2) - 1);
} else if (strcmp(func_name, "quit") == 0) { } else if (strcmp(func_name, "quit") == 0) {
func = quit; func = quit;
@ -1448,33 +1448,33 @@ bool parse_option(Config *config, char *key, char *value) {
} else if (strcmp(key, "xkb_rules_rules") == 0) { } else if (strcmp(key, "xkb_rules_rules") == 0) {
strncpy(xkb_rules_rules, value, sizeof(xkb_rules_rules) - 1); strncpy(xkb_rules_rules, value, sizeof(xkb_rules_rules) - 1);
xkb_rules_rules[sizeof(xkb_rules_rules) - 1] = xkb_rules_rules[sizeof(xkb_rules_rules) - 1] =
'\0'; // 确保字符串以 null 结尾 '\0'; // Ensure string ends with null
} else if (strcmp(key, "xkb_rules_model") == 0) { } else if (strcmp(key, "xkb_rules_model") == 0) {
strncpy(xkb_rules_model, value, sizeof(xkb_rules_model) - 1); strncpy(xkb_rules_model, value, sizeof(xkb_rules_model) - 1);
xkb_rules_model[sizeof(xkb_rules_model) - 1] = xkb_rules_model[sizeof(xkb_rules_model) - 1] =
'\0'; // 确保字符串以 null 结尾 '\0'; // Ensure string ends with null
} else if (strcmp(key, "xkb_rules_layout") == 0) { } else if (strcmp(key, "xkb_rules_layout") == 0) {
strncpy(xkb_rules_layout, value, sizeof(xkb_rules_layout) - 1); strncpy(xkb_rules_layout, value, sizeof(xkb_rules_layout) - 1);
xkb_rules_layout[sizeof(xkb_rules_layout) - 1] = xkb_rules_layout[sizeof(xkb_rules_layout) - 1] =
'\0'; // 确保字符串以 null 结尾 '\0'; // Ensure string ends with null
} else if (strcmp(key, "xkb_rules_variant") == 0) { } else if (strcmp(key, "xkb_rules_variant") == 0) {
strncpy(xkb_rules_variant, value, sizeof(xkb_rules_variant) - 1); strncpy(xkb_rules_variant, value, sizeof(xkb_rules_variant) - 1);
xkb_rules_variant[sizeof(xkb_rules_variant) - 1] = xkb_rules_variant[sizeof(xkb_rules_variant) - 1] =
'\0'; // 确保字符串以 null 结尾 '\0'; // Ensure string ends with null
} else if (strcmp(key, "xkb_rules_options") == 0) { } else if (strcmp(key, "xkb_rules_options") == 0) {
strncpy(xkb_rules_options, value, sizeof(xkb_rules_options) - 1); strncpy(xkb_rules_options, value, sizeof(xkb_rules_options) - 1);
xkb_rules_options[sizeof(xkb_rules_options) - 1] = xkb_rules_options[sizeof(xkb_rules_options) - 1] =
'\0'; // 确保字符串以 null 结尾 '\0'; // Ensure string ends with null
} else if (strcmp(key, "scroller_proportion_preset") == 0) { } else if (strcmp(key, "scroller_proportion_preset") == 0) {
// 1. 统计 value 中有多少个逗号，确定需要解析的浮点数个数 // 1. Count commas in value to determine number of floats to parse
int32_t count = 0; // 初始化为 0 int32_t count = 0; // Initialize to 0
for (const char *p = value; *p; p++) { for (const char *p = value; *p; p++) {
if (*p == ',') if (*p == ',')
count++; count++;
} }
int32_t float_count = count + 1; // 浮点数的数量是逗号数量加 1 int32_t float_count = count + 1; // Number of floats is comma count plus 1
// 2. 动态分配内存，存储浮点数 // 2. Dynamically allocate memory to store floats
config->scroller_proportion_preset = config->scroller_proportion_preset =
(float *)malloc(float_count * sizeof(float)); (float *)malloc(float_count * sizeof(float));
if (!config->scroller_proportion_preset) { if (!config->scroller_proportion_preset) {
@ -1483,9 +1483,9 @@ bool parse_option(Config *config, char *key, char *value) {
return false; return false;
} }
// 3. 解析 value 中的浮点数 // 3. Parse floats in value
char *value_copy = char *value_copy =
strdup(value); // 复制 value，因为 strtok 会修改原字符串 strdup(value); // Copy value since strtok modifies original string
char *token = strtok(value_copy, ","); char *token = strtok(value_copy, ",");
int32_t i = 0; int32_t i = 0;
float value_set; float value_set;
@ -1512,7 +1512,7 @@ bool parse_option(Config *config, char *key, char *value) {
i++; i++;
} }
// 4. 检查解析的浮点数数量是否匹配 // 4. Check if parsed float count matches
if (i != float_count) { if (i != float_count) {
fprintf(stderr, fprintf(stderr,
"\033[1m\033[31m[ERROR]:\033[33m Invalid " "\033[1m\033[31m[ERROR]:\033[33m Invalid "
@ -1527,18 +1527,18 @@ bool parse_option(Config *config, char *key, char *value) {
} }
config->scroller_proportion_preset_count = float_count; config->scroller_proportion_preset_count = float_count;
// 5. 释放临时复制的字符串 // 5. Release temporary copied string
free(value_copy); free(value_copy);
} else if (strcmp(key, "circle_layout") == 0) { } else if (strcmp(key, "circle_layout") == 0) {
// 1. 统计 value 中有多少个逗号，确定需要解析的字符串个数 // 1. Count commas in value to determine number of strings to parse
int32_t count = 0; // 初始化为 0 int32_t count = 0; // Initialize to 0
for (const char *p = value; *p; p++) { for (const char *p = value; *p; p++) {
if (*p == ',') if (*p == ',')
count++; count++;
} }
int32_t string_count = count + 1; // 字符串的数量是逗号数量加 1 int32_t string_count = count + 1; // Number of strings is comma count plus 1
// 2. 动态分配内存，存储字符串指针 // 2. Dynamically allocate memory to store string pointers
config->circle_layout = (char **)malloc(string_count * sizeof(char *)); config->circle_layout = (char **)malloc(string_count * sizeof(char *));
memset(config->circle_layout, 0, string_count * sizeof(char *)); memset(config->circle_layout, 0, string_count * sizeof(char *));
if (!config->circle_layout) { if (!config->circle_layout) {
@ -1547,14 +1547,14 @@ bool parse_option(Config *config, char *key, char *value) {
return false; return false;
} }
// 3. 解析 value 中的字符串 // 3. Parse strings in value
char *value_copy = char *value_copy =
strdup(value); // 复制 value，因为 strtok 会修改原字符串 strdup(value); // Copy value since strtok modifies original string
char *token = strtok(value_copy, ","); char *token = strtok(value_copy, ",");
int32_t i = 0; int32_t i = 0;
char *cleaned_token; char *cleaned_token;
while (token != NULL && i < string_count) { while (token != NULL && i < string_count) {
// 为每个字符串分配内存并复制内容 // Allocate memory and copy content for each string
cleaned_token = sanitize_string(token); cleaned_token = sanitize_string(token);
config->circle_layout[i] = strdup(cleaned_token); config->circle_layout[i] = strdup(cleaned_token);
if (!config->circle_layout[i]) { if (!config->circle_layout[i]) {
@ -1563,13 +1563,13 @@ bool parse_option(Config *config, char *key, char *value) {
"failed for " "failed for "
"string: %s\n", "string: %s\n",
token); token);
// 释放之前分配的内存 // Release previously allocated memory
for (int32_t j = 0; j < i; j++) { for (int32_t j = 0; j < i; j++) {
free(config->circle_layout[j]); free(config->circle_layout[j]);
} }
free(config->circle_layout); free(config->circle_layout);
free(value_copy); free(value_copy);
config->circle_layout = NULL; // 防止野指针 config->circle_layout = NULL; // Prevent dangling pointer
config->circle_layout_count = 0; config->circle_layout_count = 0;
return false; return false;
} }
@ -1577,25 +1577,25 @@ bool parse_option(Config *config, char *key, char *value) {
i++; i++;
} }
// 4. 检查解析的字符串数量是否匹配 // 4. Check if parsed string count matches
if (i != string_count) { if (i != string_count) {
fprintf(stderr, fprintf(stderr,
"\033[1m\033[31m[ERROR]:\033[33m Invalid circle_layout " "\033[1m\033[31m[ERROR]:\033[33m Invalid circle_layout "
"format: %s\n", "format: %s\n",
value); value);
// 释放之前分配的内存 // Release previously allocated memory
for (int32_t j = 0; j < i; j++) { for (int32_t j = 0; j < i; j++) {
free(config->circle_layout[j]); free(config->circle_layout[j]);
} }
free(config->circle_layout); free(config->circle_layout);
free(value_copy); free(value_copy);
config->circle_layout = NULL; // 防止野指针 config->circle_layout = NULL; // Prevent dangling pointer
config->circle_layout_count = 0; config->circle_layout_count = 0;
return false; return false;
} }
config->circle_layout_count = string_count; config->circle_layout_count = string_count;
// 5. 释放临时复制的字符串 // 5. Release temporary copied string
free(value_copy); free(value_copy);
} else if (strcmp(key, "new_is_master") == 0) { } else if (strcmp(key, "new_is_master") == 0) {
config->new_is_master = atoi(value); config->new_is_master = atoi(value);
@ -1813,7 +1813,7 @@ bool parse_option(Config *config, char *key, char *value) {
&config->monitor_rules[config->monitor_rules_count]; &config->monitor_rules[config->monitor_rules_count];
memset(rule, 0, sizeof(ConfigMonitorRule)); memset(rule, 0, sizeof(ConfigMonitorRule));
// 设置默认值 // Set default value
rule->name = NULL; rule->name = NULL;
rule->make = NULL; rule->make = NULL;
rule->model = NULL; rule->model = NULL;
@ -1891,7 +1891,7 @@ bool parse_option(Config *config, char *key, char *value) {
ConfigTagRule *rule = &config->tag_rules[config->tag_rules_count]; ConfigTagRule *rule = &config->tag_rules[config->tag_rules_count];
memset(rule, 0, sizeof(ConfigTagRule)); memset(rule, 0, sizeof(ConfigTagRule));
// 设置默认值 // Set default value
rule->id = 0; rule->id = 0;
rule->layout_name = NULL; rule->layout_name = NULL;
rule->monitor_name = NULL; rule->monitor_name = NULL;
@ -1963,7 +1963,7 @@ bool parse_option(Config *config, char *key, char *value) {
ConfigLayerRule *rule = &config->layer_rules[config->layer_rules_count]; ConfigLayerRule *rule = &config->layer_rules[config->layer_rules_count];
memset(rule, 0, sizeof(ConfigLayerRule)); memset(rule, 0, sizeof(ConfigLayerRule));
// 设置默认值 // Set default value
rule->layer_name = NULL; rule->layer_name = NULL;
rule->animation_type_open = NULL; rule->animation_type_open = NULL;
rule->animation_type_close = NULL; rule->animation_type_close = NULL;
@ -2007,7 +2007,7 @@ bool parse_option(Config *config, char *key, char *value) {
token = strtok(NULL, ","); token = strtok(NULL, ",");
} }
// 如果没有指定布局名称，则使用默认值 // Use default value if no layout name is specified
if (rule->layer_name == NULL) { if (rule->layer_name == NULL) {
rule->layer_name = strdup("default"); rule->layer_name = strdup("default");
} }
@ -2801,18 +2801,18 @@ bool parse_config_file(Config *config, const char *file_path, bool must_exist) {
void free_circle_layout(Config *config) { void free_circle_layout(Config *config) {
if (config->circle_layout) { if (config->circle_layout) {
// 释放每个字符串 // Release each string
for (int32_t i = 0; i < config->circle_layout_count; i++) { for (int32_t i = 0; i < config->circle_layout_count; i++) {
if (config->circle_layout[i]) { if (config->circle_layout[i]) {
free(config->circle_layout[i]); // 释放单个字符串 free(config->circle_layout[i]); // Release individual string
config->circle_layout[i] = NULL; // 防止野指针 config->circle_layout[i] = NULL; // Prevent dangling pointer
} }
} }
// 释放 circle_layout 数组本身 // Release circle_layout array itself
free(config->circle_layout); free(config->circle_layout);
config->circle_layout = NULL; // 防止野指针 config->circle_layout = NULL; // Prevent dangling pointer
} }
config->circle_layout_count = 0; // 重置计数 config->circle_layout_count = 0; // Reset count
} }
void free_baked_points(void) { void free_baked_points(void) {
@ -2847,10 +2847,10 @@ void free_baked_points(void) {
} }
void free_config(void) { void free_config(void) {
// 释放内存 // Release memory
int32_t i; int32_t i;
// 释放 window_rules // Release window_rules
if (config.window_rules) { if (config.window_rules) {
for (int32_t i = 0; i < config.window_rules_count; i++) { for (int32_t i = 0; i < config.window_rules_count; i++) {
ConfigWinRule *rule = &config.window_rules[i]; ConfigWinRule *rule = &config.window_rules[i];
@ -2869,7 +2869,7 @@ void free_config(void) {
rule->animation_type_open = NULL; rule->animation_type_open = NULL;
rule->animation_type_close = NULL; rule->animation_type_close = NULL;
rule->monitor = NULL; rule->monitor = NULL;
// 释放 globalkeybinding 的 arg.v（如果动态分配） // Release globalkeybinding arg.v (if dynamically allocated)
if (rule->globalkeybinding.arg.v) { if (rule->globalkeybinding.arg.v) {
free((void *)rule->globalkeybinding.arg.v); free((void *)rule->globalkeybinding.arg.v);
} }
@ -2879,7 +2879,7 @@ void free_config(void) {
config.window_rules_count = 0; config.window_rules_count = 0;
} }
// 释放 key_bindings // Release key_bindings
if (config.key_bindings) { if (config.key_bindings) {
for (i = 0; i < config.key_bindings_count; i++) { for (i = 0; i < config.key_bindings_count; i++) {
if (config.key_bindings[i].arg.v) { if (config.key_bindings[i].arg.v) {
@ -2900,7 +2900,7 @@ void free_config(void) {
config.key_bindings_count = 0; config.key_bindings_count = 0;
} }
// 释放 mouse_bindings // Release mouse_bindings
if (config.mouse_bindings) { if (config.mouse_bindings) {
for (i = 0; i < config.mouse_bindings_count; i++) { for (i = 0; i < config.mouse_bindings_count; i++) {
if (config.mouse_bindings[i].arg.v) { if (config.mouse_bindings[i].arg.v) {
@ -2921,7 +2921,7 @@ void free_config(void) {
config.mouse_bindings_count = 0; config.mouse_bindings_count = 0;
} }
// 释放 axis_bindings // Release axis_bindings
if (config.axis_bindings) { if (config.axis_bindings) {
for (i = 0; i < config.axis_bindings_count; i++) { for (i = 0; i < config.axis_bindings_count; i++) {
if (config.axis_bindings[i].arg.v) { if (config.axis_bindings[i].arg.v) {
@ -2942,7 +2942,7 @@ void free_config(void) {
config.axis_bindings_count = 0; config.axis_bindings_count = 0;
} }
// 释放 switch_bindings // Release switch_bindings
if (config.switch_bindings) { if (config.switch_bindings) {
for (i = 0; i < config.switch_bindings_count; i++) { for (i = 0; i < config.switch_bindings_count; i++) {
if (config.switch_bindings[i].arg.v) { if (config.switch_bindings[i].arg.v) {
@ -2963,7 +2963,7 @@ void free_config(void) {
config.switch_bindings_count = 0; config.switch_bindings_count = 0;
} }
// 释放 gesture_bindings // Release gesture_bindings
if (config.gesture_bindings) { if (config.gesture_bindings) {
for (i = 0; i < config.gesture_bindings_count; i++) { for (i = 0; i < config.gesture_bindings_count; i++) {
if (config.gesture_bindings[i].arg.v) { if (config.gesture_bindings[i].arg.v) {
@ -2984,7 +2984,7 @@ void free_config(void) {
config.gesture_bindings_count = 0; config.gesture_bindings_count = 0;
} }
// 释放 tag_rules // Release tag_rules
if (config.tag_rules) { if (config.tag_rules) {
for (int32_t i = 0; i < config.tag_rules_count; i++) { for (int32_t i = 0; i < config.tag_rules_count; i++) {
if (config.tag_rules[i].layout_name) if (config.tag_rules[i].layout_name)
@ -3003,7 +3003,7 @@ void free_config(void) {
config.tag_rules_count = 0; config.tag_rules_count = 0;
} }
// 释放 monitor_rules // Release monitor_rules
if (config.monitor_rules) { if (config.monitor_rules) {
for (int32_t i = 0; i < config.monitor_rules_count; i++) { for (int32_t i = 0; i < config.monitor_rules_count; i++) {
if (config.monitor_rules[i].name) if (config.monitor_rules[i].name)
@ -3020,7 +3020,7 @@ void free_config(void) {
config.monitor_rules_count = 0; config.monitor_rules_count = 0;
} }
// 释放 layer_rules // Release layer_rules
if (config.layer_rules) { if (config.layer_rules) {
for (int32_t i = 0; i < config.layer_rules_count; i++) { for (int32_t i = 0; i < config.layer_rules_count; i++) {
if (config.layer_rules[i].layer_name) if (config.layer_rules[i].layer_name)
@ -3035,7 +3035,7 @@ void free_config(void) {
config.layer_rules_count = 0; config.layer_rules_count = 0;
} }
// 释放 env // Release env
if (config.env) { if (config.env) {
for (int32_t i = 0; i < config.env_count; i++) { for (int32_t i = 0; i < config.env_count; i++) {
if (config.env[i]->type) { if (config.env[i]->type) {
@ -3051,7 +3051,7 @@ void free_config(void) {
config.env_count = 0; config.env_count = 0;
} }
// 释放 exec // Release exec
if (config.exec) { if (config.exec) {
for (i = 0; i < config.exec_count; i++) { for (i = 0; i < config.exec_count; i++) {
free(config.exec[i]); free(config.exec[i]);
@ -3061,7 +3061,7 @@ void free_config(void) {
config.exec_count = 0; config.exec_count = 0;
} }
// 释放 exec_once // Release exec_once
if (config.exec_once) { if (config.exec_once) {
for (i = 0; i < config.exec_once_count; i++) { for (i = 0; i < config.exec_once_count; i++) {
free(config.exec_once[i]); free(config.exec_once[i]);
@ -3071,7 +3071,7 @@ void free_config(void) {
config.exec_once_count = 0; config.exec_once_count = 0;
} }
// 释放 scroller_proportion_preset // Release scroller_proportion_preset
if (config.scroller_proportion_preset) { if (config.scroller_proportion_preset) {
free(config.scroller_proportion_preset); free(config.scroller_proportion_preset);
config.scroller_proportion_preset = NULL; config.scroller_proportion_preset = NULL;
@ -3083,25 +3083,25 @@ void free_config(void) {
config.cursor_theme = NULL; config.cursor_theme = NULL;
} }
// 释放 circle_layout // Release circle_layout
free_circle_layout(&config); free_circle_layout(&config);
// 释放动画资源 // Release animation resources
free_baked_points(); free_baked_points();
// 清理解析按键用的keymap // Clean up keymap used for parsing keys
cleanup_config_keymap(); cleanup_config_keymap();
} }
void override_config(void) { void override_config(void) {
// 动画启用 // Enable animation
animations = CLAMP_INT(config.animations, 0, 1); animations = CLAMP_INT(config.animations, 0, 1);
layer_animations = CLAMP_INT(config.layer_animations, 0, 1); layer_animations = CLAMP_INT(config.layer_animations, 0, 1);
// 标签动画方向 // Tag animation direction
tag_animation_direction = CLAMP_INT(config.tag_animation_direction, 0, 1); tag_animation_direction = CLAMP_INT(config.tag_animation_direction, 0, 1);
// 动画淡入淡出设置 // Animation fade in/out settings
animation_fade_in = CLAMP_INT(config.animation_fade_in, 0, 1); animation_fade_in = CLAMP_INT(config.animation_fade_in, 0, 1);
animation_fade_out = CLAMP_INT(config.animation_fade_out, 0, 1); animation_fade_out = CLAMP_INT(config.animation_fade_out, 0, 1);
zoom_initial_ratio = CLAMP_FLOAT(config.zoom_initial_ratio, 0.1f, 1.0f); zoom_initial_ratio = CLAMP_FLOAT(config.zoom_initial_ratio, 0.1f, 1.0f);
@ -3110,15 +3110,15 @@ void override_config(void) {
fadeout_begin_opacity = fadeout_begin_opacity =
CLAMP_FLOAT(config.fadeout_begin_opacity, 0.0f, 1.0f); CLAMP_FLOAT(config.fadeout_begin_opacity, 0.0f, 1.0f);
// 打开关闭动画类型 // Open/close animation type
animation_type_open = config.animation_type_open; animation_type_open = config.animation_type_open;
animation_type_close = config.animation_type_close; animation_type_close = config.animation_type_close;
// layer打开关闭动画类型 // Layer open/close animation type
layer_animation_type_open = config.layer_animation_type_open; layer_animation_type_open = config.layer_animation_type_open;
layer_animation_type_close = config.layer_animation_type_close; layer_animation_type_close = config.layer_animation_type_close;
// 动画时间限制在合理范围(1-50000ms) // Animation time limited to reasonable range (1-50000ms)
animation_duration_move = animation_duration_move =
CLAMP_INT(config.animation_duration_move, 1, 50000); CLAMP_INT(config.animation_duration_move, 1, 50000);
animation_duration_open = animation_duration_open =
@ -3129,7 +3129,7 @@ void override_config(void) {
animation_duration_focus = animation_duration_focus =
CLAMP_INT(config.animation_duration_focus, 1, 50000); CLAMP_INT(config.animation_duration_focus, 1, 50000);
// 滚动布局设置 // Scroll layout settings
scroller_default_proportion = scroller_default_proportion =
CLAMP_FLOAT(config.scroller_default_proportion, 0.1f, 1.0f); CLAMP_FLOAT(config.scroller_default_proportion, 0.1f, 1.0f);
scroller_default_proportion_single = scroller_default_proportion_single =
@ -3142,14 +3142,14 @@ void override_config(void) {
CLAMP_INT(config.edge_scroller_pointer_focus, 0, 1); CLAMP_INT(config.edge_scroller_pointer_focus, 0, 1);
scroller_structs = CLAMP_INT(config.scroller_structs, 0, 1000); scroller_structs = CLAMP_INT(config.scroller_structs, 0, 1000);
// 主从布局设置 // Master-slave layout settings
default_mfact = CLAMP_FLOAT(config.default_mfact, 0.1f, 0.9f); default_mfact = CLAMP_FLOAT(config.default_mfact, 0.1f, 0.9f);
default_nmaster = CLAMP_INT(config.default_nmaster, 1, 1000); default_nmaster = CLAMP_INT(config.default_nmaster, 1, 1000);
center_master_overspread = CLAMP_INT(config.center_master_overspread, 0, 1); center_master_overspread = CLAMP_INT(config.center_master_overspread, 0, 1);
center_when_single_stack = CLAMP_INT(config.center_when_single_stack, 0, 1); center_when_single_stack = CLAMP_INT(config.center_when_single_stack, 0, 1);
new_is_master = CLAMP_INT(config.new_is_master, 0, 1); new_is_master = CLAMP_INT(config.new_is_master, 0, 1);
// 概述模式设置 // Overview mode settings
hotarea_size = CLAMP_INT(config.hotarea_size, 1, 1000); hotarea_size = CLAMP_INT(config.hotarea_size, 1, 1000);
hotarea_corner = CLAMP_INT(config.hotarea_corner, 0, 3); hotarea_corner = CLAMP_INT(config.hotarea_corner, 0, 3);
enable_hotarea = CLAMP_INT(config.enable_hotarea, 0, 1); enable_hotarea = CLAMP_INT(config.enable_hotarea, 0, 1);
@ -3157,7 +3157,7 @@ void override_config(void) {
overviewgappi = CLAMP_INT(config.overviewgappi, 0, 1000); overviewgappi = CLAMP_INT(config.overviewgappi, 0, 1000);
overviewgappo = CLAMP_INT(config.overviewgappo, 0, 1000); overviewgappo = CLAMP_INT(config.overviewgappo, 0, 1000);
// 杂项设置 // Miscellaneous settings
xwayland_persistence = CLAMP_INT(config.xwayland_persistence, 0, 1); xwayland_persistence = CLAMP_INT(config.xwayland_persistence, 0, 1);
syncobj_enable = CLAMP_INT(config.syncobj_enable, 0, 1); syncobj_enable = CLAMP_INT(config.syncobj_enable, 0, 1);
allow_tearing = CLAMP_INT(config.allow_tearing, 0, 2); allow_tearing = CLAMP_INT(config.allow_tearing, 0, 2);
@ -3183,16 +3183,16 @@ void override_config(void) {
no_border_when_single = CLAMP_INT(config.no_border_when_single, 0, 1); no_border_when_single = CLAMP_INT(config.no_border_when_single, 0, 1);
no_radius_when_single = CLAMP_INT(config.no_radius_when_single, 0, 1); no_radius_when_single = CLAMP_INT(config.no_radius_when_single, 0, 1);
cursor_hide_timeout = cursor_hide_timeout =
CLAMP_INT(config.cursor_hide_timeout, 0, 36000); // 0-10小时 CLAMP_INT(config.cursor_hide_timeout, 0, 36000); // 0-10 hours
drag_tile_to_tile = CLAMP_INT(config.drag_tile_to_tile, 0, 1); drag_tile_to_tile = CLAMP_INT(config.drag_tile_to_tile, 0, 1);
single_scratchpad = CLAMP_INT(config.single_scratchpad, 0, 1); single_scratchpad = CLAMP_INT(config.single_scratchpad, 0, 1);
// 键盘设置 // Keyboard settings
repeat_rate = CLAMP_INT(config.repeat_rate, 1, 1000); repeat_rate = CLAMP_INT(config.repeat_rate, 1, 1000);
repeat_delay = CLAMP_INT(config.repeat_delay, 1, 20000); repeat_delay = CLAMP_INT(config.repeat_delay, 1, 20000);
numlockon = CLAMP_INT(config.numlockon, 0, 1); numlockon = CLAMP_INT(config.numlockon, 0, 1);
// 触控板设置 // Touchpad settings
disable_trackpad = CLAMP_INT(config.disable_trackpad, 0, 1); disable_trackpad = CLAMP_INT(config.disable_trackpad, 0, 1);
tap_to_click = CLAMP_INT(config.tap_to_click, 0, 1); tap_to_click = CLAMP_INT(config.tap_to_click, 0, 1);
tap_and_drag = CLAMP_INT(config.tap_and_drag, 0, 1); tap_and_drag = CLAMP_INT(config.tap_and_drag, 0, 1);
@ -3204,7 +3204,7 @@ void override_config(void) {
middle_button_emulation = CLAMP_INT(config.middle_button_emulation, 0, 1); middle_button_emulation = CLAMP_INT(config.middle_button_emulation, 0, 1);
swipe_min_threshold = CLAMP_INT(config.swipe_min_threshold, 1, 1000); swipe_min_threshold = CLAMP_INT(config.swipe_min_threshold, 1, 1000);
// 鼠标设置 // Mouse settings
mouse_natural_scrolling = CLAMP_INT(config.mouse_natural_scrolling, 0, 1); mouse_natural_scrolling = CLAMP_INT(config.mouse_natural_scrolling, 0, 1);
accel_profile = CLAMP_INT(config.accel_profile, 0, 2); accel_profile = CLAMP_INT(config.accel_profile, 0, 2);
accel_speed = CLAMP_FLOAT(config.accel_speed, -1.0f, 1.0f); accel_speed = CLAMP_FLOAT(config.accel_speed, -1.0f, 1.0f);
@ -3215,7 +3215,7 @@ void override_config(void) {
button_map = CLAMP_INT(config.button_map, 0, 1); button_map = CLAMP_INT(config.button_map, 0, 1);
axis_scroll_factor = CLAMP_FLOAT(config.axis_scroll_factor, 0.1f, 10.0f); axis_scroll_factor = CLAMP_FLOAT(config.axis_scroll_factor, 0.1f, 10.0f);
// 外观设置 // Appearance settings
gappih = CLAMP_INT(config.gappih, 0, 1000); gappih = CLAMP_INT(config.gappih, 0, 1000);
gappiv = CLAMP_INT(config.gappiv, 0, 1000); gappiv = CLAMP_INT(config.gappiv, 0, 1000);
gappoh = CLAMP_INT(config.gappoh, 0, 1000); gappoh = CLAMP_INT(config.gappoh, 0, 1000);
@ -3248,7 +3248,7 @@ void override_config(void) {
unfocused_opacity = CLAMP_FLOAT(config.unfocused_opacity, 0.0f, 1.0f); unfocused_opacity = CLAMP_FLOAT(config.unfocused_opacity, 0.0f, 1.0f);
memcpy(shadowscolor, config.shadowscolor, sizeof(shadowscolor)); memcpy(shadowscolor, config.shadowscolor, sizeof(shadowscolor));
// 复制颜色数组 // Copy color array
memcpy(rootcolor, config.rootcolor, sizeof(rootcolor)); memcpy(rootcolor, config.rootcolor, sizeof(rootcolor));
memcpy(bordercolor, config.bordercolor, sizeof(bordercolor)); memcpy(bordercolor, config.bordercolor, sizeof(bordercolor));
memcpy(focuscolor, config.focuscolor, sizeof(focuscolor)); memcpy(focuscolor, config.focuscolor, sizeof(focuscolor));
@ -3259,7 +3259,7 @@ void override_config(void) {
memcpy(globalcolor, config.globalcolor, sizeof(globalcolor)); memcpy(globalcolor, config.globalcolor, sizeof(globalcolor));
memcpy(overlaycolor, config.overlaycolor, sizeof(overlaycolor)); memcpy(overlaycolor, config.overlaycolor, sizeof(overlaycolor));
// 复制动画曲线 // Copy animation curve
memcpy(animation_curve_move, config.animation_curve_move, memcpy(animation_curve_move, config.animation_curve_move,
sizeof(animation_curve_move)); sizeof(animation_curve_move));
memcpy(animation_curve_open, config.animation_curve_open, memcpy(animation_curve_open, config.animation_curve_open,
@ -3278,13 +3278,13 @@ void override_config(void) {
void set_value_default() { void set_value_default() {
/* animaion */ /* animaion */
config.animations = animations; // 是否启用动画 config.animations = animations; // Whether to enable animation
config.layer_animations = layer_animations; // 是否启用layer动画 config.layer_animations = layer_animations; // Whether to enable layer animation
config.animation_fade_in = animation_fade_in; // Enable animation fade in config.animation_fade_in = animation_fade_in; // Enable animation fade in
config.animation_fade_out = animation_fade_out; // Enable animation fade out config.animation_fade_out = animation_fade_out; // Enable animation fade out
config.tag_animation_direction = tag_animation_direction; // 标签动画方向 config.tag_animation_direction = tag_animation_direction; // Tag animation direction
config.zoom_initial_ratio = zoom_initial_ratio; // 动画起始窗口比例 config.zoom_initial_ratio = zoom_initial_ratio; // Animation initial window ratio
config.zoom_end_ratio = zoom_end_ratio; // 动画结束窗口比例 config.zoom_end_ratio = zoom_end_ratio; // Animation end window ratio
config.fadein_begin_opacity = config.fadein_begin_opacity =
fadein_begin_opacity; // Begin opac window ratio for animations fadein_begin_opacity; // Begin opac window ratio for animations
config.fadeout_begin_opacity = fadeout_begin_opacity; config.fadeout_begin_opacity = fadeout_begin_opacity;

4
src/data/static_keymap.h
View file

@ -1,6 +1,6 @@
typedef struct { typedef struct {
const char *full_name; const char *full_name;
const char *abbr; // 全部使用小写 const char *abbr; // all lowercase
} LayoutMapping; } LayoutMapping;
static const LayoutMapping layout_mappings[] = { static const LayoutMapping layout_mappings[] = {
@ -75,5 +75,5 @@ static const LayoutMapping layout_mappings[] = {
{"Telugu", "te"}, {"Telugu", "te"},
{"Kannada", "kn"}, {"Kannada", "kn"},
{"Malayalam", "ml"}, {"Malayalam", "ml"},
{NULL, NULL} // 结束标记 {NULL, NULL} // end marker
}; };

28
src/dispatch/bind_define.h
View file

@ -798,7 +798,7 @@ int32_t spawn_shell(const Arg *arg) {
return 0; return 0;
if (fork() == 0) { if (fork() == 0) {
// 1. 忽略可能导致 coredump 的信号 // 1. Ignore signals that may cause coredump
signal(SIGSEGV, SIG_IGN); signal(SIGSEGV, SIG_IGN);
signal(SIGABRT, SIG_IGN); signal(SIGABRT, SIG_IGN);
signal(SIGILL, SIG_IGN); signal(SIGILL, SIG_IGN);
@ -826,7 +826,7 @@ int32_t spawn(const Arg *arg) {
return 0; return 0;
if (fork() == 0) { if (fork() == 0) {
// 1. 忽略可能导致 coredump 的信号 // 1. Ignore signals that may cause coredump
signal(SIGSEGV, SIG_IGN); signal(SIGSEGV, SIG_IGN);
signal(SIGABRT, SIG_IGN); signal(SIGABRT, SIG_IGN);
signal(SIGILL, SIG_IGN); signal(SIGILL, SIG_IGN);
@ -834,7 +834,7 @@ int32_t spawn(const Arg *arg) {
dup2(STDERR_FILENO, STDOUT_FILENO); dup2(STDERR_FILENO, STDOUT_FILENO);
setsid(); setsid();
// 2. 解析参数 // 2. Parse parameters
char *argv[64]; char *argv[64];
char *allocated_strings[64]; // Track strdup'd strings for cleanup char *allocated_strings[64]; // Track strdup'd strings for cleanup
int32_t argc = 0; int32_t argc = 0;
@ -859,10 +859,10 @@ int32_t spawn(const Arg *arg) {
} }
argv[argc] = NULL; argv[argc] = NULL;
// 3. 执行命令 // 3. Execute command
execvp(argv[0], argv); execvp(argv[0], argv);
// 4. execvp 失败时：清理并退出 // 4. When execvp fails: cleanup and exit
// If execvp succeeds, this code never runs (process replaced) // If execvp succeeds, this code never runs (process replaced)
// If it fails, clean up allocated strings before exiting // If it fails, clean up allocated strings before exiting
for (int32_t i = 0; i < alloc_count; i++) { for (int32_t i = 0; i < alloc_count; i++) {
@ -870,7 +870,7 @@ int32_t spawn(const Arg *arg) {
} }
wlr_log(WLR_ERROR, "mango: execvp '%s' failed: %s\n", argv[0], wlr_log(WLR_ERROR, "mango: execvp '%s' failed: %s\n", argv[0],
strerror(errno)); strerror(errno));
_exit(EXIT_FAILURE); // 使用 _exit 避免缓冲区刷新等操作 _exit(EXIT_FAILURE); // Use _exit to avoid buffer flush operations
} }
return 0; return 0;
} }
@ -907,7 +907,7 @@ int32_t switch_keyboard_layout(const Arg *arg) {
return 0; return 0;
} }
// 1. 获取当前布局和计算下一个布局 // 1. Get current layout and calculate next layout
xkb_layout_index_t current = xkb_state_serialize_layout( xkb_layout_index_t current = xkb_state_serialize_layout(
keyboard->xkb_state, XKB_STATE_LAYOUT_EFFECTIVE); keyboard->xkb_state, XKB_STATE_LAYOUT_EFFECTIVE);
const int32_t num_layouts = xkb_keymap_num_layouts(keyboard->keymap); const int32_t num_layouts = xkb_keymap_num_layouts(keyboard->keymap);
@ -917,14 +917,14 @@ int32_t switch_keyboard_layout(const Arg *arg) {
} }
xkb_layout_index_t next = (current + 1) % num_layouts; xkb_layout_index_t next = (current + 1) % num_layouts;
// 6. 应用新 keymap // 6. Apply new keymap
uint32_t depressed = keyboard->modifiers.depressed; uint32_t depressed = keyboard->modifiers.depressed;
uint32_t latched = keyboard->modifiers.latched; uint32_t latched = keyboard->modifiers.latched;
uint32_t locked = keyboard->modifiers.locked; uint32_t locked = keyboard->modifiers.locked;
wlr_keyboard_notify_modifiers(keyboard, depressed, latched, locked, next); wlr_keyboard_notify_modifiers(keyboard, depressed, latched, locked, next);
// 7. 更新 seat // 7. Update seat
wlr_seat_set_keyboard(seat, keyboard); wlr_seat_set_keyboard(seat, keyboard);
wlr_seat_keyboard_notify_modifiers(seat, &keyboard->modifiers); wlr_seat_keyboard_notify_modifiers(seat, &keyboard->modifiers);
@ -937,7 +937,7 @@ int32_t switch_keyboard_layout(const Arg *arg) {
struct wlr_keyboard *tkb = (struct wlr_keyboard *)id->device_data; struct wlr_keyboard *tkb = (struct wlr_keyboard *)id->device_data;
wlr_keyboard_notify_modifiers(tkb, depressed, latched, locked, next); wlr_keyboard_notify_modifiers(tkb, depressed, latched, locked, next);
// 7. 更新 seat // 7. Update seat
wlr_seat_set_keyboard(seat, tkb); wlr_seat_set_keyboard(seat, tkb);
wlr_seat_keyboard_notify_modifiers(seat, &tkb->modifiers); wlr_seat_keyboard_notify_modifiers(seat, &tkb->modifiers);
} }
@ -1102,8 +1102,8 @@ int32_t tagmon(const Arg *arg) {
selmon = c->mon; selmon = c->mon;
c->float_geom = setclient_coordinate_center(c, c->mon, c->float_geom, 0, 0); c->float_geom = setclient_coordinate_center(c, c->mon, c->float_geom, 0, 0);
// 重新计算居中的坐标 // Recalculate centered coordinates
// 重新计算居中的坐标 // Recalculate centered coordinates
if (c->isfloating) { if (c->isfloating) {
c->geom = c->float_geom; c->geom = c->float_geom;
target = get_tags_first_tag(c->tags); target = get_tags_first_tag(c->tags);
@ -1586,8 +1586,8 @@ int32_t toggleoverview(const Arg *arg) {
return 0; return 0;
} }
// 正常视图到overview,退出所有窗口的浮动和全屏状态参与平铺, // Normal view to overview, exit all floating and fullscreen states to participate in tiling,
// overview到正常视图,还原之前退出的浮动和全屏窗口状态 // Overview to normal view, restore previously exited floating and fullscreen window states
if (selmon->isoverview) { if (selmon->isoverview) {
wl_list_for_each(c, &clients, link) { wl_list_for_each(c, &clients, link) {
if (c && c->mon == selmon && !client_is_unmanaged(c) && if (c && c->mon == selmon && !client_is_unmanaged(c) &&

4
src/ext-protocol/dwl-ipc.h
View file

@ -99,14 +99,14 @@ static void dwl_ipc_output_destroy(struct wl_resource *resource) {
free(ipc_output); free(ipc_output);
} }
// 修改IPC输出函数，接受掩码参数 // Modify IPC output function to accept mask parameter
void dwl_ipc_output_printstatus(Monitor *monitor) { void dwl_ipc_output_printstatus(Monitor *monitor) {
DwlIpcOutput *ipc_output; DwlIpcOutput *ipc_output;
wl_list_for_each(ipc_output, &monitor->dwl_ipc_outputs, link) wl_list_for_each(ipc_output, &monitor->dwl_ipc_outputs, link)
dwl_ipc_output_printstatus_to(ipc_output); dwl_ipc_output_printstatus_to(ipc_output);
} }
// 修改主IPC输出函数，根据掩码发送相应事件 // Modify main IPC output function to send events based on mask
void dwl_ipc_output_printstatus_to(DwlIpcOutput *ipc_output) { void dwl_ipc_output_printstatus_to(DwlIpcOutput *ipc_output) {
Monitor *monitor = ipc_output->mon; Monitor *monitor = ipc_output->mon;
Client *c = NULL, *focused = NULL; Client *c = NULL, *focused = NULL;

8
src/ext-protocol/foreign-toplevel.h
View file

@ -111,7 +111,7 @@ void add_foreign_toplevel(Client *c) {
c->foreign_toplevel = c->foreign_toplevel =
wlr_foreign_toplevel_handle_v1_create(foreign_toplevel_manager); wlr_foreign_toplevel_handle_v1_create(foreign_toplevel_manager);
// 监听来自外部对于窗口的事件请求 // Listen to external event requests for the window
if (c->foreign_toplevel) { if (c->foreign_toplevel) {
LISTEN(&(c->foreign_toplevel->events.request_activate), LISTEN(&(c->foreign_toplevel->events.request_activate),
&c->foreign_activate_request, handle_foreign_activate_request); &c->foreign_activate_request, handle_foreign_activate_request);
@ -126,19 +126,19 @@ void add_foreign_toplevel(Client *c) {
&c->foreign_close_request, handle_foreign_close_request); &c->foreign_close_request, handle_foreign_close_request);
LISTEN(&(c->foreign_toplevel->events.destroy), &c->foreign_destroy, LISTEN(&(c->foreign_toplevel->events.destroy), &c->foreign_destroy,
handle_foreign_destroy); handle_foreign_destroy);
// 设置外部顶层句柄的id为应用的id // Set the foreign toplevel handle's id to the application's id
const char *appid; const char *appid;
appid = client_get_appid(c); appid = client_get_appid(c);
if (appid) if (appid)
wlr_foreign_toplevel_handle_v1_set_app_id(c->foreign_toplevel, wlr_foreign_toplevel_handle_v1_set_app_id(c->foreign_toplevel,
appid); appid);
// 设置外部顶层句柄的title为应用的title // Set the foreign toplevel handle's title to the application's title
const char *title; const char *title;
title = client_get_title(c); title = client_get_title(c);
if (title) if (title)
wlr_foreign_toplevel_handle_v1_set_title(c->foreign_toplevel, wlr_foreign_toplevel_handle_v1_set_title(c->foreign_toplevel,
title); title);
// 设置外部顶层句柄的显示监视器为当前监视器 // Set the foreign toplevel handle's display monitor to the current monitor
wlr_foreign_toplevel_handle_v1_output_enter(c->foreign_toplevel, wlr_foreign_toplevel_handle_v1_output_enter(c->foreign_toplevel,
c->mon->wlr_output); c->mon->wlr_output);
} }

14
src/ext-protocol/tearing.h
View file

@ -99,30 +99,30 @@ bool custom_wlr_scene_output_commit(struct wlr_scene_output *scene_output,
struct wlr_output *wlr_output = scene_output->output; struct wlr_output *wlr_output = scene_output->output;
Monitor *m = wlr_output->data; Monitor *m = wlr_output->data;
// 检查是否需要帧 // Check if frame is needed
if (!wlr_scene_output_needs_frame(scene_output)) { if (!wlr_scene_output_needs_frame(scene_output)) {
wlr_log(WLR_DEBUG, "No frame needed for output %s", wlr_output->name); wlr_log(WLR_DEBUG, "No frame needed for output %s", wlr_output->name);
return true; return true;
} }
// 构建输出状态 // Build output state
if (!wlr_scene_output_build_state(scene_output, state, NULL)) { if (!wlr_scene_output_build_state(scene_output, state, NULL)) {
wlr_log(WLR_ERROR, "Failed to build output state for %s", wlr_log(WLR_ERROR, "Failed to build output state for %s",
wlr_output->name); wlr_output->name);
return false; return false;
} }
// 测试撕裂翻页 // Test tearing page flip
if (state->tearing_page_flip) { if (state->tearing_page_flip) {
if (!wlr_output_test_state(wlr_output, state)) { if (!wlr_output_test_state(wlr_output, state)) {
state->tearing_page_flip = false; state->tearing_page_flip = false;
} }
} }
// 尝试提交 // Attempt commit
bool committed = wlr_output_commit_state(wlr_output, state); bool committed = wlr_output_commit_state(wlr_output, state);
// 如果启用撕裂翻页但提交失败，重试禁用撕裂翻页 // If tearing page flip is enabled but commit fails, retry without tearing page flip
if (!committed && state->tearing_page_flip) { if (!committed && state->tearing_page_flip) {
wlr_log(WLR_DEBUG, "Retrying commit without tearing for %s", wlr_log(WLR_DEBUG, "Retrying commit without tearing for %s",
wlr_output->name); wlr_output->name);
@ -130,7 +130,7 @@ bool custom_wlr_scene_output_commit(struct wlr_scene_output *scene_output,
committed = wlr_output_commit_state(wlr_output, state); committed = wlr_output_commit_state(wlr_output, state);
} }
// 处理状态清理 // Handle state cleanup
if (committed) { if (committed) {
wlr_log(WLR_DEBUG, "Successfully committed output %s", wlr_log(WLR_DEBUG, "Successfully committed output %s",
wlr_output->name); wlr_output->name);
@ -140,7 +140,7 @@ bool custom_wlr_scene_output_commit(struct wlr_scene_output *scene_output,
} }
} else { } else {
wlr_log(WLR_ERROR, "Failed to commit output %s", wlr_output->name); wlr_log(WLR_ERROR, "Failed to commit output %s", wlr_output->name);
// 即使提交失败，也清理状态避免积累 // Clean up state even if commit fails to avoid accumulation
if (state == &m->pending) { if (state == &m->pending) {
wlr_output_state_finish(&m->pending); wlr_output_state_finish(&m->pending);
wlr_output_state_init(&m->pending); wlr_output_state_init(&m->pending);

6
src/ext-protocol/text-input.h
View file

@ -52,7 +52,7 @@ struct wlr_input_method_manager_v2 *input_method_manager;
struct wlr_text_input_manager_v3 *text_input_manager; struct wlr_text_input_manager_v3 *text_input_manager;
struct dwl_input_method_relay *dwl_input_method_relay; struct dwl_input_method_relay *dwl_input_method_relay;
/*-------------------封装给外部调用-------------------------------*/ /*------------------- Wrapped for external calls -------------------------------*/
bool dwl_im_keyboard_grab_forward_key(KeyboardGroup *keyboard, bool dwl_im_keyboard_grab_forward_key(KeyboardGroup *keyboard,
struct wlr_keyboard_key_event *event); struct wlr_keyboard_key_event *event);
@ -66,7 +66,7 @@ void dwl_im_relay_set_focus(struct dwl_input_method_relay *relay,
struct wlr_surface *surface); struct wlr_surface *surface);
/*----------------------------------------------------------*/ /*----------------------------------------------------------*/
/*------------------协议内部代码------------------------------*/ /*------------------ Protocol internal code ------------------------------*/
Monitor *output_from_wlr_output(struct wlr_output *wlr_output) { Monitor *output_from_wlr_output(struct wlr_output *wlr_output) {
Monitor *m = NULL; Monitor *m = NULL;
wl_list_for_each(m, &mons, link) { wl_list_for_each(m, &mons, link) {
@ -111,7 +111,7 @@ get_keyboard_grab(KeyboardGroup *keyboard) {
return NULL; return NULL;
} }
// kb_group是一个物理键盘组，它不应该被过滤掉 // kb_group is a physical keyboard group, it should not be filtered out
if (keyboard != kb_group) if (keyboard != kb_group)
return NULL; return NULL;

44
src/fetch/client.h
View file

@ -75,7 +75,7 @@ Client *get_client_by_id_or_title(const char *arg_id, const char *arg_title) {
} }
return target_client; return target_client;
} }
struct wlr_box // 计算客户端居中坐标 struct wlr_box // Calculate client center coordinates
setclient_coordinate_center(Client *c, Monitor *tm, struct wlr_box geom, setclient_coordinate_center(Client *c, Monitor *tm, struct wlr_box geom,
int32_t offsetx, int32_t offsety) { int32_t offsetx, int32_t offsety) {
struct wlr_box tempbox; struct wlr_box tempbox;
@ -101,7 +101,7 @@ setclient_coordinate_center(Client *c, Monitor *tm, struct wlr_box geom,
offset = len * (offsetx / 100.0); offset = len * (offsetx / 100.0);
tempbox.x += offset; tempbox.x += offset;
// 限制窗口在屏幕内 // Constrain window within screen
if (tempbox.x < m->m.x) { if (tempbox.x < m->m.x) {
tempbox.x = m->m.x - cbw; tempbox.x = m->m.x - cbw;
} }
@ -114,7 +114,7 @@ setclient_coordinate_center(Client *c, Monitor *tm, struct wlr_box geom,
offset = len * (offsety / 100.0); offset = len * (offsety / 100.0);
tempbox.y += offset; tempbox.y += offset;
// 限制窗口在屏幕内 // Constrain window within screen
if (tempbox.y < m->m.y) { if (tempbox.y < m->m.y) {
tempbox.y = m->m.y - cbw; tempbox.y = m->m.y - cbw;
} }
@ -158,10 +158,10 @@ Client *center_tiled_select(Monitor *m) {
Client *find_client_by_direction(Client *tc, const Arg *arg, bool findfloating, Client *find_client_by_direction(Client *tc, const Arg *arg, bool findfloating,
bool ignore_align) { bool ignore_align) {
Client *c = NULL; Client *c = NULL;
Client **tempClients = NULL; // 初始化为 NULL Client **tempClients = NULL; // Initialize to NULL
int32_t last = -1; int32_t last = -1;
// 第一次遍历，计算客户端数量 // First pass: count clients
wl_list_for_each(c, &clients, link) { wl_list_for_each(c, &clients, link) {
if (c && (findfloating || !c->isfloating) && !c->isunglobal && if (c && (findfloating || !c->isfloating) && !c->isunglobal &&
(focus_cross_monitor || c->mon == tc->mon) && (focus_cross_monitor || c->mon == tc->mon) &&
@ -171,17 +171,17 @@ Client *find_client_by_direction(Client *tc, const Arg *arg, bool findfloating,
} }
if (last < 0) { if (last < 0) {
return NULL; // 没有符合条件的客户端 return NULL; // No clients matching criteria
} }
// 动态分配内存 // Allocate memory dynamically
tempClients = malloc((last + 1) * sizeof(Client *)); tempClients = malloc((last + 1) * sizeof(Client *));
if (!tempClients) { if (!tempClients) {
// 处理内存分配失败的情况 // Handle memory allocation failure
return NULL; return NULL;
} }
// 第二次遍历，填充 tempClients // Second pass: fill tempClients
last = -1; last = -1;
wl_list_for_each(c, &clients, link) { wl_list_for_each(c, &clients, link) {
if (c && (findfloating || !c->isfloating) && !c->isunglobal && if (c && (findfloating || !c->isfloating) && !c->isunglobal &&
@ -209,7 +209,7 @@ Client *find_client_by_direction(Client *tc, const Arg *arg, bool findfloating,
int32_t dis_x = tempClients[_i]->geom.x - sel_x; int32_t dis_x = tempClients[_i]->geom.x - sel_x;
int32_t dis_y = tempClients[_i]->geom.y - sel_y; int32_t dis_y = tempClients[_i]->geom.y - sel_y;
int64_t tmp_distance = int64_t tmp_distance =
dis_x * dis_x + dis_y * dis_y; // 计算距离 dis_x * dis_x + dis_y * dis_y; // Calculate distance
if (tmp_distance < distance) { if (tmp_distance < distance) {
distance = tmp_distance; distance = tmp_distance;
tempFocusClients = tempClients[_i]; tempFocusClients = tempClients[_i];
@ -225,7 +225,7 @@ Client *find_client_by_direction(Client *tc, const Arg *arg, bool findfloating,
int32_t dis_x = tempClients[_i]->geom.x - sel_x; int32_t dis_x = tempClients[_i]->geom.x - sel_x;
int32_t dis_y = tempClients[_i]->geom.y - sel_y; int32_t dis_y = tempClients[_i]->geom.y - sel_y;
int64_t tmp_distance = int64_t tmp_distance =
dis_x * dis_x + dis_y * dis_y; // 计算距离 dis_x * dis_x + dis_y * dis_y; // Calculate distance
if (tmp_distance < distance) { if (tmp_distance < distance) {
distance = tmp_distance; distance = tmp_distance;
tempFocusClients = tempClients[_i]; tempFocusClients = tempClients[_i];
@ -244,7 +244,7 @@ Client *find_client_by_direction(Client *tc, const Arg *arg, bool findfloating,
int32_t dis_x = tempClients[_i]->geom.x - sel_x; int32_t dis_x = tempClients[_i]->geom.x - sel_x;
int32_t dis_y = tempClients[_i]->geom.y - sel_y; int32_t dis_y = tempClients[_i]->geom.y - sel_y;
int64_t tmp_distance = int64_t tmp_distance =
dis_x * dis_x + dis_y * dis_y; // 计算距离 dis_x * dis_x + dis_y * dis_y; // Calculate distance
if (tmp_distance < distance) { if (tmp_distance < distance) {
distance = tmp_distance; distance = tmp_distance;
tempFocusClients = tempClients[_i]; tempFocusClients = tempClients[_i];
@ -267,7 +267,7 @@ Client *find_client_by_direction(Client *tc, const Arg *arg, bool findfloating,
int32_t dis_x = tempClients[_i]->geom.x - sel_x; int32_t dis_x = tempClients[_i]->geom.x - sel_x;
int32_t dis_y = tempClients[_i]->geom.y - sel_y; int32_t dis_y = tempClients[_i]->geom.y - sel_y;
int64_t tmp_distance = int64_t tmp_distance =
dis_x * dis_x + dis_y * dis_y; // 计算距离 dis_x * dis_x + dis_y * dis_y; // Calculate distance
if (tmp_distance < distance) { if (tmp_distance < distance) {
distance = tmp_distance; distance = tmp_distance;
tempFocusClients = tempClients[_i]; tempFocusClients = tempClients[_i];
@ -283,7 +283,7 @@ Client *find_client_by_direction(Client *tc, const Arg *arg, bool findfloating,
int32_t dis_x = tempClients[_i]->geom.x - sel_x; int32_t dis_x = tempClients[_i]->geom.x - sel_x;
int32_t dis_y = tempClients[_i]->geom.y - sel_y; int32_t dis_y = tempClients[_i]->geom.y - sel_y;
int64_t tmp_distance = int64_t tmp_distance =
dis_x * dis_x + dis_y * dis_y; // 计算距离 dis_x * dis_x + dis_y * dis_y; // Calculate distance
if (tmp_distance < distance) { if (tmp_distance < distance) {
distance = tmp_distance; distance = tmp_distance;
tempFocusClients = tempClients[_i]; tempFocusClients = tempClients[_i];
@ -302,7 +302,7 @@ Client *find_client_by_direction(Client *tc, const Arg *arg, bool findfloating,
int32_t dis_x = tempClients[_i]->geom.x - sel_x; int32_t dis_x = tempClients[_i]->geom.x - sel_x;
int32_t dis_y = tempClients[_i]->geom.y - sel_y; int32_t dis_y = tempClients[_i]->geom.y - sel_y;
int64_t tmp_distance = int64_t tmp_distance =
dis_x * dis_x + dis_y * dis_y; // 计算距离 dis_x * dis_x + dis_y * dis_y; // Calculate distance
if (tmp_distance < distance) { if (tmp_distance < distance) {
distance = tmp_distance; distance = tmp_distance;
tempFocusClients = tempClients[_i]; tempFocusClients = tempClients[_i];
@ -325,7 +325,7 @@ Client *find_client_by_direction(Client *tc, const Arg *arg, bool findfloating,
int32_t dis_x = tempClients[_i]->geom.x - sel_x; int32_t dis_x = tempClients[_i]->geom.x - sel_x;
int32_t dis_y = tempClients[_i]->geom.y - sel_y; int32_t dis_y = tempClients[_i]->geom.y - sel_y;
int64_t tmp_distance = int64_t tmp_distance =
dis_x * dis_x + dis_y * dis_y; // 计算距离 dis_x * dis_x + dis_y * dis_y; // Calculate distance
if (tmp_distance < distance) { if (tmp_distance < distance) {
distance = tmp_distance; distance = tmp_distance;
tempFocusClients = tempClients[_i]; tempFocusClients = tempClients[_i];
@ -341,7 +341,7 @@ Client *find_client_by_direction(Client *tc, const Arg *arg, bool findfloating,
int32_t dis_x = tempClients[_i]->geom.x - sel_x; int32_t dis_x = tempClients[_i]->geom.x - sel_x;
int32_t dis_y = tempClients[_i]->geom.y - sel_y; int32_t dis_y = tempClients[_i]->geom.y - sel_y;
int64_t tmp_distance = int64_t tmp_distance =
dis_x * dis_x + dis_y * dis_y; // 计算距离 dis_x * dis_x + dis_y * dis_y; // Calculate distance
if (tmp_distance < distance) { if (tmp_distance < distance) {
distance = tmp_distance; distance = tmp_distance;
tempFocusClients = tempClients[_i]; tempFocusClients = tempClients[_i];
@ -360,7 +360,7 @@ Client *find_client_by_direction(Client *tc, const Arg *arg, bool findfloating,
int32_t dis_x = tempClients[_i]->geom.x - sel_x; int32_t dis_x = tempClients[_i]->geom.x - sel_x;
int32_t dis_y = tempClients[_i]->geom.y - sel_y; int32_t dis_y = tempClients[_i]->geom.y - sel_y;
int64_t tmp_distance = int64_t tmp_distance =
dis_x * dis_x + dis_y * dis_y; // 计算距离 dis_x * dis_x + dis_y * dis_y; // Calculate distance
if (tmp_distance < distance) { if (tmp_distance < distance) {
distance = tmp_distance; distance = tmp_distance;
tempFocusClients = tempClients[_i]; tempFocusClients = tempClients[_i];
@ -383,7 +383,7 @@ Client *find_client_by_direction(Client *tc, const Arg *arg, bool findfloating,
int32_t dis_x = tempClients[_i]->geom.x - sel_x; int32_t dis_x = tempClients[_i]->geom.x - sel_x;
int32_t dis_y = tempClients[_i]->geom.y - sel_y; int32_t dis_y = tempClients[_i]->geom.y - sel_y;
int64_t tmp_distance = int64_t tmp_distance =
dis_x * dis_x + dis_y * dis_y; // 计算距离 dis_x * dis_x + dis_y * dis_y; // Calculate distance
if (tmp_distance < distance) { if (tmp_distance < distance) {
distance = tmp_distance; distance = tmp_distance;
tempFocusClients = tempClients[_i]; tempFocusClients = tempClients[_i];
@ -399,7 +399,7 @@ Client *find_client_by_direction(Client *tc, const Arg *arg, bool findfloating,
int32_t dis_x = tempClients[_i]->geom.x - sel_x; int32_t dis_x = tempClients[_i]->geom.x - sel_x;
int32_t dis_y = tempClients[_i]->geom.y - sel_y; int32_t dis_y = tempClients[_i]->geom.y - sel_y;
int64_t tmp_distance = int64_t tmp_distance =
dis_x * dis_x + dis_y * dis_y; // 计算距离 dis_x * dis_x + dis_y * dis_y; // Calculate distance
if (tmp_distance < distance) { if (tmp_distance < distance) {
distance = tmp_distance; distance = tmp_distance;
tempFocusClients = tempClients[_i]; tempFocusClients = tempClients[_i];
@ -418,7 +418,7 @@ Client *find_client_by_direction(Client *tc, const Arg *arg, bool findfloating,
int32_t dis_x = tempClients[_i]->geom.x - sel_x; int32_t dis_x = tempClients[_i]->geom.x - sel_x;
int32_t dis_y = tempClients[_i]->geom.y - sel_y; int32_t dis_y = tempClients[_i]->geom.y - sel_y;
int64_t tmp_distance = int64_t tmp_distance =
dis_x * dis_x + dis_y * dis_y; // 计算距离 dis_x * dis_x + dis_y * dis_y; // Calculate distance
if (tmp_distance < distance) { if (tmp_distance < distance) {
distance = tmp_distance; distance = tmp_distance;
tempFocusClients = tempClients[_i]; tempFocusClients = tempClients[_i];
@ -434,7 +434,7 @@ Client *find_client_by_direction(Client *tc, const Arg *arg, bool findfloating,
break; break;
} }
free(tempClients); // 释放内存 free(tempClients); // Release memory
if (tempSameMonitorFocusClients) { if (tempSameMonitorFocusClients) {
return tempSameMonitorFocusClients; return tempSameMonitorFocusClients;
} else { } else {

22
src/fetch/common.h
View file

@ -8,7 +8,7 @@ pid_t getparentprocess(pid_t p) {
if (!(f = fopen(buf, "r"))) if (!(f = fopen(buf, "r")))
return 0; return 0;
// 检查fscanf返回值，确保成功读取了1个参数 // Check fscanf return value to ensure 1 parameter was successfully read
if (fscanf(f, "%*u %*s %*c %u", &v) != 1) { if (fscanf(f, "%*u %*s %*c %u", &v) != 1) {
fclose(f); fclose(f);
return 0; return 0;
@ -30,10 +30,10 @@ int32_t isdescprocess(pid_t p, pid_t c) {
#define LAYOUT_ABBR_SIZE 32 #define LAYOUT_ABBR_SIZE 32
void get_layout_abbr(char *abbr, const char *full_name) { void get_layout_abbr(char *abbr, const char *full_name) {
// 清空输出缓冲区 // Clear output buffer
abbr[0] = '\0'; abbr[0] = '\0';
// 1. 尝试在映射表中查找 // 1. Try to find in mapping table
for (int32_t i = 0; layout_mappings[i].full_name != NULL; i++) { for (int32_t i = 0; layout_mappings[i].full_name != NULL; i++) {
if (strcmp(full_name, layout_mappings[i].full_name) == 0) { if (strcmp(full_name, layout_mappings[i].full_name) == 0) {
strncpy(abbr, layout_mappings[i].abbr, LAYOUT_ABBR_SIZE - 1); strncpy(abbr, layout_mappings[i].abbr, LAYOUT_ABBR_SIZE - 1);
@ -42,13 +42,13 @@ void get_layout_abbr(char *abbr, const char *full_name) {
} }
} }
// 2. 尝试从名称中提取并转换为小写 // 2. Try to extract and convert to lowercase from name
const char *open = strrchr(full_name, '('); const char *open = strrchr(full_name, '(');
const char *close = strrchr(full_name, ')'); const char *close = strrchr(full_name, ')');
if (open && close && close > open) { if (open && close && close > open) {
uint32_t len = close - open - 1; uint32_t len = close - open - 1;
if (len > 0 && len <= 4) { if (len > 0 && len <= 4) {
// 提取并转换为小写 // Extract and convert to lowercase
for (uint32_t j = 0; j < len; j++) { for (uint32_t j = 0; j < len; j++) {
abbr[j] = tolower(open[j + 1]); abbr[j] = tolower(open[j + 1]);
} }
@ -57,7 +57,7 @@ void get_layout_abbr(char *abbr, const char *full_name) {
} }
} }
// 3. 提取前2-3个字母并转换为小写 // 3. Extract first 2-3 letters and convert to lowercase
uint32_t j = 0; uint32_t j = 0;
for (uint32_t i = 0; full_name[i] != '\0' && j < 3; i++) { for (uint32_t i = 0; full_name[i] != '\0' && j < 3; i++) {
if (isalpha(full_name[i])) { if (isalpha(full_name[i])) {
@ -66,17 +66,17 @@ void get_layout_abbr(char *abbr, const char *full_name) {
} }
abbr[j] = '\0'; abbr[j] = '\0';
// 确保至少2个字符 // Ensure at least 2 characters
if (j >= 2) { if (j >= 2) {
return; return;
} }
// 4. 回退方案：使用首字母小写 // 4. Fallback: use first letter in lowercase
if (j == 1) { if (j == 1) {
abbr[1] = full_name[1] ? tolower(full_name[1]) : '\0'; abbr[1] = full_name[1] ? tolower(full_name[1]) : '\0';
abbr[2] = '\0'; abbr[2] = '\0';
} else { } else {
// 5. 最终回退：返回 "xx" // 5. Final fallback: return "xx"
abbr[0] = 'x'; abbr[0] = 'x';
abbr[1] = 'x'; abbr[1] = 'x';
abbr[2] = '\0'; abbr[2] = '\0';
@ -112,8 +112,8 @@ void xytonode(double x, double y, struct wlr_surface **psurface, Client **pc,
} }
/* start from the topmost layer, /* start from the topmost layer,
find a sureface that can be focused by pointer, find a surface that can be focused by pointer,
impopup neither a client nor a layer surface.*/ impopup is neither a client nor a layer surface.*/
if (layer == LyrIMPopup) { if (layer == LyrIMPopup) {
c = NULL; c = NULL;
l = NULL; l = NULL;

2
src/fetch/monitor.h
View file

@ -70,7 +70,7 @@ uint32_t get_tags_first_tag_num(uint32_t source_tags) {
} }
} }
// 获取tags中最前面的tag的tagmask // Get the first tag's tagmask from tags
uint32_t get_tags_first_tag(uint32_t source_tags) { uint32_t get_tags_first_tag(uint32_t source_tags) {
uint32_t i, tag; uint32_t i, tag;
tag = 0; tag = 0;

94
src/layout/arrange.h
View file

@ -82,7 +82,7 @@ void resize_tile_master_horizontal(Client *grabc, bool isdrag, int32_t offsetx,
bool begin_find_nextnext = false; bool begin_find_nextnext = false;
bool begin_find_prevprev = false; bool begin_find_prevprev = false;
// 从当前节点的下一个开始遍历 // Start traversal from next node of current node
for (node = grabc->link.next; node != &clients; node = node->next) { for (node = grabc->link.next; node != &clients; node = node->next) {
tc = wl_container_of(node, tc, link); tc = wl_container_of(node, tc, link);
if (begin_find_nextnext && VISIBLEON(tc, grabc->mon) && ISTILED(tc)) { if (begin_find_nextnext && VISIBLEON(tc, grabc->mon) && ISTILED(tc)) {
@ -91,14 +91,14 @@ void resize_tile_master_horizontal(Client *grabc, bool isdrag, int32_t offsetx,
} }
if (!begin_find_nextnext && VISIBLEON(tc, grabc->mon) && if (!begin_find_nextnext && VISIBLEON(tc, grabc->mon) &&
ISTILED(tc)) { // 根据你的实际字段名调整 ISTILED(tc)) { // Adjust according to your actual field names
next = tc; next = tc;
begin_find_nextnext = true; begin_find_nextnext = true;
continue; continue;
} }
} }
// 从当前节点的上一个开始遍历 // Start traversal from previous node of current node
for (node = grabc->link.prev; node != &clients; node = node->prev) { for (node = grabc->link.prev; node != &clients; node = node->prev) {
tc = wl_container_of(node, tc, link); tc = wl_container_of(node, tc, link);
@ -108,7 +108,7 @@ void resize_tile_master_horizontal(Client *grabc, bool isdrag, int32_t offsetx,
} }
if (!begin_find_prevprev && VISIBLEON(tc, grabc->mon) && if (!begin_find_prevprev && VISIBLEON(tc, grabc->mon) &&
ISTILED(tc)) { // 根据你的实际字段名调整 ISTILED(tc)) { // Adjust according to your actual field names
prev = tc; prev = tc;
begin_find_prevprev = true; begin_find_prevprev = true;
continue; continue;
@ -119,7 +119,7 @@ void resize_tile_master_horizontal(Client *grabc, bool isdrag, int32_t offsetx,
drag_begin_cursorx = cursor->x; drag_begin_cursorx = cursor->x;
drag_begin_cursory = cursor->y; drag_begin_cursory = cursor->y;
start_drag_window = true; start_drag_window = true;
// 记录初始状态 // Record initial state
grabc->old_master_mfact_per = grabc->master_mfact_per; grabc->old_master_mfact_per = grabc->master_mfact_per;
grabc->old_master_inner_per = grabc->master_inner_per; grabc->old_master_inner_per = grabc->master_inner_per;
grabc->old_stack_inner_per = grabc->stack_inner_per; grabc->old_stack_inner_per = grabc->stack_inner_per;
@ -127,10 +127,10 @@ void resize_tile_master_horizontal(Client *grabc, bool isdrag, int32_t offsetx,
cursor->y < grabc->geom.y + grabc->geom.height / 2; cursor->y < grabc->geom.y + grabc->geom.height / 2;
grabc->cursor_in_left_half = grabc->cursor_in_left_half =
cursor->x < grabc->geom.x + grabc->geom.width / 2; cursor->x < grabc->geom.x + grabc->geom.width / 2;
// 记录初始几何信息 // Record initial geometric information
grabc->drag_begin_geom = grabc->geom; grabc->drag_begin_geom = grabc->geom;
} else { } else {
// 计算相对于屏幕尺寸的比例变化 // Calculate proportional change relative to screen size
if (isdrag) { if (isdrag) {
offsetx = cursor->x - drag_begin_cursorx; offsetx = cursor->x - drag_begin_cursorx;
@ -205,11 +205,11 @@ void resize_tile_master_horizontal(Client *grabc, bool isdrag, int32_t offsetx,
} }
} else if ((grabc->cursor_in_upper_half && moving_up) || } else if ((grabc->cursor_in_upper_half && moving_up) ||
(!grabc->cursor_in_upper_half && moving_down)) { (!grabc->cursor_in_upper_half && moving_down)) {
// 光标在窗口上方且向上移动，或在窗口下方且向下移动 → 增加高度 // Cursor above window and moving up, or below window and moving down → increase height
delta_y = fabsf(delta_y); delta_y = fabsf(delta_y);
delta_y = delta_y * 2; delta_y = delta_y * 2;
} else { } else {
// 其他情况 → 减小高度 // Other cases → decrease height
delta_y = -fabsf(delta_y); delta_y = -fabsf(delta_y);
delta_y = delta_y * 2; delta_y = delta_y * 2;
} }
@ -231,17 +231,17 @@ void resize_tile_master_horizontal(Client *grabc, bool isdrag, int32_t offsetx,
delta_x = delta_x * -1.0f; delta_x = delta_x * -1.0f;
} }
// 直接设置新的比例，基于初始值 + 变化量 // Directly set new proportion, based on initial value + change amount
float new_master_mfact_per = grabc->old_master_mfact_per + delta_x; float new_master_mfact_per = grabc->old_master_mfact_per + delta_x;
float new_master_inner_per = grabc->old_master_inner_per + delta_y; float new_master_inner_per = grabc->old_master_inner_per + delta_y;
float new_stack_inner_per = grabc->old_stack_inner_per + delta_y; float new_stack_inner_per = grabc->old_stack_inner_per + delta_y;
// 应用限制，确保比例在合理范围内 // Apply limits to ensure proportion is within reasonable range
new_master_mfact_per = fmaxf(0.1f, fminf(0.9f, new_master_mfact_per)); new_master_mfact_per = fmaxf(0.1f, fminf(0.9f, new_master_mfact_per));
new_master_inner_per = fmaxf(0.1f, fminf(0.9f, new_master_inner_per)); new_master_inner_per = fmaxf(0.1f, fminf(0.9f, new_master_inner_per));
new_stack_inner_per = fmaxf(0.1f, fminf(0.9f, new_stack_inner_per)); new_stack_inner_per = fmaxf(0.1f, fminf(0.9f, new_stack_inner_per));
// 应用到所有平铺窗口 // Apply to all tiling windows
wl_list_for_each(tc, &clients, link) { wl_list_for_each(tc, &clients, link) {
if (VISIBLEON(tc, grabc->mon) && ISTILED(tc)) { if (VISIBLEON(tc, grabc->mon) && ISTILED(tc)) {
tc->master_mfact_per = new_master_mfact_per; tc->master_mfact_per = new_master_mfact_per;
@ -272,23 +272,23 @@ void resize_tile_master_vertical(Client *grabc, bool isdrag, int32_t offsetx,
Client *prev = NULL; Client *prev = NULL;
struct wl_list *node; struct wl_list *node;
// 从当前节点的下一个开始遍历 // Start traversal from next node of current node
for (node = grabc->link.next; node != &clients; node = node->next) { for (node = grabc->link.next; node != &clients; node = node->next) {
tc = wl_container_of(node, tc, link); tc = wl_container_of(node, tc, link);
if (VISIBLEON(tc, grabc->mon) && if (VISIBLEON(tc, grabc->mon) &&
ISTILED(tc)) { // 根据你的实际字段名调整 ISTILED(tc)) { // Adjust according to your actual field names
next = tc; next = tc;
break; break;
} }
} }
// 从当前节点的上一个开始遍历 // Start traversal from previous node of current node
for (node = grabc->link.prev; node != &clients; node = node->prev) { for (node = grabc->link.prev; node != &clients; node = node->prev) {
tc = wl_container_of(node, tc, link); tc = wl_container_of(node, tc, link);
if (VISIBLEON(tc, grabc->mon) && if (VISIBLEON(tc, grabc->mon) &&
ISTILED(tc)) { // 根据你的实际字段名调整 ISTILED(tc)) { // Adjust according to your actual field names
prev = tc; prev = tc;
break; break;
} }
@ -299,7 +299,7 @@ void resize_tile_master_vertical(Client *grabc, bool isdrag, int32_t offsetx,
drag_begin_cursory = cursor->y; drag_begin_cursory = cursor->y;
start_drag_window = true; start_drag_window = true;
// 记录初始状态 // Record initial state
grabc->old_master_mfact_per = grabc->master_mfact_per; grabc->old_master_mfact_per = grabc->master_mfact_per;
grabc->old_master_inner_per = grabc->master_inner_per; grabc->old_master_inner_per = grabc->master_inner_per;
grabc->old_stack_inner_per = grabc->stack_inner_per; grabc->old_stack_inner_per = grabc->stack_inner_per;
@ -307,11 +307,11 @@ void resize_tile_master_vertical(Client *grabc, bool isdrag, int32_t offsetx,
cursor->y < grabc->geom.y + grabc->geom.height / 2; cursor->y < grabc->geom.y + grabc->geom.height / 2;
grabc->cursor_in_left_half = grabc->cursor_in_left_half =
cursor->x < grabc->geom.x + grabc->geom.width / 2; cursor->x < grabc->geom.x + grabc->geom.width / 2;
// 记录初始几何信息 // Record initial geometric information
grabc->drag_begin_geom = grabc->geom; grabc->drag_begin_geom = grabc->geom;
} else { } else {
// 计算相对于屏幕尺寸的比例变化 // Calculate proportional change relative to screen size
// 计算相对于屏幕尺寸的比例变化 // Calculate proportional change relative to screen size
if (isdrag) { if (isdrag) {
offsetx = cursor->x - drag_begin_cursorx; offsetx = cursor->x - drag_begin_cursorx;
@ -326,7 +326,7 @@ void resize_tile_master_vertical(Client *grabc, bool isdrag, int32_t offsetx,
} }
if (grabc->ismaster) { if (grabc->ismaster) {
// 垂直版本：左右移动调整高度比例，上下移动调整宽度比例 // Vertical version: left-right movement adjusts height proportion, up-down movement adjusts width proportion
delta_x = (float)(offsetx) * (grabc->old_master_inner_per) / delta_x = (float)(offsetx) * (grabc->old_master_inner_per) /
grabc->drag_begin_geom.width; grabc->drag_begin_geom.width;
delta_y = (float)(offsety) * (grabc->old_master_mfact_per) / delta_y = (float)(offsety) * (grabc->old_master_mfact_per) /
@ -349,56 +349,56 @@ void resize_tile_master_vertical(Client *grabc, bool isdrag, int32_t offsetx,
moving_right = cursor->x > drag_begin_cursorx; moving_right = cursor->x > drag_begin_cursorx;
} }
// 调整主区域和栈区域的高度比例（垂直分割） // Adjust height proportion of master and stack areas (vertical split)
if (grabc->ismaster && !prev) { if (grabc->ismaster && !prev) {
if (moving_left) { if (moving_left) {
delta_x = -fabsf(delta_x); // 向上移动减少主区域高度 delta_x = -fabsf(delta_x); // Move up to decrease master area height
} else { } else {
delta_x = fabsf(delta_x); // 向下移动增加主区域高度 delta_x = fabsf(delta_x); // Move down to increase master area height
} }
} else if (grabc->ismaster && next && !next->ismaster) { } else if (grabc->ismaster && next && !next->ismaster) {
if (moving_left) { if (moving_left) {
delta_x = fabsf(delta_x); // 向上移动增加主区域高度 delta_x = fabsf(delta_x); // Move up to increase master area height
} else { } else {
delta_x = -fabsf(delta_x); // 向下移动减少主区域高度 delta_x = -fabsf(delta_x); // Move down to decrease master area height
} }
} else if (!grabc->ismaster && prev && prev->ismaster) { } else if (!grabc->ismaster && prev && prev->ismaster) {
if (moving_left) { if (moving_left) {
delta_x = -fabsf(delta_x); // 向上移动减少栈区域高度 delta_x = -fabsf(delta_x); // Move up to decrease stack area height
} else { } else {
delta_x = fabsf(delta_x); // 向下移动增加栈区域高度 delta_x = fabsf(delta_x); // Move down to increase stack area height
} }
} else if (!grabc->ismaster && !next) { } else if (!grabc->ismaster && !next) {
if (moving_left) { if (moving_left) {
delta_x = fabsf(delta_x); // 向上移动增加栈区域高度 delta_x = fabsf(delta_x); // Move up to increase stack area height
} else { } else {
delta_x = -fabsf(delta_x); // 向下移动减少栈区域高度 delta_x = -fabsf(delta_x); // Move down to decrease stack area height
} }
} else if ((grabc->cursor_in_left_half && moving_left) || } else if ((grabc->cursor_in_left_half && moving_left) ||
(!grabc->cursor_in_left_half && moving_right)) { (!grabc->cursor_in_left_half && moving_right)) {
// 光标在窗口左侧且向左移动，或在窗口右侧且向右移动 → 增加宽度 // Cursor on left side of window and moving left, or on right side and moving right → increase width
delta_x = fabsf(delta_x); delta_x = fabsf(delta_x);
delta_x = delta_x * 2; delta_x = delta_x * 2;
} else { } else {
// 其他情况 → 减小宽度 // Other cases → decrease width
delta_x = -fabsf(delta_x); delta_x = -fabsf(delta_x);
delta_x = delta_x * 2; delta_x = delta_x * 2;
} }
// 直接设置新的比例，基于初始值 + 变化量 // Directly set new proportion, based on initial value + change amount
float new_master_mfact_per = grabc->old_master_mfact_per + float new_master_mfact_per = grabc->old_master_mfact_per +
delta_y; // 垂直：delta_y调整主区域高度 delta_y; // Vertical: delta_y adjusts master area height
float new_master_inner_per = grabc->old_master_inner_per + float new_master_inner_per = grabc->old_master_inner_per +
delta_x; // 垂直：delta_x调整主区域内部宽度 delta_x; // Vertical: delta_x adjusts master area internal width
float new_stack_inner_per = grabc->old_stack_inner_per + float new_stack_inner_per = grabc->old_stack_inner_per +
delta_x; // 垂直：delta_x调整栈区域内部宽度 delta_x; // Vertical: delta_x adjusts stack area internal width
// 应用限制，确保比例在合理范围内 // Apply limits to ensure proportion is within reasonable range
new_master_mfact_per = fmaxf(0.1f, fminf(0.9f, new_master_mfact_per)); new_master_mfact_per = fmaxf(0.1f, fminf(0.9f, new_master_mfact_per));
new_master_inner_per = fmaxf(0.1f, fminf(0.9f, new_master_inner_per)); new_master_inner_per = fmaxf(0.1f, fminf(0.9f, new_master_inner_per));
new_stack_inner_per = fmaxf(0.1f, fminf(0.9f, new_stack_inner_per)); new_stack_inner_per = fmaxf(0.1f, fminf(0.9f, new_stack_inner_per));
// 应用到所有平铺窗口 // Apply to all tiling windows
wl_list_for_each(tc, &clients, link) { wl_list_for_each(tc, &clients, link) {
if (VISIBLEON(tc, grabc->mon) && ISTILED(tc)) { if (VISIBLEON(tc, grabc->mon) && ISTILED(tc)) {
tc->master_mfact_per = new_master_mfact_per; tc->master_mfact_per = new_master_mfact_per;
@ -437,7 +437,7 @@ void resize_tile_scroller(Client *grabc, bool isdrag, int32_t offsetx,
drag_begin_cursory = cursor->y; drag_begin_cursory = cursor->y;
start_drag_window = true; start_drag_window = true;
// 记录初始状态 // Record initial state
stack_head->old_scroller_pproportion = stack_head->scroller_proportion; stack_head->old_scroller_pproportion = stack_head->scroller_proportion;
grabc->old_stack_proportion = grabc->stack_proportion; grabc->old_stack_proportion = grabc->stack_proportion;
@ -445,11 +445,11 @@ void resize_tile_scroller(Client *grabc, bool isdrag, int32_t offsetx,
cursor->x < grabc->geom.x + grabc->geom.width / 2; cursor->x < grabc->geom.x + grabc->geom.width / 2;
grabc->cursor_in_upper_half = grabc->cursor_in_upper_half =
cursor->y < grabc->geom.y + grabc->geom.height / 2; cursor->y < grabc->geom.y + grabc->geom.height / 2;
// 记录初始几何信息 // Record initial geometric information
grabc->drag_begin_geom = grabc->geom; grabc->drag_begin_geom = grabc->geom;
} else { } else {
// 计算相对于屏幕尺寸的比例变化 // Calculate proportional change relative to screen size
// 计算相对于屏幕尺寸的比例变化 // Calculate proportional change relative to screen size
if (isdrag) { if (isdrag) {
offsetx = cursor->x - drag_begin_cursorx; offsetx = cursor->x - drag_begin_cursorx;
@ -499,10 +499,10 @@ void resize_tile_scroller(Client *grabc, bool isdrag, int32_t offsetx,
if ((grabc->cursor_in_upper_half && moving_up) || if ((grabc->cursor_in_upper_half && moving_up) ||
(!grabc->cursor_in_upper_half && moving_down)) { (!grabc->cursor_in_upper_half && moving_down)) {
// 光标在窗口上方且向上移动，或在窗口下方且向下移动 → 增加高度 // Cursor above window and moving up, or below window and moving down → increase height
delta_y = fabsf(delta_y); delta_y = fabsf(delta_y);
} else { } else {
// 其他情况 → 减小高度 // Other cases → decrease height
delta_y = -fabsf(delta_y); delta_y = -fabsf(delta_y);
} }
@ -568,7 +568,7 @@ void resize_tile_scroller(Client *grabc, bool isdrag, int32_t offsetx,
} }
} }
// 直接设置新的比例，基于初始值 + 变化量 // Directly set new proportion, based on initial value + change amount
if (isvertical) { if (isvertical) {
new_scroller_proportion = new_scroller_proportion =
stack_head->old_scroller_pproportion + delta_y; stack_head->old_scroller_pproportion + delta_y;
@ -580,7 +580,7 @@ void resize_tile_scroller(Client *grabc, bool isdrag, int32_t offsetx,
new_stack_proportion = grabc->old_stack_proportion + delta_y; new_stack_proportion = grabc->old_stack_proportion + delta_y;
} }
// 应用限制，确保比例在合理范围内 // Apply limits to ensure proportion is within reasonable range
new_scroller_proportion = new_scroller_proportion =
fmaxf(0.1f, fminf(1.0f, new_scroller_proportion)); fmaxf(0.1f, fminf(1.0f, new_scroller_proportion));
new_stack_proportion = fmaxf(0.1f, fminf(1.0f, new_stack_proportion)); new_stack_proportion = fmaxf(0.1f, fminf(1.0f, new_stack_proportion));
@ -705,7 +705,7 @@ void reset_size_per_mon(Monitor *m, int32_t tile_cilent_num,
} }
} }
void // 17 void // Main arrange function
arrange(Monitor *m, bool want_animation, bool from_view) { arrange(Monitor *m, bool want_animation, bool from_view) {
Client *c = NULL; Client *c = NULL;
double total_stack_inner_percent = 0; double total_stack_inner_percent = 0;

84
src/layout/horizontal.h
View file

@ -1,4 +1,4 @@
// 网格布局窗口大小和位置计算 // Grid layout window size and position calculation
void grid(Monitor *m) { void grid(Monitor *m) {
int32_t i, n; int32_t i, n;
int32_t cx, cy, cw, ch; int32_t cx, cy, cw, ch;
@ -16,7 +16,7 @@ void grid(Monitor *m) {
n = m->isoverview ? m->visible_clients : m->visible_tiling_clients; n = m->isoverview ? m->visible_clients : m->visible_tiling_clients;
if (n == 0) { if (n == 0) {
return; // 没有需要处理的客户端，直接返回 return; // No clients to process, return directly
} }
if (n == 1) { if (n == 1) {
@ -68,7 +68,7 @@ void grid(Monitor *m) {
return; return;
} }
// 计算列数和行数 // Calculate columns and rows
for (cols = 0; cols <= n / 2; cols++) { for (cols = 0; cols <= n / 2; cols++) {
if (cols * cols >= n) { if (cols * cols >= n) {
break; break;
@ -76,18 +76,18 @@ void grid(Monitor *m) {
} }
rows = (cols && (cols - 1) * cols >= n) ? cols - 1 : cols; rows = (cols && (cols - 1) * cols >= n) ? cols - 1 : cols;
// 计算每个客户端的高度和宽度 // Calculate height and width for each client
ch = (m->w.height - 2 * target_gappo - (rows - 1) * target_gappi) / rows; ch = (m->w.height - 2 * target_gappo - (rows - 1) * target_gappi) / rows;
cw = (m->w.width - 2 * target_gappo - (cols - 1) * target_gappi) / cols; cw = (m->w.width - 2 * target_gappo - (cols - 1) * target_gappi) / cols;
// 处理多余的列 // Handle extra columns
overcols = n % cols; overcols = n % cols;
if (overcols) { if (overcols) {
dx = (m->w.width - overcols * cw - (overcols - 1) * target_gappi) / 2 - dx = (m->w.width - overcols * cw - (overcols - 1) * target_gappi) / 2 -
target_gappo; target_gappo;
} }
// 调整每个客户端的位置和大小 // Adjust position and size for each client
i = 0; i = 0;
wl_list_for_each(c, &clients, link) { wl_list_for_each(c, &clients, link) {
@ -273,13 +273,13 @@ void horizontal_check_scroller_root_inside_mon(Client *c,
} }
} }
// 滚动布局 // Scroll layout
void scroller(Monitor *m) { void scroller(Monitor *m) {
int32_t i, n, j; int32_t i, n, j;
float single_proportion = 1.0; float single_proportion = 1.0;
Client *c = NULL, *root_client = NULL; Client *c = NULL, *root_client = NULL;
Client **tempClients = NULL; // 初始化为 NULL Client **tempClients = NULL; // Initialize to NULL
struct wlr_box target_geom; struct wlr_box target_geom;
int32_t focus_client_index = 0; int32_t focus_client_index = 0;
bool need_scroller = false; bool need_scroller = false;
@ -300,17 +300,17 @@ void scroller(Monitor *m) {
n = m->visible_scroll_tiling_clients; n = m->visible_scroll_tiling_clients;
if (n == 0) { if (n == 0) {
return; // 没有需要处理的客户端，直接返回 return; // No clients to process, return directly
} }
// 动态分配内存 // Allocate memory dynamically
tempClients = malloc(n * sizeof(Client *)); tempClients = malloc(n * sizeof(Client *));
if (!tempClients) { if (!tempClients) {
// 处理内存分配失败的情况 // Handle memory allocation failure
return; return;
} }
// 第二次遍历，填充 tempClients // Second pass: fill tempClients
j = 0; j = 0;
wl_list_for_each(c, &clients, link) { wl_list_for_each(c, &clients, link) {
if (VISIBLEON(c, m) && ISSCROLLTILED(c) && !c->prev_in_stack) { if (VISIBLEON(c, m) && ISSCROLLTILED(c) && !c->prev_in_stack) {
@ -333,7 +333,7 @@ void scroller(Monitor *m) {
target_geom.y = m->w.y + (m->w.height - target_geom.height) / 2; target_geom.y = m->w.y + (m->w.height - target_geom.height) / 2;
horizontal_check_scroller_root_inside_mon(c, &target_geom); horizontal_check_scroller_root_inside_mon(c, &target_geom);
arrange_stack(c, target_geom, cur_gappiv); arrange_stack(c, target_geom, cur_gappiv);
free(tempClients); // 释放内存 free(tempClients); // Release memory
return; return;
} }
@ -352,7 +352,7 @@ void scroller(Monitor *m) {
} }
if (!root_client) { if (!root_client) {
free(tempClients); // 释放内存 free(tempClients); // Release memory
return; return;
} }
@ -440,7 +440,7 @@ void scroller(Monitor *m) {
arrange_stack(c, target_geom, cur_gappiv); arrange_stack(c, target_geom, cur_gappiv);
} }
free(tempClients); // 最后释放内存 free(tempClients); // Finally release memory
} }
void center_tile(Monitor *m) { void center_tile(Monitor *m) {
@ -460,19 +460,19 @@ void center_tile(Monitor *m) {
if (n == 0) if (n == 0)
return; return;
// 获取第一个可见的平铺客户端用于主区域宽度百分比 // Get the first visible tiling client for master area width percentage
wl_list_for_each(fc, &clients, link) { wl_list_for_each(fc, &clients, link) {
if (VISIBLEON(fc, m) && ISTILED(fc)) if (VISIBLEON(fc, m) && ISTILED(fc))
break; break;
} }
// 间隙参数处理 // Gap parameter handling
int32_t cur_gappiv = enablegaps ? m->gappiv : 0; // 内部垂直间隙 int32_t cur_gappiv = enablegaps ? m->gappiv : 0; // Internal vertical gap
int32_t cur_gappih = enablegaps ? m->gappih : 0; // 内部水平间隙 int32_t cur_gappih = enablegaps ? m->gappih : 0; // Internal horizontal gap
int32_t cur_gappov = enablegaps ? m->gappov : 0; // 外部垂直间隙 int32_t cur_gappov = enablegaps ? m->gappov : 0; // Outer vertical gap
int32_t cur_gappoh = enablegaps ? m->gappoh : 0; // 外部水平间隙 int32_t cur_gappoh = enablegaps ? m->gappoh : 0; // Outer horizontal gap
// 智能间隙处理 // Smart gap handling
cur_gappiv = smartgaps && m->visible_tiling_clients == 1 ? 0 : cur_gappiv; cur_gappiv = smartgaps && m->visible_tiling_clients == 1 ? 0 : cur_gappiv;
cur_gappih = smartgaps && m->visible_tiling_clients == 1 ? 0 : cur_gappih; cur_gappih = smartgaps && m->visible_tiling_clients == 1 ? 0 : cur_gappih;
cur_gappov = smartgaps && m->visible_tiling_clients == 1 ? 0 : cur_gappov; cur_gappov = smartgaps && m->visible_tiling_clients == 1 ? 0 : cur_gappov;
@ -482,13 +482,13 @@ void center_tile(Monitor *m) {
mfact = fc->master_mfact_per > 0.0f ? fc->master_mfact_per mfact = fc->master_mfact_per > 0.0f ? fc->master_mfact_per
: m->pertag->mfacts[m->pertag->curtag]; : m->pertag->mfacts[m->pertag->curtag];
// 初始化区域 // Initialize areas
mw = m->w.width; mw = m->w.width;
mx = cur_gappoh; mx = cur_gappoh;
my = cur_gappov; my = cur_gappov;
tw = mw; tw = mw;
// 判断是否需要主区域铺满 // Determine if master area should overspread
int32_t should_overspread = center_master_overspread && (n <= nmasters); int32_t should_overspread = center_master_overspread && (n <= nmasters);
int32_t master_surplus_height = int32_t master_surplus_height =
@ -505,35 +505,35 @@ void center_tile(Monitor *m) {
float slave_right_surplus_ratio = 1.0; float slave_right_surplus_ratio = 1.0;
if (n > nmasters || !should_overspread) { if (n > nmasters || !should_overspread) {
// 计算主区域宽度（居中模式） // Calculate master area width (centered mode)
mw = nmasters ? (m->w.width - 2 * cur_gappoh - cur_gappih * ie) * mfact mw = nmasters ? (m->w.width - 2 * cur_gappoh - cur_gappih * ie) * mfact
: 0; : 0;
if (n - nmasters > 1) { if (n - nmasters > 1) {
// 多个堆叠窗口：主区域居中，左右两侧各有一个堆叠区域 // Multiple stack windows: master centered, one stack area on each side
tw = (m->w.width - mw) / 2 - cur_gappoh - cur_gappih * ie; tw = (m->w.width - mw) / 2 - cur_gappoh - cur_gappih * ie;
mx = cur_gappoh + tw + cur_gappih * ie; mx = cur_gappoh + tw + cur_gappih * ie;
} else if (n - nmasters == 1) { } else if (n - nmasters == 1) {
// 单个堆叠窗口的处理 // Single stack window handling
if (center_when_single_stack) { if (center_when_single_stack) {
// stack在右边，master居中，左边空着 // stack on the right, master centered, left side empty
tw = (m->w.width - mw) / 2 - cur_gappoh - cur_gappih * ie; tw = (m->w.width - mw) / 2 - cur_gappoh - cur_gappih * ie;
mx = cur_gappoh + tw + cur_gappih * ie; // master居中 mx = cur_gappoh + tw + cur_gappih * ie; // master centered
} else { } else {
// stack在右边，master在左边 // stack on the right, master on the left
tw = m->w.width - mw - 2 * cur_gappoh - cur_gappih * ie; tw = m->w.width - mw - 2 * cur_gappoh - cur_gappih * ie;
mx = cur_gappoh; // master在左边 mx = cur_gappoh; // master on the left
} }
} else { } else {
// 只有主区域窗口：居中显示 // Only master area windows: center display
tw = (m->w.width - mw) / 2 - cur_gappoh - cur_gappih * ie; tw = (m->w.width - mw) / 2 - cur_gappoh - cur_gappih * ie;
mx = cur_gappoh + tw + cur_gappih * ie; mx = cur_gappoh + tw + cur_gappih * ie;
} }
} else { } else {
// 主区域铺满模式（只有主区域窗口时） // Master area overspread mode (when only master area windows exist)
mw = m->w.width - 2 * cur_gappoh; mw = m->w.width - 2 * cur_gappoh;
mx = cur_gappoh; mx = cur_gappoh;
tw = 0; // 堆叠区域宽度为0 tw = 0; // Stack area width is 0
} }
oty = cur_gappov; oty = cur_gappov;
@ -545,7 +545,7 @@ void center_tile(Monitor *m) {
continue; continue;
if (i < nmasters) { if (i < nmasters) {
// 主区域窗口 // Master area windows
r = MIN(n, nmasters) - i; r = MIN(n, nmasters) - i;
if (c->master_inner_per > 0.0f) { if (c->master_inner_per > 0.0f) {
h = master_surplus_height * c->master_inner_per / h = master_surplus_height * c->master_inner_per /
@ -571,11 +571,11 @@ void center_tile(Monitor *m) {
0); 0);
my += c->geom.height + cur_gappiv * ie; my += c->geom.height + cur_gappiv * ie;
} else { } else {
// 堆叠区域窗口 // Stack area windows
int32_t stack_index = i - nmasters; int32_t stack_index = i - nmasters;
if (n - nmasters == 1) { if (n - nmasters == 1) {
// 单个堆叠窗口 // Single stack window
r = n - i; r = n - i;
if (c->stack_inner_per > 0.0f) { if (c->stack_inner_per > 0.0f) {
h = (m->w.height - 2 * cur_gappov - h = (m->w.height - 2 * cur_gappov -
@ -593,10 +593,10 @@ void center_tile(Monitor *m) {
int32_t stack_x; int32_t stack_x;
if (center_when_single_stack) { if (center_when_single_stack) {
// 放在右侧（master居中时，stack在右边） // Place on the right (when master is centered, stack is on the right)
stack_x = m->w.x + mx + mw + cur_gappih * ie; stack_x = m->w.x + mx + mw + cur_gappih * ie;
} else { } else {
// 放在右侧（master在左边时，stack在右边） // Place on the right (when master is on the left, stack is on the right)
stack_x = m->w.x + mx + mw + cur_gappih * ie; stack_x = m->w.x + mx + mw + cur_gappih * ie;
} }
@ -608,11 +608,11 @@ void center_tile(Monitor *m) {
0); 0);
ety += c->geom.height + cur_gappiv * ie; ety += c->geom.height + cur_gappiv * ie;
} else { } else {
// 多个堆叠窗口：交替放在左右两侧 // Multiple stack windows: alternate on left and right sides
r = (n - i + 1) / 2; r = (n - i + 1) / 2;
if ((stack_index % 2) ^ (n % 2 == 0)) { if ((stack_index % 2) ^ (n % 2 == 0)) {
// 右侧堆叠窗口 // Right stack window
if (c->stack_inner_per > 0.0f) { if (c->stack_inner_per > 0.0f) {
h = slave_right_surplus_height * c->stack_inner_per / h = slave_right_surplus_height * c->stack_inner_per /
slave_right_surplus_ratio; slave_right_surplus_ratio;
@ -641,7 +641,7 @@ void center_tile(Monitor *m) {
0); 0);
ety += c->geom.height + cur_gappiv * ie; ety += c->geom.height + cur_gappiv * ie;
} else { } else {
// 左侧堆叠窗口 // Left stack window
if (c->stack_inner_per > 0.0f) { if (c->stack_inner_per > 0.0f) {
h = slave_left_surplus_height * c->stack_inner_per / h = slave_left_surplus_height * c->stack_inner_per /
slave_left_surplus_ratio; slave_left_surplus_ratio;

26
src/layout/layout.h
View file

@ -32,19 +32,19 @@ enum {
}; };
Layout layouts[] = { Layout layouts[] = {
// 最少两个,不能删除少于两个 // At least two required, cannot delete to less than two
/* symbol arrange function name */ /* symbol arrange function name */
{"T", tile, "tile", TILE}, // 平铺布局 {"T", tile, "tile", TILE}, // Tile layout
{"S", scroller, "scroller", SCROLLER}, // 滚动布局 {"S", scroller, "scroller", SCROLLER}, // Scroll layout
{"G", grid, "grid", GRID}, // 格子布局 {"G", grid, "grid", GRID}, // Grid layout
{"M", monocle, "monocle", MONOCLE}, // 单屏布局 {"M", monocle, "monocle", MONOCLE}, // Monocle layout
{"K", deck, "deck", DECK}, // 卡片布局 {"K", deck, "deck", DECK}, // Deck layout
{"CT", center_tile, "center_tile", CENTER_TILE}, // 居中布局 {"CT", center_tile, "center_tile", CENTER_TILE}, // Center tile layout
{"RT", right_tile, "right_tile", RIGHT_TILE}, // 右布局 {"RT", right_tile, "right_tile", RIGHT_TILE}, // Right tile layout
{"VS", vertical_scroller, "vertical_scroller", {"VS", vertical_scroller, "vertical_scroller",
VERTICAL_SCROLLER}, // 垂直滚动布局 VERTICAL_SCROLLER}, // Vertical scroll layout
{"VT", vertical_tile, "vertical_tile", VERTICAL_TILE}, // 垂直平铺布局 {"VT", vertical_tile, "vertical_tile", VERTICAL_TILE}, // Vertical tile layout
{"VG", vertical_grid, "vertical_grid", VERTICAL_GRID}, // 垂直格子布局 {"VG", vertical_grid, "vertical_grid", VERTICAL_GRID}, // Vertical grid layout
{"VK", vertical_deck, "vertical_deck", VERTICAL_DECK}, // 垂直卡片布局 {"VK", vertical_deck, "vertical_deck", VERTICAL_DECK}, // Vertical deck layout
{"TG", tgmix, "tgmix", TGMIX}, // 混合布局 {"TG", tgmix, "tgmix", TGMIX}, // Mix layout
}; };

2
src/layout/vertical.h
View file

@ -260,7 +260,7 @@ void vertical_check_scroller_root_inside_mon(Client *c,
} }
} }
// 竖屏滚动布局 // Vertical scroll layout
void vertical_scroller(Monitor *m) { void vertical_scroller(Monitor *m) {
int32_t i, n, j; int32_t i, n, j;
float single_proportion = 1.0; float single_proportion = 1.0;

230
src/mango.c
View file

@ -166,7 +166,7 @@ enum { VERTICAL, HORIZONTAL };
enum { SWIPE_UP, SWIPE_DOWN, SWIPE_LEFT, SWIPE_RIGHT }; enum { SWIPE_UP, SWIPE_DOWN, SWIPE_LEFT, SWIPE_RIGHT };
enum { CurNormal, CurPressed, CurMove, CurResize }; /* cursor */ enum { CurNormal, CurPressed, CurMove, CurResize }; /* cursor */
enum { XDGShell, LayerShell, X11 }; /* client types */ enum { XDGShell, LayerShell, X11 }; /* client types */
enum { AxisUp, AxisDown, AxisLeft, AxisRight }; // 滚轮滚动的方向 enum { AxisUp, AxisDown, AxisLeft, AxisRight }; // Mouse wheel scroll directions
enum { enum {
LyrBg, LyrBg,
LyrBlur, LyrBlur,
@ -205,7 +205,7 @@ enum seat_config_shortcuts_inhibit {
SHORTCUTS_INHIBIT_ENABLE, SHORTCUTS_INHIBIT_ENABLE,
}; };
// 事件掩码枚举 // Event mask enum
enum print_event_type { enum print_event_type {
PRINT_ACTIVE = 1 << 0, PRINT_ACTIVE = 1 << 0,
PRINT_TAG = 1 << 1, PRINT_TAG = 1 << 1,
@ -224,7 +224,7 @@ enum print_event_type {
PRINT_KEYMODE = 1 << 14, PRINT_KEYMODE = 1 << 14,
PRINT_SCALEFACTOR = 1 << 15, PRINT_SCALEFACTOR = 1 << 15,
PRINT_FRAME = 1 << 16, PRINT_FRAME = 1 << 16,
PRINT_ALL = (1 << 17) - 1 // 所有位都设为1 PRINT_ALL = (1 << 17) - 1 // All bits set to 1
}; };
typedef struct Pertag Pertag; typedef struct Pertag Pertag;
@ -256,7 +256,7 @@ typedef struct {
uint32_t button; uint32_t button;
int32_t (*func)(const Arg *); int32_t (*func)(const Arg *);
const Arg arg; const Arg arg;
} Button; // 鼠标按键 } Button; // Mouse buttons
typedef struct { typedef struct {
char mode[28]; char mode[28];
@ -564,18 +564,18 @@ typedef struct {
/* function declarations */ /* function declarations */
static void applybounds( static void applybounds(
Client *c, Client *c,
struct wlr_box *bbox); // 设置边界规则,能让一些窗口拥有比较适合的大小 struct wlr_box *bbox); // Set boundary rules to allow some windows to have appropriate sizes
static void applyrules(Client *c); // 窗口规则应用,应用config.h中定义的窗口规则 static void applyrules(Client *c); // Apply window rules defined in config.h
static void arrange(Monitor *m, bool want_animation, static void arrange(Monitor *m, bool want_animation,
bool from_view); // 布局函数,让窗口俺平铺规则移动和重置大小 bool from_view); // Layout function to move and resize windows according to tiling rules
static void arrangelayer(Monitor *m, struct wl_list *list, static void arrangelayer(Monitor *m, struct wl_list *list,
struct wlr_box *usable_area, int32_t exclusive); struct wlr_box *usable_area, int32_t exclusive);
static void arrangelayers(Monitor *m); static void arrangelayers(Monitor *m);
static void handle_print_status(struct wl_listener *listener, void *data); static void handle_print_status(struct wl_listener *listener, void *data);
static void axisnotify(struct wl_listener *listener, static void axisnotify(struct wl_listener *listener,
void *data); // 滚轮事件处理 void *data); // Mouse wheel event handling
static void buttonpress(struct wl_listener *listener, static void buttonpress(struct wl_listener *listener,
void *data); // 鼠标按键事件处理 void *data); // Mouse button event handling
static int32_t ongesture(struct wlr_pointer_swipe_end_event *event); static int32_t ongesture(struct wlr_pointer_swipe_end_event *event);
static void swipe_begin(struct wl_listener *listener, void *data); static void swipe_begin(struct wl_listener *listener, void *data);
static void swipe_update(struct wl_listener *listener, void *data); static void swipe_update(struct wl_listener *listener, void *data);
@ -591,7 +591,7 @@ static void cleanupmon(struct wl_listener *listener,
void *data); // Monitor cleanup void *data); // Monitor cleanup
static void closemon(Monitor *m); static void closemon(Monitor *m);
static void cleanuplisteners(void); static void cleanuplisteners(void);
static void toggle_hotarea(int32_t x_root, int32_t y_root); // 触发热区 static void toggle_hotarea(int32_t x_root, int32_t y_root); // Trigger hot area
static void maplayersurfacenotify(struct wl_listener *listener, void *data); static void maplayersurfacenotify(struct wl_listener *listener, void *data);
static void commitlayersurfacenotify(struct wl_listener *listener, void *data); static void commitlayersurfacenotify(struct wl_listener *listener, void *data);
static void commitnotify(struct wl_listener *listener, void *data); static void commitnotify(struct wl_listener *listener, void *data);
@ -1029,7 +1029,7 @@ void clear_fullscreen_and_maximized_state(Monitor *m) {
} }
} }
/*清除全屏标志,还原全屏时清0的border*/ /*Clear fullscreen flag and restore border that was set to 0 during fullscreen*/
void clear_fullscreen_flag(Client *c) { void clear_fullscreen_flag(Client *c) {
if ((c->mon->pertag->ltidxs[get_tags_first_tag_num(c->tags)]->id == if ((c->mon->pertag->ltidxs[get_tags_first_tag_num(c->tags)]->id ==
@ -1052,7 +1052,7 @@ void clear_fullscreen_flag(Client *c) {
void show_scratchpad(Client *c) { void show_scratchpad(Client *c) {
c->is_scratchpad_show = 1; c->is_scratchpad_show = 1;
if (c->isfullscreen || c->ismaximizescreen) { if (c->isfullscreen || c->ismaximizescreen) {
c->isfullscreen = 0; // 清除窗口全屏标志 c->isfullscreen = 0; // Clear window fullscreen flag
c->ismaximizescreen = 0; c->ismaximizescreen = 0;
c->bw = c->isnoborder ? 0 : borderpx; c->bw = c->isnoborder ? 0 : borderpx;
} }
@ -1066,7 +1066,7 @@ void show_scratchpad(Client *c) {
c->geom.height = c->iscustomsize c->geom.height = c->iscustomsize
? c->float_geom.height ? c->float_geom.height
: c->mon->w.height * scratchpad_height_ratio; : c->mon->w.height * scratchpad_height_ratio;
// 重新计算居中的坐标 // Recalculate centered coordinates
c->float_geom = c->geom = c->animainit_geom = c->animation.current = c->float_geom = c->geom = c->animainit_geom = c->animation.current =
setclient_coordinate_center(c, c->mon, c->geom, 0, 0); setclient_coordinate_center(c, c->mon, c->geom, 0, 0);
c->iscustomsize = 1; c->iscustomsize = 1;
@ -1074,8 +1074,8 @@ void show_scratchpad(Client *c) {
} }
c->oldtags = c->mon->tagset[c->mon->seltags]; c->oldtags = c->mon->tagset[c->mon->seltags];
wl_list_remove(&c->link); // 从原来位置移除 wl_list_remove(&c->link); // Remove from original position
wl_list_insert(clients.prev->next, &c->link); // 插入开头 wl_list_insert(clients.prev->next, &c->link); // Insert at head
show_hide_client(c); show_hide_client(c);
setborder_color(c); setborder_color(c);
} }
@ -1135,14 +1135,14 @@ bool switch_scratchpad_client_state(Client *c) {
if (scratchpad_cross_monitor && selmon && c->mon != selmon && if (scratchpad_cross_monitor && selmon && c->mon != selmon &&
c->is_in_scratchpad) { c->is_in_scratchpad) {
// 保存原始monitor用于尺寸计算 // Save original monitor for size calculation
Monitor *oldmon = c->mon; Monitor *oldmon = c->mon;
c->scratchpad_switching_mon = true; c->scratchpad_switching_mon = true;
c->mon = selmon; c->mon = selmon;
reset_foreign_tolevel(c); reset_foreign_tolevel(c);
client_update_oldmonname_record(c, selmon); client_update_oldmonname_record(c, selmon);
// 根据新monitor调整窗口尺寸 // Adjust window size based on new monitor
c->float_geom.width = c->float_geom.width =
(int32_t)(c->float_geom.width * c->mon->w.width / oldmon->w.width); (int32_t)(c->float_geom.width * c->mon->w.width / oldmon->w.width);
c->float_geom.height = (int32_t)(c->float_geom.height * c->float_geom.height = (int32_t)(c->float_geom.height *
@ -1151,7 +1151,7 @@ bool switch_scratchpad_client_state(Client *c) {
c->float_geom = c->float_geom =
setclient_coordinate_center(c, c->mon, c->float_geom, 0, 0); setclient_coordinate_center(c, c->mon, c->float_geom, 0, 0);
// 只有显示状态的scratchpad才需要聚焦和返回true // Only scratchpad in displayed state needs focus and returns true
if (c->is_scratchpad_show) { if (c->is_scratchpad_show) {
c->tags = get_tags_first_tag(selmon->tagset[selmon->seltags]); c->tags = get_tags_first_tag(selmon->tagset[selmon->seltags]);
resize(c, c->float_geom, 0); resize(c, c->float_geom, 0);
@ -1239,59 +1239,59 @@ void handlesig(int32_t signo) {
} }
void toggle_hotarea(int32_t x_root, int32_t y_root) { void toggle_hotarea(int32_t x_root, int32_t y_root) {
// 左下角热区坐标计算,兼容多显示屏 // Bottom-left hot area coordinate calculation, compatible with multiple displays
Arg arg = {0}; Arg arg = {0};
// 在刚启动的时候,selmon为NULL,但鼠标可能已经处于热区, // At startup, selmon is NULL, but mouse may already be in hot area,
// 必须判断避免奔溃 // Must check to avoid crash
if (!selmon) if (!selmon)
return; return;
if (grabc) if (grabc)
return; return;
// 根据热角位置计算不同的热区坐标 // Calculate different hot area coordinates based on hot corner position
unsigned hx, hy; unsigned hx, hy;
switch (hotarea_corner) { switch (hotarea_corner) {
case BOTTOM_RIGHT: // 右下角 case BOTTOM_RIGHT: // Bottom-right corner
hx = selmon->m.x + selmon->m.width - hotarea_size; hx = selmon->m.x + selmon->m.width - hotarea_size;
hy = selmon->m.y + selmon->m.height - hotarea_size; hy = selmon->m.y + selmon->m.height - hotarea_size;
break; break;
case TOP_LEFT: // 左上角 case TOP_LEFT: // Top-left corner
hx = selmon->m.x + hotarea_size; hx = selmon->m.x + hotarea_size;
hy = selmon->m.y + hotarea_size; hy = selmon->m.y + hotarea_size;
break; break;
case TOP_RIGHT: // 右上角 case TOP_RIGHT: // Top-right corner
hx = selmon->m.x + selmon->m.width - hotarea_size; hx = selmon->m.x + selmon->m.width - hotarea_size;
hy = selmon->m.y + hotarea_size; hy = selmon->m.y + hotarea_size;
break; break;
case BOTTOM_LEFT: // 左下角（默认） case BOTTOM_LEFT: // Bottom-left corner (default)
default: default:
hx = selmon->m.x + hotarea_size; hx = selmon->m.x + hotarea_size;
hy = selmon->m.y + selmon->m.height - hotarea_size; hy = selmon->m.y + selmon->m.height - hotarea_size;
break; break;
} }
// 判断鼠标是否在热区内 // Check if mouse is in hot area
int in_hotarea = 0; int in_hotarea = 0;
switch (hotarea_corner) { switch (hotarea_corner) {
case BOTTOM_RIGHT: // 右下角 case BOTTOM_RIGHT: // Bottom-right corner
in_hotarea = (y_root > hy && x_root > hx && in_hotarea = (y_root > hy && x_root > hx &&
x_root <= (selmon->m.x + selmon->m.width) && x_root <= (selmon->m.x + selmon->m.width) &&
y_root <= (selmon->m.y + selmon->m.height)); y_root <= (selmon->m.y + selmon->m.height));
break; break;
case TOP_LEFT: // 左上角 case TOP_LEFT: // Top-left corner
in_hotarea = (y_root < hy && x_root < hx && x_root >= selmon->m.x && in_hotarea = (y_root < hy && x_root < hx && x_root >= selmon->m.x &&
y_root >= selmon->m.y); y_root >= selmon->m.y);
break; break;
case TOP_RIGHT: // 右上角 case TOP_RIGHT: // Top-right corner
in_hotarea = (y_root < hy && x_root > hx && in_hotarea = (y_root < hy && x_root > hx &&
x_root <= (selmon->m.x + selmon->m.width) && x_root <= (selmon->m.x + selmon->m.width) &&
y_root >= selmon->m.y); y_root >= selmon->m.y);
break; break;
case BOTTOM_LEFT: // 左下角（默认） case BOTTOM_LEFT: // Bottom-left corner (default)
default: default:
in_hotarea = (y_root > hy && x_root < hx && x_root >= selmon->m.x && in_hotarea = (y_root > hy && x_root < hx && x_root >= selmon->m.x &&
y_root <= (selmon->m.y + selmon->m.height)); y_root <= (selmon->m.y + selmon->m.height));
@ -1748,7 +1748,7 @@ void arrangelayers(Monitor *m) {
reset_exclusive_layer(m); reset_exclusive_layer(m);
} }
void // 鼠标滚轮事件 void // Mouse wheel event
axisnotify(struct wl_listener *listener, void *data) { axisnotify(struct wl_listener *listener, void *data) {
/* This event is forwarded by the cursor when a pointer emits an axis event, /* This event is forwarded by the cursor when a pointer emits an axis event,
@ -1784,14 +1784,14 @@ axisnotify(struct wl_listener *listener, void *data) {
if (config.axis_bindings_count < 1) if (config.axis_bindings_count < 1)
break; break;
a = &config.axis_bindings[ji]; a = &config.axis_bindings[ji];
if (CLEANMASK(mods) == CLEANMASK(a->mod) && // 按键一致 if (CLEANMASK(mods) == CLEANMASK(a->mod) && // Keys match
adir == a->dir && a->func) { // 滚轮方向判断一致且处理函数存在 adir == a->dir && a->func) { // Scroll direction matches and handler function exists
if (event->time_msec - axis_apply_time > axis_bind_apply_timeout || if (event->time_msec - axis_apply_time > axis_bind_apply_timeout ||
axis_apply_dir * event->delta < 0) { axis_apply_dir * event->delta < 0) {
a->func(&a->arg); a->func(&a->arg);
axis_apply_time = event->time_msec; axis_apply_time = event->time_msec;
axis_apply_dir = event->delta > 0 ? 1 : -1; axis_apply_dir = event->delta > 0 ? 1 : -1;
return; // 如果成功匹配就不把这个滚轮事件传送给客户端了 return; // If successfully matched, do not send this wheel event to client
} else { } else {
axis_apply_dir = event->delta > 0 ? 1 : -1; axis_apply_dir = event->delta > 0 ? 1 : -1;
axis_apply_time = event->time_msec; axis_apply_time = event->time_msec;
@ -1805,7 +1805,7 @@ axisnotify(struct wl_listener *listener, void *data) {
*/ */
/* Notify the client with pointer focus of the axis event. */ /* Notify the client with pointer focus of the axis event. */
wlr_seat_pointer_notify_axis( wlr_seat_pointer_notify_axis(
seat, // 滚轮事件发送给客户端也就是窗口 seat, // Send wheel event to client (window)
event->time_msec, event->orientation, event->delta * axis_scroll_factor, event->time_msec, event->orientation, event->delta * axis_scroll_factor,
roundf(event->delta_discrete * axis_scroll_factor), event->source, roundf(event->delta_discrete * axis_scroll_factor), event->source,
event->relative_direction); event->relative_direction);
@ -1969,16 +1969,16 @@ bool check_trackpad_disabled(struct wlr_pointer *pointer) {
if (wlr_input_device_is_libinput(&pointer->base) && if (wlr_input_device_is_libinput(&pointer->base) &&
(device = wlr_libinput_get_device_handle(&pointer->base))) { (device = wlr_libinput_get_device_handle(&pointer->base))) {
// 如果是触摸板且被禁用，忽略事件 // If it is touchpad and disabled, ignore event
if (libinput_device_config_tap_get_finger_count(device) > 0) { if (libinput_device_config_tap_get_finger_count(device) > 0) {
return true; // 不处理事件 return true; // Do not handle event
} }
} }
return false; return false;
} }
void // 鼠标按键事件 void // Mouse button event
buttonpress(struct wl_listener *listener, void *data) { buttonpress(struct wl_listener *listener, void *data) {
struct wlr_pointer_button_event *event = data; struct wlr_pointer_button_event *event = data;
struct wlr_keyboard *hard_keyboard, *keyboard; struct wlr_keyboard *hard_keyboard, *keyboard;
@ -2017,7 +2017,7 @@ buttonpress(struct wl_listener *listener, void *data) {
motionnotify(0, NULL, 0, 0, 0, 0); motionnotify(0, NULL, 0, 0, 0, 0);
} }
// 聚焦按需要交互焦点的layer，但注意不能抢占独占焦点的layer // Focus layer that needs interactive focus, but note cannot preempt exclusive focus layer
if (l && !exclusive_focus && if (l && !exclusive_focus &&
l->layer_surface->current.keyboard_interactive == l->layer_surface->current.keyboard_interactive ==
ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND) { ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND) {
@ -2025,8 +2025,8 @@ buttonpress(struct wl_listener *listener, void *data) {
} }
} }
// 当鼠标焦点在layer上的时候，不检测虚拟键盘的mod状态， // When mouse focus is on layer, do not detect virtual keyboard mod state,
// 避免layer虚拟键盘锁死mod按键状态 // Avoid layer virtual keyboard locking mod key state
hard_keyboard = &kb_group->wlr_group->keyboard; hard_keyboard = &kb_group->wlr_group->keyboard;
hard_mods = hard_mods =
hard_keyboard ? wlr_keyboard_get_modifiers(hard_keyboard) : 0; hard_keyboard ? wlr_keyboard_get_modifiers(hard_keyboard) : 0;
@ -2314,7 +2314,7 @@ void layer_flush_blur_background(LayerSurface *l) {
if (!blur) if (!blur)
return; return;
// 如果背景层发生变化,标记优化的模糊背景缓存需要更新 // If background layer changes, mark optimized blur background cache needs update
if (l->layer_surface->current.layer == if (l->layer_surface->current.layer ==
ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND) { ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND) {
if (l->mon) { if (l->mon) {
@ -2334,11 +2334,11 @@ void maplayersurfacenotify(struct wl_listener *listener, void *data) {
if (!l->mon) if (!l->mon)
return; return;
strncpy(l->mon->last_surface_ws_name, layer_surface->namespace, strncpy(l->mon->last_surface_ws_name, layer_surface->namespace,
sizeof(l->mon->last_surface_ws_name) - 1); // 最多拷贝255个字符 sizeof(l->mon->last_surface_ws_name) - 1); // Copy at most 255 characters
l->mon->last_surface_ws_name[sizeof(l->mon->last_surface_ws_name) - 1] = l->mon->last_surface_ws_name[sizeof(l->mon->last_surface_ws_name) - 1] =
'\0'; // 确保字符串以null结尾 '\0'; // Ensure string ends with null
// 初始化几何位置 // Initialize geometric position
get_layer_target_geometry(l, &l->geom); get_layer_target_geometry(l, &l->geom);
l->noanim = 0; l->noanim = 0;
@ -2347,7 +2347,7 @@ void maplayersurfacenotify(struct wl_listener *listener, void *data) {
l->shadow = NULL; l->shadow = NULL;
l->need_output_flush = true; l->need_output_flush = true;
// 应用layer规则 // Apply layer rules
for (ji = 0; ji < config.layer_rules_count; ji++) { for (ji = 0; ji < config.layer_rules_count; ji++) {
if (config.layer_rules_count < 1) if (config.layer_rules_count < 1)
break; break;
@ -2363,7 +2363,7 @@ void maplayersurfacenotify(struct wl_listener *listener, void *data) {
} }
} }
// 初始化阴影 // Initialize shadow
if (layer_surface->current.exclusive_zone == 0 && if (layer_surface->current.exclusive_zone == 0 &&
layer_surface->current.layer != ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM && layer_surface->current.layer != ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM &&
layer_surface->current.layer != ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND) { layer_surface->current.layer != ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND) {
@ -2373,16 +2373,16 @@ void maplayersurfacenotify(struct wl_listener *listener, void *data) {
wlr_scene_node_set_enabled(&l->shadow->node, true); wlr_scene_node_set_enabled(&l->shadow->node, true);
} }
// 初始化动画 // Initialize animation
if (animations && layer_animations && !l->noanim) { if (animations && layer_animations && !l->noanim) {
l->animation.duration = animation_duration_open; l->animation.duration = animation_duration_open;
l->animation.action = OPEN; l->animation.action = OPEN;
layer_set_pending_state(l); layer_set_pending_state(l);
} }
// 刷新布局，让窗口能感应到exclude_zone变化以及设置独占表面 // Refresh layout so windows can sense exclude_zone changes and set exclusive surface
arrangelayers(l->mon); arrangelayers(l->mon);
// 按需交互layer需要像正常窗口一样抢占非独占layer的焦点 // On-demand interactive layer needs to preempt non-exclusive layer focus like normal window
if (!exclusive_focus && if (!exclusive_focus &&
l->layer_surface->current.keyboard_interactive == l->layer_surface->current.keyboard_interactive ==
ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND) { ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND) {
@ -2411,8 +2411,8 @@ void commitlayersurfacenotify(struct wl_listener *listener, void *data) {
return; return;
} }
// 检查surface是否有buffer // Check if surface has buffer
// 空buffer，只是隐藏，不改变mapped状态 // Empty buffer, just hide, do not change mapped state
if (l->mapped && !layer_surface->surface->buffer) { if (l->mapped && !layer_surface->surface->buffer) {
wlr_scene_node_set_enabled(&l->scene->node, false); wlr_scene_node_set_enabled(&l->scene->node, false);
return; return;
@ -2438,7 +2438,7 @@ void commitlayersurfacenotify(struct wl_listener *listener, void *data) {
} }
if (blur && blur_layer) { if (blur && blur_layer) {
// 设置非背景layer模糊 // Set non-background layer blur
if (!l->noblur && if (!l->noblur &&
layer_surface->current.layer != ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM && layer_surface->current.layer != ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM &&
@ -2834,10 +2834,10 @@ void createmon(struct wl_listener *listener, void *data) {
r = &config.monitor_rules[ji]; r = &config.monitor_rules[ji];
// 检查是否匹配的变量 // Check if variable matches
match_rule = true; match_rule = true;
// 检查四个标识字段的匹配 // Check matching of four identifier fields
if (r->name != NULL) { if (r->name != NULL) {
if (!regex_match(r->name, m->wlr_output->name)) { if (!regex_match(r->name, m->wlr_output->name)) {
match_rule = false; match_rule = false;
@ -3007,30 +3007,30 @@ void destroyinputdevice(struct wl_listener *listener, void *data) {
InputDevice *input_dev = InputDevice *input_dev =
wl_container_of(listener, input_dev, destroy_listener); wl_container_of(listener, input_dev, destroy_listener);
// 清理设备特定数据 // Clean up device-specific data
if (input_dev->device_data) { if (input_dev->device_data) {
// 根据设备类型进行特定清理 // Perform specific cleanup based on device type
switch (input_dev->wlr_device->type) { switch (input_dev->wlr_device->type) {
case WLR_INPUT_DEVICE_SWITCH: { case WLR_INPUT_DEVICE_SWITCH: {
Switch *sw = (Switch *)input_dev->device_data; Switch *sw = (Switch *)input_dev->device_data;
// 移除 toggle 监听器 // Remove toggle listener
wl_list_remove(&sw->toggle.link); wl_list_remove(&sw->toggle.link);
// 释放 Switch 内存 // Release Switch memory
free(sw); free(sw);
break; break;
} }
// 可以添加其他设备类型的清理代码 // Can add cleanup code for other device types
default: default:
break; break;
} }
input_dev->device_data = NULL; input_dev->device_data = NULL;
} }
// 从设备列表中移除 // Remove from device list
wl_list_remove(&input_dev->link); wl_list_remove(&input_dev->link);
// 移除 destroy 监听器 // Remove destroy listener
wl_list_remove(&input_dev->destroy_listener.link); wl_list_remove(&input_dev->destroy_listener.link);
// 释放内存 // Release memory
free(input_dev); free(input_dev);
} }
@ -3105,10 +3105,10 @@ void createpointer(struct wlr_pointer *pointer) {
} }
void switch_toggle(struct wl_listener *listener, void *data) { void switch_toggle(struct wl_listener *listener, void *data) {
// 获取包含监听器的结构体 // Get structure containing listener
Switch *sw = wl_container_of(listener, sw, toggle); Switch *sw = wl_container_of(listener, sw, toggle);
// 处理切换事件 // Handle switch event
struct wlr_switch_toggle_event *event = data; struct wlr_switch_toggle_event *event = data;
SwitchBinding *s; SwitchBinding *s;
int32_t ji; int32_t ji;
@ -3134,25 +3134,25 @@ void createswitch(struct wlr_switch *switch_device) {
InputDevice *input_dev = calloc(1, sizeof(InputDevice)); InputDevice *input_dev = calloc(1, sizeof(InputDevice));
input_dev->wlr_device = &switch_device->base; input_dev->wlr_device = &switch_device->base;
input_dev->libinput_device = device; input_dev->libinput_device = device;
input_dev->device_data = NULL; // 初始化为 NULL input_dev->device_data = NULL; // Initialize to NULL
input_dev->destroy_listener.notify = destroyinputdevice; input_dev->destroy_listener.notify = destroyinputdevice;
wl_signal_add(&switch_device->base.events.destroy, wl_signal_add(&switch_device->base.events.destroy,
&input_dev->destroy_listener); &input_dev->destroy_listener);
// 创建 Switch 特定数据 // Create Switch-specific data
Switch *sw = calloc(1, sizeof(Switch)); Switch *sw = calloc(1, sizeof(Switch));
sw->wlr_switch = switch_device; sw->wlr_switch = switch_device;
sw->toggle.notify = switch_toggle; sw->toggle.notify = switch_toggle;
sw->input_dev = input_dev; sw->input_dev = input_dev;
// 将 Switch 指针保存到 input_device 中 // Save Switch pointer to input_device
input_dev->device_data = sw; input_dev->device_data = sw;
// 添加 toggle 监听器 // Add toggle listener
wl_signal_add(&switch_device->events.toggle, &sw->toggle); wl_signal_add(&switch_device->events.toggle, &sw->toggle);
// 添加到全局列表 // Add to global list
wl_list_insert(&inputdevices, &input_dev->link); wl_list_insert(&inputdevices, &input_dev->link);
} }
} }
@ -3364,7 +3364,7 @@ void focusclient(Client *c, int32_t lift) {
/* Raise client in stacking order if requested */ /* Raise client in stacking order if requested */
if (c && lift) if (c && lift)
wlr_scene_node_raise_to_top(&c->scene->node); // 将视图提升到顶层 wlr_scene_node_raise_to_top(&c->scene->node); // Raise view to top
if (c && client_surface(c) == old_keyboard_focus_surface && selmon && if (c && client_surface(c) == old_keyboard_focus_surface && selmon &&
selmon->sel) selmon->sel)
@ -4020,7 +4020,7 @@ mapnotify(struct wl_listener *listener, void *data) {
if (new_is_master && selmon && !is_scroller_layout(selmon)) if (new_is_master && selmon && !is_scroller_layout(selmon))
// tile at the top // tile at the top
wl_list_insert(&clients, &c->link); // 新窗口是master,头部入栈 wl_list_insert(&clients, &c->link); // New window is master, insert at head
else if (selmon && is_scroller_layout(selmon) && else if (selmon && is_scroller_layout(selmon) &&
selmon->visible_scroll_tiling_clients > 0) { selmon->visible_scroll_tiling_clients > 0) {
@ -4037,10 +4037,10 @@ mapnotify(struct wl_listener *listener, void *data) {
c->link.next = at_client->link.next; c->link.next = at_client->link.next;
at_client->link.next = &c->link; at_client->link.next = &c->link;
} else { } else {
wl_list_insert(clients.prev, &c->link); // 尾部入栈 wl_list_insert(clients.prev, &c->link); // Insert at tail
} }
} else } else
wl_list_insert(clients.prev, &c->link); // 尾部入栈 wl_list_insert(clients.prev, &c->link); // Insert at tail
wl_list_insert(&fstack, &c->flink); wl_list_insert(&fstack, &c->flink);
applyrules(c); applyrules(c);
@ -4118,8 +4118,8 @@ void set_minimized(Client *c) {
arrange(c->mon, false, false); arrange(c->mon, false, false);
wlr_foreign_toplevel_handle_v1_set_activated(c->foreign_toplevel, false); wlr_foreign_toplevel_handle_v1_set_activated(c->foreign_toplevel, false);
wlr_foreign_toplevel_handle_v1_set_minimized(c->foreign_toplevel, true); wlr_foreign_toplevel_handle_v1_set_minimized(c->foreign_toplevel, true);
wl_list_remove(&c->link); // 从原来位置移除 wl_list_remove(&c->link); // Remove from original position
wl_list_insert(clients.prev, &c->link); // 插入尾部 wl_list_insert(clients.prev, &c->link); // Insert at tail
} }
void minimizenotify(struct wl_listener *listener, void *data) { void minimizenotify(struct wl_listener *listener, void *data) {
@ -4423,7 +4423,7 @@ void pointerfocus(Client *c, struct wlr_surface *surface, double sx, double sy,
wlr_seat_pointer_notify_motion(seat, time, sx, sy); wlr_seat_pointer_notify_motion(seat, time, sx, sy);
} }
// 修改printstatus函数，接受掩码参数 // Modify printstatus function to accept mask parameter
void printstatus(void) { wl_signal_emit(&mango_print_status, NULL); } void printstatus(void) { wl_signal_emit(&mango_print_status, NULL); }
void powermgrsetmode(struct wl_listener *listener, void *data) { void powermgrsetmode(struct wl_listener *listener, void *data) {
@ -4502,7 +4502,7 @@ void rendermon(struct wl_listener *listener, void *data) {
frame_allow_tearing = check_tearing_frame_allow(m); frame_allow_tearing = check_tearing_frame_allow(m);
// 绘制层和淡出效果 // Draw layers and fade effects
for (i = 0; i < LENGTH(m->layers); i++) { for (i = 0; i < LENGTH(m->layers); i++) {
layer_list = &m->layers[i]; layer_list = &m->layers[i];
wl_list_for_each_safe(l, tmpl, layer_list, link) { wl_list_for_each_safe(l, tmpl, layer_list, link) {
@ -4518,7 +4518,7 @@ void rendermon(struct wl_listener *listener, void *data) {
need_more_frames = layer_draw_fadeout_frame(l) || need_more_frames; need_more_frames = layer_draw_fadeout_frame(l) || need_more_frames;
} }
// 绘制客户端 // Draw clients
wl_list_for_each(c, &clients, link) { wl_list_for_each(c, &clients, link) {
need_more_frames = client_draw_frame(c) || need_more_frames; need_more_frames = client_draw_frame(c) || need_more_frames;
if (!animations && !(allow_tearing && frame_allow_tearing) && if (!animations && !(allow_tearing && frame_allow_tearing) &&
@ -4533,7 +4533,7 @@ void rendermon(struct wl_listener *listener, void *data) {
monitor_stop_skip_timer(m); monitor_stop_skip_timer(m);
} }
// 只有在需要帧时才构建和提交状态 // Only build and commit state when frame is needed
if (allow_tearing && frame_allow_tearing) { if (allow_tearing && frame_allow_tearing) {
apply_tear_state(m); apply_tear_state(m);
} else { } else {
@ -4541,7 +4541,7 @@ void rendermon(struct wl_listener *listener, void *data) {
} }
skip: skip:
// 发送帧完成通知 // Send frame done notification
clock_gettime(CLOCK_MONOTONIC, &now); clock_gettime(CLOCK_MONOTONIC, &now);
if (allow_tearing && frame_allow_tearing) { if (allow_tearing && frame_allow_tearing) {
wlr_scene_output_send_frame_done(m->scene_output, &now); wlr_scene_output_send_frame_done(m->scene_output, &now);
@ -4550,7 +4550,7 @@ skip:
wlr_output_state_finish(&pending); wlr_output_state_finish(&pending);
} }
// 如果需要更多帧，确保安排下一帧 // If more frames needed, ensure next frame is scheduled
if (need_more_frames && allow_frame_scheduling) { if (need_more_frames && allow_frame_scheduling) {
request_fresh_all_monitors(); request_fresh_all_monitors();
} }
@ -4561,11 +4561,11 @@ void requestdecorationmode(struct wl_listener *listener, void *data) {
struct wlr_xdg_toplevel_decoration_v1 *deco = data; struct wlr_xdg_toplevel_decoration_v1 *deco = data;
if (c->surface.xdg->initialized) { if (c->surface.xdg->initialized) {
// 获取客户端请求的模式 // Get mode requested by client
enum wlr_xdg_toplevel_decoration_v1_mode requested_mode = enum wlr_xdg_toplevel_decoration_v1_mode requested_mode =
deco->requested_mode; deco->requested_mode;
// 如果客户端没有指定，使用默认模式 // If client did not specify, use default mode
if (!c->allow_csd) { if (!c->allow_csd) {
requested_mode = WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE; requested_mode = WLR_XDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE;
} }
@ -4626,7 +4626,7 @@ void exchange_two_client(Client *c1, Client *c2) {
Client *c1head = get_scroll_stack_head(c1); Client *c1head = get_scroll_stack_head(c1);
Client *c2head = get_scroll_stack_head(c2); Client *c2head = get_scroll_stack_head(c2);
// 交换布局参数 // Swap layout parameters
if (c1head == c2head) { if (c1head == c2head) {
scroller_proportion = c1->scroller_proportion; scroller_proportion = c1->scroller_proportion;
stack_proportion = c1->stack_proportion; stack_proportion = c1->stack_proportion;
@ -4649,13 +4649,13 @@ void exchange_two_client(Client *c1, Client *c2) {
c2->master_mfact_per = master_mfact_per; c2->master_mfact_per = master_mfact_per;
c2->stack_inner_per = stack_inner_per; c2->stack_inner_per = stack_inner_per;
// 交换栈链表连接 // Swap stack list connections
Client *tmp1_next_in_stack = c1->next_in_stack; Client *tmp1_next_in_stack = c1->next_in_stack;
Client *tmp1_prev_in_stack = c1->prev_in_stack; Client *tmp1_prev_in_stack = c1->prev_in_stack;
Client *tmp2_next_in_stack = c2->next_in_stack; Client *tmp2_next_in_stack = c2->next_in_stack;
Client *tmp2_prev_in_stack = c2->prev_in_stack; Client *tmp2_prev_in_stack = c2->prev_in_stack;
// 处理相邻节点的情况 // Handle adjacent node case
if (c1->next_in_stack == c2) { if (c1->next_in_stack == c2) {
c1->next_in_stack = tmp2_next_in_stack; c1->next_in_stack = tmp2_next_in_stack;
c2->next_in_stack = c1; c2->next_in_stack = c1;
@ -4683,13 +4683,13 @@ void exchange_two_client(Client *c1, Client *c2) {
return; return;
} }
// 交换全局链表连接 // Swap global list connections
struct wl_list *tmp1_prev = c1->link.prev; struct wl_list *tmp1_prev = c1->link.prev;
struct wl_list *tmp2_prev = c2->link.prev; struct wl_list *tmp2_prev = c2->link.prev;
struct wl_list *tmp1_next = c1->link.next; struct wl_list *tmp1_next = c1->link.next;
struct wl_list *tmp2_next = c2->link.next; struct wl_list *tmp2_next = c2->link.next;
// 处理相邻节点的情况 // Handle adjacent node case
if (c1->link.next == &c2->link) { if (c1->link.next == &c2->link) {
c1->link.next = c2->link.next; c1->link.next = c2->link.next;
c1->link.prev = &c2->link; c1->link.prev = &c2->link;
@ -4704,7 +4704,7 @@ void exchange_two_client(Client *c1, Client *c2) {
c1->link.prev = tmp2_prev; c1->link.prev = tmp2_prev;
tmp2_prev->next = &c1->link; tmp2_prev->next = &c1->link;
tmp1_next->prev = &c2->link; tmp1_next->prev = &c2->link;
} else { // 不为相邻节点 } else { // Not adjacent nodes
c2->link.next = tmp1_next; c2->link.next = tmp1_next;
c2->link.prev = tmp1_prev; c2->link.prev = tmp1_prev;
c1->link.next = tmp2_next; c1->link.next = tmp2_next;
@ -4716,7 +4716,7 @@ void exchange_two_client(Client *c1, Client *c2) {
tmp2_next->prev = &c1->link; tmp2_next->prev = &c1->link;
} }
// 处理跨监视器交换 // Handle cross-monitor swap
if (exchange_cross_monitor) { if (exchange_cross_monitor) {
tmp_mon = c2->mon; tmp_mon = c2->mon;
tmp_tags = c2->tags; tmp_tags = c2->tags;
@ -4842,14 +4842,14 @@ setfloating(Client *c, int32_t floating) {
if (floating == 1 && c != grabc) { if (floating == 1 && c != grabc) {
if (c->isfullscreen || c->ismaximizescreen) { if (c->isfullscreen || c->ismaximizescreen) {
c->isfullscreen = 0; // 清除窗口全屏标志 c->isfullscreen = 0; // Clear window fullscreen flag
c->ismaximizescreen = 0; c->ismaximizescreen = 0;
c->bw = c->isnoborder ? 0 : borderpx; c->bw = c->isnoborder ? 0 : borderpx;
} }
exit_scroller_stack(c); exit_scroller_stack(c);
// 重新计算居中的坐标 // Recalculate centered coordinates
if (!client_is_x11(c) && !c->iscustompos) if (!client_is_x11(c) && !c->iscustompos)
target_box = target_box =
setclient_coordinate_center(c, c->mon, target_box, 0, 0); setclient_coordinate_center(c, c->mon, target_box, 0, 0);
@ -4883,7 +4883,7 @@ setfloating(Client *c, int32_t floating) {
c->is_scratchpad_show = 0; c->is_scratchpad_show = 0;
c->is_in_scratchpad = 0; c->is_in_scratchpad = 0;
c->isnamedscratchpad = 0; c->isnamedscratchpad = 0;
// 让当前tag中的全屏窗口退出全屏参与平铺 // Make fullscreen windows in current tag exit fullscreen to participate in tiling
wl_list_for_each(fc, &clients, wl_list_for_each(fc, &clients,
link) if (fc && fc != c && VISIBLEON(fc, c->mon) && link) if (fc && fc != c && VISIBLEON(fc, c->mon) &&
c->tags & fc->tags && ISFULLSCREEN(fc)) { c->tags & fc->tags && ISFULLSCREEN(fc)) {
@ -4973,7 +4973,7 @@ void setmaximizescreen(Client *c, int32_t maximizescreen) {
maximizescreen_box.y = c->mon->w.y + gappov; maximizescreen_box.y = c->mon->w.y + gappov;
maximizescreen_box.width = c->mon->w.width - 2 * gappoh; maximizescreen_box.width = c->mon->w.width - 2 * gappoh;
maximizescreen_box.height = c->mon->w.height - 2 * gappov; maximizescreen_box.height = c->mon->w.height - 2 * gappov;
wlr_scene_node_raise_to_top(&c->scene->node); // 将视图提升到顶层 wlr_scene_node_raise_to_top(&c->scene->node); // Raise view to top
if (!is_scroller_layout(c->mon) || c->isfloating) if (!is_scroller_layout(c->mon) || c->isfloating)
resize(c, maximizescreen_box, 0); resize(c, maximizescreen_box, 0);
c->ismaximizescreen = 1; c->ismaximizescreen = 1;
@ -5010,7 +5010,7 @@ void setfakefullscreen(Client *c, int32_t fakefullscreen) {
client_set_fullscreen(c, fakefullscreen); client_set_fullscreen(c, fakefullscreen);
} }
void setfullscreen(Client *c, int32_t fullscreen) // 用自定义全屏代理自带全屏 void setfullscreen(Client *c, int32_t fullscreen) // Use custom fullscreen as proxy for built-in fullscreen
{ {
if (!c || !c->mon || !client_surface(c)->mapped || c->iskilling) if (!c || !c->mon || !client_surface(c)->mapped || c->iskilling)
@ -5036,7 +5036,7 @@ void setfullscreen(Client *c, int32_t fullscreen) // 用自定义全屏代理自
c->isfakefullscreen = 0; c->isfakefullscreen = 0;
c->bw = 0; c->bw = 0;
wlr_scene_node_raise_to_top(&c->scene->node); // 将视图提升到顶层 wlr_scene_node_raise_to_top(&c->scene->node); // Raise view to top
if (!is_scroller_layout(c->mon) || c->isfloating) if (!is_scroller_layout(c->mon) || c->isfloating)
resize(c, c->mon->m, 1); resize(c, c->mon->m, 1);
c->isfullscreen = 1; c->isfullscreen = 1;
@ -5100,17 +5100,17 @@ void reset_keyboard_layout(void) {
return; return;
} }
// 现在安全地创建真正的keymap // Now safely create the real keymap
struct xkb_keymap *new_keymap = xkb_keymap_new_from_names( struct xkb_keymap *new_keymap = xkb_keymap_new_from_names(
context, &xkb_rules, XKB_KEYMAP_COMPILE_NO_FLAGS); context, &xkb_rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
if (!new_keymap) { if (!new_keymap) {
// 理论上这里不应该失败，因为前面已经验证过了 // Theoretically should not fail here since already validated
wlr_log(WLR_ERROR, wlr_log(WLR_ERROR,
"Unexpected failure to create keymap after validation"); "Unexpected failure to create keymap after validation");
goto cleanup_context; goto cleanup_context;
} }
// 验证新keymap是否有布局 // Verify new keymap has layouts
const int32_t new_num_layouts = xkb_keymap_num_layouts(new_keymap); const int32_t new_num_layouts = xkb_keymap_num_layouts(new_keymap);
if (new_num_layouts < 1) { if (new_num_layouts < 1) {
wlr_log(WLR_ERROR, "New keymap has no layouts"); wlr_log(WLR_ERROR, "New keymap has no layouts");
@ -5118,7 +5118,7 @@ void reset_keyboard_layout(void) {
goto cleanup_context; goto cleanup_context;
} }
// 确保当前布局索引在新keymap中有效 // Ensure current layout index is valid in new keymap
if (current >= new_num_layouts) { if (current >= new_num_layouts) {
wlr_log(WLR_INFO, wlr_log(WLR_INFO,
"Current layout index %u out of range for new keymap, " "Current layout index %u out of range for new keymap, "
@ -5153,7 +5153,7 @@ void reset_keyboard_layout(void) {
wlr_keyboard_notify_modifiers(tkb, depressed, latched, locked, 0); wlr_keyboard_notify_modifiers(tkb, depressed, latched, locked, 0);
tkb->modifiers.group = 0; tkb->modifiers.group = 0;
// 7. 更新 seat // 7. Update seat
wlr_seat_set_keyboard(seat, tkb); wlr_seat_set_keyboard(seat, tkb);
wlr_seat_keyboard_notify_modifiers(seat, &tkb->modifiers); wlr_seat_keyboard_notify_modifiers(seat, &tkb->modifiers);
} }
@ -5265,7 +5265,7 @@ void create_output(struct wlr_backend *backend, void *data) {
#endif #endif
} }
// 修改信号处理函数，接收掩码参数 // Modify signal handler function to accept mask parameter
void handle_print_status(struct wl_listener *listener, void *data) { void handle_print_status(struct wl_listener *listener, void *data) {
Monitor *m = NULL; Monitor *m = NULL;
@ -5374,7 +5374,7 @@ void setup(void) {
wlr_alpha_modifier_v1_create(dpy); wlr_alpha_modifier_v1_create(dpy);
wlr_ext_data_control_manager_v1_create(dpy, 1); wlr_ext_data_control_manager_v1_create(dpy, 1);
// 在 setup 函数中 // In setup function
wl_signal_init(&mango_print_status); wl_signal_init(&mango_print_status);
wl_signal_add(&mango_print_status, &print_status_listener); wl_signal_add(&mango_print_status, &print_status_listener);
@ -5482,7 +5482,7 @@ void setup(void) {
wl_signal_add(&cursor->events.axis, &cursor_axis); wl_signal_add(&cursor->events.axis, &cursor_axis);
wl_signal_add(&cursor->events.frame, &cursor_frame); wl_signal_add(&cursor->events.frame, &cursor_frame);
// 这两句代码会造成obs窗口里的鼠标光标消失,不知道注释有什么影响 // These two lines will cause mouse cursor to disappear in obs window, unknown impact of commenting
cursor_shape_mgr = wlr_cursor_shape_manager_v1_create(dpy, 1); cursor_shape_mgr = wlr_cursor_shape_manager_v1_create(dpy, 1);
wl_signal_add(&cursor_shape_mgr->events.request_set_shape, wl_signal_add(&cursor_shape_mgr->events.request_set_shape,
&request_set_cursor_shape); &request_set_cursor_shape);
@ -5555,14 +5555,14 @@ void setup(void) {
wl_global_create(dpy, &zdwl_ipc_manager_v2_interface, 2, NULL, wl_global_create(dpy, &zdwl_ipc_manager_v2_interface, 2, NULL,
dwl_ipc_manager_bind); dwl_ipc_manager_bind);
// 创建顶层管理句柄 // Create toplevel management handle
foreign_toplevel_manager = wlr_foreign_toplevel_manager_v1_create(dpy); foreign_toplevel_manager = wlr_foreign_toplevel_manager_v1_create(dpy);
struct wlr_xdg_foreign_registry *foreign_registry = struct wlr_xdg_foreign_registry *foreign_registry =
wlr_xdg_foreign_registry_create(dpy); wlr_xdg_foreign_registry_create(dpy);
wlr_xdg_foreign_v1_create(dpy, foreign_registry); wlr_xdg_foreign_v1_create(dpy, foreign_registry);
wlr_xdg_foreign_v2_create(dpy, foreign_registry); wlr_xdg_foreign_v2_create(dpy, foreign_registry);
// ext-workspace协议 // ext-workspace protocol
workspaces_init(); workspaces_init();
#ifdef XWAYLAND #ifdef XWAYLAND
/* /*
@ -5619,7 +5619,7 @@ void tag_client(const Arg *arg, Client *target_client) {
void overview(Monitor *m) { grid(m); } void overview(Monitor *m) { grid(m); }
// 目标窗口有其他窗口和它同个tag就返回0 // Return 0 if target window has other windows with same tag
uint32_t want_restore_fullscreen(Client *target_client) { uint32_t want_restore_fullscreen(Client *target_client) {
Client *c = NULL; Client *c = NULL;
wl_list_for_each(c, &clients, link) { wl_list_for_each(c, &clients, link) {
@ -5636,7 +5636,7 @@ uint32_t want_restore_fullscreen(Client *target_client) {
return 1; return 1;
} }
// 普通视图切换到overview时保存窗口的旧状态 // Save window old state when switching from normal view to overview
void overview_backup(Client *c) { void overview_backup(Client *c) {
c->overview_isfloatingbak = c->isfloating; c->overview_isfloatingbak = c->isfloating;
c->overview_isfullscreenbak = c->isfullscreen; c->overview_isfullscreenbak = c->isfullscreen;
@ -5651,7 +5651,7 @@ void overview_backup(Client *c) {
c->isfloating = 0; c->isfloating = 0;
} }
if (c->isfullscreen || c->ismaximizescreen) { if (c->isfullscreen || c->ismaximizescreen) {
c->isfullscreen = 0; // 清除窗口全屏标志 c->isfullscreen = 0; // Clear window fullscreen flag
c->ismaximizescreen = 0; c->ismaximizescreen = 0;
} }
c->bw = c->isnoborder ? 0 : borderpx; c->bw = c->isnoborder ? 0 : borderpx;
@ -5660,7 +5660,7 @@ void overview_backup(Client *c) {
WLR_EDGE_RIGHT); WLR_EDGE_RIGHT);
} }
// overview切回到普通视图还原窗口的状态 // Restore window state when switching back from overview to normal view
void overview_restore(Client *c, const Arg *arg) { void overview_restore(Client *c, const Arg *arg) {
c->isfloating = c->overview_isfloatingbak; c->isfloating = c->overview_isfloatingbak;
c->isfullscreen = c->overview_isfullscreenbak; c->isfullscreen = c->overview_isfullscreenbak;
@ -5674,7 +5674,7 @@ void overview_restore(Client *c, const Arg *arg) {
c->is_restoring_from_ov = (arg->ui & c->tags & TAGMASK) == 0 ? true : false; c->is_restoring_from_ov = (arg->ui & c->tags & TAGMASK) == 0 ? true : false;
if (c->isfloating) { if (c->isfloating) {
// XRaiseWindow(dpy, c->win); // 提升悬浮窗口到顶层 // XRaiseWindow(dpy, c->win); // Raise floating window to top
resize(c, c->overview_backup_geom, 0); resize(c, c->overview_backup_geom, 0);
} else if (c->isfullscreen || c->ismaximizescreen) { } else if (c->isfullscreen || c->ismaximizescreen) {
if (want_restore_fullscreen(c) && c->ismaximizescreen) { if (want_restore_fullscreen(c) && c->ismaximizescreen) {
@ -5694,7 +5694,7 @@ void overview_restore(Client *c, const Arg *arg) {
} }
if (c->bw == 0 && if (c->bw == 0 &&
!c->isfullscreen) { // 如果是在ov模式中创建的窗口,没有bw记录 !c->isfullscreen) { // If window was created in ov mode, no bw record
c->bw = c->isnoborder ? 0 : borderpx; c->bw = c->isnoborder ? 0 : borderpx;
} }
@ -6191,7 +6191,7 @@ void fix_xwayland_unmanaged_coordinate(Client *c) {
if (!selmon) if (!selmon)
return; return;
// 1. 如果窗口已经在当前活动显示器内，直接返回 // 1. If window is already in current active monitor, return directly
if (c->geom.x >= selmon->m.x && c->geom.x < selmon->m.x + selmon->m.width && if (c->geom.x >= selmon->m.x && c->geom.x < selmon->m.x + selmon->m.width &&
c->geom.y >= selmon->m.y && c->geom.y < selmon->m.y + selmon->m.height) c->geom.y >= selmon->m.y && c->geom.y < selmon->m.y + selmon->m.height)
return; return;