mirror of
https://github.com/kovidgoyal/kitty.git
synced 2026-11-16 13:08:25 +00:00
The formatting of cells (colors and SGR attributes) is now interned per screen in a StyleTable and cells store a 17 bit index into it in the previously unused bits of CPUCell. Render data (sprite and mark) is kept in a separate RenderCell array for screen lines and in a small render cache for history lines being displayed, so the scrollback stores only CPUCells, 12 bytes per cell instead of 32. GPUCell is now only the upload format, built from the CPUCell, its style and its RenderCell. When the table fills up, it is compacted at the start of drawing text, reducing the color precision of cells in the scrollback if needed, cells on screen always keep their exact styles. The map from styles to indices is a verstable set of indices with a small cache of recent styles in front of it. benchmark.py throughput: ascii +48%, unicode +29%, csi +10%, truecolor text -22%, truecolor half blocks -9%.
622 lines
21 KiB
Python
622 lines
21 KiB
Python
#!/usr/bin/env python
|
|
# License: GPL v3 Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
|
|
|
|
import fcntl
|
|
import io
|
|
import os
|
|
import select
|
|
import shlex
|
|
import shutil
|
|
import signal
|
|
import struct
|
|
import sys
|
|
import termios
|
|
import time
|
|
from contextlib import contextmanager, suppress
|
|
from functools import wraps
|
|
from unittest import TestCase
|
|
|
|
from kitty.config import finalize_keys, finalize_mouse_mappings
|
|
from kitty.fast_data_types import TEXT_SIZE_CODE, Cursor, HistoryBuf, LineBuf, Screen, get_options, monotonic, set_options
|
|
from kitty.options.parse import merge_result_dicts
|
|
from kitty.options.types import Options, defaults
|
|
from kitty.options.utils import mouse_wheel_buttons
|
|
from kitty.rgb import to_color
|
|
from kitty.types import MouseEvent
|
|
from kitty.window import da1, decode_cmdline, process_remote_print, process_title_from_child
|
|
|
|
from . import is_ci
|
|
|
|
|
|
def parse_bytes(screen, data, dump_callback=None):
|
|
data = memoryview(data)
|
|
while data:
|
|
dest = screen.test_create_write_buffer()
|
|
s = screen.test_commit_write_buffer(data, dest)
|
|
data = data[s:]
|
|
screen.test_parse_written_data(dump_callback)
|
|
|
|
|
|
def draw_multicell(
|
|
screen: Screen, text: str, width: int = 0, scale: int = 1, subscale_n: int = 0, subscale_d: int = 0, vertical_align: int = 0, horizontal_align: int = 0
|
|
) -> None:
|
|
cmd = f'\x1b]{TEXT_SIZE_CODE};w={width}:s={scale}:n={subscale_n}:d={subscale_d}:v={vertical_align}:h={horizontal_align};{text}\a'
|
|
parse_bytes(screen, cmd.encode())
|
|
|
|
|
|
class Callbacks:
|
|
def __init__(self, pty=None) -> None:
|
|
self.clear()
|
|
self.pty = pty
|
|
self.ftc = None
|
|
self.set_pointer_shape = lambda data: None
|
|
self.last_cmd_at = 0
|
|
self.last_cmd_cmdline = ''
|
|
self.last_cmd_exit_status = sys.maxsize
|
|
|
|
def write(self, data) -> None:
|
|
self.wtcbuf += bytes(data)
|
|
|
|
def notify_child_of_resize(self):
|
|
self.num_of_resize_events += 1
|
|
|
|
def on_reset(self, is_hard_reset: bool = True) -> None:
|
|
if self.pty is not None:
|
|
self.pty.reset_termios_state()
|
|
|
|
def color_control(self, code, data) -> None:
|
|
from kitty.fast_data_types import base64_decode
|
|
from kitty.window import color_control
|
|
|
|
response = color_control(self.color_profile, code, data)
|
|
if response:
|
|
|
|
def p(x):
|
|
if '@' in x:
|
|
return (to_color(x.partition('@')[0]), int(255 * float(x.partition('@')[2])))
|
|
ans = to_color(x)
|
|
if ans is None:
|
|
ans = x
|
|
return ans
|
|
|
|
parts = {}
|
|
for x in response.split(';')[1:]:
|
|
k, _, v = x.partition('=')
|
|
if k == 'unknown':
|
|
# unknown field names are base64 encoded, collect the decoded names in a list
|
|
parts.setdefault('unknown', []).append(base64_decode(v).decode('ascii'))
|
|
else:
|
|
parts[k] = p(v)
|
|
self.color_control_responses.append(parts)
|
|
|
|
def title_changed(self, data, is_base64=False) -> None:
|
|
self.titlebuf.append(process_title_from_child(data, is_base64, ''))
|
|
|
|
def on_cwd_change(self, raw_url) -> None:
|
|
self.cwd_changes.append(raw_url)
|
|
|
|
def osc_context(self, data):
|
|
pass
|
|
|
|
def program_status_report(self, data):
|
|
self.program_status_reports.append(str(data, 'utf-8'))
|
|
|
|
def icon_changed(self, data) -> None:
|
|
self.iconbuf += str(data, 'utf-8')
|
|
|
|
def set_dynamic_color(self, code, data='') -> None:
|
|
if code == 22:
|
|
self.set_pointer_shape(data)
|
|
else:
|
|
self.colorbuf += str(data or b'', 'utf-8')
|
|
|
|
def set_color_table_color(self, code, data='') -> None:
|
|
self.ctbuf += ''
|
|
|
|
def color_profile_popped(self, x) -> None:
|
|
pass
|
|
|
|
def cmd_output_marking(self, is_start: bool | None, data: str = '') -> None:
|
|
if is_start:
|
|
self.last_cmd_at = monotonic()
|
|
self.last_cmd_cmdline = decode_cmdline(data) if data else data
|
|
else:
|
|
if self.last_cmd_at != 0:
|
|
self.last_cmd_at = 0
|
|
with suppress(Exception):
|
|
self.last_cmd_exit_status = int(data)
|
|
|
|
def request_capabilities(self, q) -> None:
|
|
from kitty.terminfo import get_capabilities
|
|
|
|
for c in get_capabilities(q, None):
|
|
self.write(c.encode('ascii'))
|
|
|
|
def desktop_notify(self, osc_code: int, raw_data: memoryview) -> None:
|
|
self.notifications.append((osc_code, str(raw_data, 'utf-8')))
|
|
|
|
def open_url(self, url: str, hyperlink_id: int) -> None:
|
|
self.open_urls.append((url, hyperlink_id))
|
|
|
|
def clipboard_control(self, data: memoryview, is_partial: bool = False) -> None:
|
|
self.cc_buf.append((str(data, 'utf-8'), is_partial))
|
|
|
|
def clear(self) -> None:
|
|
self.wtcbuf = b''
|
|
self.iconbuf = self.colorbuf = self.ctbuf = ''
|
|
self.titlebuf = []
|
|
self.cwd_changes = []
|
|
self.printbuf = []
|
|
self.color_control_responses = []
|
|
self.notifications = []
|
|
self.program_status_reports = []
|
|
self.open_urls = []
|
|
self.cc_buf = []
|
|
self.bell_count = 0
|
|
self.clone_cmds = []
|
|
self.current_clone_data = ''
|
|
self.last_cmd_exit_status = sys.maxsize
|
|
self.last_cmd_cmdline = ''
|
|
self.last_cmd_at = 0
|
|
self.num_of_resize_events = 0
|
|
self.da1 = []
|
|
|
|
def on_bell(self) -> None:
|
|
self.bell_count += 1
|
|
|
|
def on_da1(self) -> None:
|
|
opts = None
|
|
with suppress(RuntimeError):
|
|
opts = get_options()
|
|
if opts is None:
|
|
opts = defaults
|
|
payload = da1(opts)
|
|
self.da1.append(payload)
|
|
if self.pty and self.pty.needs_da1:
|
|
self.pty.send_da1_response(payload)
|
|
|
|
def on_activity_since_last_focus(self) -> None:
|
|
pass
|
|
|
|
def finish_scroll_animation(self) -> None:
|
|
pass
|
|
|
|
def on_mouse_event(self, event):
|
|
steps = 1
|
|
if event['button'] in mouse_wheel_buttons: # repeat_count is the number of wheel steps
|
|
steps, event['repeat_count'] = event['repeat_count'], 1
|
|
ev = MouseEvent(**event)
|
|
opts = get_options()
|
|
action_def = opts.mousemap.get(ev)
|
|
if not action_def:
|
|
return False
|
|
self.current_mouse_button = ev.button
|
|
for _ in range(steps):
|
|
for action in opts.alias_map.resolve_aliases(action_def, 'mouse_map'):
|
|
getattr(self, action.func)(*action.args)
|
|
self.current_mouse_button = 0
|
|
return True
|
|
|
|
def handle_remote_print(self, msg):
|
|
text = process_remote_print(msg)
|
|
self.printbuf.append(text)
|
|
|
|
def handle_remote_cmd(self, msg):
|
|
pass
|
|
|
|
def handle_remote_clone(self, msg):
|
|
msg = str(msg, 'utf-8')
|
|
if not msg:
|
|
if self.current_clone_data:
|
|
cdata, self.current_clone_data = self.current_clone_data, ''
|
|
from kitty.launch import CloneCmd
|
|
|
|
self.clone_cmds.append(CloneCmd(cdata))
|
|
self.current_clone_data = ''
|
|
return
|
|
num, rest = msg.split(':', 1)
|
|
if num == '0' or len(self.current_clone_data) > 1024 * 1024:
|
|
self.current_clone_data = ''
|
|
self.current_clone_data += rest
|
|
|
|
def handle_remote_ssh(self, msg):
|
|
from kittens.ssh.utils import get_ssh_data
|
|
|
|
if self.pty:
|
|
for line in get_ssh_data(msg, 'testing'):
|
|
self.pty.write_to_child(line)
|
|
|
|
def handle_remote_echo(self, msg):
|
|
from base64 import standard_b64decode
|
|
|
|
if self.pty:
|
|
data = standard_b64decode(msg)
|
|
self.pty.write_to_child(data)
|
|
|
|
def file_transmission(self, data):
|
|
if self.ftc:
|
|
self.ftc.handle_serialized_command(data)
|
|
|
|
|
|
def filled_line_buf(ynum=5, xnum=5, cursor=Cursor()):
|
|
ans = LineBuf(ynum, xnum)
|
|
cursor.x = 0
|
|
for i in range(ynum):
|
|
t = (f'{i}') * xnum
|
|
ans.line(i).set_text(t, 0, xnum, cursor)
|
|
return ans
|
|
|
|
|
|
def filled_cursor():
|
|
ans = Cursor()
|
|
ans.bold = ans.italic = ans.reverse = ans.strikethrough = ans.dim = True
|
|
ans.fg = 0x101
|
|
ans.bg = 0x201
|
|
ans.decoration_fg = 0x301
|
|
return ans
|
|
|
|
|
|
def filled_history_buf(ynum=5, xnum=5, cursor=Cursor()):
|
|
lb = filled_line_buf(ynum, xnum, cursor)
|
|
ans = HistoryBuf(ynum, xnum)
|
|
for i in range(ynum):
|
|
ans.push(lb.line(i))
|
|
return ans
|
|
|
|
|
|
max_attempts = 4 if is_ci else 2
|
|
sleep_duration = 4 if is_ci else 2
|
|
|
|
|
|
def retry_on_failure(max_attempts=max_attempts, sleep_duration=sleep_duration):
|
|
def decorator(func):
|
|
@wraps(func)
|
|
def wrapper(*args, **kwargs):
|
|
for attempt in range(max_attempts):
|
|
try:
|
|
return func(*args, **kwargs)
|
|
except Exception:
|
|
if attempt < max_attempts - 1: # Don't sleep on the last attempt
|
|
time.sleep(sleep_duration)
|
|
print(f'{func.__name__} failed, retrying in {sleep_duration} seconds', file=sys.stderr)
|
|
else:
|
|
raise # Re-raise the last exception
|
|
|
|
return wrapper
|
|
|
|
return decorator
|
|
|
|
|
|
class BaseTest(TestCase):
|
|
ae = TestCase.assertEqual
|
|
maxDiff = 2048
|
|
is_ci = is_ci
|
|
|
|
def rmtree_ignoring_errors(self, tdir):
|
|
try:
|
|
shutil.rmtree(tdir)
|
|
except FileNotFoundError as err:
|
|
print('Failed to delete the directory:', tdir, 'with error:', err, file=sys.stderr)
|
|
|
|
def tearDown(self):
|
|
# Check that every cell of every screen created by the test has a
|
|
# valid index into the style table of the screen
|
|
screens, self._screens_to_verify_styles = getattr(self, '_screens_to_verify_styles', []), []
|
|
for s in screens:
|
|
mismatches = s.test_verify_styles()
|
|
if mismatches:
|
|
self.fail(f'Cell style mismatches: {mismatches}')
|
|
set_options(None)
|
|
|
|
def set_options(self, options=None):
|
|
final_options = {'scrollback_pager_history_size': 1024, 'click_interval': 0.5}
|
|
if options:
|
|
final_options.update(options)
|
|
options = Options(merge_result_dicts(defaults._asdict(), final_options))
|
|
finalize_keys(options, {})
|
|
finalize_mouse_mappings(options, {})
|
|
set_options(options)
|
|
return options
|
|
|
|
def cmd_to_run_python_code(self, code):
|
|
from kitty.constants import kitty_exe
|
|
|
|
return [kitty_exe(), '+runpy', code]
|
|
|
|
def create_screen(self, cols=5, lines=5, scrollback=5, cell_width=10, cell_height=20, options=None):
|
|
self.set_options(options)
|
|
c = Callbacks()
|
|
s = Screen(c, lines, cols, scrollback, cell_width, cell_height, 0, c)
|
|
c.color_profile = s.color_profile
|
|
if not hasattr(self, '_screens_to_verify_styles'):
|
|
self._screens_to_verify_styles = []
|
|
self._screens_to_verify_styles.append(s)
|
|
return s
|
|
|
|
def create_pty(
|
|
self,
|
|
argv=None,
|
|
cols=80,
|
|
lines=100,
|
|
scrollback=100,
|
|
cell_width=10,
|
|
cell_height=20,
|
|
options=None,
|
|
cwd=None,
|
|
env=None,
|
|
stdin_fd=None,
|
|
needs_da1=False,
|
|
):
|
|
self.set_options(options)
|
|
return PTY(
|
|
argv,
|
|
lines,
|
|
cols,
|
|
scrollback,
|
|
cell_width,
|
|
cell_height,
|
|
cwd,
|
|
env,
|
|
stdin_fd=stdin_fd,
|
|
needs_da1=needs_da1,
|
|
)
|
|
|
|
def assertEqualAttributes(self, c1, c2):
|
|
x1, y1, c1.x, c1.y = c1.x, c1.y, 0, 0
|
|
x2, y2, c2.x, c2.y = c2.x, c2.y, 0, 0
|
|
try:
|
|
self.assertEqual(c1, c2)
|
|
finally:
|
|
c1.x, c1.y, c2.x, c2.y = x1, y1, x2, y2
|
|
|
|
|
|
debug_stdout = debug_stderr = -1
|
|
|
|
|
|
@contextmanager
|
|
def forwardable_stdio():
|
|
global debug_stderr, debug_stdout
|
|
debug_stdout = fd = os.dup(sys.stdout.fileno())
|
|
os.set_inheritable(fd, True)
|
|
debug_stderr = fd = os.dup(sys.stderr.fileno())
|
|
os.set_inheritable(fd, True)
|
|
try:
|
|
yield
|
|
finally:
|
|
os.close(debug_stderr)
|
|
os.close(debug_stdout)
|
|
debug_stderr = debug_stdout = -1
|
|
|
|
|
|
class PTY:
|
|
def __init__(
|
|
self,
|
|
argv=None,
|
|
rows=25,
|
|
columns=80,
|
|
scrollback=100,
|
|
cell_width=10,
|
|
cell_height=20,
|
|
cwd=None,
|
|
env=None,
|
|
stdin_fd=None,
|
|
needs_da1=True,
|
|
window_id=0,
|
|
log_data_flow=False,
|
|
):
|
|
self.log_data_flow = log_data_flow
|
|
if isinstance(argv, str):
|
|
argv = shlex.split(argv)
|
|
self.write_buf = b''
|
|
self.child_pid = 0
|
|
self.child_waited_for = False
|
|
self.cell_width = cell_width
|
|
self.cell_height = cell_height
|
|
if argv is None:
|
|
from kitty.child import openpty
|
|
|
|
self.master_fd, self.slave_fd = openpty()
|
|
self.initial_termios_state = termios.tcgetattr(self.master_fd)
|
|
else:
|
|
self.child_pid, self.master_fd = self.spawn_child(argv, rows, columns, cwd, env, stdin_fd)
|
|
if stdin_fd is not None:
|
|
os.close(stdin_fd)
|
|
os.set_blocking(self.master_fd, False)
|
|
self.set_window_size(rows=rows, columns=columns)
|
|
self.needs_da1 = needs_da1
|
|
self.callbacks = Callbacks(self)
|
|
self.screen = Screen(self.callbacks, rows, columns, scrollback, cell_width, cell_height, window_id, self.callbacks)
|
|
self.received_bytes = b''
|
|
|
|
def spawn_child(self, argv, rows, columns, cwd, env, stdin_fd):
|
|
# Do not use pty.fork() as that runs Python code in the forked child
|
|
# before exec(), and macOS (since Tahoe 26.2) sometimes kills processes
|
|
# that do anything non-trivial between fork() and exec() with SIGKILL.
|
|
# spawn() does all the child setup in C using only async-signal-safe
|
|
# functions. The window size is set before spawning so that the child
|
|
# sees the correct size from the start.
|
|
from kitty.child import openpty
|
|
from kitty.constants import kitten_exe
|
|
from kitty.fast_data_types import spawn
|
|
|
|
master, slave = openpty()
|
|
try:
|
|
s = struct.pack('HHHH', rows, columns, columns * self.cell_width, rows * self.cell_height)
|
|
fcntl.ioctl(master, termios.TIOCSWINSZ, s)
|
|
env = dict(os.environ if env is None else env)
|
|
pass_fds: tuple[int, ...] = ()
|
|
if debug_stdout > -1:
|
|
env['KITTY_STDIO_FORWARDED'] = str(debug_stdout)
|
|
pass_fds = (debug_stdout, debug_stderr)
|
|
ready_read_fd, ready_write_fd = os.pipe()
|
|
try:
|
|
pid = spawn(
|
|
argv[0],
|
|
cwd or os.getcwd(),
|
|
tuple(argv),
|
|
tuple(f'{k}={v}' for k, v in env.items()),
|
|
master,
|
|
slave,
|
|
-1 if stdin_fd is None else stdin_fd,
|
|
-1,
|
|
ready_read_fd,
|
|
ready_write_fd,
|
|
(),
|
|
kitten_exe(),
|
|
False,
|
|
pass_fds,
|
|
)
|
|
finally:
|
|
os.close(ready_read_fd)
|
|
# Closing the write end tells the child it can exec
|
|
os.close(ready_write_fd)
|
|
except BaseException:
|
|
os.close(master)
|
|
raise
|
|
finally:
|
|
os.close(slave)
|
|
return pid, master
|
|
|
|
def reset_termios_state(self):
|
|
if s := getattr(self, 'initial_termios_state', None):
|
|
termios.tcsetattr(self.master_fd, termios.TCSANOW, s)
|
|
|
|
def turn_off_echo(self):
|
|
s = termios.tcgetattr(self.master_fd)
|
|
s[3] &= ~termios.ECHO
|
|
termios.tcsetattr(self.master_fd, termios.TCSANOW, s)
|
|
|
|
def is_echo_on(self):
|
|
s = termios.tcgetattr(self.master_fd)
|
|
return True if s[3] & termios.ECHO else False
|
|
|
|
def __enter__(self):
|
|
return self
|
|
|
|
def __exit__(self, *a):
|
|
self.__del__()
|
|
|
|
def __del__(self):
|
|
if hasattr(self, 'master_fd'):
|
|
os.close(self.master_fd)
|
|
del self.master_fd
|
|
if hasattr(self, 'slave_fd'):
|
|
os.close(self.slave_fd)
|
|
del self.slave_fd
|
|
if getattr(self, 'child_pid', 0) > 0 and not self.child_waited_for:
|
|
st = time.monotonic()
|
|
while time.monotonic() - st < 2:
|
|
pid, ec = os.waitpid(self.child_pid, os.WNOHANG)
|
|
if pid == self.child_pid:
|
|
self.child_waited_for = True
|
|
break
|
|
time.sleep(0.1)
|
|
if not self.child_waited_for:
|
|
os.kill(self.child_pid, signal.SIGKILL)
|
|
os.waitpid(self.child_pid, 0)
|
|
self.child_waited_for = True
|
|
|
|
def write_to_child(self, data, flush=False):
|
|
if isinstance(data, str):
|
|
data = data.encode('utf-8')
|
|
if self.log_data_flow:
|
|
print('t -> c:', bytes(data))
|
|
self.write_buf += data
|
|
if flush:
|
|
self.process_input_from_child(0)
|
|
|
|
def send_da1_response(self, data: str) -> None:
|
|
self.write_to_child('\x1b[' + data, flush=False) # ]]]]]]
|
|
|
|
def send_cmd_to_child(self, cmd, flush=False):
|
|
self.callbacks.last_cmd_exit_status = sys.maxsize
|
|
self.last_cmd = cmd
|
|
self.write_to_child(cmd + '\r', flush=flush)
|
|
|
|
def process_input_from_child(self, timeout=10):
|
|
rd, wd, _ = select.select([self.master_fd], [self.master_fd] if self.write_buf else [], [], max(0, timeout))
|
|
if wd:
|
|
n = os.write(self.master_fd, self.write_buf)
|
|
self.write_buf = self.write_buf[n:]
|
|
|
|
bytes_read = 0
|
|
if rd:
|
|
data = os.read(self.master_fd, io.DEFAULT_BUFFER_SIZE)
|
|
bytes_read += len(data)
|
|
self.received_bytes += data
|
|
if self.log_data_flow:
|
|
print('c -> t:', data)
|
|
parse_bytes(self.screen, data)
|
|
return bytes_read
|
|
|
|
def wait_till(self, q, timeout=10, timeout_msg=None):
|
|
end_time = time.monotonic() + timeout
|
|
while not q() and time.monotonic() <= end_time:
|
|
try:
|
|
self.process_input_from_child(timeout=end_time - time.monotonic())
|
|
except OSError as e:
|
|
if not q():
|
|
raise Exception(f'Failed to read from pty with error: {e}. {self.screen_contents_for_error()}') from e
|
|
return
|
|
if not q():
|
|
msg = 'The condition was not met'
|
|
if timeout_msg is not None:
|
|
msg = timeout_msg()
|
|
if not msg.endswith('\n'):
|
|
msg += '. '
|
|
raise TimeoutError(f'Timed out after {timeout} seconds: {msg}{self.screen_contents_for_error()}')
|
|
|
|
def wait_till_child_exits(self, timeout=30 if BaseTest.is_ci else 10, require_exit_code=None):
|
|
end_time = time.monotonic() + timeout
|
|
while time.monotonic() <= end_time:
|
|
si_pid, status = os.waitpid(self.child_pid, os.WNOHANG)
|
|
if si_pid == self.child_pid:
|
|
# The child has been reaped, calling waitpid() on it again
|
|
# would fail with ECHILD, so handle every kind of termination
|
|
# here, not just a normal exit.
|
|
self.child_waited_for = True
|
|
with suppress(OSError):
|
|
while self.process_input_from_child(timeout=0):
|
|
pass
|
|
if os.WIFSIGNALED(status):
|
|
sig = os.WTERMSIG(status)
|
|
try:
|
|
signame = signal.Signals(sig).name
|
|
except ValueError:
|
|
signame = str(sig)
|
|
raise AssertionError(f'Child was killed by signal: {signame}. {self.screen_contents_for_error()}')
|
|
ec = os.waitstatus_to_exitcode(status)
|
|
if require_exit_code is not None and ec != require_exit_code:
|
|
raise AssertionError(f'Child exited with exit status: {status} code: {ec} != {require_exit_code}. {self.screen_contents_for_error()}')
|
|
return status
|
|
with suppress(OSError):
|
|
self.process_input_from_child(timeout=0.02)
|
|
raise AssertionError(f'Child did not exit in {timeout} seconds. {self.screen_contents_for_error()}')
|
|
|
|
def set_window_size(self, rows=25, columns=80, send_signal=True):
|
|
if hasattr(self, 'screen'):
|
|
self.screen.resize(rows, columns)
|
|
if send_signal:
|
|
x_pixels = columns * self.cell_width
|
|
y_pixels = rows * self.cell_height
|
|
s = struct.pack('HHHH', rows, columns, x_pixels, y_pixels)
|
|
fcntl.ioctl(self.master_fd, termios.TIOCSWINSZ, s)
|
|
|
|
def screen_contents_for_error(self):
|
|
from kitty.window import as_text
|
|
|
|
ans = as_text(self.screen, add_history=True, as_ansi=False)
|
|
return f'Screen contents as repr:\n{ans!r}\nScreen contents:\n{ans.rstrip()}'
|
|
|
|
def screen_contents(self):
|
|
lines = []
|
|
for i in range(self.screen.lines):
|
|
x = str(self.screen.line(i))
|
|
if x:
|
|
lines.append(x)
|
|
return '\n'.join(lines)
|
|
|
|
def last_cmd_output(self, as_ansi=False, add_wrap_markers=False):
|
|
from kitty.window import cmd_output
|
|
|
|
return cmd_output(self.screen, as_ansi=as_ansi, add_wrap_markers=add_wrap_markers)
|