mirror of
https://github.com/kovidgoyal/kitty.git
synced 2026-11-19 14:45:29 +00:00
Some checks are pending
CI / Linux (python=3.14 cc=clang sanitize=1) (push) Waiting to run
CI / Linux (python=3.12 cc=gcc sanitize=0) (push) Waiting to run
CI / Linux (python=3.13 cc=gcc sanitize=1) (push) Waiting to run
CI / Linux package (push) Waiting to run
CI / Bundle test (macos-latest) (push) Waiting to run
CI / Bundle test (ubuntu-latest) (push) Waiting to run
CI / macOS Brew (push) Waiting to run
CI / Test ./dev.sh and benchmark (push) Waiting to run
CodeQL / CodeQL-Build (actions, ubuntu-latest) (push) Waiting to run
CodeQL / CodeQL-Build (c, macos-latest) (push) Waiting to run
CodeQL / CodeQL-Build (c, ubuntu-latest) (push) Waiting to run
CodeQL / CodeQL-Build (go, ubuntu-latest) (push) Waiting to run
CodeQL / CodeQL-Build (python, ubuntu-latest) (push) Waiting to run
Depscan / Scan dependencies for vulnerabilities (push) Waiting to run
A bell in the active window was never marked as needing attention, even when the OS window did not have keyboard focus, so the tab bar bell symbol was not shown. Now a window needs attention unless it is both active and in the focused OS window. Since the active window can now need attention, also: - Clear needs_attention when the OS window gains focus, as focus_changed() is a no-op if the window became active while the OS window was unfocused, which would leave the indicator stuck. - Use the bell color for minimal borders of an active group needing attention, instead of the active color (or the fallback green when active_border_color is none). Fixes #10880
1761 lines
77 KiB
Python
1761 lines
77 KiB
Python
#!/usr/bin/env python
|
|
# License: GPL v3 Copyright: 2018, Kovid Goyal <kovid at kovidgoyal.net>
|
|
|
|
import weakref
|
|
from types import SimpleNamespace
|
|
from unittest.mock import patch
|
|
|
|
from kitty.borders import Border, BorderColor, add_borders
|
|
from kitty.config import defaults
|
|
from kitty.fast_data_types import BOTTOM_EDGE, LEFT_EDGE, RIGHT_EDGE, TOP_EDGE, Region
|
|
from kitty.layout.base import blank_rects_for_window, layout_dimension, lgd
|
|
from kitty.layout.interface import Fat, Grid, Horizontal, Splits, Stack, Tall, Vertical
|
|
from kitty.layout.splits import Pair, SplitsLayoutOpts
|
|
from kitty.rc.set_spacing import parse_spacing_settings
|
|
from kitty.types import WindowGeometry
|
|
from kitty.window import DeferredWatcherCalls, EdgeWidths, GlobalWatchers, Watchers
|
|
from kitty.window_list import WindowList, reset_group_id_counter
|
|
|
|
from .base import BaseTest
|
|
|
|
|
|
class Window:
|
|
show_title_bar = False
|
|
|
|
def __init__(self, win_id, overlay_for=None, overlay_window_id=None):
|
|
self.id = win_id
|
|
self.serialized_id = 0
|
|
self.overlay_for = overlay_for
|
|
self.overlay_window_id = overlay_window_id
|
|
self.is_visible_in_layout = True
|
|
self.geometry = WindowGeometry(0, 0, 0, 0, 0, 0)
|
|
self.padding = EdgeWidths()
|
|
self.margin = EdgeWidths()
|
|
self.focused = False
|
|
|
|
def focus_changed(self, focused):
|
|
self.focused = focused
|
|
|
|
def effective_border(self):
|
|
return 1
|
|
|
|
def effective_padding(self, edge):
|
|
return 1
|
|
|
|
def effective_margin(self, edge):
|
|
return 1
|
|
|
|
def default_margin(self, edge):
|
|
return 1
|
|
|
|
def set_visible_in_layout(self, val):
|
|
self.is_visible_in_layout = bool(val)
|
|
|
|
def set_geometry(self, geometry):
|
|
self.geometry = geometry
|
|
|
|
|
|
def create_layout(cls, opts=None, border_width=2):
|
|
if opts is None:
|
|
opts = defaults
|
|
ans = cls(1, 1)
|
|
ans.set_active_window_in_os_window = lambda idx: None
|
|
ans.swap_windows_in_os_window = lambda a, b: None
|
|
orig = ans._set_dimensions
|
|
|
|
def set_dimensions(all_windows):
|
|
orig(all_windows)
|
|
# we need a non-zero width and height for central
|
|
lgd.central = Region((0, 0, 0, 0, 1, 1))
|
|
|
|
ans._set_dimensions = set_dimensions
|
|
return ans
|
|
|
|
|
|
class Tab:
|
|
def active_window_changed(self):
|
|
self.current_layout.update_visibility(self.windows)
|
|
|
|
|
|
def create_windows(layout, num=5, window_class=Window):
|
|
t = Tab()
|
|
t.current_layout = layout
|
|
t.windows = ans = WindowList(t)
|
|
ans.tab_mem = t
|
|
reset_group_id_counter()
|
|
for i in range(num):
|
|
ans.add_window(window_class(i + 1))
|
|
ans.set_active_group_idx(0)
|
|
return ans
|
|
|
|
|
|
def utils(self, q, windows):
|
|
def ids():
|
|
return [w.id for w in windows.groups]
|
|
|
|
def visible_ids():
|
|
return {gr.id for gr in windows.groups if gr.is_visible_in_layout}
|
|
|
|
def expect_ids(*a):
|
|
self.assertEqual(tuple(ids()), a)
|
|
|
|
def check_visible():
|
|
if q.only_active_window_visible:
|
|
self.ae(visible_ids(), {windows.active_group.id})
|
|
else:
|
|
self.ae(visible_ids(), {gr.id for gr in windows.groups})
|
|
|
|
return ids, visible_ids, expect_ids, check_visible
|
|
|
|
|
|
class TestLayout(BaseTest):
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.set_options({'tab_bar_style': 'hidden'})
|
|
|
|
def test_window_border_radius_geometry(self):
|
|
q = create_layout(Splits)
|
|
windows = create_windows(q, 1)
|
|
windows.active_window.set_geometry(WindowGeometry(10, 20, 110, 120, 0, 0))
|
|
group = windows.active_group
|
|
color = BorderColor.active
|
|
straight = [
|
|
Border(8, 18, 112, 19, color, -1, True),
|
|
Border(8, 121, 112, 122, color, 1, True),
|
|
Border(8, 18, 9, 122, color, -1),
|
|
Border(111, 18, 112, 122, color, 1),
|
|
]
|
|
|
|
rects = []
|
|
add_borders(rects, color, group)
|
|
self.ae(rects, straight)
|
|
|
|
rects = []
|
|
add_borders(rects, color, group, 12)
|
|
self.ae(
|
|
rects,
|
|
[
|
|
*(border._replace(render=False) for border in straight),
|
|
Border(8, 18, 112, 122, color, render=False, radius=12, thickness=1),
|
|
],
|
|
)
|
|
|
|
def do_ops_test(self, q):
|
|
windows = create_windows(q)
|
|
ids, visible_ids, expect_ids, check_visible = utils(self, q, windows)
|
|
# Test layout
|
|
q(windows)
|
|
self.ae(windows.active_group_idx, 0)
|
|
expect_ids(*range(1, len(windows) + 1))
|
|
check_visible()
|
|
|
|
# Test nth_window
|
|
for i in range(windows.num_groups):
|
|
q.activate_nth_window(windows, i)
|
|
self.ae(windows.active_group_idx, i)
|
|
expect_ids(*range(1, len(windows) + 1))
|
|
check_visible()
|
|
|
|
# Test next_window
|
|
for i in range(2 * windows.num_groups):
|
|
expected = (windows.active_group_idx + 1) % windows.num_groups
|
|
q.next_window(windows)
|
|
self.ae(windows.active_group_idx, expected)
|
|
expect_ids(*range(1, len(windows) + 1))
|
|
check_visible()
|
|
|
|
# Test move_window
|
|
windows.set_active_group_idx(0)
|
|
expect_ids(1, 2, 3, 4, 5)
|
|
q.move_window(windows, 3)
|
|
self.ae(windows.active_group_idx, 3)
|
|
expect_ids(4, 2, 3, 1, 5)
|
|
check_visible()
|
|
windows.set_active_group_idx(0)
|
|
q.move_window(windows, 3)
|
|
expect_ids(*range(1, len(windows) + 1))
|
|
check_visible()
|
|
|
|
# Test add_window
|
|
windows.set_active_group_idx(4)
|
|
q.add_window(windows, Window(6))
|
|
self.ae(windows.num_groups, 6)
|
|
self.ae(windows.active_group_idx, 5)
|
|
expect_ids(*range(1, windows.num_groups + 1))
|
|
check_visible()
|
|
|
|
# Test remove_window
|
|
prev_window = windows.active_window
|
|
windows.set_active_group_idx(3)
|
|
self.ae(windows.active_group_idx, 3)
|
|
windows.remove_window(windows.active_window)
|
|
self.ae(windows.active_window, prev_window)
|
|
check_visible()
|
|
expect_ids(1, 2, 3, 5, 6)
|
|
|
|
windows.set_active_group_idx(0)
|
|
to_remove = windows.active_window
|
|
windows.set_active_group_idx(3)
|
|
prev_window = windows.active_window
|
|
windows.remove_window(to_remove)
|
|
self.ae(windows.active_group_idx, 2)
|
|
self.ae(windows.active_window, prev_window)
|
|
check_visible()
|
|
expect_ids(2, 3, 5, 6)
|
|
|
|
# Test set_active_window
|
|
for i in range(windows.num_groups):
|
|
windows.set_active_group_idx(i)
|
|
self.ae(i, windows.active_group_idx)
|
|
check_visible()
|
|
|
|
# Test
|
|
|
|
def do_overlay_test(self, q):
|
|
windows = create_windows(q)
|
|
ids, visible_ids, expect_ids, check_visible = utils(self, q, windows)
|
|
|
|
# Test add_window
|
|
w = Window(len(windows) + 1)
|
|
before = windows.active_group_idx
|
|
overlaid_group = before
|
|
overlay_window_id = w.id
|
|
windows.add_window(w, group_of=windows.active_window)
|
|
self.ae(before, windows.active_group_idx)
|
|
self.ae(w, windows.active_window)
|
|
expect_ids(1, 2, 3, 4, 5)
|
|
check_visible()
|
|
|
|
# Test layout
|
|
q(windows)
|
|
expect_ids(1, 2, 3, 4, 5)
|
|
check_visible()
|
|
w = Window(len(windows) + 1)
|
|
windows.add_window(w)
|
|
expect_ids(1, 2, 3, 4, 5, 6)
|
|
self.ae(windows.active_group_idx, windows.num_groups - 1)
|
|
|
|
# Test nth_window
|
|
for i in range(windows.num_groups):
|
|
q.activate_nth_window(windows, i)
|
|
self.ae(windows.active_group_idx, i)
|
|
if i == overlaid_group:
|
|
self.ae(windows.active_window.id, overlay_window_id)
|
|
expect_ids(1, 2, 3, 4, 5, 6)
|
|
check_visible()
|
|
|
|
# Test next_window
|
|
for i in range(windows.num_groups):
|
|
expected = (windows.active_group_idx + 1) % windows.num_groups
|
|
q.next_window(windows)
|
|
self.ae(windows.active_group_idx, expected)
|
|
expect_ids(1, 2, 3, 4, 5, 6)
|
|
check_visible()
|
|
|
|
# Test move_window
|
|
windows.set_active_group_idx(overlaid_group)
|
|
expect_ids(1, 2, 3, 4, 5, 6)
|
|
q.move_window(windows, 3)
|
|
self.ae(windows.active_group_idx, 3)
|
|
self.ae(windows.active_window.id, overlay_window_id)
|
|
expect_ids(4, 2, 3, 1, 5, 6)
|
|
check_visible()
|
|
windows.set_active_group_idx(0)
|
|
q.move_window(windows, 3)
|
|
expect_ids(1, 2, 3, 4, 5, 6)
|
|
check_visible()
|
|
|
|
# Test set_active_window
|
|
for i in range(windows.num_groups):
|
|
windows.set_active_group_idx(i)
|
|
self.ae(i, windows.active_group_idx)
|
|
if i == overlaid_group:
|
|
self.ae(windows.active_window.id, overlay_window_id)
|
|
check_visible()
|
|
|
|
# Test remove_window
|
|
expect_ids(1, 2, 3, 4, 5, 6)
|
|
windows.set_active_group_idx(overlaid_group)
|
|
windows.remove_window(overlay_window_id)
|
|
self.ae(windows.active_group_idx, overlaid_group)
|
|
self.ae(windows.active_window.id, 1)
|
|
expect_ids(1, 2, 3, 4, 5, 6)
|
|
check_visible()
|
|
|
|
def test_layout_operations(self):
|
|
for layout_class in (Stack, Horizontal, Tall, Grid):
|
|
q = create_layout(layout_class)
|
|
self.do_ops_test(q)
|
|
|
|
def test_overlay_layout_operations(self):
|
|
for layout_class in (Stack, Horizontal, Tall, Grid):
|
|
q = create_layout(layout_class)
|
|
self.do_overlay_test(q)
|
|
|
|
def test_splits(self):
|
|
q = create_layout(Splits)
|
|
all_windows = create_windows(q, num=0)
|
|
q.add_window(all_windows, Window(1))
|
|
self.ae(all_windows.active_group_idx, 0)
|
|
q.add_window(all_windows, Window(2), location='vsplit')
|
|
self.ae(all_windows.active_group_idx, 1)
|
|
q(all_windows)
|
|
self.ae(q.pairs_root.pair_for_window(2).horizontal, True)
|
|
q.add_window(all_windows, Window(3), location='hsplit')
|
|
self.ae(q.pairs_root.pair_for_window(2).horizontal, False)
|
|
q.add_window(all_windows, Window(4), location='vsplit')
|
|
windows = list(all_windows)
|
|
windows[0].set_geometry(WindowGeometry(0, 0, 10, 20, 0, 0))
|
|
windows[1].set_geometry(WindowGeometry(11, 0, 20, 10, 0, 0))
|
|
windows[2].set_geometry(WindowGeometry(11, 11, 15, 20, 0, 0))
|
|
windows[3].set_geometry(WindowGeometry(16, 11, 20, 20, 0, 0))
|
|
self.ae(q.neighbors_for_window(windows[0], all_windows), {'right': [2, 3]})
|
|
self.ae(q.neighbors_for_window(windows[1], all_windows), {'left': [1], 'bottom': [3, 4]})
|
|
self.ae(q.neighbors_for_window(windows[2], all_windows), {'left': [1], 'right': [4], 'top': [2]})
|
|
self.ae(q.neighbors_for_window(windows[3], all_windows), {'left': [3], 'top': [2]})
|
|
|
|
def test_splits_unserialize_into_unused_layout(self):
|
|
# Restoring the state of a layout that was not the active one when the session
|
|
# was saved: its pairs tree is empty, and the window list must not be
|
|
# reordered, since only the layout being made current does that.
|
|
q = create_layout(Splits)
|
|
all_windows = create_windows(q, num=0)
|
|
for wid, loc in ((1, None), (2, 'hsplit'), (3, 'vsplit')):
|
|
win = Window(wid)
|
|
win.serialized_id = wid
|
|
q.add_window(all_windows, win, location=loc)
|
|
q(all_windows)
|
|
expected = {'horizontal': False, 'one': 1, 'two': {'one': 2, 'two': 3}}
|
|
self.ae(q.pairs_root.serialize(), expected)
|
|
state = q.serialize(all_windows)
|
|
groups_before = [g.id for g in all_windows.groups]
|
|
|
|
fresh = create_layout(Splits)
|
|
self.ae(fresh.pairs_root.serialize(), {})
|
|
self.assertTrue(fresh.unserialize(state, all_windows, apply_to_window_list=False))
|
|
self.ae(fresh.pairs_root.serialize(), expected)
|
|
self.ae([g.id for g in all_windows.groups], groups_before)
|
|
|
|
def test_unserialize_malformed_state(self):
|
|
# unserialize() must return False gracefully for bad session data rather
|
|
# than raising KeyError or similar.
|
|
q = create_layout(Tall)
|
|
all_windows = create_windows(q, num=3)
|
|
for w in all_windows.all_windows:
|
|
w.serialized_id = w.id
|
|
q(all_windows)
|
|
|
|
# Missing 'all_windows' key
|
|
state = q.serialize(all_windows)
|
|
del state['all_windows']
|
|
self.assertFalse(q.unserialize(state, all_windows))
|
|
|
|
# Wrong 'class' value
|
|
state = q.serialize(all_windows)
|
|
state['class'] = 'NonExistentLayout'
|
|
self.assertFalse(q.unserialize(state, all_windows))
|
|
|
|
# Mismatched layout type (Tall state passed to Splits)
|
|
state = q.serialize(all_windows)
|
|
other = create_layout(Splits)
|
|
self.assertFalse(other.unserialize(state, all_windows))
|
|
|
|
def test_unserialize_inactive_layout_non_splits(self):
|
|
# apply_to_window_list=False must not reorder windows for non-Splits layouts.
|
|
q = create_layout(Tall)
|
|
all_windows = create_windows(q, num=3)
|
|
for w in all_windows.all_windows:
|
|
w.serialized_id = w.id
|
|
q(all_windows)
|
|
state = q.serialize(all_windows)
|
|
groups_before = [g.id for g in all_windows.groups]
|
|
active_before = all_windows.active_group_idx
|
|
|
|
fresh = create_layout(Tall)
|
|
self.assertTrue(fresh.unserialize(state, all_windows, apply_to_window_list=False))
|
|
self.ae([g.id for g in all_windows.groups], groups_before)
|
|
self.ae(all_windows.active_group_idx, active_before)
|
|
|
|
def test_active_group_idx_preserved_after_unserialize(self):
|
|
# When unserialize reorders the window list, active_group_idx must be
|
|
# updated so it still points to the same group object.
|
|
#
|
|
# Simulate a session restore where windows were created in a different
|
|
# order than the serialised state expects. The original session had
|
|
# windows [1,2,3] in that order with window 3 active. The fresh list
|
|
# has windows with the same serialised ids but inserted in reverse
|
|
# order, so after unserialize the groups array is shuffled.
|
|
original = create_layout(Stack)
|
|
orig_windows = create_windows(original, num=0)
|
|
for wid in (1, 2, 3):
|
|
win = Window(wid)
|
|
win.serialized_id = wid
|
|
orig_windows.add_window(win)
|
|
original(orig_windows)
|
|
orig_windows.set_active_group_idx(2) # window 3 active
|
|
state = original.serialize(orig_windows)
|
|
|
|
# Fresh window list: windows added in reverse serialised-id order so
|
|
# their group positions differ from the serialised group order.
|
|
fresh = create_layout(Stack)
|
|
fresh_windows = create_windows(fresh, num=0)
|
|
for actual_id, serialized_id in ((10, 3), (20, 2), (30, 1)):
|
|
win = Window(actual_id)
|
|
win.serialized_id = serialized_id
|
|
fresh_windows.add_window(win)
|
|
fresh(fresh_windows)
|
|
# Simulate _startup: set active to the window whose serialised id is 3
|
|
# (i.e. the window with actual_id=10, which is at index 0).
|
|
fresh_windows.set_active_group_idx(0)
|
|
active_group = fresh_windows.active_group
|
|
|
|
self.assertTrue(fresh.unserialize(state, fresh_windows))
|
|
# active_group_idx must still point to the same group object after reorder.
|
|
self.assertIs(fresh_windows.groups[fresh_windows.active_group_idx], active_group)
|
|
|
|
def test_unserialize_session_roundtrip_splits(self):
|
|
# Full serialize → unserialize round-trip for Splits: tree structure and
|
|
# window ordering are both restored correctly.
|
|
q = create_layout(Splits)
|
|
all_windows = create_windows(q, num=0)
|
|
for wid, loc in ((1, None), (2, 'vsplit'), (3, 'hsplit')):
|
|
win = Window(wid)
|
|
win.serialized_id = wid
|
|
q.add_window(all_windows, win, location=loc)
|
|
q(all_windows)
|
|
tree_before = q.pairs_root.serialize()
|
|
state = q.serialize(all_windows)
|
|
expected_groups = [g.id for g in all_windows.groups]
|
|
|
|
# Restore into the same window list (simulating a session with identical
|
|
# windows but a fresh layout object, as happens on restart).
|
|
fresh = create_layout(Splits)
|
|
self.assertTrue(fresh.unserialize(state, all_windows))
|
|
self.ae(fresh.pairs_root.serialize(), tree_before)
|
|
self.ae([g.id for g in all_windows.groups], expected_groups)
|
|
|
|
def test_unserialize_session_roundtrip_tall(self):
|
|
# Full serialize → unserialize round-trip for the Tall layout: custom
|
|
# bias values and window ordering are preserved.
|
|
q = create_layout(Tall)
|
|
all_windows = create_windows(q, num=3)
|
|
for w in all_windows.all_windows:
|
|
w.serialized_id = w.id
|
|
q(all_windows)
|
|
# Skew the main bias so we have something non-default to verify.
|
|
q.main_bias = list(q.main_bias)
|
|
q.main_bias[0] = 0.7
|
|
state = q.serialize(all_windows)
|
|
expected_groups = [g.id for g in all_windows.groups]
|
|
|
|
fresh = create_layout(Tall)
|
|
self.assertTrue(fresh.unserialize(state, all_windows))
|
|
self.ae(fresh.main_bias[0], 0.7)
|
|
self.ae([g.id for g in all_windows.groups], expected_groups)
|
|
|
|
def test_splits_maximize(self):
|
|
q = create_layout(Splits)
|
|
all_windows = create_windows(q, num=0)
|
|
w1 = Window(1)
|
|
q.add_window(all_windows, w1)
|
|
w2 = Window(2)
|
|
q.add_window(all_windows, w2, location='vsplit')
|
|
w3 = Window(3)
|
|
q.add_window(all_windows, w3, location='hsplit')
|
|
# Layout: w1 | (w2 above w3) — horizontal split at root, vertical split on right
|
|
root = q.pairs_root
|
|
# root is horizontal, containing w1 and [w2/w3 vertical pair]
|
|
self.ae(root.horizontal, True)
|
|
right_pair = root.two if isinstance(root.two, Pair) else root.one
|
|
self.assertIsInstance(right_pair, Pair)
|
|
|
|
# Focus window 3 (bottom-right)
|
|
all_windows.set_active_group_idx(all_windows.groups.index(all_windows.group_for_window(w3)))
|
|
|
|
# Save original biases
|
|
root_bias_before = root.bias
|
|
right_pair_bias_before = right_pair.bias
|
|
|
|
# maximize vertical (fill full height) — affects vertical (horizontal==False) pairs
|
|
result = q.layout_action('maximize', ('vertical',), all_windows)
|
|
self.assertTrue(result)
|
|
# right_pair is vertical (horizontal==False) so its bias should be 0.0 (w3 is in 'two')
|
|
self.ae(right_pair.bias, 0.0)
|
|
# root is horizontal so its bias should be unchanged
|
|
self.ae(root.bias, root_bias_before)
|
|
# _maximized_biases should track w3's vertical maximize
|
|
self.assertIn((all_windows.active_group.id, False), q._maximized_biases)
|
|
|
|
# Toggle back
|
|
result = q.layout_action('maximize', ('vertical',), all_windows)
|
|
self.assertTrue(result)
|
|
self.ae(right_pair.bias, right_pair_bias_before)
|
|
self.ae(getattr(q, '_maximized_biases', {}), {})
|
|
|
|
# maximize horizontal (fill full width) — affects horizontal pairs
|
|
result = q.layout_action('maximize', ('horizontal',), all_windows)
|
|
self.assertTrue(result)
|
|
# root is horizontal, w3 is under root.two (right side), so bias should be 0.0
|
|
self.ae(root.bias, 0.0)
|
|
# right_pair is vertical, so unchanged
|
|
self.ae(right_pair.bias, right_pair_bias_before)
|
|
|
|
# Toggle back
|
|
result = q.layout_action('maximize', ('horizontal',), all_windows)
|
|
self.assertTrue(result)
|
|
self.ae(root.bias, root_bias_before)
|
|
|
|
def test_splits_equalize(self):
|
|
q = create_layout(Splits)
|
|
all_windows = create_windows(q, num=0)
|
|
w1 = Window(1)
|
|
q.add_window(all_windows, w1)
|
|
w2 = Window(2)
|
|
q.add_window(all_windows, w2, location='vsplit')
|
|
w3 = Window(3)
|
|
q.add_window(all_windows, w3, location='vsplit')
|
|
# Tree: root(H) -> w1, Pair(H) -> w2, w3
|
|
# Proportional equalize: root.bias=1/3, inner.bias=0.5
|
|
root = q.pairs_root
|
|
inner = root.two if isinstance(root.two, Pair) else root.one
|
|
self.assertIsInstance(inner, Pair)
|
|
|
|
# Skew biases so equalize has something to fix
|
|
root.bias = 0.8
|
|
inner.bias = 0.8
|
|
|
|
result = q.layout_action('equalize', (), all_windows)
|
|
self.assertTrue(result)
|
|
self.assertAlmostEqual(root.bias, 1 / 3, places=5)
|
|
self.assertAlmostEqual(inner.bias, 0.5, places=5)
|
|
|
|
# Single window — equalize should still succeed
|
|
q2 = create_layout(Splits)
|
|
aw2 = create_windows(q2, num=0)
|
|
q2.add_window(aw2, Window(10))
|
|
result = q2.layout_action('equalize', (), aw2)
|
|
self.assertTrue(result)
|
|
|
|
def test_splits_equalize_mixed(self):
|
|
# One vsplit then three hsplits, each from the freshly added window:
|
|
# root(H) -> w1, inner1(V) -> w2, inner2(V) -> w3, inner3(V) -> w4, w5
|
|
# Equalize should give each of w2-w5 an equal share of the right column.
|
|
q = create_layout(Splits)
|
|
all_windows = create_windows(q, num=0)
|
|
q.add_window(all_windows, Window(1))
|
|
q.add_window(all_windows, Window(2), location='vsplit')
|
|
q.add_window(all_windows, Window(3), location='hsplit')
|
|
q.add_window(all_windows, Window(4), location='hsplit')
|
|
q.add_window(all_windows, Window(5), location='hsplit')
|
|
|
|
root = q.pairs_root
|
|
inner1 = root.two
|
|
self.assertIsInstance(inner1, Pair)
|
|
inner2 = inner1.two
|
|
self.assertIsInstance(inner2, Pair)
|
|
inner3 = inner2.two
|
|
self.assertIsInstance(inner3, Pair)
|
|
|
|
for pair in root.self_and_descendants():
|
|
pair.bias = 0.9
|
|
|
|
result = q.layout_action('equalize', (), all_windows)
|
|
self.assertTrue(result)
|
|
self.assertAlmostEqual(root.bias, 0.5, places=5) # w1 vs right column: 1:1
|
|
self.assertAlmostEqual(inner1.bias, 1 / 4, places=5) # w2 vs [w3,w4,w5]: 1:3
|
|
self.assertAlmostEqual(inner2.bias, 1 / 3, places=5) # w3 vs [w4,w5]: 1:2
|
|
self.assertAlmostEqual(inner3.bias, 0.5, places=5) # w4 vs w5: 1:1
|
|
|
|
def test_splits_equalize_after_remove(self):
|
|
# 1 vsplit + 2 hsplits: root(H) -> w1, inner1(V) -> w2, inner2(V) -> w3, w4
|
|
q = create_layout(Splits)
|
|
all_windows = create_windows(q, num=0)
|
|
w1, w2, w3, w4 = Window(1), Window(2), Window(3), Window(4)
|
|
q.add_window(all_windows, w1)
|
|
q.add_window(all_windows, w2, location='vsplit')
|
|
q.add_window(all_windows, w3, location='hsplit')
|
|
q.add_window(all_windows, w4, location='hsplit')
|
|
|
|
root = q.pairs_root
|
|
inner1 = root.two
|
|
inner2 = inner1.two
|
|
self.assertIsInstance(inner1, Pair)
|
|
self.assertIsInstance(inner2, Pair)
|
|
|
|
result = q.layout_action('equalize', (), all_windows)
|
|
self.assertTrue(result)
|
|
self.assertAlmostEqual(root.bias, 0.5, places=5) # w1 vs right column: 1:1
|
|
self.assertAlmostEqual(inner1.bias, 1 / 3, places=5) # w2 vs [w3,w4]: 1:2 → RHS in thirds
|
|
self.assertAlmostEqual(inner2.bias, 0.5, places=5) # w3 vs w4: 1:1
|
|
|
|
# Remove w4 — inner2 collapses: inner1.two becomes grp_w3 leaf
|
|
g4 = all_windows.group_for_window(w4)
|
|
q.remove_windows(g4.id)
|
|
|
|
self.assertNotIsInstance(inner1.two, Pair) # collapsed to a leaf
|
|
|
|
result = q.layout_action('equalize', (), all_windows)
|
|
self.assertTrue(result)
|
|
self.assertAlmostEqual(root.bias, 0.5, places=5) # w1 vs right column: 1:1
|
|
self.assertAlmostEqual(inner1.bias, 0.5, places=5) # w2 vs w3 top/bottom: 1:1
|
|
|
|
def test_splits_collapse_nested_empty_pairs(self):
|
|
# Removing every window of a nested sub-tree in a single pass must not
|
|
# leave an empty pair behind, still consuming its share of the space.
|
|
q = create_layout(Splits)
|
|
all_windows = create_windows(q, num=0)
|
|
for i in range(1, 6):
|
|
q.add_window(all_windows, Window(i))
|
|
q.pairs_root.unserialize({'one': {'one': {'one': 1, 'two': 2}, 'two': {'one': 3, 'two': 4}}, 'two': 5}, lambda x: x)
|
|
q.remove_windows(3, 2, 1, 4)
|
|
self.ae(list(q.pairs_root.all_window_ids()), [5])
|
|
for pair in q.pairs_root.self_and_descendants():
|
|
self.assertFalse(pair.one is None and pair.two is None, f'empty pair left in tree: {q.pairs_root}')
|
|
self.ae(q.pairs_root.window_weights(), {5: 1.0})
|
|
|
|
def test_splits_relayout_after_root_collapse(self):
|
|
# Windows added in the same relayout that collapses the root must go into
|
|
# the new root, not the discarded one.
|
|
q = create_layout(Splits)
|
|
all_windows = create_windows(q, num=0)
|
|
for i in (1, 2, 3):
|
|
q.add_window(all_windows, Window(i), location='vsplit')
|
|
all_windows.remove_window(all_windows.id_map[1])
|
|
all_windows.add_window(Window(4))
|
|
q(all_windows)
|
|
self.ae(sorted(q.pairs_root.all_window_ids()), [2, 3, 4])
|
|
|
|
def test_layout_opts_serialization(self):
|
|
opts = SplitsLayoutOpts({})
|
|
s = opts.serialized()
|
|
self.ae(s, SplitsLayoutOpts(s).serialized())
|
|
|
|
def test_splits_equalize_on_close(self):
|
|
q = create_layout(Splits)
|
|
q.layout_opts = SplitsLayoutOpts({})
|
|
q.layout_opts.equalize_on_close = True
|
|
all_windows = create_windows(q, num=0)
|
|
w1, w2, w3 = Window(1), Window(2), Window(3)
|
|
q.add_window(all_windows, w1)
|
|
q.add_window(all_windows, w2, location='vsplit')
|
|
q.add_window(all_windows, w3, location='vsplit')
|
|
|
|
root = q.pairs_root
|
|
root.bias = 0.9
|
|
inner = root.two if isinstance(root.two, Pair) else root.one
|
|
self.assertIsInstance(inner, Pair)
|
|
inner.bias = 0.9
|
|
|
|
g3 = all_windows.group_for_window(w3)
|
|
q.remove_windows(g3.id)
|
|
|
|
result = q.on_window_removed(all_windows)
|
|
self.assertTrue(result)
|
|
self.assertAlmostEqual(root.bias, 0.5, places=5)
|
|
|
|
# equalize_on_close=false (default) must not trigger equalization
|
|
q2 = create_layout(Splits)
|
|
aw2 = create_windows(q2, num=0)
|
|
q2.add_window(aw2, Window(10))
|
|
q2.add_window(aw2, Window(11), location='vsplit')
|
|
q2.pairs_root.bias = 0.9
|
|
result = q2.on_window_removed(aw2)
|
|
self.assertFalse(result)
|
|
self.assertAlmostEqual(q2.pairs_root.bias, 0.9, places=5)
|
|
|
|
def test_splits_equalize_redundant_pair(self):
|
|
# Equalizing must leave a pair holding a single window with an even bias,
|
|
# as that bias is used when the pair is split again, see #10522
|
|
def split_after(equalize_on_close: bool, bias: float) -> float:
|
|
q = create_layout(Splits)
|
|
q.layout_opts = SplitsLayoutOpts({})
|
|
q.layout_opts.equalize_on_close = equalize_on_close
|
|
all_windows = create_windows(q, num=0)
|
|
q.add_window(all_windows, Window(1))
|
|
w2 = Window(2)
|
|
q.add_window(all_windows, w2, location='vsplit')
|
|
q.pairs_root.bias = bias
|
|
q.remove_windows(all_windows.group_for_window(w2).id)
|
|
all_windows.remove_window(w2)
|
|
if equalize_on_close:
|
|
self.assertTrue(q.on_window_removed(all_windows))
|
|
else:
|
|
self.assertTrue(q.layout_action('equalize', (), all_windows))
|
|
q.add_window(all_windows, Window(3), location='hsplit')
|
|
return q.pairs_root.bias
|
|
|
|
for equalize_on_close in (False, True):
|
|
with self.subTest(equalize_on_close=equalize_on_close):
|
|
self.assertAlmostEqual(split_after(equalize_on_close, 0.5), 0.5, places=5)
|
|
self.assertAlmostEqual(split_after(equalize_on_close, 0.8), 0.5, places=5)
|
|
|
|
# Without an equalize, the bias of a closed split is preserved by design
|
|
q = create_layout(Splits)
|
|
all_windows = create_windows(q, num=0)
|
|
q.add_window(all_windows, Window(1))
|
|
w2 = Window(2)
|
|
q.add_window(all_windows, w2, location='vsplit')
|
|
q.pairs_root.bias = 0.8
|
|
q.remove_windows(all_windows.group_for_window(w2).id)
|
|
all_windows.remove_window(w2)
|
|
self.assertFalse(q.on_window_removed(all_windows))
|
|
q.add_window(all_windows, Window(3), location='vsplit')
|
|
self.assertAlmostEqual(q.pairs_root.bias, 0.8, places=5)
|
|
|
|
def test_layout_dimension_no_negative_cells(self):
|
|
# Regression test for issue #9946: when window padding exceeds the
|
|
# available space (e.g. after maximize sets a window to minimum width),
|
|
# layout_dimension must not produce a negative cells_per_window value
|
|
# which would cause right < left in the resulting window geometry.
|
|
for length, cell_length, decs in (
|
|
(8, 8, [(5, 5)]), # padding (10) > length (8) > cell_length (8)
|
|
(6, 8, [(4, 4)]), # length < cell_length
|
|
(0, 8, [(4, 4)]), # zero length
|
|
(4, 8, [(3, 3)]), # space_needed == length, no room for cells
|
|
):
|
|
result = next(layout_dimension(0, length, cell_length, decs))
|
|
self.assertGreaterEqual(
|
|
result.cells_per_window, 0, f'cells_per_window={result.cells_per_window} < 0 for length={length}, cell_length={cell_length}, decs={decs}'
|
|
)
|
|
self.assertGreaterEqual(
|
|
result.content_size, 0, f'content_size={result.content_size} < 0 for length={length}, cell_length={cell_length}, decs={decs}'
|
|
)
|
|
# content_pos must be within [0, length]: right edge = content_pos + content_size <= length
|
|
self.assertGreaterEqual(result.content_pos, 0)
|
|
self.assertLessEqual(
|
|
result.content_pos + result.content_size,
|
|
length,
|
|
f'right ({result.content_pos + result.content_size}) > length ({length}) for cell_length={cell_length}, decs={decs}',
|
|
)
|
|
|
|
def test_drag_resize_target_windows(self):
|
|
# Helper: call drag_resize_target_windows with given window and edge flags.
|
|
def drtw(q, all_windows, window, edges):
|
|
return q.drag_resize_target_windows(window, 0, 0, edges, all_windows)
|
|
|
|
# --- 2-window horizontal split: A | B ---
|
|
q = create_layout(Splits)
|
|
all_windows = create_windows(q, num=0)
|
|
wA = Window(1)
|
|
q.add_window(all_windows, wA)
|
|
wB = Window(2)
|
|
q.add_window(all_windows, wB, location='vsplit')
|
|
q(all_windows)
|
|
root = q.pairs_root
|
|
self.ae(root.horizontal, True)
|
|
root_id = id(root)
|
|
|
|
# Right edge of A (left of divider): divider belongs to root, A is on one-side
|
|
d = drtw(q, all_windows, wA, RIGHT_EDGE)
|
|
self.ae(d.horizontal_id, root_id)
|
|
self.ae(d.width_increases_rightwards, True)
|
|
|
|
# Left edge of B (right of divider): same divider, same direction
|
|
d = drtw(q, all_windows, wB, LEFT_EDGE)
|
|
self.ae(d.horizontal_id, root_id)
|
|
self.ae(d.width_increases_rightwards, True)
|
|
|
|
# Right edge of B (outer border): direction reversed
|
|
d = drtw(q, all_windows, wB, RIGHT_EDGE)
|
|
self.ae(d.horizontal_id, root_id)
|
|
self.ae(d.width_increases_rightwards, False)
|
|
|
|
# --- 2-window vertical split: A / B ---
|
|
q = create_layout(Splits)
|
|
all_windows = create_windows(q, num=0)
|
|
wA = Window(1)
|
|
q.add_window(all_windows, wA)
|
|
wB = Window(2)
|
|
q.add_window(all_windows, wB, location='hsplit')
|
|
q(all_windows)
|
|
root = q.pairs_root
|
|
self.ae(root.horizontal, False)
|
|
root_id = id(root)
|
|
|
|
# Bottom edge of A: divider belongs to root, A is in one-side
|
|
d = drtw(q, all_windows, wA, BOTTOM_EDGE)
|
|
self.ae(d.vertical_id, root_id)
|
|
self.ae(d.height_increases_downwards, True)
|
|
|
|
# Top edge of B: same divider
|
|
d = drtw(q, all_windows, wB, TOP_EDGE)
|
|
self.ae(d.vertical_id, root_id)
|
|
self.ae(d.height_increases_downwards, True)
|
|
|
|
# Bottom edge of B (outer border): direction reversed
|
|
d = drtw(q, all_windows, wB, BOTTOM_EDGE)
|
|
self.ae(d.vertical_id, root_id)
|
|
self.ae(d.height_increases_downwards, False)
|
|
|
|
# --- 3-window layout: top_pair(A | B) / C ---
|
|
# root(vertical) -> one: top_pair(horizontal, one=A, two=B), two: C
|
|
q = create_layout(Splits)
|
|
all_windows = create_windows(q, num=0)
|
|
wA = Window(1)
|
|
q.add_window(all_windows, wA)
|
|
wC = Window(3)
|
|
q.add_window(all_windows, wC, location='hsplit') # C below A (vertical root)
|
|
all_windows.set_active_window_group_for(wA)
|
|
wB = Window(2)
|
|
q.add_window(all_windows, wB, location='vsplit') # B right of A (horizontal top_pair)
|
|
q(all_windows)
|
|
root = q.pairs_root
|
|
self.ae(root.horizontal, False)
|
|
top_pair = root.one
|
|
self.assertIsInstance(top_pair, Pair)
|
|
self.ae(top_pair.horizontal, True)
|
|
root_id = id(root)
|
|
top_pair_id = id(top_pair)
|
|
|
|
# Divider between A and B: belongs to top_pair
|
|
d = drtw(q, all_windows, wA, RIGHT_EDGE)
|
|
self.ae(d.horizontal_id, top_pair_id)
|
|
self.ae(d.width_increases_rightwards, True)
|
|
|
|
d = drtw(q, all_windows, wB, LEFT_EDGE)
|
|
self.ae(d.horizontal_id, top_pair_id)
|
|
self.ae(d.width_increases_rightwards, True)
|
|
|
|
# Divider between top_pair and C: belongs to root
|
|
d = drtw(q, all_windows, wA, BOTTOM_EDGE)
|
|
self.ae(d.vertical_id, root_id)
|
|
self.ae(d.height_increases_downwards, True)
|
|
|
|
d = drtw(q, all_windows, wB, BOTTOM_EDGE)
|
|
self.ae(d.vertical_id, root_id)
|
|
self.ae(d.height_increases_downwards, True)
|
|
|
|
d = drtw(q, all_windows, wC, TOP_EDGE)
|
|
self.ae(d.vertical_id, root_id)
|
|
self.ae(d.height_increases_downwards, True)
|
|
|
|
# --- 3-window layout: A | right_pair(B / C) ---
|
|
# root(horizontal) -> one: A, two: right_pair(vertical, one=B, two=C)
|
|
q = create_layout(Splits)
|
|
all_windows = create_windows(q, num=0)
|
|
wA = Window(1)
|
|
q.add_window(all_windows, wA)
|
|
wB = Window(2)
|
|
q.add_window(all_windows, wB, location='vsplit') # B right of A (horizontal root)
|
|
wC = Window(3)
|
|
q.add_window(all_windows, wC, location='hsplit') # C below B (vertical right_pair)
|
|
q(all_windows)
|
|
root = q.pairs_root
|
|
self.ae(root.horizontal, True)
|
|
right_pair = root.two
|
|
self.assertIsInstance(right_pair, Pair)
|
|
self.ae(right_pair.horizontal, False)
|
|
root_id = id(root)
|
|
right_pair_id = id(right_pair)
|
|
|
|
# Divider between A and right_pair: A at RIGHT_EDGE -> root
|
|
d = drtw(q, all_windows, wA, RIGHT_EDGE)
|
|
self.ae(d.horizontal_id, root_id)
|
|
self.ae(d.width_increases_rightwards, True)
|
|
|
|
# B at LEFT_EDGE: B is on the leading side of right_pair, border belongs to root
|
|
d = drtw(q, all_windows, wB, LEFT_EDGE)
|
|
self.ae(d.horizontal_id, root_id)
|
|
self.ae(d.width_increases_rightwards, True)
|
|
|
|
# Divider between B and C: belongs to right_pair
|
|
d = drtw(q, all_windows, wB, BOTTOM_EDGE)
|
|
self.ae(d.vertical_id, right_pair_id)
|
|
self.ae(d.height_increases_downwards, True)
|
|
|
|
d = drtw(q, all_windows, wC, TOP_EDGE)
|
|
self.ae(d.vertical_id, right_pair_id)
|
|
self.ae(d.height_increases_downwards, True)
|
|
|
|
# --- 4-window layout (bug scenario): left_pair(A/C) | right_pair(B/D) ---
|
|
# root(horizontal) -> one: left_pair(vertical, one=A, two=C),
|
|
# two: right_pair(vertical, one=B, two=D)
|
|
q = create_layout(Splits)
|
|
all_windows = create_windows(q, num=0)
|
|
wA = Window(1)
|
|
q.add_window(all_windows, wA)
|
|
wB = Window(2)
|
|
q.add_window(all_windows, wB, location='vsplit') # B right of A
|
|
all_windows.set_active_window_group_for(wA)
|
|
wC = Window(3)
|
|
q.add_window(all_windows, wC, location='hsplit') # C below A
|
|
all_windows.set_active_window_group_for(wB)
|
|
wD = Window(4)
|
|
q.add_window(all_windows, wD, location='hsplit') # D below B
|
|
q(all_windows)
|
|
root = q.pairs_root
|
|
self.ae(root.horizontal, True)
|
|
left_pair = root.one
|
|
right_pair = root.two
|
|
self.assertIsInstance(left_pair, Pair)
|
|
self.assertIsInstance(right_pair, Pair)
|
|
self.ae(left_pair.horizontal, False)
|
|
self.ae(right_pair.horizontal, False)
|
|
root_id = id(root)
|
|
left_pair_id = id(left_pair)
|
|
right_pair_id = id(right_pair)
|
|
|
|
# Bug #1: A at RIGHT_EDGE should give root with correct (rightward) direction
|
|
d = drtw(q, all_windows, wA, RIGHT_EDGE)
|
|
self.ae(d.horizontal_id, root_id)
|
|
self.ae(d.width_increases_rightwards, True)
|
|
|
|
# Bug #2: B at LEFT_EDGE should find root and give correct direction
|
|
d = drtw(q, all_windows, wB, LEFT_EDGE)
|
|
self.ae(d.horizontal_id, root_id)
|
|
self.ae(d.width_increases_rightwards, True)
|
|
|
|
# C at RIGHT_EDGE: same divider between left_pair and right_pair
|
|
d = drtw(q, all_windows, wC, RIGHT_EDGE)
|
|
self.ae(d.horizontal_id, root_id)
|
|
self.ae(d.width_increases_rightwards, True)
|
|
|
|
# D at LEFT_EDGE: same divider
|
|
d = drtw(q, all_windows, wD, LEFT_EDGE)
|
|
self.ae(d.horizontal_id, root_id)
|
|
self.ae(d.width_increases_rightwards, True)
|
|
|
|
# Vertical divider within left_pair (between A and C)
|
|
d = drtw(q, all_windows, wA, BOTTOM_EDGE)
|
|
self.ae(d.vertical_id, left_pair_id)
|
|
self.ae(d.height_increases_downwards, True)
|
|
|
|
d = drtw(q, all_windows, wC, TOP_EDGE)
|
|
self.ae(d.vertical_id, left_pair_id)
|
|
self.ae(d.height_increases_downwards, True)
|
|
|
|
# Vertical divider within right_pair (between B and D)
|
|
d = drtw(q, all_windows, wB, BOTTOM_EDGE)
|
|
self.ae(d.vertical_id, right_pair_id)
|
|
self.ae(d.height_increases_downwards, True)
|
|
|
|
d = drtw(q, all_windows, wD, TOP_EDGE)
|
|
self.ae(d.vertical_id, right_pair_id)
|
|
self.ae(d.height_increases_downwards, True)
|
|
|
|
|
|
class BaseSplitGeometryTest(BaseTest):
|
|
# These tests stub out Layout._set_dimensions, so they have to put back the lgd
|
|
# singleton, which is global state shared with every other layout test.
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.set_options({'tab_bar_style': 'hidden'})
|
|
saved = vars(lgd).copy()
|
|
self.addCleanup(lambda: (vars(lgd).clear(), vars(lgd).update(saved)))
|
|
|
|
def stub_dimensions(self, layout, central, minimal=True):
|
|
def dimensions(all_windows):
|
|
lgd.central = central
|
|
lgd.cell_width, lgd.cell_height = 10, 20
|
|
lgd.draw_minimal_borders = minimal
|
|
|
|
layout._set_dimensions = dimensions
|
|
|
|
def check_extents_fit(self, layout):
|
|
# Every pair must divide its area exactly between its two halves and the
|
|
# borders between them, otherwise windows overlap their neighbours.
|
|
for p in layout.pairs_root.self_and_descendants():
|
|
if p.is_redundant:
|
|
continue
|
|
with self.subTest(pair=repr(p)):
|
|
if p.horizontal:
|
|
one = p.first_extent.right - p.first_extent.left
|
|
two = p.second_extent.right - p.second_extent.left
|
|
self.ae(one + two + 2 * p.border_width, p.width)
|
|
self.ae(p.second_extent.right, p.left + p.width)
|
|
else:
|
|
one = p.first_extent.bottom - p.first_extent.top
|
|
two = p.second_extent.bottom - p.second_extent.top
|
|
self.ae(one + two + 2 * p.border_width, p.height)
|
|
self.ae(p.second_extent.bottom, p.top + p.height)
|
|
|
|
|
|
class TestSplitBorderResize(BaseSplitGeometryTest):
|
|
def make_layout(self, shape):
|
|
layout = create_layout(Splits)
|
|
windows = create_windows(layout, num=0)
|
|
for i in range(1, 5):
|
|
layout.add_window(windows, Window(i))
|
|
layout.pairs_root.unserialize(shape, lambda x: x)
|
|
self.stub_dimensions(layout, Region((0, 0, 1499, 1099, 1500, 1100)))
|
|
layout(windows)
|
|
return layout, windows
|
|
|
|
def test_left_center_stack_right_after_resize(self):
|
|
layout, windows = self.make_layout(
|
|
{
|
|
'bias': 1 / 3,
|
|
'one': 1,
|
|
'two': {'one': {'horizontal': False, 'one': 2, 'two': 3}, 'two': 4},
|
|
}
|
|
)
|
|
root = layout.pairs_root
|
|
right_pair = root.two
|
|
center = right_pair.one
|
|
ws = {w.id: w for w in windows}
|
|
# Resize right first, then alternate both sides of the left and right
|
|
# dividers and both halves of the central horizontal divider.
|
|
for _ in range(3):
|
|
for wid, edge, expected in (
|
|
(4, LEFT_EDGE, right_pair),
|
|
(2, LEFT_EDGE, root),
|
|
(3, LEFT_EDGE, root),
|
|
(1, RIGHT_EDGE, root),
|
|
(2, RIGHT_EDGE, right_pair),
|
|
(3, RIGHT_EDGE, right_pair),
|
|
(2, BOTTOM_EDGE, center),
|
|
(3, TOP_EDGE, center),
|
|
):
|
|
for increment in (3, -3):
|
|
with self.subTest(wid=wid, edge=edge, increment=increment):
|
|
data = layout.drag_resize_target_windows(ws[wid], 0, 0, edge, windows)
|
|
horizontal = bool(edge & (LEFT_EDGE | RIGHT_EDGE))
|
|
target = data.horizontal_id if horizontal else data.vertical_id
|
|
forwards = data.width_increases_rightwards if horizontal else data.height_increases_downwards
|
|
self.assertEqual(target, id(expected))
|
|
self.assertTrue(forwards)
|
|
|
|
def positions():
|
|
return {id(p): p.first_extent.right if p.horizontal else p.first_extent.bottom for p in root.self_and_descendants()}
|
|
|
|
before = positions()
|
|
self.assertTrue(layout.drag_resize_window(windows, target, increment, horizontal))
|
|
layout(windows)
|
|
cell = lgd.cell_width if horizontal else lgd.cell_height
|
|
for pid, position in positions().items():
|
|
self.ae(position - before[pid], increment * cell if pid == target else 0)
|
|
|
|
def test_all_rendered_internal_borders(self):
|
|
# All 5 binary tree shapes with 4 leaves, with every combination of
|
|
# horizontal/vertical ancestors: 40 distinct arrangements.
|
|
def shapes(ids):
|
|
if len(ids) == 1:
|
|
yield ids[0]
|
|
return
|
|
for n in range(1, len(ids)):
|
|
for one in shapes(ids[:n]):
|
|
for two in shapes(ids[n:]):
|
|
for horizontal in (True, False):
|
|
yield {
|
|
'horizontal': horizontal,
|
|
'bias': 0.39,
|
|
'one': one,
|
|
'two': two,
|
|
}
|
|
|
|
count = 0
|
|
for shape in shapes((1, 2, 3, 4)):
|
|
layout, windows = self.make_layout(shape)
|
|
ws = {w.id: w for w in windows}
|
|
for pair in layout.pairs_root.self_and_descendants():
|
|
if pair.is_redundant:
|
|
continue
|
|
for half in pair.between_borders:
|
|
for border in half:
|
|
trailing = border.window_id > 0
|
|
edge = (RIGHT_EDGE if trailing else LEFT_EDGE) if pair.horizontal else (BOTTOM_EDGE if trailing else TOP_EDGE)
|
|
with self.subTest(shape=shape, wid=border.window_id, edge=edge):
|
|
data = layout.drag_resize_target_windows(ws[abs(border.window_id)], 0, 0, edge, windows)
|
|
target = data.horizontal_id if pair.horizontal else data.vertical_id
|
|
forwards = data.width_increases_rightwards if pair.horizontal else data.height_increases_downwards
|
|
self.assertEqual(target, id(pair))
|
|
self.assertTrue(forwards)
|
|
count += 1
|
|
self.assertEqual(count, 120)
|
|
|
|
def test_corner_axes_independent_and_single_pane(self):
|
|
layout, windows = self.make_layout(
|
|
{
|
|
'one': 1,
|
|
'two': {'one': {'horizontal': False, 'one': 2, 'two': 3}, 'two': 4},
|
|
}
|
|
)
|
|
ws = {w.id: w for w in windows}
|
|
data = layout.drag_resize_target_windows(ws[2], 0, 0, LEFT_EDGE | BOTTOM_EDGE, windows)
|
|
self.assertEqual(data.horizontal_id, id(layout.pairs_root))
|
|
self.assertEqual(data.vertical_id, id(layout.pairs_root.two.one))
|
|
self.assertTrue(data.width_increases_rightwards)
|
|
self.assertTrue(data.height_increases_downwards)
|
|
layout.pairs_root = Pair()
|
|
layout.pairs_root.one = 1
|
|
data = layout.drag_resize_target_windows(ws[1], 0, 0, LEFT_EDGE | TOP_EDGE, windows)
|
|
self.assertIsNone(data.horizontal_id)
|
|
self.assertIsNone(data.vertical_id)
|
|
|
|
|
|
class BellWindow(Window):
|
|
needs_attention = False
|
|
|
|
|
|
class TestMinimalBorderColors(BaseSplitGeometryTest):
|
|
def test_active_window_needing_attention_uses_bell_color(self):
|
|
# The active window can need attention when its OS window is unfocused,
|
|
# its minimal borders must then use the bell color not the active color
|
|
for layout_class in (Tall, Fat, Grid, Horizontal, Vertical, Splits):
|
|
for draw_active_borders in (True, False):
|
|
with self.subTest(layout=layout_class.name, draw_active_borders=draw_active_borders):
|
|
layout = create_layout(layout_class)
|
|
windows = create_windows(layout, num=3, window_class=BellWindow)
|
|
self.stub_dimensions(layout, Region((0, 0, 1499, 1099, 1500, 1100)))
|
|
layout(windows)
|
|
lgd.draw_active_borders = draw_active_borders
|
|
active = windows.active_window
|
|
|
|
def colors():
|
|
return {b.color for b in layout.get_minimal_borders(windows) if abs(b.window_id) == active.id}
|
|
|
|
self.ae(colors(), {BorderColor.active} if draw_active_borders else {BorderColor.inactive})
|
|
active.needs_attention = True
|
|
self.ae(colors(), {BorderColor.bell})
|
|
|
|
|
|
class TestReservedSpaces(BaseSplitGeometryTest):
|
|
def test_reserved_spaces_do_not_overlap(self):
|
|
# Custom shaders treat the space a layout reserves around the active
|
|
# window (WindowGeometry.spaces) as part of it, so the reserved boxes
|
|
# of visible windows must fit in the central area without overlapping.
|
|
central = Region((19, 47, 1518, 1146, 1500, 1100))
|
|
for cls in (Tall, Grid, Horizontal, Stack, Splits):
|
|
for minimal in (True, False):
|
|
for num in (1, 2, 3, 5):
|
|
layout = create_layout(cls)
|
|
windows = create_windows(layout, num=num)
|
|
self.stub_dimensions(layout, central, minimal)
|
|
layout(windows)
|
|
boxes = []
|
|
for w in windows:
|
|
if not w.is_visible_in_layout:
|
|
continue
|
|
g = w.geometry
|
|
boxes.append((g.left - g.spaces.left, g.top - g.spaces.top, g.right + g.spaces.right, g.bottom + g.spaces.bottom))
|
|
with self.subTest(layout=cls.name, minimal=minimal, num=num):
|
|
self.assertTrue(boxes)
|
|
for left, top, right, bottom in boxes:
|
|
self.assertGreaterEqual(left, central.left)
|
|
self.assertGreaterEqual(top, central.top)
|
|
self.assertLessEqual(right, central.left + central.width)
|
|
self.assertLessEqual(bottom, central.top + central.height)
|
|
for i, a in enumerate(boxes):
|
|
for b in boxes[i + 1 :]:
|
|
overlaps = a[0] < b[2] and b[0] < a[2] and a[1] < b[3] and b[1] < a[3]
|
|
self.assertFalse(overlaps, f'{a} overlaps {b}')
|
|
|
|
|
|
class WideMarginWindow(Window):
|
|
def effective_margin(self, edge):
|
|
return 5
|
|
|
|
def default_margin(self, edge):
|
|
return 5
|
|
|
|
|
|
class TestFrameAlignment(BaseSplitGeometryTest):
|
|
# The cells never exactly fill these sizes, so windows get compensatory padding
|
|
central = Region((19, 47, 1021, 753, 1003, 707))
|
|
splits_shape = {
|
|
'bias': 0.37,
|
|
'one': {'horizontal': False, 'bias': 0.61, 'one': 1, 'two': 2},
|
|
'two': {'horizontal': False, 'bias': 0.29, 'one': 3, 'two': {'bias': 0.53, 'one': 4, 'two': 5}},
|
|
}
|
|
|
|
def layouts(self, window_class=Window):
|
|
for cls in (Tall, Fat, Grid, Vertical, Horizontal, Splits):
|
|
for num in (2, 3, 5):
|
|
layout = create_layout(cls)
|
|
windows = create_windows(layout, num=num, window_class=window_class)
|
|
if cls is Splits and num == 5:
|
|
layout.pairs_root.unserialize(self.splits_shape, lambda x: x)
|
|
yield layout, windows
|
|
|
|
def frames(self, windows):
|
|
ans = []
|
|
for wg in windows.iter_all_layoutable_groups(only_visible=True):
|
|
rects = []
|
|
add_borders(rects, BorderColor.active, wg)
|
|
frame = min(r.left for r in rects), min(r.top for r in rects), max(r.right for r in rects), max(r.bottom for r in rects)
|
|
g = wg.geometry
|
|
allocation = g.left - g.spaces.left, g.top - g.spaces.top, g.right + g.spaces.right, g.bottom + g.spaces.bottom
|
|
ans.append((frame, allocation, g))
|
|
return ans
|
|
|
|
def check_frames(self, frames, margins, gap, area):
|
|
left, top, right, bottom = area.left, area.top, area.left + area.width, area.top + area.height
|
|
ml, mt, mr, mb = margins
|
|
neighbors = 0
|
|
for frame, allocation, g in frames:
|
|
# Each frame is exactly margin inside its allocation, whatever compensatory padding the window has
|
|
if allocation[0] == left:
|
|
self.ae(frame[0], left + ml)
|
|
if allocation[1] == top:
|
|
self.ae(frame[1], top + mt)
|
|
if allocation[2] == right:
|
|
self.ae(frame[2], right - mr)
|
|
if allocation[3] == bottom:
|
|
self.ae(frame[3], bottom - mb)
|
|
for i, (a, aa, _) in enumerate(frames):
|
|
for b, ba, _ in frames[i + 1 :]:
|
|
for (first, fa), (second, sa) in (((a, aa), (b, ba)), ((b, ba), (a, aa))):
|
|
if fa[2] == sa[0] and min(fa[3], sa[3]) > max(fa[1], sa[1]):
|
|
neighbors += 1
|
|
self.ae(second[0] - first[2], gap)
|
|
if fa[3] == sa[1] and min(fa[2], sa[2]) > max(fa[0], sa[0]):
|
|
neighbors += 1
|
|
self.ae(second[1] - first[3], gap)
|
|
self.assertGreater(neighbors, 0)
|
|
|
|
def test_frames_aligned_and_gaps_uniform(self):
|
|
for layout, windows in self.layouts():
|
|
self.stub_dimensions(layout, self.central, minimal=False)
|
|
layout(windows)
|
|
frames = self.frames(windows)
|
|
with self.subTest(layout=layout.name, num=len(frames)):
|
|
self.assertTrue(any(any(g.compensatory) for _, _, g in frames))
|
|
# margin 1, so the gap between neighbors is 2
|
|
self.check_frames(frames, (1, 1, 1, 1), 2, self.central)
|
|
|
|
def test_title_bar_has_no_compensatory_padding_before_it(self):
|
|
for position in ('top', 'bottom'):
|
|
self.set_options({'tab_bar_style': 'hidden', 'window_title_bar_min_windows': 1, 'window_title_bar': position})
|
|
for layout, windows in self.layouts():
|
|
self.stub_dimensions(layout, self.central, minimal=False)
|
|
layout(windows)
|
|
frames = self.frames(windows)
|
|
with self.subTest(layout=layout.name, num=len(frames), position=position):
|
|
self.assertTrue(all(w.show_title_bar for w in windows))
|
|
self.assertTrue(any(any(g.compensatory) for _, _, g in frames))
|
|
for _, _, g in frames:
|
|
self.ae(g.compensatory.top if position == 'top' else g.compensatory.bottom, 0)
|
|
self.check_frames(frames, (1, 1, 1, 1), 2, self.central)
|
|
self.ae(len(layout.blank_rects), sum(len(tuple(blank_rects_for_window(g))) for _, _, g in frames))
|
|
|
|
def test_collapse_window_margins(self):
|
|
from unittest.mock import patch
|
|
|
|
full = Region((19, 47, 1021, 753, 1003, 707))
|
|
viewport = full, Region((0, 0, 0, 0, 0, 0)), 1100, 800, 10, 20
|
|
for collapse in (False, True):
|
|
self.set_options({'tab_bar_style': 'hidden', 'collapse_window_margins': collapse, 'window_margin_width': 5, 'draw_minimal_borders': False})
|
|
for layout, windows in self.layouts(WideMarginWindow):
|
|
layout.set_active_window_in_os_window = lambda idx: None
|
|
del layout._set_dimensions # remove the stub from create_layout
|
|
with patch('kitty.layout.base.viewport_for_window', return_value=viewport):
|
|
layout(windows)
|
|
frames = self.frames(windows)
|
|
with self.subTest(layout=layout.name, num=len(frames), collapse=collapse):
|
|
if collapse:
|
|
# half the margin is supplied by the inset of the layout area, the
|
|
# rest by the windows and the gap between windows equals the margin
|
|
self.ae(lgd.central, Region((21, 49, 1018, 750, 998, 702)))
|
|
self.ae(layout.collapsed_margin_rects, [(19, 47, 1022, 49), (19, 751, 1022, 754), (19, 49, 21, 751), (1019, 49, 1022, 751)])
|
|
self.assertTrue(set(layout.collapsed_margin_rects).issubset(layout.blank_rects))
|
|
# windows use 3 of their margin of 5 on the left and top and 2 on the right and bottom
|
|
self.check_frames(frames, (3, 3, 2, 2), 5, lgd.central)
|
|
for frame, _, _ in frames:
|
|
self.assertGreaterEqual(frame[0] - full.left, 5)
|
|
self.assertGreaterEqual(frame[1] - full.top, 5)
|
|
self.assertGreaterEqual(full.left + full.width - frame[2], 5)
|
|
self.assertGreaterEqual(full.top + full.height - frame[3], 5)
|
|
else:
|
|
self.ae(lgd.central, full)
|
|
self.ae(layout.collapsed_margin_rects, [])
|
|
self.check_frames(frames, (5, 5, 5, 5), 10, full)
|
|
|
|
|
|
class TestSplitDragGeometry(BaseSplitGeometryTest):
|
|
def make_layout(self, shape, minimal=True, num=4):
|
|
from types import SimpleNamespace
|
|
|
|
from kitty.tabs import Tab as RealTab
|
|
|
|
layout = create_layout(Splits)
|
|
layout.layout_opts = SplitsLayoutOpts({'proportional': 'yes'})
|
|
windows = create_windows(layout, num=num)
|
|
layout.pairs_root.unserialize(shape, lambda x: x)
|
|
self.stub_dimensions(layout, Region((19, 47, 1518, 1146, 1500, 1100)), minimal)
|
|
tab = SimpleNamespace(current_layout=layout, windows=windows, relayout=lambda: layout(windows))
|
|
tab.drag_resize_window = lambda *args: RealTab.drag_resize_window(tab, *args)
|
|
tab.relayout()
|
|
return layout, windows, tab
|
|
|
|
def positions(self, layout):
|
|
return {
|
|
id(p): (p.first_extent.right if p.horizontal else p.first_extent.bottom) + p.border_width
|
|
for p in layout.pairs_root.self_and_descendants()
|
|
if not p.is_redundant
|
|
}
|
|
|
|
def fixed_dividers(self, pair):
|
|
# The dividers move_divider() promises to leave alone: every divider outside
|
|
# the dragged pair's region, plus the same-axis dividers inside it. Same-axis
|
|
# dividers nested inside a perpendicular unit are excluded, that unit is
|
|
# resized as a whole so they scale with it.
|
|
inside = set()
|
|
|
|
def walk(p):
|
|
if not isinstance(p, Pair):
|
|
return
|
|
if p.is_redundant:
|
|
return walk(p.one or p.two)
|
|
if p.horizontal != pair.horizontal:
|
|
return
|
|
inside.add(id(p))
|
|
walk(p.one)
|
|
walk(p.two)
|
|
|
|
walk(pair)
|
|
descendants = {id(p) for p in pair.self_and_descendants()}
|
|
return lambda pid: pid not in descendants or pid in inside
|
|
|
|
def check_drags(self, layout, tab):
|
|
for pair in layout.pairs_root.self_and_descendants():
|
|
if pair.is_redundant:
|
|
continue
|
|
cell = lgd.cell_width if pair.horizontal else lgd.cell_height
|
|
is_fixed = self.fixed_dividers(pair)
|
|
for steps in (3, -5, 2):
|
|
before = self.positions(layout)
|
|
self.assertTrue(tab.drag_resize_window(id(pair), steps, pair.horizontal))
|
|
after = self.positions(layout)
|
|
self.check_extents_fit(layout)
|
|
for pid, position in before.items():
|
|
if pid == id(pair):
|
|
self.ae(after[pid] - position, steps * cell)
|
|
elif is_fixed(pid):
|
|
self.ae(after[pid], position)
|
|
|
|
def test_split_drag_adjacent_geometry(self):
|
|
shapes = (
|
|
{'bias': 0.3, 'one': 1, 'two': {'bias': 0.4, 'one': 2, 'two': {'one': 3, 'two': 4}}},
|
|
{'one': {'bias': 0.6, 'one': 1, 'two': 2}, 'two': {'one': 3, 'two': 4}},
|
|
{'one': {'one': {'one': 1, 'two': 2}, 'two': 3}, 'two': 4},
|
|
{'horizontal': False, 'bias': 0.35, 'one': 4, 'two': {'one': 1, 'two': {'one': 2, 'two': 3}}},
|
|
{'one': 1, 'two': {'one': {'horizontal': False, 'one': 2, 'two': 3}, 'two': 4}},
|
|
# same-axis dividers nested inside a perpendicular unit
|
|
{'one': 1, 'two': {'horizontal': False, 'one': {'bias': 0.6, 'one': 2, 'two': 3}, 'two': 4}},
|
|
{'horizontal': False, 'bias': 0.5, 'one': {'one': {'horizontal': False, 'bias': 0.6, 'one': 1, 'two': 2}, 'two': 3}, 'two': 4},
|
|
)
|
|
|
|
def transpose(node):
|
|
if isinstance(node, int):
|
|
return node
|
|
return {**node, 'horizontal': not node.get('horizontal', True), 'one': transpose(node['one']), 'two': transpose(node['two'])}
|
|
|
|
for shape in shapes:
|
|
for oriented in (shape, transpose(shape)):
|
|
for minimal in (True, False):
|
|
with self.subTest(shape=oriented, minimal=minimal):
|
|
layout, windows, tab = self.make_layout(oriented, minimal)
|
|
self.check_drags(layout, tab)
|
|
|
|
def test_split_drag_after_reposition_and_restore(self):
|
|
shape = {'horizontal': False, 'one': 4, 'two': {'bias': 0.3, 'one': 1, 'two': {'bias': 0.6, 'one': 2, 'two': 3}}}
|
|
layout, windows, tab = self.make_layout(shape)
|
|
ws = {w.id: w for w in windows}
|
|
self.check_drags(layout, tab)
|
|
layout.insert_window_next_to(windows, ws[3], ws[1], True, False)
|
|
tab.relayout()
|
|
self.ae(list(layout.pairs_root.two.all_window_ids()), [3, 1, 2])
|
|
self.check_drags(layout, tab)
|
|
saved = {**layout.layout_state(), 'opts': layout.layout_opts.serialized()}
|
|
self.assertTrue(layout.set_layout_state(saved, lambda x: x))
|
|
tab.relayout()
|
|
self.check_drags(layout, tab)
|
|
|
|
def test_split_drag_minimum_size(self):
|
|
layout, windows, tab = self.make_layout({'one': 1, 'two': {'one': 2, 'two': {'one': 3, 'two': 4}}})
|
|
root = layout.pairs_root
|
|
before = self.positions(layout)
|
|
self.assertTrue(tab.drag_resize_window(id(root), 10000, True))
|
|
after = self.positions(layout)
|
|
for pid in before:
|
|
if pid != id(root):
|
|
self.ae(after[pid], before[pid])
|
|
self.assertGreaterEqual(root.two.first_extent.right - root.two.first_extent.left, lgd.cell_width)
|
|
self.assertFalse(tab.drag_resize_window(id(root), 1, True))
|
|
self.assertTrue(tab.drag_resize_window(id(root), -1, True))
|
|
self.ae(self.positions(layout)[id(root)], after[id(root)] - lgd.cell_width)
|
|
|
|
def test_split_drag_nested_minimum_no_overlap(self):
|
|
# Dragging a divider until a nested perpendicular unit is squeezed to its
|
|
# minimum must not leave that unit's halves overflowing the area they were
|
|
# given, which would overlap them with the neighbouring window.
|
|
shape = {'horizontal': False, 'bias': 0.5, 'one': {'one': {'horizontal': False, 'bias': 0.6, 'one': 1, 'two': 2}, 'two': 3}, 'two': 4}
|
|
for minimal in (True, False):
|
|
with self.subTest(minimal=minimal):
|
|
layout, windows, tab = self.make_layout(shape, minimal)
|
|
root = layout.pairs_root
|
|
tab.drag_resize_window(id(root), -1000, False)
|
|
self.check_extents_fit(layout)
|
|
inner = root.one.one
|
|
self.ae(inner.second_extent.bottom, inner.top + inner.height)
|
|
|
|
def test_split_drag_corner_and_subcell_motion(self):
|
|
from types import SimpleNamespace
|
|
|
|
from kitty.boss import Boss
|
|
from kitty.types import WindowResizeDrag, WindowResizeDragData
|
|
|
|
layout, windows, tab = self.make_layout({'one': 1, 'two': {'one': {'horizontal': False, 'one': 2, 'two': 3}, 'two': 4}})
|
|
root = layout.pairs_root
|
|
data = WindowResizeDragData(id(root), True, id(root.two.one), True)
|
|
state = WindowResizeDrag(is_active=True, cell_width=10, cell_height=20, initial_x=300, initial_y=400, data=data)
|
|
boss = SimpleNamespace(drag_resize_of_window=state, tab_for_id=lambda _: tab)
|
|
before = self.positions(layout)
|
|
for x, y in ((301, 401), (299, 399), (300, 400)):
|
|
Boss.drag_resize_update(boss, x, y)
|
|
self.ae(self.positions(layout), before)
|
|
Boss.drag_resize_update(boss, 330, 440)
|
|
moved = self.positions(layout)
|
|
self.ae(moved[id(root)] - before[id(root)], 30)
|
|
self.ae(moved[id(root.two.one)] - before[id(root.two.one)], 40)
|
|
Boss.drag_resize_update(boss, 330, 440)
|
|
self.ae(self.positions(layout), moved)
|
|
Boss.drag_resize_update(boss, 300, 400)
|
|
self.ae(self.positions(layout), before)
|
|
|
|
# Overshooting a minimum size must not detach the divider from the
|
|
# pointer when the pointer comes back into the allowed region.
|
|
boss.drag_resize_of_window = state._replace(data=data._replace(vertical_id=None))
|
|
Boss.drag_resize_update(boss, 10300, 400)
|
|
limited = self.positions(layout)
|
|
Boss.drag_resize_update(boss, 9300, 400)
|
|
self.ae(self.positions(layout), limited)
|
|
Boss.drag_resize_update(boss, 330, 400)
|
|
self.ae(self.positions(layout)[id(root)], before[id(root)] + 30)
|
|
Boss.drag_resize_update(boss, 300, 400)
|
|
self.ae(self.positions(layout), before)
|
|
|
|
|
|
class TestProportionalSplits(BaseTest):
|
|
def make_layout(self, shape=None, num=3, **options):
|
|
q = create_layout(Splits)
|
|
q.layout_opts = SplitsLayoutOpts({'proportional': 'yes', **options})
|
|
windows = create_windows(q, num=0)
|
|
for i in range(1, (num + 1) if shape else 2):
|
|
q.add_window(windows, Window(i), location='vsplit')
|
|
if shape:
|
|
q.pairs_root.unserialize(shape, lambda x: x)
|
|
return q, windows
|
|
|
|
def check_weights(self, q, expected):
|
|
# Observe the serialized layout, independently of the sizing helpers.
|
|
actual = {}
|
|
|
|
def walk(node, size):
|
|
if isinstance(node, int):
|
|
actual[node] = size
|
|
elif 'two' not in node:
|
|
walk(node['one'], size)
|
|
else:
|
|
bias = node.get('bias', 0.5)
|
|
walk(node['one'], size * bias)
|
|
walk(node['two'], size * (1 - bias))
|
|
|
|
walk(q.pairs_root.serialize(), 1.0)
|
|
self.ae(actual.keys(), expected.keys())
|
|
for wid, size in expected.items():
|
|
self.assertAlmostEqual(actual[wid], size)
|
|
|
|
def test_proportional_add_equal_siblings(self):
|
|
for location in ('vsplit', 'hsplit', None):
|
|
for target in (1, 2):
|
|
with self.subTest(location=location, target=target):
|
|
q, windows = self.make_layout()
|
|
q.add_window(windows, Window(2), location=location)
|
|
windows.set_active_window_group_for(windows.id_map[target])
|
|
q.add_window(windows, Window(3), location=location)
|
|
self.check_weights(q, {1: 1 / 3, 2: 1 / 3, 3: 1 / 3})
|
|
q.add_window(windows, Window(4), location=location)
|
|
self.check_weights(q, dict.fromkeys((1, 2, 3, 4), 0.25))
|
|
|
|
def test_proportional_default_unchanged(self):
|
|
q, windows = self.make_layout(proportional='no')
|
|
q.add_window(windows, Window(2), location='vsplit')
|
|
q.add_window(windows, Window(3), location='vsplit')
|
|
self.check_weights(q, {1: 0.5, 2: 0.25, 3: 0.25})
|
|
|
|
def test_proportional_add_preserves_adjusted_weights(self):
|
|
q, windows = self.make_layout({'bias': 0.2, 'one': 1, 'two': {'bias': 0.375, 'one': 2, 'two': 3}})
|
|
q.add_window(windows, Window(4), location='vsplit', next_to=windows.id_map[2])
|
|
self.check_weights(q, {1: 2 / 13, 2: 3 / 13, 3: 5 / 13, 4: 3 / 13})
|
|
|
|
def test_proportional_explicit_bias_wins(self):
|
|
q, windows = self.make_layout()
|
|
q.add_window(windows, Window(2), location='vsplit')
|
|
q.add_window(windows, Window(3), location='vsplit', bias=80)
|
|
self.check_weights(q, {1: 0.5, 2: 0.1, 3: 0.4})
|
|
|
|
def test_proportional_close_preserves_survivors(self):
|
|
for removed in (1, 2, 3):
|
|
q, windows = self.make_layout({'bias': 0.2, 'one': 1, 'two': {'bias': 0.375, 'one': 2, 'two': 3}})
|
|
sizes = {1: 0.2, 2: 0.3, 3: 0.5}
|
|
sizes.pop(removed)
|
|
total = sum(sizes.values())
|
|
windows.remove_window(windows.id_map[removed])
|
|
q.remove_windows(removed)
|
|
self.check_weights(q, {k: v / total for k, v in sizes.items()})
|
|
|
|
def test_proportional_close_multiple(self):
|
|
q, windows = self.make_layout()
|
|
for i in range(2, 6):
|
|
q.add_window(windows, Window(i), location='vsplit')
|
|
q.remove_windows(1, 3, 5)
|
|
self.check_weights(q, {2: 0.5, 4: 0.5})
|
|
|
|
def test_proportional_batch_close_mixed_axes(self):
|
|
for horizontal in (True, False):
|
|
shape = {
|
|
'horizontal': horizontal,
|
|
'one': 1,
|
|
'two': {'horizontal': horizontal, 'one': {'horizontal': not horizontal, 'one': 2, 'two': 3}, 'two': 4},
|
|
}
|
|
q, windows = self.make_layout(shape, num=4)
|
|
q.remove_windows(1, 2)
|
|
# The surviving center pane keeps its column's width, even though
|
|
# the other pane in that column was removed at the same time.
|
|
self.check_weights(q, {3: 0.5, 4: 0.5})
|
|
|
|
def test_proportional_mixed_axes(self):
|
|
q, windows = self.make_layout({'bias': 0.4, 'one': 1, 'two': {'horizontal': False, 'bias': 0.25, 'one': 2, 'two': 3}})
|
|
q.add_window(windows, Window(4), location='hsplit', next_to=windows.id_map[2])
|
|
self.check_weights(q, {1: 0.4, 2: 0.12, 3: 0.36, 4: 0.12})
|
|
q.remove_windows(2)
|
|
self.check_weights(q, {1: 0.4, 3: 0.45, 4: 0.15})
|
|
q.remove_windows(4)
|
|
self.check_weights(q, {1: 0.4, 3: 0.6})
|
|
|
|
def test_proportional_perpendicular_subtree_unchanged(self):
|
|
q, windows = self.make_layout({'bias': 0.4, 'one': 1, 'two': {'horizontal': False, 'bias': 0.25, 'one': 2, 'two': 3}})
|
|
q.add_window(windows, Window(4), location='vsplit', next_to=windows.id_map[1])
|
|
self.check_weights(q, {1: 2 / 7, 4: 2 / 7, 2: 3 / 28, 3: 9 / 28})
|
|
|
|
def test_proportional_reposition(self):
|
|
q, windows = self.make_layout({'bias': 0.2, 'one': 1, 'two': {'bias': 0.375, 'one': 2, 'two': 3}})
|
|
q.insert_window_next_to(windows, windows.id_map[3], windows.id_map[1], True, False)
|
|
self.check_weights(q, {1: 2 / 7, 2: 3 / 7, 3: 2 / 7})
|
|
self.ae(list(q.pairs_root.all_window_ids()), [3, 1, 2])
|
|
before = q.layout_state()
|
|
q.insert_window_next_to(windows, windows.id_map[1], windows.id_map[1], True, False)
|
|
self.ae(q.layout_state(), before)
|
|
|
|
def test_proportional_overlay_does_not_change_weights(self):
|
|
q, windows = self.make_layout()
|
|
q.add_window(windows, Window(2), location='vsplit')
|
|
before = q.layout_state()
|
|
q.add_window(windows, Window(10), overlay_for=2)
|
|
self.ae(q.layout_state(), before)
|
|
q.add_window(windows, Window(3), location='vsplit')
|
|
self.check_weights(q, {1: 1 / 3, 2: 1 / 3, 3: 1 / 3})
|
|
self.assertIs(windows.group_for_window(windows.id_map[10]), windows.group_for_window(windows.id_map[2]))
|
|
|
|
def test_proportional_option_roundtrip_and_equalize(self):
|
|
q, windows = self.make_layout({'bias': 0.2, 'one': 1, 'two': {'bias': 0.375, 'one': 2, 'two': 3}}, equalize_on_window_close='yes')
|
|
options = SplitsLayoutOpts(q.layout_opts.serialized())
|
|
self.assertTrue(options.proportional)
|
|
self.assertTrue(options.equalize_on_close)
|
|
windows.remove_window(windows.id_map[1])
|
|
q.remove_windows(1)
|
|
self.assertTrue(q.on_window_removed(windows))
|
|
self.check_weights(q, {2: 0.5, 3: 0.5})
|
|
|
|
def test_proportional_close_with_zero_sized_survivor(self):
|
|
# Window 3 has been squeezed to nothing by maximize/bias, so it has zero
|
|
# weight. Closing window 2 must not hand its column's space to windows 1
|
|
# and 4, which are not in any sub-tree that lost a window.
|
|
shape = {'one': 1, 'two': {'one': {'bias': 1.0, 'one': 2, 'two': 3}, 'two': 4}}
|
|
q, windows = self.make_layout(shape, num=4)
|
|
self.check_weights(q, {1: 0.5, 2: 0.25, 3: 0.0, 4: 0.25})
|
|
q.remove_windows(2)
|
|
self.check_weights(q, {1: 0.5, 3: 0.25, 4: 0.25})
|
|
|
|
def test_proportional_batch_close_matches_sequential(self):
|
|
# Pruning several windows in one pass (which happens when they are closed
|
|
# while a different layout is active) must match closing them one by one.
|
|
shape = {
|
|
'bias': 0.4,
|
|
'one': {'horizontal': False, 'one': 1, 'two': {'one': 2, 'two': 3}},
|
|
'two': {'horizontal': False, 'one': 4, 'two': {'horizontal': False, 'one': 5, 'two': 6}},
|
|
}
|
|
removed = (6, 1, 3)
|
|
q, windows = self.make_layout(shape, num=6)
|
|
q.remove_windows(*removed)
|
|
batch = q.pairs_root.window_weights()
|
|
q, windows = self.make_layout(shape, num=6)
|
|
for wid in removed:
|
|
q.remove_windows(wid)
|
|
sequential = q.pairs_root.window_weights()
|
|
self.ae(batch.keys(), sequential.keys())
|
|
for wid, weight in sequential.items():
|
|
self.assertAlmostEqual(batch[wid], weight)
|
|
|
|
def test_proportional_balanced_add(self):
|
|
# A window that appears without being split off an existing one (it was
|
|
# created while another layout was active) still gets a proportional share.
|
|
q, windows = self.make_layout()
|
|
q.add_window(windows, Window(2), location='vsplit')
|
|
q.add_window(windows, Window(3), location='vsplit')
|
|
self.check_weights(q, dict.fromkeys((1, 2, 3), 1 / 3))
|
|
self.ae(q.balanced_add_window(4).horizontal, q.pairs_root.horizontal)
|
|
self.check_weights(q, dict.fromkeys((1, 2, 3, 4), 0.25))
|
|
|
|
|
|
class TestWindowHelpers(BaseTest):
|
|
def test_edge_widths_launch_args(self):
|
|
ew = EdgeWidths({'left': 1, 'right': 2, 'top': 3, 'bottom': 4})
|
|
for prefix in ('padding', 'margin'):
|
|
args = list(ew.as_launch_args(prefix))
|
|
self.ae(len(set(args)), 4)
|
|
self.ae(
|
|
parse_spacing_settings(a.partition('=')[2] for a in args),
|
|
{f'{prefix}-left': 1, f'{prefix}-right': 2, f'{prefix}-top': 3, f'{prefix}-bottom': 4},
|
|
)
|
|
|
|
def test_quit_close_event(self):
|
|
from kitty import fast_data_types as f
|
|
from kitty.boss import Boss
|
|
|
|
boss = SimpleNamespace(desktop_session_ending=False, quit_confirmed=False)
|
|
|
|
def ev(cause):
|
|
with patch('kitty.boss.current_application_quit_cause', lambda: cause):
|
|
return Boss.quit_close_event(boss)
|
|
|
|
for cause, name in (
|
|
(f.QUIT_CAUSE_ACTION, 'action'),
|
|
(f.QUIT_CAUSE_OS_REQUEST, 'os_request'),
|
|
(f.QUIT_CAUSE_LOGOUT, 'logout'),
|
|
(f.QUIT_CAUSE_SIGNAL, 'signal'),
|
|
(f.QUIT_CAUSE_FATAL_ERROR, 'fatal_error'),
|
|
(f.QUIT_CAUSE_NONE, 'unknown'),
|
|
):
|
|
self.ae(ev(cause), {'reason': 'quit', 'cause': name, 'confirmed': False})
|
|
boss.quit_confirmed = True
|
|
self.ae(ev(f.QUIT_CAUSE_ACTION), {'reason': 'quit', 'cause': 'action', 'confirmed': True})
|
|
# being killed by a signal while the desktop session is ending is a logout
|
|
boss.desktop_session_ending = True
|
|
self.ae(ev(f.QUIT_CAUSE_SIGNAL)['cause'], 'logout')
|
|
self.ae(ev(f.QUIT_CAUSE_FATAL_ERROR)['cause'], 'fatal_error')
|
|
|
|
def test_deferred_watcher_calls(self):
|
|
timers = []
|
|
next_timer_id = [0]
|
|
|
|
def add_timer(callback, interval, repeats=True):
|
|
if len(timers) >= 128: # simulate the fixed size glfw timer table
|
|
return 0
|
|
timers.append(callback)
|
|
next_timer_id[0] += 1
|
|
return next_timer_id[0]
|
|
|
|
def fire_timers():
|
|
while timers:
|
|
callback = timers.pop(0)
|
|
callback(1)
|
|
|
|
delivered = []
|
|
|
|
class FakeWindow:
|
|
def __init__(self, num, watched=True):
|
|
self.num = num
|
|
self.watchers = Watchers()
|
|
if watched:
|
|
self.watchers.on_resize.append(lambda boss, window, data: None)
|
|
|
|
def call_watchers(self, which, data):
|
|
delivered.append((self.num, data['n']))
|
|
if data.get('recurse'):
|
|
dc(weakref.ref(self), 'on_resize', {'n': data['n'] + 1000})
|
|
|
|
with patch('kitty.window.add_timer', add_timer), patch('kitty.window.log_error', lambda *a: None):
|
|
dc = DeferredWatcherCalls()
|
|
windows = [FakeWindow(i) for i in range(10)]
|
|
unwatched = FakeWindow(-1, watched=False)
|
|
expected = []
|
|
for n in range(300):
|
|
w = windows[n % len(windows)]
|
|
dc(weakref.ref(w), 'on_resize', {'n': n})
|
|
dc(weakref.ref(unwatched), 'on_resize', {'n': n})
|
|
expected.append((w.num, n))
|
|
self.ae(len(timers), 1)
|
|
self.ae(delivered, [])
|
|
fire_timers()
|
|
self.ae(delivered, expected)
|
|
|
|
# calls made during delivery go to the next batch
|
|
del delivered[:]
|
|
dc(weakref.ref(windows[0]), 'on_resize', {'n': 1, 'recurse': True})
|
|
timers.pop(0)(1)
|
|
self.ae(delivered, [(0, 1)])
|
|
self.ae(len(timers), 1)
|
|
fire_timers()
|
|
self.ae(delivered, [(0, 1), (0, 1001)])
|
|
|
|
# calls for windows that have been garbage collected are dropped
|
|
del delivered[:]
|
|
w = FakeWindow(99)
|
|
dc(weakref.ref(w), 'on_resize', {'n': 7})
|
|
dc(weakref.ref(windows[1]), 'on_resize', {'n': 8})
|
|
del w
|
|
fire_timers()
|
|
self.ae(delivered, [(1, 8)])
|
|
|
|
# an exception escaping a watcher does not lose the rest of the batch
|
|
del delivered[:]
|
|
|
|
class Interrupted(BaseException):
|
|
pass
|
|
|
|
def interrupting_call_watchers(which, data):
|
|
raise Interrupted()
|
|
|
|
bad = FakeWindow(50)
|
|
bad.call_watchers = interrupting_call_watchers
|
|
dc(weakref.ref(windows[0]), 'on_resize', {'n': 1})
|
|
dc(weakref.ref(bad), 'on_resize', {'n': 2})
|
|
dc(weakref.ref(windows[1]), 'on_resize', {'n': 3})
|
|
with self.assertRaises(Interrupted):
|
|
timers.pop(0)(1)
|
|
self.ae(delivered, [(0, 1)])
|
|
self.ae(len(timers), 1)
|
|
fire_timers()
|
|
self.ae(delivered, [(0, 1), (1, 3)])
|
|
|
|
# if the timer cannot be added, calls are kept and retried on the next event
|
|
del delivered[:]
|
|
timers.extend([lambda timer_id: None] * 128)
|
|
dc(weakref.ref(windows[2]), 'on_resize', {'n': 1})
|
|
self.ae(dc.timer_id, 0)
|
|
del timers[:]
|
|
dc(weakref.ref(windows[3]), 'on_resize', {'n': 2})
|
|
self.ae(len(timers), 1)
|
|
fire_timers()
|
|
self.ae(delivered, [(2, 1), (3, 2)])
|
|
|
|
def test_global_watchers(self):
|
|
opts = SimpleNamespace(watcher={})
|
|
w1 = Watchers()
|
|
calls = []
|
|
|
|
def load(paths):
|
|
paths = tuple(paths)
|
|
calls.append(paths)
|
|
return w1 if paths else None
|
|
|
|
with patch('kitty.window.get_options', lambda: opts), patch('kitty.launch.load_watch_modules', load):
|
|
g = GlobalWatchers()
|
|
g.set_extra('x.py')
|
|
self.assertIs(g(), w1)
|
|
self.assertIs(g(), w1)
|
|
self.ae(calls, [('x.py',)])
|
|
g = GlobalWatchers()
|
|
opts.watcher = {'a.py': 'a.py'}
|
|
self.assertIs(g(), w1)
|
|
opts.watcher = {}
|
|
ans = g()
|
|
self.assertIsNot(ans, w1)
|
|
self.assertIsInstance(ans, Watchers)
|
|
self.ae(calls[-1], ())
|
|
# changing the extra watcher after first use must take effect
|
|
g.set_extra('y.py')
|
|
self.assertIs(g(), w1)
|
|
self.ae(calls[-1], ('y.py',))
|