mirror of
https://github.com/DreamMaoMao/maomaowm.git
synced 2026-05-25 21:37:33 -04:00
1006 lines
29 KiB
C
1006 lines
29 KiB
C
void save_old_size_per(Monitor *m) {
|
||
Client *c = NULL;
|
||
|
||
wl_list_for_each(c, &clients, link) {
|
||
if (VISIBLEON(c, m) && ISTILED(c)) {
|
||
c->old_master_inner_per = c->master_inner_per;
|
||
c->old_stack_inner_per = c->stack_inner_per;
|
||
}
|
||
}
|
||
}
|
||
|
||
void restore_size_per(Monitor *m, Client *c) {
|
||
Client *fc = NULL;
|
||
|
||
if (!m || !c)
|
||
return;
|
||
|
||
if (!m->wlr_output->enabled)
|
||
return;
|
||
|
||
wl_list_for_each(fc, &clients, link) {
|
||
if (VISIBLEON(fc, m) && ISTILED(fc)) {
|
||
fc->old_ismaster = fc->ismaster;
|
||
}
|
||
}
|
||
|
||
c->old_master_inner_per = c->master_inner_per;
|
||
c->old_stack_inner_per = c->stack_inner_per;
|
||
|
||
pre_caculate_before_arrange(m, false, false, true);
|
||
|
||
const Layout *current_layout = m->pertag->ltidxs[m->pertag->curtag];
|
||
|
||
if (current_layout->id == SCROLLER ||
|
||
current_layout->id == VERTICAL_SCROLLER || current_layout->id == GRID ||
|
||
current_layout->id == FAIR || current_layout->id == VERTICAL_FAIR ||
|
||
current_layout->id == VERTICAL_GRID || current_layout->id == DECK ||
|
||
current_layout->id == VERTICAL_DECK || current_layout->id == MONOCLE) {
|
||
return;
|
||
}
|
||
|
||
if (current_layout->id == CENTER_TILE) {
|
||
wl_list_for_each(fc, &clients, link) {
|
||
if (VISIBLEON(fc, m) && ISTILED(fc) && !c->ismaster) {
|
||
set_size_per(m, fc);
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
// it is possible that the current floating window is moved to another tag,
|
||
// but the tag has not executed save_old_size_per
|
||
// so it must be judged whether their old size values are initial values
|
||
|
||
if (!c->ismaster && c->old_stack_inner_per < 1.0 &&
|
||
c->old_stack_inner_per > 0.0f && c->stack_inner_per < 1.0 &&
|
||
c->stack_inner_per > 0.0f) {
|
||
c->stack_inner_per = (1.0 - c->stack_inner_per) *
|
||
c->old_stack_inner_per /
|
||
(1.0 - c->old_stack_inner_per);
|
||
}
|
||
|
||
if (c->ismaster && c->old_master_inner_per < 1.0 &&
|
||
c->old_master_inner_per > 0.0f && c->master_inner_per < 1.0 &&
|
||
c->master_inner_per > 0.0f) {
|
||
c->master_inner_per = (1.0 - c->master_inner_per) *
|
||
c->old_master_inner_per /
|
||
(1.0 - c->old_master_inner_per);
|
||
}
|
||
|
||
wl_list_for_each(fc, &clients, link) {
|
||
if (VISIBLEON(fc, m) && ISTILED(fc) && fc != c && !fc->ismaster &&
|
||
fc->old_ismaster && fc->old_stack_inner_per < 1.0 &&
|
||
fc->old_stack_inner_per > 0.0f && fc->stack_inner_per < 1.0 &&
|
||
fc->stack_inner_per > 0.0f) {
|
||
fc->stack_inner_per = (1.0 - fc->stack_inner_per) *
|
||
fc->old_stack_inner_per /
|
||
(1.0 - fc->old_stack_inner_per);
|
||
fc->old_ismaster = false;
|
||
}
|
||
}
|
||
}
|
||
|
||
void set_size_per(Monitor *m, Client *c) {
|
||
Client *fc = NULL;
|
||
bool found = false;
|
||
|
||
if (!m || !c)
|
||
return;
|
||
|
||
const Layout *current_layout = m->pertag->ltidxs[m->pertag->curtag];
|
||
|
||
wl_list_for_each(fc, &clients, link) {
|
||
if (VISIBLEON(fc, m) && ISTILED(fc) && fc != c) {
|
||
if (current_layout->id == CENTER_TILE &&
|
||
(fc->isleftstack ^ c->isleftstack))
|
||
continue;
|
||
c->master_mfact_per = fc->master_mfact_per;
|
||
c->master_inner_per = fc->master_inner_per;
|
||
c->stack_inner_per = fc->stack_inner_per;
|
||
found = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (!found) {
|
||
c->master_mfact_per = m->pertag->mfacts[m->pertag->curtag];
|
||
c->master_inner_per = 1.0f;
|
||
c->stack_inner_per = 1.0f;
|
||
}
|
||
}
|
||
|
||
void resize_tile_master_horizontal(Client *grabc, bool isdrag, int32_t offsetx,
|
||
int32_t offsety, uint32_t time,
|
||
int32_t type) {
|
||
Client *tc = NULL;
|
||
float delta_x, delta_y;
|
||
Client *next = NULL;
|
||
Client *prev = NULL;
|
||
Client *nextnext = NULL;
|
||
Client *prevprev = NULL;
|
||
struct wl_list *node;
|
||
bool begin_find_nextnext = false;
|
||
bool begin_find_prevprev = false;
|
||
|
||
/* 寻找 next / nextnext */
|
||
for (node = grabc->link.next; node != &clients; node = node->next) {
|
||
tc = wl_container_of(node, tc, link);
|
||
if (begin_find_nextnext && VISIBLEON(tc, grabc->mon) && ISTILED(tc)) {
|
||
nextnext = tc;
|
||
break;
|
||
}
|
||
if (!begin_find_nextnext && VISIBLEON(tc, grabc->mon) && ISTILED(tc)) {
|
||
next = tc;
|
||
begin_find_nextnext = true;
|
||
continue;
|
||
}
|
||
}
|
||
|
||
/* 寻找 prev / prevprev */
|
||
for (node = grabc->link.prev; node != &clients; node = node->prev) {
|
||
tc = wl_container_of(node, tc, link);
|
||
if (begin_find_prevprev && VISIBLEON(tc, grabc->mon) && ISTILED(tc)) {
|
||
prevprev = tc;
|
||
break;
|
||
}
|
||
if (!begin_find_prevprev && VISIBLEON(tc, grabc->mon) && ISTILED(tc)) {
|
||
prev = tc;
|
||
begin_find_prevprev = true;
|
||
continue;
|
||
}
|
||
}
|
||
|
||
if (!start_drag_window && isdrag) {
|
||
drag_begin_cursorx = cursor->x;
|
||
drag_begin_cursory = cursor->y;
|
||
start_drag_window = true;
|
||
grabc->old_master_mfact_per = grabc->master_mfact_per;
|
||
grabc->old_master_inner_per = grabc->master_inner_per;
|
||
grabc->old_stack_inner_per = grabc->stack_inner_per;
|
||
grabc->cursor_in_upper_half =
|
||
cursor->y < grabc->geom.y + grabc->geom.height / 2;
|
||
grabc->cursor_in_left_half =
|
||
cursor->x < grabc->geom.x + grabc->geom.width / 2;
|
||
grabc->drag_begin_geom = grabc->geom;
|
||
} else {
|
||
if (isdrag) {
|
||
offsetx = cursor->x - drag_begin_cursorx;
|
||
offsety = cursor->y - drag_begin_cursory;
|
||
} else {
|
||
grabc->old_master_mfact_per = grabc->master_mfact_per;
|
||
grabc->old_master_inner_per = grabc->master_inner_per;
|
||
grabc->old_stack_inner_per = grabc->stack_inner_per;
|
||
grabc->drag_begin_geom = grabc->geom;
|
||
grabc->cursor_in_upper_half = true;
|
||
grabc->cursor_in_left_half = false;
|
||
}
|
||
|
||
if (grabc->ismaster) {
|
||
delta_x = (float)(offsetx) * (grabc->old_master_mfact_per) /
|
||
grabc->drag_begin_geom.width;
|
||
delta_y = (float)(offsety) * (grabc->old_master_inner_per) /
|
||
grabc->drag_begin_geom.height;
|
||
} else {
|
||
delta_x = (float)(offsetx) * (1 - grabc->old_master_mfact_per) /
|
||
grabc->drag_begin_geom.width;
|
||
delta_y = (float)(offsety) * (grabc->old_stack_inner_per) /
|
||
grabc->drag_begin_geom.height;
|
||
}
|
||
|
||
bool moving_up, moving_down;
|
||
if (!isdrag) {
|
||
moving_up = offsety < 0;
|
||
moving_down = offsety > 0;
|
||
} else {
|
||
moving_up = cursor->y < drag_begin_cursory;
|
||
moving_down = cursor->y > drag_begin_cursory;
|
||
}
|
||
|
||
if (grabc->ismaster && !prev) {
|
||
if (moving_up)
|
||
delta_y = -fabsf(delta_y);
|
||
else
|
||
delta_y = fabsf(delta_y);
|
||
} else if (grabc->ismaster && next && !next->ismaster) {
|
||
if (moving_up)
|
||
delta_y = fabsf(delta_y);
|
||
else
|
||
delta_y = -fabsf(delta_y);
|
||
} else if (!grabc->ismaster && prev && prev->ismaster) {
|
||
if (moving_up)
|
||
delta_y = -fabsf(delta_y);
|
||
else
|
||
delta_y = fabsf(delta_y);
|
||
} else if (!grabc->ismaster && !next) {
|
||
if (moving_up)
|
||
delta_y = fabsf(delta_y);
|
||
else
|
||
delta_y = -fabsf(delta_y);
|
||
} else if (type == CENTER_TILE && !grabc->ismaster && !nextnext) {
|
||
if (moving_up)
|
||
delta_y = fabsf(delta_y);
|
||
else
|
||
delta_y = -fabsf(delta_y);
|
||
} else if (type == CENTER_TILE && !grabc->ismaster && prevprev &&
|
||
prevprev->ismaster) {
|
||
if (moving_up)
|
||
delta_y = -fabsf(delta_y);
|
||
else
|
||
delta_y = fabsf(delta_y);
|
||
} else if ((grabc->cursor_in_upper_half && moving_up) ||
|
||
(!grabc->cursor_in_upper_half && moving_down)) {
|
||
delta_y = fabsf(delta_y) * 2;
|
||
} else {
|
||
delta_y = -fabsf(delta_y) * 2;
|
||
}
|
||
|
||
if (!grabc->ismaster && grabc->isleftstack && type == CENTER_TILE)
|
||
delta_x = delta_x * -1.0f;
|
||
if (grabc->ismaster && type == CENTER_TILE &&
|
||
grabc->cursor_in_left_half)
|
||
delta_x = delta_x * -1.0f;
|
||
if (grabc->ismaster && type == CENTER_TILE)
|
||
delta_x = delta_x * 2;
|
||
if (type == RIGHT_TILE)
|
||
delta_x = delta_x * -1.0f;
|
||
|
||
float new_master_mfact_per = grabc->old_master_mfact_per + delta_x;
|
||
float new_master_inner_per = grabc->old_master_inner_per + delta_y;
|
||
float new_stack_inner_per = grabc->old_stack_inner_per + delta_y;
|
||
|
||
new_master_mfact_per = fmaxf(0.1f, fminf(0.9f, new_master_mfact_per));
|
||
new_master_inner_per = fmaxf(0.1f, fminf(0.9f, new_master_inner_per));
|
||
new_stack_inner_per = fmaxf(0.1f, fminf(0.9f, new_stack_inner_per));
|
||
|
||
// 实时缩放同组其他窗口的比例，保持组内总和为 1,
|
||
// 不然增加的比例并不是排布后的比例
|
||
if (isdrag) {
|
||
if (grabc->ismaster) {
|
||
/* 主窗口组：调整所有主窗口的 master_inner_per */
|
||
float cur_other_sum = 1.0f - grabc->master_inner_per;
|
||
float new_other_sum = 1.0f - new_master_inner_per;
|
||
if (cur_other_sum > 0.001f) {
|
||
float scale = new_other_sum / cur_other_sum;
|
||
wl_list_for_each(tc, &clients, link) {
|
||
if (VISIBLEON(tc, grabc->mon) && ISTILED(tc) &&
|
||
tc->ismaster && tc != grabc)
|
||
tc->master_inner_per *= scale;
|
||
}
|
||
}
|
||
} else {
|
||
/* 栈窗口组：根据布局类型分开处理 */
|
||
if (type == CENTER_TILE) {
|
||
/* 仅缩放同侧栈窗口的 stack_inner_per */
|
||
float cur_other_sum = 1.0f - grabc->stack_inner_per;
|
||
float new_other_sum = 1.0f - new_stack_inner_per;
|
||
if (cur_other_sum > 0.001f) {
|
||
float scale = new_other_sum / cur_other_sum;
|
||
wl_list_for_each(tc, &clients, link) {
|
||
if (VISIBLEON(tc, grabc->mon) && ISTILED(tc) &&
|
||
!tc->ismaster && tc != grabc &&
|
||
tc->isleftstack == grabc->isleftstack)
|
||
tc->stack_inner_per *= scale;
|
||
}
|
||
}
|
||
} else {
|
||
/* TILE / RIGHT_TILE / DECK：所有栈窗口共用一个比例组 */
|
||
float cur_other_sum = 1.0f - grabc->stack_inner_per;
|
||
float new_other_sum = 1.0f - new_stack_inner_per;
|
||
if (cur_other_sum > 0.001f) {
|
||
float scale = new_other_sum / cur_other_sum;
|
||
wl_list_for_each(tc, &clients, link) {
|
||
if (VISIBLEON(tc, grabc->mon) && ISTILED(tc) &&
|
||
!tc->ismaster && tc != grabc)
|
||
tc->stack_inner_per *= scale;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
/* 键盘步进 */
|
||
wl_list_for_each(tc, &clients, link) {
|
||
if (!VISIBLEON(tc, grabc->mon) || !ISTILED(tc))
|
||
continue;
|
||
if (tc != grabc) {
|
||
if (!tc->ismaster && new_stack_inner_per != 1.0f &&
|
||
grabc->old_stack_inner_per != 1.0f &&
|
||
(type != CENTER_TILE ||
|
||
!(grabc->isleftstack ^ tc->isleftstack)))
|
||
tc->stack_inner_per = (1 - new_stack_inner_per) /
|
||
(1 - grabc->old_stack_inner_per) *
|
||
tc->stack_inner_per;
|
||
if (tc->ismaster && new_master_inner_per != 1.0f &&
|
||
grabc->old_master_inner_per != 1.0f)
|
||
tc->master_inner_per =
|
||
(1.0f - new_master_inner_per) /
|
||
(1.0f - grabc->old_master_inner_per) *
|
||
tc->master_inner_per;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* 将新比例应用到抓取窗口本身 */
|
||
grabc->master_inner_per = new_master_inner_per;
|
||
grabc->stack_inner_per = new_stack_inner_per;
|
||
|
||
/* 广播 master_mfact_per 到所有平铺窗口 */
|
||
wl_list_for_each(tc, &clients, link) {
|
||
if (VISIBLEON(tc, grabc->mon) && ISTILED(tc))
|
||
tc->master_mfact_per = new_master_mfact_per;
|
||
}
|
||
|
||
if (!isdrag) {
|
||
arrange(grabc->mon, false, false);
|
||
return;
|
||
}
|
||
|
||
if (last_apply_drap_time == 0 ||
|
||
time - last_apply_drap_time > config.drag_tile_refresh_interval) {
|
||
arrange(grabc->mon, false, false);
|
||
last_apply_drap_time = time;
|
||
}
|
||
}
|
||
}
|
||
|
||
void resize_tile_master_vertical(Client *grabc, bool isdrag, int32_t offsetx,
|
||
int32_t offsety, uint32_t time, int32_t type) {
|
||
Client *tc = NULL;
|
||
float delta_x, delta_y;
|
||
Client *next = NULL;
|
||
Client *prev = NULL;
|
||
struct wl_list *node;
|
||
|
||
/* 寻找 next */
|
||
for (node = grabc->link.next; node != &clients; node = node->next) {
|
||
tc = wl_container_of(node, tc, link);
|
||
if (VISIBLEON(tc, grabc->mon) && ISTILED(tc)) {
|
||
next = tc;
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* 寻找 prev */
|
||
for (node = grabc->link.prev; node != &clients; node = node->prev) {
|
||
tc = wl_container_of(node, tc, link);
|
||
if (VISIBLEON(tc, grabc->mon) && ISTILED(tc)) {
|
||
prev = tc;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (!start_drag_window && isdrag) {
|
||
drag_begin_cursorx = cursor->x;
|
||
drag_begin_cursory = cursor->y;
|
||
start_drag_window = true;
|
||
grabc->old_master_mfact_per = grabc->master_mfact_per;
|
||
grabc->old_master_inner_per = grabc->master_inner_per;
|
||
grabc->old_stack_inner_per = grabc->stack_inner_per;
|
||
grabc->cursor_in_upper_half =
|
||
cursor->y < grabc->geom.y + grabc->geom.height / 2;
|
||
grabc->cursor_in_left_half =
|
||
cursor->x < grabc->geom.x + grabc->geom.width / 2;
|
||
grabc->drag_begin_geom = grabc->geom;
|
||
} else {
|
||
if (isdrag) {
|
||
offsetx = cursor->x - drag_begin_cursorx;
|
||
offsety = cursor->y - drag_begin_cursory;
|
||
} else {
|
||
grabc->old_master_mfact_per = grabc->master_mfact_per;
|
||
grabc->old_master_inner_per = grabc->master_inner_per;
|
||
grabc->old_stack_inner_per = grabc->stack_inner_per;
|
||
grabc->drag_begin_geom = grabc->geom;
|
||
grabc->cursor_in_upper_half = true;
|
||
grabc->cursor_in_left_half = false;
|
||
}
|
||
|
||
if (grabc->ismaster) {
|
||
delta_x = (float)(offsetx) * (grabc->old_master_inner_per) /
|
||
grabc->drag_begin_geom.width;
|
||
delta_y = (float)(offsety) * (grabc->old_master_mfact_per) /
|
||
grabc->drag_begin_geom.height;
|
||
} else {
|
||
delta_x = (float)(offsetx) * (grabc->old_stack_inner_per) /
|
||
grabc->drag_begin_geom.width;
|
||
delta_y = (float)(offsety) * (1 - grabc->old_master_mfact_per) /
|
||
grabc->drag_begin_geom.height;
|
||
}
|
||
|
||
bool moving_left, moving_right;
|
||
if (!isdrag) {
|
||
moving_left = offsetx < 0;
|
||
moving_right = offsetx > 0;
|
||
} else {
|
||
moving_left = cursor->x < drag_begin_cursorx;
|
||
moving_right = cursor->x > drag_begin_cursorx;
|
||
}
|
||
|
||
if (grabc->ismaster && !prev) {
|
||
if (moving_left)
|
||
delta_x = -fabsf(delta_x);
|
||
else
|
||
delta_x = fabsf(delta_x);
|
||
} else if (grabc->ismaster && next && !next->ismaster) {
|
||
if (moving_left)
|
||
delta_x = fabsf(delta_x);
|
||
else
|
||
delta_x = -fabsf(delta_x);
|
||
} else if (!grabc->ismaster && prev && prev->ismaster) {
|
||
if (moving_left)
|
||
delta_x = -fabsf(delta_x);
|
||
else
|
||
delta_x = fabsf(delta_x);
|
||
} else if (!grabc->ismaster && !next) {
|
||
if (moving_left)
|
||
delta_x = fabsf(delta_x);
|
||
else
|
||
delta_x = -fabsf(delta_x);
|
||
} else if ((grabc->cursor_in_left_half && moving_left) ||
|
||
(!grabc->cursor_in_left_half && moving_right)) {
|
||
delta_x = fabsf(delta_x) * 2;
|
||
} else {
|
||
delta_x = -fabsf(delta_x) * 2;
|
||
}
|
||
|
||
float new_master_mfact_per = grabc->old_master_mfact_per + delta_y;
|
||
float new_master_inner_per = grabc->old_master_inner_per + delta_x;
|
||
float new_stack_inner_per = grabc->old_stack_inner_per + delta_x;
|
||
|
||
new_master_mfact_per = fmaxf(0.1f, fminf(0.9f, new_master_mfact_per));
|
||
new_master_inner_per = fmaxf(0.1f, fminf(0.9f, new_master_inner_per));
|
||
new_stack_inner_per = fmaxf(0.1f, fminf(0.9f, new_stack_inner_per));
|
||
|
||
// 实时缩放同组其他窗口的比例，保持组内总和为 1,
|
||
// 不然增加的比例并不是排布后的比例
|
||
|
||
if (isdrag) {
|
||
if (grabc->ismaster) {
|
||
float cur_other_sum = 1.0f - grabc->master_inner_per;
|
||
float new_other_sum = 1.0f - new_master_inner_per;
|
||
if (cur_other_sum > 0.001f) {
|
||
float scale = new_other_sum / cur_other_sum;
|
||
wl_list_for_each(tc, &clients, link) {
|
||
if (VISIBLEON(tc, grabc->mon) && ISTILED(tc) &&
|
||
tc->ismaster && tc != grabc)
|
||
tc->master_inner_per *= scale;
|
||
}
|
||
}
|
||
} else {
|
||
/* 所有栈窗口（垂直布局没有左侧/右侧区分） */
|
||
float cur_other_sum = 1.0f - grabc->stack_inner_per;
|
||
float new_other_sum = 1.0f - new_stack_inner_per;
|
||
if (cur_other_sum > 0.001f) {
|
||
float scale = new_other_sum / cur_other_sum;
|
||
wl_list_for_each(tc, &clients, link) {
|
||
if (VISIBLEON(tc, grabc->mon) && ISTILED(tc) &&
|
||
!tc->ismaster && tc != grabc)
|
||
tc->stack_inner_per *= scale;
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
/* 键盘步进 */
|
||
wl_list_for_each(tc, &clients, link) {
|
||
if (!VISIBLEON(tc, grabc->mon) || !ISTILED(tc))
|
||
continue;
|
||
if (tc != grabc) {
|
||
if (!tc->ismaster && new_stack_inner_per != 1.0f &&
|
||
grabc->old_stack_inner_per != 1.0f)
|
||
tc->stack_inner_per = (1 - new_stack_inner_per) /
|
||
(1 - grabc->old_stack_inner_per) *
|
||
tc->stack_inner_per;
|
||
if (tc->ismaster && new_master_inner_per != 1.0f &&
|
||
grabc->old_master_inner_per != 1.0f)
|
||
tc->master_inner_per =
|
||
(1.0f - new_master_inner_per) /
|
||
(1.0f - grabc->old_master_inner_per) *
|
||
tc->master_inner_per;
|
||
}
|
||
}
|
||
}
|
||
|
||
grabc->master_inner_per = new_master_inner_per;
|
||
grabc->stack_inner_per = new_stack_inner_per;
|
||
|
||
/* 广播 master_mfact_per */
|
||
wl_list_for_each(tc, &clients, link) {
|
||
if (VISIBLEON(tc, grabc->mon) && ISTILED(tc))
|
||
tc->master_mfact_per = new_master_mfact_per;
|
||
}
|
||
|
||
if (!isdrag) {
|
||
arrange(grabc->mon, false, false);
|
||
return;
|
||
}
|
||
|
||
if (last_apply_drap_time == 0 ||
|
||
time - last_apply_drap_time > config.drag_tile_refresh_interval) {
|
||
arrange(grabc->mon, false, false);
|
||
last_apply_drap_time = time;
|
||
}
|
||
}
|
||
}
|
||
|
||
void resize_tile_dwindle(Client *grabc, bool isdrag, int32_t offsetx,
|
||
int32_t offsety, uint32_t time, bool isvertical) {
|
||
|
||
if (!isdrag) {
|
||
dwindle_resize_client_step(grabc->mon, grabc, offsetx, offsety);
|
||
return;
|
||
}
|
||
|
||
if (last_apply_drap_time == 0 ||
|
||
time - last_apply_drap_time > config.drag_tile_refresh_interval) {
|
||
dwindle_resize_client(grabc->mon, grabc);
|
||
last_apply_drap_time = time;
|
||
}
|
||
}
|
||
|
||
void resize_tile_scroller(Client *grabc, bool isdrag, int32_t offsetx,
|
||
int32_t offsety, uint32_t time, bool isvertical) {
|
||
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;
|
||
|
||
if (!start_drag_window && isdrag) {
|
||
drag_begin_cursorx = cursor->x;
|
||
drag_begin_cursory = cursor->y;
|
||
start_drag_window = true;
|
||
|
||
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 {
|
||
grabc->old_master_mfact_per = grabc->master_mfact_per;
|
||
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_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) *
|
||
(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) *
|
||
(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, moving_down, moving_left, moving_right;
|
||
if (!isdrag) {
|
||
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;
|
||
moving_left = cursor->x < drag_begin_cursorx;
|
||
moving_right = cursor->x > drag_begin_cursorx;
|
||
}
|
||
|
||
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);
|
||
}
|
||
|
||
if ((grabc->cursor_in_left_half && moving_left) ||
|
||
(!grabc->cursor_in_left_half && moving_right)) {
|
||
delta_x = fabsf(delta_x);
|
||
} else {
|
||
delta_x = -fabsf(delta_x);
|
||
}
|
||
|
||
if (isvertical) {
|
||
if (!curnode->next_in_stack && curnode->prev_in_stack && !isdrag) {
|
||
delta_x = delta_x * -1.0f;
|
||
}
|
||
if (!curnode->next_in_stack && curnode->prev_in_stack && isdrag) {
|
||
if (moving_right)
|
||
delta_x = -fabsf(delta_x);
|
||
else
|
||
delta_x = fabsf(delta_x);
|
||
}
|
||
if (!curnode->prev_in_stack && curnode->next_in_stack && isdrag) {
|
||
if (moving_left)
|
||
delta_x = -fabsf(delta_x);
|
||
else
|
||
delta_x = fabsf(delta_x);
|
||
}
|
||
if (isdrag) {
|
||
if (moving_up)
|
||
delta_y = -fabsf(delta_y);
|
||
else
|
||
delta_y = fabsf(delta_y);
|
||
}
|
||
} else {
|
||
if (!curnode->next_in_stack && curnode->prev_in_stack && !isdrag) {
|
||
delta_y = delta_y * -1.0f;
|
||
}
|
||
if (!curnode->next_in_stack && curnode->prev_in_stack && isdrag) {
|
||
if (moving_down)
|
||
delta_y = -fabsf(delta_y);
|
||
else
|
||
delta_y = fabsf(delta_y);
|
||
}
|
||
if (!curnode->prev_in_stack && curnode->next_in_stack && isdrag) {
|
||
if (moving_up)
|
||
delta_y = -fabsf(delta_y);
|
||
else
|
||
delta_y = fabsf(delta_y);
|
||
}
|
||
if (isdrag) {
|
||
if (moving_left)
|
||
delta_x = -fabsf(delta_x);
|
||
else
|
||
delta_x = fabsf(delta_x);
|
||
}
|
||
}
|
||
|
||
if (isvertical) {
|
||
new_scroller_proportion =
|
||
headnode->client->old_scroller_pproportion + delta_y;
|
||
new_stack_proportion = grabc->old_stack_proportion + delta_x;
|
||
} else {
|
||
new_scroller_proportion =
|
||
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));
|
||
|
||
// 保持总和为 1，避免后续 arrange 归一化吞掉位移
|
||
if (isdrag) {
|
||
float current_other_sum = 1.0f - curnode->stack_proportion;
|
||
float new_other_sum = 1.0f - new_stack_proportion;
|
||
if (current_other_sum > 0.001f) {
|
||
float scale = new_other_sum / current_other_sum;
|
||
for (struct ScrollerStackNode *tc = headnode; tc;
|
||
tc = tc->next_in_stack) {
|
||
if (tc != curnode) {
|
||
tc->stack_proportion *= scale;
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
// 键盘步进
|
||
if (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;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
curnode->stack_proportion = new_stack_proportion;
|
||
headnode->scroller_proportion = new_scroller_proportion;
|
||
|
||
/* 同步回全局字段 */
|
||
sync_scroller_state_to_clients(m, tag);
|
||
|
||
if (!isdrag) {
|
||
arrange(m, false, false);
|
||
return;
|
||
}
|
||
|
||
if (last_apply_drap_time == 0 ||
|
||
time - last_apply_drap_time > config.drag_tile_refresh_interval) {
|
||
arrange(m, false, false);
|
||
last_apply_drap_time = time;
|
||
}
|
||
}
|
||
}
|
||
|
||
void resize_tile_client(Client *grabc, bool isdrag, int32_t offsetx,
|
||
int32_t offsety, uint32_t time) {
|
||
|
||
if (!grabc || grabc->isfullscreen || grabc->ismaximizescreen)
|
||
return;
|
||
|
||
if (grabc->mon->isoverview)
|
||
return;
|
||
|
||
const Layout *current_layout =
|
||
grabc->mon->pertag->ltidxs[grabc->mon->pertag->curtag];
|
||
if (current_layout->id == TILE || current_layout->id == DECK ||
|
||
current_layout->id == CENTER_TILE || current_layout->id == RIGHT_TILE
|
||
|
||
) {
|
||
resize_tile_master_horizontal(grabc, isdrag, offsetx, offsety, time,
|
||
current_layout->id);
|
||
} else if (current_layout->id == VERTICAL_TILE ||
|
||
current_layout->id == VERTICAL_DECK) {
|
||
resize_tile_master_vertical(grabc, isdrag, offsetx, offsety, time,
|
||
current_layout->id);
|
||
} else if (current_layout->id == SCROLLER) {
|
||
resize_tile_scroller(grabc, isdrag, offsetx, offsety, time, false);
|
||
} else if (current_layout->id == VERTICAL_SCROLLER) {
|
||
resize_tile_scroller(grabc, isdrag, offsetx, offsety, time, true);
|
||
} else if (current_layout->id == DWINDLE) {
|
||
resize_tile_dwindle(grabc, isdrag, offsetx, offsety, time, true);
|
||
}
|
||
}
|
||
|
||
/* If there are no calculation omissions,
|
||
these two functions will never be triggered.
|
||
Just in case to facilitate the final investigation*/
|
||
|
||
void check_size_per_valid(Client *c) {
|
||
if (c->ismaster) {
|
||
assert(c->master_inner_per > 0.0f && c->master_inner_per <= 1.0f);
|
||
} else {
|
||
assert(c->stack_inner_per > 0.0f && c->stack_inner_per <= 1.0f);
|
||
}
|
||
}
|
||
|
||
void reset_size_per_mon(Monitor *m, int32_t tile_cilent_num,
|
||
double total_left_stack_hight_percent,
|
||
double total_right_stack_hight_percent,
|
||
double total_stack_hight_percent,
|
||
double total_master_inner_percent, int32_t master_num,
|
||
int32_t stack_num) {
|
||
Client *c = NULL;
|
||
int32_t i = 0;
|
||
uint32_t stack_index = 0;
|
||
uint32_t nmasters = m->pertag->nmasters[m->pertag->curtag];
|
||
|
||
if (m->pertag->ltidxs[m->pertag->curtag]->id != CENTER_TILE) {
|
||
|
||
wl_list_for_each(c, &clients, link) {
|
||
if (VISIBLEON(c, m) && ISTILED(c)) {
|
||
|
||
if (total_master_inner_percent > 0.0 && i < nmasters) {
|
||
c->ismaster = true;
|
||
c->stack_inner_per = stack_num ? 1.0f / stack_num : 1.0f;
|
||
c->master_inner_per =
|
||
c->master_inner_per / total_master_inner_percent;
|
||
} else {
|
||
c->ismaster = false;
|
||
c->master_inner_per =
|
||
master_num > 0 ? 1.0f / master_num : 1.0f;
|
||
c->stack_inner_per =
|
||
total_stack_hight_percent
|
||
? c->stack_inner_per / total_stack_hight_percent
|
||
: 1.0f;
|
||
}
|
||
i++;
|
||
|
||
check_size_per_valid(c);
|
||
}
|
||
}
|
||
} else {
|
||
wl_list_for_each(c, &clients, link) {
|
||
if (VISIBLEON(c, m) && ISTILED(c)) {
|
||
|
||
if (total_master_inner_percent > 0.0 && i < nmasters) {
|
||
c->ismaster = true;
|
||
if ((stack_index % 2) ^ (tile_cilent_num % 2 == 0)) {
|
||
c->stack_inner_per =
|
||
stack_num > 1 ? 1.0f / ((stack_num - 1) / 2.0f)
|
||
: 1.0f;
|
||
} else {
|
||
c->stack_inner_per =
|
||
stack_num > 1 ? 2.0f / stack_num : 1.0f;
|
||
}
|
||
|
||
c->master_inner_per =
|
||
c->master_inner_per / total_master_inner_percent;
|
||
} else {
|
||
stack_index = i - nmasters;
|
||
|
||
c->ismaster = false;
|
||
c->master_inner_per =
|
||
master_num > 0 ? 1.0f / master_num : 1.0f;
|
||
if ((stack_index % 2) ^ (tile_cilent_num % 2 == 0)) {
|
||
c->stack_inner_per =
|
||
total_right_stack_hight_percent
|
||
? c->stack_inner_per /
|
||
total_right_stack_hight_percent
|
||
: 1.0f;
|
||
} else {
|
||
c->stack_inner_per =
|
||
total_left_stack_hight_percent
|
||
? c->stack_inner_per /
|
||
total_left_stack_hight_percent
|
||
: 1.0f;
|
||
}
|
||
}
|
||
i++;
|
||
|
||
check_size_per_valid(c);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void pre_caculate_before_arrange(Monitor *m, bool want_animation,
|
||
bool from_view, bool only_caculate) {
|
||
Client *c = NULL;
|
||
double total_stack_inner_percent = 0;
|
||
double total_master_inner_percent = 0;
|
||
double total_right_stack_hight_percent = 0;
|
||
double total_left_stack_hight_percent = 0;
|
||
int32_t i = 0;
|
||
int32_t nmasters = 0;
|
||
int32_t stack_index = 0;
|
||
int32_t master_num = 0;
|
||
int32_t stack_num = 0;
|
||
|
||
m->visible_clients = 0;
|
||
m->visible_tiling_clients = 0;
|
||
m->visible_scroll_tiling_clients = 0;
|
||
|
||
uint32_t tag = m->pertag->curtag;
|
||
struct TagScrollerState *st = m->pertag->scroller_state[tag];
|
||
|
||
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);
|
||
}
|
||
|
||
if (c->mon == m && (c->isglobal || c->isunglobal)) {
|
||
c->tags = m->tagset[m->seltags];
|
||
}
|
||
|
||
if (from_view && m->sel == NULL && c->isglobal && VISIBLEON(c, m)) {
|
||
focusclient(c, 1);
|
||
}
|
||
|
||
if (VISIBLEON(c, m)) {
|
||
if (from_view && !client_only_in_one_tag(c)) {
|
||
set_size_per(m, c);
|
||
}
|
||
|
||
if (!c->isunglobal)
|
||
m->visible_clients++;
|
||
|
||
if (ISTILED(c)) {
|
||
m->visible_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++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
nmasters = m->pertag->nmasters[m->pertag->curtag];
|
||
|
||
wl_list_for_each(c, &clients, link) {
|
||
if (c->iskilling)
|
||
continue;
|
||
|
||
if (c->mon == m) {
|
||
if (VISIBLEON(c, m)) {
|
||
if (ISTILED(c)) {
|
||
if (i < nmasters) {
|
||
master_num++;
|
||
total_master_inner_percent += c->master_inner_per;
|
||
} else {
|
||
stack_num++;
|
||
total_stack_inner_percent += c->stack_inner_per;
|
||
stack_index = i - nmasters;
|
||
if ((stack_index % 2) ^
|
||
(m->visible_tiling_clients % 2 == 0)) {
|
||
c->isleftstack = false;
|
||
total_right_stack_hight_percent +=
|
||
c->stack_inner_per;
|
||
} else {
|
||
c->isleftstack = true;
|
||
total_left_stack_hight_percent +=
|
||
c->stack_inner_per;
|
||
}
|
||
}
|
||
i++;
|
||
}
|
||
|
||
if (!only_caculate)
|
||
set_arrange_visible(m, c, want_animation);
|
||
} else {
|
||
if (!only_caculate)
|
||
set_arrange_hidden(m, c, want_animation);
|
||
}
|
||
}
|
||
|
||
if (!only_caculate && c->mon == m && c->ismaximizescreen &&
|
||
!c->animation.tagouted && !c->animation.tagouting &&
|
||
VISIBLEON(c, m)) {
|
||
reset_maximizescreen_size(c);
|
||
}
|
||
}
|
||
|
||
reset_size_per_mon(
|
||
m, m->visible_tiling_clients, total_left_stack_hight_percent,
|
||
total_right_stack_hight_percent, total_stack_inner_percent,
|
||
total_master_inner_percent, master_num, stack_num);
|
||
}
|
||
|
||
void // 17
|
||
arrange(Monitor *m, bool want_animation, bool from_view) {
|
||
|
||
if (!m)
|
||
return;
|
||
|
||
if (!m->wlr_output->enabled)
|
||
return;
|
||
|
||
pre_caculate_before_arrange(m, want_animation, from_view, false);
|
||
|
||
if (m->isoverview) {
|
||
overviewlayout.arrange(m);
|
||
} else {
|
||
m->pertag->ltidxs[m->pertag->curtag]->arrange(m);
|
||
}
|
||
|
||
if (!start_drag_window) {
|
||
motionnotify(0, NULL, 0, 0, 0, 0);
|
||
checkidleinhibitor(NULL);
|
||
}
|
||
|
||
printstatus();
|
||
}
|