mirrors/maomaowm
1
0
Fork 0
mirror of https://github.com/DreamMaoMao/maomaowm.git synced 2026-05-28 21:37:28 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

opt: avoid manula caculate in normal dwindle mode

Browse source
This commit is contained in:
DreamMaoMao 2026-05-15 07:59:35 +08:00
parent 42a46259fb
commit 89b24d514c
1 changed files with 80 additions and 76 deletions
Download patch file Download diff file Expand all files Collapse all files

156
src/layout/dwindle.h
View file

@ -81,35 +81,37 @@ static void dwindle_insert(DwindleNode **root, Client *new_c, Client *focused,
target = dwindle_first_leaf(*root); target = dwindle_first_leaf(*root);
// ================= 保持其他窗口比例缩减逻辑 ================= // ================= 保持其他窗口比例缩减逻辑 =================
DwindleNode *path[512]; if (config.dwindle_manual_split) {
float p[512]; DwindleNode *path[512];
int path_len = get_block_path_and_ratios(target, split_h, path, p); float p[512];
int path_len = get_block_path_and_ratios(target, split_h, path, p);
int n_old = 1; int n_old = 1;
if (path_len > 1) { if (path_len > 1) {
n_old = count_block_items(path[path_len - 1], split_h); n_old = count_block_items(path[path_len - 1], split_h);
} }
float N = (float)(n_old + 1); float N = (float)(n_old + 1);
for (int i = path_len - 1; i > 0; i--) { for (int i = path_len - 1; i > 0; i--) {
DwindleNode *S = path[i]; DwindleNode *S = path[i];
DwindleNode *child = path[i - 1]; DwindleNode *child = path[i - 1];
float p_S = p[i]; float p_S = p[i];
float p_first = p_S * S->ratio; float p_first = p_S * S->ratio;
if (S->first == child) { if (S->first == child) {
float p_first_new = p_first * (N - 1.0f) / N + 1.0f / N; float p_first_new = p_first * (N - 1.0f) / N + 1.0f / N;
float p_S_new = p_S * (N - 1.0f) / N + 1.0f / N; float p_S_new = p_S * (N - 1.0f) / N + 1.0f / N;
S->ratio = p_first_new / p_S_new; S->ratio = p_first_new / p_S_new;
} else { } else {
float p_first_new = p_first * (N - 1.0f) / N; float p_first_new = p_first * (N - 1.0f) / N;
float p_S_new = p_S * (N - 1.0f) / N + 1.0f / N; float p_S_new = p_S * (N - 1.0f) / N + 1.0f / N;
S->ratio = p_first_new / p_S_new; S->ratio = p_first_new / p_S_new;
}
if (S->ratio < 0.001f)
S->ratio = 0.001f;
if (S->ratio > 0.999f)
S->ratio = 0.999f;
} }
if (S->ratio < 0.001f)
S->ratio = 0.001f;
if (S->ratio > 0.999f)
S->ratio = 0.999f;
} }
// ============================================================ // ============================================================
@ -166,55 +168,57 @@ static void dwindle_remove(DwindleNode **root, Client *c) {
// 开始删除空间的比例回退逻辑 // 开始删除空间的比例回退逻辑
// 查找连续的同方向块路径 // 查找连续的同方向块路径
bool split_h = parent->split_h; if (config.dwindle_manual_split) {
DwindleNode *path[128]; bool split_h = parent->split_h;
int path_len = 0; DwindleNode *path[512];
path[path_len++] = parent; int path_len = 0;
DwindleNode *curr = parent->parent; path[path_len++] = parent;
while (curr && curr->split_h == split_h) { DwindleNode *curr = parent->parent;
path[path_len++] = curr; while (curr && curr->split_h == split_h) {
curr = curr->parent; path[path_len++] = curr;
} curr = curr->parent;
// 计算各祖先的旧绝对占比
float p[128];
p[path_len - 1] = 1.0f;
for (int i = path_len - 1; i > 0; i--) {
DwindleNode *S = path[i];
DwindleNode *child = path[i - 1];
if (S->first == child)
p[i - 1] = p[i] * S->ratio;
else
p[i - 1] = p[i] * (1.0f - S->ratio);
}
// 计算即将被删除的叶子节点，在该方向块中所占的绝对面积比例 (P_del)
float p_del =
p[0] * (parent->first == leaf ? parent->ratio : (1.0f - parent->ratio));
if (p_del > 0.999f)
p_del = 0.999f; // 兜底
// 重算祖先比例：将 P_del 空出来的空间，按原定比例无缝分配给其他窗口
for (int i = path_len - 1; i > 0; i--) {
DwindleNode *S = path[i];
DwindleNode *child = path[i - 1];
float p_S = p[i];
float p_first = p_S * S->ratio;
float denom = p_S - p_del;
if (denom < 0.0001f)
denom = 0.0001f;
if (S->first == child) {
S->ratio = (p_first - p_del) / denom;
} else {
S->ratio = p_first / denom;
} }
if (S->ratio < 0.001f) // 计算各祖先的旧绝对占比
S->ratio = 0.001f; float p[512];
if (S->ratio > 0.999f) p[path_len - 1] = 1.0f;
S->ratio = 0.999f; for (int i = path_len - 1; i > 0; i--) {
DwindleNode *S = path[i];
DwindleNode *child = path[i - 1];
if (S->first == child)
p[i - 1] = p[i] * S->ratio;
else
p[i - 1] = p[i] * (1.0f - S->ratio);
}
// 计算即将被删除的叶子节点，在该方向块中所占的绝对面积比例 (P_del)
float p_del = p[0] * (parent->first == leaf ? parent->ratio
: (1.0f - parent->ratio));
if (p_del > 0.999f)
p_del = 0.999f; // 兜底
// 重算祖先比例：将 P_del 空出来的空间，按原定比例无缝分配给其他窗口
for (int i = path_len - 1; i > 0; i--) {
DwindleNode *S = path[i];
DwindleNode *child = path[i - 1];
float p_S = p[i];
float p_first = p_S * S->ratio;
float denom = p_S - p_del;
if (denom < 0.0001f)
denom = 0.0001f;
if (S->first == child) {
S->ratio = (p_first - p_del) / denom;
} else {
S->ratio = p_first / denom;
}
if (S->ratio < 0.001f)
S->ratio = 0.001f;
if (S->ratio > 0.999f)
S->ratio = 0.999f;
}
} }
// 比例重算结束 // 比例重算结束
@ -490,8 +494,8 @@ static void dwindle_insert_with_config(DwindleNode **root, Client *new_c,
as_first = false; as_first = false;
// ================= 计算新节点的 1/N 比例 ================= // ================= 计算新节点的 1/N 比例 =================
DwindleNode *path[128]; DwindleNode *path[512];
float p[128]; float p[512];
int path_len = get_block_path_and_ratios(target, split_h, path, p); int path_len = get_block_path_and_ratios(target, split_h, path, p);
int n_old = 1; int n_old = 1;