Always show colorcolumn if a line crosses it

[Hubro]

This plugin works really freaking well, I'm always a fan of reducing visual noise, but one this I miss is that I can no longer tell of a line in the current view crosses the column.

If I set scope to "visible", then the point of the plugin is largely lost, I don't want to see the colorcolumn as long as nothing crosses it.

What would be perfect is if the plugin did exactly what it currently does, but if a currently visible line crosses the colorcolumn, it should be displayed no matter what.

Unless I've misunderstood the documentation, this isn't currently possible. Is there a elegant way this can be implemented?

---

Maybe something like:

warningscope = "buffer" | "visible"

Works like scope, but overrides it if a line actually crosses the colorcolumn. My ideal behavior would be scope = "line" and warningscope = "visible". I would also probably like warningscope = "buffer" so I would immediately know if any line in the current file was too long.

[Bekaboo]

Hi, thanks for reporting.

but one this I miss is that I can no longer tell of a line in the current view crosses the column.
if a currently visible line crosses the colorcolumn, it should be displayed no matter what.

Seems like that setting scope to visible does exactly what you want.

[Hubro]

@Bekaboo Except for:

If I set scope to "visible", then the point of the plugin is largely lost, I don't want to see the colorcolumn as long as nothing crosses it.

If I set scope to "visible", I pretty much always see the colorcolumn, because I almost always have at least one line in the current viewport that comes close to the colorcolumn, which makes it visible, even though nothing crosses it.

[Bekaboo]

OK, I understand. Can you try setting opts.blending.threshold to 1 to show the colorcolumn in red only when a line is longer than cc

[Hubro]

@Bekaboo But that wouldn't be the default behavior, I like the default behavior 😄

What I'm hoping for is to expand the default behavior to additionally show the colorcolumn when a line in the current viewport crosses it. If no lines in the current viewport crosses the colorcolumn, then the default behavior is perfect.

Setting opts.blending.threshold to 1 would (if I understand correctly) completely change the default behavior so that I only see the colorcolumn when I cross it, even in insert mode.

[Bekaboo]

Setting opts.blending.threshold to 1 should show the color column in red only when there exists a line in scope longer than cc.

Setting opts.blending.threshold to 1 would (if I understand correctly) completely change the default behavior so that I only see the colorcolumn when I cross it, even in insert mode.

Whether the colored column will be shown in insert mode is controlled by opts.modes, if you do not want it to show in insert mode, you can set opts.modes to { 'n' }.

If this is not what you expected, please elaborate, and express your desire in clearer way, e.g. using a table or a list to show in which modes, under what conditions, with what scope do you like to see the colored column. I have to admit that I don't fully get your point and your feature request seems vague to me.

[Hubro]

I think the default behavior is perfect as long as no lines are currently crossing the colorcolumn:

However, as soon as a line actually crosses the colorcolumn, this is no longer so nice:

Because now it's not clear if any lines are too long, and I have to actually move the cursor to each line to check if they are too long:

Basically, I wish it was possible to keep scope at "line", but have it behave as if it was set to "visible" only when a line actually crosses a colorcolumn in the current viewport. (In other words, the colorcolumn would not be visible in the first screenshot, but would be visible in the third screenshot.)

My tentative suggestion was:

-- Default behavior
scope = "line"

-- Default behavior, but make colorcolumn visible if any lines in the current viewport
-- cross the colorcolumn
scope = "line"
warningscope = "visible"

-- Default behavior, but make colorcolumn visible if any lines in the current buffer
-- cross the colorcolumn
scope = "line"
warningscope = "buffer"

[Bekaboo]

Firstly, the images shown in the screenshots do not reflect the default behavior -- by default this plugin will not show the colored column in normal mode not matter what, so I assume you passed some custom config and let deadcolumn.nvim show the colored column in normal mode.

Secondly, if I do not misunderstand your proposal, you want the colored column to be shown in red if there is a line visible that is longer than cc, but if there is not such line, you would like the deadcolumn.nvim to behave as if it is configured with opts.modes = { 'n' }, right?

