mirror of
https://github.com/DreamMaoMao/maomaowm.git
synced 2026-05-12 23:51:28 -04:00
opt: redo scroller and dwindle layout
This commit is contained in:
DreamMaoMao
parent
bccdb5d4c5
commit
d347649f33
8 changed files with 1352 additions and 1081 deletions
|
|
@ -672,7 +672,6 @@ uint32_t parse_mod(const char *mod_str) {
|
|||
}
|
||||
}
|
||||
} else {
|
||||
// 完整的 modifier 检查（保留原始所有检查项）
|
||||
if (!strcmp(token, "super") || !strcmp(token, "super_l") ||
|
||||
!strcmp(token, "super_r")) {
|
||||
mod |= WLR_MODIFIER_LOGO;
|
||||
|
|
|
|||
|
|
@ -630,15 +630,106 @@ int32_t set_proportion(const Arg *arg) {
|
|||
return 0;
|
||||
|
||||
Client *tc = selmon->sel;
|
||||
if (!tc)
|
||||
return 0;
|
||||
|
||||
if (tc) {
|
||||
tc = get_scroll_stack_head(tc);
|
||||
uint32_t max_client_width =
|
||||
selmon->w.width - 2 * config.scroller_structs - config.gappih;
|
||||
tc->scroller_proportion = arg->f;
|
||||
tc->geom.width = max_client_width * arg->f;
|
||||
arrange(selmon, false, false);
|
||||
/* 获取堆叠头部客户端 */
|
||||
tc = scroll_get_stack_head_client(tc);
|
||||
if (!tc)
|
||||
return 0;
|
||||
|
||||
Monitor *m = tc->mon;
|
||||
uint32_t tag = m->pertag->curtag;
|
||||
struct TagScrollerState *st = m->pertag->scroller_state[tag];
|
||||
struct ScrollerStackNode *node = NULL;
|
||||
|
||||
if (st)
|
||||
node = find_scroller_node(st, tc);
|
||||
|
||||
/* 同时更新节点和客户端字段 */
|
||||
if (node)
|
||||
node->scroller_proportion = arg->f;
|
||||
tc->scroller_proportion = arg->f;
|
||||
|
||||
/* 可选的即时几何更新，arrange 时会重新计算 */
|
||||
uint32_t max_client_width =
|
||||
m->w.width - 2 * config.scroller_structs - config.gappih;
|
||||
tc->geom.width = max_client_width * arg->f;
|
||||
|
||||
arrange(m, false, false);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int32_t switch_proportion_preset(const Arg *arg) {
|
||||
float target_proportion = 0;
|
||||
if (!selmon)
|
||||
return 0;
|
||||
|
||||
if (config.scroller_proportion_preset_count == 0)
|
||||
return 0;
|
||||
|
||||
if (selmon->isoverview || !is_scroller_layout(selmon))
|
||||
return 0;
|
||||
|
||||
if (selmon->visible_tiling_clients == 1 &&
|
||||
!config.scroller_ignore_proportion_single)
|
||||
return 0;
|
||||
|
||||
Client *tc = selmon->sel;
|
||||
if (!tc)
|
||||
return 0;
|
||||
|
||||
tc = scroll_get_stack_head_client(tc);
|
||||
if (!tc)
|
||||
return 0;
|
||||
|
||||
Monitor *m = tc->mon;
|
||||
uint32_t tag = m->pertag->curtag;
|
||||
struct TagScrollerState *st = m->pertag->scroller_state[tag];
|
||||
struct ScrollerStackNode *node = NULL;
|
||||
|
||||
if (st)
|
||||
node = find_scroller_node(st, tc);
|
||||
|
||||
/* 优先从节点读取当前比例，以确保切换基于正确的值 */
|
||||
float current_proportion =
|
||||
node ? node->scroller_proportion : tc->scroller_proportion;
|
||||
|
||||
/* 查找预设目标 */
|
||||
for (int32_t i = 0; i < config.scroller_proportion_preset_count; i++) {
|
||||
if (config.scroller_proportion_preset[i] == current_proportion) {
|
||||
if (arg->i == NEXT) {
|
||||
if (i == config.scroller_proportion_preset_count - 1)
|
||||
target_proportion = config.scroller_proportion_preset[0];
|
||||
else
|
||||
target_proportion =
|
||||
config.scroller_proportion_preset[i + 1];
|
||||
} else {
|
||||
if (i == 0)
|
||||
target_proportion =
|
||||
config.scroller_proportion_preset
|
||||
[config.scroller_proportion_preset_count - 1];
|
||||
else
|
||||
target_proportion =
|
||||
config.scroller_proportion_preset[i - 1];
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (target_proportion == 0.0f)
|
||||
target_proportion = config.scroller_proportion_preset[0];
|
||||
|
||||
/* 更新节点和客户端 */
|
||||
if (node)
|
||||
node->scroller_proportion = target_proportion;
|
||||
tc->scroller_proportion = target_proportion;
|
||||
|
||||
uint32_t max_client_width =
|
||||
m->w.width - 2 * config.scroller_structs - config.gappih;
|
||||
tc->geom.width = max_client_width * target_proportion;
|
||||
|
||||
arrange(m, false, false);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -836,7 +927,7 @@ int32_t centerwin(const Arg *arg) {
|
|||
if (!is_scroller_layout(selmon))
|
||||
return 0;
|
||||
|
||||
Client *stack_head = get_scroll_stack_head(c);
|
||||
Client *stack_head = scroll_get_stack_head_client(c);
|
||||
if (selmon->pertag->ltidxs[selmon->pertag->curtag]->id == SCROLLER) {
|
||||
stack_head->geom.x =
|
||||
selmon->w.x + (selmon->w.width - stack_head->geom.width) / 2;
|
||||
|
|
@ -1043,68 +1134,6 @@ int32_t switch_layout(const Arg *arg) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
int32_t switch_proportion_preset(const Arg *arg) {
|
||||
float target_proportion = 0;
|
||||
if (!selmon)
|
||||
return 0;
|
||||
|
||||
if (config.scroller_proportion_preset_count == 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (selmon->isoverview || !is_scroller_layout(selmon))
|
||||
return 0;
|
||||
|
||||
if (selmon->visible_tiling_clients == 1 &&
|
||||
!config.scroller_ignore_proportion_single)
|
||||
return 0;
|
||||
|
||||
Client *tc = selmon->sel;
|
||||
|
||||
if (tc) {
|
||||
tc = get_scroll_stack_head(tc);
|
||||
for (int32_t i = 0; i < config.scroller_proportion_preset_count; i++) {
|
||||
if (config.scroller_proportion_preset[i] ==
|
||||
tc->scroller_proportion) {
|
||||
|
||||
if (arg->i == NEXT) {
|
||||
if (i == config.scroller_proportion_preset_count - 1) {
|
||||
target_proportion =
|
||||
config.scroller_proportion_preset[0];
|
||||
break;
|
||||
} else {
|
||||
target_proportion =
|
||||
config.scroller_proportion_preset[i + 1];
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
if (i == 0) {
|
||||
target_proportion =
|
||||
config.scroller_proportion_preset
|
||||
[config.scroller_proportion_preset_count - 1];
|
||||
break;
|
||||
} else {
|
||||
target_proportion =
|
||||
config.scroller_proportion_preset[i - 1];
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (target_proportion == 0) {
|
||||
target_proportion = config.scroller_proportion_preset[0];
|
||||
}
|
||||
|
||||
uint32_t max_client_width =
|
||||
selmon->w.width - 2 * config.scroller_structs - config.gappih;
|
||||
tc->scroller_proportion = target_proportion;
|
||||
tc->geom.width = max_client_width * target_proportion;
|
||||
arrange(selmon, false, false);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int32_t tag(const Arg *arg) {
|
||||
if (!selmon)
|
||||
return 0;
|
||||
|
|
@ -1203,7 +1232,6 @@ int32_t tagsilent(const Arg *arg) {
|
|||
clear_fullscreen_flag(fc);
|
||||
}
|
||||
}
|
||||
exit_scroller_stack(target_client);
|
||||
focusclient(focustop(selmon), 1);
|
||||
arrange(target_client->mon, false, false);
|
||||
return 0;
|
||||
|
|
@ -1354,11 +1382,6 @@ int32_t toggleglobal(const Arg *arg) {
|
|||
selmon->sel->isnamedscratchpad = 0;
|
||||
}
|
||||
selmon->sel->isglobal ^= 1;
|
||||
if (selmon->sel->isglobal &&
|
||||
(selmon->sel->prev_in_stack || selmon->sel->next_in_stack)) {
|
||||
exit_scroller_stack(selmon->sel);
|
||||
arrange(selmon, false, false);
|
||||
}
|
||||
setborder_color(selmon->sel);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1781,76 +1804,69 @@ int32_t toggle_monitor(const Arg *arg) {
|
|||
|
||||
int32_t scroller_apply_stack(Client *c, Client *target_client,
|
||||
int32_t direction) {
|
||||
if (!c || !c->mon || c->isfloating || !is_scroller_layout(c->mon))
|
||||
return 0;
|
||||
|
||||
Client *source_stack_head = NULL;
|
||||
Client *stack_head = NULL;
|
||||
bool is_horizontal_layout =
|
||||
c->mon->pertag->ltidxs[c->mon->pertag->curtag]->id == SCROLLER ? true
|
||||
: false;
|
||||
Monitor *m = c->mon;
|
||||
uint32_t tag = m->pertag->curtag;
|
||||
struct TagScrollerState *st = ensure_scroller_state(m, tag);
|
||||
|
||||
if (target_client) {
|
||||
stack_head = get_scroll_stack_head(target_client);
|
||||
}
|
||||
/* 获取当前节点 */
|
||||
struct ScrollerStackNode *cnode = find_scroller_node(st, c);
|
||||
struct ScrollerStackNode *tnode =
|
||||
target_client ? find_scroller_node(st, target_client) : NULL;
|
||||
|
||||
source_stack_head = get_scroll_stack_head(c);
|
||||
bool is_horizontal = (m->pertag->ltidxs[tag]->id == SCROLLER);
|
||||
|
||||
if (source_stack_head == stack_head) {
|
||||
/* 若方向为 UNDIR 且有目标，直接插入到目标尾部 */
|
||||
if (direction == UNDIR && target_client && target_client->mon == c->mon) {
|
||||
scroller_insert_stack(c, target_client, false);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (c->isfullscreen) {
|
||||
setfullscreen(c, 0);
|
||||
}
|
||||
/* 处理从堆叠中移出的情况（方向 LEFT/UP 或 RIGHT/DOWN） */
|
||||
if (cnode && (cnode->prev_in_stack || cnode->next_in_stack)) {
|
||||
bool to_left_or_up = (is_horizontal && direction == LEFT) ||
|
||||
(!is_horizontal && direction == UP);
|
||||
bool to_right_or_down = (is_horizontal && direction == RIGHT) ||
|
||||
(!is_horizontal && direction == DOWN);
|
||||
|
||||
if (c->ismaximizescreen) {
|
||||
setmaximizescreen(c, 0);
|
||||
}
|
||||
if (to_left_or_up || to_right_or_down) {
|
||||
/* 找到当前堆叠的头节点，以便移动全局链表位置 */
|
||||
struct ScrollerStackNode *head = cnode;
|
||||
while (head->prev_in_stack)
|
||||
head = head->prev_in_stack;
|
||||
Client *source_stack_head = head->client;
|
||||
|
||||
if (c->prev_in_stack && direction != UNDIR) {
|
||||
if ((is_horizontal_layout && direction == LEFT) ||
|
||||
(!is_horizontal_layout && direction == UP)) {
|
||||
exit_scroller_stack(c);
|
||||
/* 从 tag 状态中移除该客户端对应的节点 */
|
||||
scroller_node_remove(st, cnode);
|
||||
/* 重新创建一个独立的节点（无堆叠关系） */
|
||||
scroller_node_create(st, c);
|
||||
|
||||
/* 调整全局客户端链表顺序：移到源堆叠头的前面或后面 */
|
||||
wl_list_remove(&c->link);
|
||||
wl_list_insert(source_stack_head->link.prev, &c->link);
|
||||
arrange(selmon, false, false);
|
||||
if (to_left_or_up)
|
||||
wl_list_insert(source_stack_head->link.prev, &c->link);
|
||||
else
|
||||
wl_list_insert(&source_stack_head->link, &c->link);
|
||||
|
||||
} else if ((is_horizontal_layout && direction == RIGHT) ||
|
||||
(!is_horizontal_layout && direction == DOWN)) {
|
||||
exit_scroller_stack(c);
|
||||
wl_list_remove(&c->link);
|
||||
wl_list_insert(&source_stack_head->link, &c->link);
|
||||
arrange(selmon, false, false);
|
||||
/* 同步到客户端字段并重排 */
|
||||
sync_scroller_state_to_clients(m, tag);
|
||||
arrange(m, false, false);
|
||||
return 0;
|
||||
}
|
||||
return 0;
|
||||
} else if (c->next_in_stack && direction != UNDIR) {
|
||||
Client *next_in_stack = c->next_in_stack;
|
||||
if ((is_horizontal_layout && direction == LEFT) ||
|
||||
(!is_horizontal_layout && direction == UP)) {
|
||||
exit_scroller_stack(c);
|
||||
wl_list_remove(&c->link);
|
||||
wl_list_insert(next_in_stack->link.prev, &c->link);
|
||||
arrange(selmon, false, false);
|
||||
} else if ((is_horizontal_layout && direction == RIGHT) ||
|
||||
(!is_horizontal_layout && direction == DOWN)) {
|
||||
exit_scroller_stack(c);
|
||||
wl_list_remove(&c->link);
|
||||
wl_list_insert(&next_in_stack->link, &c->link);
|
||||
arrange(selmon, false, false);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!target_client || target_client->mon != c->mon) {
|
||||
if (!target_client || target_client->mon != c->mon)
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Find the tail of target_client's stack
|
||||
Client *stack_tail = target_client;
|
||||
while (stack_tail->next_in_stack) {
|
||||
stack_tail = stack_tail->next_in_stack;
|
||||
}
|
||||
/* 找到目标堆叠的尾部节点 */
|
||||
struct ScrollerStackNode *tail = tnode;
|
||||
while (tail->next_in_stack)
|
||||
tail = tail->next_in_stack;
|
||||
|
||||
scroller_insert_stack(c, stack_tail, false);
|
||||
/* 通过封装好的插入函数实现（尾部插入） */
|
||||
scroller_insert_stack(c, tail->client, false);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -538,18 +538,6 @@ bool client_only_in_one_tag(Client *c) {
|
|||
}
|
||||
}
|
||||
|
||||
Client *get_scroll_stack_head(Client *c) {
|
||||
Client *scroller_stack_head = c;
|
||||
|
||||
if (!scroller_stack_head)
|
||||
return NULL;
|
||||
|
||||
while (scroller_stack_head->prev_in_stack) {
|
||||
scroller_stack_head = scroller_stack_head->prev_in_stack;
|
||||
}
|
||||
return scroller_stack_head;
|
||||
}
|
||||
|
||||
bool client_is_in_same_stack(Client *sc, Client *tc, Client *fc) {
|
||||
if (!sc || !tc)
|
||||
return false;
|
||||
|
|
@ -562,10 +550,11 @@ bool client_is_in_same_stack(Client *sc, Client *tc, Client *fc) {
|
|||
return false;
|
||||
|
||||
if (id == SCROLLER || id == VERTICAL_SCROLLER) {
|
||||
Client *source_stack_head = get_scroll_stack_head(sc);
|
||||
Client *target_stack_head = get_scroll_stack_head(tc);
|
||||
Client *fc_head = fc ? get_scroll_stack_head(fc) : NULL;
|
||||
if (fc && fc->prev_in_stack && fc_head == source_stack_head)
|
||||
Client *source_stack_head = scroll_get_stack_head_client(sc);
|
||||
Client *target_stack_head = scroll_get_stack_head_client(tc);
|
||||
Client *fc_head = fc ? scroll_get_stack_head_client(fc) : NULL;
|
||||
|
||||
if (fc && fc_head == source_stack_head)
|
||||
return false;
|
||||
if (source_stack_head == target_stack_head)
|
||||
return true;
|
||||
|
|
|
|||
|
|
@ -505,36 +505,51 @@ void resize_tile_dwindle(Client *grabc, bool isdrag, int32_t offsetx,
|
|||
|
||||
void resize_tile_scroller(Client *grabc, bool isdrag, int32_t offsetx,
|
||||
int32_t offsety, uint32_t time, bool isvertical) {
|
||||
Client *tc = NULL;
|
||||
if (!grabc || grabc->isfullscreen || grabc->ismaximizescreen)
|
||||
return;
|
||||
if (grabc->mon->isoverview)
|
||||
return;
|
||||
|
||||
Monitor *m = grabc->mon;
|
||||
uint32_t tag = m->pertag->curtag;
|
||||
struct TagScrollerState *st = m->pertag->scroller_state[tag];
|
||||
if (!st)
|
||||
return;
|
||||
|
||||
struct ScrollerStackNode *curnode = find_scroller_node(st, grabc);
|
||||
if (!curnode)
|
||||
return;
|
||||
|
||||
struct ScrollerStackNode *headnode = curnode;
|
||||
while (headnode->prev_in_stack)
|
||||
headnode = headnode->prev_in_stack;
|
||||
|
||||
Client *stack_head_client = headnode->client;
|
||||
|
||||
if (m->visible_tiling_clients == 1 &&
|
||||
!config.scroller_ignore_proportion_single)
|
||||
return;
|
||||
|
||||
float delta_x, delta_y;
|
||||
float new_scroller_proportion;
|
||||
float new_stack_proportion;
|
||||
Client *stack_head = get_scroll_stack_head(grabc);
|
||||
|
||||
if (grabc && grabc->mon->visible_tiling_clients == 1 &&
|
||||
!config.scroller_ignore_proportion_single)
|
||||
return;
|
||||
|
||||
if (!start_drag_window && isdrag) {
|
||||
drag_begin_cursorx = cursor->x;
|
||||
drag_begin_cursory = cursor->y;
|
||||
start_drag_window = true;
|
||||
|
||||
// 记录初始状态
|
||||
stack_head->old_scroller_pproportion = stack_head->scroller_proportion;
|
||||
grabc->old_stack_proportion = grabc->stack_proportion;
|
||||
headnode->client->old_scroller_pproportion =
|
||||
headnode->scroller_proportion;
|
||||
grabc->old_stack_proportion = curnode->stack_proportion;
|
||||
|
||||
grabc->cursor_in_left_half =
|
||||
cursor->x < grabc->geom.x + grabc->geom.width / 2;
|
||||
grabc->cursor_in_upper_half =
|
||||
cursor->y < grabc->geom.y + grabc->geom.height / 2;
|
||||
// 记录初始几何信息
|
||||
grabc->drag_begin_geom = grabc->geom;
|
||||
} else {
|
||||
// 计算相对于屏幕尺寸的比例变化
|
||||
// 计算相对于屏幕尺寸的比例变化
|
||||
if (isdrag) {
|
||||
|
||||
offsetx = cursor->x - drag_begin_cursorx;
|
||||
offsety = cursor->y - drag_begin_cursory;
|
||||
} else {
|
||||
|
|
@ -542,37 +557,33 @@ void resize_tile_scroller(Client *grabc, bool isdrag, int32_t offsetx,
|
|||
grabc->old_master_inner_per = grabc->master_inner_per;
|
||||
grabc->old_stack_inner_per = grabc->stack_inner_per;
|
||||
grabc->drag_begin_geom = grabc->geom;
|
||||
stack_head->old_scroller_pproportion =
|
||||
stack_head->scroller_proportion;
|
||||
grabc->old_stack_proportion = grabc->stack_proportion;
|
||||
stack_head_client->old_scroller_pproportion =
|
||||
headnode->scroller_proportion;
|
||||
grabc->old_stack_proportion = curnode->stack_proportion;
|
||||
grabc->cursor_in_upper_half = false;
|
||||
grabc->cursor_in_left_half = false;
|
||||
}
|
||||
|
||||
if (isvertical) {
|
||||
delta_y = (float)(offsety) *
|
||||
(stack_head->old_scroller_pproportion) /
|
||||
(headnode->client->old_scroller_pproportion) /
|
||||
grabc->drag_begin_geom.height;
|
||||
delta_x = (float)(offsetx) * (grabc->old_stack_proportion) /
|
||||
grabc->drag_begin_geom.width;
|
||||
} else {
|
||||
delta_x = (float)(offsetx) *
|
||||
(stack_head->old_scroller_pproportion) /
|
||||
(headnode->client->old_scroller_pproportion) /
|
||||
grabc->drag_begin_geom.width;
|
||||
delta_y = (float)(offsety) * (grabc->old_stack_proportion) /
|
||||
grabc->drag_begin_geom.height;
|
||||
}
|
||||
|
||||
bool moving_up;
|
||||
bool moving_down;
|
||||
bool moving_left;
|
||||
bool moving_right;
|
||||
|
||||
bool moving_up, moving_down, moving_left, moving_right;
|
||||
if (!isdrag) {
|
||||
moving_up = offsety < 0 ? true : false;
|
||||
moving_down = offsety > 0 ? true : false;
|
||||
moving_left = offsetx < 0 ? true : false;
|
||||
moving_right = offsetx > 0 ? true : false;
|
||||
moving_up = offsety < 0;
|
||||
moving_down = offsety > 0;
|
||||
moving_left = offsetx < 0;
|
||||
moving_right = offsetx > 0;
|
||||
} else {
|
||||
moving_up = cursor->y < drag_begin_cursory;
|
||||
moving_down = cursor->y > drag_begin_cursory;
|
||||
|
|
@ -582,10 +593,8 @@ void resize_tile_scroller(Client *grabc, bool isdrag, int32_t offsetx,
|
|||
|
||||
if ((grabc->cursor_in_upper_half && moving_up) ||
|
||||
(!grabc->cursor_in_upper_half && moving_down)) {
|
||||
// 光标在窗口上方且向上移动，或在窗口下方且向下移动 → 增加高度
|
||||
delta_y = fabsf(delta_y);
|
||||
} else {
|
||||
// 其他情况 → 减小高度
|
||||
delta_y = -fabsf(delta_y);
|
||||
}
|
||||
|
||||
|
|
@ -597,99 +606,93 @@ void resize_tile_scroller(Client *grabc, bool isdrag, int32_t offsetx,
|
|||
}
|
||||
|
||||
if (isvertical) {
|
||||
if (!grabc->next_in_stack && grabc->prev_in_stack && !isdrag) {
|
||||
if (!curnode->next_in_stack && curnode->prev_in_stack && !isdrag) {
|
||||
delta_x = delta_x * -1.0f;
|
||||
}
|
||||
if (!grabc->next_in_stack && grabc->prev_in_stack && isdrag) {
|
||||
if (moving_right) {
|
||||
if (!curnode->next_in_stack && curnode->prev_in_stack && isdrag) {
|
||||
if (moving_right)
|
||||
delta_x = -fabsf(delta_x);
|
||||
} else {
|
||||
else
|
||||
delta_x = fabsf(delta_x);
|
||||
}
|
||||
}
|
||||
if (!grabc->prev_in_stack && grabc->next_in_stack && isdrag) {
|
||||
if (moving_left) {
|
||||
if (!curnode->prev_in_stack && curnode->next_in_stack && isdrag) {
|
||||
if (moving_left)
|
||||
delta_x = -fabsf(delta_x);
|
||||
} else {
|
||||
else
|
||||
delta_x = fabsf(delta_x);
|
||||
}
|
||||
}
|
||||
|
||||
if (isdrag) {
|
||||
if (moving_up) {
|
||||
if (moving_up)
|
||||
delta_y = -fabsf(delta_y);
|
||||
} else {
|
||||
else
|
||||
delta_y = fabsf(delta_y);
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
if (!grabc->next_in_stack && grabc->prev_in_stack && !isdrag) {
|
||||
if (!curnode->next_in_stack && curnode->prev_in_stack && !isdrag) {
|
||||
delta_y = delta_y * -1.0f;
|
||||
}
|
||||
if (!grabc->next_in_stack && grabc->prev_in_stack && isdrag) {
|
||||
if (moving_down) {
|
||||
if (!curnode->next_in_stack && curnode->prev_in_stack && isdrag) {
|
||||
if (moving_down)
|
||||
delta_y = -fabsf(delta_y);
|
||||
} else {
|
||||
else
|
||||
delta_y = fabsf(delta_y);
|
||||
}
|
||||
}
|
||||
if (!grabc->prev_in_stack && grabc->next_in_stack && isdrag) {
|
||||
if (moving_up) {
|
||||
if (!curnode->prev_in_stack && curnode->next_in_stack && isdrag) {
|
||||
if (moving_up)
|
||||
delta_y = -fabsf(delta_y);
|
||||
} else {
|
||||
else
|
||||
delta_y = fabsf(delta_y);
|
||||
}
|
||||
}
|
||||
|
||||
if (isdrag) {
|
||||
if (moving_left) {
|
||||
if (moving_left)
|
||||
delta_x = -fabsf(delta_x);
|
||||
} else {
|
||||
else
|
||||
delta_x = fabsf(delta_x);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 直接设置新的比例，基于初始值 + 变化量
|
||||
if (isvertical) {
|
||||
new_scroller_proportion =
|
||||
stack_head->old_scroller_pproportion + delta_y;
|
||||
headnode->client->old_scroller_pproportion + delta_y;
|
||||
new_stack_proportion = grabc->old_stack_proportion + delta_x;
|
||||
|
||||
} else {
|
||||
new_scroller_proportion =
|
||||
stack_head->old_scroller_pproportion + delta_x;
|
||||
headnode->client->old_scroller_pproportion + delta_x;
|
||||
new_stack_proportion = grabc->old_stack_proportion + delta_y;
|
||||
}
|
||||
|
||||
// 应用限制，确保比例在合理范围内
|
||||
new_scroller_proportion =
|
||||
fmaxf(0.1f, fminf(1.0f, new_scroller_proportion));
|
||||
new_stack_proportion = fmaxf(0.1f, fminf(0.9f, new_stack_proportion));
|
||||
|
||||
grabc->stack_proportion = new_stack_proportion;
|
||||
curnode->stack_proportion = new_stack_proportion;
|
||||
headnode->scroller_proportion = new_scroller_proportion;
|
||||
|
||||
stack_head->scroller_proportion = new_scroller_proportion;
|
||||
|
||||
wl_list_for_each(tc, &clients, link) {
|
||||
if (!isdrag && new_stack_proportion != 1.0f &&
|
||||
grabc->old_stack_proportion != 1.0f && tc != grabc &&
|
||||
ISTILED(tc) && get_scroll_stack_head(tc) == stack_head) {
|
||||
tc->stack_proportion = (1.0f - new_stack_proportion) /
|
||||
(1.0f - grabc->old_stack_proportion) *
|
||||
tc->stack_proportion;
|
||||
/* 调整同一堆叠内其他节点的 stack_proportion */
|
||||
/* 调整整个堆叠内除当前窗口外的所有节点 */
|
||||
if (!isdrag && grabc->old_stack_proportion != 1.0f) {
|
||||
for (struct ScrollerStackNode *tc = headnode; tc;
|
||||
tc = tc->next_in_stack) {
|
||||
if (tc != curnode) {
|
||||
tc->stack_proportion =
|
||||
(1.0f - new_stack_proportion) /
|
||||
(1.0f - grabc->old_stack_proportion) *
|
||||
tc->stack_proportion;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* 同步回全局字段*/
|
||||
sync_scroller_state_to_clients(m, tag);
|
||||
|
||||
if (!isdrag) {
|
||||
arrange(grabc->mon, false, false);
|
||||
arrange(m, false, false);
|
||||
return;
|
||||
}
|
||||
|
||||
if (last_apply_drap_time == 0 ||
|
||||
time - last_apply_drap_time > config.drag_tile_refresh_interval) {
|
||||
arrange(grabc->mon, false, false);
|
||||
arrange(m, false, false);
|
||||
last_apply_drap_time = time;
|
||||
}
|
||||
}
|
||||
|
|
@ -834,11 +837,15 @@ void pre_caculate_before_arrange(Monitor *m, bool want_animation,
|
|||
m->visible_tiling_clients = 0;
|
||||
m->visible_scroll_tiling_clients = 0;
|
||||
|
||||
wl_list_for_each(c, &clients, link) {
|
||||
uint32_t tag = m->pertag->curtag;
|
||||
struct TagScrollerState *st = m->pertag->scroller_state[tag];
|
||||
|
||||
if (!client_only_in_one_tag(c) || c->isglobal || c->isunglobal) {
|
||||
exit_scroller_stack(c);
|
||||
}
|
||||
const Layout *cur_layout = m->pertag->ltidxs[m->pertag->curtag];
|
||||
if (cur_layout->id == SCROLLER || cur_layout->id == VERTICAL_SCROLLER) {
|
||||
update_scroller_state(m);
|
||||
}
|
||||
|
||||
wl_list_for_each(c, &clients, link) {
|
||||
|
||||
if (from_view && (c->isglobal || c->isunglobal)) {
|
||||
set_size_per(m, c);
|
||||
|
|
@ -862,10 +869,15 @@ void pre_caculate_before_arrange(Monitor *m, bool want_animation,
|
|||
|
||||
if (ISTILED(c)) {
|
||||
m->visible_tiling_clients++;
|
||||
}
|
||||
|
||||
if (ISSCROLLTILED(c) && !c->prev_in_stack) {
|
||||
m->visible_scroll_tiling_clients++;
|
||||
/* 更新可见滚动客户端计数 */
|
||||
if (st) {
|
||||
struct ScrollerStackNode *n = find_scroller_node(st, c);
|
||||
if (n && !n->prev_in_stack) /* 是堆叠头部 */
|
||||
m->visible_scroll_tiling_clients++;
|
||||
} else if (ISSCROLLTILED(c)) {
|
||||
m->visible_scroll_tiling_clients++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -879,7 +891,6 @@ void pre_caculate_before_arrange(Monitor *m, bool want_animation,
|
|||
if (c->mon == m) {
|
||||
if (VISIBLEON(c, m)) {
|
||||
if (ISTILED(c)) {
|
||||
|
||||
if (i < nmasters) {
|
||||
master_num++;
|
||||
total_master_inner_percent += c->master_inner_per;
|
||||
|
|
@ -898,7 +909,6 @@ void pre_caculate_before_arrange(Monitor *m, bool want_animation,
|
|||
c->stack_inner_per;
|
||||
}
|
||||
}
|
||||
|
||||
i++;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -184,325 +184,6 @@ void deck(Monitor *m) {
|
|||
}
|
||||
}
|
||||
|
||||
void horizontal_scroll_adjust_fullandmax(Client *c,
|
||||
struct wlr_box *target_geom) {
|
||||
Monitor *m = c->mon;
|
||||
int32_t cur_gappih = enablegaps ? m->gappih : 0;
|
||||
int32_t cur_gappoh = enablegaps ? m->gappoh : 0;
|
||||
int32_t cur_gappov = enablegaps ? m->gappov : 0;
|
||||
|
||||
cur_gappih = config.smartgaps && m->visible_scroll_tiling_clients == 1
|
||||
? 0
|
||||
: cur_gappih;
|
||||
cur_gappoh = config.smartgaps && m->visible_scroll_tiling_clients == 1
|
||||
? 0
|
||||
: cur_gappoh;
|
||||
cur_gappov = config.smartgaps && m->visible_scroll_tiling_clients == 1
|
||||
? 0
|
||||
: cur_gappov;
|
||||
|
||||
if (c->isfullscreen) {
|
||||
target_geom->height = m->m.height;
|
||||
target_geom->width = m->m.width;
|
||||
target_geom->y = m->m.y;
|
||||
return;
|
||||
}
|
||||
|
||||
if (c->ismaximizescreen) {
|
||||
target_geom->height = m->w.height - 2 * cur_gappov;
|
||||
target_geom->width = m->w.width - 2 * cur_gappoh;
|
||||
target_geom->y = m->w.y + cur_gappov;
|
||||
return;
|
||||
}
|
||||
|
||||
target_geom->height = m->w.height - 2 * cur_gappov;
|
||||
target_geom->y = m->w.y + (m->w.height - target_geom->height) / 2;
|
||||
}
|
||||
|
||||
void arrange_stack(Client *scroller_stack_head, struct wlr_box geometry,
|
||||
int32_t gappiv) {
|
||||
int32_t stack_size = 0;
|
||||
Client *iter = scroller_stack_head;
|
||||
|
||||
while (iter) {
|
||||
stack_size++;
|
||||
iter = iter->next_in_stack;
|
||||
}
|
||||
|
||||
if (stack_size == 0)
|
||||
return;
|
||||
|
||||
float total_proportion = 0.0f;
|
||||
iter = scroller_stack_head;
|
||||
while (iter) {
|
||||
if (iter->stack_proportion <= 0.0f || iter->stack_proportion >= 1.0f) {
|
||||
iter->stack_proportion =
|
||||
stack_size == 1 ? 1.0f : 1.0f / (stack_size - 1);
|
||||
}
|
||||
total_proportion += iter->stack_proportion;
|
||||
iter = iter->next_in_stack;
|
||||
}
|
||||
|
||||
iter = scroller_stack_head;
|
||||
while (iter) {
|
||||
iter->stack_proportion = iter->stack_proportion / total_proportion;
|
||||
iter = iter->next_in_stack;
|
||||
}
|
||||
|
||||
int32_t client_height;
|
||||
int32_t current_y = geometry.y;
|
||||
int32_t remain_client_height = geometry.height - (stack_size - 1) * gappiv;
|
||||
float remain_proportion = 1.0f;
|
||||
|
||||
iter = scroller_stack_head;
|
||||
while (iter) {
|
||||
|
||||
client_height =
|
||||
remain_client_height * (iter->stack_proportion / remain_proportion);
|
||||
|
||||
struct wlr_box client_geom = {.x = geometry.x,
|
||||
.y = current_y,
|
||||
.width = geometry.width,
|
||||
.height = client_height};
|
||||
resize(iter, client_geom, 0);
|
||||
remain_proportion -= iter->stack_proportion;
|
||||
remain_client_height -= client_height;
|
||||
current_y += client_height + gappiv;
|
||||
iter = iter->next_in_stack;
|
||||
}
|
||||
}
|
||||
|
||||
void horizontal_check_scroller_root_inside_mon(Client *c,
|
||||
struct wlr_box *geometry) {
|
||||
if (!GEOMINSIDEMON(geometry, c->mon)) {
|
||||
geometry->x = c->mon->w.x + (c->mon->w.width - geometry->width) / 2;
|
||||
}
|
||||
}
|
||||
|
||||
// 滚动布局
|
||||
void scroller(Monitor *m) {
|
||||
int32_t i, n, j;
|
||||
float single_proportion = 1.0;
|
||||
|
||||
Client *c = NULL, *root_client = NULL;
|
||||
Client **tempClients = NULL; // 初始化为 NULL
|
||||
struct wlr_box target_geom;
|
||||
int32_t focus_client_index = 0;
|
||||
bool need_scroller = false;
|
||||
bool over_overspread_to_left = false;
|
||||
int32_t cur_gappih = enablegaps ? m->gappih : 0;
|
||||
int32_t cur_gappoh = enablegaps ? m->gappoh : 0;
|
||||
int32_t cur_gappov = enablegaps ? m->gappov : 0;
|
||||
int32_t cur_gappiv = enablegaps ? m->gappiv : 0;
|
||||
|
||||
cur_gappih = config.smartgaps && m->visible_scroll_tiling_clients == 1
|
||||
? 0
|
||||
: cur_gappih;
|
||||
cur_gappoh = config.smartgaps && m->visible_scroll_tiling_clients == 1
|
||||
? 0
|
||||
: cur_gappoh;
|
||||
cur_gappov = config.smartgaps && m->visible_scroll_tiling_clients == 1
|
||||
? 0
|
||||
: cur_gappov;
|
||||
|
||||
int32_t max_client_width =
|
||||
m->w.width - 2 * config.scroller_structs - cur_gappih;
|
||||
|
||||
n = m->visible_scroll_tiling_clients;
|
||||
|
||||
if (n == 0) {
|
||||
return; // 没有需要处理的客户端，直接返回
|
||||
}
|
||||
|
||||
// 动态分配内存
|
||||
tempClients = malloc(n * sizeof(Client *));
|
||||
if (!tempClients) {
|
||||
// 处理内存分配失败的情况
|
||||
return;
|
||||
}
|
||||
|
||||
// 第二次遍历，填充 tempClients
|
||||
j = 0;
|
||||
wl_list_for_each(c, &clients, link) {
|
||||
if (VISIBLEON(c, m) && ISSCROLLTILED(c) && !c->prev_in_stack) {
|
||||
tempClients[j] = c;
|
||||
j++;
|
||||
}
|
||||
}
|
||||
|
||||
if (n == 1 && !config.scroller_ignore_proportion_single &&
|
||||
!tempClients[0]->isfullscreen && !tempClients[0]->ismaximizescreen) {
|
||||
c = tempClients[0];
|
||||
|
||||
single_proportion = c->scroller_proportion_single > 0.0f
|
||||
? c->scroller_proportion_single
|
||||
: config.scroller_default_proportion_single;
|
||||
|
||||
target_geom.height = m->w.height - 2 * cur_gappov;
|
||||
target_geom.width = (m->w.width - 2 * cur_gappoh) * single_proportion;
|
||||
target_geom.x = m->w.x + (m->w.width - target_geom.width) / 2;
|
||||
target_geom.y = m->w.y + (m->w.height - target_geom.height) / 2;
|
||||
horizontal_check_scroller_root_inside_mon(c, &target_geom);
|
||||
arrange_stack(c, target_geom, cur_gappiv);
|
||||
free(tempClients); // 释放内存
|
||||
return;
|
||||
}
|
||||
|
||||
if (m->sel && !client_is_unmanaged(m->sel) && ISSCROLLTILED(m->sel)) {
|
||||
root_client = m->sel;
|
||||
} else if (m->prevsel && ISSCROLLTILED(m->prevsel) &&
|
||||
VISIBLEON(m->prevsel, m) && !client_is_unmanaged(m->prevsel)) {
|
||||
root_client = m->prevsel;
|
||||
} else {
|
||||
root_client = center_tiled_select(m);
|
||||
}
|
||||
|
||||
// root_client might be in a stack, find the stack head
|
||||
if (root_client) {
|
||||
root_client = get_scroll_stack_head(root_client);
|
||||
}
|
||||
|
||||
if (!root_client) {
|
||||
free(tempClients); // 释放内存
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < n; i++) {
|
||||
c = tempClients[i];
|
||||
if (root_client == c) {
|
||||
if (c->geom.x >= m->w.x + config.scroller_structs &&
|
||||
c->geom.x + c->geom.width <=
|
||||
m->w.x + m->w.width - config.scroller_structs) {
|
||||
need_scroller = false;
|
||||
} else {
|
||||
need_scroller = true;
|
||||
}
|
||||
focus_client_index = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
bool need_apply_overspread =
|
||||
config.scroller_prefer_overspread &&
|
||||
m->visible_scroll_tiling_clients > 1 &&
|
||||
(focus_client_index == 0 || focus_client_index == n - 1) &&
|
||||
tempClients[focus_client_index]->scroller_proportion < 1.0f;
|
||||
|
||||
if (need_apply_overspread) {
|
||||
|
||||
if (focus_client_index == 0) {
|
||||
over_overspread_to_left = true;
|
||||
} else {
|
||||
over_overspread_to_left = false;
|
||||
}
|
||||
|
||||
if (over_overspread_to_left &&
|
||||
(!INSIDEMON(tempClients[1]) ||
|
||||
(tempClients[1]->scroller_proportion +
|
||||
tempClients[focus_client_index]->scroller_proportion >=
|
||||
1.0f))) {
|
||||
need_scroller = true;
|
||||
} else if (!over_overspread_to_left &&
|
||||
(!INSIDEMON(tempClients[focus_client_index - 1]) ||
|
||||
(tempClients[focus_client_index - 1]->scroller_proportion +
|
||||
tempClients[focus_client_index]->scroller_proportion >=
|
||||
1.0f))) {
|
||||
need_scroller = true;
|
||||
} else {
|
||||
need_apply_overspread = false;
|
||||
}
|
||||
}
|
||||
|
||||
bool need_apply_center =
|
||||
config.scroller_focus_center || m->visible_scroll_tiling_clients == 1 ||
|
||||
(config.scroller_prefer_center && !need_apply_overspread &&
|
||||
(!m->prevsel ||
|
||||
(ISSCROLLTILED(m->prevsel) &&
|
||||
(m->prevsel->scroller_proportion * max_client_width) +
|
||||
(tempClients[focus_client_index]->scroller_proportion *
|
||||
max_client_width) >
|
||||
m->w.width - 2 * config.scroller_structs - cur_gappih)));
|
||||
|
||||
if (n == 1 && config.scroller_ignore_proportion_single) {
|
||||
need_scroller = true;
|
||||
}
|
||||
|
||||
if (start_drag_window)
|
||||
need_scroller = false;
|
||||
|
||||
target_geom.height = m->w.height - 2 * cur_gappov;
|
||||
target_geom.width = max_client_width * c->scroller_proportion;
|
||||
target_geom.y = m->w.y + (m->w.height - target_geom.height) / 2;
|
||||
horizontal_scroll_adjust_fullandmax(tempClients[focus_client_index],
|
||||
&target_geom);
|
||||
if (tempClients[focus_client_index]->isfullscreen) {
|
||||
target_geom.x = m->m.x;
|
||||
horizontal_check_scroller_root_inside_mon(
|
||||
tempClients[focus_client_index], &target_geom);
|
||||
arrange_stack(tempClients[focus_client_index], target_geom, cur_gappiv);
|
||||
} else if (tempClients[focus_client_index]->ismaximizescreen) {
|
||||
target_geom.x = m->w.x + cur_gappoh;
|
||||
horizontal_check_scroller_root_inside_mon(
|
||||
tempClients[focus_client_index], &target_geom);
|
||||
arrange_stack(tempClients[focus_client_index], target_geom, cur_gappiv);
|
||||
} else if (need_scroller) {
|
||||
if (need_apply_center) {
|
||||
target_geom.x = m->w.x + (m->w.width - target_geom.width) / 2;
|
||||
} else if (need_apply_overspread) {
|
||||
if (over_overspread_to_left) {
|
||||
target_geom.x = m->w.x + config.scroller_structs;
|
||||
} else {
|
||||
target_geom.x =
|
||||
m->w.x +
|
||||
(m->w.width -
|
||||
tempClients[focus_client_index]->scroller_proportion *
|
||||
max_client_width -
|
||||
config.scroller_structs);
|
||||
}
|
||||
|
||||
} else {
|
||||
target_geom.x = tempClients[focus_client_index]->geom.x >
|
||||
m->w.x + (m->w.width) / 2
|
||||
? m->w.x + (m->w.width -
|
||||
tempClients[focus_client_index]
|
||||
->scroller_proportion *
|
||||
max_client_width -
|
||||
config.scroller_structs)
|
||||
: m->w.x + config.scroller_structs;
|
||||
}
|
||||
horizontal_check_scroller_root_inside_mon(
|
||||
tempClients[focus_client_index], &target_geom);
|
||||
arrange_stack(tempClients[focus_client_index], target_geom, cur_gappiv);
|
||||
} else {
|
||||
target_geom.x = c->geom.x;
|
||||
horizontal_check_scroller_root_inside_mon(
|
||||
tempClients[focus_client_index], &target_geom);
|
||||
arrange_stack(tempClients[focus_client_index], target_geom, cur_gappiv);
|
||||
}
|
||||
|
||||
for (i = 1; i <= focus_client_index; i++) {
|
||||
c = tempClients[focus_client_index - i];
|
||||
target_geom.width = max_client_width * c->scroller_proportion;
|
||||
horizontal_scroll_adjust_fullandmax(c, &target_geom);
|
||||
target_geom.x = tempClients[focus_client_index - i + 1]->geom.x -
|
||||
cur_gappih - target_geom.width;
|
||||
|
||||
arrange_stack(c, target_geom, cur_gappiv);
|
||||
}
|
||||
|
||||
for (i = 1; i < n - focus_client_index; i++) {
|
||||
c = tempClients[focus_client_index + i];
|
||||
target_geom.width = max_client_width * c->scroller_proportion;
|
||||
horizontal_scroll_adjust_fullandmax(c, &target_geom);
|
||||
target_geom.x = tempClients[focus_client_index + i - 1]->geom.x +
|
||||
cur_gappih +
|
||||
tempClients[focus_client_index + i - 1]->geom.width;
|
||||
arrange_stack(c, target_geom, cur_gappiv);
|
||||
}
|
||||
|
||||
free(tempClients); // 最后释放内存
|
||||
}
|
||||
|
||||
void center_tile(Monitor *m) {
|
||||
int32_t i, n = 0, h, r, ie = enablegaps, mw, mx, my, oty, ety, tw;
|
||||
Client *c = NULL;
|
||||
|
|
|
|||
888
src/layout/scroll.h
Normal file
888
src/layout/scroll.h
Normal file
|
|
@ -0,0 +1,888 @@
|
|||
/* 获取或创建指定 monitor 某个 tag 的 scroller 状态 */
|
||||
static struct TagScrollerState *ensure_scroller_state(Monitor *m,
|
||||
uint32_t tag) {
|
||||
if (!m->pertag->scroller_state[tag]) {
|
||||
struct TagScrollerState *st =
|
||||
calloc(1, sizeof(struct TagScrollerState));
|
||||
m->pertag->scroller_state[tag] = st;
|
||||
}
|
||||
return m->pertag->scroller_state[tag];
|
||||
}
|
||||
|
||||
/* 在 tag 状态中查找客户端对应的节点（无则返回 NULL） */
|
||||
static struct ScrollerStackNode *find_scroller_node(struct TagScrollerState *st,
|
||||
Client *c) {
|
||||
if (!st)
|
||||
return NULL;
|
||||
for (struct ScrollerStackNode *n = st->all_first; n; n = n->all_next)
|
||||
if (n->client == c)
|
||||
return n;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* 创建一个新节点并插入到 tag 状态的 all 链表中 */
|
||||
static struct ScrollerStackNode *
|
||||
scroller_node_create(struct TagScrollerState *st, Client *c) {
|
||||
struct ScrollerStackNode *n = calloc(1, sizeof(*n));
|
||||
n->client = c;
|
||||
n->scroller_proportion = c->scroller_proportion;
|
||||
n->stack_proportion = c->stack_proportion;
|
||||
n->scroller_proportion_single = c->scroller_proportion_single;
|
||||
n->next_in_stack = NULL;
|
||||
n->prev_in_stack = NULL;
|
||||
n->all_next = st->all_first;
|
||||
st->all_first = n;
|
||||
st->count++;
|
||||
return n;
|
||||
}
|
||||
|
||||
/* 从 tag 状态中移除一个节点并释放 */
|
||||
static void scroller_node_remove(struct TagScrollerState *st,
|
||||
struct ScrollerStackNode *target) {
|
||||
if (!st || !target)
|
||||
return;
|
||||
|
||||
/* 保存邻居 */
|
||||
struct ScrollerStackNode *prev = target->prev_in_stack;
|
||||
struct ScrollerStackNode *next = target->next_in_stack;
|
||||
|
||||
/* 从堆叠链表中摘除 */
|
||||
if (prev)
|
||||
prev->next_in_stack = next;
|
||||
if (next)
|
||||
next->prev_in_stack = prev;
|
||||
|
||||
/* 从 all 链表摘除 */
|
||||
struct ScrollerStackNode **indirect = &st->all_first;
|
||||
while (*indirect && *indirect != target)
|
||||
indirect = &(*indirect)->all_next;
|
||||
if (*indirect == target) {
|
||||
*indirect = target->all_next;
|
||||
st->count--;
|
||||
}
|
||||
free(target);
|
||||
}
|
||||
|
||||
/* 清空一个 tag 的全部 scroller 状态 */
|
||||
static void clear_scroller_state(struct TagScrollerState *st) {
|
||||
if (!st)
|
||||
return;
|
||||
struct ScrollerStackNode *n = st->all_first;
|
||||
while (n) {
|
||||
struct ScrollerStackNode *next = n->all_next;
|
||||
free(n);
|
||||
n = next;
|
||||
}
|
||||
free(st);
|
||||
}
|
||||
|
||||
/* 在 Monitor 销毁时清理所有 tag 的 scroller 状态 */
|
||||
static void cleanup_monitor_scroller(Monitor *m) {
|
||||
for (int t = 0; t < LENGTH(tags) + 1; t++) {
|
||||
if (m->pertag->scroller_state[t]) {
|
||||
clear_scroller_state(m->pertag->scroller_state[t]);
|
||||
m->pertag->scroller_state[t] = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* 将某个 tag 的状态同步回所有客户端的全局字段 */
|
||||
static void sync_scroller_state_to_clients(Monitor *m, uint32_t tag) {
|
||||
struct TagScrollerState *st = m->pertag->scroller_state[tag];
|
||||
if (!st)
|
||||
return;
|
||||
for (struct ScrollerStackNode *n = st->all_first; n; n = n->all_next) {
|
||||
Client *c = n->client;
|
||||
c->scroller_proportion = n->scroller_proportion;
|
||||
c->stack_proportion = n->stack_proportion;
|
||||
c->scroller_proportion_single = n->scroller_proportion_single;
|
||||
}
|
||||
}
|
||||
|
||||
void vertical_scroll_adjust_fullandmax(Client *c, struct wlr_box *target_geom) {
|
||||
Monitor *m = c->mon;
|
||||
int32_t cur_gappiv = enablegaps ? m->gappiv : 0;
|
||||
int32_t cur_gappov = enablegaps ? m->gappov : 0;
|
||||
int32_t cur_gappoh = enablegaps ? m->gappoh : 0;
|
||||
|
||||
cur_gappiv = config.smartgaps && m->visible_scroll_tiling_clients == 1
|
||||
? 0
|
||||
: cur_gappiv;
|
||||
cur_gappov = config.smartgaps && m->visible_scroll_tiling_clients == 1
|
||||
? 0
|
||||
: cur_gappov;
|
||||
cur_gappoh = config.smartgaps && m->visible_scroll_tiling_clients == 1
|
||||
? 0
|
||||
: cur_gappoh;
|
||||
|
||||
if (c->isfullscreen) {
|
||||
target_geom->width = m->m.width;
|
||||
target_geom->height = m->m.height;
|
||||
target_geom->x = m->m.x;
|
||||
return;
|
||||
}
|
||||
|
||||
if (c->ismaximizescreen) {
|
||||
target_geom->width = m->w.width - 2 * cur_gappoh;
|
||||
target_geom->height = m->w.height - 2 * cur_gappov;
|
||||
target_geom->x = m->w.x + cur_gappoh;
|
||||
return;
|
||||
}
|
||||
|
||||
target_geom->width = m->w.width - 2 * cur_gappoh;
|
||||
target_geom->x = m->w.x + (m->w.width - target_geom->width) / 2;
|
||||
}
|
||||
|
||||
void vertical_check_scroller_root_inside_mon(Client *c,
|
||||
struct wlr_box *geometry) {
|
||||
if (!GEOMINSIDEMON(geometry, c->mon)) {
|
||||
geometry->y = c->mon->w.y + (c->mon->w.height - geometry->height) / 2;
|
||||
}
|
||||
}
|
||||
|
||||
void horizontal_scroll_adjust_fullandmax(Client *c,
|
||||
struct wlr_box *target_geom) {
|
||||
Monitor *m = c->mon;
|
||||
int32_t cur_gappih = enablegaps ? m->gappih : 0;
|
||||
int32_t cur_gappoh = enablegaps ? m->gappoh : 0;
|
||||
int32_t cur_gappov = enablegaps ? m->gappov : 0;
|
||||
|
||||
cur_gappih = config.smartgaps && m->visible_scroll_tiling_clients == 1
|
||||
? 0
|
||||
: cur_gappih;
|
||||
cur_gappoh = config.smartgaps && m->visible_scroll_tiling_clients == 1
|
||||
? 0
|
||||
: cur_gappoh;
|
||||
cur_gappov = config.smartgaps && m->visible_scroll_tiling_clients == 1
|
||||
? 0
|
||||
: cur_gappov;
|
||||
|
||||
if (c->isfullscreen) {
|
||||
target_geom->height = m->m.height;
|
||||
target_geom->width = m->m.width;
|
||||
target_geom->y = m->m.y;
|
||||
return;
|
||||
}
|
||||
|
||||
if (c->ismaximizescreen) {
|
||||
target_geom->height = m->w.height - 2 * cur_gappov;
|
||||
target_geom->width = m->w.width - 2 * cur_gappoh;
|
||||
target_geom->y = m->w.y + cur_gappov;
|
||||
return;
|
||||
}
|
||||
|
||||
target_geom->height = m->w.height - 2 * cur_gappov;
|
||||
target_geom->y = m->w.y + (m->w.height - target_geom->height) / 2;
|
||||
}
|
||||
|
||||
void horizontal_check_scroller_root_inside_mon(Client *c,
|
||||
struct wlr_box *geometry) {
|
||||
if (!GEOMINSIDEMON(geometry, c->mon)) {
|
||||
geometry->x = c->mon->w.x + (c->mon->w.width - geometry->width) / 2;
|
||||
}
|
||||
}
|
||||
|
||||
void arrange_stack_node(struct ScrollerStackNode *head, struct wlr_box geometry,
|
||||
int32_t gappiv) {
|
||||
int32_t stack_size = 0;
|
||||
struct ScrollerStackNode *iter = head;
|
||||
while (iter) {
|
||||
stack_size++;
|
||||
iter = iter->next_in_stack;
|
||||
}
|
||||
if (stack_size == 0)
|
||||
return;
|
||||
|
||||
/* 归一化比例 */
|
||||
float total_proportion = 0.0f;
|
||||
iter = head;
|
||||
while (iter) {
|
||||
if (iter->stack_proportion <= 0.0f || iter->stack_proportion >= 1.0f)
|
||||
iter->stack_proportion =
|
||||
stack_size == 1 ? 1.0f : 1.0f / (stack_size - 1);
|
||||
total_proportion += iter->stack_proportion;
|
||||
iter = iter->next_in_stack;
|
||||
}
|
||||
iter = head;
|
||||
while (iter) {
|
||||
iter->stack_proportion /= total_proportion;
|
||||
iter = iter->next_in_stack;
|
||||
}
|
||||
|
||||
/* 竖向排列（水平堆叠） */
|
||||
int32_t client_height;
|
||||
int32_t current_y = geometry.y;
|
||||
int32_t remain_client_height = geometry.height - (stack_size - 1) * gappiv;
|
||||
float remain_proportion = 1.0f;
|
||||
|
||||
iter = head;
|
||||
while (iter) {
|
||||
client_height =
|
||||
remain_client_height * (iter->stack_proportion / remain_proportion);
|
||||
struct wlr_box client_geom = {.x = geometry.x,
|
||||
.y = current_y,
|
||||
.width = geometry.width,
|
||||
.height = client_height};
|
||||
resize(iter->client, client_geom, 0);
|
||||
remain_proportion -= iter->stack_proportion;
|
||||
remain_client_height -= client_height;
|
||||
current_y += client_height + gappiv;
|
||||
iter = iter->next_in_stack;
|
||||
}
|
||||
}
|
||||
|
||||
void arrange_stack_vertical_node(struct ScrollerStackNode *head,
|
||||
struct wlr_box geometry, int32_t gappih) {
|
||||
int32_t stack_size = 0;
|
||||
struct ScrollerStackNode *iter = head;
|
||||
while (iter) {
|
||||
stack_size++;
|
||||
iter = iter->next_in_stack;
|
||||
}
|
||||
if (stack_size == 0)
|
||||
return;
|
||||
|
||||
/* 归一化比例 */
|
||||
float total_proportion = 0.0f;
|
||||
iter = head;
|
||||
while (iter) {
|
||||
if (iter->stack_proportion <= 0.0f || iter->stack_proportion >= 1.0f)
|
||||
iter->stack_proportion =
|
||||
stack_size == 1 ? 1.0f : 1.0f / (stack_size - 1);
|
||||
total_proportion += iter->stack_proportion;
|
||||
iter = iter->next_in_stack;
|
||||
}
|
||||
iter = head;
|
||||
while (iter) {
|
||||
iter->stack_proportion /= total_proportion;
|
||||
iter = iter->next_in_stack;
|
||||
}
|
||||
|
||||
/* 横向排列（垂直堆叠） */
|
||||
int32_t client_width;
|
||||
int32_t current_x = geometry.x;
|
||||
int32_t remain_client_width = geometry.width - (stack_size - 1) * gappih;
|
||||
float remain_proportion = 1.0f;
|
||||
|
||||
iter = head;
|
||||
while (iter) {
|
||||
client_width =
|
||||
remain_client_width * (iter->stack_proportion / remain_proportion);
|
||||
struct wlr_box client_geom = {.y = geometry.y,
|
||||
.x = current_x,
|
||||
.height = geometry.height,
|
||||
.width = client_width};
|
||||
resize(iter->client, client_geom, 0);
|
||||
remain_proportion -= iter->stack_proportion;
|
||||
remain_client_width -= client_width;
|
||||
current_x += client_width + gappih;
|
||||
iter = iter->next_in_stack;
|
||||
}
|
||||
}
|
||||
|
||||
void scroller(Monitor *m) {
|
||||
uint32_t tag = m->pertag->curtag;
|
||||
struct TagScrollerState *st = ensure_scroller_state(m, tag);
|
||||
Client *c = NULL;
|
||||
|
||||
/* 按全局客户端链表顺序收集所有堆叠头，确保视觉顺序正确 */
|
||||
struct ScrollerStackNode *heads[64];
|
||||
int32_t n_heads = 0;
|
||||
wl_list_for_each(c, &clients, link) {
|
||||
if (VISIBLEON(c, m) && ISSCROLLTILED(c)) {
|
||||
struct ScrollerStackNode *node = find_scroller_node(st, c);
|
||||
if (node && !node->prev_in_stack) {
|
||||
bool already = false;
|
||||
for (int k = 0; k < n_heads; k++) {
|
||||
if (heads[k] == node) {
|
||||
already = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!already)
|
||||
heads[n_heads++] = node;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (n_heads == 0) {
|
||||
sync_scroller_state_to_clients(m, tag);
|
||||
return;
|
||||
}
|
||||
|
||||
m->visible_scroll_tiling_clients = n_heads;
|
||||
|
||||
int32_t cur_gappih = enablegaps ? m->gappih : 0;
|
||||
int32_t cur_gappoh = enablegaps ? m->gappoh : 0;
|
||||
int32_t cur_gappov = enablegaps ? m->gappov : 0;
|
||||
int32_t cur_gappiv = enablegaps ? m->gappiv : 0;
|
||||
if (config.smartgaps && n_heads == 1) {
|
||||
cur_gappih = cur_gappoh = cur_gappov = 0;
|
||||
}
|
||||
int32_t max_client_width =
|
||||
m->w.width - 2 * config.scroller_structs - cur_gappih;
|
||||
|
||||
/* 单客户端特例 */
|
||||
if (n_heads == 1 && !config.scroller_ignore_proportion_single &&
|
||||
!heads[0]->client->isfullscreen &&
|
||||
!heads[0]->client->ismaximizescreen) {
|
||||
struct ScrollerStackNode *head = heads[0];
|
||||
float single_proportion =
|
||||
head->scroller_proportion_single > 0.0f
|
||||
? head->scroller_proportion_single
|
||||
: config.scroller_default_proportion_single;
|
||||
struct wlr_box target_geom;
|
||||
target_geom.height = m->w.height - 2 * cur_gappov;
|
||||
target_geom.width = (m->w.width - 2 * cur_gappoh) * single_proportion;
|
||||
target_geom.x = m->w.x + (m->w.width - target_geom.width) / 2;
|
||||
target_geom.y = m->w.y + (m->w.height - target_geom.height) / 2;
|
||||
horizontal_check_scroller_root_inside_mon(head->client, &target_geom);
|
||||
arrange_stack_node(head, target_geom, cur_gappiv);
|
||||
sync_scroller_state_to_clients(m, tag);
|
||||
return;
|
||||
}
|
||||
|
||||
struct ScrollerStackNode *root_node = NULL;
|
||||
if (m->sel && ISSCROLLTILED(m->sel)) {
|
||||
root_node = find_scroller_node(st, m->sel);
|
||||
if (root_node) {
|
||||
while (root_node->prev_in_stack)
|
||||
root_node = root_node->prev_in_stack;
|
||||
}
|
||||
}
|
||||
if (!root_node && m->prevsel && ISSCROLLTILED(m->prevsel)) {
|
||||
root_node = find_scroller_node(st, m->prevsel);
|
||||
if (root_node) {
|
||||
while (root_node->prev_in_stack)
|
||||
root_node = root_node->prev_in_stack;
|
||||
}
|
||||
}
|
||||
if (!root_node)
|
||||
root_node = heads[n_heads / 2]; /* 简单回退 */
|
||||
|
||||
int32_t focus_index = -1;
|
||||
for (int i = 0; i < n_heads; i++) {
|
||||
if (heads[i] == root_node) {
|
||||
focus_index = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (focus_index < 0)
|
||||
focus_index = n_heads / 2;
|
||||
|
||||
/* 判断是否需要滚动、overspread、center */
|
||||
bool need_scroller = false;
|
||||
bool over_overspread_to_left = false;
|
||||
Client *root_client = root_node->client;
|
||||
|
||||
if (root_client->geom.x >= m->w.x + config.scroller_structs &&
|
||||
root_client->geom.x + root_client->geom.width <=
|
||||
m->w.x + m->w.width - config.scroller_structs) {
|
||||
need_scroller = false;
|
||||
} else {
|
||||
need_scroller = true;
|
||||
}
|
||||
|
||||
bool need_apply_overspread =
|
||||
config.scroller_prefer_overspread && n_heads > 1 &&
|
||||
(focus_index == 0 || focus_index == n_heads - 1) &&
|
||||
heads[focus_index]->scroller_proportion < 1.0f;
|
||||
|
||||
if (need_apply_overspread) {
|
||||
if (focus_index == 0) {
|
||||
over_overspread_to_left = true;
|
||||
} else {
|
||||
over_overspread_to_left = false;
|
||||
}
|
||||
if (over_overspread_to_left &&
|
||||
(!INSIDEMON(heads[1]->client) ||
|
||||
(heads[1]->scroller_proportion + heads[0]->scroller_proportion >=
|
||||
1.0f))) {
|
||||
need_scroller = true;
|
||||
} else if (!over_overspread_to_left &&
|
||||
(!INSIDEMON(heads[focus_index - 1]->client) ||
|
||||
(heads[focus_index - 1]->scroller_proportion +
|
||||
heads[focus_index]->scroller_proportion >=
|
||||
1.0f))) {
|
||||
need_scroller = true;
|
||||
} else {
|
||||
need_apply_overspread = false;
|
||||
}
|
||||
}
|
||||
|
||||
bool need_apply_center =
|
||||
config.scroller_focus_center || n_heads == 1 ||
|
||||
(config.scroller_prefer_center && !need_apply_overspread &&
|
||||
(!m->prevsel ||
|
||||
(ISSCROLLTILED(m->prevsel) &&
|
||||
(m->prevsel->scroller_proportion * max_client_width) +
|
||||
(heads[focus_index]->scroller_proportion *
|
||||
max_client_width) >
|
||||
m->w.width - 2 * config.scroller_structs - cur_gappih)));
|
||||
|
||||
if (n_heads == 1 && config.scroller_ignore_proportion_single) {
|
||||
need_scroller = true;
|
||||
}
|
||||
if (start_drag_window)
|
||||
need_scroller = false;
|
||||
|
||||
struct wlr_box target_geom;
|
||||
target_geom.height = m->w.height - 2 * cur_gappov;
|
||||
target_geom.width =
|
||||
max_client_width * heads[focus_index]->scroller_proportion;
|
||||
target_geom.y = m->w.y + (m->w.height - target_geom.height) / 2;
|
||||
horizontal_scroll_adjust_fullandmax(heads[focus_index]->client,
|
||||
&target_geom);
|
||||
|
||||
if (heads[focus_index]->client->isfullscreen) {
|
||||
target_geom.x = m->m.x;
|
||||
horizontal_check_scroller_root_inside_mon(heads[focus_index]->client,
|
||||
&target_geom);
|
||||
arrange_stack_node(heads[focus_index], target_geom, cur_gappiv);
|
||||
} else if (heads[focus_index]->client->ismaximizescreen) {
|
||||
target_geom.x = m->w.x + cur_gappoh;
|
||||
horizontal_check_scroller_root_inside_mon(heads[focus_index]->client,
|
||||
&target_geom);
|
||||
arrange_stack_node(heads[focus_index], target_geom, cur_gappiv);
|
||||
} else if (need_scroller) {
|
||||
if (need_apply_center) {
|
||||
target_geom.x = m->w.x + (m->w.width - target_geom.width) / 2;
|
||||
} else if (need_apply_overspread) {
|
||||
if (over_overspread_to_left) {
|
||||
target_geom.x = m->w.x + config.scroller_structs;
|
||||
} else {
|
||||
target_geom.x =
|
||||
m->w.x + (m->w.width -
|
||||
heads[focus_index]->scroller_proportion *
|
||||
max_client_width -
|
||||
config.scroller_structs);
|
||||
}
|
||||
} else {
|
||||
target_geom.x =
|
||||
root_client->geom.x > m->w.x + (m->w.width) / 2
|
||||
? m->w.x + (m->w.width -
|
||||
heads[focus_index]->scroller_proportion *
|
||||
max_client_width -
|
||||
config.scroller_structs)
|
||||
: m->w.x + config.scroller_structs;
|
||||
}
|
||||
horizontal_check_scroller_root_inside_mon(heads[focus_index]->client,
|
||||
&target_geom);
|
||||
arrange_stack_node(heads[focus_index], target_geom, cur_gappiv);
|
||||
} else {
|
||||
target_geom.x = root_client->geom.x;
|
||||
horizontal_check_scroller_root_inside_mon(heads[focus_index]->client,
|
||||
&target_geom);
|
||||
arrange_stack_node(heads[focus_index], target_geom, cur_gappiv);
|
||||
}
|
||||
|
||||
/* 排列左侧的堆叠 */
|
||||
for (int i = 1; i <= focus_index; i++) {
|
||||
struct ScrollerStackNode *cur = heads[focus_index - i];
|
||||
struct wlr_box left_geom;
|
||||
left_geom.height = m->w.height - 2 * cur_gappov;
|
||||
left_geom.width = max_client_width * cur->scroller_proportion;
|
||||
horizontal_scroll_adjust_fullandmax(cur->client, &left_geom);
|
||||
left_geom.x = heads[focus_index - i + 1]->client->geom.x - cur_gappih -
|
||||
left_geom.width;
|
||||
arrange_stack_node(cur, left_geom, cur_gappiv);
|
||||
}
|
||||
|
||||
/* 排列右侧的堆叠 */
|
||||
for (int i = 1; i < n_heads - focus_index; i++) {
|
||||
struct ScrollerStackNode *cur = heads[focus_index + i];
|
||||
struct wlr_box right_geom;
|
||||
right_geom.height = m->w.height - 2 * cur_gappov;
|
||||
right_geom.width = max_client_width * cur->scroller_proportion;
|
||||
horizontal_scroll_adjust_fullandmax(cur->client, &right_geom);
|
||||
right_geom.x = heads[focus_index + i - 1]->client->geom.x + cur_gappih +
|
||||
heads[focus_index + i - 1]->client->geom.width;
|
||||
arrange_stack_node(cur, right_geom, cur_gappiv);
|
||||
}
|
||||
|
||||
sync_scroller_state_to_clients(m, tag);
|
||||
}
|
||||
|
||||
void vertical_scroller(Monitor *m) {
|
||||
uint32_t tag = m->pertag->curtag;
|
||||
struct TagScrollerState *st = ensure_scroller_state(m, tag);
|
||||
Client *c = NULL;
|
||||
|
||||
/* 按全局顺序收集堆叠头 */
|
||||
struct ScrollerStackNode *heads[64];
|
||||
int32_t n_heads = 0;
|
||||
wl_list_for_each(c, &clients, link) {
|
||||
if (VISIBLEON(c, m) && ISSCROLLTILED(c)) {
|
||||
struct ScrollerStackNode *node = find_scroller_node(st, c);
|
||||
if (node && !node->prev_in_stack) {
|
||||
bool already = false;
|
||||
for (int k = 0; k < n_heads; k++)
|
||||
if (heads[k] == node)
|
||||
already = true;
|
||||
if (!already)
|
||||
heads[n_heads++] = node;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (n_heads == 0) {
|
||||
sync_scroller_state_to_clients(m, tag);
|
||||
return;
|
||||
}
|
||||
|
||||
m->visible_scroll_tiling_clients = n_heads;
|
||||
|
||||
int32_t cur_gappiv = enablegaps ? m->gappiv : 0;
|
||||
int32_t cur_gappov = enablegaps ? m->gappov : 0;
|
||||
int32_t cur_gappoh = enablegaps ? m->gappoh : 0;
|
||||
int32_t cur_gappih = enablegaps ? m->gappih : 0;
|
||||
if (config.smartgaps && n_heads == 1) {
|
||||
cur_gappiv = cur_gappov = cur_gappoh = 0;
|
||||
}
|
||||
int32_t max_client_height =
|
||||
m->w.height - 2 * config.scroller_structs - cur_gappiv;
|
||||
|
||||
if (n_heads == 1 && !config.scroller_ignore_proportion_single &&
|
||||
!heads[0]->client->isfullscreen &&
|
||||
!heads[0]->client->ismaximizescreen) {
|
||||
struct ScrollerStackNode *head = heads[0];
|
||||
float single_proportion =
|
||||
head->scroller_proportion_single > 0.0f
|
||||
? head->scroller_proportion_single
|
||||
: config.scroller_default_proportion_single;
|
||||
struct wlr_box target_geom;
|
||||
target_geom.width = m->w.width - 2 * cur_gappoh;
|
||||
target_geom.height = (m->w.height - 2 * cur_gappov) * single_proportion;
|
||||
target_geom.y = m->w.y + (m->w.height - target_geom.height) / 2;
|
||||
target_geom.x = m->w.x + (m->w.width - target_geom.width) / 2;
|
||||
vertical_check_scroller_root_inside_mon(head->client, &target_geom);
|
||||
arrange_stack_vertical_node(head, target_geom, cur_gappih);
|
||||
sync_scroller_state_to_clients(m, tag);
|
||||
return;
|
||||
}
|
||||
|
||||
struct ScrollerStackNode *root_node = NULL;
|
||||
if (m->sel && ISSCROLLTILED(m->sel)) {
|
||||
root_node = find_scroller_node(st, m->sel);
|
||||
if (root_node) {
|
||||
while (root_node->prev_in_stack)
|
||||
root_node = root_node->prev_in_stack;
|
||||
}
|
||||
}
|
||||
if (!root_node && m->prevsel && ISSCROLLTILED(m->prevsel)) {
|
||||
root_node = find_scroller_node(st, m->prevsel);
|
||||
if (root_node) {
|
||||
while (root_node->prev_in_stack)
|
||||
root_node = root_node->prev_in_stack;
|
||||
}
|
||||
}
|
||||
if (!root_node)
|
||||
root_node = heads[n_heads / 2];
|
||||
|
||||
int32_t focus_index = -1;
|
||||
for (int i = 0; i < n_heads; i++) {
|
||||
if (heads[i] == root_node) {
|
||||
focus_index = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (focus_index < 0)
|
||||
focus_index = n_heads / 2;
|
||||
|
||||
bool need_scroller = false;
|
||||
bool over_overspread_to_up = false;
|
||||
Client *root_client = root_node->client;
|
||||
|
||||
if (root_client->geom.y >= m->w.y + config.scroller_structs &&
|
||||
root_client->geom.y + root_client->geom.height <=
|
||||
m->w.y + m->w.height - config.scroller_structs) {
|
||||
need_scroller = false;
|
||||
} else {
|
||||
need_scroller = true;
|
||||
}
|
||||
|
||||
bool need_apply_overspread =
|
||||
config.scroller_prefer_overspread && n_heads > 1 &&
|
||||
(focus_index == 0 || focus_index == n_heads - 1) &&
|
||||
heads[focus_index]->scroller_proportion < 1.0f;
|
||||
|
||||
if (need_apply_overspread) {
|
||||
if (focus_index == 0) {
|
||||
over_overspread_to_up = true;
|
||||
} else {
|
||||
over_overspread_to_up = false;
|
||||
}
|
||||
if (over_overspread_to_up &&
|
||||
(!INSIDEMON(heads[1]->client) ||
|
||||
(heads[1]->scroller_proportion + heads[0]->scroller_proportion >=
|
||||
1.0f))) {
|
||||
need_scroller = true;
|
||||
} else if (!over_overspread_to_up &&
|
||||
(!INSIDEMON(heads[focus_index - 1]->client) ||
|
||||
(heads[focus_index - 1]->scroller_proportion +
|
||||
heads[focus_index]->scroller_proportion >=
|
||||
1.0f))) {
|
||||
need_scroller = true;
|
||||
} else {
|
||||
need_apply_overspread = false;
|
||||
}
|
||||
}
|
||||
|
||||
bool need_apply_center =
|
||||
config.scroller_focus_center || n_heads == 1 ||
|
||||
(config.scroller_prefer_center && !need_apply_overspread &&
|
||||
(!m->prevsel ||
|
||||
(ISSCROLLTILED(m->prevsel) &&
|
||||
(m->prevsel->scroller_proportion * max_client_height) +
|
||||
(heads[focus_index]->scroller_proportion *
|
||||
max_client_height) >
|
||||
m->w.height - 2 * config.scroller_structs - cur_gappiv)));
|
||||
|
||||
if (n_heads == 1 && config.scroller_ignore_proportion_single) {
|
||||
need_scroller = true;
|
||||
}
|
||||
if (start_drag_window)
|
||||
need_scroller = false;
|
||||
|
||||
struct wlr_box target_geom;
|
||||
target_geom.width = m->w.width - 2 * cur_gappoh;
|
||||
target_geom.height =
|
||||
max_client_height * heads[focus_index]->scroller_proportion;
|
||||
target_geom.x = m->w.x + (m->w.width - target_geom.width) / 2;
|
||||
vertical_scroll_adjust_fullandmax(heads[focus_index]->client, &target_geom);
|
||||
|
||||
if (heads[focus_index]->client->isfullscreen) {
|
||||
target_geom.y = m->m.y;
|
||||
vertical_check_scroller_root_inside_mon(heads[focus_index]->client,
|
||||
&target_geom);
|
||||
arrange_stack_vertical_node(heads[focus_index], target_geom,
|
||||
cur_gappih);
|
||||
} else if (heads[focus_index]->client->ismaximizescreen) {
|
||||
target_geom.y = m->w.y + cur_gappov;
|
||||
vertical_check_scroller_root_inside_mon(heads[focus_index]->client,
|
||||
&target_geom);
|
||||
arrange_stack_vertical_node(heads[focus_index], target_geom,
|
||||
cur_gappih);
|
||||
} else if (need_scroller) {
|
||||
if (need_apply_center) {
|
||||
target_geom.y = m->w.y + (m->w.height - target_geom.height) / 2;
|
||||
} else if (need_apply_overspread) {
|
||||
if (over_overspread_to_up) {
|
||||
target_geom.y = m->w.y + config.scroller_structs;
|
||||
} else {
|
||||
target_geom.y =
|
||||
m->w.y + (m->w.height -
|
||||
heads[focus_index]->scroller_proportion *
|
||||
max_client_height -
|
||||
config.scroller_structs);
|
||||
}
|
||||
} else {
|
||||
target_geom.y =
|
||||
root_client->geom.y > m->w.y + (m->w.height) / 2
|
||||
? m->w.y + (m->w.height -
|
||||
heads[focus_index]->scroller_proportion *
|
||||
max_client_height -
|
||||
config.scroller_structs)
|
||||
: m->w.y + config.scroller_structs;
|
||||
}
|
||||
vertical_check_scroller_root_inside_mon(heads[focus_index]->client,
|
||||
&target_geom);
|
||||
arrange_stack_vertical_node(heads[focus_index], target_geom,
|
||||
cur_gappih);
|
||||
} else {
|
||||
target_geom.y = root_client->geom.y;
|
||||
vertical_check_scroller_root_inside_mon(heads[focus_index]->client,
|
||||
&target_geom);
|
||||
arrange_stack_vertical_node(heads[focus_index], target_geom,
|
||||
cur_gappih);
|
||||
}
|
||||
|
||||
for (int i = 1; i <= focus_index; i++) {
|
||||
struct ScrollerStackNode *cur = heads[focus_index - i];
|
||||
struct wlr_box up_geom;
|
||||
up_geom.width = m->w.width - 2 * cur_gappoh;
|
||||
up_geom.height = max_client_height * cur->scroller_proportion;
|
||||
vertical_scroll_adjust_fullandmax(cur->client, &up_geom);
|
||||
up_geom.y = heads[focus_index - i + 1]->client->geom.y - cur_gappiv -
|
||||
up_geom.height;
|
||||
arrange_stack_vertical_node(cur, up_geom, cur_gappih);
|
||||
}
|
||||
|
||||
for (int i = 1; i < n_heads - focus_index; i++) {
|
||||
struct ScrollerStackNode *cur = heads[focus_index + i];
|
||||
struct wlr_box down_geom;
|
||||
down_geom.width = m->w.width - 2 * cur_gappoh;
|
||||
down_geom.height = max_client_height * cur->scroller_proportion;
|
||||
vertical_scroll_adjust_fullandmax(cur->client, &down_geom);
|
||||
down_geom.y = heads[focus_index + i - 1]->client->geom.y + cur_gappiv +
|
||||
heads[focus_index + i - 1]->client->geom.height;
|
||||
arrange_stack_vertical_node(cur, down_geom, cur_gappih);
|
||||
}
|
||||
|
||||
sync_scroller_state_to_clients(m, tag);
|
||||
}
|
||||
|
||||
void scroller_remove_client(Client *c) {
|
||||
Monitor *m;
|
||||
wl_list_for_each(m, &mons, link) {
|
||||
for (uint32_t t = 0; t < LENGTH(tags) + 1; t++) {
|
||||
struct TagScrollerState *st = m->pertag->scroller_state[t];
|
||||
if (!st)
|
||||
continue;
|
||||
struct ScrollerStackNode *node = find_scroller_node(st, c);
|
||||
if (node) {
|
||||
scroller_node_remove(st, node);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void scroller_insert_stack(Client *c, Client *target_client,
|
||||
bool insert_before) {
|
||||
if (!target_client || target_client->mon != c->mon)
|
||||
return;
|
||||
|
||||
if (c->isfullscreen)
|
||||
setfullscreen(c, 0);
|
||||
if (c->ismaximizescreen)
|
||||
setmaximizescreen(c, 0);
|
||||
|
||||
Monitor *m = c->mon;
|
||||
uint32_t tag = m->pertag->curtag;
|
||||
struct TagScrollerState *st = ensure_scroller_state(m, tag);
|
||||
|
||||
struct ScrollerStackNode *cnode = find_scroller_node(st, c);
|
||||
if (cnode)
|
||||
scroller_node_remove(st, cnode);
|
||||
|
||||
struct ScrollerStackNode *tnode = find_scroller_node(st, target_client);
|
||||
if (!tnode)
|
||||
tnode = scroller_node_create(st, target_client);
|
||||
|
||||
struct ScrollerStackNode *newnode = scroller_node_create(st, c);
|
||||
/* 将新节点插入到 tnode 的前面或后面 */
|
||||
if (insert_before) {
|
||||
newnode->next_in_stack = tnode;
|
||||
newnode->prev_in_stack = tnode->prev_in_stack;
|
||||
if (tnode->prev_in_stack)
|
||||
tnode->prev_in_stack->next_in_stack = newnode;
|
||||
tnode->prev_in_stack = newnode;
|
||||
} else {
|
||||
newnode->prev_in_stack = tnode;
|
||||
newnode->next_in_stack = tnode->next_in_stack;
|
||||
if (tnode->next_in_stack)
|
||||
tnode->next_in_stack->prev_in_stack = newnode;
|
||||
tnode->next_in_stack = newnode;
|
||||
}
|
||||
|
||||
/* 处理堆叠头部的全屏/最大化状态*/
|
||||
struct ScrollerStackNode *head = tnode;
|
||||
while (head->prev_in_stack)
|
||||
head = head->prev_in_stack;
|
||||
Client *stack_head = head->client;
|
||||
if (stack_head->ismaximizescreen)
|
||||
setmaximizescreen(stack_head, 0);
|
||||
if (stack_head->isfullscreen)
|
||||
setfullscreen(stack_head, 0);
|
||||
|
||||
/* 同步到 Client 字段 */
|
||||
sync_scroller_state_to_clients(m, tag);
|
||||
|
||||
arrange(m, false, false);
|
||||
}
|
||||
|
||||
void scroller_drop_tile(Client *c, Client *closest, int vertical) {
|
||||
|
||||
Client *stack_head = scroll_get_stack_head_client(closest);
|
||||
|
||||
if (vertical) {
|
||||
if (closest->drop_direction == LEFT) {
|
||||
setfloating(c, 0);
|
||||
scroller_insert_stack(c, closest, true);
|
||||
return;
|
||||
} else if (closest->drop_direction == RIGHT) {
|
||||
setfloating(c, 0);
|
||||
scroller_insert_stack(c, closest, false);
|
||||
return;
|
||||
} else if (closest->drop_direction == UP) {
|
||||
wl_list_remove(&c->link);
|
||||
wl_list_insert(stack_head->link.prev, &c->link);
|
||||
} else if (closest->drop_direction == DOWN) {
|
||||
wl_list_remove(&c->link);
|
||||
wl_list_insert(&stack_head->link, &c->link);
|
||||
}
|
||||
} else {
|
||||
if (closest->drop_direction == UP) {
|
||||
setfloating(c, 0);
|
||||
scroller_insert_stack(c, closest, true);
|
||||
return;
|
||||
} else if (closest->drop_direction == DOWN) {
|
||||
setfloating(c, 0);
|
||||
scroller_insert_stack(c, closest, false);
|
||||
return;
|
||||
} else if (closest->drop_direction == LEFT) {
|
||||
wl_list_remove(&c->link);
|
||||
wl_list_insert(stack_head->link.prev, &c->link);
|
||||
} else if (closest->drop_direction == RIGHT) {
|
||||
wl_list_remove(&c->link);
|
||||
wl_list_insert(&stack_head->link, &c->link);
|
||||
}
|
||||
}
|
||||
|
||||
setfloating(c, 0);
|
||||
}
|
||||
|
||||
Client *scroll_get_stack_head_client(Client *c) {
|
||||
if (!c || !c->mon)
|
||||
return c;
|
||||
uint32_t tag = c->mon->pertag->curtag;
|
||||
struct TagScrollerState *st = c->mon->pertag->scroller_state[tag];
|
||||
if (st) {
|
||||
struct ScrollerStackNode *n = find_scroller_node(st, c);
|
||||
if (n) {
|
||||
while (n->prev_in_stack)
|
||||
n = n->prev_in_stack;
|
||||
return n->client;
|
||||
}
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
static void update_scroller_state(Monitor *m) {
|
||||
uint32_t tag = m->pertag->curtag;
|
||||
struct TagScrollerState *st = ensure_scroller_state(m, tag);
|
||||
|
||||
/* 收集当前可见的所有 scroller 平铺窗口 */
|
||||
Client *vis[512];
|
||||
int32_t count = 0;
|
||||
Client *c;
|
||||
wl_list_for_each(c, &clients, link) {
|
||||
if (VISIBLEON(c, m) && ISSCROLLTILED(c))
|
||||
vis[count++] = c;
|
||||
if (count == 512)
|
||||
break;
|
||||
}
|
||||
|
||||
/* 移除不再可见的节点 */
|
||||
struct ScrollerStackNode *n = st->all_first;
|
||||
while (n) {
|
||||
bool found = false;
|
||||
for (int i = 0; i < count; i++) {
|
||||
if (vis[i] == n->client) {
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
struct ScrollerStackNode *next = n->all_next;
|
||||
if (!found)
|
||||
scroller_node_remove(st, n);
|
||||
n = next;
|
||||
}
|
||||
|
||||
/* 为新的可见窗口创建节点 */
|
||||
for (int i = 0; i < count; i++) {
|
||||
if (!find_scroller_node(st, vis[i])) {
|
||||
scroller_node_create(st, vis[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -176,324 +176,6 @@ void vertical_deck(Monitor *m) {
|
|||
}
|
||||
}
|
||||
|
||||
void vertical_scroll_adjust_fullandmax(Client *c, struct wlr_box *target_geom) {
|
||||
Monitor *m = c->mon;
|
||||
int32_t cur_gappiv = enablegaps ? m->gappiv : 0;
|
||||
int32_t cur_gappov = enablegaps ? m->gappov : 0;
|
||||
int32_t cur_gappoh = enablegaps ? m->gappoh : 0;
|
||||
|
||||
cur_gappiv = config.smartgaps && m->visible_scroll_tiling_clients == 1
|
||||
? 0
|
||||
: cur_gappiv;
|
||||
cur_gappov = config.smartgaps && m->visible_scroll_tiling_clients == 1
|
||||
? 0
|
||||
: cur_gappov;
|
||||
cur_gappoh = config.smartgaps && m->visible_scroll_tiling_clients == 1
|
||||
? 0
|
||||
: cur_gappoh;
|
||||
|
||||
if (c->isfullscreen) {
|
||||
target_geom->width = m->m.width;
|
||||
target_geom->height = m->m.height;
|
||||
target_geom->x = m->m.x;
|
||||
return;
|
||||
}
|
||||
|
||||
if (c->ismaximizescreen) {
|
||||
target_geom->width = m->w.width - 2 * cur_gappoh;
|
||||
target_geom->height = m->w.height - 2 * cur_gappov;
|
||||
target_geom->x = m->w.x + cur_gappoh;
|
||||
return;
|
||||
}
|
||||
|
||||
target_geom->width = m->w.width - 2 * cur_gappoh;
|
||||
target_geom->x = m->w.x + (m->w.width - target_geom->width) / 2;
|
||||
}
|
||||
|
||||
void arrange_stack_vertical(Client *scroller_stack_head,
|
||||
struct wlr_box geometry, int32_t gappih) {
|
||||
int32_t stack_size = 0;
|
||||
Client *iter = scroller_stack_head;
|
||||
|
||||
while (iter) {
|
||||
stack_size++;
|
||||
iter = iter->next_in_stack;
|
||||
}
|
||||
|
||||
if (stack_size == 0)
|
||||
return;
|
||||
|
||||
float total_proportion = 0.0f;
|
||||
iter = scroller_stack_head;
|
||||
while (iter) {
|
||||
if (iter->stack_proportion <= 0.0f || iter->stack_proportion >= 1.0f) {
|
||||
iter->stack_proportion =
|
||||
stack_size == 1 ? 1.0f : 1.0f / (stack_size - 1);
|
||||
}
|
||||
total_proportion += iter->stack_proportion;
|
||||
iter = iter->next_in_stack;
|
||||
}
|
||||
|
||||
iter = scroller_stack_head;
|
||||
while (iter) {
|
||||
iter->stack_proportion = iter->stack_proportion / total_proportion;
|
||||
iter = iter->next_in_stack;
|
||||
}
|
||||
|
||||
int32_t client_width;
|
||||
int32_t current_x = geometry.x;
|
||||
int32_t remain_client_width = geometry.width - (stack_size - 1) * gappih;
|
||||
float remain_proportion = 1.0f;
|
||||
|
||||
iter = scroller_stack_head;
|
||||
while (iter) {
|
||||
|
||||
client_width =
|
||||
remain_client_width * (iter->stack_proportion / remain_proportion);
|
||||
|
||||
struct wlr_box client_geom = {.y = geometry.y,
|
||||
.x = current_x,
|
||||
.height = geometry.height,
|
||||
.width = client_width};
|
||||
resize(iter, client_geom, 0);
|
||||
remain_proportion -= iter->stack_proportion;
|
||||
remain_client_width -= client_width;
|
||||
current_x += client_width + gappih;
|
||||
iter = iter->next_in_stack;
|
||||
}
|
||||
}
|
||||
|
||||
void vertical_check_scroller_root_inside_mon(Client *c,
|
||||
struct wlr_box *geometry) {
|
||||
if (!GEOMINSIDEMON(geometry, c->mon)) {
|
||||
geometry->y = c->mon->w.y + (c->mon->w.height - geometry->height) / 2;
|
||||
}
|
||||
}
|
||||
|
||||
// 竖屏滚动布局
|
||||
void vertical_scroller(Monitor *m) {
|
||||
int32_t i, n, j;
|
||||
float single_proportion = 1.0;
|
||||
|
||||
Client *c = NULL, *root_client = NULL;
|
||||
Client **tempClients = NULL;
|
||||
struct wlr_box target_geom;
|
||||
int32_t focus_client_index = 0;
|
||||
bool need_scroller = false;
|
||||
bool over_overspread_to_up = false;
|
||||
int32_t cur_gappiv = enablegaps ? m->gappiv : 0;
|
||||
int32_t cur_gappov = enablegaps ? m->gappov : 0;
|
||||
int32_t cur_gappoh = enablegaps ? m->gappoh : 0;
|
||||
int32_t cur_gappih = enablegaps ? m->gappih : 0;
|
||||
|
||||
cur_gappiv = config.smartgaps && m->visible_scroll_tiling_clients == 1
|
||||
? 0
|
||||
: cur_gappiv;
|
||||
cur_gappov = config.smartgaps && m->visible_scroll_tiling_clients == 1
|
||||
? 0
|
||||
: cur_gappov;
|
||||
cur_gappoh = config.smartgaps && m->visible_scroll_tiling_clients == 1
|
||||
? 0
|
||||
: cur_gappoh;
|
||||
|
||||
int32_t max_client_height =
|
||||
m->w.height - 2 * config.scroller_structs - cur_gappiv;
|
||||
|
||||
n = m->visible_scroll_tiling_clients;
|
||||
|
||||
if (n == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
tempClients = malloc(n * sizeof(Client *));
|
||||
if (!tempClients) {
|
||||
return;
|
||||
}
|
||||
|
||||
j = 0;
|
||||
wl_list_for_each(c, &clients, link) {
|
||||
if (VISIBLEON(c, m) && ISSCROLLTILED(c) && !c->prev_in_stack) {
|
||||
tempClients[j] = c;
|
||||
j++;
|
||||
}
|
||||
}
|
||||
|
||||
if (n == 1 && !config.scroller_ignore_proportion_single &&
|
||||
!tempClients[0]->isfullscreen && !tempClients[0]->ismaximizescreen) {
|
||||
c = tempClients[0];
|
||||
|
||||
single_proportion = c->scroller_proportion_single > 0.0f
|
||||
? c->scroller_proportion_single
|
||||
: config.scroller_default_proportion_single;
|
||||
|
||||
target_geom.width = m->w.width - 2 * cur_gappoh;
|
||||
target_geom.height = (m->w.height - 2 * cur_gappov) * single_proportion;
|
||||
target_geom.y = m->w.y + (m->w.height - target_geom.height) / 2;
|
||||
target_geom.x = m->w.x + (m->w.width - target_geom.width) / 2;
|
||||
vertical_check_scroller_root_inside_mon(c, &target_geom);
|
||||
arrange_stack_vertical(c, target_geom, cur_gappih);
|
||||
free(tempClients);
|
||||
return;
|
||||
}
|
||||
|
||||
if (m->sel && !client_is_unmanaged(m->sel) && ISSCROLLTILED(m->sel)) {
|
||||
root_client = m->sel;
|
||||
} else if (m->prevsel && ISSCROLLTILED(m->prevsel) &&
|
||||
VISIBLEON(m->prevsel, m) && !client_is_unmanaged(m->prevsel)) {
|
||||
root_client = m->prevsel;
|
||||
} else {
|
||||
root_client = center_tiled_select(m);
|
||||
}
|
||||
|
||||
// root_client might be in a stack, find the stack head
|
||||
if (root_client) {
|
||||
root_client = get_scroll_stack_head(root_client);
|
||||
}
|
||||
|
||||
if (!root_client) {
|
||||
free(tempClients);
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = 0; i < n; i++) {
|
||||
c = tempClients[i];
|
||||
if (root_client == c) {
|
||||
if (c->geom.y >= m->w.y + config.scroller_structs &&
|
||||
c->geom.y + c->geom.height <=
|
||||
m->w.y + m->w.height - config.scroller_structs) {
|
||||
need_scroller = false;
|
||||
} else {
|
||||
need_scroller = true;
|
||||
}
|
||||
focus_client_index = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
bool need_apply_overspread =
|
||||
config.scroller_prefer_overspread &&
|
||||
m->visible_scroll_tiling_clients > 1 &&
|
||||
(focus_client_index == 0 || focus_client_index == n - 1) &&
|
||||
tempClients[focus_client_index]->scroller_proportion < 1.0f;
|
||||
|
||||
if (need_apply_overspread) {
|
||||
|
||||
if (focus_client_index == 0) {
|
||||
over_overspread_to_up = true;
|
||||
} else {
|
||||
over_overspread_to_up = false;
|
||||
}
|
||||
|
||||
if (over_overspread_to_up &&
|
||||
(!INSIDEMON(tempClients[1]) ||
|
||||
(tempClients[1]->scroller_proportion +
|
||||
tempClients[focus_client_index]->scroller_proportion >=
|
||||
1.0f))) {
|
||||
need_scroller = true;
|
||||
} else if (!over_overspread_to_up &&
|
||||
(!INSIDEMON(tempClients[focus_client_index - 1]) ||
|
||||
(tempClients[focus_client_index - 1]->scroller_proportion +
|
||||
tempClients[focus_client_index]->scroller_proportion >=
|
||||
1.0f))) {
|
||||
need_scroller = true;
|
||||
} else {
|
||||
need_apply_overspread = false;
|
||||
}
|
||||
}
|
||||
|
||||
bool need_apply_center =
|
||||
config.scroller_focus_center || m->visible_scroll_tiling_clients == 1 ||
|
||||
(config.scroller_prefer_center && !need_apply_overspread &&
|
||||
(!m->prevsel ||
|
||||
(ISSCROLLTILED(m->prevsel) &&
|
||||
(m->prevsel->scroller_proportion * max_client_height) +
|
||||
(tempClients[focus_client_index]->scroller_proportion *
|
||||
max_client_height) >
|
||||
m->w.height - 2 * config.scroller_structs - cur_gappiv)));
|
||||
|
||||
if (n == 1 && config.scroller_ignore_proportion_single) {
|
||||
need_scroller = true;
|
||||
}
|
||||
|
||||
if (start_drag_window)
|
||||
need_scroller = false;
|
||||
|
||||
target_geom.width = m->w.width - 2 * cur_gappoh;
|
||||
target_geom.height = max_client_height * c->scroller_proportion;
|
||||
target_geom.x = m->w.x + (m->w.width - target_geom.width) / 2;
|
||||
vertical_scroll_adjust_fullandmax(tempClients[focus_client_index],
|
||||
&target_geom);
|
||||
|
||||
if (tempClients[focus_client_index]->isfullscreen) {
|
||||
target_geom.y = m->m.y;
|
||||
vertical_check_scroller_root_inside_mon(tempClients[focus_client_index],
|
||||
&target_geom);
|
||||
arrange_stack_vertical(tempClients[focus_client_index], target_geom,
|
||||
cur_gappih);
|
||||
} else if (tempClients[focus_client_index]->ismaximizescreen) {
|
||||
target_geom.y = m->w.y + cur_gappov;
|
||||
vertical_check_scroller_root_inside_mon(tempClients[focus_client_index],
|
||||
&target_geom);
|
||||
arrange_stack_vertical(tempClients[focus_client_index], target_geom,
|
||||
cur_gappih);
|
||||
} else if (need_scroller) {
|
||||
if (need_apply_center) {
|
||||
target_geom.y = m->w.y + (m->w.height - target_geom.height) / 2;
|
||||
} else if (need_apply_overspread) {
|
||||
if (over_overspread_to_up) {
|
||||
target_geom.y = m->w.y + config.scroller_structs;
|
||||
} else {
|
||||
target_geom.y =
|
||||
m->w.y +
|
||||
(m->w.height -
|
||||
tempClients[focus_client_index]->scroller_proportion *
|
||||
max_client_height -
|
||||
config.scroller_structs);
|
||||
}
|
||||
} else {
|
||||
target_geom.y = root_client->geom.y > m->w.y + (m->w.height) / 2
|
||||
? m->w.y + (m->w.height -
|
||||
tempClients[focus_client_index]
|
||||
->scroller_proportion *
|
||||
max_client_height -
|
||||
config.scroller_structs)
|
||||
: m->w.y + config.scroller_structs;
|
||||
}
|
||||
vertical_check_scroller_root_inside_mon(tempClients[focus_client_index],
|
||||
&target_geom);
|
||||
arrange_stack_vertical(tempClients[focus_client_index], target_geom,
|
||||
cur_gappih);
|
||||
} else {
|
||||
target_geom.y = c->geom.y;
|
||||
vertical_check_scroller_root_inside_mon(tempClients[focus_client_index],
|
||||
&target_geom);
|
||||
arrange_stack_vertical(tempClients[focus_client_index], target_geom,
|
||||
cur_gappih);
|
||||
}
|
||||
|
||||
for (i = 1; i <= focus_client_index; i++) {
|
||||
c = tempClients[focus_client_index - i];
|
||||
target_geom.height = max_client_height * c->scroller_proportion;
|
||||
vertical_scroll_adjust_fullandmax(c, &target_geom);
|
||||
target_geom.y = tempClients[focus_client_index - i + 1]->geom.y -
|
||||
cur_gappiv - target_geom.height;
|
||||
|
||||
arrange_stack_vertical(c, target_geom, cur_gappih);
|
||||
}
|
||||
|
||||
for (i = 1; i < n - focus_client_index; i++) {
|
||||
c = tempClients[focus_client_index + i];
|
||||
target_geom.height = max_client_height * c->scroller_proportion;
|
||||
vertical_scroll_adjust_fullandmax(c, &target_geom);
|
||||
target_geom.y = tempClients[focus_client_index + i - 1]->geom.y +
|
||||
cur_gappiv +
|
||||
tempClients[focus_client_index + i - 1]->geom.height;
|
||||
arrange_stack_vertical(c, target_geom, cur_gappih);
|
||||
}
|
||||
|
||||
free(tempClients);
|
||||
}
|
||||
|
||||
void vertical_grid(Monitor *m) {
|
||||
int32_t i, n;
|
||||
int32_t cx, cy, cw, ch;
|
||||
|
|
|
|||
438
src/mango.c
438
src/mango.c
|
|
@ -112,7 +112,9 @@
|
|||
(A && !(A)->isfloating && !(A)->isminimized && !(A)->iskilling && \
|
||||
!(A)->isunglobal)
|
||||
#define VISIBLEON(C, M) \
|
||||
((C) && (M) && (C)->mon == (M) && ((C)->tags & (M)->tagset[(M)->seltags]))
|
||||
((C) && (M) && (C)->mon == (M) && \
|
||||
(((C)->tags & (M)->tagset[(M)->seltags] || (C)->isglobal || \
|
||||
(C)->isunglobal)))
|
||||
#define LENGTH(X) (sizeof X / sizeof X[0])
|
||||
#define END(A) ((A) + LENGTH(A))
|
||||
#define TAGMASK ((1 << LENGTH(tags)) - 1)
|
||||
|
|
@ -421,8 +423,6 @@ struct Client {
|
|||
int32_t allow_shortcuts_inhibit;
|
||||
float scroller_proportion_single;
|
||||
bool isfocusing;
|
||||
struct Client *next_in_stack;
|
||||
struct Client *prev_in_stack;
|
||||
bool enable_drop_area_draw;
|
||||
int32_t drop_direction;
|
||||
struct wlr_box drag_tile_float_backup_geom;
|
||||
|
|
@ -571,6 +571,21 @@ struct capture_session_tracker {
|
|||
struct wlr_ext_image_copy_capture_session_v1 *session;
|
||||
};
|
||||
typedef struct DwindleNode DwindleNode;
|
||||
struct ScrollerStackNode {
|
||||
Client *client;
|
||||
float scroller_proportion;
|
||||
float stack_proportion;
|
||||
float scroller_proportion_single;
|
||||
|
||||
struct ScrollerStackNode *next_in_stack;
|
||||
struct ScrollerStackNode *prev_in_stack;
|
||||
struct ScrollerStackNode *all_next;
|
||||
};
|
||||
|
||||
struct TagScrollerState {
|
||||
struct ScrollerStackNode *all_first; /* 所有节点的单链表头 */
|
||||
int count;
|
||||
};
|
||||
|
||||
/* function declarations */
|
||||
static void applybounds(
|
||||
|
|
@ -807,7 +822,7 @@ static void request_fresh_all_monitors(void);
|
|||
static Client *find_client_by_direction(Client *tc, const Arg *arg,
|
||||
bool findfloating, bool ignore_align);
|
||||
static void exit_scroller_stack(Client *c);
|
||||
static Client *get_scroll_stack_head(Client *c);
|
||||
static Client *scroll_get_stack_head_client(Client *c);
|
||||
static bool client_only_in_one_tag(Client *c);
|
||||
static Client *get_focused_stack_client(Client *sc);
|
||||
static bool client_is_in_same_stack(Client *sc, Client *tc, Client *fc);
|
||||
|
|
@ -834,6 +849,16 @@ static void dwindle_resize_client_step(Monitor *m, Client *c, int32_t dx,
|
|||
int32_t dy);
|
||||
static void dwindle_resize_client(Monitor *m, Client *c);
|
||||
|
||||
static struct TagScrollerState *ensure_scroller_state(Monitor *m, uint32_t tag);
|
||||
static struct ScrollerStackNode *find_scroller_node(struct TagScrollerState *st,
|
||||
Client *c);
|
||||
static void sync_scroller_state_to_clients(Monitor *m, uint32_t tag);
|
||||
static void scroller_node_remove(struct TagScrollerState *st,
|
||||
struct ScrollerStackNode *target);
|
||||
static struct ScrollerStackNode *
|
||||
scroller_node_create(struct TagScrollerState *st, Client *c);
|
||||
static void update_scroller_state(Monitor *m);
|
||||
|
||||
#include "data/static_keymap.h"
|
||||
#include "dispatch/bind_declare.h"
|
||||
#include "layout/layout.h"
|
||||
|
|
@ -963,19 +988,17 @@ static struct {
|
|||
|
||||
#include "client/client.h"
|
||||
#include "config/preset.h"
|
||||
|
||||
struct Pertag {
|
||||
uint32_t curtag, prevtag; /* current and previous tag */
|
||||
int32_t nmasters[LENGTH(tags) + 1]; /* number of windows in master area */
|
||||
float mfacts[LENGTH(tags) + 1]; /* mfacts per tag */
|
||||
int32_t no_hide[LENGTH(tags) + 1]; /* no_hide per tag */
|
||||
int32_t no_render_border[LENGTH(tags) + 1]; /* no_render_border per tag */
|
||||
int32_t open_as_floating[LENGTH(tags) + 1]; /* open_as_floating per tag */
|
||||
uint32_t curtag, prevtag;
|
||||
int32_t nmasters[LENGTH(tags) + 1];
|
||||
float mfacts[LENGTH(tags) + 1];
|
||||
int32_t no_hide[LENGTH(tags) + 1];
|
||||
int32_t no_render_border[LENGTH(tags) + 1];
|
||||
int32_t open_as_floating[LENGTH(tags) + 1];
|
||||
struct DwindleNode *dwindle_root[LENGTH(tags) + 1];
|
||||
const Layout
|
||||
*ltidxs[LENGTH(tags) + 1]; /* matrix of tags and layouts indexes */
|
||||
const Layout *ltidxs[LENGTH(tags) + 1];
|
||||
struct TagScrollerState *scroller_state[LENGTH(tags) + 1];
|
||||
};
|
||||
|
||||
#include "config/parse_config.h"
|
||||
|
||||
static struct wl_signal mango_print_status;
|
||||
|
|
@ -1048,6 +1071,7 @@ static struct wl_event_source *sync_keymap;
|
|||
#include "layout/arrange.h"
|
||||
#include "layout/dwindle.h"
|
||||
#include "layout/horizontal.h"
|
||||
#include "layout/scroll.h"
|
||||
#include "layout/vertical.h"
|
||||
|
||||
void client_change_mon(Client *c, Monitor *m) {
|
||||
|
|
@ -1176,15 +1200,12 @@ void swallow(Client *c, Client *w) {
|
|||
c->master_inner_per = w->master_inner_per;
|
||||
c->master_mfact_per = w->master_mfact_per;
|
||||
c->scroller_proportion = w->scroller_proportion;
|
||||
c->next_in_stack = w->next_in_stack;
|
||||
c->prev_in_stack = w->prev_in_stack;
|
||||
c->isglobal = w->isglobal;
|
||||
|
||||
if (w->next_in_stack)
|
||||
w->next_in_stack->prev_in_stack = c;
|
||||
if (w->prev_in_stack)
|
||||
w->prev_in_stack->next_in_stack = c;
|
||||
/* 调整 w 的邻居指针，让它们指向 c */
|
||||
c->stack_proportion = w->stack_proportion;
|
||||
|
||||
/* 全局链表替换 */
|
||||
wl_list_insert(&w->link, &c->link);
|
||||
wl_list_insert(&w->flink, &c->flink);
|
||||
|
||||
|
|
@ -1210,16 +1231,39 @@ void swallow(Client *c, Client *w) {
|
|||
client_pending_maximized_state(c, w->ismaximizescreen);
|
||||
client_pending_minimized_state(c, w->isminimized);
|
||||
|
||||
/* ---------- 跨 tag 同步：dwindle 与 scroller ---------- */
|
||||
Monitor *m;
|
||||
wl_list_for_each(m, &mons, link) {
|
||||
for (uint32_t t = 0; t < LENGTH(tags) + 1; t++) {
|
||||
/* dwindle */
|
||||
DwindleNode **root = &m->pertag->dwindle_root[t];
|
||||
dwindle_remove(root, c);
|
||||
DwindleNode *wn = dwindle_find_leaf(*root, w);
|
||||
DwindleNode *dnode = dwindle_find_leaf(*root, w);
|
||||
if (dnode)
|
||||
dnode->client = c;
|
||||
|
||||
/* scroller */
|
||||
struct TagScrollerState *st = m->pertag->scroller_state[t];
|
||||
if (!st)
|
||||
continue;
|
||||
|
||||
/* 先移除 c 在任意 tag 中的旧节点 */
|
||||
struct ScrollerStackNode *cn = find_scroller_node(st, c);
|
||||
if (cn)
|
||||
scroller_node_remove(st, cn);
|
||||
|
||||
/* 将 w 的节点（如果存在）转给 c */
|
||||
struct ScrollerStackNode *wn = find_scroller_node(st, w);
|
||||
if (wn)
|
||||
wn->client = c;
|
||||
}
|
||||
}
|
||||
|
||||
/* 同步当前活动 tag 的全局客户端字段 */
|
||||
if (c->mon) {
|
||||
uint32_t curtag = c->mon->pertag->curtag;
|
||||
sync_scroller_state_to_clients(c->mon, curtag);
|
||||
}
|
||||
}
|
||||
|
||||
bool switch_scratchpad_client_state(Client *c) {
|
||||
|
|
@ -2125,100 +2169,6 @@ Client *find_closest_tiled_client(Client *c) {
|
|||
return closest;
|
||||
}
|
||||
|
||||
void scroller_insert_stack(Client *c, Client *target_client,
|
||||
bool insert_before) {
|
||||
Client *stack_head = NULL;
|
||||
|
||||
if (!target_client || target_client->mon != c->mon) {
|
||||
return;
|
||||
} else {
|
||||
c->isglobal = target_client->isglobal = 0;
|
||||
c->isunglobal = target_client->isunglobal = 0;
|
||||
c->tags = target_client->tags = get_tags_first_tag(target_client->tags);
|
||||
}
|
||||
|
||||
if (c->isfullscreen) {
|
||||
setfullscreen(c, 0);
|
||||
}
|
||||
|
||||
if (c->ismaximizescreen) {
|
||||
setmaximizescreen(c, 0);
|
||||
}
|
||||
|
||||
exit_scroller_stack(c);
|
||||
stack_head = get_scroll_stack_head(target_client);
|
||||
|
||||
if (insert_before) {
|
||||
if (target_client->prev_in_stack) {
|
||||
target_client->prev_in_stack->next_in_stack = c;
|
||||
}
|
||||
c->prev_in_stack = target_client->prev_in_stack;
|
||||
c->next_in_stack = target_client;
|
||||
target_client->prev_in_stack = c;
|
||||
|
||||
} else {
|
||||
if (target_client->next_in_stack) {
|
||||
target_client->next_in_stack->prev_in_stack = c;
|
||||
}
|
||||
c->next_in_stack = target_client->next_in_stack;
|
||||
c->prev_in_stack = target_client;
|
||||
target_client->next_in_stack = c;
|
||||
}
|
||||
|
||||
if (stack_head->ismaximizescreen) {
|
||||
setmaximizescreen(stack_head, 0);
|
||||
}
|
||||
|
||||
if (stack_head->isfullscreen) {
|
||||
setfullscreen(stack_head, 0);
|
||||
}
|
||||
|
||||
arrange(c->mon, false, false);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
void try_scroller_drop(Client *c, Client *closest, int vertical) {
|
||||
|
||||
Client *stack_head = get_scroll_stack_head(closest);
|
||||
|
||||
if (vertical) {
|
||||
if (closest->drop_direction == LEFT) {
|
||||
setfloating(c, 0);
|
||||
scroller_insert_stack(c, closest, true);
|
||||
return;
|
||||
} else if (closest->drop_direction == RIGHT) {
|
||||
setfloating(c, 0);
|
||||
scroller_insert_stack(c, closest, false);
|
||||
return;
|
||||
} else if (closest->drop_direction == UP) {
|
||||
wl_list_remove(&c->link);
|
||||
wl_list_insert(stack_head->link.prev, &c->link);
|
||||
} else if (closest->drop_direction == DOWN) {
|
||||
wl_list_remove(&c->link);
|
||||
wl_list_insert(&stack_head->link, &c->link);
|
||||
}
|
||||
} else {
|
||||
if (closest->drop_direction == UP) {
|
||||
setfloating(c, 0);
|
||||
scroller_insert_stack(c, closest, true);
|
||||
return;
|
||||
} else if (closest->drop_direction == DOWN) {
|
||||
setfloating(c, 0);
|
||||
scroller_insert_stack(c, closest, false);
|
||||
return;
|
||||
} else if (closest->drop_direction == LEFT) {
|
||||
wl_list_remove(&c->link);
|
||||
wl_list_insert(stack_head->link.prev, &c->link);
|
||||
} else if (closest->drop_direction == RIGHT) {
|
||||
wl_list_remove(&c->link);
|
||||
wl_list_insert(&stack_head->link, &c->link);
|
||||
}
|
||||
}
|
||||
|
||||
setfloating(c, 0);
|
||||
}
|
||||
|
||||
void place_drag_tile_client(Client *c) {
|
||||
Client *closest = find_closest_tiled_client(c);
|
||||
|
||||
|
|
@ -2233,11 +2183,11 @@ void place_drag_tile_client(Client *c) {
|
|||
}
|
||||
|
||||
if (layout->id == SCROLLER) {
|
||||
try_scroller_drop(c, closest, 0);
|
||||
scroller_drop_tile(c, closest, 0);
|
||||
return;
|
||||
}
|
||||
if (layout->id == VERTICAL_SCROLLER) {
|
||||
try_scroller_drop(c, closest, 1);
|
||||
scroller_drop_tile(c, closest, 1);
|
||||
return;
|
||||
}
|
||||
if (layout->id == DWINDLE) {
|
||||
|
|
@ -2567,6 +2517,9 @@ void cleanupmon(struct wl_listener *listener, void *data) {
|
|||
|
||||
for (uint32_t t = 0; t < LENGTH(tags) + 1; t++)
|
||||
dwindle_free_tree(m->pertag->dwindle_root[t]);
|
||||
|
||||
cleanup_monitor_scroller(m);
|
||||
|
||||
free(m->pertag);
|
||||
free(m);
|
||||
}
|
||||
|
|
@ -3250,7 +3203,11 @@ void createmon(struct wl_listener *listener, void *data) {
|
|||
wlr_output_state_finish(&state);
|
||||
|
||||
wl_list_insert(&mons, &m->link);
|
||||
|
||||
m->pertag = calloc(1, sizeof(Pertag));
|
||||
for (int i = 0; i < LENGTH(tags) + 1; i++)
|
||||
m->pertag->scroller_state[i] = NULL;
|
||||
|
||||
if (chvt_backup_tag &&
|
||||
regex_match(chvt_backup_selmon, m->wlr_output->name)) {
|
||||
m->tagset[0] = m->tagset[1] = (1 << (chvt_backup_tag - 1)) & TAGMASK;
|
||||
|
|
@ -4248,8 +4205,6 @@ void init_client_properties(Client *c) {
|
|||
c->float_geom.x = 0;
|
||||
c->float_geom.y = 0;
|
||||
c->stack_proportion = 0.0f;
|
||||
c->next_in_stack = NULL;
|
||||
c->prev_in_stack = NULL;
|
||||
memset(c->oldmonname, 0, sizeof(c->oldmonname));
|
||||
memcpy(c->opacity_animation.initial_border_color, config.bordercolor,
|
||||
sizeof(c->opacity_animation.initial_border_color));
|
||||
|
|
@ -4359,7 +4314,7 @@ mapnotify(struct wl_listener *listener, void *data) {
|
|||
|
||||
if (selmon->sel && ISSCROLLTILED(selmon->sel) &&
|
||||
VISIBLEON(selmon->sel, selmon)) {
|
||||
at_client = get_scroll_stack_head(selmon->sel);
|
||||
at_client = scroll_get_stack_head_client(selmon->sel);
|
||||
} else {
|
||||
at_client = center_tiled_select(selmon);
|
||||
}
|
||||
|
|
@ -5026,91 +4981,137 @@ void setborder_color(Client *c) {
|
|||
}
|
||||
|
||||
void exchange_two_client(Client *c1, Client *c2) {
|
||||
|
||||
Monitor *tmp_mon = NULL;
|
||||
uint32_t tmp_tags;
|
||||
double master_inner_per = 0.0f;
|
||||
double master_mfact_per = 0.0f;
|
||||
double stack_inner_per = 0.0f;
|
||||
float scroller_proportion = 0.0f;
|
||||
float stack_proportion = 0.0f;
|
||||
struct ScrollerStackNode *n1 = NULL;
|
||||
struct ScrollerStackNode *n2 = NULL;
|
||||
struct TagScrollerState *st1 = NULL;
|
||||
struct TagScrollerState *st2 = NULL;
|
||||
|
||||
if (c1 == NULL || c2 == NULL ||
|
||||
(!config.exchange_cross_monitor && c1->mon != c2->mon)) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (c1->mon != c2->mon && (c1->prev_in_stack || c2->prev_in_stack ||
|
||||
c1->next_in_stack || c2->next_in_stack))
|
||||
return;
|
||||
|
||||
Client *c1head = get_scroll_stack_head(c1);
|
||||
Client *c2head = get_scroll_stack_head(c2);
|
||||
|
||||
// 交换布局参数
|
||||
if (c1head == c2head) {
|
||||
scroller_proportion = c1->scroller_proportion;
|
||||
stack_proportion = c1->stack_proportion;
|
||||
|
||||
c1->scroller_proportion = c2->scroller_proportion;
|
||||
c1->stack_proportion = c2->stack_proportion;
|
||||
c2->scroller_proportion = scroller_proportion;
|
||||
c2->stack_proportion = stack_proportion;
|
||||
}
|
||||
|
||||
master_inner_per = c1->master_inner_per;
|
||||
master_mfact_per = c1->master_mfact_per;
|
||||
stack_inner_per = c1->stack_inner_per;
|
||||
|
||||
c1->master_inner_per = c2->master_inner_per;
|
||||
c1->master_mfact_per = c2->master_mfact_per;
|
||||
c1->stack_inner_per = c2->stack_inner_per;
|
||||
|
||||
c2->master_inner_per = master_inner_per;
|
||||
c2->master_mfact_per = master_mfact_per;
|
||||
c2->stack_inner_per = stack_inner_per;
|
||||
|
||||
// 交换栈链表连接
|
||||
Client *tmp1_next_in_stack = c1->next_in_stack;
|
||||
Client *tmp1_prev_in_stack = c1->prev_in_stack;
|
||||
Client *tmp2_next_in_stack = c2->next_in_stack;
|
||||
Client *tmp2_prev_in_stack = c2->prev_in_stack;
|
||||
bool c1_scroller = c1->mon && is_scroller_layout(c1->mon);
|
||||
bool c2_scroller = c2->mon && is_scroller_layout(c2->mon);
|
||||
Monitor *m1 = c1->mon;
|
||||
Monitor *m2 = c2->mon;
|
||||
uint32_t tag1 = m1->pertag->curtag;
|
||||
uint32_t tag2 = m2->pertag->curtag;
|
||||
|
||||
// 处理相邻节点的情况
|
||||
if (c1->next_in_stack == c2) {
|
||||
c1->next_in_stack = tmp2_next_in_stack;
|
||||
c2->next_in_stack = c1;
|
||||
c1->prev_in_stack = c2;
|
||||
c2->prev_in_stack = tmp1_prev_in_stack;
|
||||
if (tmp1_prev_in_stack)
|
||||
tmp1_prev_in_stack->next_in_stack = c2;
|
||||
if (tmp2_next_in_stack)
|
||||
tmp2_next_in_stack->prev_in_stack = c1;
|
||||
} else if (c2->next_in_stack == c1) {
|
||||
c2->next_in_stack = tmp1_next_in_stack;
|
||||
c1->next_in_stack = c2;
|
||||
c2->prev_in_stack = c1;
|
||||
c1->prev_in_stack = tmp2_prev_in_stack;
|
||||
if (tmp2_prev_in_stack)
|
||||
tmp2_prev_in_stack->next_in_stack = c1;
|
||||
if (tmp1_next_in_stack)
|
||||
tmp1_next_in_stack->prev_in_stack = c2;
|
||||
} else if (is_scroller_layout(c1->mon) &&
|
||||
(c1->prev_in_stack || c2->prev_in_stack)) {
|
||||
Client *c1head = get_scroll_stack_head(c1);
|
||||
Client *c2head = get_scroll_stack_head(c2);
|
||||
exchange_two_client(c1head, c2head);
|
||||
focusclient(c1, 0);
|
||||
return;
|
||||
if (c1_scroller) {
|
||||
st1 = ensure_scroller_state(m1, tag1);
|
||||
n1 = find_scroller_node(st1, c1);
|
||||
}
|
||||
|
||||
// 交换全局链表连接
|
||||
if (c2_scroller) {
|
||||
st2 = ensure_scroller_state(m2, tag2);
|
||||
n2 = find_scroller_node(st2, c2);
|
||||
}
|
||||
|
||||
if (!n1 || !n2)
|
||||
goto exchange_common;
|
||||
|
||||
if (n1 && n2) {
|
||||
|
||||
/* 跨显示器且任一方有堆叠关系时不允许交换 */
|
||||
if (m1 != m2 && (n1->prev_in_stack || n2->prev_in_stack ||
|
||||
n1->next_in_stack || n2->next_in_stack))
|
||||
return;
|
||||
|
||||
/* 获取各自的堆叠头节点 */
|
||||
struct ScrollerStackNode *head1 = n1;
|
||||
while (head1->prev_in_stack)
|
||||
head1 = head1->prev_in_stack;
|
||||
struct ScrollerStackNode *head2 = n2;
|
||||
while (head2->prev_in_stack)
|
||||
head2 = head2->prev_in_stack;
|
||||
|
||||
/* 同一堆叠内交换 */
|
||||
if (head1 == head2) {
|
||||
float tmp_scroller = n1->scroller_proportion;
|
||||
float tmp_stack = n1->stack_proportion;
|
||||
n1->scroller_proportion = n2->scroller_proportion;
|
||||
n1->stack_proportion = n2->stack_proportion;
|
||||
n2->scroller_proportion = tmp_scroller;
|
||||
n2->stack_proportion = tmp_stack;
|
||||
|
||||
/* 交换堆叠链表指针 */
|
||||
struct ScrollerStackNode *p1 = n1->prev_in_stack;
|
||||
struct ScrollerStackNode *next1 = n1->next_in_stack;
|
||||
struct ScrollerStackNode *p2 = n2->prev_in_stack;
|
||||
struct ScrollerStackNode *next2 = n2->next_in_stack;
|
||||
|
||||
if (n1->next_in_stack == n2) {
|
||||
n1->next_in_stack = next2;
|
||||
n2->prev_in_stack = p1;
|
||||
n1->prev_in_stack = n2;
|
||||
n2->next_in_stack = n1;
|
||||
if (p1)
|
||||
p1->next_in_stack = n2;
|
||||
if (next2)
|
||||
next2->prev_in_stack = n1;
|
||||
} else if (n2->next_in_stack == n1) {
|
||||
n2->next_in_stack = next1;
|
||||
n1->prev_in_stack = p2;
|
||||
n2->prev_in_stack = n1;
|
||||
n1->next_in_stack = n2;
|
||||
if (p2)
|
||||
p2->next_in_stack = n1;
|
||||
if (next1)
|
||||
next1->prev_in_stack = n2;
|
||||
} else {
|
||||
if (p1)
|
||||
p1->next_in_stack = n2;
|
||||
if (next1)
|
||||
next1->prev_in_stack = n2;
|
||||
if (p2)
|
||||
p2->next_in_stack = n1;
|
||||
if (next2)
|
||||
next2->prev_in_stack = n1;
|
||||
n1->prev_in_stack = p2;
|
||||
n1->next_in_stack = next2;
|
||||
n2->prev_in_stack = p1;
|
||||
n2->next_in_stack = next1;
|
||||
}
|
||||
|
||||
sync_scroller_state_to_clients(m1, tag1);
|
||||
} else {
|
||||
/* 不同堆叠：交换两个堆叠整体位置 */
|
||||
if (n1 != head1 || n2 != head2) {
|
||||
/* 当前不是头部，递归交换头部 */
|
||||
exchange_two_client(head1->client, head2->client);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
exchange_common:
|
||||
|
||||
/* 跨显示器且任一方有堆叠关系时不允许交换 */
|
||||
if (m1 != m2 && ((n1 && n1->prev_in_stack) || (n2 && n2->prev_in_stack) ||
|
||||
(n1 && n1->next_in_stack) || (n2 && n2->next_in_stack)))
|
||||
return;
|
||||
|
||||
struct wl_list *tmp1_prev = c1->link.prev;
|
||||
struct wl_list *tmp2_prev = c2->link.prev;
|
||||
struct wl_list *tmp1_next = c1->link.next;
|
||||
struct wl_list *tmp2_next = c2->link.next;
|
||||
|
||||
// 处理相邻节点的情况
|
||||
if (c1->link.next == &c2->link) {
|
||||
c1->link.next = c2->link.next;
|
||||
c1->link.prev = &c2->link;
|
||||
|
|
@ -5125,39 +5126,47 @@ void exchange_two_client(Client *c1, Client *c2) {
|
|||
c1->link.prev = tmp2_prev;
|
||||
tmp2_prev->next = &c1->link;
|
||||
tmp1_next->prev = &c2->link;
|
||||
} else { // 不为相邻节点
|
||||
} else {
|
||||
c2->link.next = tmp1_next;
|
||||
c2->link.prev = tmp1_prev;
|
||||
c1->link.next = tmp2_next;
|
||||
c1->link.prev = tmp2_prev;
|
||||
|
||||
tmp1_prev->next = &c2->link;
|
||||
tmp1_next->prev = &c2->link;
|
||||
tmp2_prev->next = &c1->link;
|
||||
tmp2_next->prev = &c1->link;
|
||||
}
|
||||
|
||||
// 处理跨监视器交换
|
||||
if (config.exchange_cross_monitor) {
|
||||
DwindleNode **c1_root = &m1->pertag->dwindle_root[m1->pertag->curtag];
|
||||
DwindleNode *c1node = dwindle_find_leaf(*c1_root, c1);
|
||||
|
||||
DwindleNode **c2_root = &m2->pertag->dwindle_root[m2->pertag->curtag];
|
||||
DwindleNode *c2node = dwindle_find_leaf(*c2_root, c2);
|
||||
|
||||
if (c1node)
|
||||
c1node->client = c2;
|
||||
|
||||
if (c2node)
|
||||
c2node->client = c1;
|
||||
|
||||
tmp_mon = c2->mon;
|
||||
tmp_tags = c2->tags;
|
||||
setmon(c2, c1->mon, c1->tags, false);
|
||||
setmon(c1, tmp_mon, tmp_tags, false);
|
||||
if (c1->mon &&
|
||||
c1->mon->pertag->ltidxs[c1->mon->pertag->curtag]->id == DWINDLE)
|
||||
dwindle_swap_clients(
|
||||
&c1->mon->pertag->dwindle_root[c1->mon->pertag->curtag], c1,
|
||||
c2);
|
||||
c2->mon = c1->mon;
|
||||
c1->mon = tmp_mon;
|
||||
c2->tags = c1->tags;
|
||||
c1->tags = tmp_tags;
|
||||
|
||||
arrange(c1->mon, false, false);
|
||||
arrange(c2->mon, false, false);
|
||||
focusclient(c1, 0);
|
||||
} else {
|
||||
if (c1->mon &&
|
||||
c1->mon->pertag->ltidxs[c1->mon->pertag->curtag]->id == DWINDLE)
|
||||
c1->mon->pertag->ltidxs[c1->mon->pertag->curtag]->id == DWINDLE) {
|
||||
dwindle_swap_clients(
|
||||
&c1->mon->pertag->dwindle_root[c1->mon->pertag->curtag], c1,
|
||||
c2);
|
||||
arrange(c1->mon, false, false);
|
||||
arrange(c1->mon, false, false);
|
||||
}
|
||||
}
|
||||
|
||||
// In order to facilitate repeated exchanges for get_focused_stack_client
|
||||
|
|
@ -5426,24 +5435,18 @@ void reset_maximizescreen_size(Client *c) {
|
|||
}
|
||||
|
||||
void exit_scroller_stack(Client *c) {
|
||||
// If c is already in a stack, remove it.
|
||||
if (c->prev_in_stack) {
|
||||
c->prev_in_stack->next_in_stack = c->next_in_stack;
|
||||
}
|
||||
if (!c || !c->mon)
|
||||
return;
|
||||
|
||||
if (!c->prev_in_stack && c->next_in_stack) {
|
||||
c->next_in_stack->scroller_proportion = c->scroller_proportion;
|
||||
wl_list_remove(&c->next_in_stack->link);
|
||||
wl_list_insert(&c->link, &c->next_in_stack->link);
|
||||
uint32_t tag = c->mon->pertag->curtag;
|
||||
struct TagScrollerState *st = c->mon->pertag->scroller_state[tag];
|
||||
if (st) {
|
||||
struct ScrollerStackNode *n = find_scroller_node(st, c);
|
||||
if (n) {
|
||||
scroller_node_remove(st, n);
|
||||
return; /* 节点已移除，客户端指针已在函数内清空 */
|
||||
}
|
||||
}
|
||||
|
||||
if (c->next_in_stack) {
|
||||
c->next_in_stack->prev_in_stack = c->prev_in_stack;
|
||||
}
|
||||
|
||||
c->prev_in_stack = NULL;
|
||||
c->next_in_stack = NULL;
|
||||
c->stack_proportion = 0.0f;
|
||||
}
|
||||
|
||||
void setmaximizescreen(Client *c, int32_t maximizescreen) {
|
||||
|
|
@ -6113,7 +6116,6 @@ void tag_client(const Arg *arg, Client *target_client) {
|
|||
Client *fc = NULL;
|
||||
if (target_client && arg->ui & TAGMASK) {
|
||||
|
||||
exit_scroller_stack(target_client);
|
||||
target_client->tags = arg->ui & TAGMASK;
|
||||
target_client->istagswitching = 1;
|
||||
|
||||
|
|
@ -6306,9 +6308,15 @@ void unmapnotify(struct wl_listener *listener, void *data) {
|
|||
Client *c = wl_container_of(listener, c, unmap);
|
||||
Monitor *m = NULL;
|
||||
Client *nextfocus = NULL;
|
||||
Client *next_in_stack = c->next_in_stack;
|
||||
Client *prev_in_stack = c->prev_in_stack;
|
||||
c->iskilling = 1;
|
||||
struct ScrollerStackNode *target_node =
|
||||
c->mon ? find_scroller_node(
|
||||
c->mon->pertag->scroller_state[c->mon->pertag->curtag], c)
|
||||
: NULL;
|
||||
struct ScrollerStackNode *prev_node =
|
||||
target_node ? target_node->prev_in_stack : NULL;
|
||||
struct ScrollerStackNode *next_node =
|
||||
target_node ? target_node->next_in_stack : NULL;
|
||||
|
||||
if (config.animations && !c->is_clip_to_hide && !c->isminimized &&
|
||||
(!c->mon || VISIBLEON(c, c->mon)))
|
||||
|
|
@ -6320,7 +6328,8 @@ void unmapnotify(struct wl_listener *listener, void *data) {
|
|||
c->swallowedby->mon = c->mon;
|
||||
swallow(c->swallowedby, c);
|
||||
} else {
|
||||
exit_scroller_stack(c);
|
||||
scroller_remove_client(c);
|
||||
dwindle_remove_client(c);
|
||||
}
|
||||
|
||||
if (c == grabc) {
|
||||
|
|
@ -6345,10 +6354,10 @@ void unmapnotify(struct wl_listener *listener, void *data) {
|
|||
}
|
||||
|
||||
if (c->mon && c->mon == selmon) {
|
||||
if (next_in_stack && !c->swallowedby) {
|
||||
nextfocus = next_in_stack;
|
||||
} else if (prev_in_stack && !c->swallowedby) {
|
||||
nextfocus = prev_in_stack;
|
||||
if (next_node && !c->swallowedby) {
|
||||
nextfocus = next_node->client;
|
||||
} else if (prev_node && !c->swallowedby) {
|
||||
nextfocus = prev_node->client;
|
||||
} else {
|
||||
nextfocus = focustop(selmon);
|
||||
}
|
||||
|
|
@ -6414,10 +6423,7 @@ void unmapnotify(struct wl_listener *listener, void *data) {
|
|||
c->image_capture_source = NULL;
|
||||
|
||||
c->stack_proportion = 0.0f;
|
||||
c->next_in_stack = NULL;
|
||||
c->prev_in_stack = NULL;
|
||||
|
||||
dwindle_remove_client(c);
|
||||
wlr_scene_node_destroy(&c->scene->node);
|
||||
printstatus();
|
||||
motionnotify(0, NULL, 0, 0, 0, 0);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue