//! 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 (`"`), 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 => {}, } p.registers.put(p.gpa, name, text, p.multi_index, p.multi_count, p.multi_first); if (name == '+' and p.multi_first) p.emit(.{ .set_clipboard = {} }); } /// 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 = p.multi_index; 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 { 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. /// Where a paste goes: after the selection, before it, or over it. pub const Paste = enum { after, before, replace }; pub fn pasteRegister(p: *Pardes, t: *Text, how: Paste, 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, panes.paneIdOf(p, pane) orelse return, how); } 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: Paste, }; pub fn clipRequest(p: *Pardes, id: usize, mode: Paste) 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 (panes.promptTarget(p, 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 }; 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 = kept; t.restoreSels(kept_sels[0..kept_n]); } } pub fn clipYank(p: *Pardes, pane: *Pane, main_only: bool) void { // helix's `"+y`: the clipboard register, and only it const named = p.register; p.register = '+'; defer p.register = named; if (comptime pdf_enabled) if (pane.pdf) |pv| { if (pv.selection_text.len > 0) setYank(p, pv.selection_text); return; }; if (pane.body.nsel > 0 and !main_only) { normal.replaySels(p, &pane.body, .{ .normal = .{ .role = .yank } }); } 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, if any pub fn currentSelText(p: *Pardes, pane: *Pane) ?[]const u8 { if (comptime pdf_enabled) if (p.frontend.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 null; return vselText(p, &pane.body); } pub fn exitInsert(p: *Pardes, t: *Text) void { t.mode = .normal; t.reg_wait = 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; 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. if (r + 1 < panes.File.textLineCount(t, eb.text)) return eb; if (b.hi_col < @as(i32, @intCast(panes.File.textLine(t, eb.text, r).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); } /// `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); 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); } /// The file whose text `t` edits in place (File.replace), the bytes it puts /// in and no copy of the text: a file's body, not a live query's (whose /// edits `setEditTextSpan` cuts to its line 1). fn bodyFile(t: *Text) ?*panes.File.State { if (t.what != .body) return null; const pane = t.pane() orelse return null; const f = if (pane.file) |*file| file else return null; if (pane.query) |q| if (!q.frozen) return null; return f; } /// 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.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_count == 1) 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.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 : 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), through the file's // line index when `text` is the file's: finding line 94000 by // counting was most of a keystroke in a 7 MB file. const at = if (c.row < panes.File.textLineCount(t, text)) panes.File.textLineStart(t, text, c.row) + @min(c.col, panes.File.textLine(t, text, c.row).len) else modal.insertOffset(text, c); const end = modal.advanceBy(c, key.text); if (bodyFile(t)) |f| { if (!panes.File.replace(p, f, at, 0, key.text)) return; t.last_edit = .{ .row = @intCast(end.row), .col = @intCast(end.col) }; } else { const new = modal.spliceAlloc(p.gpa, text, at, at, key.text) catch return; setEditTextSpan(p, t, new, end, .{ .head = at, .tail = text.len - at }); } t.cur_row = @as(i32, @intCast(end.row)) + eb.row0; t.cur_col = @intCast(end.col); 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 start = panes.File.textLineStart(t, text, c.row); const line = panes.File.textLine(t, text, c.row); 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 = start + @min(prev, line.len); const e = start + @min(c.col, line.len); if (bodyFile(t)) |f| { // As the whole text put back would be: a no-op edit // when there is nothing before the cursor to take. if (!(if (e > s) panes.File.replace(p, f, s, e - s, "") else panes.File.replace(p, f, text.len, 0, ""))) return; t.last_edit = .{ .row = @intCast(c.row), .col = @intCast(prev) }; } else { 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 at = modal.offsetAt(text, c); const new = modal.spliceAlloc(p.gpa, text, at, modal.nextGrapheme(text, at), "") 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_count == 1 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_ask.seq; p.lspRequest(p.active, .completion, ""); if (p.lsp_ask.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_node_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 text = flatSurface(p, t) catch return ""; const r = t.primaryRange(text, 0); return p.scratch.allocator().dupe(u8, text[@min(r.anchor, r.head)..@max(r.anchor, r.head)]) catch ""; } pub fn normalDelete(p: *Pardes, t: *Text, yank: bool) void { t.select = false; // helix delete exits select mode t.sticky_col = -1; // A bare cursor is the 1-wide selection on its cell (helix), a '\n' // cell too, where the delete joins the lines. if (!t.vsel.active) t.vsel = .{ .active = true, .row = t.cur_row, .col = t.cur_col, .explicit = false }; 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 new = deleteSelection(p, t, eb) orelse return; setEditText(p, t, new); t.cur_row = b.lo_row; t.cur_col = b.lo_col; t.clampCursor(new, eb.row0); } 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; }; setYank(p, if (t.vsel.active) vselText(p, t) else selText(p, t)); } 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.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); const n = modal.lineCount(d); 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, row)); const arena = p.scratch.allocator(); const block = std.fmt.allocPrint(arena, "{s}\n", .{ind}) catch return; const new = modal.insertAt(p.gpa, d, .{ .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.cur_pinned = true; t.mode = .insert; t.normal.clear(); t.show(); return; } setYank(p, vselText(p, t)); pushUndo(p, t); const new = deleteSelection(p, t, eb) orelse return; setEditText(p, t, new); t.cur_row = b.lo_row; t.cur_col = b.lo_col; t.clampCursor(new, eb.row0); t.mode = .insert; t.normal.clear(); return; } pushUndo(p, t); const eb = editTextEol(p, t, selRows(t)) orelse return; const r = t.primaryRange(eb.text, eb.row0); setYank(p, eb.text[r.anchor..r.head]); const new = modal.spliceAlloc(p.gpa, eb.text, r.anchor, r.head, "") catch return; setEditText(p, t, new); const llen = modal.lineSlice(new, @intCast(@max(0, t.cur_row - eb.row0))).len; t.cur_col = @min(t.cur_col, @as(i32, @intCast(llen))); t.mode = .insert; t.normal.clear(); } /// `eb` without the primary range, or null (the selection dropped) when /// there is no memory for it. fn deleteSelection(p: *Pardes, t: *Text, eb: panes.EditText) ?[]u8 { const r = t.primaryRange(eb.text, eb.row0); return modal.spliceAlloc(p.gpa, eb.text, @min(r.anchor, r.head), @max(r.anchor, r.head), "") catch { t.vsel.active = false; return null; }; } /// the rows an op's selection spans, absolute (what editText must cover) fn selRows(t: *Text) Bounds { if (t.vsel.active) return vselBounds(t); return .{ .lo_row = t.cur_row, .lo_col = t.cur_col, .hi_row = t.cur_row, .hi_col = t.cur_col }; } /// `selRows` widened over every range: the rows a one-edit op's buffer /// must cover. fn allSelRows(t: *Text) Bounds { 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)); } return b; } /// Put in `new`, an edit of the buffer whose first line is surface row /// `row0`, and select `cells`, each range's cursor and anchor cells in it. fn setEditCells(p: *Pardes, t: *Text, new: []u8, row0: i32, cells: []const Text.Cells, pri: usize, expl: bool) void { var sels: [Text.max_selections]Text.SelRange = undefined; for (cells, sels[0..cells.len]) |c, *s| { const cc = modal.positionAt(new, c.cur); const ac = modal.positionAt(new, c.anc); s.* = .{ .row = @as(i32, @intCast(cc.row)) + row0, .col = @intCast(cc.col), .arow = @as(i32, @intCast(ac.row)) + row0, .acol = @intCast(ac.col) }; } setEditText(p, t, new); const text = flatSurface(p, t) catch return; var rs: [Text.max_selections]modal.Selection = undefined; for (sels[0..cells.len], rs[0..cells.len]) |s, *r| r.* = Text.cellRange(text, s.arow, s.acol, s.row, s.col); t.setRanges(text, rs[0..cells.len], &.{}, pri, expl); } /// `r`: 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 rep = p.scratch.allocator().alloc(u8, graphemes * encoded_len) catch return; for (0..graphemes) |i| @memcpy(rep[i * encoded_len ..][0..encoded_len], encoded[0..encoded_len]); pushUndo(p, t); const new = modal.spliceAlloc(p.gpa, eb.text, lo, hi, rep) catch return; setEditText(p, t, new); const end = lo + rep.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 = t.primaryRange(eb.text, eb.row0); const lo = @min(r.anchor, r.head); pushUndo(p, t); const new = modal.spliceAlloc(p.gpa, eb.text, lo, @max(r.anchor, r.head), y) catch return; setEditText(p, t, new); const end = lo + y.len; t.setRange(new, eb.row0, if (r.head < r.anchor) .{ .anchor = end, .head = lo } else .{ .anchor = lo, .head = end }, false); } /// `~` / `` ` `` / ``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 = t.primaryRange(eb.text, eb.row0); pushUndo(p, t); const new = modal.changeCase(p.gpa, eb.text, @min(r.anchor, r.head), @max(r.anchor, r.head), 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; // a join always eats the newline of its last line, so the buffer has // to reach one row PAST every range const b = allSelRows(t); 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 = panes.File.textLineCount(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 the file's index const lo = @min(r.anchor, r.head); const hi = @max(r.anchor, r.head); const span = .{ .start = panes.File.textPosition(t, text, lo).row, .end = panes.File.textPosition(t, text, if (lo == hi) hi else @max(modal.prevGrapheme(text, hi), lo)).row }; 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 from = panes.File.textLineStart(t, text, l) + panes.File.textLine(t, text, l).len; var to = if (l + 1 >= nlines) text.len else panes.File.textLineStart(t, text, l + 1); while (to < text.len and (text[to] == ' ' or text[to] == '\t')) to += 1; const last = @min(l + 1, nlines - 1); const sep: []const u8 = if (to == panes.File.textLineStart(t, text, last) + panes.File.textLine(t, text, last).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.Cells = 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; cells[n] = .{ .cur = at, .anc = at }; n += 1; } pri = 0; } if (n == 0) { for (rs[0..got.n], cells[0..got.n]) |r, *cell| { const c = Text.rangeCells(text, r); cell.* = .{ .cur = mapThroughChanges(chs[0..chs_len], c.cur), .anc = mapThroughChanges(chs[0..chs_len], c.anc) }; } n = got.n; pri = got.pri; } setEditCells(p, t, new, eb.row0, cells[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; const eb = editTextEol(p, t, allSelRows(t)) 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.Cells = undefined; var delta: i64 = 0; for (chs[0..n], rs[0..n], cells[0..n]) |ch, r, *cell| { 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; cell.* = Text.rangeCells(new, if (r.anchor > r.head) .{ .anchor = to, .head = from } else .{ .anchor = from, .head = to }); } setEditCells(p, t, new, eb.row0, cells[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; const eb = editTextEol(p, t, allSelRows(t)) 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.Cells = undefined; for (rs[0..n], cells[0..n]) |r, *cell| { const c = Text.rangeCells(text, r); cell.* = .{ .cur = mapThroughChanges(chs[0..m], c.cur), .anc = mapThroughChanges(chs[0..m], c.anc) }; } setEditCells(p, t, new, eb.row0, cells[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.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; t.select = false; // helix exit_select_mode // the buffer must cover every cursor's rows, not just the primary's const b = allSelRows(t); 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.Cells = undefined; const new = sam.apply(p.gpa, text, chs[0..chs_len]) catch return; for (rs[0..got.n], cells[0..got.n]) |r, *cell| cell.* = Text.rangeCells(new, .{ .anchor = mapThroughChanges(chs[0..chs_len], r.anchor), .head = mapThroughChanges(chs[0..chs_len], r.head), }); setEditCells(p, t, new, eb.row0, cells[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 = t.primaryRange(eb.text, eb.row0); const lo = @min(r.anchor, r.head); const hi = @max(r.anchor, r.head); const rep = (modal.incrementDecimal(p.scratch.allocator(), eb.text[lo..hi], delta) catch null) orelse return; pushUndo(p, t); t.select = false; const new = modal.spliceAlloc(p.gpa, eb.text, lo, hi, rep) catch return; setEditText(p, t, new); t.setRange(new, eb.row0, .{ .anchor = lo, .head = lo + rep.len }, false); } /// `]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; } 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`: 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 = t.primaryRange(eb.text, eb.row0); const lo = @min(r.anchor, r.head); const hi = @max(r.anchor, r.head); pushUndo(p, t); const open = [1]u8{pr.o}; const close = [1]u8{pr.c}; const new = sam.apply(p.gpa, eb.text, &.{ .{ .q0 = @intCast(lo), .q1 = @intCast(lo), .text = &open }, .{ .q0 = @intCast(hi), .q1 = @intCast(hi), .text = &close } }) catch return; setEditText(p, t, new); // the wrapped range keeps the direction it had (helix with_direction) t.setRange(new, eb.row0, if (r.head < r.anchor) .{ .anchor = hi + 2, .head = lo } else .{ .anchor = lo, .head = hi + 2 }, false); } /// `md`: 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 }); const new = sam.apply(p.gpa, text, &.{ .{ .q0 = @intCast(a_off), .q1 = @intCast(modal.nextGrapheme(text, a_off)), .text = "" }, .{ .q0 = @intCast(b_off), .q1 = @intCast(modal.nextGrapheme(text, b_off)), .text = "" }, }) 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.cur_pinned = true; t.show(); } /// `mr`: swap the enclosing pair's chars for '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_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); } /// Undo (back) or redo one step of the text's history: its file's, its /// terminal overlay's, or a tag's or header's own. pub fn undoStep(p: *Pardes, t: *Text, back: bool) void { if (t.what == .tag or t.what == .column or t.what == .workspace) return stepOwn(p, t, back); if (t.what != .body) return; const pane = t.pane() orelse return; if (pane.file != null) return panes.File.undoStep(p, pane, back); panes.terminal.undoStep(p, pane, back); } /// 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" { 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, modal.advanceBy(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" { 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(f.line_starts.ptr[0..@max(f.line_cap, f.line_starts.len)]); f.line_starts = &.{}; f.line_cap = 0; 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); } }