#!/usr/bin/env python # License: GPL v3 Copyright: 2018, Kovid Goyal 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 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 = {} num_calls = len(calls) ans = g() self.assertIsNot(ans, w1) self.assertIsInstance(ans, Watchers) # with no watchers, the slow to import launch module is not used self.ae(len(calls), num_calls) # 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',))