summaryrefslogtreecommitdiff
path: root/src/panes.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/panes.zig')
-rw-r--r--src/panes.zig76
1 files changed, 73 insertions, 3 deletions
diff --git a/src/panes.zig b/src/panes.zig
index ed2f3767..4f9ac6fc 100644
--- a/src/panes.zig
+++ b/src/panes.zig
@@ -146,7 +146,12 @@ pub const Pane = struct {
/// A shell has run in it (Pardes.acknowledgeShell): a Term whose first
/// shell fails to start closes, one started again keeps its pane.
had_shell: bool = false,
- pending_command: terminal.PendingCommand = .{},
+ /// What pardes typed for a shell not ready for it yet: queued until it
+ /// is started (`spawn`) and then at its prompt (`input`).
+ pending_command: struct {
+ bytes: []u8 = &.{},
+ wait: enum { none, spawn, input } = .none,
+ } = .{},
/// The last command line pardes typed into this terminal (an exec, a
/// middle click, a pty/run): its first word, which Kill matches, and
/// the shell's command count its start (C mark) reaches.
@@ -971,6 +976,69 @@ pub const Pane = struct {
return @intCast(@min(pane.rows - shown, (at + 1) -| shown));
}
+ /// Whether a new terminal's greeting may be typed now: only at the
+ /// shell's first prompt (pardes's own marks: no command started; a
+ /// prompt drawn again for a resize is the same first prompt), with
+ /// nothing typed at it and no program on the alternate screen. Any
+ /// later moment is `.never`, for good: something has run or been typed
+ /// first, and an `ls` then would go into it. A shell pardes cannot mark
+ /// has no first prompt to find, and is never greeted.
+ pub fn greeting(pane: *const Pane) enum { wait, now, never } {
+ if (pane.fs.unmarked) return .never;
+ // Text typed into the edit buffer that stands in for the prompt row.
+ if (pane.ovl) |o| if (o.text.len > 0) return .never;
+ const state = pane.terminal orelse return .wait;
+ const at = Term.prompt(state);
+ // (Not `declined`: bash's first prompt comes after a D of its own.)
+ if (at.started > 0) return .never;
+ // At a prompt's input (the emulator's semantic marks, pardes's or
+ // the shell's own), before any command pardes's marks saw run.
+ if (!at.input_ready) return .wait;
+ return if (at.input_empty) .now else .never;
+ }
+
+ /// Remembers a line pardes types into this terminal as the command it
+ /// started, for Kill: it runs from the shell's next C mark to its D.
+ /// ponytail: of several lines queued for a shell not up yet, only the
+ /// last is remembered, as the first of them.
+ pub fn noteCommand(pane: *Pane, line: []const u8) void {
+ const state = pane.terminal orelse return;
+ const said = std.mem.trim(u8, line, " \t");
+ const word = said[0 .. std.mem.indexOfAny(u8, said, " \t") orelse said.len];
+ var sent: @typeInfo(@FieldType(Pane, "sent_command")).optional.child = .{ .seq = Term.prompt(state).started +% 1 };
+ sent.len = @intCast(@min(word.len, sent.word.len));
+ @memcpy(sent.word[0..sent.len], word[0..sent.len]);
+ pane.sent_command = sent;
+ }
+
+ /// A line for a shell not ready for it (`pending_command`), queued
+ /// after the ones before it; false when the shell is ready now.
+ pub fn queuePendingCommand(pane: *Pane, command: []const u8) !bool {
+ if (pane.pending_command.wait == .none) return false;
+ const old_len = pane.pending_command.bytes.len;
+ const new_len = try std.math.add(usize, old_len, try std.math.add(usize, command.len, 1));
+ const bytes = if (old_len == 0)
+ try pane.gpa.alloc(u8, new_len)
+ else
+ try pane.gpa.realloc(pane.pending_command.bytes, new_len);
+ @memcpy(bytes[old_len..][0..command.len], command);
+ bytes[new_len - 1] = '\r';
+ pane.pending_command.bytes = bytes;
+ pane.greet = false;
+ return true;
+ }
+
+ /// The lines queued for its shell, written now that it is `ready`.
+ pub fn releasePendingCommand(pane: *Pane, p: *Pardes, id: usize, ready: bool) void {
+ if (!ready) return;
+ const bytes = pane.pending_command.bytes;
+ pane.pending_command = .{};
+ if (bytes.len > 0) {
+ p.emitWrite(id, bytes);
+ pane.gpa.free(bytes);
+ }
+ }
+
/// `run <serial> <word>` or `exit <serial> <N|?>` in the log.
/// The whole line, one record as `msg` carries its text: its control
/// characters, a newline too, become spaces (events.pushLog). A new pane is
@@ -1130,7 +1198,8 @@ pub fn teardownPane(p: *Pardes, pane: *Pane) void {
}
p.shell_rows.dropPane(pane);
for (0..pane.pointer_selections.len) |slot| pane.clearPointerSelection(slot);
- panes.terminal.deinitPendingCommand(pane);
+ if (pane.pending_command.bytes.len > 0) pane.gpa.free(pane.pending_command.bytes);
+ pane.pending_command = .{};
if (pane.command) |line| p.gpa.free(line);
if (pane.shell) |bin| p.gpa.free(bin);
@import("Kind.zig").close(p, pane);
@@ -1194,7 +1263,8 @@ pub fn newShell(p: *Pardes, id: usize, cwd: []const u8) !*Pane {
// shell saying it is there is no rename (`new N /` then `rename`);
// out of memory for it, the shell names it when it says.
if (cwd.len > 0) pane.setOwnedCwd(cwd) catch {};
- panes.terminal.armShellSpawn(pane);
+ std.debug.assert(pane.pending_command.bytes.len == 0);
+ pane.pending_command.wait = .spawn;
p.installPane(id, pane);
p.emitSpawn(id, pane.serial, cwd);
return pane;