mirror of
https://github.com/kovidgoyal/kitty.git
synced 2026-11-16 13:08:25 +00:00
- Only restore entry sizes in the Splits layout resize mode was opened in; otherwise fall back to the default reset rather than refusing to reset - Do not take a snapshot lazily from already resized sizes when resize mode was opened in another layout - Running the resize kitten while its overlay is open replaces the overlay so the new options take effect, keeping the original-size snapshot - Newer edge statuses replace older local messages, and edge failures beep - Switching strategy no longer discards a --fraction command-line override - Compute divider room without deep copying the pair subtree - Fractional resize in other layouts adopts the probed state instead of replaying every step
345 lines
19 KiB
Python
345 lines
19 KiB
Python
#!/usr/bin/env python
|
|
# License: GPLv3 Copyright: 2026, Kovid Goyal, <kovid at kovidgoyal.net>
|
|
|
|
import json
|
|
from math import ceil
|
|
from types import SimpleNamespace
|
|
from unittest.mock import Mock, patch
|
|
|
|
from kitty.layout.base import lgd
|
|
from kitty.rc.base import PayloadGetter
|
|
from kitty.rc.resize_window import resize_window
|
|
from kitty.rc.resize_window_edge import ResizeWindowEdge
|
|
|
|
from . import layout as geometry_tests
|
|
|
|
|
|
class TestResizeEntry(geometry_tests.BaseTest):
|
|
def test_reenter_resize_replaces_existing_overlay(self):
|
|
from kitty.boss import Boss
|
|
|
|
launched = []
|
|
|
|
def create_kitten_handler(kitten, args):
|
|
launched.append(args)
|
|
raise AssertionError('Launched')
|
|
|
|
for name in ('resize_window', 'resize-window'):
|
|
cmd = ResizeWindowEdge()
|
|
base = Mock(is_resize_overlay=False)
|
|
resize = Mock(is_resize_overlay=True)
|
|
# Another overlay can temporarily cover the resize UI.
|
|
other = Mock(is_resize_overlay=False)
|
|
group = SimpleNamespace(windows=[base, resize, other])
|
|
tab = SimpleNamespace(windows=SimpleNamespace(group_for_window=lambda w: group), set_active_window=Mock())
|
|
base.tabref = other.tabref = lambda: tab
|
|
session = cmd.start_session(resize, None)
|
|
boss = SimpleNamespace(active_window=other, active_tab=tab, mark_window_for_close=Mock())
|
|
with patch('kitty.rc.resize_window_edge.resize_window_edge', cmd), patch('kittens.runner.create_kitten_handler', create_kitten_handler):
|
|
with self.assertRaisesRegex(AssertionError, 'Launched'):
|
|
Boss.run_kitten_with_metadata(boss, name, args=['--strategy=edge'])
|
|
# The new options are used, the old UI is closed and its snapshot is handed over
|
|
self.ae(launched.pop(), ['--strategy=edge'])
|
|
boss.mark_window_for_close.assert_called_once_with(resize)
|
|
self.assertNotIn(resize, cmd.sessions)
|
|
new_overlay = Mock()
|
|
self.assertIs(cmd.start_session(new_overlay, None, session), session)
|
|
self.assertIs(cmd.sessions[new_overlay], session)
|
|
tab.set_active_window.assert_not_called()
|
|
|
|
def test_resize_reentry_is_scoped_to_kitten_and_pane(self):
|
|
from kitty.boss import Boss
|
|
|
|
shell = SimpleNamespace(is_resize_overlay=False)
|
|
resize = SimpleNamespace(is_resize_overlay=True)
|
|
group = SimpleNamespace(windows=[shell])
|
|
tab = SimpleNamespace(windows=SimpleNamespace(group_for_window=lambda w: group), set_active_window=Mock())
|
|
window = SimpleNamespace(tabref=lambda: tab)
|
|
boss = SimpleNamespace(active_window=window, active_tab=tab, mark_window_for_close=Mock())
|
|
with patch('kittens.runner.create_kitten_handler', side_effect=AssertionError('Normal launch')):
|
|
with self.assertRaisesRegex(AssertionError, 'Normal launch'):
|
|
Boss.run_kitten_with_metadata(boss, 'resize_window')
|
|
group.windows.append(resize)
|
|
with self.assertRaisesRegex(AssertionError, 'Normal launch'):
|
|
Boss.run_kitten_with_metadata(boss, 'hints')
|
|
tab.set_active_window.assert_not_called()
|
|
boss.mark_window_for_close.assert_not_called()
|
|
|
|
|
|
class TestEdgeResize(geometry_tests.BaseSplitGeometryTest):
|
|
make_layout = geometry_tests.TestSplitDragGeometry.make_layout
|
|
positions = geometry_tests.TestSplitDragGeometry.positions
|
|
fixed_dividers = geometry_tests.TestSplitDragGeometry.fixed_dividers
|
|
|
|
def resize(self, tab, window_id, edge, increment, fraction=0):
|
|
changed = tab.current_layout.modify_size_of_window_edge(tab.windows, window_id, edge, increment, fraction)
|
|
if changed:
|
|
tab.relayout()
|
|
return changed
|
|
|
|
def test_nested_edge_selection(self):
|
|
shape = {'one': 1, 'two': {'one': 2, 'two': {'one': 3, 'two': 4}}}
|
|
layout, windows, tab = self.make_layout(shape)
|
|
expected = {1: {'right'}, 2: {'left', 'right'}, 3: {'left', 'right'}, 4: {'left'}}
|
|
before = self.positions(layout)
|
|
for window_id, edges in expected.items():
|
|
found = {edge for edge in ('left', 'right', 'top', 'bottom') if layout.pair_for_window_edge(windows, window_id, edge)}
|
|
self.ae(found, edges)
|
|
self.assertIs(layout.pair_for_window_edge(windows, 2, 'left'), layout.pairs_root)
|
|
self.assertIs(layout.pair_for_window_edge(windows, 2, 'right'), layout.pairs_root.two)
|
|
self.assertIs(layout.pair_for_window_edge(windows, 3, 'left'), layout.pairs_root.two)
|
|
self.assertIsNone(layout.pair_for_window_edge(windows, 999, 'left'))
|
|
self.ae(self.positions(layout), before)
|
|
shape = {'one': {'horizontal': False, 'one': 1, 'two': 2}, 'two': {'horizontal': False, 'one': 3, 'two': 4}}
|
|
layout, windows, tab = self.make_layout(shape)
|
|
for window_id, expected in ((1, {'right', 'bottom'}), (2, {'right', 'top'}), (3, {'left', 'bottom'}), (4, {'left', 'top'})):
|
|
self.ae({edge for edge in ('left', 'right', 'top', 'bottom') if layout.pair_for_window_edge(windows, window_id, edge)}, expected)
|
|
|
|
def test_only_selected_same_axis_divider_moves(self):
|
|
shapes = (
|
|
{'one': 1, 'two': {'one': 2, 'two': {'one': 3, 'two': 4}}},
|
|
{'one': {'one': 1, 'two': 2}, 'two': {'one': 3, 'two': 4}},
|
|
{'one': 1, 'two': {'one': {'horizontal': False, 'one': 2, 'two': 3}, 'two': 4}},
|
|
{'horizontal': False, 'one': 1, 'two': {'horizontal': False, 'one': 2, 'two': {'horizontal': False, 'one': 3, 'two': 4}}},
|
|
)
|
|
for shape in shapes:
|
|
for minimal in (True, False):
|
|
layout, windows, tab = self.make_layout(shape, minimal)
|
|
for window_id in (1, 2, 3, 4):
|
|
for edge in ('left', 'right', 'top', 'bottom'):
|
|
pair = layout.pair_for_window_edge(windows, window_id, edge)
|
|
if pair is None:
|
|
continue
|
|
fixed = self.fixed_dividers(pair)
|
|
cell = lgd.cell_width if pair.horizontal else lgd.cell_height
|
|
for increment in (2, -2):
|
|
before = self.positions(layout)
|
|
self.assertTrue(self.resize(tab, window_id, edge, increment))
|
|
after = self.positions(layout)
|
|
self.ae(after[id(pair)] - before[id(pair)], increment * cell)
|
|
for pid, position in before.items():
|
|
if pid != id(pair) and fixed(pid):
|
|
self.ae(after[pid], position)
|
|
self.check_extents_fit(layout)
|
|
|
|
def test_fractional_steps_limits_and_custom_fraction(self):
|
|
for horizontal in (True, False):
|
|
for window_id in (1, 2):
|
|
for sign in (-1, 1):
|
|
for remaining in (0, 1, 2, 3, 4, 5, 6, 10):
|
|
for fraction in (1 / 3, 1 / 4, 1 / 2, 1):
|
|
layout, windows, tab = self.make_layout({'horizontal': horizontal, 'one': 1, 'two': 2}, num=2)
|
|
pair = layout.pairs_root
|
|
edge = ('right' if window_id == 1 else 'left') if horizontal else ('bottom' if window_id == 1 else 'top')
|
|
step = 2 * (lgd.cell_width if horizontal else lgd.cell_height)
|
|
pair.move_divider(sign * (pair.width if horizontal else pair.height))
|
|
tab.relayout()
|
|
pair.move_divider(-sign * step * remaining)
|
|
tab.relayout()
|
|
before = self.positions(layout)[id(pair)]
|
|
self.ae(self.resize(tab, window_id, edge, sign * 2, fraction), bool(remaining))
|
|
self.ae(self.positions(layout)[id(pair)] - before, sign * step * ceil(remaining * fraction - 1e-9))
|
|
while self.resize(tab, window_id, edge, sign * 2, fraction):
|
|
self.check_extents_fit(layout)
|
|
before = self.positions(layout)
|
|
self.assertFalse(self.resize(tab, window_id, edge, sign * 2, fraction))
|
|
self.ae(self.positions(layout), before)
|
|
self.assertTrue(self.resize(tab, window_id, edge, -sign * 2, fraction))
|
|
self.check_extents_fit(layout)
|
|
|
|
def test_partial_step_and_invalid_requests(self):
|
|
layout, windows, tab = self.make_layout({'one': 1, 'two': 2}, num=2)
|
|
pair = layout.pairs_root
|
|
pair.move_divider(pair.width)
|
|
tab.relayout()
|
|
partial = lgd.cell_width - 1
|
|
pair.move_divider(-partial)
|
|
tab.relayout()
|
|
before = self.positions(layout)
|
|
self.assertTrue(self.resize(tab, 1, 'right', 2, 0.25))
|
|
self.ae(self.positions(layout)[id(pair)] - before[id(pair)], partial)
|
|
for edge, window_id, increment, fraction in (
|
|
('left', 1, 2, 0),
|
|
('right', 999, 2, 0),
|
|
('right', 1, 0, 0),
|
|
('right', 1, 2, -1),
|
|
('right', 1, 2, float('nan')),
|
|
):
|
|
before = self.positions(layout)
|
|
self.assertFalse(self.resize(tab, window_id, edge, increment, fraction))
|
|
self.ae(self.positions(layout), before)
|
|
|
|
def command(self, cmd, tab, window_id, operation, **payload):
|
|
window = tab.windows.id_map[window_id]
|
|
window.tabref = lambda: tab
|
|
boss = SimpleNamespace(active_window=window)
|
|
return json.loads(cmd.response_from_kitty(boss, window, PayloadGetter(cmd, {'self': True, 'operation': operation, **payload})))
|
|
|
|
def test_session_reset_restores_entry_geometry(self):
|
|
layout, windows, tab = self.make_layout({'bias': 0.3, 'one': 1, 'two': {'bias': 0.4, 'one': 2, 'two': 3}}, num=3)
|
|
cmd = ResizeWindowEdge()
|
|
before = self.positions(layout)
|
|
self.command(cmd, tab, 2, 'start')
|
|
for edge, increment in (('left', 3), ('right', -2)):
|
|
selected = self.command(cmd, tab, 2, 'select', edge=edge)
|
|
self.ae(selected['selected'], edge)
|
|
self.command(cmd, tab, 2, 'move', edge=edge, increment=increment, divider=selected['divider'])
|
|
self.assertNotEqual(self.positions(layout), before)
|
|
restored = self.command(cmd, tab, 2, 'reset')
|
|
self.ae(self.positions(layout), before)
|
|
self.ae(restored['selected'], '')
|
|
self.assertIn('Restored', restored['status'])
|
|
self.ae(layout.pairs_root.bias, 0.3)
|
|
self.ae(layout.pairs_root.two.bias, 0.4)
|
|
self.command(cmd, tab, 2, 'reset')
|
|
self.ae(self.positions(layout), before)
|
|
|
|
def test_entry_selection_and_snapshot_survive_strategy_activation(self):
|
|
for horizontal in (True, False):
|
|
layout, windows, tab = self.make_layout({'horizontal': horizontal, 'bias': 0.3, 'one': 1, 'two': 2}, num=2)
|
|
cmd = ResizeWindowEdge()
|
|
before = self.positions(layout)
|
|
# Boss takes the snapshot before either strategy has resized anything.
|
|
cmd.start_session(windows.id_map[1], layout)
|
|
layout.pairs_root.bias = 0.6
|
|
tab.relayout()
|
|
started = self.command(cmd, tab, 1, 'start')
|
|
self.ae(started['selected'], 'right' if horizontal else 'bottom')
|
|
self.assertTrue(started['divider'])
|
|
self.command(cmd, tab, 1, 'start')
|
|
self.command(cmd, tab, 1, 'reset')
|
|
self.ae(self.positions(layout), before)
|
|
layout, windows, tab = self.make_layout({'one': 1, 'two': {'one': 2, 'two': 3}}, num=3)
|
|
started = self.command(ResizeWindowEdge(), tab, 2, 'start')
|
|
self.ae(started['edges'], ['left', 'right'])
|
|
self.ae(started['selected'], '')
|
|
|
|
def test_no_internal_edge_and_unsupported_layout(self):
|
|
layout, windows, tab = self.make_layout({'one': 1}, num=1)
|
|
cmd = ResizeWindowEdge()
|
|
before = self.positions(layout)
|
|
started = self.command(cmd, tab, 1, 'start')
|
|
self.ae(started['edges'], [])
|
|
self.ae(started['selected'], '')
|
|
self.command(cmd, tab, 1, 'move', edge='right', increment=2)
|
|
self.ae(self.positions(layout), before)
|
|
tab.current_layout = geometry_tests.create_layout(geometry_tests.Tall)
|
|
unavailable = self.command(cmd, tab, 1, 'start')
|
|
self.ae(unavailable['edges'], [])
|
|
self.assertIn('requires the Splits layout', unavailable['status'])
|
|
|
|
def test_session_selection_stale_identity_and_structure_change(self):
|
|
layout, windows, tab = self.make_layout({'one': 1, 'two': 2}, num=2)
|
|
cmd = ResizeWindowEdge()
|
|
before = self.positions(layout)
|
|
self.command(cmd, tab, 1, 'start')
|
|
outside = self.command(cmd, tab, 1, 'select', edge='left')
|
|
self.ae(outside['selected'], '')
|
|
selected = self.command(cmd, tab, 1, 'select', edge='right')
|
|
self.ae(selected['selected'], 'right')
|
|
self.ae(self.positions(layout), before)
|
|
stale = self.command(cmd, tab, 1, 'move', edge='right', divider='invalid', increment=2)
|
|
self.ae(stale['selected'], '')
|
|
self.ae(self.positions(layout), before)
|
|
layout.pairs_root.horizontal = False
|
|
tab.relayout()
|
|
changed = self.positions(layout)
|
|
refused = self.command(cmd, tab, 1, 'reset')
|
|
self.assertIn('structure changed', refused['status'])
|
|
self.ae(self.positions(layout), changed)
|
|
|
|
def test_window_reset_restores_same_entry_snapshot(self):
|
|
layout, windows, tab = self.make_layout({'bias': 0.31, 'one': 1, 'two': {'bias': 0.43, 'one': 2, 'two': 3}}, num=3)
|
|
window = windows.id_map[2]
|
|
window.tabref = lambda: tab
|
|
cmd = ResizeWindowEdge()
|
|
cmd.start_session(window, layout)
|
|
before = self.positions(layout)
|
|
boss = SimpleNamespace(active_window=window, resize_layout_window=Mock())
|
|
payload = PayloadGetter(resize_window, {'self': True, 'axis': 'reset', 'restore_entry_layout': True})
|
|
with patch('kitty.rc.resize_window_edge.resize_window_edge', cmd):
|
|
self.assertTrue(self.resize(tab, 2, 'left', 3))
|
|
self.assertTrue(self.resize(tab, 2, 'right', -2))
|
|
self.assertIsNone(resize_window.response_from_kitty(boss, window, payload))
|
|
self.ae(self.positions(layout), before)
|
|
boss.resize_layout_window.assert_not_called()
|
|
layout.pairs_root.horizontal = False
|
|
tab.relayout()
|
|
changed = self.positions(layout)
|
|
result = resize_window.response_from_kitty(boss, window, payload)
|
|
self.assertIn('structure changed', result)
|
|
self.ae(self.positions(layout), changed)
|
|
|
|
def test_reset_after_leaving_entry_layout_uses_default_reset(self):
|
|
layout, windows, tab = self.make_layout({'bias': 0.3, 'one': 1, 'two': 2}, num=2)
|
|
window = windows.id_map[1]
|
|
window.tabref = lambda: tab
|
|
cmd = ResizeWindowEdge()
|
|
cmd.start_session(window, layout)
|
|
boss = SimpleNamespace(active_window=window, resize_layout_window=Mock(return_value=None))
|
|
payload = PayloadGetter(resize_window, {'self': True, 'axis': 'reset', 'increment': 2, 'restore_entry_layout': True})
|
|
with patch('kitty.rc.resize_window_edge.resize_window_edge', cmd):
|
|
tab.current_layout = geometry_tests.create_layout(geometry_tests.Tall)
|
|
self.assertIsNone(resize_window.response_from_kitty(boss, window, payload))
|
|
self.assertTrue(boss.resize_layout_window.call_args.kwargs['reset'])
|
|
# Returning to the entry layout restores its snapshot again
|
|
tab.current_layout = layout
|
|
layout.pairs_root.bias = 0.6
|
|
boss.resize_layout_window.reset_mock()
|
|
self.assertIsNone(resize_window.response_from_kitty(boss, window, payload))
|
|
boss.resize_layout_window.assert_not_called()
|
|
self.ae(layout.pairs_root.bias, 0.3)
|
|
|
|
def test_no_snapshot_when_entered_in_other_layout(self):
|
|
layout, windows, tab = self.make_layout({'bias': 0.3, 'one': 1, 'two': 2}, num=2)
|
|
window = windows.id_map[1]
|
|
window.tabref = lambda: tab
|
|
tab.reset_window_sizes = Mock()
|
|
cmd = ResizeWindowEdge()
|
|
cmd.start_session(window, geometry_tests.create_layout(geometry_tests.Tall))
|
|
layout.pairs_root.bias = 0.6
|
|
started = self.command(cmd, tab, 1, 'start')
|
|
self.assertTrue(started['divider'])
|
|
moved = self.command(cmd, tab, 1, 'move', edge='right', increment=2, divider=started['divider'])
|
|
self.ae(moved['status'], '')
|
|
self.assertFalse(moved['failed'])
|
|
# Sizes changed after entry must not be treated as the original sizes
|
|
reset = self.command(cmd, tab, 1, 'reset')
|
|
tab.reset_window_sizes.assert_called_once_with()
|
|
self.assertNotIn('Restored', reset['status'])
|
|
self.assertFalse(reset['failed'])
|
|
|
|
def test_failure_flag(self):
|
|
layout, windows, tab = self.make_layout({'one': 1, 'two': 2}, num=2)
|
|
cmd = ResizeWindowEdge()
|
|
self.command(cmd, tab, 1, 'start')
|
|
self.assertTrue(self.command(cmd, tab, 1, 'select', edge='left')['failed'])
|
|
selected = self.command(cmd, tab, 1, 'select', edge='right')
|
|
self.assertFalse(selected['failed'])
|
|
while not (moved := self.command(cmd, tab, 1, 'move', edge='right', increment=2, divider=selected['divider']))['failed']:
|
|
pass
|
|
self.assertIn('size limit', moved['status'])
|
|
restored = self.command(cmd, tab, 1, 'reset')
|
|
self.assertIn('Restored', restored['status'])
|
|
self.assertFalse(restored['failed'])
|
|
|
|
def test_window_reset_without_session_keeps_default_behavior(self):
|
|
layout, windows, tab = self.make_layout({'one': 1, 'two': 2}, num=2)
|
|
window = windows.id_map[1]
|
|
window.tabref = lambda: tab
|
|
boss = SimpleNamespace(active_window=window, resize_layout_window=Mock(return_value=None))
|
|
cmd = ResizeWindowEdge()
|
|
with patch('kitty.rc.resize_window_edge.resize_window_edge', cmd):
|
|
for restore in (False, True):
|
|
payload = PayloadGetter(resize_window, {'self': True, 'axis': 'reset', 'increment': 2, 'restore_entry_layout': restore})
|
|
self.assertIsNone(resize_window.response_from_kitty(boss, window, payload))
|
|
self.assertTrue(boss.resize_layout_window.call_args.kwargs['reset'])
|
|
cmd.start_session(window, layout)
|
|
before = boss.resize_layout_window.call_count
|
|
# An ordinary remote-control reset always retains default-size reset.
|
|
payload = PayloadGetter(resize_window, {'self': True, 'axis': 'reset', 'increment': 2})
|
|
resize_window.response_from_kitty(boss, window, payload)
|
|
self.ae(boss.resize_layout_window.call_count, before + 1)
|
|
for fraction in (-1, 1.1, float('nan'), float('inf')):
|
|
with self.assertRaises(ValueError):
|
|
self.command(cmd, tab, 1, 'move', edge='bottom', fraction=fraction)
|