mirror of
https://github.com/kovidgoyal/kitty.git
synced 2026-11-16 13:08:25 +00:00
The title bars shown only for a window drag were hidden before the drop was classified, which moves the windows, so a drop on a title bar was treated as a directional insert instead of a swap. Classify the drop in on_window_drop() before hiding them. On Wayland the drag source can finish before the drop is delivered, so when the drop is on kitty, on_drag_source_finished() now leaves hiding them to the drop, falling back to hiding them if the drop never arrives. Closes #10709
1115 lines
54 KiB
Python
1115 lines
54 KiB
Python
#!/usr/bin/env python
|
|
# License: GPL v3 Copyright: 2026, kitty contributors
|
|
|
|
import os
|
|
from collections import deque
|
|
from contextlib import nullcontext
|
|
from functools import partial
|
|
from types import SimpleNamespace
|
|
from unittest.mock import MagicMock, Mock, patch
|
|
|
|
from kitty.boss import Boss
|
|
from kitty.layout.interface import Splits, Stack, Tall
|
|
from kitty.tab_bar import TabBarData, WindowDropTarget
|
|
from kitty.tabs import DragOverlayMode, Tab, TabManager
|
|
|
|
from .base import BaseTest
|
|
from .layout import Window, create_layout, create_windows
|
|
|
|
|
|
def tab_mime() -> str:
|
|
# Must be computed at run time, the test runner may fork after importing this module
|
|
return f'application/net.kovidgoyal.kitty-tab-{os.getpid()}'
|
|
|
|
|
|
def region(left: int, top: int, right: int, bottom: int) -> SimpleNamespace:
|
|
return SimpleNamespace(left=left, top=top, right=right, bottom=bottom)
|
|
|
|
|
|
class Viewport:
|
|
"""Models the coupling between tab bar visibility and the size of the central region.
|
|
|
|
The real viewport_for_window() shrinks the central region as soon as the tab bar becomes
|
|
visible, and a drag hovering over an OS Window forces the tab bar visible. Drop classification
|
|
therefore feeds back into the geometry it is based on, so tests need a viewport that reproduces
|
|
it rather than a fixed pair of regions."""
|
|
|
|
tab_bar_height = 30
|
|
cell_width, cell_height = 10, 20
|
|
|
|
def __init__(self, num_tabs: int = 1, min_tabs: int = 2, width: int = 1000, height: int = 800):
|
|
self.num_tabs, self.min_tabs = num_tabs, min_tabs
|
|
self.width, self.height = width, height
|
|
self.drag_over = False
|
|
|
|
@property
|
|
def tab_bar_visible(self) -> bool:
|
|
return self.drag_over or self.num_tabs >= self.min_tabs
|
|
|
|
def regions(self) -> tuple[SimpleNamespace, ...]:
|
|
top = self.tab_bar_height if self.tab_bar_visible else 0
|
|
tab_bar = region(0, 0, self.width, top) if top else region(0, 0, 0, 0)
|
|
return region(0, top, self.width, self.height), tab_bar, self.width, self.height, self.cell_width, self.cell_height
|
|
|
|
|
|
class FakeTabManager:
|
|
"The parts of TabManager that Boss touches while classifying a drop"
|
|
|
|
def __init__(self, viewport: Viewport, os_window_id: int = 1, active_tab: object = None):
|
|
self.viewport, self.os_window_id, self.active_tab = viewport, os_window_id, active_tab
|
|
self.tab_being_dropped: object = None
|
|
self.window_being_dropped: object = None
|
|
for name in ('on_tab_drop_move', 'on_window_drop_move', 'on_window_drop', 'on_tab_drop', 'finish_tab_drag_hover', 'layout_tab_bar'):
|
|
setattr(self, name, Mock(name=name))
|
|
|
|
def set_drag_over_me(self, over: bool) -> None:
|
|
self.viewport.drag_over = over
|
|
|
|
|
|
class BossDropTest(BaseTest):
|
|
"Drives the real Boss drop handlers against fake tab managers and a viewport model"
|
|
|
|
num_tabs_in_destination = 2
|
|
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.viewport = Viewport(num_tabs=self.num_tabs_in_destination)
|
|
self.viewports = {1: self.viewport}
|
|
self.window = SimpleNamespace(id=10)
|
|
self.source = SimpleNamespace(id=1, os_window_id=1, windows=SimpleNamespace(num_groups=1), active_window=self.window)
|
|
self.destination = SimpleNamespace(id=2)
|
|
self.tm = FakeTabManager(self.viewport, active_tab=self.destination)
|
|
self.boss = SimpleNamespace(
|
|
os_window_map={1: self.tm},
|
|
all_tab_managers=[self.tm],
|
|
tab_for_id=lambda tid: self.source if tid == 1 else None,
|
|
_move_tab_to=Mock(),
|
|
_move_window_to=Mock(),
|
|
_insert_window_in_direction=Mock(),
|
|
window_id_map={},
|
|
awaiting_window_drop=False,
|
|
_hide_force_shown_title_bars=Mock(),
|
|
)
|
|
for name in ('_update_drag_over', '_reset_drop_previews', '_sole_window_of_tab', '_tab_merge_target'):
|
|
setattr(self.boss, name, partial(getattr(Boss, name), self.boss))
|
|
self.data = {tab_mime(): b'1'}
|
|
for name, value in (
|
|
('viewport_for_window', lambda os_window_id: self.viewports[os_window_id].regions()),
|
|
('get_tab_being_dragged', Mock(return_value=(1, True))),
|
|
('get_window_being_dragged', Mock(return_value=(0, False))),
|
|
('set_tab_being_dragged', Mock()),
|
|
('change_drag_thumbnail', Mock()),
|
|
):
|
|
patcher = patch('kitty.boss.' + name, value)
|
|
patcher.start()
|
|
self.addCleanup(patcher.stop)
|
|
setattr(self, name, value)
|
|
|
|
def drag_move(self, x: int, y: int, is_leave: bool = False) -> tuple[tuple[object, ...], tuple[object, ...]]:
|
|
"Deliver a drag move and return the (window preview, tab preview) arguments it produced"
|
|
self.tm.on_window_drop_move.reset_mock()
|
|
self.tm.on_tab_drop_move.reset_mock()
|
|
Boss.on_drop_move(self.boss, 1, x, y, True, is_leave)
|
|
return self.tm.on_window_drop_move.call_args.args, self.tm.on_tab_drop_move.call_args.args
|
|
|
|
def drop(self, x: int, y: int) -> str:
|
|
"Deliver a drop and return the name of the action it performed"
|
|
Boss.on_drop(self.boss, 1, self.data, True, x, y)
|
|
if self.tm.on_window_drop.called:
|
|
return 'merge'
|
|
if self.tm.on_tab_drop.called:
|
|
return 'tab_drop'
|
|
if self.boss._move_tab_to.called:
|
|
return 'reorder'
|
|
return 'nothing'
|
|
|
|
|
|
class TestTabDropClassification(BossDropTest):
|
|
def test_single_window_tab_merges_into_destination_layout(self):
|
|
self.ae(self.drag_move(600, 400), ((10, True, 600, 400), (1, False, 600, 400)))
|
|
self.ae(self.drop(600, 400), 'merge')
|
|
self.tm.on_window_drop.assert_called_once_with(600, 400, 10)
|
|
self.tm.finish_tab_drag_hover.assert_called_with(restore_focus=False)
|
|
self.boss._move_tab_to.assert_not_called()
|
|
self.set_tab_being_dragged.assert_called_once_with()
|
|
|
|
def test_merge_works_across_os_windows(self):
|
|
self.source.os_window_id = 9
|
|
self.viewports[9] = Viewport(num_tabs=1)
|
|
self.ae(self.drag_move(600, 400)[0], (10, True, 600, 400))
|
|
self.ae(self.drop(600, 400), 'merge')
|
|
self.tm.on_window_drop.assert_called_once_with(600, 400, 10)
|
|
|
|
def test_tab_bar_drop_keeps_tab_behavior(self):
|
|
self.ae(self.drag_move(600, 10), ((0, False, 600, 10), (1, True, 600, 10)))
|
|
self.ae(self.drop(600, 10), 'tab_drop')
|
|
self.tm.on_tab_drop.assert_called_once_with(600, 10)
|
|
self.tm.finish_tab_drag_hover.assert_called_with(restore_focus=True)
|
|
|
|
def test_new_tab_drag_discards_stale_hover_focus(self):
|
|
# A failed drop never reaches _reset_drop_previews, so the saved focus must not survive
|
|
# into the next drag
|
|
self.boss.show_error = Mock()
|
|
Boss.on_drop(self.boss, 1, 5, True, 600, 10)
|
|
self.boss.show_error.assert_called_once()
|
|
self.tm.finish_tab_drag_hover.assert_not_called()
|
|
self.tm.start_tab_drag = Mock()
|
|
Boss.start_tab_drag(self.boss, 1, 0, b'', 0, 0)
|
|
self.tm.finish_tab_drag_hover.assert_called_once_with(restore_focus=False)
|
|
self.tm.start_tab_drag.assert_called_once_with(b'', 0, 0)
|
|
|
|
def test_cross_window_tab_bar_drop_keeps_destination_focus(self):
|
|
self.source.os_window_id = 9
|
|
self.ae(self.drop(600, 10), 'tab_drop')
|
|
self.tm.finish_tab_drag_hover.assert_called_with(restore_focus=False)
|
|
|
|
def test_multi_window_tab_keeps_tab_behavior(self):
|
|
self.source.windows.num_groups = 2
|
|
self.ae(self.drag_move(600, 400)[0], (0, False, 600, 400))
|
|
self.ae(self.drop(600, 400), 'reorder')
|
|
self.boss._move_tab_to.assert_called_once_with(self.source)
|
|
self.source.os_window_id = 9
|
|
self.viewports[9] = Viewport(num_tabs=1)
|
|
self.ae(self.drop(600, 400), 'tab_drop')
|
|
self.tm.on_tab_drop.assert_called_once_with(600, 400)
|
|
|
|
def test_tab_drop_into_self_keeps_tab_behavior(self):
|
|
self.tm.active_tab = self.source
|
|
self.ae(self.drag_move(600, 400)[0], (0, False, 600, 400))
|
|
self.ae(self.drop(600, 400), 'reorder')
|
|
self.boss._move_tab_to.assert_called_once_with(self.source)
|
|
|
|
def test_leaving_clears_previews(self):
|
|
self.drag_move(600, 400)
|
|
self.assertTrue(self.viewport.drag_over)
|
|
self.ae(self.drag_move(600, 400, is_leave=True), ((0, False, 600, 400), (1, False, 600, 400)))
|
|
self.assertFalse(self.viewport.drag_over, 'leaving must release the forced tab bar')
|
|
|
|
|
|
class TestTabDropClassificationStability(BossDropTest):
|
|
# A destination OS Window with a single tab has its tab bar hidden until the drag forces it
|
|
# visible, which is what makes the classification feed back into the geometry.
|
|
num_tabs_in_destination = 1
|
|
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.source.os_window_id = 9
|
|
self.viewports[9] = Viewport(num_tabs=1)
|
|
self.assertFalse(self.viewport.tab_bar_visible)
|
|
|
|
def test_classification_does_not_oscillate_over_the_tab_bar(self):
|
|
# y is inside the strip the tab bar occupies once the drag forces it visible
|
|
y = Viewport.tab_bar_height // 2
|
|
first = self.drag_move(600, y)
|
|
self.assertTrue(self.viewport.drag_over, 'the drag must force the destination tab bar visible')
|
|
for _ in range(3):
|
|
self.ae(self.drag_move(600, y), first, 'classification changed while the pointer stood still')
|
|
self.ae(first, ((0, False, 600, y), (1, True, 600, y)))
|
|
self.ae(self.drop(600, y), 'tab_drop', 'the drop disagreed with the preview')
|
|
|
|
def test_classification_is_stable_over_the_content_area(self):
|
|
first = self.drag_move(600, 400)
|
|
for _ in range(3):
|
|
self.ae(self.drag_move(600, 400), first)
|
|
self.ae(first, ((10, True, 600, 400), (1, False, 600, 400)))
|
|
self.ae(self.drop(600, 400), 'merge')
|
|
|
|
def test_drop_matches_preview_at_every_height(self):
|
|
for y in range(0, self.viewport.height, 7):
|
|
with self.subTest(y=y):
|
|
previewed_merge = self.drag_move(600, y)[0][1]
|
|
self.tm.on_window_drop.reset_mock(), self.tm.on_tab_drop.reset_mock()
|
|
self.boss._move_tab_to.reset_mock()
|
|
action = self.drop(600, y)
|
|
self.ae(action, 'merge' if previewed_merge else 'tab_drop')
|
|
|
|
|
|
class TestWaylandDragFinish(BossDropTest):
|
|
def finish(self, was_dropped: bool = True, was_canceled: bool = False) -> None:
|
|
Boss.on_drag_source_finished(self.boss, was_dropped, was_canceled, '', 0, self.data, True, not was_dropped)
|
|
|
|
def set_pending_target(self, quadrant: int, direction: str | None) -> SimpleNamespace:
|
|
target = SimpleNamespace(id=20, tab_id=2)
|
|
self.boss.window_id_map[20] = target
|
|
self.tm.window_being_dropped = SimpleNamespace(window_id=20, quadrant=quadrant, direction=direction)
|
|
return target
|
|
|
|
def test_cancel_clears_preview_without_detaching(self):
|
|
self.set_pending_target(1, 'left')
|
|
for reported_drop in (True, False):
|
|
with self.subTest(was_dropped=reported_drop):
|
|
self.finish(reported_drop, was_canceled=True)
|
|
self.tm.on_window_drop_move.assert_called_with()
|
|
self.boss._move_tab_to.assert_not_called()
|
|
self.boss._insert_window_in_direction.assert_not_called()
|
|
self.boss._move_window_to.assert_not_called()
|
|
|
|
def test_finish_inserts_at_the_previewed_edge(self):
|
|
for quadrant, direction in enumerate(('left', 'right', 'top', 'bottom'), 1):
|
|
with self.subTest(quadrant=quadrant):
|
|
target = self.set_pending_target(quadrant, direction)
|
|
self.finish()
|
|
self.boss._insert_window_in_direction.assert_called_with(self.window, target, direction)
|
|
self.tm.on_window_drop_move.assert_called_with()
|
|
self.boss._move_tab_to.assert_not_called()
|
|
|
|
def test_finish_uses_recorded_direction_for_whole_window_highlight(self):
|
|
# Quadrant 6 highlights the whole window (Stack and friends) but still inserts
|
|
# directionally, so the direction resolved when previewing must be the one used.
|
|
for direction in ('left', 'right', 'top', 'bottom'):
|
|
with self.subTest(direction=direction):
|
|
target = self.set_pending_target(6, direction)
|
|
self.finish()
|
|
self.boss._insert_window_in_direction.assert_called_with(self.window, target, direction)
|
|
|
|
def test_finish_moves_window_for_title_bar_target(self):
|
|
self.set_pending_target(5, None)
|
|
self.finish()
|
|
self.boss._move_window_to.assert_called_once_with(self.window, target_tab_id=2)
|
|
self.boss._insert_window_in_direction.assert_not_called()
|
|
|
|
def test_multi_window_tab_is_not_merged(self):
|
|
self.source.windows.num_groups = 2
|
|
self.set_pending_target(1, 'left')
|
|
self.finish()
|
|
self.boss._insert_window_in_direction.assert_not_called()
|
|
self.boss._move_window_to.assert_not_called()
|
|
|
|
def test_internal_drop_finishes_before_data_arrives(self):
|
|
# glfw.c reports was_dropped=False while an internal drop destination exists, even for a
|
|
# successful drop, and the data can arrive after this callback.
|
|
target = self.set_pending_target(1, 'left')
|
|
self.finish(was_dropped=False)
|
|
self.boss._insert_window_in_direction.assert_called_once_with(self.window, target, 'left')
|
|
self.boss._move_tab_to.assert_not_called()
|
|
|
|
def test_internal_tab_reordering_is_preserved(self):
|
|
self.tm.tab_being_dropped = SimpleNamespace()
|
|
self.finish(was_dropped=False)
|
|
self.tm.on_tab_drop.assert_called_once_with(0, 0, bypass_move=True)
|
|
self.boss._move_tab_to.assert_not_called()
|
|
|
|
def test_completed_drop_is_not_detached_again(self):
|
|
self.get_tab_being_dragged.return_value = (0, False)
|
|
self.finish()
|
|
self.boss._move_tab_to.assert_not_called()
|
|
|
|
def test_drop_outside_kitty_detaches_into_new_os_window(self):
|
|
self.finish()
|
|
self.boss._move_tab_to.assert_called_once_with(self.source)
|
|
|
|
|
|
class TestWindowDragFinish(BossDropTest):
|
|
"The title bars shown only for a window drag must stay until the drop has been classified"
|
|
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.data = {f'application/net.kovidgoyal.kitty-window-{os.getpid()}': b'10'}
|
|
self.get_window_being_dragged.return_value = (10, True)
|
|
self.enterContext(patch('kitty.boss.set_window_being_dragged'))
|
|
|
|
def finish(self, was_dropped: bool = False, was_canceled: bool = False, dropped_on_kitty: bool = True) -> None:
|
|
Boss.on_drag_source_finished(self.boss, was_dropped, was_canceled, '', 0, self.data, True, dropped_on_kitty)
|
|
|
|
def test_drop_on_kitty_delivered_after_finish(self):
|
|
self.finish()
|
|
self.boss._hide_force_shown_title_bars.assert_not_called()
|
|
self.assertTrue(self.boss.awaiting_window_drop)
|
|
Boss.on_drop(self.boss, 1, self.data, True, 600, 400)
|
|
# on_window_drop() hides them once it has classified the drop
|
|
self.tm.on_window_drop.assert_called_once_with(600, 400, 10)
|
|
self.boss._hide_force_shown_title_bars.assert_not_called()
|
|
self.assertFalse(self.boss.awaiting_window_drop)
|
|
# the leave that follows a drop must not do anything further
|
|
Boss.on_drop_move(self.boss, 1, 600, 400, True, True)
|
|
self.boss._hide_force_shown_title_bars.assert_not_called()
|
|
|
|
def test_awaited_drop_that_never_arrives(self):
|
|
self.finish()
|
|
self.get_window_being_dragged.return_value = (0, False)
|
|
Boss.on_drop_move(self.boss, 1, 600, 400, True, True)
|
|
self.boss._hide_force_shown_title_bars.assert_called_once_with()
|
|
self.assertFalse(self.boss.awaiting_window_drop)
|
|
|
|
def test_awaited_drop_replaced_by_another_drop(self):
|
|
self.tm.active_tab = None
|
|
for drop in ({'text/plain': b'x'}, 5):
|
|
with self.subTest(drop=drop):
|
|
self.boss._hide_force_shown_title_bars.reset_mock()
|
|
self.boss.awaiting_window_drop = True
|
|
with patch.object(self.boss, 'show_error', Mock(), create=True):
|
|
Boss.on_drop(self.boss, 1, drop, False, 600, 400)
|
|
self.boss._hide_force_shown_title_bars.assert_called_once_with()
|
|
self.assertFalse(self.boss.awaiting_window_drop)
|
|
|
|
def test_title_bars_hidden_immediately_without_a_drop_on_kitty(self):
|
|
for was_dropped, was_canceled, dropped_on_kitty in ((True, False, False), (False, True, False), (False, True, True), (False, False, False)):
|
|
with self.subTest(was_dropped=was_dropped, was_canceled=was_canceled, dropped_on_kitty=dropped_on_kitty):
|
|
self.boss._hide_force_shown_title_bars.reset_mock()
|
|
self.finish(was_dropped, was_canceled, dropped_on_kitty)
|
|
self.boss._hide_force_shown_title_bars.assert_called_once_with()
|
|
self.assertFalse(self.boss.awaiting_window_drop)
|
|
|
|
|
|
class TestFileDrop(BossDropTest):
|
|
def test_hit_test_accounts_for_an_offset_tab_bar(self):
|
|
central = self.viewport.regions()[0]
|
|
mid = (central.top + central.bottom) // 2
|
|
top = SimpleNamespace(id=1, is_visible_in_layout=True, geometry=region(0, central.top, central.right, mid), on_drop=Mock())
|
|
bottom = SimpleNamespace(id=2, is_visible_in_layout=True, geometry=region(0, mid, central.right, central.bottom), on_drop=Mock())
|
|
hidden = SimpleNamespace(id=3, is_visible_in_layout=False, geometry=top.geometry, on_drop=Mock())
|
|
tab = MagicMock()
|
|
tab.__iter__.return_value = [hidden, top, bottom]
|
|
self.tm.active_tab = tab
|
|
drop = {'text/plain': b'hello'}
|
|
for expected, y in ((top, central.top + 2), (top, mid - 2), (bottom, mid + 2), (bottom, central.bottom - 2)):
|
|
with self.subTest(y=y):
|
|
for w in (top, bottom, hidden):
|
|
w.on_drop.reset_mock()
|
|
tab.__iter__.return_value = [hidden, top, bottom]
|
|
Boss.on_drop(self.boss, 1, drop, False, 500, y)
|
|
expected.on_drop.assert_called_once_with(drop)
|
|
hidden.on_drop.assert_not_called()
|
|
|
|
|
|
class FakeTabs(SimpleNamespace):
|
|
"Enough of a TabManager to drive its drop handlers, with active_tab following the active index, as in the real one"
|
|
|
|
@property
|
|
def active_tab(self):
|
|
return self.tabs[self.active_tab_idx] if 0 <= self.active_tab_idx < len(self.tabs) else None
|
|
|
|
def bind(self, *names: str) -> None:
|
|
for name in names:
|
|
setattr(self, name, partial(getattr(TabManager, name), self))
|
|
self._set_active_tab = Mock(side_effect=lambda idx, **kw: setattr(self, 'active_tab_idx', idx))
|
|
self.set_active_tab = Mock(side_effect=lambda tab: setattr(self, 'active_tab_idx', self.tabs.index(tab)))
|
|
|
|
def ids(self) -> list[int]:
|
|
return [t.id for t in self.tabs]
|
|
|
|
|
|
class TestTabInsertionPreview(BaseTest):
|
|
def make_tab(self, tab_id, os_window_id=7, num_groups=2):
|
|
return SimpleNamespace(
|
|
id=tab_id,
|
|
os_window_id=os_window_id,
|
|
windows=SimpleNamespace(num_groups=num_groups),
|
|
active_window=SimpleNamespace(id=tab_id * 10),
|
|
data_for_tab_bar=lambda active: TabBarData(title=f'tab {tab_id}', tab_id=tab_id, is_active=active),
|
|
)
|
|
|
|
def setUp(self):
|
|
super().setUp()
|
|
tabs = [self.make_tab(i) for i in (1, 2, 3, 4)]
|
|
self.source = self.make_tab(9, 8)
|
|
self.tm = tm = FakeTabs(
|
|
tabs=tabs,
|
|
tabs_to_be_shown_in_tab_bar=tabs,
|
|
active_tab_idx=0,
|
|
os_window_id=7,
|
|
tab_bar=SimpleNamespace(
|
|
tab_drop_insert_before=None,
|
|
tab_insertion_target_at=Mock(return_value=2),
|
|
window_drop_target_at=Mock(return_value=WindowDropTarget(before_tab_id=2)),
|
|
),
|
|
tab_being_dropped=None,
|
|
window_drag_target_tab_id=0,
|
|
window_drag_over_me=True,
|
|
drag_hover=None,
|
|
drag_hover_delay=0.6,
|
|
tab_drag_focus_before_hover=0,
|
|
tab_drag_history_before_hover=(),
|
|
active_tab_history=deque(),
|
|
tab_bar_should_be_visible=True,
|
|
tab_bar_hidden=False,
|
|
mark_tab_bar_dirty=Mock(),
|
|
layout_tab_bar=Mock(),
|
|
resize=Mock(),
|
|
)
|
|
tm.bind(
|
|
'tab_for_id',
|
|
'on_tab_drop_move',
|
|
'on_tab_drop',
|
|
'apply_tab_ordering',
|
|
'_set_drag_target_tab',
|
|
'_cancel_drag_hover',
|
|
'_update_drag_hover',
|
|
'_activate_drag_hover',
|
|
'finish_tab_drag_hover',
|
|
)
|
|
|
|
def move(tab, os_window_id):
|
|
# Like the real one, the new tab is appended and made active
|
|
self.ae((tab.id, os_window_id), (9, 7))
|
|
tm.tabs.append(self.make_tab(99))
|
|
tm.active_tab_idx = len(tm.tabs) - 1
|
|
return tm.tabs[-1]
|
|
|
|
self.boss = SimpleNamespace(
|
|
tab_for_id=lambda tid: self.source if tid == 9 else tm.tab_for_id(tid),
|
|
_move_tab_to=Mock(side_effect=move),
|
|
_move_window_to=Mock(),
|
|
)
|
|
self.enterContext(patch('kitty.tabs.get_boss', return_value=self.boss))
|
|
self.enterContext(patch('kitty.tabs.is_tab_bar_visible', return_value=True))
|
|
self.enterContext(patch('kitty.tabs.set_tab_being_dragged'))
|
|
self.enterContext(patch('kitty.tabs.get_window_being_dragged', return_value=(0, False)))
|
|
self.drag = self.enterContext(patch('kitty.tabs.get_tab_being_dragged', return_value=(9, True, 0, 0)))
|
|
self.clock = self.enterContext(patch('kitty.tabs.monotonic', return_value=10.0))
|
|
self.add_timer = self.enterContext(patch('kitty.tabs.add_timer', side_effect=range(1, 100)))
|
|
self.remove_timer = self.enterContext(patch('kitty.tabs.remove_timer'))
|
|
self.enterContext(patch('kitty.tabs.get_options', return_value=SimpleNamespace(tab_bar_show_new_tab_button=False)))
|
|
self.reorder = self.enterContext(patch('kitty.tabs.reorder_tabs'))
|
|
|
|
def rendered_ids(self):
|
|
return [t.tab_id for t in TabManager.tab_bar_data.fget(self.tm)]
|
|
|
|
def test_cross_window_preview_keeps_existing_tabs_and_count(self):
|
|
for before, expected in ((1, [9, 1, 2, 3, 4]), (3, [1, 2, 9, 3, 4]), (0, [1, 2, 3, 4, 9])):
|
|
self.tm.tab_bar.tab_insertion_target_at.return_value = before
|
|
for _ in range(3):
|
|
self.tm.on_tab_drop_move(9, True, 200, 10)
|
|
self.ae(self.rendered_ids(), [1, 2, 3, 4])
|
|
self.ae(self.tm.ids(), [1, 2, 3, 4])
|
|
self.ae(self.tm.tab_being_dropped.tab_ids, expected)
|
|
self.ae(self.tm.tab_bar.tab_drop_insert_before, before)
|
|
self.boss._move_tab_to.assert_not_called()
|
|
self.reorder.assert_not_called()
|
|
|
|
def test_cross_window_drop_inserts_and_activates_dropped_tab(self):
|
|
self.tm.active_tab_idx = 2
|
|
self.tm.on_tab_drop_move(9, True, 200, 10)
|
|
self.tm.on_tab_drop(200, 10)
|
|
self.ae(self.tm.ids(), [1, 99, 2, 3, 4])
|
|
self.boss._move_tab_to.assert_called_once_with(self.source, 7)
|
|
self.ae(self.tm.active_tab.id, 99)
|
|
self.assertIsNone(self.tm.tab_bar.tab_drop_insert_before)
|
|
self.assertIsNone(self.tm.tab_being_dropped)
|
|
|
|
def test_same_window_drop_inserts_and_keeps_active_tab(self):
|
|
for active_idx, drag_id, before, expected in ((0, 1, 4, [2, 3, 1, 4]), (2, 1, 0, [2, 3, 4, 1]), (3, 4, 1, [4, 1, 2, 3])):
|
|
with self.subTest(drag_id=drag_id, before=before):
|
|
self.tm.tabs[:] = sorted(self.tm.tabs, key=lambda t: t.id)
|
|
self.tm.active_tab_idx = active_idx
|
|
active = self.tm.active_tab
|
|
self.tm.tab_bar.tab_insertion_target_at.return_value = before
|
|
self.tm.on_tab_drop_move(drag_id, True, 200, 10)
|
|
self.ae(self.rendered_ids(), [1, 2, 3, 4])
|
|
self.tm.on_tab_drop(200, 10)
|
|
self.ae(self.tm.ids(), expected)
|
|
self.assertIs(self.tm.active_tab, active)
|
|
self.boss._move_tab_to.assert_not_called()
|
|
|
|
def test_leaving_clears_marker_without_changing_order(self):
|
|
self.tm.on_tab_drop_move(9, True, 200, 10)
|
|
self.tm.on_tab_drop_move()
|
|
self.ae(self.rendered_ids(), [1, 2, 3, 4])
|
|
self.assertIsNone(self.tm.tab_bar.tab_drop_insert_before)
|
|
self.assertIsNone(self.tm.tab_being_dropped)
|
|
self.boss._move_tab_to.assert_not_called()
|
|
|
|
def test_pending_drop_finishes_at_previewed_boundary(self):
|
|
self.tm.on_tab_drop_move(9, True, 200, 10)
|
|
self.tm.tab_bar.tab_insertion_target_at.return_value = 0
|
|
self.tm.on_tab_drop(0, 0, bypass_move=True)
|
|
self.ae(self.tm.ids(), [1, 99, 2, 3, 4])
|
|
|
|
def test_closed_drag_source_clears_marker(self):
|
|
self.tm.on_tab_drop_move(9, True, 200, 10)
|
|
self.source = None
|
|
self.tm.on_tab_drop(200, 10)
|
|
self.assertIsNone(self.tm.tab_bar.tab_drop_insert_before)
|
|
self.assertIsNone(self.tm.tab_being_dropped)
|
|
self.ae(self.rendered_ids(), [1, 2, 3, 4])
|
|
|
|
def hover_single_pane(self, target_id=2):
|
|
self.source.windows.num_groups = 1
|
|
self.tm.tab_bar.window_drop_target_at.return_value = WindowDropTarget(tab_id=target_id)
|
|
self.tm.on_tab_drop_move(9, True, 200, 10)
|
|
|
|
def test_single_pane_tab_drop_on_tab_reorders(self):
|
|
self.hover_single_pane()
|
|
# The insertion marker is shown, as dropping re-orders rather than merges
|
|
self.ae(self.tm.tab_bar.tab_drop_insert_before, 2)
|
|
self.ae(self.tm.window_drag_target_tab_id, 0)
|
|
self.tm.on_tab_drop(200, 10)
|
|
self.boss._move_window_to.assert_not_called()
|
|
self.ae(self.tm.ids(), [1, 99, 2, 3, 4])
|
|
self.assertIsNone(self.tm.drag_hover)
|
|
|
|
def test_single_pane_tab_hover_switches_without_moving(self):
|
|
self.hover_single_pane()
|
|
self.ae(self.rendered_ids(), [1, 2, 3, 4])
|
|
self.tm.set_active_tab.assert_not_called()
|
|
callback, interval, repeats = self.add_timer.call_args.args
|
|
self.ae((interval, repeats), (0.6, False))
|
|
callback(self.tm.drag_hover.timer)
|
|
self.ae(self.tm.active_tab.id, 2)
|
|
self.boss._move_window_to.assert_not_called()
|
|
self.boss._move_tab_to.assert_not_called()
|
|
self.remove_timer.assert_not_called()
|
|
|
|
def test_tab_bar_drop_restores_focus_after_hover_with_or_without_reorder(self):
|
|
source = self.tm.tabs[0]
|
|
source.windows.num_groups = 1
|
|
self.source = source
|
|
self.drag.return_value = (source.id, True, 0, 0)
|
|
self.tm.tab_bar.window_drop_target_at.return_value = WindowDropTarget(tab_id=2)
|
|
for before, expected in ((2, [1, 2, 3, 4]), (0, [2, 3, 4, 1])):
|
|
with self.subTest(before=before):
|
|
self.tm.tabs[:] = sorted(self.tm.tabs, key=lambda t: t.id)
|
|
self.tm.active_tab_idx = 2 # The dragged tab need not be the active one
|
|
self.tm.active_tab_history = deque([4])
|
|
self.tm.tab_bar.tab_insertion_target_at.return_value = before
|
|
self.tm.on_tab_drop_move(source.id, True, 200, 10)
|
|
self.add_timer.call_args.args[0](self.tm.drag_hover.timer)
|
|
self.ae(self.tm.active_tab.id, 2)
|
|
self.tm.on_tab_drop(200, 10)
|
|
self.tm.finish_tab_drag_hover()
|
|
self.ae(self.tm.ids(), expected)
|
|
self.ae(self.tm.active_tab.id, 3)
|
|
self.ae(list(self.tm.active_tab_history), [4])
|
|
|
|
def test_split_drop_keeps_hovered_tab_active(self):
|
|
self.hover_single_pane()
|
|
self.add_timer.call_args.args[0](self.tm.drag_hover.timer)
|
|
self.tm.finish_tab_drag_hover(restore_focus=False)
|
|
self.ae(self.tm.active_tab.id, 2)
|
|
self.ae(self.tm.tab_drag_focus_before_hover, 0)
|
|
|
|
def test_single_pane_tab_periodic_hover_switches_at_deadline(self):
|
|
self.hover_single_pane()
|
|
self.clock.return_value = 10.59
|
|
self.tm.on_tab_drop_move(9, True, 200, 10)
|
|
self.tm.set_active_tab.assert_not_called()
|
|
self.clock.return_value = 10.6
|
|
self.tm.on_tab_drop_move(9, True, 200, 10)
|
|
self.ae(self.tm.active_tab.id, 2)
|
|
self.remove_timer.assert_called_once_with(1)
|
|
self.tm.on_tab_drop_move(9, True, 200, 10)
|
|
self.ae(self.add_timer.call_count, 1)
|
|
|
|
def test_single_pane_tab_edge_cancels_hover_and_keeps_insertion(self):
|
|
self.hover_single_pane()
|
|
callback = self.add_timer.call_args.args[0]
|
|
self.tm.tab_bar.window_drop_target_at.return_value = WindowDropTarget(before_tab_id=2)
|
|
self.tm.on_tab_drop_move(9, True, 200, 10)
|
|
callback(1)
|
|
self.tm.set_active_tab.assert_not_called()
|
|
self.ae(self.tm.tab_bar.tab_drop_insert_before, 2)
|
|
self.assertIsNone(self.tm.drag_hover)
|
|
self.remove_timer.assert_called_once_with(1)
|
|
|
|
def test_single_pane_tab_leaving_cancels_hover(self):
|
|
self.hover_single_pane()
|
|
callback = self.add_timer.call_args.args[0]
|
|
self.tm.on_tab_drop_move()
|
|
callback(1)
|
|
self.tm.set_active_tab.assert_not_called()
|
|
self.assertIsNone(self.tm.drag_hover)
|
|
|
|
def test_multiple_pane_tab_does_not_hover_switch(self):
|
|
self.tm.tab_bar.window_drop_target_at.return_value = WindowDropTarget(tab_id=2)
|
|
self.tm.on_tab_drop_move(9, True, 200, 10)
|
|
self.ae(self.tm.tab_bar.tab_drop_insert_before, 2)
|
|
self.add_timer.assert_not_called()
|
|
|
|
def test_adding_a_pane_during_hover_prevents_switching(self):
|
|
self.hover_single_pane()
|
|
self.source.windows.num_groups = 2
|
|
self.add_timer.call_args.args[0](self.tm.drag_hover.timer)
|
|
self.tm.set_active_tab.assert_not_called()
|
|
|
|
def test_finished_tab_drag_cannot_switch_later(self):
|
|
self.hover_single_pane()
|
|
self.drag.return_value = (0, False, 0, 0)
|
|
self.add_timer.call_args.args[0](self.tm.drag_hover.timer)
|
|
self.tm.set_active_tab.assert_not_called()
|
|
|
|
def test_tab_hover_ignores_stale_timer_after_changing_target(self):
|
|
self.hover_single_pane()
|
|
callback = self.add_timer.call_args.args[0]
|
|
self.hover_single_pane(3)
|
|
callback(1)
|
|
self.tm.set_active_tab.assert_not_called()
|
|
callback(2)
|
|
self.ae(self.tm.active_tab.id, 3)
|
|
|
|
|
|
class TestWindowDropTabs(BaseTest):
|
|
def make_tab(self, tab_id, num_windows=1, os_window_id=7):
|
|
tab = SimpleNamespace(id=tab_id, os_window_id=os_window_id, windows=SimpleNamespace(num_groups=num_windows))
|
|
tab.active_window = SimpleNamespace(id=tab_id * 10, tabref=lambda: tab)
|
|
return tab
|
|
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.tabs = [self.make_tab(1, 2), self.make_tab(2), self.make_tab(3)]
|
|
self.tm = tm = FakeTabs(
|
|
tabs=self.tabs,
|
|
active_tab_idx=0,
|
|
tab_bar=SimpleNamespace(window_drop_insert_before=None),
|
|
window_drag_target_tab_id=0,
|
|
drag_hover=None,
|
|
drag_hover_delay=0.6,
|
|
window_drag_over_me=True,
|
|
os_window_id=7,
|
|
mark_tab_bar_dirty=Mock(),
|
|
set_drag_over_me=Mock(),
|
|
_clear_force_show_title_bars=Mock(),
|
|
)
|
|
tm.bind(
|
|
'tab_for_id',
|
|
'_set_drag_target_tab',
|
|
'_cancel_drag_hover',
|
|
'_activate_drag_hover',
|
|
'_update_drag_hover',
|
|
'_set_window_drop_tab_target',
|
|
'apply_tab_ordering',
|
|
'_insert_window_as_tab',
|
|
)
|
|
self.clock = self.enterContext(patch('kitty.tabs.monotonic', return_value=10.0))
|
|
self.drag = self.enterContext(patch('kitty.tabs.get_window_being_dragged', return_value=(10, True, 0, 0)))
|
|
self.add_timer = self.enterContext(patch('kitty.tabs.add_timer', side_effect=range(1, 100)))
|
|
self.remove_timer = self.enterContext(patch('kitty.tabs.remove_timer'))
|
|
|
|
def hover(self, tab_id=2):
|
|
self.tm._set_window_drop_tab_target(WindowDropTarget(tab_id=tab_id), 10)
|
|
|
|
def test_hover_timer_switches_without_moving_window(self):
|
|
self.hover()
|
|
self.tm.set_active_tab.assert_not_called()
|
|
callback, interval, repeats = self.add_timer.call_args.args
|
|
self.ae((interval, repeats), (0.6, False))
|
|
callback(1)
|
|
self.tm.set_active_tab.assert_called_once_with(self.tabs[1])
|
|
self.assertIsNone(self.tm.drag_hover)
|
|
self.remove_timer.assert_not_called()
|
|
|
|
def test_periodic_drag_updates_switch_at_deadline(self):
|
|
self.hover()
|
|
self.clock.return_value = 10.59
|
|
self.hover()
|
|
self.tm.set_active_tab.assert_not_called()
|
|
self.clock.return_value = 10.6
|
|
self.hover()
|
|
self.tm.set_active_tab.assert_called_once_with(self.tabs[1])
|
|
self.remove_timer.assert_called_once_with(1)
|
|
self.hover()
|
|
self.ae(self.add_timer.call_count, 1)
|
|
|
|
def test_clearing_window_preview_preserves_tab_hover(self):
|
|
self.tm._update_drag_hover(2, 9, source_is_window=False)
|
|
hover = self.tm.drag_hover
|
|
for _ in range(3):
|
|
self.tm._set_window_drop_tab_target()
|
|
self.assertIs(self.tm.drag_hover, hover)
|
|
self.add_timer.assert_called_once()
|
|
self.remove_timer.assert_not_called()
|
|
|
|
def test_changing_targets_restarts_hover_and_ignores_stale_timer(self):
|
|
self.hover()
|
|
first_callback = self.add_timer.call_args.args[0]
|
|
self.hover(3)
|
|
first_callback(1)
|
|
self.tm.set_active_tab.assert_not_called()
|
|
self.add_timer.call_args.args[0](2)
|
|
self.tm.set_active_tab.assert_called_once_with(self.tabs[2])
|
|
|
|
def test_clearing_or_inserting_cancels_hover(self):
|
|
for target in (None, WindowDropTarget(before_tab_id=2), WindowDropTarget(before_tab_id=0)):
|
|
with self.subTest(target=target):
|
|
self.hover()
|
|
callback = self.add_timer.call_args.args[0]
|
|
timer = self.tm.drag_hover.timer
|
|
self.tm._set_window_drop_tab_target(target)
|
|
callback(timer)
|
|
self.tm.set_active_tab.assert_not_called()
|
|
self.assertIsNone(self.tm.drag_hover)
|
|
self.ae(self.tm.tab_bar.window_drop_insert_before, target.before_tab_id if target else None)
|
|
|
|
def test_new_tab_button_is_highlighted_only_when_appending(self):
|
|
for target, highlighted in (
|
|
(WindowDropTarget(before_tab_id=0), -1),
|
|
(WindowDropTarget(before_tab_id=2), 0),
|
|
(WindowDropTarget(tab_id=3), 3),
|
|
(None, 0),
|
|
):
|
|
self.tm._set_window_drop_tab_target(target, 10)
|
|
self.ae(self.tm.window_drag_target_tab_id, highlighted, target)
|
|
|
|
def test_ended_drag_or_closed_target_cannot_switch(self):
|
|
for closed in (False, True):
|
|
self.hover()
|
|
timer = self.tm.drag_hover.timer
|
|
if closed:
|
|
self.tabs.remove(self.tabs[1])
|
|
else:
|
|
self.drag.return_value = (0, False, 0, 0)
|
|
self.add_timer.call_args.args[0](timer)
|
|
self.tm.set_active_tab.assert_not_called()
|
|
self.drag.return_value = (10, True, 0, 0)
|
|
|
|
def drop(self, target, window):
|
|
tm = self.tm
|
|
tm.tab_bar.window_drop_target_at = Mock(return_value=target)
|
|
|
|
def move_window(w, target_tab_id, target_os_window_id=None):
|
|
# Like the real one, creates the new tab before moving the window into it
|
|
self.assertIs(w, window)
|
|
if target_tab_id == 'new':
|
|
self.ae(target_os_window_id, 7)
|
|
tab = self.make_tab(4)
|
|
tm.tabs.append(tab)
|
|
w.tabref = lambda: tab
|
|
else:
|
|
self.assertIsNotNone(tm.tab_for_id(target_tab_id))
|
|
|
|
def move_tab(tab, os_window_id):
|
|
self.ae(os_window_id, 7)
|
|
new_tab = self.make_tab(5)
|
|
tm.tabs.append(new_tab)
|
|
return new_tab
|
|
|
|
boss = SimpleNamespace(window_id_map={window.id: window}, _move_window_to=Mock(side_effect=move_window), _move_tab_to=Mock(side_effect=move_tab))
|
|
boss._sole_window_of_tab = partial(Boss._sole_window_of_tab, boss)
|
|
with (
|
|
patch('kitty.tabs.get_boss', return_value=boss),
|
|
patch('kitty.tabs.set_window_being_dragged'),
|
|
patch('kitty.tabs.reorder_tabs') as reorder,
|
|
patch('kitty.fast_data_types.viewport_for_window', return_value=(region(0, 30, 1000, 800), region(0, 0, 1000, 30))),
|
|
):
|
|
TabManager.on_window_drop(tm, 500, 10, window.id)
|
|
return boss, reorder
|
|
|
|
def test_drop_window_of_multi_window_tab_creates_tab_at_position(self):
|
|
for before, expected in ((1, [4, 1, 2, 3]), (2, [1, 4, 2, 3]), (0, [1, 2, 3, 4])):
|
|
with self.subTest(before=before):
|
|
self.tm.tabs[:] = self.tabs = [t for t in self.tabs if t.id != 4]
|
|
window = SimpleNamespace(id=11, tabref=lambda: self.tabs[0])
|
|
boss, reorder = self.drop(WindowDropTarget(before_tab_id=before), window)
|
|
self.ae(self.tm.ids(), expected)
|
|
reorder.assert_called_once_with(7, *expected)
|
|
boss._move_window_to.assert_called_once_with(window, target_tab_id='new', target_os_window_id=7)
|
|
self.ae(self.tm.active_tab.id, 4)
|
|
|
|
def test_drop_window_of_single_window_tab_moves_its_tab(self):
|
|
for before, expected in ((1, [3, 1, 2]), (3, [1, 2, 3]), (0, [1, 2, 3])):
|
|
with self.subTest(before=before):
|
|
self.tm.tabs[:] = sorted(self.tm.tabs, key=lambda t: t.id)
|
|
boss, reorder = self.drop(WindowDropTarget(before_tab_id=before), self.tabs[2].active_window)
|
|
boss._move_window_to.assert_not_called()
|
|
boss._move_tab_to.assert_not_called()
|
|
self.ae(self.tm.ids(), expected)
|
|
self.ae(self.tm.active_tab.id, 3)
|
|
|
|
def test_drop_window_of_single_window_tab_from_other_os_window(self):
|
|
other = self.make_tab(9, os_window_id=8)
|
|
boss, reorder = self.drop(WindowDropTarget(before_tab_id=2), other.active_window)
|
|
boss._move_tab_to.assert_called_once_with(other, 7)
|
|
boss._move_window_to.assert_not_called()
|
|
self.ae(self.tm.ids(), [1, 5, 2, 3])
|
|
self.ae(self.tm.active_tab.id, 5)
|
|
|
|
def test_failed_window_move_leaves_tabs_alone(self):
|
|
window = SimpleNamespace(id=11, tabref=lambda: None)
|
|
boss, reorder = self.drop(WindowDropTarget(before_tab_id=2), window)
|
|
boss._move_window_to.assert_not_called()
|
|
self.ae(self.tm.ids(), [1, 2, 3])
|
|
reorder.assert_not_called()
|
|
|
|
def test_center_drop_moves_to_existing_tab(self):
|
|
window = SimpleNamespace(id=11, tabref=lambda: self.tabs[0])
|
|
boss, reorder = self.drop(WindowDropTarget(tab_id=2), window)
|
|
boss._move_window_to.assert_called_once_with(window, target_tab_id=2)
|
|
reorder.assert_not_called()
|
|
|
|
|
|
class TestWindowDropTargets(BaseTest):
|
|
"Drives the real TabManager drop handlers, whose hit testing is in OS Window coordinates"
|
|
|
|
def make_window(self, win_id, geometry, show_title_bar=False, is_visible_in_layout=True, tab=None):
|
|
return SimpleNamespace(
|
|
id=win_id,
|
|
geometry=geometry,
|
|
show_title_bar=show_title_bar,
|
|
is_visible_in_layout=is_visible_in_layout,
|
|
tab_id=7,
|
|
tabref=lambda: tab,
|
|
is_drag_target=False,
|
|
_title_bar_screen=None,
|
|
update_title_bar=Mock(),
|
|
)
|
|
|
|
def make_boss(self, *windows):
|
|
return SimpleNamespace(window_id_map={w.id: w for w in windows}, _insert_window_in_direction=Mock(), _move_window_to=Mock())
|
|
|
|
def make_tab_manager(self, windows, central, tab_bar, mode=DragOverlayMode.free):
|
|
tab = MagicMock(current_layout=SimpleNamespace(drag_overlay_mode=mode))
|
|
tab.__iter__.side_effect = lambda: iter(windows)
|
|
tm = SimpleNamespace(
|
|
os_window_id=1,
|
|
active_tab=tab,
|
|
window_being_dropped=None,
|
|
window_drag_over_me=True,
|
|
tab_bar_hidden=False,
|
|
_set_drag_target_tab=Mock(),
|
|
_set_window_drop_tab_target=Mock(),
|
|
_clear_force_show_title_bars=Mock(),
|
|
mark_tab_bar_dirty=Mock(),
|
|
layout_tab_bar=Mock(),
|
|
resize=Mock(),
|
|
set_drag_over_me=Mock(),
|
|
)
|
|
for name in ('_find_window_at', '_pointer_in_title_bar_of', '_drop_direction_for', '_set_drag_target_window', 'on_window_drop_move'):
|
|
setattr(tm, name, partial(getattr(TabManager, name), tm))
|
|
return tm, (central, tab_bar, central.right, central.bottom, 10, 20)
|
|
|
|
def drop_window(self, tm, regions, boss, x, y, window_id):
|
|
with (
|
|
patch('kitty.fast_data_types.viewport_for_window', return_value=regions),
|
|
patch('kitty.fast_data_types.cell_size_for_window', return_value=(10, 20)),
|
|
patch('kitty.fast_data_types.set_window_drag_overlay'),
|
|
patch('kitty.tabs.get_options', return_value=SimpleNamespace(window_title_bar='top')),
|
|
patch('kitty.tabs.get_boss', return_value=boss),
|
|
patch('kitty.tabs.set_window_being_dragged'),
|
|
):
|
|
tm.on_window_drop_move(window_id, True, x, y)
|
|
preview = tm.window_being_dropped
|
|
TabManager.on_window_drop(tm, x, y, window_id)
|
|
return preview
|
|
|
|
def edge_points(self, g):
|
|
return {
|
|
'left': (g.left + 2, (g.top + g.bottom) // 2),
|
|
'right': (g.right - 2, (g.top + g.bottom) // 2),
|
|
'top': ((g.left + g.right) // 2, g.top + 2),
|
|
'bottom': ((g.left + g.right) // 2, g.bottom - 2),
|
|
}
|
|
|
|
def test_drop_with_offset_tab_bar(self):
|
|
for left, top in ((0, 30), (80, 0), (80, 30)):
|
|
central = region(left, top, 1000, 800)
|
|
tab_bar = region(0, 0, left or 1000, top or 800)
|
|
g = region(left + 5, top + 5, 995, 795)
|
|
dest = self.make_window(20, g)
|
|
src = self.make_window(10, g)
|
|
tm, regions = self.make_tab_manager([dest], central, tab_bar)
|
|
boss = self.make_boss(src, dest)
|
|
for direction, (x, y) in self.edge_points(g).items():
|
|
with self.subTest(left=left, top=top, direction=direction):
|
|
boss._insert_window_in_direction.reset_mock()
|
|
tm.window_being_dropped = None
|
|
preview = self.drop_window(tm, regions, boss, x, y, 10)
|
|
self.ae((preview.window_id, preview.direction), (20, direction))
|
|
boss._insert_window_in_direction.assert_called_once_with(src, dest, direction)
|
|
boss._move_window_to.assert_not_called()
|
|
|
|
def test_hidden_windows_are_not_drop_targets(self):
|
|
# In a Stack layout every group has the same geometry and only one window is visible, so
|
|
# without a visibility check the hit test would depend on iteration order.
|
|
central = region(0, 30, 1000, 800)
|
|
g = region(5, 35, 995, 795)
|
|
hidden = self.make_window(30, g, is_visible_in_layout=False)
|
|
visible = self.make_window(20, g)
|
|
src = self.make_window(10, g)
|
|
tm, regions = self.make_tab_manager([hidden, visible], central, region(0, 0, 1000, 30))
|
|
boss = self.make_boss(src, visible, hidden)
|
|
with patch('kitty.fast_data_types.viewport_for_window', return_value=regions):
|
|
self.assertIs(TabManager._find_window_at(tm, 500, 400), visible)
|
|
preview = self.drop_window(tm, regions, boss, 500, 400, 10)
|
|
self.ae(preview.window_id, 20)
|
|
boss._insert_window_in_direction.assert_called_once()
|
|
self.assertIs(boss._insert_window_in_direction.call_args.args[1], visible)
|
|
|
|
def test_whole_window_highlight_still_records_a_direction(self):
|
|
central = region(0, 30, 1000, 800)
|
|
g = region(5, 35, 995, 795)
|
|
dest = self.make_window(20, g)
|
|
src = self.make_window(10, g)
|
|
tm, regions = self.make_tab_manager([dest], central, region(0, 0, 1000, 30), mode=DragOverlayMode.full)
|
|
boss = self.make_boss(src, dest)
|
|
for direction, (x, y) in self.edge_points(g).items():
|
|
with self.subTest(direction=direction):
|
|
boss._insert_window_in_direction.reset_mock()
|
|
tm.window_being_dropped = None
|
|
preview = self.drop_window(tm, regions, boss, x, y, 10)
|
|
self.ae((preview.quadrant, preview.direction), (6, direction))
|
|
boss._insert_window_in_direction.assert_called_once_with(src, dest, direction)
|
|
|
|
def test_axis_layouts_restrict_the_direction(self):
|
|
central = region(0, 30, 1000, 800)
|
|
g = region(5, 35, 995, 795)
|
|
dest = self.make_window(20, g)
|
|
for mode, expected in (
|
|
(DragOverlayMode.axis_x, {'left': 'left', 'right': 'right', 'top': 'left', 'bottom': 'right'}),
|
|
(DragOverlayMode.axis_y, {'left': 'top', 'right': 'bottom', 'top': 'top', 'bottom': 'bottom'}),
|
|
):
|
|
tm, _ = self.make_tab_manager([dest], central, region(0, 0, 1000, 30), mode=mode)
|
|
for edge, (x, y) in self.edge_points(g).items():
|
|
with self.subTest(mode=mode, edge=edge):
|
|
# the pointer is exactly centred on the off-axis, so ties resolve to the
|
|
# second half of the axis; only the on-axis edges are interesting
|
|
if edge in ('left', 'right') and mode is DragOverlayMode.axis_y:
|
|
continue
|
|
if edge in ('top', 'bottom') and mode is DragOverlayMode.axis_x:
|
|
continue
|
|
self.ae(TabManager._drop_direction_for(tm, dest, x, y), expected[edge])
|
|
|
|
def hide_title_bar_on_clear(self, tm, *windows):
|
|
"Make clearing the title bars shown for the drag hide them, moving the window content up as the real layout does"
|
|
|
|
def clear():
|
|
for w in windows:
|
|
if w.show_title_bar:
|
|
w.show_title_bar = False
|
|
w.geometry = region(w.geometry.left, w.geometry.top + 20, w.geometry.right, w.geometry.bottom)
|
|
|
|
tm._clear_force_show_title_bars = Mock(side_effect=clear)
|
|
|
|
def test_drop_on_temporarily_shown_title_bar_swaps(self):
|
|
central = region(0, 30, 1000, 800)
|
|
tab = MagicMock()
|
|
dest = self.make_window(20, region(5, 35, 995, 400), show_title_bar=True, tab=tab)
|
|
src = self.make_window(10, region(5, 400, 995, 795), show_title_bar=True, tab=tab)
|
|
tm, regions = self.make_tab_manager([dest, src], central, region(0, 0, 1000, 30))
|
|
self.hide_title_bar_on_clear(tm, dest, src)
|
|
boss = self.make_boss(src, dest)
|
|
preview = self.drop_window(tm, regions, boss, 500, 45, 10)
|
|
self.ae(preview.quadrant, 5)
|
|
tm._clear_force_show_title_bars.assert_called_once_with()
|
|
tab.swap_windows.assert_called_once_with(src, dest)
|
|
boss._insert_window_in_direction.assert_not_called()
|
|
boss._move_window_to.assert_not_called()
|
|
|
|
def test_drop_direction_matches_preview_when_title_bars_hide(self):
|
|
central = region(0, 30, 1000, 800)
|
|
g = region(5, 35, 995, 795)
|
|
# just below the centre of the window with its title bar shown, and so above
|
|
# the centre once hiding the title bar moves the window down
|
|
x, y = (g.left + g.right) // 2, (g.top + g.bottom) // 2 + 5
|
|
dest = self.make_window(20, g, show_title_bar=True)
|
|
src = self.make_window(10, g)
|
|
tm, regions = self.make_tab_manager([dest], central, region(0, 0, 1000, 30), mode=DragOverlayMode.axis_y)
|
|
self.hide_title_bar_on_clear(tm, dest)
|
|
boss = self.make_boss(src, dest)
|
|
preview = self.drop_window(tm, regions, boss, x, y, 10)
|
|
self.ae(preview.direction, 'bottom')
|
|
boss._insert_window_in_direction.assert_called_once_with(src, dest, 'bottom')
|
|
|
|
def test_title_bar_hover_targets_the_whole_window(self):
|
|
central = region(0, 30, 1000, 800)
|
|
g = region(5, 35, 995, 795)
|
|
dest = self.make_window(20, g, show_title_bar=True, tab=object())
|
|
src = self.make_window(10, g, tab=object())
|
|
tm, regions = self.make_tab_manager([dest], central, region(0, 0, 1000, 30))
|
|
tm.active_tab.id = 7
|
|
boss = self.make_boss(src, dest)
|
|
preview = self.drop_window(tm, regions, boss, 500, g.top + 5, 10)
|
|
self.ae((preview.quadrant, preview.direction), (5, None))
|
|
boss._move_window_to.assert_called_once_with(src, target_tab_id=7)
|
|
boss._insert_window_in_direction.assert_not_called()
|
|
|
|
|
|
def make_tab(layout, windows):
|
|
"A stand-in for Tab that uses the real window attaching implementation"
|
|
tab = SimpleNamespace(id=2, os_window_id=1, current_layout=layout, windows=windows, mark_tab_bar_dirty=Mock(), relayout=Mock())
|
|
tab._add_window = lambda window, overlay_for=None: layout.add_window(windows, window, overlay_for=overlay_for)
|
|
for name in ('_take_ownership_of_window', 'attach_window', 'attach_window_at_edge', 'attach_windows'):
|
|
setattr(tab, name, partial(getattr(Tab, name), tab))
|
|
return tab
|
|
|
|
|
|
def new_window(win_id):
|
|
w = Window(win_id)
|
|
w.change_tab = Mock()
|
|
return w
|
|
|
|
|
|
class TestWindowAttach(BaseTest):
|
|
def test_attach_at_edge_preserves_split_weights_and_overlays(self):
|
|
for horizontal in (True, False):
|
|
for after in (True, False):
|
|
with self.subTest(horizontal=horizontal, after=after):
|
|
layout = create_layout(Splits)
|
|
windows = create_windows(layout, num=0)
|
|
for wid in (1, 2, 3):
|
|
layout.add_window(windows, Window(wid), location='vsplit')
|
|
layout.pairs_root.unserialize({'bias': 0.2, 'one': 1, 'two': {'bias': 0.375, 'one': 2, 'two': 3}}, lambda x: x)
|
|
tab = make_tab(layout, windows)
|
|
pane, overlay = new_window(4), new_window(5)
|
|
with patch('kitty.tabs.attach_window') as native_attach:
|
|
tab.attach_windows((pane, overlay), next_to=windows.id_map[2], horizontal=horizontal, after=after)
|
|
self.ae(native_attach.call_count, 2, 'every window must be handed over to the tab natively')
|
|
for w in (pane, overlay):
|
|
w.change_tab.assert_called_once_with(tab)
|
|
root = layout.pairs_root
|
|
self.assertAlmostEqual(root.bias, 0.2)
|
|
self.assertAlmostEqual(root.two.bias, 0.375)
|
|
split = root.two.one
|
|
self.ae(split.horizontal, horizontal)
|
|
self.ae((split.one, split.two), (2, 4) if after else (4, 2))
|
|
self.assertAlmostEqual(split.bias, 0.5)
|
|
self.assertIs(windows.group_for_window(pane), windows.group_for_window(overlay))
|
|
self.assertIs(windows.active_window, overlay)
|
|
|
|
def test_attach_at_edge_keeps_the_new_group_beside_its_target(self):
|
|
# For layouts where group order is the layout, the new group must land next to the drop
|
|
# target rather than being appended and then swapped with an unrelated group.
|
|
for after in (True, False):
|
|
with self.subTest(after=after):
|
|
layout = create_layout(Stack)
|
|
windows = create_windows(layout, num=3)
|
|
tab = make_tab(layout, windows)
|
|
target = windows.id_map[2]
|
|
target_gid = windows.group_for_window(target).id
|
|
others = [g.id for g in windows.groups if g.id != target_gid]
|
|
pane = new_window(4)
|
|
with patch('kitty.tabs.attach_window'):
|
|
tab.attach_windows((pane,), next_to=target, horizontal=True, after=after)
|
|
order = [g.id for g in windows.groups]
|
|
new_gid = windows.group_for_window(pane).id
|
|
self.ae(abs(order.index(new_gid) - order.index(target_gid)), 1, f'new group is not beside its target: {order}')
|
|
self.ae([gid for gid in order if gid not in (new_gid, target_gid)], others, 'an unrelated group was moved')
|
|
|
|
def test_attach_without_a_target_is_unchanged(self):
|
|
layout = create_layout(Tall)
|
|
windows = create_windows(layout, num=2)
|
|
tab = make_tab(layout, windows)
|
|
pane, overlay = new_window(4), new_window(5)
|
|
with patch('kitty.tabs.attach_window') as native_attach:
|
|
tab.attach_windows((pane, overlay))
|
|
self.ae(native_attach.call_count, 2)
|
|
self.ae(len(windows.groups), 3)
|
|
self.assertIs(windows.group_for_window(pane), windows.group_for_window(overlay))
|
|
|
|
def test_cross_tab_directional_insert_uses_direct_attachment(self):
|
|
source = SimpleNamespace(detach_window=Mock(return_value=('pane', 'overlay')))
|
|
dest = SimpleNamespace(attach_windows=Mock(), make_active=Mock())
|
|
pane = SimpleNamespace(tabref=lambda: source)
|
|
target = SimpleNamespace(tabref=lambda: dest)
|
|
boss = SimpleNamespace(suppress_focus_change_events=nullcontext, _cleanup_tab_after_window_removal=Mock())
|
|
for direction, horizontal, after in (('left', True, False), ('right', True, True), ('top', False, False), ('bottom', False, True)):
|
|
with self.subTest(direction=direction):
|
|
Boss._insert_window_in_direction(boss, pane, target, direction)
|
|
dest.attach_windows.assert_called_with(('pane', 'overlay'), next_to=target, horizontal=horizontal, after=after)
|
|
boss._cleanup_tab_after_window_removal.assert_called_with(source)
|
|
dest.make_active.assert_called_with()
|
|
|
|
def test_same_tab_directional_insert_repositions_in_place(self):
|
|
layout = create_layout(Splits)
|
|
windows = create_windows(layout, num=0)
|
|
for wid in (1, 2, 3):
|
|
layout.add_window(windows, Window(wid), location='vsplit')
|
|
tab = SimpleNamespace(current_layout=layout, windows=windows, relayout=Mock())
|
|
window, dest_window = windows.id_map[3], windows.id_map[1]
|
|
window.tabref = dest_window.tabref = lambda: tab
|
|
boss = SimpleNamespace(suppress_focus_change_events=nullcontext)
|
|
Boss._insert_window_in_direction(boss, window, dest_window, 'top')
|
|
src_gid = windows.group_for_window(window).id
|
|
pair = layout.pairs_root.pair_for_window(src_gid)
|
|
self.ae(sorted(pair.all_window_ids()), sorted((src_gid, windows.group_for_window(dest_window).id)))
|
|
self.assertFalse(pair.horizontal, "'top' must split along the vertical axis")
|
|
self.ae(pair.one, src_gid, "'top' must put the moved window before its target")
|
|
tab.relayout.assert_called_with()
|