def shape_string(text="abcd",
family='monospace',
size=11.0,
dpi=96.0,
path=None):
try:
sprites, cell_width, cell_height = setup_for_testing(family, size, dpi)
s = Screen(None, 1, len(text) * 2)
line = s.line(0)
s.draw(text)
return test_shape(line, path)
finally:
set_send_sprite_to_gpu(None)
def shape_string(
text: str = "abcd",
family: str = 'monospace',
size: float = 11.0,
dpi: float = 96.0,
path: Optional[str] = None
) -> List[Tuple[int, int, int, Tuple[int, ...]]]:
with setup_for_testing(family, size,
dpi) as (sprites, cell_width, cell_height):
s = Screen(None, 1, len(text) * 2)
line = s.line(0)
s.draw(text)
return test_shape(line, path)
def render_string(text: str, family: str = 'monospace', size: float = 11.0, dpi: float = 96.0) -> Tuple[int, int, List[bytes]]:
with setup_for_testing(family, size, dpi) as (sprites, cell_width, cell_height):
s = Screen(None, 1, len(text)*2)
line = s.line(0)
s.draw(text)
test_render_line(line)
cells = []
found_content = False
for i in reversed(range(s.columns)):
sp = list(line.sprite_at(i))
sp[2] &= 0xfff
tsp = sp[0], sp[1], sp[2]
if tsp == (0, 0, 0) and not found_content:
continue
found_content = True
cells.append(sprites[tsp])
return cell_width, cell_height, list(reversed(cells))
def render_string(text, family='monospace', size=11.0, dpi=96.0):
with setup_for_testing(family, size,
dpi) as (sprites, cell_width, cell_height):
s = Screen(None, 1, len(text) * 2)
line = s.line(0)
s.draw(text)
test_render_line(line)
cells = []
found_content = False
for i in reversed(range(s.columns)):
sp = list(line.sprite_at(i))
sp[2] &= 0xfff
sp = tuple(sp)
if sp == (0, 0, 0) and not found_content:
continue
found_content = True
cells.append(sprites[sp])
return cell_width, cell_height, list(reversed(cells))
class PTY:
def __init__(self,
argv,
rows=25,
columns=80,
scrollback=100,
cell_width=10,
cell_height=20,
cwd=None,
env=None):
if isinstance(argv, str):
argv = shlex.split(argv)
pid, self.master_fd = fork()
self.is_child = pid == CHILD
self.write_buf = b''
if self.is_child:
while read_screen_size().width != columns * cell_width:
time.sleep(0.01)
if cwd:
os.chdir(cwd)
os.execvpe(argv[0], argv, env or os.environ)
os.set_blocking(self.master_fd, False)
self.cell_width = cell_width
self.cell_height = cell_height
self.set_window_size(rows=rows, columns=columns)
self.callbacks = Callbacks(self)
self.screen = Screen(self.callbacks, rows, columns, scrollback,
cell_width, cell_height, 0, self.callbacks)
self.received_bytes = b''
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 __del__(self):
if not self.is_child:
fd = self.master_fd
del self.master_fd
os.close(fd)
def write_to_child(self, data):
if isinstance(data, str):
data = data.encode('utf-8')
self.write_buf += data
def send_cmd_to_child(self, cmd):
self.write_to_child(cmd + '\r')
def process_input_from_child(self, timeout=10):
rd, wd, err = select.select([self.master_fd],
[self.master_fd] if self.write_buf else [],
[self.master_fd], timeout)
if err:
raise OSError('master_fd is in error condition')
while wd:
try:
n = os.write(self.master_fd, self.write_buf)
except (BlockingIOError, OSError):
n = 0
if not n:
break
self.write_buf = self.write_buf[n:]
bytes_read = 0
while rd:
try:
data = os.read(self.master_fd, io.DEFAULT_BUFFER_SIZE)
except (BlockingIOError, OSError):
data = b''
if not data:
break
bytes_read += len(data)
self.received_bytes += data
parse_bytes(self.screen, data)
return bytes_read
def wait_till(self, q, timeout=10):
end_time = time.monotonic() + timeout
while not q() and time.monotonic() <= end_time:
self.process_input_from_child(
timeout=max(0, end_time - time.monotonic()))
if not q():
raise TimeoutError(
f'The condition was not met. Screen contents: \n {repr(self.screen_contents())}'
)
def set_window_size(self, rows=25, columns=80):
if hasattr(self, 'screen'):
self.screen.resize(rows, columns)
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(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)