mirror of
https://github.com/ghostty-org/ghostty.git
synced 2025-07-16 08:46:08 +03:00
1c0b79c40f
Default colors are those set by the user in the config file, or an actual default value if unset. The actual colors are modifiable and can be changed using the OSC 4, 10, and 11 sequences.
2249 lines
79 KiB
Zig
2249 lines
79 KiB
Zig
//! Implementation of IO that uses child exec to talk to the child process.
|
|
pub const Exec = @This();
|
|
|
|
const std = @import("std");
|
|
const builtin = @import("builtin");
|
|
const build_config = @import("../build_config.zig");
|
|
const assert = std.debug.assert;
|
|
const Allocator = std.mem.Allocator;
|
|
const ArenaAllocator = std.heap.ArenaAllocator;
|
|
const EnvMap = std.process.EnvMap;
|
|
const termio = @import("../termio.zig");
|
|
const Command = @import("../Command.zig");
|
|
const Pty = @import("../pty.zig").Pty;
|
|
const SegmentedPool = @import("../segmented_pool.zig").SegmentedPool;
|
|
const terminal = @import("../terminal/main.zig");
|
|
const terminfo = @import("../terminfo/main.zig");
|
|
const xev = @import("xev");
|
|
const renderer = @import("../renderer.zig");
|
|
const tracy = @import("tracy");
|
|
const trace = tracy.trace;
|
|
const apprt = @import("../apprt.zig");
|
|
const fastmem = @import("../fastmem.zig");
|
|
const internal_os = @import("../os/main.zig");
|
|
const windows = internal_os.windows;
|
|
const configpkg = @import("../config.zig");
|
|
const shell_integration = @import("shell_integration.zig");
|
|
|
|
const log = std.log.scoped(.io_exec);
|
|
|
|
const c = @cImport({
|
|
@cInclude("errno.h");
|
|
@cInclude("signal.h");
|
|
@cInclude("unistd.h");
|
|
});
|
|
|
|
/// True if we should disable the kitty keyboard protocol. We have to
|
|
/// disable this on GLFW because GLFW input events don't support the
|
|
/// correct granularity of events.
|
|
const disable_kitty_keyboard_protocol = apprt.runtime == apprt.glfw;
|
|
|
|
/// Allocator
|
|
alloc: Allocator,
|
|
|
|
/// This is the pty fd created for the subcommand.
|
|
subprocess: Subprocess,
|
|
|
|
/// The terminal emulator internal state. This is the abstract "terminal"
|
|
/// that manages input, grid updating, etc. and is renderer-agnostic. It
|
|
/// just stores internal state about a grid.
|
|
terminal: terminal.Terminal,
|
|
|
|
/// The shared render state
|
|
renderer_state: *renderer.State,
|
|
|
|
/// A handle to wake up the renderer. This hints to the renderer that that
|
|
/// a repaint should happen.
|
|
renderer_wakeup: xev.Async,
|
|
|
|
/// The mailbox for notifying the renderer of things.
|
|
renderer_mailbox: *renderer.Thread.Mailbox,
|
|
|
|
/// The mailbox for communicating with the surface.
|
|
surface_mailbox: apprt.surface.Mailbox,
|
|
|
|
/// The cached grid size whenever a resize is called.
|
|
grid_size: renderer.GridSize,
|
|
|
|
/// The default cursor style. We need to know this so that we can set
|
|
/// it when a CSI q with default is called.
|
|
default_cursor_style: terminal.Cursor.Style,
|
|
default_cursor_blink: ?bool,
|
|
|
|
/// Default foreground color as set by the config file
|
|
default_foreground_color: terminal.color.RGB,
|
|
|
|
/// Default background color as set by the config file
|
|
default_background_color: terminal.color.RGB,
|
|
|
|
/// Actual foreground color
|
|
foreground_color: terminal.color.RGB,
|
|
|
|
/// Actual background color
|
|
background_color: terminal.color.RGB,
|
|
|
|
/// The OSC 10/11 reply style.
|
|
osc_color_report_format: configpkg.Config.OSCColorReportFormat,
|
|
|
|
/// The data associated with the currently running thread.
|
|
data: ?*EventData,
|
|
|
|
/// The configuration for this IO that is derived from the main
|
|
/// configuration. This must be exported so that we don't need to
|
|
/// pass around Config pointers which makes memory management a pain.
|
|
pub const DerivedConfig = struct {
|
|
palette: terminal.color.Palette,
|
|
image_storage_limit: usize,
|
|
cursor_style: terminal.Cursor.Style,
|
|
cursor_blink: ?bool,
|
|
foreground: configpkg.Config.Color,
|
|
background: configpkg.Config.Color,
|
|
osc_color_report_format: configpkg.Config.OSCColorReportFormat,
|
|
term: []const u8,
|
|
|
|
pub fn init(
|
|
alloc_gpa: Allocator,
|
|
config: *const configpkg.Config,
|
|
) !DerivedConfig {
|
|
_ = alloc_gpa;
|
|
|
|
return .{
|
|
.palette = config.palette.value,
|
|
.image_storage_limit = config.@"image-storage-limit",
|
|
.cursor_style = config.@"cursor-style",
|
|
.cursor_blink = config.@"cursor-style-blink",
|
|
.foreground = config.foreground,
|
|
.background = config.background,
|
|
.osc_color_report_format = config.@"osc-color-report-format",
|
|
.term = config.term,
|
|
};
|
|
}
|
|
|
|
pub fn deinit(self: *DerivedConfig) void {
|
|
_ = self;
|
|
}
|
|
};
|
|
|
|
/// Initialize the exec implementation. This will also start the child
|
|
/// process.
|
|
pub fn init(alloc: Allocator, opts: termio.Options) !Exec {
|
|
// Clean up our derived config because we don't need it after this.
|
|
var config = opts.config;
|
|
defer config.deinit();
|
|
|
|
// Create our terminal
|
|
var term = try terminal.Terminal.init(
|
|
alloc,
|
|
opts.grid_size.columns,
|
|
opts.grid_size.rows,
|
|
);
|
|
errdefer term.deinit(alloc);
|
|
term.color_palette = opts.config.palette;
|
|
|
|
// Set the image size limits
|
|
try term.screen.kitty_images.setLimit(alloc, opts.config.image_storage_limit);
|
|
try term.secondary_screen.kitty_images.setLimit(alloc, opts.config.image_storage_limit);
|
|
|
|
// Set default cursor blink settings
|
|
term.modes.set(
|
|
.cursor_blinking,
|
|
opts.config.cursor_blink orelse true,
|
|
);
|
|
|
|
var subprocess = try Subprocess.init(alloc, opts);
|
|
errdefer subprocess.deinit();
|
|
|
|
// If we have an initial pwd requested by the subprocess, then we
|
|
// set that on the terminal now. This allows rapidly initializing
|
|
// new surfaces to use the proper pwd.
|
|
if (subprocess.cwd) |cwd| term.setPwd(cwd) catch |err| {
|
|
log.warn("error setting initial pwd err={}", .{err});
|
|
};
|
|
|
|
// Initial width/height based on subprocess
|
|
term.width_px = subprocess.screen_size.width;
|
|
term.height_px = subprocess.screen_size.height;
|
|
|
|
return Exec{
|
|
.alloc = alloc,
|
|
.terminal = term,
|
|
.subprocess = subprocess,
|
|
.renderer_state = opts.renderer_state,
|
|
.renderer_wakeup = opts.renderer_wakeup,
|
|
.renderer_mailbox = opts.renderer_mailbox,
|
|
.surface_mailbox = opts.surface_mailbox,
|
|
.grid_size = opts.grid_size,
|
|
.default_cursor_style = opts.config.cursor_style,
|
|
.default_cursor_blink = opts.config.cursor_blink,
|
|
.default_foreground_color = config.foreground.toTerminalRGB(),
|
|
.default_background_color = config.background.toTerminalRGB(),
|
|
.foreground_color = config.foreground.toTerminalRGB(),
|
|
.background_color = config.background.toTerminalRGB(),
|
|
.osc_color_report_format = config.osc_color_report_format,
|
|
.data = null,
|
|
};
|
|
}
|
|
|
|
pub fn deinit(self: *Exec) void {
|
|
self.subprocess.deinit();
|
|
|
|
// Clean up our other members
|
|
self.terminal.deinit(self.alloc);
|
|
}
|
|
|
|
pub fn threadEnter(self: *Exec, thread: *termio.Thread) !ThreadData {
|
|
assert(self.data == null);
|
|
const alloc = self.alloc;
|
|
|
|
// Start our subprocess
|
|
const pty_fds = try self.subprocess.start(alloc);
|
|
errdefer self.subprocess.stop();
|
|
const pid = pid: {
|
|
const command = self.subprocess.command orelse return error.ProcessNotStarted;
|
|
break :pid command.pid orelse return error.ProcessNoPid;
|
|
};
|
|
|
|
// Create our pipe that we'll use to kill our read thread.
|
|
// pipe[0] is the read end, pipe[1] is the write end.
|
|
const pipe = try internal_os.pipe();
|
|
errdefer std.os.close(pipe[0]);
|
|
errdefer std.os.close(pipe[1]);
|
|
|
|
// Setup our data that is used for callbacks
|
|
var ev_data_ptr = try alloc.create(EventData);
|
|
errdefer alloc.destroy(ev_data_ptr);
|
|
|
|
// Setup our stream so that we can write.
|
|
var stream = xev.Stream.initFd(pty_fds.write);
|
|
errdefer stream.deinit();
|
|
|
|
// Wakeup watcher for the writer thread.
|
|
var wakeup = try xev.Async.init();
|
|
errdefer wakeup.deinit();
|
|
|
|
// Watcher to detect subprocess exit
|
|
var process = try xev.Process.init(pid);
|
|
errdefer process.deinit();
|
|
|
|
// Setup our event data before we start
|
|
ev_data_ptr.* = .{
|
|
.writer_mailbox = thread.mailbox,
|
|
.writer_wakeup = thread.wakeup,
|
|
.surface_mailbox = self.surface_mailbox,
|
|
.renderer_state = self.renderer_state,
|
|
.renderer_wakeup = self.renderer_wakeup,
|
|
.renderer_mailbox = self.renderer_mailbox,
|
|
.process = process,
|
|
.data_stream = stream,
|
|
.loop = &thread.loop,
|
|
.terminal_stream = .{
|
|
.handler = .{
|
|
.alloc = self.alloc,
|
|
.ev = ev_data_ptr,
|
|
.terminal = &self.terminal,
|
|
.grid_size = &self.grid_size,
|
|
.default_cursor_style = self.default_cursor_style,
|
|
.default_cursor_blink = self.default_cursor_blink,
|
|
.default_foreground_color = self.default_foreground_color,
|
|
.default_background_color = self.default_background_color,
|
|
.foreground_color = self.foreground_color,
|
|
.background_color = self.background_color,
|
|
.osc_color_report_format = self.osc_color_report_format,
|
|
},
|
|
|
|
.parser = .{
|
|
.osc_parser = .{
|
|
// Populate the OSC parser allocator (optional) because
|
|
// we want to support large OSC payloads such as OSC 52.
|
|
.alloc = self.alloc,
|
|
},
|
|
},
|
|
},
|
|
};
|
|
errdefer ev_data_ptr.deinit(self.alloc);
|
|
|
|
// Store our data so our callbacks can access it
|
|
self.data = ev_data_ptr;
|
|
errdefer self.data = null;
|
|
|
|
// Start our process watcher
|
|
process.wait(
|
|
ev_data_ptr.loop,
|
|
&ev_data_ptr.process_wait_c,
|
|
EventData,
|
|
ev_data_ptr,
|
|
processExit,
|
|
);
|
|
|
|
// Start our reader thread
|
|
const read_thread = try std.Thread.spawn(
|
|
.{},
|
|
if (builtin.os.tag == .windows) ReadThread.threadMainWindows else ReadThread.threadMainPosix,
|
|
.{ pty_fds.read, ev_data_ptr, pipe[0] },
|
|
);
|
|
read_thread.setName("io-reader") catch {};
|
|
|
|
// Return our thread data
|
|
return ThreadData{
|
|
.alloc = alloc,
|
|
.ev = ev_data_ptr,
|
|
.read_thread = read_thread,
|
|
.read_thread_pipe = pipe[1],
|
|
.read_thread_fd = if (builtin.os.tag == .windows) pty_fds.read else {},
|
|
};
|
|
}
|
|
|
|
pub fn threadExit(self: *Exec, data: ThreadData) void {
|
|
// Clear out our data since we're not active anymore.
|
|
self.data = null;
|
|
|
|
// Stop our subprocess
|
|
if (data.ev.process_exited) self.subprocess.externalExit();
|
|
self.subprocess.stop();
|
|
|
|
// Quit our read thread after exiting the subprocess so that
|
|
// we don't get stuck waiting for data to stop flowing if it is
|
|
// a particularly noisy process.
|
|
_ = std.os.write(data.read_thread_pipe, "x") catch |err|
|
|
log.warn("error writing to read thread quit pipe err={}", .{err});
|
|
|
|
if (comptime builtin.os.tag == .windows) {
|
|
// Interrupt the blocking read so the thread can see the quit message
|
|
if (windows.kernel32.CancelIoEx(data.read_thread_fd, null) == 0) {
|
|
switch (windows.kernel32.GetLastError()) {
|
|
.NOT_FOUND => {},
|
|
else => |err| log.warn("error interrupting read thread err={}", .{err}),
|
|
}
|
|
}
|
|
}
|
|
|
|
data.read_thread.join();
|
|
}
|
|
|
|
/// Update the configuration.
|
|
pub fn changeConfig(self: *Exec, config: *DerivedConfig) !void {
|
|
defer config.deinit();
|
|
|
|
// Update the configuration that we know about.
|
|
//
|
|
// Specific things we don't update:
|
|
// - command, working-directory: we never restart the underlying
|
|
// process so we don't care or need to know about these.
|
|
|
|
// Update the palette. Note this will only apply to new colors drawn
|
|
// since we decode all palette colors to RGB on usage.
|
|
self.terminal.color_palette = config.palette;
|
|
|
|
// Update our default cursor style
|
|
self.default_cursor_style = config.cursor_style;
|
|
self.default_cursor_blink = config.cursor_blink;
|
|
|
|
// Update default foreground and background colors
|
|
self.default_foreground_color = config.foreground.toTerminalRGB();
|
|
self.default_background_color = config.background.toTerminalRGB();
|
|
|
|
// If we have event data, then update our active stream too
|
|
if (self.data) |data| {
|
|
data.terminal_stream.handler.changeDefaultCursor(
|
|
config.cursor_style,
|
|
config.cursor_blink,
|
|
);
|
|
}
|
|
|
|
// Set the image size limits
|
|
try self.terminal.screen.kitty_images.setLimit(
|
|
self.alloc,
|
|
config.image_storage_limit,
|
|
);
|
|
try self.terminal.secondary_screen.kitty_images.setLimit(
|
|
self.alloc,
|
|
config.image_storage_limit,
|
|
);
|
|
}
|
|
|
|
/// Resize the terminal.
|
|
pub fn resize(
|
|
self: *Exec,
|
|
grid_size: renderer.GridSize,
|
|
screen_size: renderer.ScreenSize,
|
|
padding: renderer.Padding,
|
|
) !void {
|
|
// Update the size of our pty.
|
|
const padded_size = screen_size.subPadding(padding);
|
|
try self.subprocess.resize(grid_size, padded_size);
|
|
|
|
// Update our cached grid size
|
|
self.grid_size = grid_size;
|
|
|
|
// Enter the critical area that we want to keep small
|
|
{
|
|
self.renderer_state.mutex.lock();
|
|
defer self.renderer_state.mutex.unlock();
|
|
|
|
// Update the size of our terminal state
|
|
try self.terminal.resize(
|
|
self.alloc,
|
|
grid_size.columns,
|
|
grid_size.rows,
|
|
);
|
|
|
|
// Update our pixel sizes
|
|
self.terminal.width_px = padded_size.width;
|
|
self.terminal.height_px = padded_size.height;
|
|
|
|
// Disable synchronized output mode so that we show changes
|
|
// immediately for a resize. This is allowed by the spec.
|
|
self.terminal.modes.set(.synchronized_output, false);
|
|
|
|
// Wake up our renderer so any changes will be shown asap
|
|
self.renderer_wakeup.notify() catch {};
|
|
}
|
|
}
|
|
|
|
/// Reset the synchronized output mode. This is usually called by timer
|
|
/// expiration from the termio thread.
|
|
pub fn resetSynchronizedOutput(self: *Exec) void {
|
|
self.renderer_state.mutex.lock();
|
|
defer self.renderer_state.mutex.unlock();
|
|
self.terminal.modes.set(.synchronized_output, false);
|
|
self.renderer_wakeup.notify() catch {};
|
|
}
|
|
|
|
/// Clear the screen.
|
|
pub fn clearScreen(self: *Exec, history: bool) !void {
|
|
{
|
|
self.renderer_state.mutex.lock();
|
|
defer self.renderer_state.mutex.unlock();
|
|
|
|
// If we're on the alternate screen, we do not clear. Since this is an
|
|
// emulator-level screen clear, this messes up the running programs
|
|
// knowledge of where the cursor is and causes rendering issues. So,
|
|
// for alt screen, we do nothing.
|
|
if (self.terminal.active_screen == .alternate) return;
|
|
|
|
// Clear our scrollback
|
|
if (history) try self.terminal.screen.clear(.history);
|
|
|
|
// If we're not at a prompt, we clear the screen manually using
|
|
// the terminal screen state. If we are at a prompt, we send
|
|
// form-feed so that the shell can repaint the entire screen.
|
|
if (!self.terminal.cursorIsAtPrompt()) {
|
|
// Clear above the cursor
|
|
try self.terminal.screen.clear(.above_cursor);
|
|
|
|
// Exit
|
|
return;
|
|
}
|
|
}
|
|
|
|
// If we reached here it means we're at a prompt, so we send a form-feed.
|
|
assert(self.terminal.cursorIsAtPrompt());
|
|
try self.queueWrite(&[_]u8{0x0C}, false);
|
|
}
|
|
|
|
/// Scroll the viewport
|
|
pub fn scrollViewport(self: *Exec, scroll: terminal.Terminal.ScrollViewport) !void {
|
|
self.renderer_state.mutex.lock();
|
|
defer self.renderer_state.mutex.unlock();
|
|
try self.terminal.scrollViewport(scroll);
|
|
}
|
|
|
|
/// Jump the viewport to the prompt.
|
|
pub fn jumpToPrompt(self: *Exec, delta: isize) !void {
|
|
const wakeup: bool = wakeup: {
|
|
self.renderer_state.mutex.lock();
|
|
defer self.renderer_state.mutex.unlock();
|
|
break :wakeup self.terminal.screen.jump(.{
|
|
.prompt_delta = delta,
|
|
});
|
|
};
|
|
|
|
if (wakeup) {
|
|
try self.renderer_wakeup.notify();
|
|
}
|
|
}
|
|
|
|
pub inline fn queueWrite(self: *Exec, data: []const u8, linefeed: bool) !void {
|
|
const ev = self.data.?;
|
|
|
|
// We go through and chunk the data if necessary to fit into
|
|
// our cached buffers that we can queue to the stream.
|
|
var i: usize = 0;
|
|
while (i < data.len) {
|
|
const req = try ev.write_req_pool.getGrow(self.alloc);
|
|
const buf = try ev.write_buf_pool.getGrow(self.alloc);
|
|
const slice = slice: {
|
|
// The maximum end index is either the end of our data or
|
|
// the end of our buffer, whichever is smaller.
|
|
const max = @min(data.len, i + buf.len);
|
|
|
|
// Fast
|
|
if (!linefeed) {
|
|
fastmem.copy(u8, buf, data[i..max]);
|
|
const len = max - i;
|
|
i = max;
|
|
break :slice buf[0..len];
|
|
}
|
|
|
|
// Slow, have to replace \r with \r\n
|
|
var buf_i: usize = 0;
|
|
while (i < data.len and buf_i < buf.len - 1) {
|
|
const ch = data[i];
|
|
i += 1;
|
|
|
|
if (ch != '\r') {
|
|
buf[buf_i] = ch;
|
|
buf_i += 1;
|
|
continue;
|
|
}
|
|
|
|
// CRLF
|
|
buf[buf_i] = '\r';
|
|
buf[buf_i + 1] = '\n';
|
|
buf_i += 2;
|
|
}
|
|
|
|
break :slice buf[0..buf_i];
|
|
};
|
|
|
|
//for (slice) |b| log.warn("write: {x}", .{b});
|
|
|
|
ev.data_stream.queueWrite(
|
|
ev.loop,
|
|
&ev.write_queue,
|
|
req,
|
|
.{ .slice = slice },
|
|
EventData,
|
|
ev,
|
|
ttyWrite,
|
|
);
|
|
}
|
|
}
|
|
|
|
const ThreadData = struct {
|
|
/// Allocator used for the event data
|
|
alloc: Allocator,
|
|
|
|
/// The data that is attached to the callbacks.
|
|
ev: *EventData,
|
|
|
|
/// Our read thread
|
|
read_thread: std.Thread,
|
|
read_thread_pipe: std.os.fd_t,
|
|
read_thread_fd: if (builtin.os.tag == .windows) std.os.fd_t else void,
|
|
|
|
pub fn deinit(self: *ThreadData) void {
|
|
std.os.close(self.read_thread_pipe);
|
|
self.ev.deinit(self.alloc);
|
|
self.alloc.destroy(self.ev);
|
|
self.* = undefined;
|
|
}
|
|
};
|
|
|
|
const EventData = struct {
|
|
// The preallocation size for the write request pool. This should be big
|
|
// enough to satisfy most write requests. It must be a power of 2.
|
|
const WRITE_REQ_PREALLOC = std.math.pow(usize, 2, 5);
|
|
|
|
/// Mailbox for data to the writer thread.
|
|
writer_mailbox: *termio.Mailbox,
|
|
writer_wakeup: xev.Async,
|
|
|
|
/// Mailbox for the surface.
|
|
surface_mailbox: apprt.surface.Mailbox,
|
|
|
|
/// The stream parser. This parses the stream of escape codes and so on
|
|
/// from the child process and calls callbacks in the stream handler.
|
|
terminal_stream: terminal.Stream(StreamHandler),
|
|
|
|
/// The shared render state
|
|
renderer_state: *renderer.State,
|
|
|
|
/// A handle to wake up the renderer. This hints to the renderer that that
|
|
/// a repaint should happen.
|
|
renderer_wakeup: xev.Async,
|
|
|
|
/// The mailbox for notifying the renderer of things.
|
|
renderer_mailbox: *renderer.Thread.Mailbox,
|
|
|
|
/// The process watcher
|
|
process: xev.Process,
|
|
process_exited: bool = false,
|
|
|
|
/// This is used for both waiting for the process to exit and then
|
|
/// subsequently to wait for the data_stream to close.
|
|
process_wait_c: xev.Completion = .{},
|
|
|
|
/// The data stream is the main IO for the pty.
|
|
data_stream: xev.Stream,
|
|
|
|
/// The event loop,
|
|
loop: *xev.Loop,
|
|
|
|
/// The write queue for the data stream.
|
|
write_queue: xev.Stream.WriteQueue = .{},
|
|
|
|
/// This is the pool of available (unused) write requests. If you grab
|
|
/// one from the pool, you must put it back when you're done!
|
|
write_req_pool: SegmentedPool(xev.Stream.WriteRequest, WRITE_REQ_PREALLOC) = .{},
|
|
|
|
/// The pool of available buffers for writing to the pty.
|
|
write_buf_pool: SegmentedPool([64]u8, WRITE_REQ_PREALLOC) = .{},
|
|
|
|
/// Last time the cursor was reset. This is used to prevent message
|
|
/// flooding with cursor resets.
|
|
last_cursor_reset: i64 = 0,
|
|
|
|
/// This is set to true when we've seen a title escape sequence. We use
|
|
/// this to determine if we need to default the window title.
|
|
seen_title: bool = false,
|
|
|
|
pub fn deinit(self: *EventData, alloc: Allocator) void {
|
|
// Clear our write pools. We know we aren't ever going to do
|
|
// any more IO since we stop our data stream below so we can just
|
|
// drop this.
|
|
self.write_req_pool.deinit(alloc);
|
|
self.write_buf_pool.deinit(alloc);
|
|
|
|
// Stop our data stream
|
|
self.data_stream.deinit();
|
|
|
|
// Stop our process watcher
|
|
self.process.deinit();
|
|
|
|
// Clear any StreamHandler state
|
|
self.terminal_stream.handler.deinit();
|
|
self.terminal_stream.deinit();
|
|
}
|
|
|
|
/// This queues a render operation with the renderer thread. The render
|
|
/// isn't guaranteed to happen immediately but it will happen as soon as
|
|
/// practical.
|
|
inline fn queueRender(self: *EventData) !void {
|
|
try self.renderer_wakeup.notify();
|
|
}
|
|
};
|
|
|
|
fn processExit(
|
|
ev_: ?*EventData,
|
|
_: *xev.Loop,
|
|
_: *xev.Completion,
|
|
r: xev.Process.WaitError!u32,
|
|
) xev.CallbackAction {
|
|
const code = r catch unreachable;
|
|
log.debug("child process exited status={}", .{code});
|
|
|
|
const ev = ev_.?;
|
|
ev.process_exited = true;
|
|
|
|
// Notify our surface we want to close
|
|
_ = ev.surface_mailbox.push(.{
|
|
.child_exited = {},
|
|
}, .{ .forever = {} });
|
|
|
|
return .disarm;
|
|
}
|
|
|
|
fn ttyWrite(
|
|
ev_: ?*EventData,
|
|
_: *xev.Loop,
|
|
_: *xev.Completion,
|
|
_: xev.Stream,
|
|
_: xev.WriteBuffer,
|
|
r: xev.Stream.WriteError!usize,
|
|
) xev.CallbackAction {
|
|
const ev = ev_.?;
|
|
ev.write_req_pool.put();
|
|
ev.write_buf_pool.put();
|
|
|
|
const d = r catch |err| {
|
|
log.err("write error: {}", .{err});
|
|
return .disarm;
|
|
};
|
|
_ = d;
|
|
//log.info("WROTE: {d}", .{d});
|
|
|
|
return .disarm;
|
|
}
|
|
|
|
/// Subprocess manages the lifecycle of the shell subprocess.
|
|
const Subprocess = struct {
|
|
/// If we build with flatpak support then we have to keep track of
|
|
/// a potential execution on the host.
|
|
const FlatpakHostCommand = if (build_config.flatpak) internal_os.FlatpakHostCommand else void;
|
|
|
|
arena: std.heap.ArenaAllocator,
|
|
cwd: ?[]const u8,
|
|
env: EnvMap,
|
|
path: []const u8,
|
|
args: [][]const u8,
|
|
grid_size: renderer.GridSize,
|
|
screen_size: renderer.ScreenSize,
|
|
pty: ?Pty = null,
|
|
command: ?Command = null,
|
|
flatpak_command: ?FlatpakHostCommand = null,
|
|
|
|
/// Initialize the subprocess. This will NOT start it, this only sets
|
|
/// up the internal state necessary to start it later.
|
|
pub fn init(gpa: Allocator, opts: termio.Options) !Subprocess {
|
|
// We have a lot of maybe-allocations that all share the same lifetime
|
|
// so use an arena so we don't end up in an accounting nightmare.
|
|
var arena = std.heap.ArenaAllocator.init(gpa);
|
|
errdefer arena.deinit();
|
|
const alloc = arena.allocator();
|
|
|
|
// Determine the path to the binary we're executing
|
|
const path = try Command.expandPath(
|
|
alloc,
|
|
opts.full_config.command orelse switch (builtin.os.tag) {
|
|
.windows => "cmd.exe",
|
|
else => "sh",
|
|
},
|
|
) orelse return error.CommandNotFound;
|
|
|
|
// On macOS, we launch the program as a login shell. This is a Mac-specific
|
|
// behavior (see other terminals). Terminals in general should NOT be
|
|
// spawning login shells because well... we're not "logging in." The solution
|
|
// is to put dotfiles in "rc" variants rather than "_login" variants. But,
|
|
// history!
|
|
const argv0_override: ?[]const u8 = if (comptime builtin.target.isDarwin()) argv0: {
|
|
// Get rid of the path
|
|
const argv0 = if (std.mem.lastIndexOf(u8, path, "/")) |idx|
|
|
path[idx + 1 ..]
|
|
else
|
|
path;
|
|
|
|
// Copy it with a hyphen so its a login shell
|
|
const argv0_buf = try alloc.alloc(u8, argv0.len + 1);
|
|
argv0_buf[0] = '-';
|
|
std.mem.copy(u8, argv0_buf[1..], argv0);
|
|
break :argv0 argv0_buf;
|
|
} else null;
|
|
|
|
// Set our env vars. For Flatpak builds running in Flatpak we don't
|
|
// inherit our environment because the login shell on the host side
|
|
// will get it.
|
|
var env = env: {
|
|
if (comptime build_config.flatpak) {
|
|
if (internal_os.isFlatpak()) {
|
|
break :env std.process.EnvMap.init(alloc);
|
|
}
|
|
}
|
|
|
|
break :env try std.process.getEnvMap(alloc);
|
|
};
|
|
errdefer env.deinit();
|
|
|
|
// If we have a resources dir then set our env var
|
|
const resources_key = "GHOSTTY_RESOURCES_DIR";
|
|
if (opts.resources_dir) |dir| {
|
|
log.info("found Ghostty resources dir: {s}", .{dir});
|
|
try env.put(resources_key, dir);
|
|
}
|
|
|
|
// Set our TERM var. This is a bit complicated because we want to use
|
|
// the ghostty TERM value but we want to only do that if we have
|
|
// ghostty in the TERMINFO database.
|
|
//
|
|
// For now, we just look up a bundled dir but in the future we should
|
|
// also load the terminfo database and look for it.
|
|
if (opts.resources_dir) |base| {
|
|
var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
|
|
const dir = try std.fmt.bufPrint(&buf, "{s}/terminfo", .{base});
|
|
try env.put("TERM", opts.config.term);
|
|
try env.put("COLORTERM", "truecolor");
|
|
try env.put("TERMINFO", dir);
|
|
} else {
|
|
if (comptime builtin.target.isDarwin()) {
|
|
log.warn("ghostty terminfo not found, using xterm-256color", .{});
|
|
log.warn("the terminfo SHOULD exist on macos, please ensure", .{});
|
|
log.warn("you're using a valid app bundle.", .{});
|
|
}
|
|
|
|
try env.put("TERM", "xterm-256color");
|
|
try env.put("COLORTERM", "truecolor");
|
|
}
|
|
|
|
// Set environment variables used by some programs (such as neovim) to detect
|
|
// which terminal emulator and version they're running under.
|
|
try env.put("TERM_PROGRAM", "ghostty");
|
|
try env.put("TERM_PROGRAM_VERSION", build_config.version_string);
|
|
|
|
// When embedding in macOS and running via XCode, XCode injects
|
|
// a bunch of things that break our shell process. We remove those.
|
|
if (comptime builtin.target.isDarwin() and build_config.artifact == .lib) {
|
|
if (env.get("__XCODE_BUILT_PRODUCTS_DIR_PATHS") != null) {
|
|
env.remove("__XCODE_BUILT_PRODUCTS_DIR_PATHS");
|
|
env.remove("__XPC_DYLD_LIBRARY_PATH");
|
|
env.remove("DYLD_FRAMEWORK_PATH");
|
|
env.remove("DYLD_INSERT_LIBRARIES");
|
|
env.remove("DYLD_LIBRARY_PATH");
|
|
env.remove("LD_LIBRARY_PATH");
|
|
env.remove("SECURITYSESSIONID");
|
|
env.remove("XPC_SERVICE_NAME");
|
|
}
|
|
|
|
// Remove this so that running `ghostty` within Ghostty works.
|
|
env.remove("GHOSTTY_MAC_APP");
|
|
}
|
|
|
|
// Build our args list
|
|
const args = args: {
|
|
const cap = 1 + opts.full_config.@"command-arg".list.items.len;
|
|
var args = try std.ArrayList([]const u8).initCapacity(alloc, cap);
|
|
defer args.deinit();
|
|
|
|
if (!internal_os.isFlatpak()) {
|
|
try args.append(argv0_override orelse path);
|
|
} else {
|
|
// We run our shell wrapped in a /bin/sh login shell because
|
|
// some systems do not properly initialize the env vars unless
|
|
// we start this way (NixOS!)
|
|
try args.append("/bin/sh");
|
|
try args.append("-l");
|
|
try args.append("-c");
|
|
try args.append(path);
|
|
}
|
|
|
|
try args.appendSlice(opts.full_config.@"command-arg".list.items);
|
|
break :args try args.toOwnedSlice();
|
|
};
|
|
|
|
// We have to copy the cwd because there is no guarantee that
|
|
// pointers in full_config remain valid.
|
|
var cwd: ?[]u8 = if (opts.full_config.@"working-directory") |cwd|
|
|
try alloc.dupe(u8, cwd)
|
|
else
|
|
null;
|
|
|
|
// The execution path
|
|
const final_path = if (internal_os.isFlatpak()) args[0] else path;
|
|
|
|
// Setup our shell integration, if we can.
|
|
const shell_integrated: ?shell_integration.Shell = shell: {
|
|
const force: ?shell_integration.Shell = switch (opts.full_config.@"shell-integration") {
|
|
.none => break :shell null,
|
|
.detect => null,
|
|
.fish => .fish,
|
|
.zsh => .zsh,
|
|
};
|
|
|
|
const dir = opts.resources_dir orelse break :shell null;
|
|
break :shell try shell_integration.setup(
|
|
dir,
|
|
final_path,
|
|
&env,
|
|
force,
|
|
opts.full_config.@"shell-integration-features",
|
|
);
|
|
};
|
|
if (shell_integrated) |shell| {
|
|
log.info(
|
|
"shell integration automatically injected shell={}",
|
|
.{shell},
|
|
);
|
|
} else if (opts.full_config.@"shell-integration" != .none) {
|
|
log.warn("shell could not be detected, no automatic shell integration will be injected", .{});
|
|
}
|
|
|
|
// Our screen size should be our padded size
|
|
const padded_size = opts.screen_size.subPadding(opts.padding);
|
|
|
|
return .{
|
|
.arena = arena,
|
|
.env = env,
|
|
.cwd = cwd,
|
|
.path = final_path,
|
|
.args = args,
|
|
.grid_size = opts.grid_size,
|
|
.screen_size = padded_size,
|
|
};
|
|
}
|
|
|
|
/// Clean up the subprocess. This will stop the subprocess if it is started.
|
|
pub fn deinit(self: *Subprocess) void {
|
|
self.stop();
|
|
if (self.pty) |*pty| pty.deinit();
|
|
self.arena.deinit();
|
|
self.* = undefined;
|
|
}
|
|
|
|
/// Start the subprocess. If the subprocess is already started this
|
|
/// will crash.
|
|
pub fn start(self: *Subprocess, alloc: Allocator) !struct {
|
|
read: Pty.Fd,
|
|
write: Pty.Fd,
|
|
} {
|
|
assert(self.pty == null and self.command == null);
|
|
|
|
// Create our pty
|
|
var pty = try Pty.open(.{
|
|
.ws_row = @intCast(self.grid_size.rows),
|
|
.ws_col = @intCast(self.grid_size.columns),
|
|
.ws_xpixel = @intCast(self.screen_size.width),
|
|
.ws_ypixel = @intCast(self.screen_size.height),
|
|
});
|
|
self.pty = pty;
|
|
errdefer {
|
|
pty.deinit();
|
|
self.pty = null;
|
|
}
|
|
|
|
log.debug("starting command path={s} args={s}", .{
|
|
self.path,
|
|
self.args,
|
|
});
|
|
|
|
// In flatpak, we use the HostCommand to execute our shell.
|
|
if (internal_os.isFlatpak()) flatpak: {
|
|
if (comptime !build_config.flatpak) {
|
|
log.warn("flatpak detected, but flatpak support not built-in", .{});
|
|
break :flatpak;
|
|
}
|
|
|
|
// For flatpak our path and argv[0] must match because that is
|
|
// used for execution by the dbus API.
|
|
assert(std.mem.eql(u8, self.path, self.args[0]));
|
|
|
|
// Flatpak command must have a stable pointer.
|
|
self.flatpak_command = .{
|
|
.argv = self.args,
|
|
.env = &self.env,
|
|
.stdin = pty.slave,
|
|
.stdout = pty.slave,
|
|
.stderr = pty.slave,
|
|
};
|
|
var cmd = &self.flatpak_command.?;
|
|
const pid = try cmd.spawn(alloc);
|
|
errdefer killCommandFlatpak(cmd);
|
|
|
|
log.info("started subcommand on host via flatpak API path={s} pid={?}", .{
|
|
self.path,
|
|
pid,
|
|
});
|
|
|
|
// Once started, we can close the pty child side. We do this after
|
|
// wait right now but that is fine too. This lets us read the
|
|
// parent and detect EOF.
|
|
_ = std.os.close(pty.slave);
|
|
|
|
return .{
|
|
.read = pty.master,
|
|
.write = pty.master,
|
|
};
|
|
}
|
|
|
|
// If we can't access the cwd, then don't set any cwd and inherit.
|
|
// This is important because our cwd can be set by the shell (OSC 7)
|
|
// and we don't want to break new windows.
|
|
const cwd: ?[]const u8 = if (self.cwd) |proposed| cwd: {
|
|
if (std.fs.accessAbsolute(proposed, .{})) {
|
|
break :cwd proposed;
|
|
} else |err| {
|
|
log.warn("cannot access cwd, ignoring: {}", .{err});
|
|
break :cwd null;
|
|
}
|
|
} else null;
|
|
|
|
// Build our subcommand
|
|
var cmd: Command = .{
|
|
.path = self.path,
|
|
.args = self.args,
|
|
.env = &self.env,
|
|
.cwd = cwd,
|
|
.stdin = if (builtin.os.tag == .windows) null else .{ .handle = pty.slave },
|
|
.stdout = if (builtin.os.tag == .windows) null else .{ .handle = pty.slave },
|
|
.stderr = if (builtin.os.tag == .windows) null else .{ .handle = pty.slave },
|
|
.pseudo_console = if (builtin.os.tag == .windows) pty.pseudo_console else {},
|
|
.pre_exec = if (builtin.os.tag == .windows) null else (struct {
|
|
fn callback(cmd: *Command) void {
|
|
const p = cmd.getData(Pty) orelse unreachable;
|
|
p.childPreExec() catch |err|
|
|
log.err("error initializing child: {}", .{err});
|
|
}
|
|
}).callback,
|
|
.data = &self.pty.?,
|
|
};
|
|
try cmd.start(alloc);
|
|
errdefer killCommand(&cmd) catch |err| {
|
|
log.warn("error killing command during cleanup err={}", .{err});
|
|
};
|
|
log.info("started subcommand path={s} pid={?}", .{ self.path, cmd.pid });
|
|
|
|
self.command = cmd;
|
|
return switch (builtin.os.tag) {
|
|
.windows => .{
|
|
.read = pty.out_pipe,
|
|
.write = pty.in_pipe,
|
|
},
|
|
|
|
else => .{
|
|
.read = pty.master,
|
|
.write = pty.master,
|
|
},
|
|
};
|
|
}
|
|
|
|
/// Called to notify that we exited externally so we can unset our
|
|
/// running state.
|
|
pub fn externalExit(self: *Subprocess) void {
|
|
self.command = null;
|
|
}
|
|
|
|
/// Stop the subprocess. This is safe to call anytime. This will wait
|
|
/// for the subprocess to register that it has been signalled, but not
|
|
/// for it to terminate, so it will not block.
|
|
/// This does not close the pty.
|
|
pub fn stop(self: *Subprocess) void {
|
|
// Kill our command
|
|
if (self.command) |*cmd| {
|
|
killCommand(cmd) catch |err|
|
|
log.err("error sending SIGHUP to command, may hang: {}", .{err});
|
|
_ = cmd.wait(false) catch |err|
|
|
log.err("error waiting for command to exit: {}", .{err});
|
|
self.command = null;
|
|
}
|
|
|
|
// Kill our Flatpak command
|
|
if (FlatpakHostCommand != void) {
|
|
if (self.flatpak_command) |*cmd| {
|
|
killCommandFlatpak(cmd) catch |err|
|
|
log.err("error sending SIGHUP to command, may hang: {}", .{err});
|
|
_ = cmd.wait() catch |err|
|
|
log.err("error waiting for command to exit: {}", .{err});
|
|
self.flatpak_command = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Resize the pty subprocess. This is safe to call anytime.
|
|
pub fn resize(
|
|
self: *Subprocess,
|
|
grid_size: renderer.GridSize,
|
|
screen_size: renderer.ScreenSize,
|
|
) !void {
|
|
self.grid_size = grid_size;
|
|
self.screen_size = screen_size;
|
|
|
|
if (self.pty) |*pty| {
|
|
try pty.setSize(.{
|
|
.ws_row = @intCast(grid_size.rows),
|
|
.ws_col = @intCast(grid_size.columns),
|
|
.ws_xpixel = @intCast(screen_size.width),
|
|
.ws_ypixel = @intCast(screen_size.height),
|
|
});
|
|
}
|
|
}
|
|
|
|
/// Kill the underlying subprocess. This sends a SIGHUP to the child
|
|
/// process. This doesn't wait for the child process to be exited.
|
|
fn killCommand(command: *Command) !void {
|
|
if (command.pid) |pid| {
|
|
switch (builtin.os.tag) {
|
|
.windows => {
|
|
if (windows.kernel32.TerminateProcess(pid, 0) == 0) {
|
|
return windows.unexpectedError(windows.kernel32.GetLastError());
|
|
}
|
|
},
|
|
|
|
else => {
|
|
const pgid_: ?c.pid_t = pgid: {
|
|
const pgid = c.getpgid(pid);
|
|
|
|
// Don't know why it would be zero but its not a valid pid
|
|
if (pgid == 0) break :pgid null;
|
|
|
|
// If the pid doesn't exist then... okay.
|
|
if (pgid == c.ESRCH) break :pgid null;
|
|
|
|
// If we have an error...
|
|
if (pgid < 0) {
|
|
log.warn("error getting pgid for kill", .{});
|
|
break :pgid null;
|
|
}
|
|
|
|
break :pgid pgid;
|
|
};
|
|
|
|
if (pgid_) |pgid| {
|
|
if (c.killpg(pgid, c.SIGHUP) < 0) {
|
|
log.warn("error killing process group pgid={}", .{pgid});
|
|
return error.KillFailed;
|
|
}
|
|
}
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Kill the underlying process started via Flatpak host command.
|
|
/// This sends a signal via the Flatpak API.
|
|
fn killCommandFlatpak(command: *FlatpakHostCommand) !void {
|
|
try command.signal(c.SIGHUP, true);
|
|
}
|
|
};
|
|
|
|
/// The read thread sits in a loop doing the following pseudo code:
|
|
///
|
|
/// while (true) { blocking_read(); exit_if_eof(); process(); }
|
|
///
|
|
/// Almost all terminal-modifying activity is from the pty read, so
|
|
/// putting this on a dedicated thread keeps performance very predictable
|
|
/// while also almost optimal. "Locking is fast, lock contention is slow."
|
|
/// and since we rarely have contention, this is fast.
|
|
///
|
|
/// This is also empirically fast compared to putting the read into
|
|
/// an async mechanism like io_uring/epoll because the reads are generally
|
|
/// small.
|
|
///
|
|
/// We use a basic poll syscall here because we are only monitoring two
|
|
/// fds and this is still much faster and lower overhead than any async
|
|
/// mechanism.
|
|
const ReadThread = struct {
|
|
fn threadMainPosix(fd: std.os.fd_t, ev: *EventData, quit: std.os.fd_t) void {
|
|
// Always close our end of the pipe when we exit.
|
|
defer std.os.close(quit);
|
|
|
|
// First thing, we want to set the fd to non-blocking. We do this
|
|
// so that we can try to read from the fd in a tight loop and only
|
|
// check the quit fd occasionally.
|
|
if (std.os.fcntl(fd, std.os.F.GETFL, 0)) |flags| {
|
|
_ = std.os.fcntl(fd, std.os.F.SETFL, flags | std.os.O.NONBLOCK) catch |err| {
|
|
log.warn("read thread failed to set flags err={}", .{err});
|
|
log.warn("this isn't a fatal error, but may cause performance issues", .{});
|
|
};
|
|
} else |err| {
|
|
log.warn("read thread failed to get flags err={}", .{err});
|
|
log.warn("this isn't a fatal error, but may cause performance issues", .{});
|
|
}
|
|
|
|
// Build up the list of fds we're going to poll. We are looking
|
|
// for data on the pty and our quit notification.
|
|
var pollfds: [2]std.os.pollfd = .{
|
|
.{ .fd = fd, .events = std.os.POLL.IN, .revents = undefined },
|
|
.{ .fd = quit, .events = std.os.POLL.IN, .revents = undefined },
|
|
};
|
|
|
|
var buf: [1024]u8 = undefined;
|
|
while (true) {
|
|
// We try to read from the file descriptor as long as possible
|
|
// to maximize performance. We only check the quit fd if the
|
|
// main fd blocks. This optimizes for the realistic scenario that
|
|
// the data will eventually stop while we're trying to quit. This
|
|
// is always true because we kill the process.
|
|
while (true) {
|
|
const n = std.os.read(fd, &buf) catch |err| {
|
|
switch (err) {
|
|
// This means our pty is closed. We're probably
|
|
// gracefully shutting down.
|
|
error.NotOpenForReading,
|
|
error.InputOutput,
|
|
=> {
|
|
log.info("io reader exiting", .{});
|
|
return;
|
|
},
|
|
|
|
// No more data, fall back to poll and check for
|
|
// exit conditions.
|
|
error.WouldBlock => break,
|
|
|
|
else => {
|
|
log.err("io reader error err={}", .{err});
|
|
unreachable;
|
|
},
|
|
}
|
|
};
|
|
|
|
// This happens on macOS instead of WouldBlock when the
|
|
// child process dies. To be safe, we just break the loop
|
|
// and let our poll happen.
|
|
if (n == 0) break;
|
|
|
|
// log.info("DATA: {d}", .{n});
|
|
@call(.always_inline, process, .{ ev, buf[0..n] });
|
|
}
|
|
|
|
// Wait for data.
|
|
_ = std.os.poll(&pollfds, -1) catch |err| {
|
|
log.warn("poll failed on read thread, exiting early err={}", .{err});
|
|
return;
|
|
};
|
|
|
|
// If our quit fd is set, we're done.
|
|
if (pollfds[1].revents & std.os.POLL.IN != 0) {
|
|
log.info("read thread got quit signal", .{});
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn threadMainWindows(fd: std.os.fd_t, ev: *EventData, quit: std.os.fd_t) void {
|
|
// Always close our end of the pipe when we exit.
|
|
defer std.os.close(quit);
|
|
|
|
var buf: [1024]u8 = undefined;
|
|
while (true) {
|
|
while (true) {
|
|
var n: windows.DWORD = 0;
|
|
if (windows.kernel32.ReadFile(fd, &buf, buf.len, &n, null) == 0) {
|
|
const err = windows.kernel32.GetLastError();
|
|
switch (err) {
|
|
// Check for a quit signal
|
|
.OPERATION_ABORTED => break,
|
|
|
|
else => {
|
|
log.err("io reader error err={}", .{err});
|
|
unreachable;
|
|
},
|
|
}
|
|
}
|
|
|
|
@call(.always_inline, process, .{ ev, buf[0..n] });
|
|
}
|
|
|
|
var quit_bytes: windows.DWORD = 0;
|
|
if (windows.exp.kernel32.PeekNamedPipe(quit, null, 0, null, &quit_bytes, null) == 0) {
|
|
const err = windows.kernel32.GetLastError();
|
|
log.err("quit pipe reader error err={}", .{err});
|
|
unreachable;
|
|
}
|
|
|
|
if (quit_bytes > 0) {
|
|
log.info("read thread got quit signal", .{});
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn process(
|
|
ev: *EventData,
|
|
buf: []const u8,
|
|
) void {
|
|
const zone = trace(@src());
|
|
defer zone.end();
|
|
|
|
// log.info("DATA: {d}", .{n});
|
|
// log.info("DATA: {any}", .{buf[0..@intCast(usize, n)]});
|
|
|
|
// Whenever a character is typed, we ensure the cursor is in the
|
|
// non-blink state so it is rendered if visible. If we're under
|
|
// HEAVY read load, we don't want to send a ton of these so we
|
|
// use a timer under the covers
|
|
const now = ev.loop.now();
|
|
if (now - ev.last_cursor_reset > 500) {
|
|
ev.last_cursor_reset = now;
|
|
_ = ev.renderer_mailbox.push(.{
|
|
.reset_cursor_blink = {},
|
|
}, .{ .forever = {} });
|
|
}
|
|
|
|
// We are modifying terminal state from here on out
|
|
ev.renderer_state.mutex.lock();
|
|
defer ev.renderer_state.mutex.unlock();
|
|
|
|
// Schedule a render
|
|
ev.queueRender() catch unreachable;
|
|
|
|
// If we have an inspector, we enter SLOW MODE because we need to
|
|
// process a byte at a time alternating between the inspector handler
|
|
// and the termio handler. This is very slow compared to our optimizations
|
|
// below but at least users only pay for it if they're using the inspector.
|
|
if (ev.renderer_state.inspector) |insp| {
|
|
for (buf, 0..) |byte, i| {
|
|
insp.recordPtyRead(buf[i .. i + 1]) catch |err| {
|
|
log.err("error recording pty read in inspector err={}", .{err});
|
|
};
|
|
|
|
ev.terminal_stream.next(byte) catch |err|
|
|
log.err("error processing terminal data: {}", .{err});
|
|
}
|
|
} else {
|
|
// Process the terminal data. This is an extremely hot part of the
|
|
// terminal emulator, so we do some abstraction leakage to avoid
|
|
// function calls and unnecessary logic.
|
|
//
|
|
// The ground state is the only state that we can see and print/execute
|
|
// ASCII, so we only execute this hot path if we're already in the ground
|
|
// state.
|
|
//
|
|
// Empirically, this alone improved throughput of large text output by ~20%.
|
|
var i: usize = 0;
|
|
const end = buf.len;
|
|
if (ev.terminal_stream.parser.state == .ground) {
|
|
for (buf[i..end]) |ch| {
|
|
switch (terminal.parse_table.table[ch][@intFromEnum(terminal.Parser.State.ground)].action) {
|
|
// Print, call directly.
|
|
.print => ev.terminal_stream.handler.print(@intCast(ch)) catch |err|
|
|
log.err("error processing terminal data: {}", .{err}),
|
|
|
|
// C0 execute, let our stream handle this one but otherwise
|
|
// continue since we're guaranteed to be back in ground.
|
|
.execute => ev.terminal_stream.execute(ch) catch |err|
|
|
log.err("error processing terminal data: {}", .{err}),
|
|
|
|
// Otherwise, break out and go the slow path until we're
|
|
// back in ground. There is a slight optimization here where
|
|
// could try to find the next transition to ground but when
|
|
// I implemented that it didn't materially change performance.
|
|
else => break,
|
|
}
|
|
|
|
i += 1;
|
|
}
|
|
}
|
|
|
|
if (i < end) {
|
|
ev.terminal_stream.nextSlice(buf[i..end]) catch |err|
|
|
log.err("error processing terminal data: {}", .{err});
|
|
}
|
|
}
|
|
|
|
// If our stream handling caused messages to be sent to the writer
|
|
// thread, then we need to wake it up so that it processes them.
|
|
if (ev.terminal_stream.handler.writer_messaged) {
|
|
ev.terminal_stream.handler.writer_messaged = false;
|
|
ev.writer_wakeup.notify() catch |err| {
|
|
log.warn("failed to wake up writer thread err={}", .{err});
|
|
};
|
|
}
|
|
}
|
|
};
|
|
|
|
/// This is used as the handler for the terminal.Stream type. This is
|
|
/// stateful and is expected to live for the entire lifetime of the terminal.
|
|
/// It is NOT VALID to stop a stream handler, create a new one, and use that
|
|
/// unless all of the member fields are copied.
|
|
const StreamHandler = struct {
|
|
ev: *EventData,
|
|
alloc: Allocator,
|
|
grid_size: *renderer.GridSize,
|
|
terminal: *terminal.Terminal,
|
|
|
|
/// The APC command handler maintains the APC state. APC is like
|
|
/// CSI or OSC, but it is a private escape sequence that is used
|
|
/// to send commands to the terminal emulator. This is used by
|
|
/// the kitty graphics protocol.
|
|
apc: terminal.apc.Handler = .{},
|
|
|
|
/// The DCS handler maintains DCS state. DCS is like CSI or OSC,
|
|
/// but requires more stateful parsing. This is used by functionality
|
|
/// such as XTGETTCAP.
|
|
dcs: terminal.dcs.Handler = .{},
|
|
|
|
/// This is set to true when a message was written to the writer
|
|
/// mailbox. This can be used by callers to determine if they need
|
|
/// to wake up the writer.
|
|
writer_messaged: bool = false,
|
|
|
|
/// The default cursor state. This is used with CSI q. This is
|
|
/// set to true when we're currently in the default cursor state.
|
|
default_cursor: bool = true,
|
|
default_cursor_style: terminal.Cursor.Style,
|
|
default_cursor_blink: ?bool,
|
|
|
|
/// The default foreground and background color are those set by the user's
|
|
/// config file. These can be overridden by terminal applications using OSC
|
|
/// 10 and OSC 11, respectively.
|
|
default_foreground_color: terminal.color.RGB,
|
|
default_background_color: terminal.color.RGB,
|
|
|
|
/// The actual foreground and background color. Normally this will be the
|
|
/// same as the default foreground and background color, unless changed by a
|
|
/// terminal application.
|
|
foreground_color: terminal.color.RGB,
|
|
background_color: terminal.color.RGB,
|
|
|
|
osc_color_report_format: configpkg.Config.OSCColorReportFormat,
|
|
|
|
pub fn deinit(self: *StreamHandler) void {
|
|
self.apc.deinit();
|
|
self.dcs.deinit();
|
|
}
|
|
|
|
inline fn queueRender(self: *StreamHandler) !void {
|
|
try self.ev.queueRender();
|
|
}
|
|
|
|
inline fn messageWriter(self: *StreamHandler, msg: termio.Message) void {
|
|
_ = self.ev.writer_mailbox.push(msg, .{ .forever = {} });
|
|
self.writer_messaged = true;
|
|
}
|
|
|
|
pub fn changeDefaultCursor(
|
|
self: *StreamHandler,
|
|
style: terminal.Cursor.Style,
|
|
blink: ?bool,
|
|
) void {
|
|
self.default_cursor_style = style;
|
|
self.default_cursor_blink = blink;
|
|
|
|
// If our cursor is the default, then we update it immediately.
|
|
if (self.default_cursor) self.setCursorStyle(.default) catch |err| {
|
|
log.warn("failed to set default cursor style: {}", .{err});
|
|
return;
|
|
};
|
|
}
|
|
|
|
pub fn dcsHook(self: *StreamHandler, dcs: terminal.DCS) !void {
|
|
self.dcs.hook(self.alloc, dcs);
|
|
}
|
|
|
|
pub fn dcsPut(self: *StreamHandler, byte: u8) !void {
|
|
self.dcs.put(byte);
|
|
}
|
|
|
|
pub fn dcsUnhook(self: *StreamHandler) !void {
|
|
var cmd = self.dcs.unhook() orelse return;
|
|
defer cmd.deinit();
|
|
|
|
// log.warn("DCS command: {}", .{cmd});
|
|
switch (cmd) {
|
|
.xtgettcap => |*gettcap| {
|
|
const map = comptime terminfo.ghostty.xtgettcapMap();
|
|
while (gettcap.next()) |key| {
|
|
const response = map.get(key) orelse continue;
|
|
self.messageWriter(.{ .write_stable = response });
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
pub fn apcStart(self: *StreamHandler) !void {
|
|
self.apc.start();
|
|
}
|
|
|
|
pub fn apcPut(self: *StreamHandler, byte: u8) !void {
|
|
self.apc.feed(self.alloc, byte);
|
|
}
|
|
|
|
pub fn apcEnd(self: *StreamHandler) !void {
|
|
var cmd = self.apc.end() orelse return;
|
|
defer cmd.deinit(self.alloc);
|
|
|
|
// log.warn("APC command: {}", .{cmd});
|
|
switch (cmd) {
|
|
.kitty => |*kitty_cmd| {
|
|
if (self.terminal.kittyGraphics(self.alloc, kitty_cmd)) |resp| {
|
|
var buf: [1024]u8 = undefined;
|
|
var buf_stream = std.io.fixedBufferStream(&buf);
|
|
try resp.encode(buf_stream.writer());
|
|
const final = buf_stream.getWritten();
|
|
if (final.len > 2) {
|
|
// log.warn("kitty graphics response: {s}", .{std.fmt.fmtSliceHexLower(final)});
|
|
self.messageWriter(try termio.Message.writeReq(self.alloc, final));
|
|
}
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
pub fn print(self: *StreamHandler, ch: u21) !void {
|
|
try self.terminal.print(ch);
|
|
}
|
|
|
|
pub fn printRepeat(self: *StreamHandler, count: usize) !void {
|
|
try self.terminal.printRepeat(count);
|
|
}
|
|
|
|
pub fn bell(self: StreamHandler) !void {
|
|
_ = self;
|
|
log.info("BELL", .{});
|
|
}
|
|
|
|
pub fn backspace(self: *StreamHandler) !void {
|
|
self.terminal.backspace();
|
|
}
|
|
|
|
pub fn horizontalTab(self: *StreamHandler, count: u16) !void {
|
|
for (0..count) |_| {
|
|
const x = self.terminal.screen.cursor.x;
|
|
try self.terminal.horizontalTab();
|
|
if (x == self.terminal.screen.cursor.x) break;
|
|
}
|
|
}
|
|
|
|
pub fn horizontalTabBack(self: *StreamHandler, count: u16) !void {
|
|
for (0..count) |_| {
|
|
const x = self.terminal.screen.cursor.x;
|
|
try self.terminal.horizontalTabBack();
|
|
if (x == self.terminal.screen.cursor.x) break;
|
|
}
|
|
}
|
|
|
|
pub fn linefeed(self: *StreamHandler) !void {
|
|
// Small optimization: call index instead of linefeed because they're
|
|
// identical and this avoids one layer of function call overhead.
|
|
try self.terminal.index();
|
|
}
|
|
|
|
pub fn carriageReturn(self: *StreamHandler) !void {
|
|
self.terminal.carriageReturn();
|
|
}
|
|
|
|
pub fn setCursorLeft(self: *StreamHandler, amount: u16) !void {
|
|
self.terminal.cursorLeft(amount);
|
|
}
|
|
|
|
pub fn setCursorRight(self: *StreamHandler, amount: u16) !void {
|
|
self.terminal.cursorRight(amount);
|
|
}
|
|
|
|
pub fn setCursorDown(self: *StreamHandler, amount: u16, carriage: bool) !void {
|
|
self.terminal.cursorDown(amount);
|
|
if (carriage) self.terminal.carriageReturn();
|
|
}
|
|
|
|
pub fn setCursorUp(self: *StreamHandler, amount: u16, carriage: bool) !void {
|
|
self.terminal.cursorUp(amount);
|
|
if (carriage) self.terminal.carriageReturn();
|
|
}
|
|
|
|
pub fn setCursorCol(self: *StreamHandler, col: u16) !void {
|
|
self.terminal.setCursorPos(self.terminal.screen.cursor.y + 1, col);
|
|
}
|
|
|
|
pub fn setCursorColRelative(self: *StreamHandler, offset: u16) !void {
|
|
self.terminal.setCursorPos(
|
|
self.terminal.screen.cursor.y + 1,
|
|
self.terminal.screen.cursor.x + 1 + offset,
|
|
);
|
|
}
|
|
|
|
pub fn setCursorRow(self: *StreamHandler, row: u16) !void {
|
|
self.terminal.setCursorPos(row, self.terminal.screen.cursor.x + 1);
|
|
}
|
|
|
|
pub fn setCursorRowRelative(self: *StreamHandler, offset: u16) !void {
|
|
self.terminal.setCursorPos(
|
|
self.terminal.screen.cursor.y + 1 + offset,
|
|
self.terminal.screen.cursor.x + 1,
|
|
);
|
|
}
|
|
|
|
pub fn setCursorPos(self: *StreamHandler, row: u16, col: u16) !void {
|
|
self.terminal.setCursorPos(row, col);
|
|
}
|
|
|
|
pub fn eraseDisplay(self: *StreamHandler, mode: terminal.EraseDisplay, protected: bool) !void {
|
|
if (mode == .complete) {
|
|
// Whenever we erase the full display, scroll to bottom.
|
|
try self.terminal.scrollViewport(.{ .bottom = {} });
|
|
try self.queueRender();
|
|
}
|
|
|
|
self.terminal.eraseDisplay(self.alloc, mode, protected);
|
|
}
|
|
|
|
pub fn eraseLine(self: *StreamHandler, mode: terminal.EraseLine, protected: bool) !void {
|
|
self.terminal.eraseLine(mode, protected);
|
|
}
|
|
|
|
pub fn deleteChars(self: *StreamHandler, count: usize) !void {
|
|
try self.terminal.deleteChars(count);
|
|
}
|
|
|
|
pub fn eraseChars(self: *StreamHandler, count: usize) !void {
|
|
self.terminal.eraseChars(count);
|
|
}
|
|
|
|
pub fn insertLines(self: *StreamHandler, count: usize) !void {
|
|
try self.terminal.insertLines(count);
|
|
}
|
|
|
|
pub fn insertBlanks(self: *StreamHandler, count: usize) !void {
|
|
self.terminal.insertBlanks(count);
|
|
}
|
|
|
|
pub fn deleteLines(self: *StreamHandler, count: usize) !void {
|
|
try self.terminal.deleteLines(count);
|
|
}
|
|
|
|
pub fn reverseIndex(self: *StreamHandler) !void {
|
|
try self.terminal.reverseIndex();
|
|
}
|
|
|
|
pub fn index(self: *StreamHandler) !void {
|
|
try self.terminal.index();
|
|
}
|
|
|
|
pub fn nextLine(self: *StreamHandler) !void {
|
|
try self.terminal.index();
|
|
self.terminal.carriageReturn();
|
|
}
|
|
|
|
pub fn setTopAndBottomMargin(self: *StreamHandler, top: u16, bot: u16) !void {
|
|
self.terminal.setTopAndBottomMargin(top, bot);
|
|
}
|
|
|
|
pub fn setLeftAndRightMargin(self: *StreamHandler, left: u16, right: u16) !void {
|
|
self.terminal.setLeftAndRightMargin(left, right);
|
|
}
|
|
|
|
pub fn setModifyKeyFormat(self: *StreamHandler, format: terminal.ModifyKeyFormat) !void {
|
|
self.terminal.flags.modify_other_keys_2 = false;
|
|
switch (format) {
|
|
.other_keys => |v| switch (v) {
|
|
.numeric => self.terminal.flags.modify_other_keys_2 = true,
|
|
else => {},
|
|
},
|
|
else => {},
|
|
}
|
|
}
|
|
|
|
pub fn requestMode(self: *StreamHandler, mode_raw: u16, ansi: bool) !void {
|
|
// Get the mode value and respond.
|
|
const code: u8 = code: {
|
|
const mode = terminal.modes.modeFromInt(mode_raw, ansi) orelse break :code 0;
|
|
if (self.terminal.modes.get(mode)) break :code 1;
|
|
break :code 2;
|
|
};
|
|
|
|
var msg: termio.Message = .{ .write_small = .{} };
|
|
const resp = try std.fmt.bufPrint(
|
|
&msg.write_small.data,
|
|
"\x1B[{s}{};{}$y",
|
|
.{
|
|
if (ansi) "" else "?",
|
|
mode_raw,
|
|
code,
|
|
},
|
|
);
|
|
msg.write_small.len = @intCast(resp.len);
|
|
self.messageWriter(msg);
|
|
}
|
|
|
|
pub fn saveMode(self: *StreamHandler, mode: terminal.Mode) !void {
|
|
// log.debug("save mode={}", .{mode});
|
|
self.terminal.modes.save(mode);
|
|
}
|
|
|
|
pub fn restoreMode(self: *StreamHandler, mode: terminal.Mode) !void {
|
|
// For restore mode we have to restore but if we set it, we
|
|
// always have to call setMode because setting some modes have
|
|
// side effects and we want to make sure we process those.
|
|
const v = self.terminal.modes.restore(mode);
|
|
// log.debug("restore mode={} v={}", .{ mode, v });
|
|
try self.setMode(mode, v);
|
|
}
|
|
|
|
pub fn setMode(self: *StreamHandler, mode: terminal.Mode, enabled: bool) !void {
|
|
// Note: this function doesn't need to grab the render state or
|
|
// terminal locks because it is only called from process() which
|
|
// grabs the lock.
|
|
|
|
// If we are setting cursor blinking, we ignore it if we have
|
|
// a default cursor blink setting set. This is a really weird
|
|
// behavior so this comment will go deep into trying to explain it.
|
|
//
|
|
// There are two ways to set cursor blinks: DECSCUSR (CSI _ q)
|
|
// and DEC mode 12. DECSCUSR is the modern approach and has a
|
|
// way to revert to the "default" (as defined by the terminal)
|
|
// cursor style and blink by doing "CSI 0 q". DEC mode 12 controls
|
|
// blinking and is either on or off and has no way to set a
|
|
// default. DEC mode 12 is also the more antiquated approach.
|
|
//
|
|
// The problem is that if the user specifies a desired default
|
|
// cursor blink with `cursor-style-blink`, the moment a running
|
|
// program uses DEC mode 12, the cursor blink can never be reset
|
|
// to the default without an explicit DECSCUSR. But if a program
|
|
// is using mode 12, it is by definition not using DECSCUSR.
|
|
// This makes for somewhat annoying interactions where a poorly
|
|
// (or legacy) behaved program will stop blinking, and it simply
|
|
// never restarts.
|
|
//
|
|
// To get around this, we have a special case where if the user
|
|
// specifies some explicit default cursor blink desire, we ignore
|
|
// DEC mode 12. We allow DECSCUSR to still set the cursor blink
|
|
// because programs using DECSCUSR usually are well behaved and
|
|
// reset the cursor blink to the default when they exit.
|
|
//
|
|
// To be extra safe, users can also add a manual `CSI 0 q` to
|
|
// their shell config when they render prompts to ensure the
|
|
// cursor is exactly as they request.
|
|
if (mode == .cursor_blinking and
|
|
self.default_cursor_blink != null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// We first always set the raw mode on our mode state.
|
|
self.terminal.modes.set(mode, enabled);
|
|
|
|
// And then some modes require additional processing.
|
|
switch (mode) {
|
|
// Schedule a render since we changed colors
|
|
.reverse_colors => try self.queueRender(),
|
|
|
|
// Origin resets cursor pos
|
|
.origin => self.terminal.setCursorPos(1, 1),
|
|
|
|
.enable_left_and_right_margin => if (!enabled) {
|
|
// When we disable left/right margin mode we need to
|
|
// reset the left/right margins.
|
|
self.terminal.scrolling_region.left = 0;
|
|
self.terminal.scrolling_region.right = self.terminal.cols - 1;
|
|
},
|
|
|
|
.alt_screen_save_cursor_clear_enter => {
|
|
const opts: terminal.Terminal.AlternateScreenOptions = .{
|
|
.cursor_save = true,
|
|
.clear_on_enter = true,
|
|
};
|
|
|
|
if (enabled)
|
|
self.terminal.alternateScreen(self.alloc, opts)
|
|
else
|
|
self.terminal.primaryScreen(self.alloc, opts);
|
|
|
|
// Schedule a render since we changed screens
|
|
try self.queueRender();
|
|
},
|
|
|
|
// Force resize back to the window size
|
|
.enable_mode_3 => self.terminal.resize(
|
|
self.alloc,
|
|
self.grid_size.columns,
|
|
self.grid_size.rows,
|
|
) catch |err| {
|
|
log.err("error updating terminal size: {}", .{err});
|
|
},
|
|
|
|
.@"132_column" => try self.terminal.deccolm(
|
|
self.alloc,
|
|
if (enabled) .@"132_cols" else .@"80_cols",
|
|
),
|
|
|
|
// We need to start a timer to prevent the emulator being hung
|
|
// forever.
|
|
.synchronized_output => {
|
|
if (enabled) self.messageWriter(.{ .start_synchronized_output = {} });
|
|
try self.queueRender();
|
|
},
|
|
|
|
.linefeed => {
|
|
self.messageWriter(.{ .linefeed_mode = enabled });
|
|
},
|
|
|
|
.mouse_event_x10 => {
|
|
if (enabled) {
|
|
self.terminal.flags.mouse_event = .x10;
|
|
try self.setMouseShape(.default);
|
|
} else {
|
|
self.terminal.flags.mouse_event = .none;
|
|
try self.setMouseShape(.text);
|
|
}
|
|
},
|
|
.mouse_event_normal => {
|
|
if (enabled) {
|
|
self.terminal.flags.mouse_event = .normal;
|
|
try self.setMouseShape(.default);
|
|
} else {
|
|
self.terminal.flags.mouse_event = .none;
|
|
try self.setMouseShape(.text);
|
|
}
|
|
},
|
|
.mouse_event_button => {
|
|
if (enabled) {
|
|
self.terminal.flags.mouse_event = .button;
|
|
try self.setMouseShape(.default);
|
|
} else {
|
|
self.terminal.flags.mouse_event = .none;
|
|
try self.setMouseShape(.text);
|
|
}
|
|
},
|
|
.mouse_event_any => {
|
|
if (enabled) {
|
|
self.terminal.flags.mouse_event = .any;
|
|
try self.setMouseShape(.default);
|
|
} else {
|
|
self.terminal.flags.mouse_event = .none;
|
|
try self.setMouseShape(.text);
|
|
}
|
|
},
|
|
|
|
.mouse_format_utf8 => self.terminal.flags.mouse_format = if (enabled) .utf8 else .x10,
|
|
.mouse_format_sgr => self.terminal.flags.mouse_format = if (enabled) .sgr else .x10,
|
|
.mouse_format_urxvt => self.terminal.flags.mouse_format = if (enabled) .urxvt else .x10,
|
|
.mouse_format_sgr_pixels => self.terminal.flags.mouse_format = if (enabled) .sgr_pixels else .x10,
|
|
|
|
else => {},
|
|
}
|
|
}
|
|
|
|
pub fn setMouseShiftCapture(self: *StreamHandler, v: bool) !void {
|
|
self.terminal.flags.mouse_shift_capture = if (v) .true else .false;
|
|
}
|
|
|
|
pub fn setAttribute(self: *StreamHandler, attr: terminal.Attribute) !void {
|
|
switch (attr) {
|
|
.unknown => |unk| log.warn("unimplemented or unknown SGR attribute: {any}", .{unk}),
|
|
|
|
else => self.terminal.setAttribute(attr) catch |err|
|
|
log.warn("error setting attribute {}: {}", .{ attr, err }),
|
|
}
|
|
}
|
|
|
|
pub fn deviceAttributes(
|
|
self: *StreamHandler,
|
|
req: terminal.DeviceAttributeReq,
|
|
params: []const u16,
|
|
) !void {
|
|
_ = params;
|
|
|
|
// For the below, we quack as a VT220. We don't quack as
|
|
// a 420 because we don't support DCS sequences.
|
|
switch (req) {
|
|
.primary => self.messageWriter(.{
|
|
.write_stable = "\x1B[?62;22c",
|
|
}),
|
|
|
|
.secondary => self.messageWriter(.{
|
|
.write_stable = "\x1B[>1;10;0c",
|
|
}),
|
|
|
|
else => log.warn("unimplemented device attributes req: {}", .{req}),
|
|
}
|
|
}
|
|
|
|
pub fn deviceStatusReport(
|
|
self: *StreamHandler,
|
|
req: terminal.DeviceStatusReq,
|
|
) !void {
|
|
switch (req) {
|
|
.operating_status => self.messageWriter(.{ .write_stable = "\x1B[0n" }),
|
|
|
|
.cursor_position => {
|
|
const pos: struct {
|
|
x: usize,
|
|
y: usize,
|
|
} = if (self.terminal.modes.get(.origin)) .{
|
|
.x = self.terminal.screen.cursor.x -| self.terminal.scrolling_region.left,
|
|
.y = self.terminal.screen.cursor.y -| self.terminal.scrolling_region.top,
|
|
} else .{
|
|
.x = self.terminal.screen.cursor.x,
|
|
.y = self.terminal.screen.cursor.y,
|
|
};
|
|
|
|
// Response always is at least 4 chars, so this leaves the
|
|
// remainder for the row/column as base-10 numbers. This
|
|
// will support a very large terminal.
|
|
var msg: termio.Message = .{ .write_small = .{} };
|
|
const resp = try std.fmt.bufPrint(&msg.write_small.data, "\x1B[{};{}R", .{
|
|
pos.y + 1,
|
|
pos.x + 1,
|
|
});
|
|
msg.write_small.len = @intCast(resp.len);
|
|
|
|
self.messageWriter(msg);
|
|
},
|
|
|
|
else => log.warn("unimplemented device status req: {}", .{req}),
|
|
}
|
|
}
|
|
|
|
pub fn setCursorStyle(
|
|
self: *StreamHandler,
|
|
style: terminal.CursorStyleReq,
|
|
) !void {
|
|
// Assume we're setting to a non-default.
|
|
self.default_cursor = false;
|
|
|
|
switch (style) {
|
|
.default => {
|
|
self.default_cursor = true;
|
|
self.terminal.screen.cursor.style = self.default_cursor_style;
|
|
self.terminal.modes.set(
|
|
.cursor_blinking,
|
|
self.default_cursor_blink orelse true,
|
|
);
|
|
},
|
|
|
|
.blinking_block => {
|
|
self.terminal.screen.cursor.style = .block;
|
|
self.terminal.modes.set(.cursor_blinking, true);
|
|
},
|
|
|
|
.steady_block => {
|
|
self.terminal.screen.cursor.style = .block;
|
|
self.terminal.modes.set(.cursor_blinking, false);
|
|
},
|
|
|
|
.blinking_underline => {
|
|
self.terminal.screen.cursor.style = .underline;
|
|
self.terminal.modes.set(.cursor_blinking, true);
|
|
},
|
|
|
|
.steady_underline => {
|
|
self.terminal.screen.cursor.style = .underline;
|
|
self.terminal.modes.set(.cursor_blinking, false);
|
|
},
|
|
|
|
.blinking_bar => {
|
|
self.terminal.screen.cursor.style = .bar;
|
|
self.terminal.modes.set(.cursor_blinking, true);
|
|
},
|
|
|
|
.steady_bar => {
|
|
self.terminal.screen.cursor.style = .bar;
|
|
self.terminal.modes.set(.cursor_blinking, false);
|
|
},
|
|
|
|
else => log.warn("unimplemented cursor style: {}", .{style}),
|
|
}
|
|
}
|
|
|
|
pub fn setProtectedMode(self: *StreamHandler, mode: terminal.ProtectedMode) !void {
|
|
self.terminal.setProtectedMode(mode);
|
|
}
|
|
|
|
pub fn decaln(self: *StreamHandler) !void {
|
|
try self.terminal.decaln();
|
|
}
|
|
|
|
pub fn tabClear(self: *StreamHandler, cmd: terminal.TabClear) !void {
|
|
self.terminal.tabClear(cmd);
|
|
}
|
|
|
|
pub fn tabSet(self: *StreamHandler) !void {
|
|
self.terminal.tabSet();
|
|
}
|
|
|
|
pub fn tabReset(self: *StreamHandler) !void {
|
|
self.terminal.tabReset();
|
|
}
|
|
|
|
pub fn saveCursor(self: *StreamHandler) !void {
|
|
self.terminal.saveCursor();
|
|
}
|
|
|
|
pub fn restoreCursor(self: *StreamHandler) !void {
|
|
self.terminal.restoreCursor();
|
|
}
|
|
|
|
pub fn enquiry(self: *StreamHandler) !void {
|
|
self.messageWriter(.{ .write_stable = "" });
|
|
}
|
|
|
|
pub fn scrollDown(self: *StreamHandler, count: usize) !void {
|
|
try self.terminal.scrollDown(count);
|
|
}
|
|
|
|
pub fn scrollUp(self: *StreamHandler, count: usize) !void {
|
|
try self.terminal.scrollUp(count);
|
|
}
|
|
|
|
pub fn setActiveStatusDisplay(
|
|
self: *StreamHandler,
|
|
req: terminal.StatusDisplay,
|
|
) !void {
|
|
self.terminal.status_display = req;
|
|
}
|
|
|
|
pub fn configureCharset(
|
|
self: *StreamHandler,
|
|
slot: terminal.CharsetSlot,
|
|
set: terminal.Charset,
|
|
) !void {
|
|
self.terminal.configureCharset(slot, set);
|
|
}
|
|
|
|
pub fn invokeCharset(
|
|
self: *StreamHandler,
|
|
active: terminal.CharsetActiveSlot,
|
|
slot: terminal.CharsetSlot,
|
|
single: bool,
|
|
) !void {
|
|
self.terminal.invokeCharset(active, slot, single);
|
|
}
|
|
|
|
pub fn fullReset(
|
|
self: *StreamHandler,
|
|
) !void {
|
|
self.terminal.fullReset(self.alloc);
|
|
try self.setMouseShape(.text);
|
|
}
|
|
|
|
pub fn queryKittyKeyboard(self: *StreamHandler) !void {
|
|
if (comptime disable_kitty_keyboard_protocol) return;
|
|
|
|
log.debug("querying kitty keyboard mode", .{});
|
|
var data: termio.Message.WriteReq.Small.Array = undefined;
|
|
const resp = try std.fmt.bufPrint(&data, "\x1b[?{}u", .{
|
|
self.terminal.screen.kitty_keyboard.current().int(),
|
|
});
|
|
|
|
self.messageWriter(.{
|
|
.write_small = .{
|
|
.data = data,
|
|
.len = @intCast(resp.len),
|
|
},
|
|
});
|
|
}
|
|
|
|
pub fn pushKittyKeyboard(
|
|
self: *StreamHandler,
|
|
flags: terminal.kitty.KeyFlags,
|
|
) !void {
|
|
if (comptime disable_kitty_keyboard_protocol) return;
|
|
|
|
log.debug("pushing kitty keyboard mode: {}", .{flags});
|
|
self.terminal.screen.kitty_keyboard.push(flags);
|
|
}
|
|
|
|
pub fn popKittyKeyboard(self: *StreamHandler, n: u16) !void {
|
|
if (comptime disable_kitty_keyboard_protocol) return;
|
|
|
|
log.debug("popping kitty keyboard mode n={}", .{n});
|
|
self.terminal.screen.kitty_keyboard.pop(@intCast(n));
|
|
}
|
|
|
|
pub fn setKittyKeyboard(
|
|
self: *StreamHandler,
|
|
mode: terminal.kitty.KeySetMode,
|
|
flags: terminal.kitty.KeyFlags,
|
|
) !void {
|
|
if (comptime disable_kitty_keyboard_protocol) return;
|
|
|
|
log.debug("setting kitty keyboard mode: {} {}", .{ mode, flags });
|
|
self.terminal.screen.kitty_keyboard.set(mode, flags);
|
|
}
|
|
|
|
pub fn reportXtversion(
|
|
self: *StreamHandler,
|
|
) !void {
|
|
log.debug("reporting XTVERSION: ghostty {s}", .{build_config.version_string});
|
|
var buf: [288]u8 = undefined;
|
|
const resp = try std.fmt.bufPrint(
|
|
&buf,
|
|
"\x1BP>|{s} {s}\x1B\\",
|
|
.{
|
|
"ghostty",
|
|
build_config.version_string,
|
|
},
|
|
);
|
|
var msg = try termio.Message.writeReq(self.alloc, resp);
|
|
self.messageWriter(msg);
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
// OSC
|
|
|
|
pub fn changeWindowTitle(self: *StreamHandler, title: []const u8) !void {
|
|
var buf: [256]u8 = undefined;
|
|
if (title.len >= buf.len) {
|
|
log.warn("change title requested larger than our buffer size, ignoring", .{});
|
|
return;
|
|
}
|
|
|
|
std.mem.copy(u8, &buf, title);
|
|
buf[title.len] = 0;
|
|
|
|
// Mark that we've seen a title
|
|
self.ev.seen_title = true;
|
|
|
|
_ = self.ev.surface_mailbox.push(.{
|
|
.set_title = buf,
|
|
}, .{ .forever = {} });
|
|
}
|
|
|
|
pub fn setMouseShape(
|
|
self: *StreamHandler,
|
|
shape: terminal.MouseShape,
|
|
) !void {
|
|
self.terminal.mouse_shape = shape;
|
|
_ = self.ev.surface_mailbox.push(.{
|
|
.set_mouse_shape = shape,
|
|
}, .{ .forever = {} });
|
|
}
|
|
|
|
pub fn clipboardContents(self: *StreamHandler, kind: u8, data: []const u8) !void {
|
|
// Note: we ignore the "kind" field and always use the standard clipboard.
|
|
// iTerm also appears to do this but other terminals seem to only allow
|
|
// certain. Let's investigate more.
|
|
|
|
// Get clipboard contents
|
|
if (data.len == 1 and data[0] == '?') {
|
|
_ = self.ev.surface_mailbox.push(.{
|
|
.clipboard_read = kind,
|
|
}, .{ .forever = {} });
|
|
return;
|
|
}
|
|
|
|
// Write clipboard contents
|
|
_ = self.ev.surface_mailbox.push(.{
|
|
.clipboard_write = try apprt.surface.Message.WriteReq.init(
|
|
self.alloc,
|
|
data,
|
|
),
|
|
}, .{ .forever = {} });
|
|
}
|
|
|
|
pub fn promptStart(self: *StreamHandler, aid: ?[]const u8, redraw: bool) !void {
|
|
_ = aid;
|
|
self.terminal.markSemanticPrompt(.prompt);
|
|
self.terminal.flags.shell_redraws_prompt = redraw;
|
|
}
|
|
|
|
pub fn promptContinuation(self: *StreamHandler, aid: ?[]const u8) !void {
|
|
_ = aid;
|
|
self.terminal.markSemanticPrompt(.prompt_continuation);
|
|
}
|
|
|
|
pub fn promptEnd(self: *StreamHandler) !void {
|
|
self.terminal.markSemanticPrompt(.input);
|
|
}
|
|
|
|
pub fn endOfInput(self: *StreamHandler) !void {
|
|
self.terminal.markSemanticPrompt(.command);
|
|
}
|
|
|
|
pub fn reportPwd(self: *StreamHandler, url: []const u8) !void {
|
|
if (builtin.os.tag == .windows) {
|
|
log.warn("reportPwd unimplemented on windows", .{});
|
|
return;
|
|
}
|
|
|
|
const uri = std.Uri.parse(url) catch |e| {
|
|
log.warn("invalid url in OSC 7: {}", .{e});
|
|
return;
|
|
};
|
|
|
|
if (!std.mem.eql(u8, "file", uri.scheme) and
|
|
!std.mem.eql(u8, "kitty-shell-cwd", uri.scheme))
|
|
{
|
|
log.warn("OSC 7 scheme must be file, got: {s}", .{uri.scheme});
|
|
return;
|
|
}
|
|
|
|
// OSC 7 is a little sketchy because anyone can send any value from
|
|
// any host (such an SSH session). The best practice terminals follow
|
|
// is to valid the hostname to be local.
|
|
const host_valid = host_valid: {
|
|
const host = uri.host orelse break :host_valid false;
|
|
|
|
// Empty or localhost is always good
|
|
if (host.len == 0 or std.mem.eql(u8, "localhost", host)) {
|
|
break :host_valid true;
|
|
}
|
|
|
|
// Otherwise, it must match our hostname.
|
|
var buf: [std.os.HOST_NAME_MAX]u8 = undefined;
|
|
const hostname = std.os.gethostname(&buf) catch |err| {
|
|
log.warn("failed to get hostname for OSC 7 validation: {}", .{err});
|
|
break :host_valid false;
|
|
};
|
|
|
|
break :host_valid std.mem.eql(u8, host, hostname);
|
|
};
|
|
if (!host_valid) {
|
|
log.warn("OSC 7 host must be local", .{});
|
|
return;
|
|
}
|
|
|
|
// We need to unescape the path. We first try to unescape onto
|
|
// the stack and fall back to heap allocation if we have to.
|
|
var pathBuf: [1024]u8 = undefined;
|
|
const path, const heap = path: {
|
|
// If the path doesn't have any escapes, we can use it directly.
|
|
if (std.mem.indexOfScalar(u8, uri.path, '%') == null)
|
|
break :path .{ uri.path, false };
|
|
|
|
// First try to stack-allocate
|
|
var fba = std.heap.FixedBufferAllocator.init(&pathBuf);
|
|
if (std.Uri.unescapeString(fba.allocator(), uri.path)) |path|
|
|
break :path .{ path, false }
|
|
else |_| {}
|
|
|
|
// Fall back to heap
|
|
if (std.Uri.unescapeString(self.alloc, uri.path)) |path|
|
|
break :path .{ path, true }
|
|
else |_| {}
|
|
|
|
// Fall back to using it directly...
|
|
log.warn("failed to unescape OSC 7 path, using it directly path={s}", .{uri.path});
|
|
break :path .{ uri.path, false };
|
|
};
|
|
defer if (heap) self.alloc.free(path);
|
|
|
|
log.debug("terminal pwd: {s}", .{path});
|
|
try self.terminal.setPwd(path);
|
|
|
|
// If we haven't seen a title, use our pwd as the title.
|
|
if (!self.ev.seen_title) {
|
|
try self.changeWindowTitle(path);
|
|
self.ev.seen_title = false;
|
|
}
|
|
}
|
|
|
|
/// Implements OSC 4, OSC 10, and OSC 11, which reports palette color,
|
|
/// default foreground color, and background color respectively.
|
|
pub fn reportColor(
|
|
self: *StreamHandler,
|
|
kind: terminal.osc.Command.DefaultColorKind,
|
|
terminator: terminal.osc.Terminator,
|
|
) !void {
|
|
if (self.osc_color_report_format == .none) return;
|
|
|
|
const color = switch (kind) {
|
|
.foreground => self.foreground_color,
|
|
.background => self.background_color,
|
|
.palette => |i| self.terminal.color_palette[i],
|
|
};
|
|
|
|
var msg: termio.Message = .{ .write_small = .{} };
|
|
const resp = switch (self.osc_color_report_format) {
|
|
.@"16-bit" => try std.fmt.bufPrint(
|
|
&msg.write_small.data,
|
|
"\x1B]{s};rgb:{x:0>4}/{x:0>4}/{x:0>4}{s}",
|
|
.{
|
|
kind.code(),
|
|
@as(u16, color.r) * 257,
|
|
@as(u16, color.g) * 257,
|
|
@as(u16, color.b) * 257,
|
|
terminator.string(),
|
|
},
|
|
),
|
|
|
|
.@"8-bit" => try std.fmt.bufPrint(
|
|
&msg.write_small.data,
|
|
"\x1B]{s};rgb:{x:0>2}/{x:0>2}/{x:0>2}{s}",
|
|
.{
|
|
kind.code(),
|
|
@as(u16, color.r),
|
|
@as(u16, color.g),
|
|
@as(u16, color.b),
|
|
terminator.string(),
|
|
},
|
|
),
|
|
|
|
.none => unreachable, // early return above
|
|
};
|
|
msg.write_small.len = @intCast(resp.len);
|
|
self.messageWriter(msg);
|
|
}
|
|
|
|
pub fn setColor(
|
|
self: *StreamHandler,
|
|
kind: terminal.osc.Command.DefaultColorKind,
|
|
value: []const u8,
|
|
) !void {
|
|
const color = try terminal.color.RGB.parse(value);
|
|
|
|
switch (kind) {
|
|
.foreground => {
|
|
self.foreground_color = color;
|
|
_ = self.ev.renderer_mailbox.push(.{
|
|
.foreground_color = color,
|
|
}, .{ .forever = {} });
|
|
},
|
|
.background => {
|
|
self.background_color = color;
|
|
_ = self.ev.renderer_mailbox.push(.{
|
|
.background_color = color,
|
|
}, .{ .forever = {} });
|
|
},
|
|
.palette => |i| self.terminal.color_palette[i] = color,
|
|
}
|
|
}
|
|
};
|