summaryrefslogtreecommitdiff
path: root/src/edit.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/edit.zig')
-rw-r--r--src/edit.zig2591
1 files changed, 2591 insertions, 0 deletions
diff --git a/src/edit.zig b/src/edit.zig
new file mode 100644
index 00000000..74dd0d1d
--- /dev/null
+++ b/src/edit.zig
@@ -0,0 +1,2591 @@
+//! Editing a pane's text (acme's text.c): which text a pane edits and how
+//! its lines and cursor map to the screen, insert mode, the d/c/y/p edit
+//! operations, replace, case, join, indent, comments, numbers, textobjects
+//! and surround, undo, yank and paste, and the pointer selections as text.
+const pardes = @import("pardes.zig");
+const tagline = @import("tagline.zig");
+const mouse = @import("mouse.zig");
+const normal = @import("normal.zig");
+const std = @import("std");
+const modal = @import("modal.zig");
+const sam = @import("sam_edit.zig");
+const panes = @import("panes.zig");
+const body_layer = @import("body_layer.zig");
+const config = @import("config.zig");
+const pdf_enabled = panes.Pdf.enabled;
+const lsp = @import("lsp/lsp.zig");
+const syntax = @import("syntax.zig");
+const platform = pardes.platform;
+const Pane = panes.Pane;
+const Text = panes.Text;
+const Layer = @import("Layer.zig");
+const TagHit = pardes.TagHit;
+const BOX_H = pardes.BOX_H;
+const TAG_TEXT_INSET = pardes.TAG_TEXT_INSET;
+const Mouse = pardes.Mouse;
+const Key = pardes.Key;
+const hit = pardes.hit;
+const sel_slot = pardes.sel_slot;
+const Effect = pardes.Effect;
+const Pardes = pardes.Pardes;
+const Registers = pardes.Registers;
+
+/// Write `text` as this range's value of the register the running command
+/// names (`"<reg>`), the default one otherwise. `_` swallows it, and the
+/// registers computed from the editor (`#`, `.`, `%`) cannot be written.
+/// `+` and `*` are the system clipboard: the value is sent there too.
+pub fn setYank(p: *Pardes, text: []const u8) void {
+ var name: u21 = if (p.register != 0) p.register else Registers.default;
+ switch (name) {
+ '_', '#', '.', '%' => return,
+ '*' => name = '+',
+ else => {},
+ }
+ const one = !p.multi_on;
+ p.registers.put(p.gpa, name, text, if (one) 0 else p.multi_index, if (one) 1 else p.multi_count, one or p.multi_first);
+ if (name == '+' and (one or p.multi_first)) p.emit(.{ .set_clipboard = {} });
+}
+
+pub fn setClipboard(p: *Pardes, text: []const u8) void {
+ const named = p.register;
+ p.register = '+';
+ defer p.register = named;
+ setYank(p, text);
+}
+
+/// Value `i` of register `name` as the command at range `i` reads it, the
+/// computed registers included: `#` is the range's number from 1, `.` its
+/// text, `%` the file's name, `_` nothing. Scratch- or register-owned.
+pub fn registerValue(p: *Pardes, t: *Text, name: u21) ?[]const u8 {
+ const i = if (p.multi_on) p.multi_index else 0;
+ return switch (name) {
+ '_' => null,
+ '#' => std.fmt.allocPrint(p.scratch.allocator(), "{d}", .{i + 1}) catch null,
+ '.' => selText(p, t),
+ '%' => if (t.what == .body) if (t.pane()) |pane| (if (pane.file) |f| f.path else null) else null else null,
+ else => p.registers.value(name, i),
+ };
+}
+
+/// the text of the range under the cursor: the selection, or the cursor's
+/// own character
+fn selText(p: *Pardes, t: *Text) []const u8 {
+ if (t.msel.active) return yankRows(p, t, @min(t.msel.r0, t.msel.r1), @max(t.msel.r0, t.msel.r1));
+ const save = t.vsel;
+ defer t.vsel = save;
+ if (!t.vsel.active) t.vsel = .{ .active = true, .row = t.cur_row, .col = t.cur_col, .explicit = false };
+ return vselText(p, t);
+}
+
+/// `p` / `P` / `R` from the register the command names: this range's value
+/// of it. The clipboard's is asked of the shell and pasted when it answers,
+/// once, at the primary.
+pub fn pasteRegister(p: *Pardes, t: *Text, how: enum { after, before, replace }, count: usize) void {
+ const name: u21 = if (p.register != 0) p.register else Registers.default;
+ if (name == '+' or name == '*') {
+ if (!normal.multiOnce(p)) return;
+ const pane = t.pane() orelse return;
+ return clipRequest(p, p.paneIdOf(pane) orelse return, switch (how) {
+ .after => .after,
+ .before => .before,
+ .replace => .replace,
+ });
+ }
+ const y = registerValue(p, t, name) orelse return;
+ switch (how) {
+ .after => pasteText(p, t, y, false, count),
+ .before => pasteText(p, t, y, true, count),
+ .replace => replaceWithText(p, t, y),
+ }
+}
+
+/// Where a `SPC p` / `SPC P` / `SPC R` goes once the shell answers.
+pub const ClipRequest = struct {
+ pane: usize,
+ serial: u32,
+ mode: enum { after, before, replace },
+};
+
+pub fn clipRequest(p: *Pardes, id: usize, mode: @FieldType(ClipRequest, "mode")) void {
+ const pane = p.panes[id] orelse return;
+ p.clip_pending = .{ .pane = id, .serial = pane.serial, .mode = mode };
+ p.emit(.read_clipboard);
+}
+
+/// Text pasted, yanked or sent into the program at `id`, as xterm pastes
+/// (terminal.encodePaste).
+pub fn typeToTty(p: *Pardes, id: usize, pane: *const Pane, text: []const u8) void {
+ if (text.len == 0) return;
+ const cp = p.scratch.allocator().dupe(u8, text) catch return;
+ for (panes.terminal.encodePaste(pane, cp)) |part| if (part.len > 0) p.emitWrite(id, part);
+}
+
+pub fn applyPaste(p: *Pardes, whole: []const u8) void {
+ // Every shell's paste comes through here, bounded: what is past the
+ // limit is left out, at a character's start, and said.
+ const limit = @import("memory.zig").limits.max_paste_bytes;
+ const bytes = if (whole.len > limit) whole[0..modal.graphemeStart(whole, limit)] else whole;
+ if (whole.len > limit) {
+ var said: [96]u8 = undefined;
+ p.setMessage(p.active, std.fmt.bufPrint(&said, "paste cut at its limit, {d} KiB: the rest left out", .{limit / 1024}) catch "paste cut at its limit");
+ }
+ // A prompt answering for a header takes the paste, as it takes keys.
+ const asking = if (p.panes[p.active]) |active| active.prompt != .none else false;
+ if (!asking) if (tagline.focusedHeader(p)) |t| {
+ p.clip_pending = null;
+ return pasteInto(p, t, bytes);
+ };
+ const req = p.clip_pending;
+ p.clip_pending = null;
+ if (bytes.len == 0) return;
+ const id = if (req) |r| r.pane else p.active;
+ const pane = p.panes[id] orelse return;
+ if (req) |r| if (pane.serial != r.serial) return;
+ p.active = id;
+ if (pane.prompt != .none and pane.prompt != .del_side and pane.prompt != .repl_choice) {
+ // an answer is one line: a newline in it would only be submitting it
+ const line = p.scratch.allocator().alloc(u8, bytes.len) catch return;
+ var n: usize = 0;
+ for (bytes) |byte| if (byte != '\n' and byte != '\r') {
+ line[n] = byte;
+ n += 1;
+ };
+ if (n > 0) insertKey(p, &pane.input, .{ .cp = line[0], .text = line[0..n] });
+ if (normal.selRegexArmed(pane)) |a| if (p.promptTarget(pane)) |t| normal.applySelRegex(p, pane, t, a.pat, a.mode);
+ return;
+ }
+ if (pane.focus == .tag) return pasteInto(p, &pane.tag, bytes);
+ if (pane.isTerminal() and pane.body.mode == .tty) return typeToTty(p, id, pane, bytes);
+ switch (if (req) |r| r.mode else .after) {
+ .after => pasteText(p, &pane.body, bytes, false, 1),
+ .before => pasteText(p, &pane.body, bytes, true, 1),
+ .replace => replaceWithText(p, &pane.body, bytes),
+ }
+}
+
+/// A paste into a tag or a header: typed at the caret while it is typed
+/// into, after the cursor's cell in normal mode, as a body's paste is.
+fn pasteInto(p: *Pardes, t: *Text, bytes: []const u8) void {
+ if (bytes.len == 0) return;
+ const typed: pardes.Key = .{ .cp = bytes[0], .text = bytes };
+ if (t.what == .tag and t.mode == .insert) if (t.pane()) |pane| if (tagline.typedIntoName(p, pane, typed)) return;
+ const kept = .{ t.cur_row, t.cur_col, t.vsel, t.msel };
+ var kept_sels: [Text.max_selections - 1]Text.SelRange = undefined;
+ const kept_n = t.nsel;
+ @memcpy(kept_sels[0..kept_n], t.sels[0..kept_n]);
+ t.refused = false;
+ if (t.mode == .insert) insertKey(p, t, typed) else pasteText(p, t, bytes, false, 1);
+ if (t.refused) {
+ t.cur_row, t.cur_col, t.vsel, t.msel = kept;
+ t.restoreSels(kept_sels[0..kept_n]);
+ }
+}
+
+pub fn clipYank(p: *Pardes, pane: *Pane, main_only: bool) void {
+ if (comptime pdf_enabled) if (pane.pdf) |pv| {
+ if (pv.selection_text.len > 0) setClipboard(p, pv.selection_text);
+ return;
+ };
+ // helix's `"+y`: the clipboard register, and only it
+ const named = p.register;
+ p.register = '+';
+ defer p.register = named;
+ if (pane.body.nsel > 0 and !main_only) {
+ normal.replaySels(p, &pane.body, .{ .normal = .{ .edit = .{ .kind = .yank, .count = 1 } } });
+ } else {
+ const others = pane.body.nsel;
+ pane.body.nsel = 0;
+ normalYank(p, &pane.body);
+ pane.body.nsel = others;
+ }
+}
+
+/// tag + '\n' + body: the full selectable pane text, a row to a screen row
+/// (the tag's lines first, the ones it shows)
+pub fn paneText(p: *Pardes, pane: *Pane) ![]u8 {
+ const arena = p.scratch.allocator();
+ const tag = (try tagline.shownTag(p, arena, pane)).text;
+ const from = modal.lineStartOffset(tag, pane.tag_top);
+ const cut = modal.lineStartOffset(tag, pane.tag_top + pane.tag_rows);
+ const shown = if (cut < tag.len) tag[from .. cut - 1] else tag[from..];
+ return std.fmt.allocPrint(arena, "{s}\n{s}", .{ shown, try body_layer.bodyText(p, arena, pane) });
+}
+
+pub fn pointerSourceLine(pane: *Pane, terminal_lines: []const []const u8, row: i32) []const u8 {
+ if (row < 0) return "";
+ if (pane.file != null) return panes.File.sourceLine(pane, row);
+ const index: usize = @intCast(row);
+ return if (index < terminal_lines.len) terminal_lines[index] else "";
+}
+
+pub fn capturePointerSelection(p: *Pardes, pane: *Pane, slot: usize) !void {
+ var gesture = pane.sel[slot];
+ if (pane.hasPdf()) return;
+ if (gesture.state != .done or @min(gesture.r0, gesture.r1) < pane.tag_rows) return;
+ if (pane.pointerSelection(gesture) != null) return;
+ pane.clearPointerSelection(slot);
+ // Refresh the source map before translating the rendered rectangle.
+ const raw = pane.isTerminal() and pane.body.mode == .tty;
+ const body = try body_layer.bodyText(p, p.scratch.allocator(), pane);
+ const terminal_lines = if (pane.file == null and !raw) try panes.terminal.cursorLines(p, pane) else &.{};
+ const first = @max(0, @min(gesture.r0, gesture.r1) - pane.tag_rows);
+ const logical_rows = if (pane.body_rows > 0) pane.body_rows else pane.rows;
+ const last = @min(@as(i32, logical_rows) - 1, @max(gesture.r0, gesture.r1) - pane.tag_rows);
+ if (first > last) return;
+ const rows = try p.gpa.alloc(Pane.PointerRow, @intCast(last - first + 1));
+ errdefer p.gpa.free(rows);
+ const raw_text = if (raw) try p.gpa.dupe(u8, try selectionText(p, pane, gesture)) else null;
+ const prefix: i32 = if (pane.file != null) panes.File.gutterWidth(pane) else 0;
+ for (rows, 0..) |*row, index| {
+ const visible = first + @as(i32, @intCast(index));
+ // A stream: only the first row starts where the press was, and no
+ // row takes in the line numbers; all but the last run on.
+ const cols = sweepCols(gesture, visible + @as(i32, pane.tag_rows)).?;
+ const left: i32 = if (cols.first) @max(cols.lo, prefix) else prefix;
+ const right: i32 = cols.hi orelse std.math.maxInt(i32) / 2;
+ var source = pane.wrapAt(visible);
+ if (raw) source = .{ .line = panes.terminal.gridOffset(pane) + visible, .at = 0 };
+ const line = if (raw) modal.lineSlice(body, @intCast(visible)) else pointerSourceLine(pane, terminal_lines, source.line);
+ var next = pane.wrapAt(visible + 1);
+ if (raw) next = .{ .line = source.line + 1, .at = 0 };
+ const end = if (next.line == source.line) @min(line.len, @as(usize, @intCast(@max(0, next.at)))) else line.len;
+ const start: usize = @intCast(@max(0, source.at));
+ // A file row through its table pads (File.rowPads), as it is drawn.
+ const lo: usize = @min(end, if (pane.file != null and !raw)
+ @as(usize, @intCast(panes.File.byteAtRowDisplay(pane, source.line, source.at, @max(0, left - prefix - source.pad))))
+ else
+ panes.File.byteAtDisplayFrom(line, start, @intCast(@max(0, left - prefix - source.pad))));
+ const at: usize = @min(end, if (pane.file != null and !raw)
+ @as(usize, @intCast(panes.File.byteAtRowDisplay(pane, source.line, source.at, @max(0, right - prefix - source.pad))))
+ else
+ panes.File.byteAtDisplayFrom(line, start, @intCast(@max(0, right - prefix - source.pad))));
+ row.* = .{
+ .row = source.line,
+ .lo = lo,
+ .hi = if (right < prefix) lo else if (cols.hi == null) end else @min(end, modal.nextGrapheme(line, at)),
+ .to_edge = cols.hi == null,
+ .raw_terminal = raw,
+ .prompt_bytes = if (raw) panes.terminal.promptPrefixBytes(pane, source.line, line) else 0,
+ };
+ }
+ pane.next_pointer_selection += 1;
+ gesture.source_id = pane.next_pointer_selection;
+ pane.sel[slot] = gesture;
+ pane.pointer_selections[slot] = .{ .gesture = gesture, .rows = rows, .raw_text = raw_text };
+}
+
+/// block-selected text, newline-joined per row; reads the rendered screen
+/// so typed text and shell output select identically. Scratch-owned.
+pub fn selectionText(p: *Pardes, pane: *Pane, sl: Pane.Sel) ![]const u8 {
+ const arena = p.scratch.allocator();
+ if (pane.rawPointerText(sl)) |text| return arena.dupe(u8, text);
+ if (pane.pointerSelection(sl)) |rows| {
+ const terminal_lines = if (pane.file == null) try panes.terminal.cursorLines(p, pane) else &.{};
+ var total: usize = rows.len -| 1;
+ for (rows) |row| {
+ const line = pointerSourceLine(pane, terminal_lines, row.row);
+ total += @min(row.hi, line.len) - @min(row.lo, line.len);
+ }
+ const result = try arena.alloc(u8, total);
+ var at: usize = 0;
+ for (rows, 0..) |row, index| {
+ if (index > 0) {
+ result[at] = '\n';
+ at += 1;
+ }
+ const line = pointerSourceLine(pane, terminal_lines, row.row);
+ const bytes = line[@min(row.lo, line.len)..@min(row.hi, line.len)];
+ @memcpy(result[at..][0..bytes.len], bytes);
+ at += bytes.len;
+ }
+ return result;
+ }
+ const text = try paneText(p, pane);
+ const shown = try tagline.shownTag(p, arena, pane);
+ var out: std.ArrayList(u8) = .empty;
+ var it = std.mem.splitAny(u8, text, "\n");
+ var v: i32 = 0;
+ var first = true;
+ while (it.next()) |line| : (v += 1) {
+ const cols = sweepCols(sl, v) orelse continue;
+ // A row the tag's wrapping began carries on its text: no newline.
+ const soft = v > 0 and v < pane.tag_rows and std.mem.indexOfScalar(
+ usize,
+ shown.soft,
+ modal.lineStartOffset(shown.text, @as(usize, @intCast(v)) + pane.tag_top) -| 1,
+ ) != null;
+ if (!first and !soft) try out.append(arena, '\n');
+ first = false;
+ // A body row starts after its line numbers, wherever the press was.
+ const gutter: i32 = if (pane.file != null and v >= pane.tag_rows) panes.File.gutterWidth(pane) else 0;
+ const lo: usize = @intCast(if (cols.first) @max(cols.lo, gutter) else gutter);
+ const b0 = @min(panes.File.renderedLineByteCol(pane, v, line, lo), line.len);
+ const b1 = if (cols.hi) |hi|
+ @max(b0, modal.nextGrapheme(line, @min(panes.File.renderedLineByteCol(pane, v, line, @intCast(hi)), line.len)))
+ else
+ line.len;
+ try out.appendSlice(arena, line[b0..b1]);
+ }
+ return out.items;
+}
+
+/// A sweep's columns on `row`, in its Sel space: acme's stream, not a
+/// rectangle (libframe/frselect.c:115-140, frselectpaint): the first row
+/// from the press to its end, the rows between whole, the last from its
+/// start to the release. `hi` null runs to the end of the row.
+pub const SweepCols = struct { lo: i32, hi: ?i32, first: bool };
+
+pub fn sweepCols(sl: Pane.Sel, row: i32) ?SweepCols {
+ const start, const end = sweepEnds(sl);
+ if (row < start[0] or row > end[0]) return null;
+ return .{
+ .lo = if (row == start[0]) @max(0, start[1]) else 0,
+ .hi = if (row == end[0]) @max(0, end[1]) else null,
+ .first = row == start[0],
+ };
+}
+
+/// The sweep's two ends in reading order, each (row, col).
+pub fn sweepEnds(sl: Pane.Sel) struct { [2]i32, [2]i32 } {
+ const fwd = sl.r0 < sl.r1 or (sl.r0 == sl.r1 and sl.c0 <= sl.c1);
+ return if (fwd) .{ .{ sl.r0, sl.c0 }, .{ sl.r1, sl.c1 } } else .{ .{ sl.r1, sl.c1 }, .{ sl.r0, sl.c0 } };
+}
+
+pub fn spanHas(r: i32, c: i32, ar: i32, ac: i32, br: i32, bc: i32) bool {
+ const fwd = ar < br or (ar == br and ac <= bc);
+ const sr, const sc = if (fwd) .{ ar, ac } else .{ br, bc };
+ const er, const ec = if (fwd) .{ br, bc } else .{ ar, ac };
+ return (r > sr or (r == sr and c >= sc)) and (r < er or (r == er and c <= ec));
+}
+
+/// the active modal selection as text (v range or x lines), if any
+pub fn currentSelText(p: *Pardes, pane: *Pane) ?[]const u8 {
+ if (comptime pdf_enabled) if (p.native_images) if (pane.pdf) |pv|
+ if (pv.selection != null and pv.selection_text.len > 0) return pv.selection_text;
+ if (pane.body.vsel.active) return vselText(p, &pane.body);
+ if (!pane.body.msel.active) return null;
+ return yankRows(p, &pane.body, @min(pane.body.msel.r0, pane.body.msel.r1), @max(pane.body.msel.r0, pane.body.msel.r1));
+}
+
+pub fn exitInsert(p: *Pardes, t: *Text) void {
+ t.mode = .normal;
+ t.reg_wait = false;
+ t.msel.active = false;
+ t.normal.clear();
+ if (!t.restore_cursor) return;
+ t.restore_cursor = false;
+ // helix enter_normal_mode: every range, from its start to the char
+ // before its end when it points forward, else to its end
+ const expl = (t.vsel.active and t.vsel.explicit) or t.msel.active;
+ const text = flatSurface(p, t) catch return;
+ var rs: [Text.max_selections]modal.Selection = undefined;
+ const got = t.ranges(text, 0, &rs);
+ for (rs[0..got.n]) |*r| {
+ const from = @min(r.anchor, r.head);
+ const to = @max(r.anchor, r.head);
+ const head = if (r.head > r.anchor) @max(from, modal.prevGrapheme(text, to)) else to;
+ r.* = .{ .anchor = from, .head = head };
+ }
+ t.setRanges(text, rs[0..got.n], &.{}, got.pri, expl);
+}
+
+pub fn paneCursorLines(p: *Pardes, t: *Text) ![]const []const u8 {
+ const arena = p.scratch.allocator();
+ if (t.what != .body) {
+ const text = try flatSurface(p, t);
+ const lines = try arena.alloc([]const u8, std.mem.count(u8, text, "\n") + 1);
+ var it = std.mem.splitScalar(u8, text, '\n');
+ for (lines) |*line| line.* = it.next().?;
+ return lines;
+ }
+ const pane = t.pane() orelse return &.{};
+ if (pane.file) |*f| return panes.File.cursorLines(arena, pane, f);
+ if (pane.hasPdf()) {
+ if (comptime pdf_enabled) return panes.Pdf.textLines(&pane.pdf.?, p.pdf_gpa, arena);
+ unreachable;
+ }
+ return panes.terminal.cursorLines(p, pane);
+}
+
+pub fn paneByteAtDisplay(p: *Pardes, t: *Text, row: i32, from_raw: i32, display_col: i32) i32 {
+ if (t.what == .body) if (t.pane()) |pane| if (pane.file != null)
+ return panes.File.byteAtRowDisplay(pane, row, from_raw, display_col);
+ const lines = paneCursorLines(p, t) catch return @max(0, from_raw + display_col);
+ const local = row;
+ if (local < 0 or @as(usize, @intCast(local)) >= lines.len)
+ return @max(0, from_raw + display_col);
+ return @intCast(panes.File.byteAtDisplayFrom(
+ lines[@intCast(local)],
+ @intCast(@max(0, from_raw)),
+ @intCast(@max(0, display_col)),
+ ));
+}
+
+/// Freeze the live terminal cursor into the modal coordinate space. The
+/// emulator reports screen cells; editing state stores UTF-8 byte offsets.
+pub fn pinPaneCursor(p: *Pardes, t: *Text) void {
+ if (t.cur_pinned) return;
+ // Only a body has a live cursor of someone else's to freeze.
+ if (t.what != .body) {
+ t.cur_pinned = true;
+ return;
+ }
+ const pane = t.pane() orelse return;
+ pane.pinCursor();
+ if (pane.file == null and !pane.hasPdf())
+ t.cur_col = paneByteAtDisplay(p, t, t.cur_row, 0, t.cur_col);
+}
+
+pub fn flatSurface(p: *Pardes, t: *Text) ![]const u8 {
+ switch (t.what) {
+ .body => {},
+ // the tag as it is shown: the keyboard reaches its prefix too
+ .tag => return if (t.pane()) |pane| try tagline.tagText(p, p.scratch.allocator(), pane) else "",
+ .input => return t.own orelse "",
+ .column, .workspace => return t.own orelse tagline.headerDefault(p, t.what),
+ }
+ const pane = t.pane() orelse return "";
+ if (pane.file) |f| return f.content;
+ if (pane.hasPdf()) {
+ if (comptime pdf_enabled) return pane.pdf.?.ensureText(p.pdf_gpa);
+ unreachable;
+ }
+ const lines = try panes.terminal.cursorLines(p, pane);
+ return panes.terminal.flatSurface(p, pane, lines);
+}
+
+pub fn paneWrapWidth(p: *const Pardes, t: *Text) usize {
+ if (t.what != .body) return 0;
+ const pane = t.pane() orelse return 0;
+ if (pane.file == null) return 0;
+ return panes.File.wrapWidth(pane, p.settings.wrap);
+}
+
+/// Route shared edit operations to the characters `t` edits: its own, or
+/// for a body its file's content or its terminal's overlay.
+fn editText(p: *Pardes, t: *Text, lo: i32, hi: i32, col: i32) ?panes.EditText {
+ // A tag or header nobody has changed shows its default; the first edit
+ // makes that default its own text.
+ if (t.what == .tag) {
+ const pane = t.pane() orelse return null;
+ return .{ .text = tagline.tagText(p, p.scratch.allocator(), pane) catch return null, .row0 = 0 };
+ }
+ if (t.what != .body and t.what != .input and t.own == null)
+ t.own = p.gpa.dupe(u8, flatSurface(p, t) catch return null) catch return null;
+ if (t.what != .body) return .{ .text = t.own orelse &.{}, .row0 = 0 };
+ const pane = t.pane() orelse return null;
+ if (pane.file) |f| return .{ .text = f.content, .row0 = 0 };
+ if (pane.image != null or pane.hasPdf()) return null;
+ return panes.terminal.editText(p, pane, lo, hi, col);
+}
+
+fn editTextEol(p: *Pardes, t: *Text, b: Bounds) ?panes.EditText {
+ const eb = editText(p, t, b.lo_row, b.hi_row, -1) orelse return null;
+ const r: usize = @intCast(@max(0, b.hi_row - eb.row0));
+ // A file's own line count and line, from its index.
+ const lines = if (indexedLine(p, t, eb.text, 0) != null) panes.File.nlines(p.gpa, &t.pane().?.file.?) else modal.lineCount(eb.text);
+ if (r + 1 < lines) return eb;
+ if (b.hi_col < @as(i32, @intCast(lineAt(p, t, eb.text, r).line.len))) return eb;
+ return editText(p, t, b.lo_row, b.hi_row + 1, -1);
+}
+
+/// install a rewritten editable text (frees the old one)
+pub fn setEditText(p: *Pardes, t: *Text, new: []u8) void {
+ setEditTextEnd(p, t, new, null);
+}
+
+const LineAt = struct { start: usize, line: []const u8 };
+
+/// `text`'s line count: the file's index when `text` is the pane's file.
+fn lineCountOf(p: *Pardes, t: *Text, text: []const u8) usize {
+ if (indexedLine(p, t, text, 0) != null) return panes.File.nlines(p.gpa, &t.pane().?.file.?);
+ return modal.cursorLineCount(text);
+}
+
+/// The row offset `off` is on: a search of the file's index when `text` is
+/// the pane's file, else the newlines before it counted (modal.lineAtOffset).
+fn rowOf(p: *Pardes, t: *Text, text: []const u8, off: usize) usize {
+ if (indexedLine(p, t, text, 0) != null) {
+ const index = panes.File.lineIndex(p.gpa, &t.pane().?.file.?) catch return modal.lineAtOffset(text, off);
+ return std.sort.upperBound(usize, index, @min(off, text.len), struct {
+ fn order(key: usize, item: usize) std.math.Order {
+ return std.math.order(key, item);
+ }
+ }.order) -| 1;
+ }
+ return modal.lineAtOffset(text, off);
+}
+
+/// Line `row` of `text` and where it starts: through the file's line index
+/// when `text` is the pane's file (a lookup), else counted from the top.
+/// Finding line 94000 by counting was most of a keystroke in a 7 MB file.
+fn lineAt(p: *Pardes, t: *Text, text: []const u8, row: usize) LineAt {
+ return indexedLine(p, t, text, row) orelse .{ .start = modal.lineStartOffset(text, row), .line = modal.lineSlice(text, row) };
+}
+
+/// lineAt's lookup, null when `text` is not the pane's file or `row` is past its last line.
+fn indexedLine(p: *Pardes, t: *Text, text: []const u8, row: usize) ?LineAt {
+ if (t.what != .body) return null;
+ const pane = t.pane() orelse return null;
+ const f = if (pane.file) |*f| f else return null;
+ if (f.content.ptr != text.ptr or f.content.len != text.len) return null;
+ if (row >= panes.File.nlines(p.gpa, f)) return null;
+ const start = @min(panes.File.lineStart(p.gpa, f, row), text.len);
+ const end = std.mem.indexOfScalarPos(u8, text, start, '\n') orelse text.len;
+ return .{ .start = start, .line = text[start..end] };
+}
+
+/// Where text `s` put in at `c` ends: `g.`'s place after typing it.
+fn insertedEnd(c: modal.Cursor, s: []const u8) modal.Cursor {
+ const nl = std.mem.lastIndexOfScalar(u8, s, '\n') orelse return .{ .row = c.row, .col = c.col + s.len };
+ return .{ .row = c.row + std.mem.count(u8, s, "\n"), .col = s.len - nl - 1 };
+}
+
+/// `setEditText` with where the edit ended in `new` (in the edit text's
+/// rows) when the caller knows it, as typing does: then nothing scans the
+/// whole text to find it. Null, it is found by comparing the texts.
+pub fn setEditTextEnd(p: *Pardes, t: *Text, new: []u8, known_end: ?modal.Cursor) void {
+ setEditTextSpan(p, t, new, known_end, null);
+}
+
+/// `setEditTextEnd` with what a file's splice left alone at either end, when
+/// the caller knows it (typing): the line index is then not found again by
+/// comparing the whole old and new texts, which a keystroke in a 7 MB file did.
+fn setEditTextSpan(p: *Pardes, t: *Text, new: []u8, known_end: ?modal.Cursor, span: ?panes.File.Span) void {
+ if (t.what == .tag) {
+ // A tag is edited as it is shown, but only what follows its
+ // prefix is its own: an edit that changed the prefix is refused.
+ // The shown text stays alive until the next such edit, since every
+ // caller reads the new text back, as a body's is kept.
+ defer retireEditText(p, new);
+ const pane = t.pane() orelse return;
+ const prefix = tagline.pathPrefix(p, p.scratch.allocator(), pane) catch return;
+ if (!std.mem.startsWith(u8, new, prefix)) {
+ t.refused = true;
+ return;
+ }
+ const tail = p.gpa.dupe(u8, new[prefix.len..]) catch return;
+ if (t.own) |old| p.gpa.free(old);
+ t.own = tail;
+ return;
+ }
+ if (t.what != .body) {
+ if (t.own) |old| p.gpa.free(old);
+ t.own = new;
+ return;
+ }
+ const pane = t.pane() orelse return retireEditText(p, new);
+ // A live query pane's rows are its line 1's (Query.zig): an edit there
+ // is refused, as a tag's prefix refuses one, and one from line 1 into
+ // them is cut at its end. The rows' metadata stays theirs across an
+ // edit of the line, which moves no row.
+ if (pane.file) |*f| if (pane.query) |q| if (!q.frozen) {
+ const kept = panes.Query.clampEdit(p, t, f.content, new) orelse return retireEditText(p, new);
+ if (kept.ptr != new.ptr) retireEditText(p, new);
+ const end = modal.positionAt(kept, kept.len - panes.File.spanOf(f.content, kept).tail);
+ t.last_edit = .{ .row = @intCast(end.row), .col = @intCast(end.col) };
+ const rows = f.location_rows;
+ const spans = f.pager_spans;
+ f.location_rows = &.{};
+ f.pager_spans = &.{};
+ panes.File.setContentSpan(p, f, kept, null);
+ if (f.location_rows.len > 0) @import("locations.zig").freeRows(p.gpa, f.location_rows);
+ p.gpa.free(f.pager_spans);
+ f.location_rows = rows;
+ f.pager_spans = spans;
+ return;
+ };
+ // what changed ended where the texts agree again from their ends
+ const old: []const u8, const row0: i32 = if (pane.file) |f| .{ f.content, 0 } else if (pane.ovl) |o| .{ o.text, o.row } else .{ "", 0 };
+ // ponytail: O(file), for the edits that do not say what they changed
+ // (paste, a pipe, d, s): compared once, block by block, here; the same
+ // span then spares the line index a second comparison.
+ const found = span orelse if (known_end == null or pane.file != null) panes.File.spanOf(old, new) else null;
+ const end = known_end orelse modal.positionAt(new, new.len - found.?.tail);
+ t.last_edit = .{ .row = @as(i32, @intCast(end.row)) + row0, .col = @intCast(end.col) };
+ if (pane.file) |*f| return panes.File.setContentSpan(p, f, new, found);
+ panes.terminal.setEditText(p, pane, new);
+}
+
+/// Take a text an edit made that nothing keeps, holding it until the next
+/// one: the edit's caller still reads it to place the cursor.
+pub fn retireEditText(p: *Pardes, new: []u8) void {
+ if (p.retired_edit) |old| p.gpa.free(old);
+ p.retired_edit = new;
+}
+
+pub const InsertAt = enum { at, append, line_start, line_end, open_below, open_above };
+
+/// Files insert only inside existing rows and at grapheme boundaries.
+/// Terminal overlays can materialize virtual rows/columns, so keep those.
+pub fn clampFileCursor(t: *Text) bool {
+ if (t.what != .body) return false;
+ const pane = t.pane() orelse return false;
+ const file = if (pane.file) |*file| file else return false;
+ const old_row = t.cur_row;
+ const old_col = t.cur_col;
+ const last = panes.File.nlines(pane.gpa, file) -| 1;
+ t.cur_row = @intCast(@min(last, @as(usize, @intCast(@max(0, t.cur_row)))));
+ const line = panes.File.sourceLine(pane, t.cur_row);
+ t.cur_col = @intCast(modal.graphemeStart(line, @min(line.len, @as(usize, @intCast(@max(0, t.cur_col))))));
+ return old_row != t.cur_row or old_col != t.cur_col;
+}
+
+pub fn enterInsert(p: *Pardes, t: *Text, where: InsertAt, cnt: usize) void {
+ if (t.what == .body) if (t.pane()) |pane| if (pane.hasPdf()) return;
+ pinPaneCursor(p, t);
+ _ = clampFileCursor(t);
+ // snapshot once per insert session (WITH the pre-insert selection) so
+ // `u` undoes the whole session and restores what was selected
+ pushUndo(p, t);
+ t.select = false;
+ t.restore_cursor = false;
+ t.sticky_col = -1;
+ const text = flatSurface(p, t) catch {
+ t.mode = .insert;
+ t.msel.active = false;
+ t.vsel.active = false;
+ t.normal.clear();
+ return;
+ };
+ const cur = t.toModalCursor();
+ const line = panes.File.textLine(t, text, cur.row);
+ const b: ?Bounds = if (t.vsel.active) vselBounds(t) else null;
+ switch (where) {
+ .at => {
+ if (b) |bb| {
+ t.cur_row = bb.lo_row;
+ t.cur_col = bb.lo_col;
+ t.vsel = .{ .active = true, .row = bb.hi_row, .col = bb.hi_col, .explicit = false };
+ t.cur_pinned = true;
+ }
+ },
+ .append => {
+ const lo_row = if (b) |bb| bb.lo_row else t.cur_row;
+ const lo_col = if (b) |bb| bb.lo_col else t.cur_col;
+ const hi_row = if (b) |bb| bb.hi_row else t.cur_row;
+ const hi_col = if (b) |bb| bb.hi_col else t.cur_col;
+ t.restore_cursor = true;
+ const hi = modal.offsetAt(text, .{ .row = @intCast(@max(0, hi_row)), .col = @intCast(@max(0, hi_col)) });
+ const gap = modal.nextGrapheme(text, hi);
+ // helix append_mode: a range that reaches the end of the text
+ // gets a newline after it to append before (a terminal's text
+ // is not the editor's to grow)
+ const terminal = t.what == .body and if (t.pane()) |pane| pane.isTerminal() else false;
+ var now = text;
+ if (hi < text.len and gap >= text.len and !terminal) {
+ const grown = std.mem.concat(p.gpa, u8, &.{ text, "\n" }) catch return;
+ setEditText(p, t, grown);
+ now = grown; // what setEditText keeps; `text` may be gone
+ }
+ const gc = modal.positionAt(now, gap);
+ t.cur_row = @intCast(gc.row);
+ t.cur_col = @intCast(gc.col);
+ // helix append_mode: the range reaches one past its end, which
+ // is where typing goes; a bare cursor becomes a range too
+ t.vsel = .{ .active = true, .row = lo_row, .col = lo_col, .explicit = false };
+ t.cur_pinned = true;
+ },
+ .line_start => {
+ t.fromModalCursor(.{ .row = cur.row, .col = modal.firstNonWs(line) });
+ t.vsel.active = false;
+ },
+ .line_end => {
+ t.cur_col = @intCast(line.len);
+ t.cur_pinned = true;
+ t.vsel.active = false;
+ },
+ .open_below, .open_above => {
+ t.vsel.active = false;
+ const below = where == .open_below;
+ const abs: i32 = if (b) |bb| (if (below) bb.hi_row else bb.lo_row) else t.cur_row;
+ const eb = editText(p, t, abs, abs, -1) orelse return;
+ const row: usize = @intCast(@max(0, abs - eb.row0));
+ const ind = modal.indentText(modal.lineSlice(eb.text, row));
+ const arena = p.scratch.allocator();
+ const block_len = std.math.mul(usize, cnt, ind.len + 1) catch return;
+ const block = arena.alloc(u8, block_len) catch return;
+ var block_at: usize = 0;
+ for (0..cnt) |_| {
+ if (below) {
+ block[block_at] = '\n';
+ block_at += 1;
+ }
+ @memcpy(block[block_at..][0..ind.len], ind);
+ block_at += ind.len;
+ if (!below) {
+ block[block_at] = '\n';
+ block_at += 1;
+ }
+ }
+ const at: modal.Cursor = if (below)
+ .{ .row = row, .col = modal.lineSlice(eb.text, row).len }
+ else
+ .{ .row = row, .col = 0 };
+ const new = modal.insertAt(p.gpa, eb.text, at, block) catch return;
+ setEditText(p, t, new);
+ t.cur_row = @as(i32, @intCast(if (below) row + 1 else row)) + eb.row0;
+ t.cur_col = @intCast(ind.len);
+ t.cur_pinned = true;
+ if (cnt > 1 and !p.multi_on) opened: {
+ const t2 = flatSurface(p, t) catch break :opened;
+ var rs: [Text.max_selections]modal.Selection = undefined;
+ const m = @min(cnt, Text.max_selections);
+ for (0..m) |k| {
+ const o = modal.offsetAt(t2, .{ .row = @intCast(@max(0, t.cur_row) + @as(i32, @intCast(k))), .col = ind.len });
+ rs[k] = .{ .anchor = o, .head = o };
+ }
+ t.setRanges(t2, rs[0..m], &.{}, 0, false);
+ }
+ },
+ }
+ t.mode = .insert;
+ t.msel.active = false;
+ t.normal.clear();
+ t.show();
+}
+
+pub fn handleInsert(p: *Pardes, t: *Text, key: Key) void {
+ if (t.nsel == 0) return insertKey(p, t, key);
+ normal.replaySels(p, t, .{ .insert = key });
+}
+
+pub fn insertKey(p: *Pardes, t: *Text, key: Key) void {
+ // helix aliases: normalize to the base key and re-dispatch
+ if (hit(key, config.insert_backspace_alias)) return insertKey(p, t, .{ .cp = Key.backspace });
+ if (hit(key, config.insert_enter_alias)) return insertKey(p, t, .{ .cp = Key.enter });
+ if (hit(key, config.insert_delete_alias)) return insertKey(p, t, .{ .cp = Key.delete });
+ // Ctrl-r <reg>: type this range's value of the register (helix
+ // insert_register)
+ if (t.reg_wait) {
+ t.reg_wait = false;
+ if (key.ctrl or key.alt or key.cp >= 0xF0000) return;
+ const y = registerValue(p, t, key.cp) orelse return;
+ if (y.len > 0) insertKey(p, t, .{ .cp = key.cp, .text = y });
+ return;
+ }
+ if (hit(key, config.insert_register)) {
+ t.reg_wait = true;
+ return;
+ }
+ // helix commit_undo_checkpoint: `u` after the session goes back to here
+ if (hit(key, config.insert_checkpoint)) return pushUndo(p, t);
+ // helix maps every range through each insert-mode edit (Range::map):
+ // the edits below work on the bare cursor, and the range the cursor
+ // heads is carried through what they did to the text afterwards
+ if (!t.vsel.active) return insertEdit(p, t, key);
+ const old = flatSurface(p, t) catch return insertEdit(p, t, key);
+ const r = t.primaryRange(old, 0);
+ const c = modal.selectionCursor(old, r);
+ const old_len = old.len;
+ const explicit = t.vsel.explicit;
+ t.vsel.active = false;
+ insertEdit(p, t, key);
+ if (t.mode != .insert) return;
+ const new = flatSurface(p, t) catch return;
+ const c2 = modal.offsetAt(new, .{ .row = @intCast(@max(0, t.cur_row)), .col = @intCast(@max(0, t.cur_col)) });
+ // every insert-mode edit happens at the cursor: an insertion there, or
+ // a deletion that ends there (backward) or starts there (forward)
+ if (key.cp == Key.enter) {
+ // helix insert_newline: an appending range stretches by what the
+ // cursor moved, any other slides by it
+ const d = @as(isize, @intCast(c2)) - @as(isize, @intCast(c));
+ const head: usize = @intCast(@as(isize, @intCast(r.head)) + d);
+ const anchor: usize = if (c > r.anchor) r.anchor else @intCast(@as(isize, @intCast(r.anchor)) + d);
+ return setInsertRange(t, new, .{ .anchor = anchor, .head = head }, explicit);
+ }
+ var at: usize = c;
+ var del: usize = 0;
+ var ins: usize = 0;
+ if (new.len > old_len and c2 == c + (new.len - old_len)) {
+ ins = new.len - old_len;
+ } else if (new.len < old_len and c2 + (old_len - new.len) == c) {
+ at = c2;
+ del = old_len - new.len;
+ } else if (new.len < old_len and c2 == c) {
+ del = old_len - new.len;
+ } else if (new.len != old_len or c2 != c) {
+ return; // a motion: the range collapses onto the cursor (helix)
+ }
+ // helix Assoc: the head sticks after an insertion at it when the range
+ // points backward or is empty, the anchor when it points forward
+ const fwd = r.anchor < r.head;
+ setInsertRange(t, new, .{
+ .anchor = mapThroughEdit(r.anchor, at, del, ins, !fwd and r.anchor != r.head),
+ .head = mapThroughEdit(r.head, at, del, ins, fwd),
+ }, explicit);
+}
+
+fn setInsertRange(t: *Text, new: []const u8, mapped: modal.Selection, explicit: bool) void {
+ const cells = Text.rangeCells(new, mapped);
+ const cc = modal.positionAt(new, cells.cur);
+ const ac = modal.positionAt(new, cells.anc);
+ t.cur_row = @intCast(cc.row);
+ t.cur_col = @intCast(cc.col);
+ t.vsel = .{ .active = cells.anc != cells.cur, .row = @intCast(ac.row), .col = @intCast(ac.col), .explicit = explicit };
+}
+
+/// A position through one edit at `at` that deleted `del` bytes and put
+/// `ins` in (one of the two is 0). A position exactly at an insertion stays
+/// before it when `before` is set, else moves past it.
+fn mapThroughEdit(pos: usize, at: usize, del: usize, ins: usize, before: bool) usize {
+ if (pos < at) return pos;
+ if (del > 0) return if (pos < at + del) at else pos - del;
+ if (pos == at and before) return pos;
+ return pos + ins;
+}
+
+fn insertEdit(p: *Pardes, t: *Text, key: Key) void {
+ t.vsel.active = false;
+ if (!t.cur_pinned) pinPaneCursor(p, t);
+ _ = clampFileCursor(t);
+ switch (key.cp) {
+ Key.left, Key.right, Key.up, Key.down => {
+ const lines = paneCursorLines(p, t) catch return;
+ const cur0 = t.toModalCursor();
+ // In a pane's tag, Up on its first line collapses it and Down
+ // on its last expands it, where they would move nothing; acme's
+ // arrows in a tag always do (plan9port text.c:776, Tagdown/Tagup).
+ if (t.what == .tag) if (t.pane()) |pane| {
+ if (key.cp == Key.up and cur0.row == 0) {
+ pane.tag_expanded = false;
+ return;
+ }
+ if (key.cp == Key.down and cur0.row + 1 >= lines.len) {
+ pane.tag_expanded = true;
+ return;
+ }
+ };
+ const nc = switch (key.cp) {
+ Key.left => modal.charLeft(lines, cur0),
+ Key.right => modal.charRight(lines, cur0),
+ Key.up => Text.insertVerticalCursor(lines, cur0, false),
+ Key.down => Text.insertVerticalCursor(lines, cur0, true),
+ else => cur0,
+ };
+ t.fromModalCursor(nc);
+ t.show();
+ return;
+ },
+ Key.page_up, Key.page_down => {
+ // helix binds insert pageup/pagedown to the same view
+ // scroll + cursor snap as normal mode
+ const flat = flatSurface(p, t) catch return;
+ const range = t.primaryRange(flat, 0);
+ if (t.what != .body) return;
+ const step: i32 = @intCast(@max(1, (t.pane() orelse return).rows));
+ t.scrollViewMove(flat, range, if (key.cp == Key.page_down) step else -step);
+ return;
+ },
+ Key.home => {
+ t.cur_col = 0;
+ t.cur_pinned = true;
+ t.show();
+ return;
+ },
+ Key.end => {
+ // helix insert End: past the last char (goto_line_end_newline)
+ const text = flatSurface(p, t) catch return;
+ const cur0 = t.toModalCursor();
+ t.cur_col = @intCast(panes.File.textLine(t, text, cur0.row).len);
+ t.cur_pinned = true;
+ t.show();
+ return;
+ },
+ else => {},
+ }
+ const eb = editText(p, t, t.cur_row, t.cur_row, t.cur_col) orelse return;
+ const text = eb.text;
+ const c = modal.Cursor{ .row = @intCast(@max(0, t.cur_row - eb.row0)), .col = @intCast(@max(0, t.cur_col)) };
+ if (key.text.len > 0 and !key.ctrl and !key.alt) {
+ // insertAt's offset (col clamped to the line), the line found once.
+ const at = if (indexedLine(p, t, text, c.row)) |l| l.start + @min(c.col, l.line.len) else modal.insertOffset(text, c);
+ const new = modal.spliceAlloc(p.gpa, text, at, at, key.text) catch return;
+ setEditTextSpan(p, t, new, insertedEnd(c, key.text), .{ .head = at, .tail = text.len - at });
+ for (key.text) |ch| {
+ if (ch == '\n') {
+ t.cur_row += 1;
+ t.cur_col = 0;
+ } else t.cur_col += 1;
+ }
+ t.cur_pinned = true;
+ t.show();
+ return;
+ }
+ // helix insert-mode kills (word/line; deleteSpan is exclusive)
+ if (hit(key, config.delete_word_backward)) {
+ const e2 = if (c.row == 0 and c.col == 0)
+ (editText(p, t, t.cur_row - 1, t.cur_row, 0) orelse return)
+ else
+ eb;
+ const c2 = modal.Cursor{ .row = @intCast(@max(0, t.cur_row - e2.row0)), .col = c.col };
+ const g = modal.offsetAt(e2.text, c2);
+ if (g == 0) return;
+ const wr = modal.moveWord(e2.text, .{ .anchor = g, .head = g }, 1, .prev_word_start);
+ const from = @min(wr.anchor, wr.head);
+ const fc = modal.positionAt(e2.text, from);
+ const new = modal.deleteSpan(p.gpa, e2.text, fc, c2) catch return;
+ setEditTextEnd(p, t, new, fc);
+ t.cur_row = @as(i32, @intCast(fc.row)) + e2.row0;
+ t.cur_col = @intCast(fc.col);
+ t.cur_pinned = true;
+ t.show();
+ return;
+ }
+ if (hit(key, config.delete_word_forward)) {
+ const e2 = if (c.col >= modal.lineSlice(text, c.row).len and c.row + 1 >= modal.lineCount(text))
+ (editText(p, t, t.cur_row, t.cur_row + 1, t.cur_col) orelse return)
+ else
+ eb;
+ const c2 = modal.Cursor{ .row = @intCast(@max(0, t.cur_row - e2.row0)), .col = c.col };
+ const g = modal.offsetAt(e2.text, c2);
+ const wr = modal.moveWord(e2.text, .{ .anchor = g, .head = g }, 1, .next_word_end);
+ const to = @max(wr.anchor, wr.head);
+ if (to <= g) return;
+ const new = modal.deleteSpan(p.gpa, e2.text, c2, modal.positionAt(e2.text, to)) catch return;
+ setEditTextEnd(p, t, new, c2);
+ t.cur_pinned = true;
+ return;
+ }
+ if (hit(key, config.kill_to_line_start)) {
+ const new = modal.deleteSpan(p.gpa, text, .{ .row = c.row, .col = 0 }, c) catch return;
+ setEditTextEnd(p, t, new, .{ .row = c.row, .col = 0 });
+ t.cur_col = 0;
+ t.cur_pinned = true;
+ t.show();
+ return;
+ }
+ if (hit(key, config.kill_to_line_end)) {
+ const llen = modal.lineSlice(text, c.row).len;
+ const new = modal.deleteSpan(p.gpa, text, c, .{ .row = c.row, .col = llen }) catch return;
+ setEditTextEnd(p, t, new, c);
+ t.cur_pinned = true;
+ return;
+ }
+ switch (key.cp) {
+ Key.enter => {
+ const line = modal.lineSlice(text, c.row);
+ const before = line[0..@min(c.col, line.len)];
+ // helix insert_newline: after nothing but blanks, the line
+ // itself moves down, blanks and all; else the blanks before the
+ // cursor go and the new line takes the indent
+ if (std.mem.indexOfNone(u8, before, " \t") == null) {
+ const new = modal.insertAt(p.gpa, text, .{ .row = c.row, .col = 0 }, "\n") catch return;
+ setEditTextEnd(p, t, new, .{ .row = c.row + 1, .col = 0 });
+ t.cur_row += 1;
+ t.cur_pinned = true;
+ t.show();
+ return;
+ }
+ // The line's own indent, as it is (tabs stay tabs), and a
+ // level more after an opening delimiter: a tab where the
+ // indent is tabs, else spaces.
+ const lead = modal.indentText(line);
+ const more = modal.newlineIndentWidth(line, c.col) - lead.len;
+ const tabbed = std.mem.indexOfScalar(u8, lead, '\t') != null;
+ const indent = lead.len + (if (more == 0) 0 else if (tabbed) 1 else more);
+ const arena = p.scratch.allocator();
+ const block = arena.alloc(u8, 1 + indent) catch return;
+ block[0] = '\n';
+ @memcpy(block[1..][0..lead.len], lead);
+ @memset(block[1 + lead.len ..], if (tabbed) '\t' else ' ');
+ // a tag keeps its blanks: they part its words, and the last
+ // may be its read-only prefix's
+ const kept = if (t.what == .body) std.mem.trimEnd(u8, before, " \t").len else c.col;
+ const cut = modal.deleteSpan(p.gpa, text, .{ .row = c.row, .col = kept }, c) catch return;
+ defer p.gpa.free(cut);
+ const new = modal.insertAt(p.gpa, cut, .{ .row = c.row, .col = kept }, block) catch return;
+ setEditTextEnd(p, t, new, .{ .row = c.row + 1, .col = indent });
+ t.cur_row += 1;
+ t.cur_col = @intCast(indent);
+ t.cur_pinned = true;
+ t.show();
+ },
+ Key.backspace => {
+ if (t.cur_col > 0) {
+ const found = lineAt(p, t, text, c.row);
+ const line = found.line;
+ var prev = modal.prevGrapheme(line, c.col);
+ // in leading blanks, back to the previous indent stop (helix
+ // dedent): a whole unit when on one, else the part past it
+ const lead = line[0..@min(c.col, line.len)];
+ if (std.mem.indexOfNone(u8, lead, " \t") == null and prev < line.len and line[prev] != '\t') {
+ var width: usize = 0;
+ for (lead) |ch| width += if (ch == '\t') modal.INDENT_W else 1;
+ var drop = width % modal.INDENT_W;
+ if (drop == 0) drop = modal.INDENT_W;
+ prev = c.col;
+ while (drop > 0 and prev > 0 and line[prev - 1] == ' ') : (drop -= 1) prev -= 1;
+ }
+ // deleteSpan's splice, the line found once.
+ const s = found.start + @min(prev, line.len);
+ const e = found.start + @min(c.col, line.len);
+ const new = if (e > s) modal.spliceAlloc(p.gpa, text, s, e, "") catch return else p.gpa.dupe(u8, text) catch return;
+ const span: panes.File.Span = if (e > s) .{ .head = s, .tail = text.len - e } else .{ .head = text.len, .tail = 0 };
+ setEditTextSpan(p, t, new, .{ .row = c.row, .col = prev }, span);
+ t.cur_col = @intCast(prev);
+ t.cur_pinned = true;
+ t.show();
+ return;
+ }
+ // at col 0: eat the newline above (join up) — a terminal grows
+ // its buffer over the row it is joining with
+ if (t.cur_row <= 0) return;
+ const e2 = editText(p, t, t.cur_row - 1, t.cur_row, 0) orelse return;
+ const row: usize = @intCast(@max(0, t.cur_row - e2.row0));
+ if (row == 0) return;
+ const prevlen = modal.lineSlice(e2.text, row - 1).len;
+ const new = modal.deleteSpan(p.gpa, e2.text, .{ .row = row - 1, .col = prevlen }, .{ .row = row, .col = 0 }) catch return;
+ setEditTextEnd(p, t, new, .{ .row = row - 1, .col = prevlen });
+ t.cur_row -= 1;
+ t.cur_col = @intCast(prevlen);
+ t.cur_pinned = true;
+ t.show();
+ },
+ Key.delete => {
+ // delete forward; at line end eat the newline (join), which on
+ // a terminal means the buffer swallowing the row below
+ const line = modal.lineSlice(text, c.row);
+ if (c.col < line.len) {
+ const new = modal.deleteChar(p.gpa, text, c) catch return;
+ setEditTextEnd(p, t, new, c);
+ } else {
+ const e2 = editText(p, t, t.cur_row, t.cur_row + 1, t.cur_col) orelse return;
+ const row: usize = @intCast(@max(0, t.cur_row - e2.row0));
+ if (row + 1 >= modal.lineCount(e2.text)) return;
+ const new = modal.deleteSpan(p.gpa, e2.text, .{ .row = row, .col = c.col }, .{ .row = row + 1, .col = 0 }) catch return;
+ setEditTextEnd(p, t, new, .{ .row = row, .col = c.col });
+ }
+ t.cur_pinned = true;
+ },
+ Key.tab => {
+ const ln = modal.lineSlice(text, c.row);
+ if (!p.multi_on and c.col > 0 and c.col <= ln.len and ln[c.col - 1] == '.') dot: {
+ if (t.what != .body) break :dot;
+ const f = (t.pane() orelse break :dot).file orelse break :dot;
+ if (f.output != null or !lsp.speaks(f.path)) break :dot;
+ const seq = p.lsp_seq;
+ p.lspRequest(p.active, .completion, "");
+ if (p.lsp_seq != seq) return;
+ }
+ // helix smart_tab: after text, Tab leaves the syntax node the
+ // cursor is in; only where the file has a grammar, since the
+ // reference pins smart tab off, which a file without one agrees
+ // with. Shift-Tab always types the tab.
+ const after_text = std.mem.indexOfNone(u8, ln[0..@min(c.col, ln.len)], " \t") != null;
+ if (!key.shift and after_text and t.what == .body) smart: {
+ const pane = t.pane() orelse break :smart;
+ const f = pane.file orelse break :smart;
+ if (!syntax.supportsPath(f.path)) break :smart;
+ return normal.nodeSelect(p, pane, t, .parent_end);
+ }
+ insertTab(p, t);
+ },
+ else => {},
+ }
+}
+
+pub fn insertTab(p: *Pardes, t: *Text) void {
+ const eb = editText(p, t, t.cur_row, t.cur_row, t.cur_col) orelse return;
+ const c: modal.Cursor = .{
+ .row = @intCast(@max(0, t.cur_row - eb.row0)),
+ .col = @intCast(@max(0, t.cur_col)),
+ };
+ const pad = modal.INDENT_W - (c.col % modal.INDENT_W);
+ const new = modal.insertAt(p.gpa, eb.text, c, " "[0..pad]) catch return;
+ setEditTextEnd(p, t, new, .{ .row = c.row, .col = c.col + pad });
+ t.cur_col += @intCast(pad);
+ t.cur_pinned = true;
+ t.show();
+}
+
+const Bounds = struct { lo_row: i32, lo_col: i32, hi_row: i32, hi_col: i32 };
+
+/// a range's two cells, normalized to document order
+pub fn cellBounds(s: Text.SelRange) Bounds {
+ if (s.row < s.arow or (s.row == s.arow and s.col < s.acol))
+ return .{ .lo_row = s.row, .lo_col = s.col, .hi_row = s.arow, .hi_col = s.acol };
+ return .{ .lo_row = s.arow, .lo_col = s.acol, .hi_row = s.row, .hi_col = s.col };
+}
+
+/// the char selection [anchor, cursor] normalized to document order
+fn vselBounds(t: *Text) Bounds {
+ return cellBounds(.{ .row = t.cur_row, .col = t.cur_col, .arow = t.vsel.row, .acol = t.vsel.col });
+}
+
+fn vselText(p: *Pardes, t: *Text) []const u8 {
+ const arena = p.scratch.allocator();
+ const b = vselBounds(t);
+ const text = flatSurface(p, t) catch return "";
+ return modal.rangeText(arena, text, .{ .row = @intCast(@max(0, b.lo_row)), .col = @intCast(@max(0, b.lo_col)) }, .{ .row = @intCast(@max(0, b.hi_row)), .col = @intCast(@max(0, b.hi_col)) }) catch "";
+}
+
+/// join surface rows [r0, r1] (absolute) with '\n'; scratch-owned
+fn yankRows(p: *Pardes, t: *Text, r0: i32, r1: i32) []const u8 {
+ const arena = p.scratch.allocator();
+ const lines = paneCursorLines(p, t) catch return "";
+ const rows_count: usize = @intCast(@max(0, r1 - r0 + 1));
+ var total: usize = rows_count -| 1;
+ var i = r0;
+ while (i <= r1) : (i += 1) {
+ if (i >= 0 and @as(usize, @intCast(i)) < lines.len)
+ total += lines[@intCast(i)].len;
+ }
+ const out = arena.alloc(u8, total) catch return "";
+ var at: usize = 0;
+ i = r0;
+ while (i <= r1) : (i += 1) {
+ if (i > r0) {
+ out[at] = '\n';
+ at += 1;
+ }
+ if (i >= 0 and @as(usize, @intCast(i)) < lines.len) {
+ const line = lines[@intCast(i)];
+ @memcpy(out[at..][0..line.len], line);
+ at += line.len;
+ }
+ }
+ return out;
+}
+
+pub fn normalDelete(p: *Pardes, t: *Text, yank: bool) void {
+ t.select = false; // helix delete exits select mode
+ t.sticky_col = -1;
+ if (t.vsel.active) {
+ const b = vselBounds(t);
+ if (yank) setYank(p, vselText(p, t)); // read the range before the move
+ pushUndo(p, t);
+ const eb = editTextEol(p, t, b) orelse {
+ t.vsel.active = false;
+ return;
+ };
+ const d = modal.deleteRange(p.gpa, eb.text, .{ .row = @intCast(@max(0, b.lo_row - eb.row0)), .col = @intCast(@max(0, b.lo_col)) }, .{ .row = @intCast(@max(0, b.hi_row - eb.row0)), .col = @intCast(@max(0, b.hi_col)) }) catch {
+ t.vsel.active = false;
+ return;
+ };
+ setEditText(p, t, d.content);
+ p.gpa.free(d.deleted);
+ t.cur_row = b.lo_row;
+ t.cur_col = b.lo_col;
+ t.clampCursor(d.content, eb.row0);
+ return;
+ }
+ if (t.msel.active) {
+ const r0 = @min(t.msel.r0, t.msel.r1);
+ const r1 = @max(t.msel.r0, t.msel.r1);
+ pushUndo(p, t);
+ // linewise: a line's newline lives on the row below it
+ const eb = editText(p, t, r0, r1 + 1, -1) orelse {
+ t.msel.active = false;
+ return;
+ };
+ const d = modal.deleteLines(p.gpa, eb.text, @intCast(@max(0, r0 - eb.row0)), @intCast(@max(0, r1 - eb.row0))) catch {
+ t.msel.active = false;
+ return;
+ };
+ setEditText(p, t, d.content);
+ if (yank) setYank(p, d.deleted);
+ p.gpa.free(d.deleted);
+ const n = modal.lineCount(d.content);
+ t.cur_row = @as(i32, @intCast(@min(@as(usize, @intCast(@max(0, r0 - eb.row0))), if (n == 0) 0 else n - 1))) + eb.row0;
+ t.cur_col = 0;
+ t.msel.active = false;
+ t.cur_pinned = true;
+ t.show();
+ } else {
+ pushUndo(p, t);
+ const eb = editTextEol(p, t, .{ .lo_row = t.cur_row, .lo_col = t.cur_col, .hi_row = t.cur_row, .hi_col = t.cur_col }) orelse return;
+ const c = modal.Cursor{ .row = @intCast(@max(0, t.cur_row - eb.row0)), .col = @intCast(@max(0, t.cur_col)) };
+ if (yank) {
+ const arena = p.scratch.allocator();
+ setYank(p, modal.rangeText(arena, eb.text, c, c) catch return);
+ }
+ // deleteRange (not deleteChar): the cursor may sit ON a '\n'
+ // cell, where a delete joins the lines (helix 1-wide selection)
+ const d = modal.deleteRange(p.gpa, eb.text, c, c) catch return;
+ setEditText(p, t, d.content);
+ p.gpa.free(d.deleted);
+ const llen = modal.lineSlice(d.content, c.row).len;
+ t.cur_col = @min(t.cur_col, @as(i32, @intCast(llen)));
+ }
+}
+
+pub fn normalYank(p: *Pardes, t: *Text) void {
+ t.select = false;
+ if (t.what == .body) if (t.pane()) |pane| if (pane.rawPointerText(pane.sel[sel_slot])) |text| {
+ setYank(p, text);
+ return;
+ };
+ if (t.vsel.active) {
+ setYank(p, vselText(p, t));
+ return;
+ }
+ if (t.msel.active) {
+ setYank(p, yankRows(p, t, @min(t.msel.r0, t.msel.r1), @max(t.msel.r0, t.msel.r1)));
+ } else {
+ const save = t.vsel;
+ t.vsel = .{ .active = true, .row = t.cur_row, .col = t.cur_col, .explicit = false };
+ setYank(p, vselText(p, t));
+ t.vsel = save;
+ }
+}
+
+pub fn pasteText(p: *Pardes, t: *Text, y0: []const u8, before: bool, count: usize) void {
+ if (y0.len == 0) return;
+ pushUndo(p, t);
+ t.select = false;
+ t.sticky_col = -1;
+ const arena = p.scratch.allocator();
+ var y: []const u8 = y0;
+ if (count > 1) {
+ const total = std.math.mul(usize, count, y0.len) catch return;
+ const buf = arena.alloc(u8, total) catch return;
+ for (0..count) |i| @memcpy(buf[i * y0.len ..][0..y0.len], y0);
+ y = buf;
+ }
+ const b: Bounds = if (t.vsel.active)
+ vselBounds(t)
+ else
+ .{ .lo_row = t.cur_row, .lo_col = t.cur_col, .hi_row = t.cur_row, .hi_col = t.cur_col };
+ const eb = editText(p, t, b.lo_row, b.hi_row, -1) orelse return;
+ const row0 = eb.row0;
+ if (y[y.len - 1] == '\n') {
+ const block_text = y[0 .. y.len - 1];
+ const n = @max(1, modal.lineCount(block_text));
+ var out: []u8 = undefined;
+ if (before) {
+ const row: usize = @intCast(@max(0, b.lo_row - row0));
+ const block = std.fmt.allocPrint(arena, "{s}\n", .{block_text}) catch return;
+ out = modal.insertAt(p.gpa, eb.text, .{ .row = row, .col = 0 }, block) catch return;
+ t.cur_row = @as(i32, @intCast(row + n - 1)) + row0;
+ } else {
+ const row: usize = @intCast(@max(0, b.hi_row - row0));
+ out = modal.pasteLineBelow(p.gpa, eb.text, row, block_text) catch return;
+ t.cur_row = @as(i32, @intCast(row + n)) + row0;
+ }
+ setEditText(p, t, out);
+ t.vsel = .{ .active = true, .row = t.cur_row - @as(i32, @intCast(n - 1)), .col = 0, .explicit = false };
+ // cursor ON the last pasted line's '\n' (helix)
+ const llen = modal.lineSlice(out, @intCast(@max(0, t.cur_row - row0))).len;
+ t.cur_col = @intCast(llen);
+ } else {
+ const at: modal.Cursor = if (before)
+ .{ .row = @intCast(@max(0, b.lo_row - row0)), .col = @intCast(@max(0, b.lo_col)) }
+ else blk: {
+ const hrow: usize = @intCast(@max(0, b.hi_row - row0));
+ const hi_col: usize = @intCast(@max(0, b.hi_col));
+ const high_line = modal.lineSlice(eb.text, hrow);
+ if (hi_col >= high_line.len) break :blk .{ .row = hrow + 1, .col = 0 };
+ const gcol = modal.nextGrapheme(high_line, hi_col);
+ break :blk .{ .row = hrow, .col = gcol };
+ };
+ const out = modal.insertAt(p.gpa, eb.text, at, y) catch return;
+ setEditText(p, t, out);
+ t.vsel = .{ .active = modal.nextGrapheme(y, 0) < y.len, .row = @as(i32, @intCast(at.row)) + row0, .col = @intCast(at.col), .explicit = false };
+ const end = modal.advanceBy(at, y);
+ if (end.col > 0) {
+ t.cur_row = @as(i32, @intCast(end.row)) + row0;
+ t.cur_col = @intCast(modal.prevGrapheme(modal.lineSlice(out, end.row), end.col));
+ } else {
+ t.cur_row = @as(i32, @intCast(end.row -| 1)) + row0;
+ t.cur_col = @intCast(modal.lineSlice(out, end.row -| 1).len);
+ }
+ }
+ t.msel.active = false;
+ t.cur_pinned = true;
+ t.show();
+}
+
+pub fn normalChange(p: *Pardes, t: *Text) void {
+ t.select = false;
+ t.sticky_col = -1;
+ if (t.vsel.active) {
+ const b = vselBounds(t);
+ const eb = editTextEol(p, t, b) orelse return;
+ const hi_len = modal.lineSlice(eb.text, @intCast(@max(0, b.hi_row - eb.row0))).len;
+ if (b.lo_col == 0 and @as(usize, @intCast(@max(0, b.hi_col))) >= hi_len) {
+ setYank(p, vselText(p, t));
+ pushUndo(p, t);
+ const d = modal.deleteLines(p.gpa, eb.text, @intCast(@max(0, b.lo_row - eb.row0)), @intCast(@max(0, b.hi_row - eb.row0))) catch return;
+ setEditText(p, t, d.content);
+ p.gpa.free(d.deleted);
+ const n = modal.lineCount(d.content);
+ const row: usize = @min(@as(usize, @intCast(@max(0, b.lo_row - eb.row0))), if (n == 0) 0 else n - 1);
+ const ind = modal.indentText(modal.lineSlice(d.content, row));
+ const arena = p.scratch.allocator();
+ const block = std.fmt.allocPrint(arena, "{s}\n", .{ind}) catch return;
+ const new = modal.insertAt(p.gpa, d.content, .{ .row = row, .col = 0 }, block) catch return;
+ setEditText(p, t, new);
+ t.cur_row = @as(i32, @intCast(row)) + eb.row0;
+ t.cur_col = @intCast(ind.len);
+ t.vsel.active = false;
+ t.msel.active = false;
+ t.cur_pinned = true;
+ t.mode = .insert;
+ t.normal.clear();
+ t.show();
+ return;
+ }
+ setYank(p, vselText(p, t));
+ pushUndo(p, t);
+ const d = modal.deleteRange(p.gpa, eb.text, .{ .row = @intCast(@max(0, b.lo_row - eb.row0)), .col = @intCast(@max(0, b.lo_col)) }, .{ .row = @intCast(@max(0, b.hi_row - eb.row0)), .col = @intCast(@max(0, b.hi_col)) }) catch {
+ t.vsel.active = false;
+ return;
+ };
+ setEditText(p, t, d.content);
+ p.gpa.free(d.deleted);
+ t.cur_row = b.lo_row;
+ t.cur_col = b.lo_col;
+ t.clampCursor(d.content, eb.row0);
+ t.mode = .insert;
+ t.normal.clear();
+ return;
+ }
+ if (t.msel.active) {
+ const r0 = @min(t.msel.r0, t.msel.r1);
+ const r1 = @max(t.msel.r0, t.msel.r1);
+ pushUndo(p, t);
+ const eb = editText(p, t, r0, r1 + 1, -1) orelse return;
+ const lo: usize = @intCast(@max(0, r0 - eb.row0));
+ const hi: usize = @intCast(@max(0, r1 - eb.row0));
+ // the lines are adjacent in the text already, their newlines and all
+ setYank(p, eb.text[modal.lineStartOffset(eb.text, lo)..modal.lineEndOffset(eb.text, hi)]);
+ var body: []u8 = eb.text;
+ if (hi > lo) {
+ const d = modal.deleteLines(p.gpa, body, lo + 1, hi) catch {
+ t.msel.active = false;
+ return;
+ };
+ setEditText(p, t, d.content);
+ p.gpa.free(d.deleted);
+ body = d.content;
+ }
+ const cl = modal.clearLine(p.gpa, body, lo) catch {
+ t.msel.active = false;
+ return;
+ };
+ setEditText(p, t, cl);
+ t.cur_row = r0;
+ t.cur_col = 0;
+ t.msel.active = false;
+ t.cur_pinned = true;
+ t.mode = .insert;
+ t.normal.clear();
+ t.show();
+ } else {
+ pushUndo(p, t);
+ const eb = editTextEol(p, t, .{ .lo_row = t.cur_row, .lo_col = t.cur_col, .hi_row = t.cur_row, .hi_col = t.cur_col }) orelse return;
+ const c = modal.Cursor{ .row = @intCast(@max(0, t.cur_row - eb.row0)), .col = @intCast(@max(0, t.cur_col)) };
+ const arena = p.scratch.allocator();
+ setYank(p, modal.rangeText(arena, eb.text, c, c) catch return);
+ const d = modal.deleteRange(p.gpa, eb.text, c, c) catch return;
+ setEditText(p, t, d.content);
+ p.gpa.free(d.deleted);
+ const llen = modal.lineSlice(d.content, c.row).len;
+ t.cur_col = @min(t.cur_col, @as(i32, @intCast(llen)));
+ t.mode = .insert;
+ t.normal.clear();
+ }
+}
+
+fn selRange(t: *Text, content: []const u8, row0: i32) modal.Range {
+ if (t.vsel.active) {
+ const b = vselBounds(t);
+ return .{
+ .a = .{ .row = @intCast(@max(0, b.lo_row - row0)), .col = @intCast(@max(0, b.lo_col)) },
+ .b = .{ .row = @intCast(@max(0, b.hi_row - row0)), .col = @intCast(@max(0, b.hi_col)) },
+ };
+ }
+ if (t.msel.active) {
+ const r0: usize = @intCast(@max(0, @min(t.msel.r0, t.msel.r1) - row0));
+ const r1: usize = @intCast(@max(0, @max(t.msel.r0, t.msel.r1) - row0));
+ const llen = modal.lineSlice(content, r1).len;
+ return .{ .a = .{ .row = r0, .col = 0 }, .b = .{ .row = r1, .col = if (llen == 0) 0 else modal.prevGrapheme(modal.lineSlice(content, r1), llen) } };
+ }
+ const c = modal.Cursor{ .row = @intCast(@max(0, t.cur_row - row0)), .col = @intCast(@max(0, t.cur_col)) };
+ return .{ .a = c, .b = c };
+}
+
+/// the rows an op's selection spans, absolute (what editText must cover)
+fn selRows(t: *Text) Bounds {
+ if (t.vsel.active) return vselBounds(t);
+ if (t.msel.active) return .{
+ .lo_row = @min(t.msel.r0, t.msel.r1),
+ .lo_col = 0,
+ .hi_row = @max(t.msel.r0, t.msel.r1),
+ .hi_col = 0,
+ };
+ return .{ .lo_row = t.cur_row, .lo_col = t.cur_col, .hi_row = t.cur_row, .hi_col = t.cur_col };
+}
+
+/// `r<ch>`: overwrite the selection (or the cursor char) with ch —
+/// newlines included (helix), so `xrz` joins the selected lines
+pub fn normalReplaceChar(p: *Pardes, t: *Text, ch: u21) void {
+ t.select = false;
+ const eb = editTextEol(p, t, selRows(t)) orelse return;
+ const before = t.primaryRange(eb.text, eb.row0);
+ const lo = @min(before.anchor, before.head);
+ const hi = @max(before.anchor, before.head);
+ var graphemes: usize = 0;
+ var at = lo;
+ while (at < hi) : (graphemes += 1) at = modal.nextGrapheme(eb.text, at);
+ var encoded: [4]u8 = undefined;
+ const encoded_len = std.unicode.utf8Encode(ch, &encoded) catch return;
+ const r = selRange(t, eb.text, eb.row0);
+ pushUndo(p, t);
+ const new = modal.replaceChars(p.gpa, eb.text, r.a, r.b, ch) catch return;
+ setEditText(p, t, new);
+ const end = lo + graphemes * encoded_len;
+ const mapped: modal.Selection = if (before.head < before.anchor)
+ .{ .anchor = end, .head = lo }
+ else
+ .{ .anchor = lo, .head = end };
+ t.setRange(new, eb.row0, mapped, t.vsel.explicit);
+}
+
+/// `R`: replace the selection (or the cursor char) with the DEFAULT
+/// register. `SPC R` is the same verb over the system clipboard.
+/// The acme chords' replace: the default register as one text.
+pub fn chordReplace(p: *Pardes, t: *Text) void {
+ replaceWithText(p, t, p.registers.text(p.gpa, Registers.default) orelse return);
+}
+
+/// The pasted text becomes the selection, in the direction the replaced one
+/// had: a forward head lands on its last char (which for a trailing-newline
+/// `y` is the '\n' cell of the last full line), a backward one on its first.
+fn replaceWithText(p: *Pardes, t: *Text, y: []const u8) void {
+ if (y.len == 0) return;
+ t.select = false;
+ const eb = editTextEol(p, t, selRows(t)) orelse return;
+ const r = selRange(t, eb.text, eb.row0);
+ const back = t.vsel.active and (t.cur_row < t.vsel.row or (t.cur_row == t.vsel.row and t.cur_col < t.vsel.col));
+ pushUndo(p, t);
+ const new = modal.replaceRange(p.gpa, eb.text, r.a, r.b, y) catch return;
+ setEditText(p, t, new);
+ t.msel.active = false;
+ const end = modal.advanceBy(r.a, y);
+ var last_row: i32 = undefined;
+ var last_col: i32 = undefined;
+ if (end.col > 0) {
+ last_row = @as(i32, @intCast(end.row)) + eb.row0;
+ last_col = @intCast(modal.prevGrapheme(modal.lineSlice(new, end.row), end.col));
+ } else {
+ // the yank ended in '\n': its last cell is that newline
+ last_row = @as(i32, @intCast(end.row -| 1)) + eb.row0;
+ last_col = @intCast(modal.lineSlice(new, end.row -| 1).len);
+ }
+ const first_row = @as(i32, @intCast(r.a.row)) + eb.row0;
+ const first_col: i32 = @intCast(r.a.col);
+ t.vsel = .{
+ .active = modal.nextGrapheme(y, 0) < y.len,
+ .row = if (back) last_row else first_row,
+ .col = if (back) last_col else first_col,
+ .explicit = false,
+ };
+ t.cur_row = if (back) first_row else last_row;
+ t.cur_col = if (back) first_col else last_col;
+ t.cur_pinned = true;
+ t.sticky_col = -1;
+ t.show();
+}
+
+/// `~` / `` ` `` / ``Alt-` ``: case-map the selection (or the cursor char),
+/// keeping the selection (helix)
+pub fn normalCase(p: *Pardes, t: *Text, op: modal.CaseOp) void {
+ t.select = false;
+ const eb = editTextEol(p, t, selRows(t)) orelse return;
+ const r = selRange(t, eb.text, eb.row0);
+ pushUndo(p, t);
+ const new = modal.changeCase(p.gpa, eb.text, r.a, r.b, op) catch return;
+ setEditText(p, t, new);
+}
+
+/// Where `pos` lands after `chs`, which are ascending and disjoint.
+fn mapThroughChanges(chs: []const sam.Op, pos: usize) usize {
+ var delta: i64 = 0;
+ for (chs) |ch| {
+ if (pos < ch.q0) break;
+ if (ch.q0 == ch.q1) {
+ delta += @intCast(ch.text.len);
+ continue;
+ }
+ if (pos == ch.q0) break;
+ if (pos < ch.q1) return @intCast(@as(i64, @intCast(ch.q0)) + delta);
+ delta += @as(i64, @intCast(ch.text.len)) - @as(i64, @intCast(ch.q1 - ch.q0));
+ }
+ return @intCast(@as(i64, @intCast(pos)) + delta);
+}
+
+/// `J` / `Alt-J`: join every range's lines with the next, in ONE edit
+/// (helix join_selections): the newline and the next line's leading blanks
+/// become one space, or nothing when that line is blank, and a line two
+/// ranges share is joined once. `Alt-J` then selects the spaces it put in.
+pub fn normalJoin(p: *Pardes, t: *Text, select_space: bool) void {
+ const expl = (t.vsel.active and t.vsel.explicit) or t.msel.active;
+ // a join always eats the newline of its last line, so the buffer has
+ // to reach one row PAST every range
+ var b = selRows(t);
+ for (t.sels[0..t.nsel]) |s| {
+ b.lo_row = @min(b.lo_row, @min(s.row, s.arow));
+ b.hi_row = @max(b.hi_row, @max(s.row, s.arow));
+ }
+ const eb = editText(p, t, b.lo_row, b.hi_row + 1, -1) orelse return;
+ const text = eb.text;
+ var rs: [Text.max_selections]modal.Selection = undefined;
+ const got = t.ranges(text, eb.row0, &rs);
+ // Lines, their count and rows from the file's index when it has one:
+ // counted from the top, a J in a 7 MB file was 8 ms.
+ const nlines = lineCountOf(p, t, text);
+ const arena = p.scratch.allocator();
+ var changes: std.ArrayList(sam.Op) = .empty;
+ var next: usize = 0; // lines below this one are joined already
+ for (rs[0..got.n]) |r| {
+ // Text.rangeLineSpan, through rowOf
+ const lo = @min(r.anchor, r.head);
+ const hi = @max(r.anchor, r.head);
+ const span = .{ .start = rowOf(p, t, text, lo), .end = rowOf(p, t, text, if (lo == hi) hi else @max(modal.prevGrapheme(text, hi), lo)) };
+ var end = span.end;
+ if (span.start == end) end = @min(end + 1, nlines - 1);
+ var l = @max(span.start, next);
+ while (l < end) : (l += 1) {
+ const here = lineAt(p, t, text, l);
+ const from = here.start + here.line.len;
+ var to = if (l + 1 >= nlines) text.len else lineAt(p, t, text, l + 1).start;
+ while (to < text.len and (text[to] == ' ' or text[to] == '\t')) to += 1;
+ const last = lineAt(p, t, text, @min(l + 1, nlines - 1));
+ const sep: []const u8 = if (to == last.start + last.line.len) "" else " ";
+ changes.append(arena, .{ .q0 = @intCast(from), .q1 = @intCast(to), .text = sep }) catch return;
+ }
+ next = @max(next, end);
+ }
+ const chs = changes.items;
+ const chs_len = chs.len;
+ if (chs_len == 0) return;
+ pushUndo(p, t);
+ const new = sam.apply(p.gpa, text, chs[0..chs_len]) catch return;
+ // every range's cells ride through the edit; Alt-J replaces them with
+ // the spaces, when it put any in
+ var cells: [Text.max_selections]Text.SelRange = undefined;
+ var n: usize = 0;
+ var pri = got.pri;
+ if (select_space) {
+ var delta: i64 = 0;
+ for (chs[0..chs_len]) |ch| {
+ const at: usize = @intCast(@as(i64, @intCast(ch.q0)) + delta);
+ delta += @as(i64, @intCast(ch.text.len)) - @as(i64, @intCast(ch.q1 - ch.q0));
+ if (ch.text.len == 0 or n == cells.len) continue;
+ const pos = modal.positionAt(new, at);
+ cells[n] = .{ .row = @as(i32, @intCast(pos.row)) + eb.row0, .col = @intCast(pos.col), .arow = @as(i32, @intCast(pos.row)) + eb.row0, .acol = @intCast(pos.col) };
+ n += 1;
+ }
+ pri = 0;
+ }
+ if (n == 0) {
+ for (rs[0..got.n]) |r| {
+ const c = Text.rangeCells(text, r);
+ const cc = modal.positionAt(new, mapThroughChanges(chs[0..chs_len], c.cur));
+ const ac = modal.positionAt(new, mapThroughChanges(chs[0..chs_len], c.anc));
+ cells[n] = .{
+ .row = @as(i32, @intCast(cc.row)) + eb.row0,
+ .col = @intCast(cc.col),
+ .arow = @as(i32, @intCast(ac.row)) + eb.row0,
+ .acol = @intCast(ac.col),
+ };
+ n += 1;
+ }
+ pri = got.pri;
+ }
+ setEditText(p, t, new);
+ const t2 = flatSurface(p, t) catch return;
+ for (cells[0..n], 0..) |s, i| rs[i] = Text.cellRange(t2, s.arow, s.acol, s.row, s.col);
+ t.setRanges(t2, rs[0..n], &.{}, pri, expl);
+}
+
+/// `Alt-)` / `Alt-(`: rotate the TEXT of the selections forward / back by
+/// one range (count ranges), in one edit (helix reorder_selection_contents).
+/// Each range comes back over the text it now holds, in its own direction,
+/// and the primary moves with the text it had.
+pub fn normalRotateContents(p: *Pardes, t: *Text, forward: bool, cnt: usize) void {
+ const expl = (t.vsel.active and t.vsel.explicit) or t.msel.active;
+ var b = selRows(t);
+ for (t.sels[0..t.nsel]) |s| {
+ b.lo_row = @min(b.lo_row, @min(s.row, s.arow));
+ b.hi_row = @max(b.hi_row, @max(s.row, s.arow));
+ }
+ const eb = editTextEol(p, t, b) orelse return;
+ const text = eb.text;
+ var rs: [Text.max_selections]modal.Selection = undefined;
+ const got = t.ranges(text, eb.row0, &rs);
+ const n = got.n;
+ if (n < 2) return;
+ const by = @min(cnt, n);
+ var chs: [Text.max_selections]sam.Op = undefined;
+ for (rs[0..n], 0..) |r, i| {
+ const src = rs[if (forward) (i + n - by) % n else (i + by) % n];
+ chs[i] = .{
+ .q0 = @intCast(@min(r.anchor, r.head)),
+ .q1 = @intCast(@max(r.anchor, r.head)),
+ .text = text[@min(src.anchor, src.head)..@max(src.anchor, src.head)],
+ };
+ }
+ pushUndo(p, t);
+ const new = sam.apply(p.gpa, text, chs[0..n]) catch return;
+ var cells: [Text.max_selections]Text.SelRange = undefined;
+ var delta: i64 = 0;
+ for (chs[0..n], rs[0..n], 0..) |ch, r, i| {
+ const from: usize = @intCast(@as(i64, @intCast(ch.q0)) + delta);
+ delta += @as(i64, @intCast(ch.text.len)) - @as(i64, @intCast(ch.q1 - ch.q0));
+ const to = from + ch.text.len;
+ const c = Text.rangeCells(new, if (r.anchor > r.head) .{ .anchor = to, .head = from } else .{ .anchor = from, .head = to });
+ const cc = modal.positionAt(new, c.cur);
+ const ac = modal.positionAt(new, c.anc);
+ cells[i] = .{
+ .row = @as(i32, @intCast(cc.row)) + eb.row0,
+ .col = @intCast(cc.col),
+ .arow = @as(i32, @intCast(ac.row)) + eb.row0,
+ .acol = @intCast(ac.col),
+ };
+ }
+ setEditText(p, t, new);
+ const t2 = flatSurface(p, t) catch return;
+ for (cells[0..n], 0..) |s, i| rs[i] = Text.cellRange(t2, s.arow, s.acol, s.row, s.col);
+ t.setRanges(t2, rs[0..n], &.{}, if (forward) (got.pri + by) % n else (got.pri + n - by) % n, expl);
+}
+
+/// `&`: pad the selections into columns, in one edit (helix
+/// align_selections). The k-th range of every line is a column; spaces go in
+/// before each range so its head lands on the column's widest head, measured
+/// in display cells. A range over several lines aligns nothing.
+pub fn normalAlign(p: *Pardes, t: *Text) void {
+ const expl = (t.vsel.active and t.vsel.explicit) or t.msel.active;
+ var b = selRows(t);
+ for (t.sels[0..t.nsel]) |s| {
+ b.lo_row = @min(b.lo_row, @min(s.row, s.arow));
+ b.hi_row = @max(b.hi_row, @max(s.row, s.arow));
+ }
+ const eb = editTextEol(p, t, b) orelse return;
+ const text = eb.text;
+ var rs: [Text.max_selections]modal.Selection = undefined;
+ const got = t.ranges(text, eb.row0, &rs);
+ const n = got.n;
+ var row: [Text.max_selections]usize = undefined;
+ var col: [Text.max_selections]usize = undefined;
+ var widths: [Text.max_selections]usize = @splat(0);
+ var line: usize = std.math.maxInt(usize);
+ var k: usize = 0;
+ var run: usize = 0;
+ for (rs[0..n], 0..) |r, i| {
+ row[i] = modal.lineAtOffset(text, r.head);
+ if (modal.lineAtOffset(text, r.anchor) != row[i]) return;
+ const ls = modal.lineStartOffset(text, row[i]);
+ col[i] = panes.File.rawDisplayCol(text[ls..modal.lineEndOffset(text, row[i])], r.head - ls);
+ if (row[i] != line) {
+ line = row[i];
+ k = 0;
+ run = 0;
+ }
+ widths[k] = @max(widths[k], col[i] - run);
+ run = col[i];
+ k += 1;
+ }
+ t.select = false; // helix exit_select_mode
+ // each column's head position, left to right
+ for (1..n) |i| widths[i] += widths[i - 1];
+ const arena = p.scratch.allocator();
+ var chs: [Text.max_selections]sam.Op = undefined;
+ var m: usize = 0;
+ line = std.math.maxInt(usize);
+ for (rs[0..n], 0..) |r, i| {
+ if (row[i] != line) {
+ line = row[i];
+ k = 0;
+ run = 0;
+ }
+ const pad = widths[k] - col[i] - run;
+ k += 1;
+ run += pad;
+ if (pad == 0) continue;
+ const spaces = arena.alloc(u8, pad) catch return;
+ @memset(spaces, ' ');
+ const at = @min(r.anchor, r.head);
+ chs[m] = .{ .q0 = @intCast(at), .q1 = @intCast(at), .text = spaces };
+ m += 1;
+ }
+ if (m == 0) return;
+ pushUndo(p, t);
+ const new = sam.apply(p.gpa, text, chs[0..m]) catch return;
+ var cells: [Text.max_selections]Text.SelRange = undefined;
+ for (rs[0..n], 0..) |r, i| {
+ const c = Text.rangeCells(text, r);
+ const cc = modal.positionAt(new, mapThroughChanges(chs[0..m], c.cur));
+ const ac = modal.positionAt(new, mapThroughChanges(chs[0..m], c.anc));
+ cells[i] = .{
+ .row = @as(i32, @intCast(cc.row)) + eb.row0,
+ .col = @intCast(cc.col),
+ .arow = @as(i32, @intCast(ac.row)) + eb.row0,
+ .acol = @intCast(ac.col),
+ };
+ }
+ setEditText(p, t, new);
+ const t2 = flatSurface(p, t) catch return;
+ for (cells[0..n], 0..) |s, i| rs[i] = Text.cellRange(t2, s.arow, s.acol, s.row, s.col);
+ t.setRanges(t2, rs[0..n], &.{}, got.pri, expl);
+}
+
+pub fn normalIndent(p: *Pardes, t: *Text, cnt: usize, add: bool) void {
+ t.select = false;
+ const sr = selRows(t);
+ const eb = editText(p, t, sr.lo_row, sr.hi_row, -1) orelse return;
+ const text = eb.text;
+ const range = t.primaryRange(text, eb.row0);
+ const span = Text.rangeLineSpan(text, range);
+ const arena = p.scratch.allocator();
+ // one run of spaces, sliced per line: `>` never inserts more than this
+ const pad = arena.alloc(u8, modal.INDENT_W * cnt) catch return;
+ @memset(pad, ' ');
+ const chs = arena.alloc(sam.Op, span.end - span.start + 1) catch return;
+ var chs_len: usize = 0;
+ var l = span.start;
+ while (l <= span.end) : (l += 1) {
+ const ls = modal.lineStartOffset(text, l);
+ const le = modal.lineEndOffset(text, l);
+ const line = text[ls..le];
+ const nw = modal.firstNonWs(line);
+ if (nw == line.len) continue; // blank lines stay blank (helix)
+ if (add) {
+ const ins = modal.INDENT_W * cnt - (nw % modal.INDENT_W);
+ chs[chs_len] = .{ .q0 = @intCast(ls), .q1 = @intCast(ls), .text = pad[0..ins] };
+ chs_len += 1;
+ } else {
+ const want = modal.INDENT_W * cnt;
+ var w: usize = 0;
+ var pos: usize = 0;
+ while (pos < line.len) {
+ if (line[pos] == ' ') {
+ w += 1;
+ } else if (line[pos] == '\t') {
+ w = (w / modal.INDENT_W + 1) * modal.INDENT_W;
+ } else break;
+ pos += 1;
+ if (w >= want) break;
+ }
+ if (pos > 0) {
+ chs[chs_len] = .{ .q0 = @intCast(ls), .q1 = @intCast(ls + pos), .text = "" };
+ chs_len += 1;
+ }
+ }
+ }
+ if (chs_len == 0) return;
+ pushUndo(p, t);
+ const cur_off = modal.offsetAt(text, .{ .row = @intCast(@max(0, t.cur_row - eb.row0)), .col = @intCast(@max(0, t.cur_col)) });
+ const anc_off = if (t.vsel.active)
+ modal.offsetAt(text, .{ .row = @intCast(@max(0, t.vsel.row - eb.row0)), .col = @intCast(@max(0, t.vsel.col)) })
+ else
+ cur_off;
+ const new = sam.apply(p.gpa, text, chs[0..chs_len]) catch return;
+ const nc = mapThroughChanges(chs[0..chs_len], cur_off);
+ const na = mapThroughChanges(chs[0..chs_len], anc_off);
+ setEditText(p, t, new);
+ const cc = modal.positionAt(new, nc);
+ const ac = modal.positionAt(new, na);
+ t.cur_row = @as(i32, @intCast(cc.row)) + eb.row0;
+ t.cur_col = @intCast(cc.col);
+ if (t.vsel.active) {
+ t.vsel.row = @as(i32, @intCast(ac.row)) + eb.row0;
+ t.vsel.col = @intCast(ac.col);
+ }
+ t.msel.active = false;
+ t.cur_pinned = true;
+ t.sticky_col = -1;
+ t.show();
+}
+
+pub fn normalToggleComment(p: *Pardes, t: *Text) void {
+ const expl = (t.vsel.active and t.vsel.explicit) or t.msel.active;
+ t.select = false; // helix exit_select_mode
+ // the buffer must cover every cursor's rows, not just the primary's
+ var b = selRows(t);
+ for (t.sels[0..t.nsel]) |s| {
+ b.lo_row = @min(b.lo_row, @min(s.row, s.arow));
+ b.hi_row = @max(b.hi_row, @max(s.row, s.arow));
+ }
+ const surface = flatSurface(p, t) catch return;
+ const last_row = @as(i32, @intCast(panes.File.textLineCount(t, surface))) - 1;
+ const eb = editText(p, t, b.lo_row, @min(b.hi_row + 1, last_row), -1) orelse return;
+ const text = eb.text;
+ var rs: [Text.max_selections]modal.Selection = undefined;
+ const got = t.ranges(text, eb.row0, &rs);
+ const nlines = modal.cursorLineCount(text);
+ const arena = p.scratch.allocator();
+ // the lines the ranges cover, each ONE ONCE and in order (helix's
+ // min_next_line: two cursors on one line comment it once)
+ const lines = arena.alloc(usize, nlines) catch return;
+ var lines_len: usize = 0;
+ var next: usize = 0;
+ for (rs[0..got.n]) |r| {
+ const span = Text.rangeLineSpan(text, r);
+ var l = @max(span.start, next);
+ const end = @min(span.end + 1, nlines);
+ while (l < end) : (l += 1) {
+ lines[lines_len] = l;
+ lines_len += 1;
+ }
+ next = @max(next, end);
+ }
+ const file = if (t.what != .body) null else if (t.pane()) |pane| pane.file else null;
+ const ext = if (file) |f| std.fs.path.extension(f.path) else "";
+ var token: []const u8 = config.comment_token_default;
+ lang: for (config.comment_tokens) |row| {
+ for (row.exts) |e| if (std.ascii.eqlIgnoreCase(ext, e)) {
+ token = row.token;
+ break :lang;
+ };
+ }
+ var commented = true;
+ var indent: usize = std.math.maxInt(usize);
+ var margin: usize = 1;
+ var live: usize = 0;
+ for (lines[0..lines_len]) |l| {
+ const line = text[modal.lineStartOffset(text, l)..modal.lineEndOffset(text, l)];
+ const nw = modal.firstNonWs(line);
+ if (nw == line.len) continue;
+ indent = @min(indent, nw);
+ if (!std.mem.startsWith(u8, line[nw..], token)) commented = false;
+ if (nw + token.len >= line.len or line[nw + token.len] != ' ') margin = 0;
+ live += 1;
+ }
+ if (live == 0) return; // nothing but blank lines
+ const ins = std.fmt.allocPrint(arena, "{s} ", .{token}) catch return;
+ const chs = arena.alloc(sam.Op, lines_len) catch return;
+ var chs_len: usize = 0;
+ for (lines[0..lines_len]) |l| {
+ const ls = modal.lineStartOffset(text, l);
+ const le = modal.lineEndOffset(text, l);
+ const line = text[ls..le];
+ if (modal.firstNonWs(line) == line.len) continue; // blank lines untouched
+ const at = ls + indent;
+ // the @min can never bind: margin is 1 only when every line has a
+ // space after its own token, which is a byte past `at + token.len`
+ chs[chs_len] = if (commented)
+ .{ .q0 = @intCast(at), .q1 = @intCast(@min(at + token.len + margin, le)), .text = "" }
+ else
+ .{ .q0 = @intCast(at), .q1 = @intCast(at), .text = ins };
+ chs_len += 1;
+ }
+ pushUndo(p, t);
+ // one edit, and the WHOLE selection rides through it (helix maps the
+ // selection with the transaction)
+ var cells: [Text.max_selections]Text.SelRange = undefined;
+ const new = sam.apply(p.gpa, text, chs[0..chs_len]) catch return;
+ for (rs[0..got.n], 0..) |r, i| {
+ const c = Text.rangeCells(new, .{
+ .anchor = mapThroughChanges(chs[0..chs_len], r.anchor),
+ .head = mapThroughChanges(chs[0..chs_len], r.head),
+ });
+ const cc = modal.positionAt(new, c.cur);
+ const ac = modal.positionAt(new, c.anc);
+ cells[i] = .{
+ .row = @as(i32, @intCast(cc.row)) + eb.row0,
+ .col = @intCast(cc.col),
+ .arow = @as(i32, @intCast(ac.row)) + eb.row0,
+ .acol = @intCast(ac.col),
+ };
+ }
+ setEditText(p, t, new);
+ const t2 = flatSurface(p, t) catch return;
+ for (cells[0..got.n], 0..) |s, i| rs[i] = Text.cellRange(t2, s.arow, s.acol, s.row, s.col);
+ t.setRanges(t2, rs[0..got.n], &.{}, got.pri, expl);
+}
+
+pub fn normalAdjustNumber(p: *Pardes, t: *Text, delta: i64) void {
+ const eb = editTextEol(p, t, selRows(t)) orelse return;
+ const r = selRange(t, eb.text, eb.row0);
+ const arena = p.scratch.allocator();
+ const frag = modal.rangeText(arena, eb.text, r.a, r.b) catch return;
+ const rep = (modal.incrementDecimal(arena, frag, delta) catch null) orelse return;
+ pushUndo(p, t);
+ t.select = false;
+ const new = modal.replaceRange(p.gpa, eb.text, r.a, r.b, rep) catch return;
+ setEditText(p, t, new);
+ const start = modal.lineStartOffset(new, r.a.row) + r.a.col;
+ const cc = modal.positionAt(new, modal.prevGrapheme(new, start + rep.len));
+ t.vsel = .{ .active = modal.nextGrapheme(rep, 0) < rep.len, .row = @as(i32, @intCast(r.a.row)) + eb.row0, .col = @intCast(r.a.col), .explicit = false };
+ t.msel.active = false;
+ t.cur_row = @as(i32, @intCast(cc.row)) + eb.row0;
+ t.cur_col = @intCast(cc.col);
+ t.cur_pinned = true;
+ t.sticky_col = -1;
+ t.show();
+}
+
+/// `]Space` / `[Space`: add blank lines below/above, the cursor staying
+/// on its text line (the selection rides along)
+pub fn addNewline(p: *Pardes, t: *Text, below: bool, cnt: usize) void {
+ // above the selection's first line, below its last (helix line_range)
+ const sr = selRows(t);
+ const at = if (below) sr.hi_row else sr.lo_row;
+ const eb = editText(p, t, at, at, -1) orelse return;
+ pushUndo(p, t);
+ const row: usize = @intCast(@max(0, at - eb.row0));
+ const arena = p.scratch.allocator();
+ const nl = arena.alloc(u8, cnt) catch return;
+ @memset(nl, '\n');
+ const llen = modal.lineSlice(eb.text, row).len;
+ const new = modal.insertAt(p.gpa, eb.text, .{ .row = row, .col = if (below) llen else 0 }, nl) catch return;
+ setEditText(p, t, new);
+ if (!below) {
+ // the whole selection moved down; stay on it
+ const n: i32 = @intCast(cnt);
+ t.cur_row += n;
+ if (t.vsel.active) t.vsel.row += n;
+ if (t.msel.active) {
+ t.msel.r0 += n;
+ t.msel.r1 += n;
+ }
+ }
+ t.cur_pinned = true;
+ t.show();
+}
+
+/// pair mapping for m-mode: either bracket names the pair; anything else
+/// surrounds with itself (quotes)
+fn pairFor(ch: u21) ?struct { o: u8, c: u8 } {
+ return switch (ch) {
+ '(', ')' => .{ .o = '(', .c = ')' },
+ '[', ']' => .{ .o = '[', .c = ']' },
+ '{', '}' => .{ .o = '{', .c = '}' },
+ '<', '>' => .{ .o = '<', .c = '>' },
+ else => if (ch <= 0x7f) .{ .o = @intCast(ch), .c = @intCast(ch) } else null,
+ };
+}
+
+pub fn textobjectSelect(p: *Pardes, t: *Text, text: []const u8, obj: u21, around: bool) void {
+ const range = t.primaryRange(text, 0);
+ // helix's tree-sitter objects, from the grammar's textobjects query
+ const object: ?modal.Normal.Object = switch (obj) {
+ 'f' => .function,
+ 't' => .class,
+ 'a' => .parameter,
+ 'c' => .comment,
+ 'T' => .@"test",
+ 'e' => .entry,
+ 'x' => .xml_element,
+ else => null,
+ };
+ if (object) |o| {
+ if (t.what != .body) return;
+ const pane = t.pane() orelse return;
+ const f = if (pane.file) |*file| file else return;
+ const tree = normal.fileTree(p, f) orelse return;
+ const s = syntax.objectAt(f.path, tree, text, o, around, modal.selectionCursor(text, range)) orelse return;
+ return t.setRange(text, 0, .{ .anchor = s.from, .head = s.to }, false);
+ }
+ switch (obj) {
+ 'w', 'W' => {
+ const r = modal.selectWord(text, range, around, obj == 'W');
+ return t.setRange(text, 0, r, false);
+ },
+ 'p' => {
+ const r = modal.selectParagraph(text, range, around, 1);
+ return t.setRange(text, 0, r, false);
+ },
+ else => {},
+ }
+ const lines = paneCursorLines(p, t) catch return;
+ const cur = modal.positionAt(text, modal.selectionCursor(text, range));
+ const pair: ?modal.Range = switch (obj) {
+ '\'', '"', '`' => modal.enclosingQuote(lines, cur, @intCast(obj)),
+ '(', ')' => modal.enclosingPair(lines, cur, '(', ')'),
+ '[', ']' => modal.enclosingPair(lines, cur, '[', ']'),
+ '{', '}' => modal.enclosingPair(lines, cur, '{', '}'),
+ '<', '>' => modal.enclosingPair(lines, cur, '<', '>'),
+ else => null,
+ };
+ const pr = pair orelse return;
+ var a = modal.offsetAt(text, pr.a);
+ var head = modal.nextGrapheme(text, modal.offsetAt(text, pr.b));
+ if (!around) {
+ // inside: shrink off the delimiters; an EMPTY pair collapses to
+ // a 1-wide cursor on the closing char (helix)
+ a = modal.nextGrapheme(text, a);
+ head = modal.prevGrapheme(text, head);
+ }
+ t.setRange(text, 0, .{ .anchor = a, .head = head }, false);
+}
+
+/// `ms<ch>`: wrap the selection (or the cursor char) in a pair; the wrap
+/// including the pair becomes the selection
+pub fn surroundAdd(p: *Pardes, t: *Text, ch: u21) void {
+ const pr = pairFor(ch) orelse return;
+ t.select = false;
+ const eb = editTextEol(p, t, selRows(t)) orelse return;
+ const r = selRange(t, eb.text, eb.row0);
+ // the wrapped range keeps the direction it had (helix with_direction)
+ const back = t.vsel.active and (t.cur_row < t.vsel.row or (t.cur_row == t.vsel.row and t.cur_col < t.vsel.col));
+ pushUndo(p, t);
+ const close_col = modal.nextGrapheme(modal.lineSlice(eb.text, r.b.row), r.b.col);
+ var new = modal.insertAt(p.gpa, eb.text, .{ .row = r.b.row, .col = close_col }, &[1]u8{pr.c}) catch return;
+ setEditText(p, t, new);
+ new = modal.insertAt(p.gpa, new, .{ .row = r.a.row, .col = r.a.col }, &[1]u8{pr.o}) catch return;
+ setEditText(p, t, new);
+ const open_row = @as(i32, @intCast(r.a.row)) + eb.row0;
+ const open_col: i32 = @intCast(r.a.col);
+ const close_row = @as(i32, @intCast(r.b.row)) + eb.row0;
+ const close_at: i32 = @intCast(close_col + @as(usize, if (r.a.row == r.b.row) 1 else 0));
+ t.msel.active = false;
+ t.vsel = .{ .active = true, .row = if (back) close_row else open_row, .col = if (back) close_at else open_col, .explicit = false };
+ t.cur_row = if (back) open_row else close_row;
+ t.cur_col = if (back) open_col else close_at;
+ t.cur_pinned = true;
+ t.sticky_col = -1;
+ t.show();
+}
+
+/// `md<ch>`: delete the enclosing pair's chars; the cursor maps through
+pub fn surroundDelete(p: *Pardes, t: *Text, ch: u21) void {
+ const pr = pairFor(ch) orelse return;
+ const lines = paneCursorLines(p, t) catch return;
+ const cur = t.toModalCursor();
+ const r = (if (pr.o == pr.c)
+ modal.enclosingQuote(lines, cur, pr.o)
+ else
+ modal.enclosingPair(lines, cur, pr.o, pr.c)) orelse return;
+ const lo: i32 = @intCast(@min(r.a.row, cur.row));
+ const hi: i32 = @intCast(@max(r.b.row, cur.row));
+ const eb = editText(p, t, lo, hi, -1) orelse return;
+ const text = eb.text;
+ const drow = -eb.row0; // surface row -> buffer row
+ const ra: modal.Cursor = .{ .row = @intCast(@as(i32, @intCast(r.a.row)) + drow), .col = r.a.col };
+ const rb: modal.Cursor = .{ .row = @intCast(@as(i32, @intCast(r.b.row)) + drow), .col = r.b.col };
+ pushUndo(p, t);
+ const a_off = modal.offsetAt(text, ra);
+ const b_off = modal.offsetAt(text, rb);
+ const cur_off = modal.offsetAt(text, .{ .row = @intCast(@as(i32, @intCast(cur.row)) + drow), .col = cur.col });
+ // the close first, so the open's position stays valid
+ var new = modal.deleteChar(p.gpa, text, rb) catch return;
+ setEditText(p, t, new);
+ new = modal.deleteChar(p.gpa, new, ra) catch return;
+ setEditText(p, t, new);
+ var nc = cur_off;
+ if (nc > b_off) nc -= 1;
+ if (nc > a_off) nc -= 1;
+ const cc = modal.positionAt(new, nc);
+ t.cur_row = @as(i32, @intCast(cc.row)) + eb.row0;
+ t.cur_col = @intCast(cc.col);
+ t.vsel.active = false;
+ t.msel.active = false;
+ t.cur_pinned = true;
+ t.show();
+}
+
+/// `mr<from><to>`: swap the enclosing <from> pair's chars for <to>'s
+pub fn surroundReplace(p: *Pardes, t: *Text, from: u21, to: u21) void {
+ const fp = pairFor(from) orelse return;
+ const tp = pairFor(to) orelse return;
+ const lines = paneCursorLines(p, t) catch return;
+ const cur = t.toModalCursor();
+ const r = (if (fp.o == fp.c)
+ modal.enclosingQuote(lines, cur, fp.o)
+ else
+ modal.enclosingPair(lines, cur, fp.o, fp.c)) orelse return;
+ const eb = editText(p, t, @as(i32, @intCast(r.a.row)), @as(i32, @intCast(r.b.row)), -1) orelse return;
+ const drow = -eb.row0; // surface row -> buffer row
+ const ar: usize = @intCast(@as(i32, @intCast(r.a.row)) + drow);
+ const br: usize = @intCast(@as(i32, @intCast(r.b.row)) + drow);
+ pushUndo(p, t);
+ const out = p.gpa.dupe(u8, eb.text) catch return;
+ out[modal.lineStartOffset(out, ar) + r.a.col] = tp.o;
+ out[modal.lineStartOffset(out, br) + r.b.col] = tp.c;
+ setEditText(p, t, out);
+}
+
+pub fn pushUndo(p: *Pardes, t: *Text) void {
+ // one keystroke, one undo step — even when it edited at ten cursors.
+ if (p.multi_on and !p.multi_first) return;
+ switch (t.what) {
+ // A B1 chord took its one undo point when it began (mouse.zig).
+ .body => if (p.chord_hold) return,
+ .tag, .column, .workspace => return t.remember(p.gpa, if (t.own) |own| .{ .text = own } else null),
+ // a prompt's answer is typed once and gone; it keeps no history
+ .input => return,
+ }
+ const pane = t.pane() orelse return;
+ if (pane.file != null) return panes.File.pushUndo(p, pane);
+ panes.terminal.pushUndo(p, pane);
+}
+
+pub fn doUndo(p: *Pardes, t: *Text) void {
+ if (t.what == .tag or t.what == .column or t.what == .workspace) return stepOwn(p, t, true);
+ if (t.what != .body) return;
+ const pane = t.pane() orelse return;
+ if (pane.file != null) return panes.File.undo(p, pane);
+ panes.terminal.undo(p, pane);
+}
+
+pub fn doRedo(p: *Pardes, t: *Text) void {
+ if (t.what == .tag or t.what == .column or t.what == .workspace) return stepOwn(p, t, false);
+ if (t.what != .body) return;
+ const pane = t.pane() orelse return;
+ if (pane.file != null) return panes.File.redo(p, pane);
+ panes.terminal.redo(p, pane);
+}
+
+/// Undo or redo an edit of a text's own characters; stepping back past its
+/// first edit gives a tag its default again.
+fn stepOwn(p: *Pardes, t: *Text, back: bool) void {
+ const to = t.step(p.gpa, if (t.own) |own| .{ .text = own } else null, back) orelse return;
+ if (t.own) |own| p.gpa.free(own);
+ t.own = if (to.ovl) |buffer| buffer.text else null;
+}
+
+const PointerTextSelection = struct {
+ sel: Pane.Sel,
+ on_tag: bool,
+};
+
+pub fn pointerTextSelection(p: *const Pardes, id: usize, col: u16, row: u16, body_hit: ?Mouse.BodyHit, tag_hit: ?TagHit) ?PointerTextSelection {
+ const pane = p.panes[id] orelse return null;
+ const r = p.rects[id];
+ if (col < r.x + config.GUTTER or col >= r.x + r.w or row < r.y or row >= r.y + r.h) return null;
+ const tag_y = p.tagTop(pane, r);
+ const body_y = p.bodyTop(pane, r);
+ const on_tag = row >= tag_y and row < tag_y + pane.tag_rows;
+ if (on_tag and col < r.x + TAG_TEXT_INSET) return null;
+ // A notice chip is chrome: it sits OVER the body's top rows, so a
+ // click inside one belongs to nobody. The rest of those rows is
+ // ordinary body text and still answers normally.
+ if (!on_tag and row >= body_y and row - body_y < pane.notices.span() and
+ pane.notices.covers(row - body_y, col)) return null;
+ if (!on_tag) if (body_hit) |supplied| {
+ const mapped_hit = mouse.bodyHitForPane(p, id, supplied, false) orelse return null;
+ const c = @as(i32, mapped_hit.col) - config.GUTTER;
+ const v = @as(i32, mapped_hit.row) + pane.tag_rows;
+ return .{ .sel = .{ .state = .dragging, .c0 = c, .c1 = c, .r0 = v, .r1 = v }, .on_tag = false };
+ };
+ const tag_col = if (on_tag) Layer.columnAt(p, .pane, id, tag_hit, false, row - tag_y) else null;
+ const c: i32 = (if (tag_col) |value| @as(i32, value) else @as(i32, col) - @as(i32, r.x + (if (on_tag) TAG_TEXT_INSET else config.GUTTER))) +
+ (if (on_tag) @as(i32, pane.tag_scroll) else 0);
+ const v: i32 = if (on_tag) @as(i32, row) - @as(i32, tag_y) else @as(i32, row) - @as(i32, body_y) + @as(i32, pane.tag_rows);
+ return .{
+ .sel = .{ .state = .dragging, .c0 = c, .c1 = c, .r0 = v, .r1 = v },
+ .on_tag = on_tag,
+ };
+}
+
+/// Drain the queue and say whether the shell was asked to do `want`.
+fn drainedEffect(p: *Pardes, want: std.meta.Tag(Effect)) bool {
+ var seen = false;
+ while (p.nextEffect()) |effect| {
+ if (std.meta.activeTag(effect) == want) seen = true;
+ }
+ return seen;
+}
+
+test "insert newline adds one indent level after a closing call" {
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true });
+ defer p.deinit();
+ while (p.nextEffect()) |_| {}
+ const pane = try p.setTestFile(" callback({})\n");
+ pane.body.mode = .insert;
+ pane.body.cur_col = 16;
+
+ p.update(.{ .key = .{ .cp = Key.enter } });
+
+ try std.testing.expectEqualSlices(u8, " callback({})\n \n", pane.file.?.content);
+ try std.testing.expectEqual(@as(i32, 1), pane.body.cur_row);
+ try std.testing.expectEqual(@as(i32, 8), pane.body.cur_col);
+}
+
+test "Enter in insert mode keeps a tab-indented line's tabs, as o and O do" {
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true });
+ defer p.deinit();
+ while (p.nextEffect()) |_| {}
+ const pane = try p.setTestFile("\t\tvalue = 1;\n\tif (x) {\n");
+ pane.body.mode = .insert;
+ pane.body.cur_col = 12;
+ p.update(.{ .key = .{ .cp = Key.enter } });
+ try std.testing.expectEqualStrings("\t\tvalue = 1;\n\t\t\n\tif (x) {\n", pane.file.?.content);
+ try std.testing.expectEqual(@as(i32, 2), pane.body.cur_col);
+ // After an opening brace, a level more: a tab, as the indent is tabs.
+ pane.body.cur_row = 2;
+ pane.body.cur_col = 9;
+ p.update(.{ .key = .{ .cp = Key.enter } });
+ try std.testing.expectEqualStrings("\t\tvalue = 1;\n\t\t\n\tif (x) {\n\t\t\n", pane.file.?.content);
+ // o opens a line with the indent as it is.
+ p.update(.{ .key = .{ .cp = Key.escape } });
+ pane.body.cur_row = 0;
+ p.update(.{ .key = .{ .cp = 'o' } });
+ try std.testing.expect(std.mem.startsWith(u8, pane.file.?.content, "\t\tvalue = 1;\n\t\t\n"));
+}
+
+test "insert on a terminal's text says it edits a copy the program's next drawing replaces" {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true });
+ defer p.deinit();
+ while (p.nextEffect()) |_| {}
+ const pane = p.panes[0].?;
+ if (!pane.isTerminal()) return error.SkipZigTest;
+ pane.body.mode = .normal;
+ p.update(.{ .key = .{ .cp = 'i' } });
+ p.update(.{ .key = .{ .cp = 'x', .text = "x" } });
+ try std.testing.expect(std.mem.indexOf(u8, pane.msg[0..pane.msg_len], "a copy of the terminal's text") != null);
+}
+
+test "insert and normal modes edit complete Unicode graphemes" {
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .cols = 60, .rows = 12 });
+ defer p.deinit();
+ const pane = try p.setTestFile("a" ++ "e\u{301}" ++ "👩🏽\u{200d}🚀" ++ "界" ++ "z");
+
+ pane.body.mode = .insert;
+ pane.body.cur_col = 22; // on z, after the CJK grapheme
+ insertKey(p, &pane.body, .{ .cp = Key.left });
+ try std.testing.expectEqual(@as(i32, 19), pane.body.cur_col);
+ insertKey(p, &pane.body, .{ .cp = Key.left });
+ try std.testing.expectEqual(@as(i32, 4), pane.body.cur_col);
+ insertKey(p, &pane.body, .{ .cp = Key.right });
+ try std.testing.expectEqual(@as(i32, 19), pane.body.cur_col);
+ insertKey(p, &pane.body, .{ .cp = Key.backspace });
+ try std.testing.expectEqualStrings("ae\u{301}界z", pane.file.?.content);
+ try std.testing.expectEqual(@as(i32, 4), pane.body.cur_col);
+
+ pane.body.mode = .normal;
+ pane.body.cur_col = 1;
+ normalDelete(p, &pane.body, false);
+ try std.testing.expectEqualStrings("a界z", pane.file.?.content);
+ try std.testing.expectEqual(@as(i32, 1), pane.body.cur_col);
+ normalReplaceChar(p, &pane.body, 'λ');
+ try std.testing.expectEqualStrings("aλz", pane.file.?.content);
+
+ panes.File.setContent(p, &pane.file.?, try gpa.dupe(u8, "界a"));
+ pane.body.cur_col = 3;
+ pane.body.vsel = .{ .active = true, .row = 0, .col = 0, .explicit = true };
+ normalReplaceChar(p, &pane.body, 'λ');
+ try std.testing.expectEqualStrings("λλ", pane.file.?.content);
+ try std.testing.expectEqual(@as(i32, 2), pane.body.cur_col);
+ try std.testing.expectEqual(@as(i32, 0), pane.body.vsel.col);
+
+ panes.File.setContent(p, &pane.file.?, try gpa.dupe(u8, "界a"));
+ pane.body.cur_col = 0;
+ pane.body.vsel = .{ .active = true, .row = 0, .col = 3, .explicit = true };
+ normalReplaceChar(p, &pane.body, 'λ');
+ try std.testing.expectEqualStrings("λλ", pane.file.?.content);
+ try std.testing.expectEqual(@as(i32, 0), pane.body.cur_col);
+ try std.testing.expectEqual(@as(i32, 2), pane.body.vsel.col);
+}
+
+test "flat text replacement preserves a terminal fragment origin and direction" {
+ const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 60, .rows = 12 });
+ defer p.deinit();
+ p.update(.{ .output = .{ .pane = 0, .bytes = "first\r\nsecond\r\nthird\r\n界a\r\n" } });
+ const pane = p.panes[0].?;
+ pane.body.mode = .normal;
+ pane.body.cur_pinned = true;
+ pane.body.cur_row = 3;
+ pane.body.cur_col = 0;
+ pane.body.vsel = .{ .active = true, .row = 3, .col = 3, .explicit = true };
+ normalReplaceChar(p, &pane.body, 'λ');
+ try std.testing.expectEqual(@as(i32, 3), pane.ovl.?.row);
+ try std.testing.expectEqualStrings("λλ", pane.ovl.?.text);
+ try std.testing.expectEqual(@as(i32, 3), pane.body.cur_row);
+ try std.testing.expectEqual(@as(i32, 0), pane.body.cur_col);
+ try std.testing.expectEqual(@as(i32, 3), pane.body.vsel.row);
+ try std.testing.expectEqual(@as(i32, 2), pane.body.vsel.col);
+ try std.testing.expect(pane.body.vsel.active and pane.body.vsel.explicit);
+ const lines = try paneCursorLines(p, &pane.body);
+ try std.testing.expectEqualStrings("first", lines[0]);
+ try std.testing.expectEqualStrings("λλ", lines[3]);
+ const flat = try flatSurface(p, &pane.body);
+ try std.testing.expect(std.mem.startsWith(u8, flat, "first\nsecond\nthird\nλλ\n"));
+}
+
+test "only the SPC clipboard commands cross to the system clipboard" {
+ if (platform == .web) return;
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml" });
+ defer p.deinit();
+ p.update(.{ .resize = .{ .cols = 80, .rows = 24 } });
+ const pane = p.panes[0].?;
+
+ _ = drainedEffect(p, .set_clipboard);
+ p.update(.{ .key = .{ .cp = 'y' } });
+ const plain = p.registers.text(gpa, Registers.default) orelse return error.MissingYank;
+ try std.testing.expect(plain.len > 0);
+ try std.testing.expect(!drainedEffect(p, .set_clipboard));
+ p.update(.{ .key = .{ .cp = 'd' } });
+ try std.testing.expect(!drainedEffect(p, .set_clipboard));
+
+ // `SPC y` is the one that does: helix's `"+y`, the ordinary yank into
+ // the clipboard register instead of the default one.
+ p.update(.{ .key = .{ .cp = ' ' } });
+ p.update(.{ .key = .{ .cp = 'y' } });
+ const yanked = try gpa.dupe(u8, p.registers.text(gpa, Registers.default) orelse "");
+ defer gpa.free(yanked);
+ const clip: []const u8 = p.registers.text(gpa, '+') orelse "";
+ try std.testing.expect(clip.len > 0);
+ try std.testing.expect(drainedEffect(p, .set_clipboard));
+
+ const before = pane.file.?.content.len;
+ p.update(.{ .key = .{ .cp = ' ' } });
+ p.update(.{ .key = .{ .cp = 'p' } });
+ try std.testing.expect(p.clip_pending != null);
+ try std.testing.expect(drainedEffect(p, .read_clipboard));
+ try std.testing.expectEqual(before, pane.file.?.content.len); // nothing yet
+ p.update(.{ .paste = "PASTED" });
+ try std.testing.expect(p.clip_pending == null);
+ try std.testing.expect(std.mem.indexOf(u8, pane.file.?.content, "PASTED") != null);
+ // ...and it did NOT land in the register on its way past, nor echo back
+ // out to the clipboard it came from.
+ try std.testing.expectEqualStrings(yanked, p.registers.text(gpa, Registers.default) orelse "");
+ try std.testing.expect(!drainedEffect(p, .set_clipboard));
+
+ // An UNSOLICITED paste — the outer terminal's bracketed paste, a Cmd-V —
+ // is the same event with no request behind it, and means paste after.
+ p.update(.{ .paste = "UNASKED" });
+ try std.testing.expect(std.mem.indexOf(u8, pane.file.?.content, "UNASKED") != null);
+ try std.testing.expectEqualStrings(yanked, p.registers.text(gpa, Registers.default) orelse "");
+
+ // A request the shell never answers dies at the next keystroke rather
+ // than firing late into whatever pane is focused by then.
+ p.update(.{ .key = .{ .cp = ' ' } });
+ p.update(.{ .key = .{ .cp = 'P' } });
+ try std.testing.expect(p.clip_pending != null);
+ p.update(.{ .key = .{ .cp = 'l' } });
+ try std.testing.expect(p.clip_pending == null);
+}
+
+/// acme's double-click (plan9port acme text.c:1407, textdoubleclick): from
+/// the point `q` (before the character clicked), the text up to the match
+/// of a bracket just before it or just after it (text.c:1386, `{[(<«` and
+/// their closers), the whole line at a line's start or end, the quoted text
+/// next to `' " \``, else the word, acme's isalnum (util.c:328) run.
+pub fn doubleClickRange(text: []const u8, q_in: usize) [2]usize {
+ const sets = [_][2][]const u21{
+ .{ &.{ '{', '[', '(', '<', 0xab }, &.{ '}', ']', ')', '>', 0xbb } },
+ .{ &.{'\n'}, &.{'\n'} },
+ .{ &.{ '\'', '"', '`' }, &.{ '\'', '"', '`' } },
+ };
+ const q = @min(q_in, text.len);
+ for (sets) |set| {
+ const left, const right = set;
+ // the character to the left, looking right
+ const before = if (q == 0) .{ @as(u21, '\n'), @as(usize, 0) } else runeBefore(text, q);
+ if (std.mem.indexOfScalar(u21, left, before[0])) |k| {
+ var at = q;
+ if (clickMatch(text, before[0], right[k], true, &at)) {
+ const closer = if (before[0] == '\n') 0 else runeLen(right[k]);
+ return .{ q, at - closer };
+ }
+ return .{ q, q };
+ }
+ // the character to the right, looking left
+ const after = if (q == text.len) @as(u21, '\n') else runeAt(text, q);
+ if (std.mem.indexOfScalar(u21, right, after)) |k| {
+ var at = q;
+ if (clickMatch(text, after, left[k], false, &at)) {
+ const q1 = q + @as(usize, @intFromBool(q < text.len and after == '\n'));
+ var q0 = at;
+ if (after != '\n' or at != 0 or (text.len > 0 and text[0] == '\n')) q0 += runeLen(left[k]);
+ return .{ @min(q0, q1), q1 };
+ }
+ return .{ q, q };
+ }
+ }
+ var lo = q;
+ var hi = q;
+ while (hi < text.len and isAlnum(runeAt(text, hi))) hi += std.unicode.utf8ByteSequenceLength(text[hi]) catch 1;
+ while (lo > 0 and isAlnum(runeBefore(text, lo)[0])) lo = runeBefore(text, lo)[1];
+ return .{ lo, hi };
+}
+
+/// acme's textclickmatch (text.c:1457): the nesting match of `cl` by `cr`
+/// from `q`, leaving `q` just past it (forward) or on it (back).
+fn clickMatch(text: []const u8, cl: u21, cr: u21, forward: bool, q: *usize) bool {
+ var nest: usize = 1;
+ while (true) {
+ var c: u21 = undefined;
+ if (forward) {
+ if (q.* >= text.len) break;
+ c = runeAt(text, q.*);
+ q.* += std.unicode.utf8ByteSequenceLength(text[q.*]) catch 1;
+ } else {
+ if (q.* == 0) break;
+ const b = runeBefore(text, q.*);
+ q.* = b[1];
+ c = b[0];
+ }
+ if (c == cr) {
+ nest -= 1;
+ if (nest == 0) return true;
+ } else if (c == cl) nest += 1;
+ }
+ return cl == '\n' and nest == 1;
+}
+
+fn runeLen(c: u21) usize {
+ return std.unicode.utf8CodepointSequenceLength(c) catch 1;
+}
+
+fn runeAt(text: []const u8, at: usize) u21 {
+ const n = std.unicode.utf8ByteSequenceLength(text[at]) catch return text[at];
+ if (at + n > text.len) return text[at];
+ return std.unicode.utf8Decode(text[at..][0..n]) catch text[at];
+}
+
+/// The rune ending at `at`, and where it starts.
+fn runeBefore(text: []const u8, at: usize) struct { u21, usize } {
+ var s = at - 1;
+ while (s > 0 and text[s] & 0xC0 == 0x80 and at - s < 4) s -= 1;
+ return .{ runeAt(text, s), s };
+}
+
+fn isAlnum(c: u21) bool {
+ if (c <= ' ') return false;
+ if (c >= 0x7F and c <= 0xA0) return false;
+ if (c < 0x80 and std.mem.indexOfScalar(u8, "!\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~", @intCast(c)) != null) return false;
+ return true;
+}
+
+test "double-click selects as acme's does" {
+ const t = "fn foo_bar(a, b) {\n x\n}\n";
+ const Case = struct { q: usize, want: []const u8 };
+ for ([_]Case{
+ .{ .q = 4, .want = "foo_bar" }, // in a word
+ .{ .q = 11, .want = "a, b" }, // just after (
+ .{ .q = 15, .want = "a, b" }, // just before )
+ .{ .q = 18, .want = "\n x\n" }, // just after {
+ .{ .q = 0, .want = "fn foo_bar(a, b) {\n" }, // a line's start
+ }) |c| {
+ const r = doubleClickRange(t, c.q);
+ try std.testing.expectEqualStrings(c.want, t[r[0]..r[1]]);
+ }
+ const quoted = "say \"hello there\" now";
+ const r = doubleClickRange(quoted, 5);
+ try std.testing.expectEqualStrings("hello there", quoted[r[0]..r[1]]);
+ const french = "«oui»";
+ const f = doubleClickRange(french, 2);
+ try std.testing.expectEqualStrings("oui", french[f[0]..f[1]]);
+ // a line's end: the whole line, its newline included
+ const lines = "one\ntwo\n";
+ const e = doubleClickRange(lines, 7);
+ try std.testing.expectEqualStrings("two\n", lines[e[0]..e[1]]);
+}
+
+test "a typed edit's known end is where the texts' comparison would find it" {
+ const p = try Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 20, .tty_only = true });
+ defer p.deinit();
+ const pane = try p.setTestFile("one\ntwo three\nfour\n");
+ const t = &pane.body;
+ const cases = [_]struct { at: modal.Cursor, s: []const u8 }{
+ .{ .at = .{ .row = 1, .col = 3 }, .s = "xy" },
+ .{ .at = .{ .row = 0, .col = 0 }, .s = "a\nbc" },
+ .{ .at = .{ .row = 2, .col = 4 }, .s = "\n" },
+ };
+ for (cases) |c| {
+ const base = try p.gpa.dupe(u8, pane.file.?.content);
+ defer p.gpa.free(base);
+ const scanned = try modal.insertAt(p.gpa, base, c.at, c.s);
+ setEditTextEnd(p, t, scanned, null);
+ const by_scan = t.last_edit.?;
+ const known = try modal.insertAt(p.gpa, base, c.at, c.s);
+ setEditTextEnd(p, t, known, insertedEnd(c.at, c.s));
+ try std.testing.expectEqual(by_scan.row, t.last_edit.?.row);
+ try std.testing.expectEqual(by_scan.col, t.last_edit.?.col);
+ }
+}
+
+test "a paste into a terminal is xterm's: bracketed when the program asked, control bytes spaces, so no ESC[201~ ends the brackets early" {
+ if (comptime !panes.terminal.enabled) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .cols = 60, .rows = 16, .tty_only = true });
+ defer p.deinit();
+ var out: std.ArrayList(u8) = .empty;
+ defer out.deinit(gpa);
+ const take = struct {
+ fn f(pp: *Pardes, o: *std.ArrayList(u8)) ![]const u8 {
+ o.clearRetainingCapacity();
+ while (pp.nextEffect()) |effect| {
+ if (effect == .write and effect.write.pane == 0) try o.appendSlice(pp.gpa, effect.write.bytes.slice());
+ }
+ return o.items;
+ }
+ }.f;
+ _ = try take(p, &out);
+ try std.testing.expectEqual(.tty, p.panes[0].?.body.mode);
+ p.update(.{ .paste = "echo a\nb\x03\tc" });
+ try std.testing.expectEqualStrings("echo a\rb \tc", try take(p, &out));
+ p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?2004h" } });
+ _ = try take(p, &out);
+ p.update(.{ .paste = "x\x1b[201~y\n" });
+ try std.testing.expectEqualStrings("\x1b[200~x [201~y\n\x1b[201~", try take(p, &out));
+}
+
+test "a paste past the limit is cut at it, and says so" {
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 });
+ defer p.deinit();
+ const pane = try p.setTestFile("");
+ pane.body.mode = .insert;
+ const limit = @import("memory.zig").limits.max_paste_bytes;
+ const big = try gpa.alloc(u8, limit + 100);
+ defer gpa.free(big);
+ @memset(big, 'x');
+ applyPaste(p, big);
+ try std.testing.expect(pane.file.?.content.len <= limit);
+ try std.testing.expect(pane.file.?.content.len > 0);
+ try std.testing.expect(std.mem.indexOf(u8, pane.msg[0..pane.msg_len], "paste cut") != null);
+}
+
+test "typing and backspace through the line index keep the text and the index as a rebuild has them" {
+ const gpa = std.testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true });
+ defer p.deinit();
+ while (p.nextEffect()) |_| {}
+ const pane = try p.setTestFile("one\n two\n\nthree four\n");
+ pane.body.mode = .insert;
+ var prng: std.Random.DefaultPrng = .init(11);
+ const random = prng.random();
+ for (0..300) |_| {
+ _ = panes.File.lineIndex(gpa, &pane.file.?) catch unreachable;
+ const f = &pane.file.?;
+ const row = random.uintLessThan(usize, panes.File.nlines(gpa, f));
+ const line = modal.lineSlice(f.content, row);
+ pane.body.cur_row = @intCast(row);
+ pane.body.cur_col = @intCast(random.uintLessThan(usize, line.len + 1));
+ pane.body.cur_pinned = true;
+ if (random.boolean()) {
+ insertKey(p, &pane.body, .{ .cp = 'x', .text = "x" });
+ } else {
+ insertKey(p, &pane.body, .{ .cp = Key.backspace });
+ }
+ // the index the edits kept, against one built from the text
+ const kept = try gpa.dupe(usize, try panes.File.lineIndex(gpa, &pane.file.?));
+ defer gpa.free(kept);
+ gpa.free(pane.file.?.line_starts);
+ pane.file.?.line_starts = &.{};
+ try std.testing.expectEqualSlices(usize, try panes.File.lineIndex(gpa, &pane.file.?), kept);
+ }
+}
+
+test "J joins a line with the next, its indent dropped, a space between unless the next is empty" {
+ const gpa = std.testing.allocator;
+ const cases = [_]struct { text: []const u8, row: i32, rows: i32 = 0, want: []const u8 }{
+ .{ .text = "a\n b\nc\n", .row = 0, .want = "a b\nc\n" },
+ .{ .text = "a\n\nc\n", .row = 0, .want = "a\nc\n" },
+ .{ .text = "a\nb", .row = 1, .want = "a\nb" },
+ .{ .text = "one\n\ttwo\nthree\nfour\n", .row = 0, .rows = 2, .want = "one two three\nfour\n" },
+ };
+ for (cases) |case| {
+ const p = try Pardes.init(gpa, .{ .tty_only = true });
+ defer p.deinit();
+ while (p.nextEffect()) |_| {}
+ const pane = try p.setTestFile(case.text);
+ pane.body.mode = .normal;
+ pane.body.cur_row = case.row;
+ pane.body.cur_col = 0;
+ if (case.rows > 0) pane.body.vsel = .{ .active = true, .row = case.row + case.rows, .col = 0, .explicit = true };
+ normalJoin(p, &pane.body, false);
+ try std.testing.expectEqualStrings(case.want, pane.file.?.content);
+ }
+}