kitty/kitty_tests/tab_bar.py
Kovid Goyal b692122f22
Allow selecting text drawn in the tab bar outside the tabs
Dragging the mouse over text drawn in the tab bar outside the tabs, such
as text a custom tab_bar.py draws below the tabs of a vertical tab bar,
selects it, and releasing the button copies it like a window selection
(primary selection, then copy_on_select). Clicks and double clicks on
empty space and presses on tabs behave as before.

Based on the draft in #10870, with these additions:

- Movement within drag_threshold selects nothing, so a slightly jittery
  double click on text still opens a new tab.
- A selection whose release was lost does not keep capturing the
  mouse: it is cancelled by a press outside the tab bar (which then goes
  to its normal target), by motion with no button held, by any press in
  the tab bar, and by the OS window losing focus.
- The pointer shape is reset after the press or release that starts or
  ends a selection, instead of being left as the drag shape.

Fixes #10869
Closes #10870
2026-11-15 09:32:37 +05:30

820 lines
41 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#!/usr/bin/env python
# License: GPL v3 Copyright: 2026, Kovid Goyal <kovid at kovidgoyal.net>
from functools import partial
from types import SimpleNamespace
from unittest.mock import Mock, patch
from kitty.fast_data_types import GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS, GLFW_RELEASE, LEFT_EDGE, Color, Region, Screen
from kitty.options.utils import copy_on_select, tab_title_wrap
from kitty.tab_bar import CellRange, DrawData, ExtraData, TabBar, TabBarData, TabExtent, WindowDropTarget, as_rgb, powerline_symbols, truncate_line, wrap_title
from kitty.tabs import MouseEvents, TabManager
from kitty.utils import color_as_int
from .base import BaseTest
def region(left: int, top: int, right: int, bottom: int) -> Region:
return Region((left, top, right, bottom, right - left, bottom - top))
class DummyBoss:
class mappings:
current_keyboard_mode_name = ''
def tab_for_id(self, tab_id: int) -> None:
return None
class TestTabBar(BaseTest):
def test_tab_insertion_uses_nearest_boundary(self):
tb = self.vertical_tab_bar()
for vertical in (False, True):
tb.is_vertical = vertical
tb.screen.resize(50, 100)
tb.cell_width, tb.cell_height = 10, 20
tb.tab_extents = tuple(
TabExtent(tid, CellRange(start, end), CellRange(start, end)) for tid, start, end in ((1, 2, 11), (2, 14, 23), (3, 26, 35), (-1, 38, 40))
)
cell_size = tb.cell_height if vertical else tb.cell_width
for coordinate, before in ((0, 1), (6.99, 1), (7, 2), (13, 2), (18.99, 2), (19, 3), (31, 0), (40, 0)):
pos = int(coordinate * cell_size)
x, y = (5, pos) if vertical else (pos, 5)
self.ae(tb.tab_insertion_target_at(x, y), before, (vertical, coordinate))
def test_vertical_insertion_marker_keeps_titles_visible(self):
def marked(num_tabs: int, attr: str, before: int) -> tuple[list[str], list[str]]:
tb = self.vertical_tab_bar(num_tabs)
data, extents, original = tb.last_laid_out_tabs, tb.tab_extents, self.screen_lines(tb)
with patch('kitty.tab_bar.update_tab_bar_edge_colors', return_value=None), patch('kitty.tab_bar.get_boss', return_value=DummyBoss()):
setattr(tb, attr, before)
tb.update(data)
self.ae(tb.last_laid_out_tabs, data)
self.ae(tb.tab_extents, extents)
lines = self.screen_lines(tb)
setattr(tb, attr, None)
tb.update(data)
self.ae(self.screen_lines(tb), original)
return original, lines
line = '━' * 12
for attr in ('tab_drop_insert_before', 'window_drop_insert_before'):
# The marker uses the blank line between tabs, or after the last tab
original, lines = marked(2, attr, 2)
self.ae(original[:4], ['t0', '', 't1', ''])
self.ae(lines[:4], ['t0', line, 't1', ''])
self.ae(marked(2, attr, 0)[1][:4], ['t0', '', 't1', line])
# Without a blank line before the first tab only its first cell is used
self.ae(marked(2, attr, 1)[1][:3], ['▶0', '', 't1'])
# Crowded tab bars have no blank lines between tabs
original, lines = marked(8, attr, 3)
self.ae(original[:4], ['t0', 't1', 't2', 't3'])
self.ae(lines[:4], ['t0', 't1', '▶2', 't3'])
def test_window_drop_tab_edges_and_gaps(self):
tb = self.vertical_tab_bar()
for vertical in (False, True):
with self.subTest(vertical=vertical):
tb.is_vertical = vertical
tb.screen.resize(50, 100)
tb.cell_width, tb.cell_height = 10, 20
tb.tab_extents = tuple(
TabExtent(tid, CellRange(start, end), CellRange(start, end)) for tid, start, end in ((1, 2, 11), (2, 14, 23), (-1, 26, 28))
)
cell_size = tb.cell_height if vertical else tb.cell_width
for coordinate, target in (
(0, WindowDropTarget(before_tab_id=1)),
(2.99, WindowDropTarget(before_tab_id=1)),
(3, WindowDropTarget(tab_id=1)),
(10.99, WindowDropTarget(tab_id=1)),
(11, WindowDropTarget(before_tab_id=2)),
(13, WindowDropTarget(before_tab_id=2)),
(14.99, WindowDropTarget(before_tab_id=2)),
(15, WindowDropTarget(tab_id=2)),
(23, WindowDropTarget(before_tab_id=0)),
(27, WindowDropTarget(before_tab_id=0)),
(40, WindowDropTarget(before_tab_id=0)),
):
pos = int(coordinate * cell_size)
x, y = (tb.window_geometry.left + 5, tb.window_geometry.top + pos) if vertical else (pos, 5)
self.ae(tb.window_drop_target_at(x, y), target, (vertical, coordinate))
def test_window_drop_custom_full_width_tabs(self):
tb = self.vertical_tab_bar()
tb.is_vertical = False
tb.screen.resize(1, 100)
tb.cell_width = 10
# A full-width custom renderer returns the cell after each tab, including the
# first cell of its neighbor. The synthetic '+' is entirely off screen.
tb.tab_extents = tuple(TabExtent(tid, CellRange(start, end)) for tid, start, end in ((1, 0, 50), (2, 50, 100), (-1, 100, 150)))
for x, target in (
(49, WindowDropTarget(before_tab_id=1)),
(50, WindowDropTarget(tab_id=1)),
(449, WindowDropTarget(tab_id=1)),
(450, WindowDropTarget(before_tab_id=2)),
(549, WindowDropTarget(before_tab_id=2)),
(550, WindowDropTarget(tab_id=2)),
(949, WindowDropTarget(tab_id=2)),
(950, WindowDropTarget(before_tab_id=0)),
(999, WindowDropTarget(before_tab_id=0)),
):
self.ae(tb.window_drop_target_at(x, 5), target, x)
tb.window_drop_insert_before = 0
tb.draw_drop_insert_marker()
self.ae(str(tb.screen.line(0))[-1], '┃')
def test_vertical_tab_bar_hit_testing(self) -> None:
self.set_options(
{
'tab_bar_edge': LEFT_EDGE,
'tab_bar_style': 'separator',
'tab_title_template': '{title}',
}
)
central = region(120, 0, 400, 160)
tab_bar = region(0, 0, 120, 160)
geometries: list[tuple[int, int, int, int]] = []
boss = DummyBoss()
with (
patch('kitty.tab_bar.cell_size_for_window', return_value=(10, 20)),
patch('kitty.tab_bar.viewport_for_window', return_value=(central, tab_bar, 400, 160, 10, 20)),
patch('kitty.tab_bar.set_tab_bar_render_data', side_effect=lambda *args: geometries.append(args[2:6])),
patch('kitty.tab_bar.get_boss', return_value=boss),
):
tb = TabBar(1)
tb.layout()
tb.update(
(
TabBarData(title='one', tab_id=1, is_active=True),
TabBarData(title='two', tab_id=2),
TabBarData(title='three', tab_id=3),
)
)
self.assertTrue(tb.is_vertical)
self.ae(geometries[-1], (0, 0, 120, 160))
self.ae(tb.drag_axis_coordinate(5, 35), 35)
# single line titles occupy one line each, separated by a blank line
self.ae(tuple(te.y for te in tb.tab_extents), (CellRange(0, 0), CellRange(2, 2), CellRange(4, 4)))
self.ae(tb.tab_id_at(5, 10), 1)
self.ae(tb.tab_id_at(110, 10), 1)
self.ae(tb.tab_id_at(60, 50), 2)
self.ae(tb.tab_id_at(60, 90), 3)
self.ae(tb.tab_id_at(60, 130), 0)
self.ae(tb.tab_id_at(180, 10), 0)
def test_tab_bar_selection(self) -> None:
tb = self.vertical_tab_bar(3) # 12x8 cells, tabs on rows 0, 2 and 4
self.ae(tb.cell_at(-5, -5), (0, 0, True))
self.ae(tb.cell_at(300, 300), (11, 7, False)) # past the end includes the last cell
tb.start_selection(1, 50)
tb.update_selection(25, 50)
with patch('kitty.tab_bar.get_boss', return_value=DummyBoss()):
tb.update(tb.last_laid_out_tabs) # erases the screen, the selection must be restored
self.ae(tb.finish_selection(), 't1 ') # strip_trailing_spaces is never by default
self.assertFalse(tb.screen.has_selection())
# losing focus cancels a selection, as its release may never arrive
from kitty.boss import Boss
tb.start_selection(1, 50)
tm = SimpleNamespace(tab_bar=tb, active_window=None, active_tab=None, mark_tab_bar_dirty=Mock())
Boss.on_focus(SimpleNamespace(os_window_map={1: tm}), 1, False) # type: ignore
self.assertIsNone(tb.selection)
self.assertFalse(tb.screen.has_selection())
for tab_bar_region in (region(0, 0, 120, 160), region(0, 0, 0, 0)): # the second hides the tab bar
tb.start_selection(1, 50)
with (
patch('kitty.tab_bar.viewport_for_window', return_value=(region(120, 0, 400, 160), tab_bar_region, 400, 160, 10, 20)),
patch('kitty.tab_bar.set_tab_bar_render_data'),
):
tb.layout()
self.assertIsNone(tb.selection)
self.assertFalse(tb.screen.has_selection())
def test_tab_bar_selection_mouse_handling(self) -> None:
tb = self.vertical_tab_bar(3)
s = tb.screen
s.cursor.x, s.cursor.y = 0, 7
s.draw('cpu 14%') # text drawn below the tabs, as by a custom tab bar
tm = SimpleNamespace(
tab_bar=tb,
os_window_id=1,
recent_tab_bar_mouse_events=MouseEvents(),
new_tab=Mock(),
active_tab=None,
set_active_tab=Mock(),
tab_for_id=lambda tab_id: SimpleNamespace(id=tab_id) if tab_id > 0 else None,
)
def mouse(x: float, y: float, action: int = -1) -> None:
TabManager.handle_tab_bar_mouse(tm, x, y, -1 if action == -1 else GLFW_MOUSE_BUTTON_LEFT, 0, action) # type: ignore
boss = Mock()
with (
patch('kitty.tabs.get_boss', return_value=boss),
patch('kitty.tabs.get_tab_being_dragged', return_value=(0, False, 0, 0)),
patch('kitty.tabs.set_tab_being_dragged'),
):
# dragging over the text copies it and is not a click
mouse(1, 150, GLFW_PRESS)
mouse(25, 150)
self.assertTrue(s.has_selection())
mouse(300, 150) # past the tab bar, over a window
mouse(300, 150, GLFW_RELEASE)
boss.copy_selected_text.assert_called_once_with('cpu 14%')
self.assertFalse(s.has_selection())
self.ae(len(tm.recent_tab_bar_mouse_events), 1)
# a double click on an empty area still opens a new tab and copies nothing
for action in (GLFW_PRESS, GLFW_RELEASE, GLFW_PRESS, GLFW_RELEASE):
mouse(5, 130, action)
tm.new_tab.assert_called_once()
boss.copy_selected_text.assert_called_once()
# a press on a tab starts no selection
mouse(5, 10, GLFW_PRESS)
self.assertIsNone(tb.selection)
mouse(5, 10, GLFW_RELEASE)
tm.recent_tab_bar_mouse_events.clear()
# jitter within drag_threshold during a double click selects nothing, so it opens a new tab
tm.new_tab.reset_mock()
for action in (GLFW_PRESS, GLFW_RELEASE, GLFW_PRESS):
mouse(3, 150, action)
mouse(7, 150) # into the right half of the cell, selecting it but for drag_threshold
self.assertFalse(s.has_selection())
mouse(7, 150, GLFW_RELEASE)
tm.new_tab.assert_called_once()
boss.copy_selected_text.assert_called_once()
# a press outside the tab bar, as can reach it during a tab drag, starts no selection
mouse(300, 150, GLFW_PRESS)
self.assertIsNone(tb.selection)
# a press after a lost release cancels the selection left over, copying nothing
mouse(1, 150, GLFW_PRESS)
mouse(25, 150)
self.assertTrue(s.has_selection())
mouse(5, 10, GLFW_PRESS)
self.assertIsNone(tb.selection)
self.assertFalse(s.has_selection())
boss.copy_selected_text.assert_called_once()
def test_copy_selected_text(self) -> None:
from kitty.boss import Boss
for value, clipboard_calls, buffers in (('no', 0, {}), ('clipboard', 1, {}), ('a1', 0, {'a1': 'text'})):
self.set_options({'copy_on_select': copy_on_select(value)})
boss = SimpleNamespace(handle_clipboard_loss=Mock(), clipboard_buffers={})
boss.set_clipboard_buffer = partial(Boss.set_clipboard_buffer, boss)
boss.copy_text_to_buffer = partial(Boss.copy_text_to_buffer, boss)
with patch('kitty.boss.set_primary_selection') as primary, patch('kitty.boss.set_clipboard_string') as clipboard:
Boss.copy_selected_text(boss, 'text') # type: ignore
Boss.copy_selected_text(boss, '') # type: ignore
primary.assert_called_once_with('text')
self.ae(clipboard.call_count, clipboard_calls)
self.ae(boss.clipboard_buffers, buffers)
def test_vertical_tab_bar_alignment(self) -> None:
self.set_options(
{
'tab_bar_align': 'end',
'tab_bar_edge': LEFT_EDGE,
'tab_bar_style': 'separator',
'tab_title_template': '{title}',
}
)
central = region(120, 0, 400, 160)
tab_bar = region(0, 0, 120, 160)
boss = DummyBoss()
with (
patch('kitty.tab_bar.cell_size_for_window', return_value=(10, 20)),
patch('kitty.tab_bar.viewport_for_window', return_value=(central, tab_bar, 400, 160, 10, 20)),
patch('kitty.tab_bar.set_tab_bar_render_data'),
patch('kitty.tab_bar.get_boss', return_value=boss),
):
tb = TabBar(1)
tb.layout()
tb.update(
(
TabBarData(title='one', tab_id=1, is_active=True),
TabBarData(title='two', tab_id=2),
)
)
# 8 lines available, two single line tabs plus a gap, aligned to the end
self.ae(tuple(te.y for te in tb.tab_extents), (CellRange(5, 5), CellRange(7, 7)))
self.ae(tb.tab_id_at(5, 10), 0)
self.ae(tb.tab_id_at(5, 110), 1)
self.ae(tb.tab_id_at(5, 150), 2)
def vertical_tab_bar(self, num_tabs: int = 2, height: int = 160, width: int = 120, **opts: object) -> TabBar:
self.set_options(
{
'tab_bar_edge': LEFT_EDGE,
'tab_bar_style': 'separator',
'tab_title_template': '{title}',
**opts,
}
)
central = region(width, 0, 400, height)
tab_bar = region(0, 0, width, height)
with (
patch('kitty.tab_bar.cell_size_for_window', return_value=(10, 20)),
patch('kitty.tab_bar.viewport_for_window', return_value=(central, tab_bar, 400, height, 10, 20)),
patch('kitty.tab_bar.set_tab_bar_render_data'),
patch('kitty.tab_bar.get_boss', return_value=DummyBoss()),
):
tb = TabBar(1)
tb.layout()
tb.update(tuple(TabBarData(title=f't{i}', tab_id=i + 1, is_active=i == 0) for i in range(num_tabs)))
return tb
def screen_lines(self, tb: TabBar) -> list[str]:
s = tb.screen
return [str(s.line(i)).rstrip() for i in range(s.lines)]
def test_vertical_tab_bar_narrow_powerline(self) -> None:
# A short title fits in a narrow vertical tab bar, since the separator
# is drawn in a column of its own
sep = powerline_symbols['round'][0]
tb = self.vertical_tab_bar(width=40, tab_bar_style='powerline', tab_powerline_style='round', tab_title_template='{index}', tab_title_max_length=1)
self.ae(tb.screen.columns, 4)
self.ae(self.screen_lines(tb)[:3], [f' 1 {sep}', '', f' 2 {sep}'])
def test_vertical_tab_bar_multiline_titles(self) -> None:
# newlines are ignored unless tab_title_max_lines allows them, and the
# dropped lines are marked with an ellipsis
tb = self.vertical_tab_bar(tab_title_template='{title}\\nbr')
self.ae(self.screen_lines(tb)[:4], ['t0…', '', 't1…', ''])
self.ae(tuple(te.y for te in tb.tab_extents), (CellRange(0, 0), CellRange(2, 2)))
# a newline now starts a new line at column zero, without staircasing,
# and each tab occupies the two lines its title needs
tb = self.vertical_tab_bar(tab_title_template='{title}\\nbr', tab_title_max_lines=2)
self.ae(self.screen_lines(tb)[:6], ['t0', 'br', '', 't1', 'br', ''])
self.ae(tuple(te.y for te in tb.tab_extents), (CellRange(0, 1), CellRange(3, 4)))
# lines beyond the limit are dropped rather than bleeding into the next tab
tb = self.vertical_tab_bar(tab_title_template='{title}\\nbr\\nextra', tab_title_max_lines=2)
self.ae(self.screen_lines(tb)[:6], ['t0', 'br…', '', 't1', 'br…', ''])
self.ae(tuple(te.y for te in tb.tab_extents), (CellRange(0, 1), CellRange(3, 4)))
def test_vertical_tab_bar_mixed_title_heights(self) -> None:
# a tab whose title has no newline stays one line tall even when the
# limit is higher, so tabs pack according to what they actually use
self.set_options(
{
'tab_bar_edge': LEFT_EDGE,
'tab_bar_style': 'separator',
'tab_title_template': '{title}',
'tab_title_max_lines': 3,
}
)
central = region(120, 0, 400, 160)
tab_bar = region(0, 0, 120, 160)
with (
patch('kitty.tab_bar.cell_size_for_window', return_value=(10, 20)),
patch('kitty.tab_bar.viewport_for_window', return_value=(central, tab_bar, 400, 160, 10, 20)),
patch('kitty.tab_bar.set_tab_bar_render_data'),
patch('kitty.tab_bar.get_boss', return_value=DummyBoss()),
):
tb = TabBar(1)
tb.layout()
tb.update(
(
TabBarData(title='one\ntwo', tab_id=1, is_active=True),
TabBarData(title='solo', tab_id=2),
TabBarData(title='a\nb\nc', tab_id=3),
)
)
self.ae(self.screen_lines(tb)[:8], ['one', 'two', '', 'solo', '', 'a', 'b', 'c'])
self.ae(tuple(te.y for te in tb.tab_extents), (CellRange(0, 1), CellRange(3, 3), CellRange(5, 7)))
self.ae(tb.tab_id_at(5, 10), 1)
self.ae(tb.tab_id_at(5, 30), 1)
self.ae(tb.tab_id_at(5, 70), 2)
self.ae(tb.tab_id_at(5, 110), 3)
self.ae(tb.tab_id_at(5, 150), 3)
def test_vertical_tab_bar_tab_spacing(self) -> None:
# a blank line is left between tabs while there is room for it, but not
# above the first tab. The gaps are not part of any tab's drawn extent,
# but for clicks the gap after a tab belongs to that tab.
tb = self.vertical_tab_bar(num_tabs=3)
self.ae(self.screen_lines(tb)[:6], ['t0', '', 't1', '', 't2', ''])
self.ae(tuple(te.y for te in tb.tab_extents), (CellRange(0, 0), CellRange(2, 2), CellRange(4, 4)))
self.ae(tb.tab_id_at(5, 10), 1)
self.ae(tb.tab_id_at(5, 30), 1)
self.ae(tb.tab_id_at(5, 50), 2)
self.ae(tb.tab_id_at(5, 90), 3)
self.ae(tb.tab_id_at(5, 110), 3)
self.ae(tb.tab_id_at(5, 130), 0)
# the gap uses the tab bar background, not the neighbouring tab's
self.ae(int(tb.screen.line(1).cursor_from(0).bg), 0)
# the gap above the new tab button belongs to the tab above it, while
# the line below the button is empty tab bar space
tb = self.vertical_tab_bar(num_tabs=2)
with patch('kitty.tab_bar.update_tab_bar_edge_colors', return_value=None), patch('kitty.tab_bar.get_boss', return_value=DummyBoss()):
tb.update(tuple(tb.last_laid_out_tabs) + (TabBarData(title='+'),))
self.ae(tuple(te.tab_id for te in tb.tab_extents)[:2], (1, 2))
self.ae(tb.tab_id_at(5, 70), 2)
self.assertLess(tb.tab_id_at(5, 90), 0)
self.ae(tb.tab_id_at(5, 110), 0)
# no gaps, no extra hit area
tb = self.vertical_tab_bar(num_tabs=8, height=160)
self.ae(tb.tab_id_at(5, 150), 8)
# spacing applies between multi-line tabs too
tb = self.vertical_tab_bar(num_tabs=2, tab_title_max_lines=2, tab_title_template='{title}\\nbr')
self.ae(self.screen_lines(tb)[:6], ['t0', 'br', '', 't1', 'br', ''])
self.ae(tuple(te.y for te in tb.tab_extents), (CellRange(0, 1), CellRange(3, 4)))
def test_vertical_tab_bar_tab_spacing_dropped_when_crowded(self) -> None:
# once the tabs need the space the blank lines go away automatically,
# rather than tabs being dropped in favour of keeping the gaps
tb = self.vertical_tab_bar(num_tabs=8, height=160)
self.ae(self.screen_lines(tb), [f't{i}' for i in range(8)])
self.ae(len(tb.tab_extents), 8)
# exactly enough room for spacing: 4 tabs need 4 + 3 gaps == 7 lines
tb = self.vertical_tab_bar(num_tabs=4, height=140)
self.ae(self.screen_lines(tb), ['t0', '', 't1', '', 't2', '', 't3'])
self.ae(len(tb.tab_extents), 4)
def test_vertical_tab_bar_fills_tab_width(self) -> None:
# every line a tab occupies must be padded to the full width of the bar
# in that tab's colors, otherwise uneven line lengths leave a ragged edge
tb = self.vertical_tab_bar(tab_title_template='{title}\\nlonger-line', tab_title_max_lines=2)
s = tb.screen
self.ae([len(str(s.line(i))) for i in (0, 1, 3, 4)], [s.columns] * 4)
def bg_of(line: int, col: int) -> int:
return int(s.line(line).cursor_from(col).bg)
# the padding after a short line uses the tab background, not the bar's
for line in (0, 1):
self.ae(bg_of(line, s.columns - 1), bg_of(line, 0))
# and the two tabs still have distinct backgrounds
self.assertNotEqual(bg_of(0, 0), bg_of(3, 0))
def test_vertical_tab_bar_title_taller_than_bar(self) -> None:
# a title needing more lines than the bar has must be clipped from the
# bottom rather than scrolling the tab bar and losing its first lines
tb = self.vertical_tab_bar(num_tabs=1, height=60, tab_title_template='{title}\\na\\nb\\nc\\nd', tab_title_max_lines=5)
self.ae(self.screen_lines(tb), ['t0', 'a', 'b…'])
self.ae(tuple(te.y for te in tb.tab_extents), (CellRange(0, 2),))
def test_vertical_tab_bar_multiline_overflow(self) -> None:
# only 4 lines fit, so two 2-line tabs are drawn and the rest are
# replaced by an ellipsis on the last line
tb = self.vertical_tab_bar(num_tabs=6, height=100, tab_title_template='{title}\\nbr', tab_title_max_lines=2)
self.ae(self.screen_lines(tb), ['t0', 'br', 't1', 'br', '…'])
self.ae(tuple(te.y for te in tb.tab_extents), (CellRange(0, 1), CellRange(2, 3)))
def test_wrap_title(self) -> None:
self.ae(wrap_title('hello world foo', 6).split('\n'), ['hello ', 'world ', 'foo'])
# a word longer than the width has to be broken mid-word
self.ae(wrap_title('unbreakable', 4).split('\n'), ['unbr', 'eaka', 'ble'])
# explicit newlines are preserved and each line wrapped independently
self.ae(wrap_title('a\nbb ccc', 4).split('\n'), ['a', 'bb c', 'cc'])
# SGR escapes are zero width, so they do not count towards the width and
# are never split in half
self.ae(wrap_title('\x1b[31mred text', 4).split('\n'), ['\x1b[31mred ', 'text'])
# wide characters take two cells each
self.ae(wrap_title('日本語', 4).split('\n'), ['日本', '語'])
# a width of zero means no wrapping
self.ae(wrap_title('abc', 0), 'abc')
# fast path: a part that fits entirely is taken without grapheme splitting
self.ae(wrap_title('abc def', 10).split('\n'), ['abc def'])
# fast path: part fits exactly at the boundary
self.ae(wrap_title('abcd', 4).split('\n'), ['abcd'])
# fast path breaks down correctly when the second part overflows
self.ae(wrap_title('abc defgh', 6).split('\n'), ['abc de', 'fgh'])
# SGR escape followed by text that fits entirely (fast path with leading escape)
self.ae(wrap_title('\x1b[1mhello', 10).split('\n'), ['\x1b[1mhello'])
# mixed: first part fits (fast path), second part must be split
self.ae(wrap_title('\x1b[1mab\x1b[0m cdefgh', 4).split('\n'), ['\x1b[1mab\x1b[0m c', 'defg', 'h'])
# wide chars: part fits entirely (fast path)
self.ae(wrap_title('日本', 4).split('\n'), ['日本'])
# wide chars: part fits on new line after breaking
self.ae(wrap_title('ab日本語', 4).split('\n'), ['ab日', '本語'])
def test_truncate_line(self) -> None:
self.ae(truncate_line('abcdef', 4), 'abc…')
self.ae(truncate_line('日本語', 4), '日…')
# the ellipsis marks dropped content, so it is added even when the text
# itself would have fit
self.ae(truncate_line('ab', 4), 'ab…')
self.ae(truncate_line('abcd', 4), 'abc…')
# fast path: entire part fits within width-1 cells, ellipsis appended
self.ae(truncate_line('abc', 6), 'abc…')
# fast path: part exactly fills width-1 cells
self.ae(truncate_line('abcde', 6), 'abcde…')
# fast path taken for first part, overflow detected in second part
self.ae(truncate_line('abc' + 'xyz', 5), 'abcx…')
# SGR escapes are zero width, so they never consume cells (fast path still taken)
self.ae(truncate_line('\x1b[1mabc\x1b[0m', 6), '\x1b[1mabc\x1b[0m…')
# wide chars: fast path fits, ellipsis appended
self.ae(truncate_line('日本', 6), '日本…')
# empty line still gets ellipsis
self.ae(truncate_line('', 4), '…')
def test_tab_title_wrap_option(self) -> None:
for off in ('no', 'No', 'n', 'false', 'none', '0'):
self.ae(tab_title_wrap(off), 0)
for on in ('yes', 'y', 'true', 'YES'):
self.ae(tab_title_wrap(on), -1)
self.ae(tab_title_wrap('20'), 20)
def test_vertical_tab_bar_wrapping(self) -> None:
# set_options bypasses the config parser, so these take parsed values:
# -1 is 'yes' (wrap at the width of the tab bar), a positive int a width
long_title = 'feature/some-really-long-branch'
def tb_with(**opts: object) -> list[str]:
self.set_options(
{
'tab_bar_edge': LEFT_EDGE,
'tab_bar_style': 'separator',
'tab_title_template': '{title}',
**opts,
}
)
central, tab_bar = region(140, 0, 740, 240), region(0, 0, 140, 240)
with (
patch('kitty.tab_bar.cell_size_for_window', return_value=(10, 20)),
patch('kitty.tab_bar.viewport_for_window', return_value=(central, tab_bar, 740, 240, 10, 20)),
patch('kitty.tab_bar.set_tab_bar_render_data'),
patch('kitty.tab_bar.get_boss', return_value=DummyBoss()),
):
tb = TabBar(1)
tb.layout()
tb.update((TabBarData(title=long_title, tab_id=1, is_active=True),))
return [line for line in self.screen_lines(tb) if line]
# off by default: the title is truncated onto a single line as before.
# The trailing text is the tail the separator style draws past the
# ellipsis, which predates wrapping.
self.ae(tb_with(tab_title_max_lines=3), ['feature/som… h'])
# 'yes' wraps at the width of the tab bar
self.ae(tb_with(tab_title_max_lines=3, tab_title_wrap=-1), ['feature/some-', 'really-long-b', 'ranch'])
# a number wraps at that many cells
self.ae(tb_with(tab_title_max_lines=3, tab_title_wrap=8), ['feature/', 'some-rea', 'lly-lon…'])
# wrapping needs more than one line to have any effect
self.ae(tb_with(tab_title_max_lines=1, tab_title_wrap=-1), ['feature/som… h'])
# when wrapping needs more lines than allowed, the last one is truncated
self.ae(tb_with(tab_title_max_lines=2, tab_title_wrap=-1), ['feature/some-', 'really-long…'])
# a wrap width wider than the bar is clamped to the bar, so the result
# matches wrapping at the bar's width
self.ae(tb_with(tab_title_max_lines=3, tab_title_wrap=99), ['feature/some-', 'really-long-b', 'ranch'])
def test_vertical_tab_bar_wrapping_with_newlines(self) -> None:
# an explicit newline still breaks the line, and each resulting line is
# wrapped independently
tb = self.vertical_tab_bar(num_tabs=1, height=200, tab_title_max_lines=4, tab_title_wrap=-1, tab_title_template='a-really-long-first\\nshort')
self.ae([line for line in self.screen_lines(tb) if line], ['a-really-lo', 'ng-first', 'short'])
def test_vertical_tab_bar_wrapping_overflow(self) -> None:
# wrapped tabs are packed by the lines they use, and once they stop
# fitting the remainder is replaced by the overflow ellipsis
long_title = 'feature/really-long-branch-name'
self.set_options(
{
'tab_bar_edge': LEFT_EDGE,
'tab_bar_style': 'separator',
'tab_title_template': '{title}',
'tab_title_max_lines': 2,
'tab_title_wrap': -1,
}
)
central, tab_bar = region(140, 0, 740, 100), region(0, 0, 140, 100)
with (
patch('kitty.tab_bar.cell_size_for_window', return_value=(10, 20)),
patch('kitty.tab_bar.viewport_for_window', return_value=(central, tab_bar, 740, 100, 10, 20)),
patch('kitty.tab_bar.set_tab_bar_render_data'),
patch('kitty.tab_bar.get_boss', return_value=DummyBoss()),
):
tb = TabBar(1)
tb.layout()
tb.update(tuple(TabBarData(title=long_title, tab_id=i + 1, is_active=i == 0) for i in range(3)))
self.ae(self.screen_lines(tb), ['feature/reall', 'y-long-bran…', 'feature/reall', 'y-long-bran…', '…'])
self.ae(tuple(te.y for te in tb.tab_extents), (CellRange(0, 1), CellRange(2, 3)))
def test_vertical_tab_bar_fade_style(self) -> None:
# Use fixed colors so every fade cell blends to the same midpoint
# colour, making fade cells easy to identify by background.
self.set_options(
{
'tab_bar_edge': LEFT_EDGE,
'tab_bar_style': 'fade',
'tab_title_template': '{title}',
'active_tab_background': Color(200, 0, 0),
'tab_bar_background': Color(0, 0, 100),
'tab_fade': (0.5, 0.5, 0.5, 0.5),
}
)
central = region(120, 0, 400, 160)
tab_bar_r = region(0, 0, 120, 160)
with (
patch('kitty.tab_bar.cell_size_for_window', return_value=(10, 20)),
patch('kitty.tab_bar.viewport_for_window', return_value=(central, tab_bar_r, 400, 160, 10, 20)),
patch('kitty.tab_bar.set_tab_bar_render_data'),
patch('kitty.tab_bar.get_boss', return_value=DummyBoss()),
):
tb = TabBar(1)
tb.layout()
tb.update((TabBarData(title='t0', tab_id=1, is_active=True),))
s = tb.screen
# Screen: 12 columns (120px / 10px), max_tab_length = 11, 4 fade cells.
# Title 't0' begins at col 4 (after 4 leading fades) and ends at col 6.
# Trailing fades should occupy cols 8–11 (flush with the right edge).
def bg(col: int) -> int:
return int(s.line(0).cursor_from(col).bg)
tab_bg = bg(4) # title cell: active_tab_background
fade_bg = bg(0) # leading fade cell: midpoint blend
# Sanity: fade colour is distinct from plain tab colour.
self.assertNotEqual(tab_bg, fade_bg)
# Issue 1: trailing fades flush with the right edge (cols 8–11), not right after the text.
self.ae(bg(6), tab_bg) # col 6, right after 't0', must be plain tab bg
self.ae(bg(8), fade_bg) # col 8, fade_start = 12 - 4, must be a fade cell
# Issue 2: no background-coloured separator after the trailing fades.
self.ae(bg(11), fade_bg) # col 11, last trailing fade, must not be default_bg
def test_vertical_tab_bar_powerline_style(self) -> None:
tb = self.vertical_tab_bar(
num_tabs=3,
tab_bar_style='powerline',
tab_powerline_style='slanted',
active_tab_background=Color(200, 0, 0),
inactive_tab_background=Color(0, 200, 0),
tab_bar_background=Color(0, 0, 100),
)
s = tb.screen
separator, soft_separator = powerline_symbols['slanted']
active_bg = as_rgb(color_as_int(Color(200, 0, 0)))
inactive_bg = as_rgb(color_as_int(Color(0, 200, 0)))
tab_bar_bg = as_rgb(color_as_int(Color(0, 0, 100)))
for row, tab_bg in ((0, active_bg), (2, inactive_bg), (4, inactive_bg)):
line = s.line(row)
text = str(line)
self.assertNotIn(soft_separator, text)
self.ae(text.index(separator), s.columns - 1)
self.ae(int(line.cursor_from(3).bg), tab_bg)
sep = line.cursor_from(s.columns - 1)
self.ae((int(sep.fg), int(sep.bg)), (tab_bg, tab_bar_bg))
tb = self.vertical_tab_bar(num_tabs=1, tab_bar_style='powerline', tab_powerline_style='slanted', tab_title_template='{title}-a-long-title')
self.ae(str(tb.screen.line(0)), f' t0-a-lon… {separator}')
tb = self.vertical_tab_bar(num_tabs=1, tab_bar_style='powerline', tab_powerline_style='slanted', tab_title_template='abcdef', tab_title_max_length=3)
self.ae(str(tb.screen.line(0)), f' ab… {separator}')
tb = self.vertical_tab_bar(
num_tabs=1, tab_bar_style='powerline', tab_title_template='{fmt.fg.red}{title}{fmt.reset}', active_tab_background=Color(200, 0, 0)
)
line = tb.screen.line(0)
self.ae({int(line.cursor_from(x).bg) for x in range(tb.screen.columns - 1)}, {active_bg})
def test_vertical_tab_bar_powerline_wrapped_titles(self) -> None:
separator = powerline_symbols['slanted'][0]
active_bg = as_rgb(color_as_int(Color(200, 0, 0)))
tab_bar_bg = as_rgb(color_as_int(Color(0, 0, 100)))
def lines(**opts: object) -> list[str]:
tb = self.vertical_tab_bar(
num_tabs=1,
height=200,
tab_bar_style='powerline',
tab_powerline_style='slanted',
active_tab_background=Color(200, 0, 0),
tab_bar_background=Color(0, 0, 100),
**opts,
)
s = tb.screen
ans = [str(s.line(i)) for i in range(s.lines)]
# Every row of the tab has the separator in the last column, blending
# into the tab bar background, with the tab background before it
for y, text in enumerate(ans):
if text:
sep = s.line(y).cursor_from(s.columns - 1)
self.ae((int(sep.fg), int(sep.bg)), (active_bg, tab_bar_bg))
self.ae({int(s.line(y).cursor_from(x).bg) for x in range(s.columns - 1)}, {active_bg})
return [x for x in ans if x]
# wrapped text stays clear of the last column
self.ae(
lines(tab_title_max_lines=3, tab_title_wrap=-1, tab_title_template='{title} abcdefgh ijklmnopq rs'),
[f' t0 abcdefg{separator}', f'h ijklmnop {separator}', f'q rs {separator}'],
)
# the last kept line is truncated with an ellipsis
self.ae(
lines(tab_title_max_lines=2, tab_title_wrap=-1, tab_title_template='{title} abcdefgh ijklmnopq rs'),
[f' t0 abcdefg{separator}', f'h ijklmno… {separator}'],
)
# an explicit wrap width narrower than the tab
self.ae(
lines(tab_title_max_lines=3, tab_title_wrap=4, tab_title_template='{title} abcdefgh'),
[f' t0 a {separator}', f'bcde {separator}', f'fgh {separator}'],
)
# with wrapping disabled, over long lines are clipped by the separator
self.ae(
lines(tab_title_max_lines=3, tab_title_wrap=0, tab_title_template='{title}\\nabcdefghijklmnop\\nx'),
[f' t0 {separator}', f'abcdefghijk{separator}', f'x {separator}'],
)
def horizontal_tab_bar_line(self, titles: list[str], columns: int, **opts: object) -> str:
self.set_options({'tab_title_template': '{title}', **opts})
central = region(0, 0, columns * 10, 180)
tab_bar = region(0, 180, columns * 10, 200)
with (
patch('kitty.tab_bar.cell_size_for_window', return_value=(10, 20)),
patch('kitty.tab_bar.viewport_for_window', return_value=(central, tab_bar, columns * 10, 200, 10, 20)),
patch('kitty.tab_bar.set_tab_bar_render_data'),
patch('kitty.tab_bar.update_tab_bar_edge_colors', return_value=None),
patch('kitty.tab_bar.get_boss', return_value=DummyBoss()),
):
tb = TabBar(1)
tb.layout()
tb.update(tuple(TabBarData(title=t, tab_id=i + 1, is_active=i == 0) for i, t in enumerate(titles)))
return str(tb.screen.line(0)).rstrip()
def test_horizontal_tab_bar_uses_free_space(self) -> None:
line = self.horizontal_tab_bar_line
# space not needed by short tabs goes to the long ones, instead of
# being left unused at the end of the tab bar
long_title = 'abcdefghijklmn'
for style, columns, titles in (
('fade', 25, ['1', long_title]),
('fade', 35, ['1'] * 2 + [long_title]),
('separator', 60, ['1'] * 8 + [long_title] * 2),
('powerline', 80, ['1'] * 5 + [long_title] * 3),
('slant', 126, ['1'] * 9 + [long_title] * 4),
):
text = line(titles, columns, tab_bar_style=style)
self.ae(text.count(long_title), titles.count(long_title), (style, text))
self.assertNotIn('…', text)
# tabs drawn more than one cell wider than their max length, by a wide
# separator or the leading space of the powerline style, must still
# fit, rather than the last one being replaced by the overflow marker
for columns, titles, opts in (
(10, ['x' * 10] * 3, {'tab_bar_style': 'separator', 'tab_separator': ' ||'}),
(15, ['x' * 10, '~'], {'tab_bar_style': 'powerline'}),
):
text = line(titles, columns, **opts)
self.assertFalse(text.endswith(' …'), (opts, text))
# no tabs
self.ae(line([], 60, tab_bar_style='separator'), '')
def test_horizontal_tab_bar_custom_draw_func_margin(self) -> None:
# a custom draw function may draw a wider overhang when given more
# space than the default max length it is measured at, so it is left
# some slack, rather than the last tab being replaced by the overflow marker
def draw_tab(
draw_data: DrawData, screen: Screen, tab: TabBarData, before: int, max_tab_length: int, index: int, is_last: bool, extra_data: ExtraData
) -> int:
screen.draw(tab.title[:max_tab_length])
if len(tab.title) > max_tab_length and max_tab_length >= 8:
screen.draw('»')
end: int = screen.cursor.x
if not is_last:
screen.draw('|')
return end
with patch('kitty.tab_bar.load_custom_draw_tab', return_value=draw_tab):
for columns in (15, 16, 17):
text = self.horizontal_tab_bar_line(['x' * 30] * 2, columns, tab_bar_style='custom')
self.assertFalse(text.endswith(' …'), (columns, text))
self.ae(text.count('|'), 1, text)
def test_tab_bar_title_cache(self) -> None:
from contextlib import nullcontext
import kitty.tab_bar as tab_bar
titles = ['~', 'abcdefghijklmnopqrstuvwx'] * 4
evaluate = tab_bar.evaluate_title_template
for style in ('fade', 'separator', 'powerline', 'slant'):
# titles are evaluated just once per tab in an update, though
# laying out the tab bar draws them several times
with patch('kitty.tab_bar.evaluate_title_template', wraps=evaluate) as ev:
cached = self.horizontal_tab_bar_line(titles, 60, tab_bar_style=style)
self.ae(ev.call_count, len(titles), style)
self.assertIsNone(tab_bar.title_cache)
with patch('kitty.tab_bar.caching_titles', nullcontext):
self.ae(self.horizontal_tab_bar_line(titles, 60, tab_bar_style=style), cached, style)
# unless the title depends on the space available for it
for template in ('{title[:max_title_length // 2]}', '{custom}'):
with patch('kitty.tab_bar.evaluate_title_template', wraps=evaluate) as ev:
cached = self.horizontal_tab_bar_line(titles, 60, tab_bar_style='separator', tab_title_template=template)
with patch('kitty.tab_bar.caching_titles', nullcontext):
self.ae(self.horizontal_tab_bar_line(titles, 60, tab_bar_style='separator', tab_title_template=template), cached, template)
self.assertGreater(ev.call_count, len(titles), template)