If that is what you expected, you can change the config dynamically when you scroll the screen, something like this might help:
. If you have any questions please fell free to ask me.

vim.api.nvim_create_autocmd({ 'VimResized', 'WinScrolled', 'BufWinEnter' }, {
    group = vim.api.nvim_create_augroup('DeadcolumnConfig', {}),
    callback = function()
        local lines = vim.api.nvim_buf_get_lines(
          0,
          vim.fn.line('w0') - 1,
          vim.fn.line('w$'),
          false
        )
        if math.max(unpack(vim.tbl_map(vim.fn.strdisplaywidth, lines))) > vim.wo.cc then
            require('deadcolumn').setup({
                scope = 'visible',
            })
        else
            require('deadcolumn').setup({
                scope = 'line',
            })
        end
    end
})

I have not tested it so there might be bugs, but you should get the point and modify the snippet as you wish. If you have any questions please fell free to ask me.

[Hubro]

You're right, I forgot I added "n" to the default modes, but fortunately that has nothing to do with my proposal.

My proposal is only to change the effective value of scope based on whether any currently visible lines cross the colorcolumn, which seems to be exactly what your snippet demonstrates 🙂

I think it would be nice if this was possible to achieve with the options of the plugin. My first two thoughts after installing this plugin was:

1. Aah, fancy! My editor looks much cleaner now!
2. Oh dear, I wonder if any of my lines are too long, I have no idea...

Having a scope and a warningscope would let me have the best of both worlds. If I don't see the colorcolumn, I can know for sure none of my lines are too long 🙂

[Bekaboo]

I'm glad that the snippet solves your problem. A possible bug I observe in the snippet is that vim.wo.cc is a string, so you have to convert it to a number before comparing it with the length of the longest line visible.

I think it would be nice if this was possible to achieve with the options

As you can see in the implementation of this plugin, this plugin is implemented in a very hacky way and the logic has now become unnecessarily complicated due to a neovim bug neovim/neovim#23227 so I have no plan to further make it even more complex before the bug getting fixed (then I can cleanup the implementation). So if the snippet can solve your problem there is no plan to add an extra option. Please understand.

[Hubro]

Completely understandable 👍

[Bekaboo]

Hi, please test commit 8f19d5f on branch dev if you are interested. This allows users to pass a callback function to opts.scope. I believe this is a more elegant way to achieve what you want.

[Hubro]

@Bekaboo Nice, that makes sense! My ideal setup would be something like:

scope = function()
  local visible_lines = vim.api.nvim_buf_get_lines(
    0, vim.fn.line("w0") - 1, vim.fn.line("w$"), false
  )
  local longest_visible_line =
    math.max(unpack(vim.tbl_map(vim.fn.strdisplaywidth, visible_lines)))

  if longest_visible_line > COLORCOLUMN then   -- ?
    return longest_visible_line
  else
    return vim.fn.strdisplaywidth(vim.api.nvim_get_current_line())
  end
end,

But I'm stuck on the COLORCOLUMN value, since this could vary per window.

I see there's a fairly chunky function resolve_cc in autocmds.lua that parses the colorcolumn value and returns a number, but it's not exported.

[Bekaboo]

Hi, please test commit de93cd9, you should be able to access that function through require('deadcolumn').utils.resolve_cc or require('deadcolumn.utils').resolve_cc.

[Hubro]

It almost works perfectly! 😁

scope = function()
  local lines = vim.api.nvim_buf_get_lines(
    0,
    vim.fn.line("w0") - 1,
    vim.fn.line("w$"),
    false
  )
  local longest_on_screen_line =
    math.max(unpack(vim.tbl_map(vim.fn.strdisplaywidth, lines)))

  local cc = require("deadcolumn.utils").resolve_cc(vim.wo.cc)

  if cc ~= nil and longest_on_screen_line >= cc then
    return longest_on_screen_line
  else
    return vim.fn.strdisplaywidth(vim.api.nvim_get_current_line())
  end
end,

But there's a bug, for some reason the colorcolumn disappears shortly after I typing anything in insert mode:

demo.mp4