vim - puntero - forzcursor autocad

Vim desplazamiento sin cambiar los cursores en la posición de pantalla

Question

Cuando el cursor está en el centro de la pantalla y me desplazo hacia abajo, el cursor se mueve hacia arriba en la pantalla. No quiero que haga eso.

¿Cómo puedo desplazarme sin cambiar la posición en pantalla de los cursores?

Solución, agregada después de la respuesta:

noremap <C-k> 14j14<C-e>
noremap <C-l> 14k14<C-y>

Answer 1

Esto cambia la posición del cursor en pantalla, pero no cambia la posición de la línea del cursor en la pantalla:

noremap <C-k> @="1/<lt>C-D>"<CR>:set scroll=0<CR>
noremap <C-l> @="1/<lt>C-U>"<CR>:set scroll=0<CR>

Sin embargo, esto restablece la opción de scroll , por lo que los <CD> y <CU> posteriores se desplazarán por media pantalla. Sin set scroll=0 , la opción de scroll se hubiera establecido en 1, y los siguientes <CD> y <CU> se desplazarían en una línea (Vim es raro).

Probablemente una función de Vimscript basada en 1<CD> y 1<CU> sería la mejor.

Answer 2

Hay dos métodos que conozco. Agregue estas líneas a su archivo .vimrc (seleccionando solo uno de los dos métodos):

Método 1:

function! s:GetNumScroll(num)
let num_rows = winheight(0)
let num_scroll = a:num
if (a:num == -1)
let num_scroll = (num_rows + 1) / 2
elseif (a:num == -2)
let num_scroll = num_rows
endif
if (num_scroll < 1)
let num_scroll = 1
endif
return num_scroll
endfunction
function! s:RtrnToOrig(before_scr_line)
normal H
let delta = a:before_scr_line - winline()
while (delta != 0)
if (delta < 0)
let delta = winline() - a:before_scr_line
let iter = 1
while (iter <= delta)
execute "normal" "gk"
let iter +=1
endwhile
elseif (delta > 0)
let iter = 1
while (iter <= delta)
execute "normal" "gj"
let iter +=1
endwhile
endif
let delta = a:before_scr_line - winline()
endwhile
endfunction
function! s:scrollUP(num)
let num_scroll = <SID>GetNumScroll(a:num)
let num_rows = winheight(0)
" -------------
let before_scr_line = winline()
normal L
let after_scr_line = winline()
let extra = num_rows - after_scr_line
let extra += num_scroll
" move by 1 to prevent over scrolling
let iter = 1
while (iter <= extra)
execute "normal" "gj"
let iter +=1
endwhile
" -------------
call <SID>RtrnToOrig(before_scr_line)
endfunction
function! s:scrollDN(num)
let num_scroll = <SID>GetNumScroll(a:num)
" -------------
let before_scr_line = winline()
normal H
let after_scr_line = line(".")
execute "normal" "gk"
let after_scr2_line = line(".")
if ( (after_scr_line == after_scr2_line) && (after_scr_line > 1) )
execute "normal" "gk"
endif
let extra = (num_scroll - 1)
let extra += (winline() - 1)
" move by 1 to prevent over scrolling
let iter = 1
while (iter <= extra)
execute "normal" "gk"
let iter +=1
endwhile
" -------------
call <SID>RtrnToOrig(before_scr_line)
endfunction
nmap <silent> <C-J> :call <SID>scrollUP(1)<CR>
nmap <silent> <C-K> :call <SID>scrollDN(1)<CR>
nmap <silent> <C-F> :call <SID>scrollUP(-1)<CR>
nmap <silent> <C-B> :call <SID>scrollDN(-1)<CR>
nmap <silent> <PageDown>:call <SID>scrollUP(-2)<CR>
nmap <silent> <PageUp> :call <SID>scrollDN(-2)<CR>

