neurocyte/flow
neurocyte/flow
1
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge pull request #1 from lulvz/cut-keybinds

Browse source 
Cut keybinds, some copy keybinds too and delete->copy functionality in existing commands
This commit is contained in:
Luís Tavares 2025-02-03 20:18:45 +00:00 • committed by GitHub
commit af9fe4953b
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
2 changed files with 242 additions and 12 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

41
src/keybind/builtin/vim.json
View file

@ -9,12 +9,15 @@
"name": "NORMAL",
"line_numbers": "relative",
"cursor": "block",
"selection": "normal",
"press": [
["b", "move_word_left_vim"],
["w", "move_word_right_vim"],
["W", "move_word_right"],
["B", "move_word_left"],
["e", "move_word_right_end_vim"],
["x", "delete_forward"],
["s", ["delete_forward"], ["enter_mode", "insert"]],
["x", "cut_forward_internal"],
["s", ["cut_forward_internal"], ["enter_mode", "insert"]],
["u", "undo"],
["j", "move_down"],
@ -31,15 +34,15 @@
["O", ["smart_insert_line_before"], ["enter_mode", "insert"]],
["v", "enter_mode", "visual"],
["V", ["move_begin"], ["enter_mode", "visual"], ["select_end"]],
["/", "find"],
["n", "goto_next_match"],
["0", "move_begin"],
["^", "smart_move_begin"],
["$", "move_end"],
[":", "open_command_palette"],
["p", "paste"],
["p", "paste_internal_vim"],
["gd", "goto_definition"],
["gi", "goto_implementation"],
["gy", "goto_type_definition"],
["gg", "move_buffer_begin"],
@ -48,10 +51,12 @@
["G", "move_buffer_end"],
["d$", "delete_to_end"],
["dd", "cut"],
["dw", "cut_word_right_vim"],
["db", "cut_word_left_vim"],
["dd", "cut_internal_vim"],
["\"_dd", "delete_line"],
["yy", "copy_line"],
["yy", ["copy_line_internal_vim"], ["cancel"]],
["<C-u>", "move_scroll_page_up"],
["<C-d>", "move_scroll_page_down"],
@ -61,10 +66,12 @@
["<C-i>", "jump_forward"],
["<C-y>", "redo"],
["/", "find"],
["<C-k>", "TODO"],
["<C-CR>", "smart_insert_line_after"],
["<CR>", "smart_insert_line"]
["<C-CR>", ["move_down"], ["move_begin"]],
["<CR>", ["move_down"], ["move_begin"]]
]
},
"visual": {
@ -72,13 +79,20 @@
"on_match_failure": "ignore",
"name": "VISUAL",
"line_numbers": "relative",
"cursor": "underline",
"cursor": "block",
"selection": "normal",
"press": [
["<Esc>", "enter_mode", "normal"],
["k", "select_up"],
["j", "select_down"],
["h", "select_left"],
["l", "select_right"]
["l", "select_right"],
["y", ["copy_internal_vim"], ["cancel"], ["enter_mode", "normal"]],
["x", ["cut_forward_internal"], ["cancel"], ["enter_mode", "normal"]],
["d", ["cut_forward_internal"], ["cancel"], ["enter_mode", "normal"]],
["s", ["cut_forward_internal"], ["cancel"], ["enter_mode", "insert"]]
]
},
"insert": {
@ -91,7 +105,10 @@
["<Esc>", "enter_mode", "normal"],
["<Del>", "delete_forward"],
["<BS>", "delete_backward"],
["<CR>", "insert_line_after"]
["<CR>", "smart_insert_line"],
["<C-BS>", "delete_word_left"],
["<C-Del", "delete_word_right"]
]
},
"home": {

213
src/tui/editor.zig
View file

@ -2364,6 +2364,12 @@ pub const Editor = struct {
}
}
fn set_clipboard_internal(self: *Self, text: []const u8) void {
if (self.clipboard) |old|
self.allocator.free(old);
self.clipboard = text;
}
fn copy_selection(root: Buffer.Root, sel: Selection, text_allocator: Allocator, metrics: Buffer.Metrics) ![]u8 {
var size: usize = 0;
_ = try root.get_range(sel, null, &size, null, metrics);
@ -2411,6 +2417,81 @@ pub const Editor = struct {
return root_;
}
fn insert_line_vim(self: *Self, root: Buffer.Root, cursel: *CurSel, s: []const u8, allocator: Allocator) !Buffer.Root {
var root_ = if (cursel.selection) |_| try self.delete_selection(root, cursel, allocator) else root;
const cursor = &cursel.cursor;
const begin = cursel.cursor;
_, _, root_ = try root_.insert_chars(cursor.row, cursor.col, s, allocator, self.metrics);
cursor.target = cursor.col;
self.nudge_insert(.{ .begin = begin, .end = cursor.* }, cursel, s.len);
return root_;
}
fn cut_to(self: *Self, move: cursor_operator_const, root_: Buffer.Root) !struct { []const u8, Buffer.Root } {
var all_stop = true;
var root = root_;
var text = std.ArrayList(u8).init(self.allocator);
var first = true;
for (self.cursels.items) |*cursel_| if (cursel_.*) |*cursel| {
if (cursel.selection) |_| {
const cut_text, root = self.cut_selection(root, cursel) catch continue;
all_stop = false;
if (first) {
first = false;
} else {
try text.appendSlice("\n");
}
try text.appendSlice(cut_text);
continue;
}
with_selection_const(root, move, cursel, self.metrics) catch continue;
const cut_text, root = self.cut_selection(root, cursel) catch continue;
if (first) {
first = false;
} else {
try text.appendSlice("\n");
}
try text.appendSlice(cut_text);
all_stop = false;
};
if (all_stop)
return error.Stop;
return .{text.items, root};
}
pub fn cut_internal_vim(self: *Self, _: Context) Result {
const primary = self.get_primary();
const b = self.buf_for_update() catch return;
var root = b.root;
var text = std.ArrayList(u8).init(self.allocator);
if (self.cursels.items.len == 1)
if (primary.selection) |_| {} else {
try text.appendSlice("\n");
const sel = primary.enable_selection(root, self.metrics) catch return;
try move_cursor_begin(root, &sel.begin, self.metrics);
try move_cursor_end(root, &sel.end, self.metrics);
try move_cursor_right(root, &sel.end, self.metrics);
};
var first = true;
for (self.cursels.items) |*cursel_| if (cursel_.*) |*cursel| {
const cut_text, root = try self.cut_selection(root, cursel);
if (first) {
first = false;
} else {
try text.appendSlice("\n");
}
try text.appendSlice(cut_text);
};
try self.update_buf(root);
self.set_clipboard_internal(text.items);
self.clamp();
}
pub const cut_internal_vim_meta = .{ .description = "Cut selection or current line to internal clipboard (vim)" };
pub fn cut(self: *Self, _: Context) Result {
const primary = self.get_primary();
const b = self.buf_for_update() catch return;
@ -2473,6 +2554,66 @@ pub const Editor = struct {
}
pub const copy_meta = .{ .description = "Copy selection to clipboard" };
pub fn copy_internal_vim(self: *Self, _: Context) Result {
const root = self.buf_root() catch return;
var first = true;
var text = std.ArrayList(u8).init(self.allocator);
for (self.cursels.items) |*cursel_| if (cursel_.*) |*cursel| {
if (cursel.selection) |sel| {
const copy_text = try copy_selection(root, sel, self.allocator, self.metrics);
if (first) {
first = false;
} else {
try text.appendSlice("\n");
}
try text.appendSlice(copy_text);
}
};
if (text.items.len > 0) {
if (text.items.len > 100) {
self.logger.print("copy:{s}...", .{std.fmt.fmtSliceEscapeLower(text.items[0..100])});
} else {
self.logger.print("copy:{s}", .{std.fmt.fmtSliceEscapeLower(text.items)});
}
self.set_clipboard_internal(text.items);
}
}
pub const copy_internal_vim_meta = .{ .description = "Copy selection to internal clipboard (vim)" };
pub fn copy_line_internal_vim(self: *Self, _: Context) Result {
const primary = self.get_primary();
const root = self.buf_root() catch return;
var first = true;
var text = std.ArrayList(u8).init(self.allocator);
try text.appendSlice("\n");
if (primary.selection) |_| {} else {
const sel = primary.enable_selection(root, self.metrics) catch return;
try move_cursor_begin(root, &sel.begin, self.metrics);
try move_cursor_end(root, &sel.end, self.metrics);
try move_cursor_right(root, &sel.end, self.metrics);
}
for (self.cursels.items) |*cursel_| if (cursel_.*) |*cursel| {
if (cursel.selection) |sel| {
const copy_text = try copy_selection(root, sel, self.allocator, self.metrics);
if (first) {
first = false;
} else {
try text.appendSlice("\n");
}
try text.appendSlice(copy_text);
}
};
if (text.items.len > 0) {
if (text.items.len > 100) {
self.logger.print("copy:{s}...", .{std.fmt.fmtSliceEscapeLower(text.items[0..100])});
} else {
self.logger.print("copy:{s}", .{std.fmt.fmtSliceEscapeLower(text.items)});
}
self.set_clipboard_internal(text.items);
}
}
pub const copy_line_internal_vim_meta = .{ .description = "Copy line to internal clipboard (vim)" };
pub fn paste(self: *Self, ctx: Context) Result {
var text: []const u8 = undefined;
if (!(ctx.args.buf.len > 0 and try ctx.args.match(.{tp.extract(&text)}))) {
@ -2508,6 +2649,51 @@ pub const Editor = struct {
}
pub const paste_meta = .{ .description = "Paste from internal clipboard" };
pub fn paste_internal_vim(self: *Self, ctx: Context) Result {
var text: []const u8 = undefined;
if (!(ctx.args.buf.len > 0 and try ctx.args.match(.{tp.extract(&text)}))) {
if (self.clipboard) |text_| text = text_ else return;
}
self.logger.print("paste: {d} bytes", .{text.len});
const b = try self.buf_for_update();
var root = b.root;
if(std.mem.eql(u8, text[text.len-1..], "\n")) text = text[0..text.len-1];
if (std.mem.indexOfScalar(u8, text, '\n')) |idx| {
if(idx == 0) {
for (self.cursels.items) |*cursel_| if (cursel_.*) |*cursel| {
try move_cursor_end(root, &cursel.cursor, self.metrics);
root = try self.insert(root, cursel, "\n", b.allocator);
};
text = text[1..];
}
if (self.cursels.items.len == 1) {
const primary = self.get_primary();
root = try self.insert_line_vim(root, primary, text, b.allocator);
} else {
for (self.cursels.items) |*cursel_| if (cursel_.*) |*cursel| {
root = try self.insert_line_vim(root, cursel, text, b.allocator);
};
}
} else {
if (self.cursels.items.len == 1) {
const primary = self.get_primary();
root = try self.insert(root, primary, text, b.allocator);
} else {
for (self.cursels.items) |*cursel_| if (cursel_.*) |*cursel| {
root = try self.insert(root, cursel, text, b.allocator);
};
}
}
try self.update_buf(root);
self.clamp();
self.need_render();
}
pub const paste_internal_vim_meta = .{ .description = "Paste from internal clipboard (vim)" };
pub fn delete_forward(self: *Self, _: Context) Result {
const b = try self.buf_for_update();
const root = try self.delete_to(move_cursor_right, b.root, b.allocator);
@ -2516,6 +2702,15 @@ pub const Editor = struct {
}
pub const delete_forward_meta = .{ .description = "Delete next character" };
pub fn cut_forward_internal(self: *Self, _: Context) Result {
const b = try self.buf_for_update();
const text, const root= try self.cut_to(move_cursor_right, b.root);
self.set_clipboard_internal(text);
try self.update_buf(root);
self.clamp();
}
pub const cut_forward_internal_meta = .{ .description = "Cut next character to internal clipboard" };
pub fn delete_backward(self: *Self, _: Context) Result {
const b = try self.buf_for_update();
const root = try self.delete_to(move_cursor_left, b.root, b.allocator);
@ -2532,6 +2727,15 @@ pub const Editor = struct {
}
pub const delete_word_left_meta = .{ .description = "Delete previous word" };
pub fn cut_word_left_vim(self: *Self, _: Context) Result {
const b = try self.buf_for_update();
const text, const root= try self.cut_to(move_cursor_word_left_vim, b.root);
self.set_clipboard_internal(text);
try self.update_buf(root);
self.clamp();
}
pub const cut_word_left_vim_meta = .{ .description = "Cut next character to internal clipboard" };
pub fn delete_word_right(self: *Self, _: Context) Result {
const b = try self.buf_for_update();
const root = try self.delete_to(move_cursor_word_right_space, b.root, b.allocator);
@ -2540,6 +2744,15 @@ pub const Editor = struct {
}
pub const delete_word_right_meta = .{ .description = "Delete next word" };
pub fn cut_word_right_vim(self: *Self, _: Context) Result {
const b = try self.buf_for_update();
const text, const root= try self.cut_to(move_cursor_word_right_vim, b.root);
self.set_clipboard_internal(text);
try self.update_buf(root);
self.clamp();
}
pub const cut_word_right_vim_meta = .{ .description = "Cut next character to internal clipboard" };
pub fn delete_to_begin(self: *Self, _: Context) Result {
const b = try self.buf_for_update();
const root = try self.delete_to(move_cursor_begin, b.root, b.allocator);