#!/usr/bin/env python # License: GPL v3 Copyright: 2026, Kovid Goyal 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)