Esto utiliza la H, L normal para ir a la pantalla superior, bot y los comandos gk, gj para moverse hacia arriba, hacia abajo por línea de pantalla en lugar de la línea real. Es más complicado de lo que parece necesario solo para funcionar correctamente cuando las líneas son más largas que el ancho de la pantalla y la separación de palabras está activada.

O este método (que se ha publicado anteriormente en vim tips wiki y en Stack Exchange):

Método 2:

" N<C-D> and N<C-U> idiotically change the scroll setting
function! s:Saving_scrollV(cmd)
let save_scroll = &scroll
execute "normal" a:cmd
let &scroll = save_scroll
endfunction
" move and scroll
nmap <silent> <C-J> :call <SID>Saving_scrollV("1<C-V><C-D>")<CR>
vmap <silent> <C-J> <Esc> :call <SID>Saving_scrollV("gv1<C-V><C-D>")<CR>
nmap <silent> <C-K> :call <SID>Saving_scrollV("1<C-V><C-U>")<CR>
vmap <silent> <C-K> <Esc> :call <SID>Saving_scrollV("gv1<C-V><C-U>")<CR>
nmap <silent> <C-F> :call <SID>Saving_scrollV("<C-V><C-D>")<CR>
vmap <silent> <C-F> <Esc> :call <SID>Saving_scrollV("gv<C-V><C-D>")<CR>
nmap <silent> <PageDown> :call <SID>Saving_scrollV("<C-V><C-D>")<CR>
vmap <silent> <PageDown> <Esc>:call <SID>Saving_scrollV("gv<C-V><C-D>")<CR>
nmap <silent> <C-B> :call <SID>Saving_scrollV("<C-V><C-U>")<CR>
vmap <silent> <C-B> <Esc> :call <SID>Saving_scrollV("gv<C-V><C-U>")<CR>
nmap <silent> <PageUp> :call <SID>Saving_scrollV("<C-V><C-U>")<CR>
vmap <silent> <PageUp> <Esc> :call <SID>Saving_scrollV("gv<C-V><C-U>")<CR>

El único problema que tengo con el segundo método es cuando las líneas son más largas que el ancho de la pantalla y la separación de palabras está activa, entonces el cursor puede moverse hacia arriba o hacia abajo para tener en cuenta las líneas adicionales del ajuste. También en la parte superior e inferior del archivo, el cursor se puede mover. El primer método realmente intenta nunca mover el cursor en todos los casos.

Answer 3

Hay dos maneras en que puedo pensar: ctrl - E y ctrl - desplaza el búfer sin mover la posición del cursor con respecto a la ventana. Creo que eso es lo que quieres. Además, si configura scrolloff en un número grande, obtendrá el mismo efecto que ctrl - E y ctrl - Y con las teclas de movimiento. scrolloff configuración de scrolloff dificultará que el cursor se mueva verticalmente en relación con la ventana. (Use algo como :set so=999 , so es una abreviatura para scrolloff ).

:help ''scrolloff''
:help scrolling

Answer 4

Pruebe este mapeo en .vimrc

map <ScrollWheelUp> 5<C-Y>
map <ScrollWheelDown> 5<C-E>

Answer 5

Si desea mover el cursor y la ventana gráfica con el cursor en cualquier lugar de la pantalla, quizás deba configurar algunos enlaces de teclas personalizados para hacer ambas cosas a la vez.

Como:

:nnoremap <C-M-u> j<C-e>

Esto moverá el cursor hacia abajo ( j ) y moverá la ventana gráfica ( Ctrl-e ) siempre que presione Ctrl-Alt-u (solo en modo normal).

Answer 6

ctrl - D y ctrl - U es lo que quieres.

ctrl - D tiene el mismo efecto que 14j14<Ce> (solo que el número 14 no está codificado y la cantidad de movimiento depende del tamaño real de la pantalla): mueves el cursor varias líneas hacia abajo en el texto pero el cursor permanece en el medio de la pantalla.

Del mismo modo ctrl - U funciona como 14k14<Cy> .

Adición: si su pantalla tiene 30 líneas, las dos son exactamente iguales.