Add support for `gg`/`G`

[ouuan]

I added these in my config:

t['gg']    = {'scroll', {'1 - vim.api.nvim_win_get_cursor(0)[1]', 'true', '1', '5', e}}
t['G']     = {'scroll', {'vim.api.nvim_buf_line_count(0) - vim.api.nvim_win_get_cursor(0)[1]', 'true', '1', '5', e}}

And it turns out that it doesn't work well when there are wrapped lines, because neoscroll uses gj and gk, which is good for other commands like <c-u>/<c-d> but bad for gg and G.

Or is there any way to get the display line number? I didn't find it in help or online.

[karb94]

Yes gg and G have some complications. The good news is that it is relatively easy to implement inside Neoscroll so the best solution is for me to make wrapper functions like I did for zt/zz/zb.

[karb94]

as a temporary solution you could do something like:

t['gg']    = {'scroll', {'-2*vim.api.nvim_buf_line_count(0)', 'true', '1', '5', e}}
t['G']     = {'scroll', {'2*vim.api.nvim_buf_line_count(0)', 'true', '1', '5', e}}

[vext01]

Similarly, it would be good if pageup and pagedown were captured by neoscroll.

[karb94]

I finally had some time to look at this. I'm not entirely sure what would be the expected behaviour when an easing function is enabled. There are two parts for this animation:

1. The window scrolls till the edge of the buffer
2. The cursor scrolls till the edge of the buffer

The cursor has to scroll after the window reaches the edge of the buffer because the cursor cannot be at the bottom/top of the window if scrolloff is greater than 0.

Having said that, when an easing function is enabled do we want the easing function to apply to both movements, only on the window scroll movement or only on the cursor movement?

[maxwelljens]

@vext01 You can add map <PageUp> <C-b> and map <PageDown> <C-f> to your config. That will make page up and page down do smooth scrolling.

[lawrence-laz]

@vext01 You can add map <PageUp> <C-b> and map <PageDown> <C-f> to your config. That will make page up and page down do smooth scrolling.

Didn't work for me.

I just duplicated mapping for PageUp and PageDown and it seems to work nicely:

t['<C-b>'] = {'scroll', {'-vim.api.nvim_win_get_height(0)', 'true', '100'}}
t['<PageUp>'] = {'scroll', {'-vim.api.nvim_win_get_height(0)', 'true', '100'}}
t['<C-f>'] = {'scroll', { 'vim.api.nvim_win_get_height(0)', 'true', '100'}}
t['<PageDown>'] = {'scroll', { 'vim.api.nvim_win_get_height(0)', 'true', '100'}}

[benwoodward]

as a temporary solution you could do something like:

t['gg']    = {'scroll', {'-2*vim.api.nvim_buf_line_count(0)', 'true', '1', '5', e}}
t['G']     = {'scroll', {'2*vim.api.nvim_buf_line_count(0)', 'true', '1', '5', e}}

This is great, thanks. The only issue with this for me is that if the file is shorter than the height of the window, then the file will scroll to the last line leaving only the last line of the file visible at the top of the window.

My workaround for this: (only smooth scroll if buffer is longer than window height)

local api = vim.api

vim.keymap.set('n', 'G', [[<Cmd> lua maybe_smooth_scroll()<CR>]], { noremap = true })

function _G.maybe_smooth_scroll()
  local win_height = api.nvim_win_get_height(0)
  local buf_line_count = api.nvim_buf_line_count(0)

  if buf_line_count < win_height then
    api.nvim_command('normal! G')
  else
    require('neoscroll').scroll(1 * buf_line_count, true, 1, 5)
  end
end

[peter-cardenas-ai]

i have the above in addition to a post hook to set the cursor to the last and first lines for G and gg respectively. i believe this is the desired workflow for these commands?

  post_hook = function(info)
    if info == nil then
      return
    end
    if info.kind == 'gg' then
      vim.api.nvim_win_set_cursor(info.winid, { 1, 0 })
    elseif info.kind == 'G' then
      local line = vim.api.nvim_buf_line_count(info.bufnr)
      vim.api.nvim_win_set_cursor(info.winid, { line, 0 })
    end
  end,

[aiya000]

I have written an implementation for one gg, G from the outside.

local neoscroll = require('neoscroll')

local keymaps_opts = {
  duration = 200,
  easing = 'quadratic',
}

---`{line_num}gg` and `{line_num}G` support
local function goto_line()
  local count = vim.v.count
  local current_line, col = unpack(vim.api.nvim_win_get_cursor(0))
  local distance = count - current_line
  if distance == 0 then
    return
  end

  local distance_to_scroll = distance > 0
    and math.min(distance, 100) -- Example: max(200, 100)
    or math.max(distance, -100) -- Example: min(-200, -100)
  neoscroll.scroll(distance_to_scroll, keymaps_opts)
  vim.defer_fn(function()
    vim.notify('poi: ' .. vim.inspect(count), vim.log.levels.INFO)
    vim.api.nvim_win_set_cursor(0, { count, col })
  end, 200)
end

vim.keymap.set('n', 'gg', function()
  if vim.v.count ~= 0 then
    goto_line()
    return
  end

  neoscroll.scroll(-100, keymaps_opts)
  vim.defer_fn(function()
    vim.cmd('normal! gg')
  end, 100)
end)

vim.keymap.set('n', 'G', function()
  if vim.v.count ~= 0 then
    goto_line()
    return
  end

  neoscroll.scroll(100, keymaps_opts)
  vim.defer_fn(function()
    vim.cmd('normal! G')
  end, 100)
end)

I'm new to neoscroll.nvim.
I may not understand exactly about keymaps_opts and opts in setup(opts).

Around durations, the number of milliseconds I'm passing to defer_fn may not be appropriate.
But in my case, it is working fine.

My idea here is to limit the smooth scroll travel distance to 100 lines, and then do the normal gg, G after the smooth scroll is terminated.
This at least achieves my goal of 'making it look like that' :)

If you prefer Japanese, or if you do not mind translating, please refer to the article I wrote in a write-down.
I have also included a working example.

https://zenn.dev/aiya000/scraps/4e63afe34e7aa6

Thank you for the best product, neoscroll.nvim!