diff --git a/rust_src/src/vterm.rs b/rust_src/src/vterm.rs index 54426cce098..31a4af15080 100644 --- a/rust_src/src/vterm.rs +++ b/rust_src/src/vterm.rs @@ -72,7 +72,7 @@ pub fn vterm_new_lisp(rows: EmacsInt, cols: EmacsInt) -> LispObject { } #[no_mangle] -pub unsafe extern "C" fn vterm_refresh_screen(term: *mut Term) { +pub unsafe extern "C" fn vterminal_refresh_screen(term: *mut Term) { if (*term).invalid_end >= (*term).invalid_start { let mut height: i32 = 0; let mut width: i32 = 0; @@ -96,7 +96,7 @@ pub unsafe extern "C" fn vterm_refresh_screen(term: *mut Term) { (*term).invalid_end = -1; } -pub unsafe extern "C" fn vterm_adjust_topline(term: *mut Term, added: i64) { +pub unsafe extern "C" fn vterminal_adjust_topline(term: *mut Term, added: i64) { let mut height: i32 = 0; let mut width: i32 = 0; vterm_get_size((*term).vt, &mut height, &mut width); @@ -109,17 +109,20 @@ pub unsafe extern "C" fn vterm_adjust_topline(term: *mut Term, added: i64) { vterm_state_get_cursorpos(state, &mut pos); let cursor_lnum = row_to_linenr(term, pos.row); + + // TODO: forward_line doesn't get the line correctly here call!( LispObject::from(intern("goto-line")), LispObject::from(cmp::min(cursor_lnum, buffer_lnum)) ); + let offset = get_col_offset(term, pos.row, pos.col); forward_char(LispObject::from((pos.col - offset as c_int) as EmacsInt)); } /// Refresh the scrollback of an invalidated terminal. #[no_mangle] -pub unsafe extern "C" fn vterm_refresh_scrollback(term: *mut Term) { +pub unsafe extern "C" fn vterminal_refresh_scrollback(term: *mut Term) { let mut height: i32 = 0; let mut width: i32 = 0; vterm_get_size((*term).vt, &mut height, &mut width); @@ -149,27 +152,27 @@ pub unsafe extern "C" fn vterm_refresh_scrollback(term: *mut Term) { // Remove extra lines at the bottom if buffer_lnum > max_line_count { - vterm_delete_lines(max_line_count + 1, buffer_lnum - max_line_count + 1, true); + vterminal_delete_lines(max_line_count + 1, buffer_lnum - max_line_count + 1, true); } } #[no_mangle] -pub unsafe extern "C" fn vterm_redraw(term: *mut Term) { +pub unsafe extern "C" fn vterminal_redraw(term: *mut Term) { if (*term).is_invalidated { let bufline_before = call!(LispObject::from(intern("line-number-at-pos"))).as_fixnum_or_error() as i64; - vterm_refresh_scrollback(term); - vterm_refresh_screen(term); + vterminal_refresh_scrollback(term); + vterminal_refresh_screen(term); let line_added = call!(LispObject::from(intern("line-number-at-pos"))).as_fixnum_or_error() as i64 - bufline_before; - vterm_adjust_topline(term, line_added); + vterminal_adjust_topline(term, line_added); } (*term).is_invalidated = false; } -#[lisp_fn(min = "0")] -pub fn vterm_update( +#[lisp_fn(min = "0", name = "vterm-update")] +pub fn vterminal_update( string: LispObject, key: LispObject, shift: bool, @@ -205,8 +208,8 @@ pub fn vterm_update( ); } - vterm_flush_output(term); - vterm_redraw(term); + vterminal_flush_output(term); + vterminal_redraw(term); LispObject::from(0) } } @@ -236,7 +239,7 @@ pub fn vterm_update( // } #[no_mangle] -pub unsafe extern "C" fn vterm_render_text( +pub unsafe extern "C" fn vterminal_render_text( buffer: *mut c_char, len: c_int, cell: *mut VTermScreenCell, @@ -296,7 +299,7 @@ pub unsafe extern "C" fn vterm_render_text( } #[no_mangle] -pub unsafe extern "C" fn vterm_flush_output(term: *mut Term) { +pub unsafe extern "C" fn vterminal_flush_output(term: *mut Term) { let len = vterm_output_get_buffer_current((*term).vt); if len > 0 { let mut buffer: Vec = Vec::with_capacity(len); @@ -304,31 +307,27 @@ pub unsafe extern "C" fn vterm_flush_output(term: *mut Term) { let output = make_string(buffer.as_mut_ptr() as *mut c_char, len as isize); - // is_not_nil shouldn't be necessary - if output.is_not_nil() { - call!(LispObject::from(intern("vterm-flush-output")), output); - } + call!(LispObject::from(intern("vterm-flush-output")), output); } } -#[lisp_fn] -pub fn vterm_write_input(input: LispObject) -> LispObject { +#[lisp_fn (name = "vterm-write-input")] +pub fn vterminal_write_input(mut input: LispStringRef) -> EmacsInt { unsafe { let term: *mut Term = global_term; - let mut s = input.as_string_or_error(); vterm_input_write( (*term).vt, - s.sdata_ptr(), - STRING_BYTES(s.as_mut()) as usize + 1, + input.sdata_ptr(), + STRING_BYTES(input.as_mut()) as usize + 1, ); vterm_screen_flush_damage((*term).vts); } - LispObject::from(0) + 0 as EmacsInt } #[lisp_fn(name = "vterm-set-size")] -pub fn vterm_set_size_lisp(rows: EmacsInt, cols: EmacsInt) -> LispObject { +pub fn vterminal_set_size_lisp(rows: EmacsInt, cols: EmacsInt) -> LispObject { unsafe { let term: *mut Term = global_term; @@ -343,14 +342,14 @@ pub fn vterm_set_size_lisp(rows: EmacsInt, cols: EmacsInt) -> LispObject { vterm_set_size((*term).vt, rows, cols); vterm_screen_flush_damage((*term).vts); - vterm_redraw(term); + vterminal_redraw(term); } } Qnil } #[no_mangle] -pub extern "C" fn vterm_delete_lines(linenum: c_int, count: c_int, del_whole_line: bool) { +pub extern "C" fn vterminal_delete_lines(linenum: c_int, count: c_int, del_whole_line: bool) { let l = LispObject::from(linenum); let c = LispObject::from(count); @@ -364,8 +363,12 @@ pub extern "C" fn vterm_delete_lines(linenum: c_int, count: c_int, del_whole_lin // vterm_screen_callbacks #[no_mangle] -pub unsafe extern "C" fn vterm_invalidate_terminal(term: *mut Term, start_row: c_int, end_row: c_int) { - if !(start_row == -1 || end_row == -1 ) { +pub unsafe extern "C" fn vterminal_invalidate_terminal( + term: *mut Term, + start_row: c_int, + end_row: c_int, +) { + if !(start_row == -1 || end_row == -1) { (*term).invalid_start = cmp::min((*term).invalid_start, start_row); (*term).invalid_end = cmp::max((*term).invalid_end, end_row); } @@ -373,18 +376,18 @@ pub unsafe extern "C" fn vterm_invalidate_terminal(term: *mut Term, start_row: c } #[no_mangle] -pub unsafe extern "C" fn vterm_damage(rect: VTermRect, data: *mut c_void) -> c_int { - vterm_invalidate_terminal(data as *mut Term, rect.start_row, rect.end_row); +pub unsafe extern "C" fn vterminal_damage(rect: VTermRect, data: *mut c_void) -> c_int { + vterminal_invalidate_terminal(data as *mut Term, rect.start_row, rect.end_row); 1 } #[no_mangle] -pub unsafe extern "C" fn vterm_moverect( +pub unsafe extern "C" fn vterminal_moverect( dest: VTermRect, src: VTermRect, data: *mut c_void, ) -> c_int { - vterm_invalidate_terminal( + vterminal_invalidate_terminal( data as *mut Term, cmp::min(dest.start_row, src.start_row), cmp::max(dest.end_row, src.end_row), @@ -394,7 +397,7 @@ pub unsafe extern "C" fn vterm_moverect( } #[no_mangle] -pub unsafe extern "C" fn vterm_movecursor( +pub unsafe extern "C" fn vterminal_movecursor( new: VTermPos, old: VTermPos, visible: c_int, @@ -403,15 +406,15 @@ pub unsafe extern "C" fn vterm_movecursor( let term: *mut Term = data as *mut Term; (*term).cursor.row = new.row; (*term).cursor.col = new.col; - vterm_invalidate_terminal(term, old.row, old.row + 1); - vterm_invalidate_terminal(term, new.row, new.row + 1); + vterminal_invalidate_terminal(term, old.row, old.row + 1); + vterminal_invalidate_terminal(term, new.row, new.row + 1); return 1; } #[no_mangle] -pub unsafe extern "C" fn vterm_resize(rows: c_int, cols: c_int, term: *mut Term) -> c_int { - vterm_invalidate_terminal(term, 0, rows); +pub unsafe extern "C" fn vterminal_resize(rows: c_int, cols: c_int, term: *mut Term) -> c_int { + vterminal_invalidate_terminal(term, 0, rows); 1 } diff --git a/src/lisp.h b/src/lisp.h index 24236fd5168..5f8df784775 100644 --- a/src/lisp.h +++ b/src/lisp.h @@ -4941,16 +4941,16 @@ extern void term_process_key(Term *term, unsigned char *key, size_t len, extern int vterm_string_bytes(Lisp_Object string); -extern Lisp_Object vterm_render_text (char *buffer, int len, VTermScreenCell *cell); +extern Lisp_Object vterminal_render_text (char *buffer, int len, VTermScreenCell *cell); -extern int vterm_movecursor(VTermPos new, VTermPos old, int visible, +extern int vterminal_movecursor(VTermPos new, VTermPos old, int visible, void *data); -extern int vterm_resize(int rows, int cols, void *term); +extern int vterminal_resize(int rows, int cols, void *term); -extern int vterm_damage(VTermRect rect, void *data); +extern int vterminal_damage(VTermRect rect, void *data); -extern int vterm_moverect(VTermRect dest, VTermRect src, void *data); +extern int vterminal_moverect(VTermRect dest, VTermRect src, void *data); extern VTermColor rgb_string_to_color(Lisp_Object string); diff --git a/src/vterm.c b/src/vterm.c index 1e83969b68c..459509afd39 100644 --- a/src/vterm.c +++ b/src/vterm.c @@ -278,7 +278,7 @@ refresh_lines (Term *term, int start_row, int end_row, int end_col) { fetch_cell(term, i, j, &cell); if (!compare_cells(&cell, &lastCell)) { - Lisp_Object text = vterm_render_text(buffer, length, &lastCell); + Lisp_Object text = vterminal_render_text(buffer, length, &lastCell); call1(intern ("insert"), text); length = 0; } @@ -306,18 +306,18 @@ refresh_lines (Term *term, int start_row, int end_row, int end_col) { buffer[length] = '\n'; length++; } - Lisp_Object text = vterm_render_text(buffer, length, &lastCell); + Lisp_Object text = vterminal_render_text(buffer, length, &lastCell); call1(intern ("insert"), text); return text; } VTermScreenCallbacks vterm_screen_callbacks = { - .damage = vterm_damage, - .moverect = vterm_moverect, - .movecursor = vterm_movecursor, + .damage = vterminal_damage, + .moverect = vterminal_moverect, + .movecursor = vterminal_movecursor, /* .settermprop = term_settermprop, */ - .resize = vterm_resize, + .resize = vterminal_resize, .sb_pushline = term_sb_push, .sb_popline = term_sb_pop,