Don't close Neotree buffer when opening a file from "current" or "float" position

[Subjective]

Hi, I'm trying to find implement an open_nofocus command, similar to #249. However, I haven't really been able to get it to work satisfactorily with position=current or position=floating.

This is what I'm using right now:

open_nofocus = function(state)
  state.commands["open"](state)
  local position = state.current_position
  if position == "float" or position == "current" then
    vim.cmd("Neotree reveal position=" .. position)
  else
    vim.api.nvim_set_current_win(state.winid)
  end
end,

Some context: I'm using vim.api.nvim_set_current_win(state.winid) to reset the cursor position to Neotree as I've found that :Neotree reveal doesn't work as well since it sometimes tries to place the cursor on the file that was just opened after a small time interval, which makes using the command to quickly open multiple files a bit jittery. However, setting the current window doesn't work with Neotree's "current" or "float" positions as it seems like they are always closed no matter what open command I use, so I've been forced to use :Neotree reveal despite the flickering.

I was wondering if there's a better way to open files in a "background" buffer without closing the Neotree buffer? Thanks.

[cseickel]

What about if you marked a set of files with M first, then opened them all at once with O?

          mappings = {
            ["M"] = function (state)
              local node = state.tree:get_node()
              if node then
                state.clipboard = state.clipboard or {}
                local id = node:get_id()
                local data = state.clipboard[id]
                if data and data.action == "mark" then
                  state.clipboard[id] = nil
                else
                  state.clipboard[id] = { action = "mark", node = node }
                end
                require("neo-tree.ui.renderer").redraw(state)
              end
            end,
            ["O"] = function (state)
              local clipboard = state.clipboard or {}
              for id, data in pairs(clipboard) do
                if data.action == "mark" then
                  require("neo-tree.utils").open_file(state, id)
                end
              end
              require("neo-tree.ui.renderer").redraw(state)
            end
          }

[Subjective]

Thanks for the suggestion! I played around with the code and made a few improvements, such as clearing the marks upon the files, and recursively marking files if a directory is selected (for some reason, this doesn't seem to recursively mark the files if the directory node if hasn't already been previously expanded, not sure how to fix that though).

Snippet

commands = {
  mark_file = function(state)
    state.clipboard = state.clipboard or {}
    local function mark_node(node)
      if node.type == "directory" then
        require("neo-tree.sources.filesystem.commands").expand_all_nodes(state, node)
        -- caveat: unable to mark child nodes if parent node hasn't been previously expanded
        for _, child in ipairs(state.tree:get_nodes(node:get_id())) do
          mark_node(child)
        end
      else
        local id = node:get_id()
        local data = state.clipboard[id]
        if data and data.action == "mark" then
          state.clipboard[id] = nil
        else
          state.clipboard[id] = { action = "mark", node = node }
        end
      end
    end
    local node = state.tree:get_node()
    if node then mark_node(node) end
    require("neo-tree.ui.renderer").redraw(state)
  end,
  -- opens marked files in addition to currently selected file (useful for ensuring the currently selected file will be the one that is focused)
  smart_open = function(state)
    local clipboard = state.clipboard or {}
    for id, data in pairs(clipboard) do
      if data.action == "mark" then
        require("neo-tree.utils").open_file(state, id)
        state.clipboard[id] = nil
      end
    end
    state.commands["open"](state)
    require("neo-tree.ui.renderer").redraw(state)
  end,
},
mappings = {
  ["<tab>"] = "mark_file",
  ["o"] = "smart_open",
  ["<cr>"] = "smart_open",
}

Still, I'm not entirely sure I prefer this approach since the order the buffers are opened in can't be controlled.

Edit: Okay, it seems like expand_all_nodes is async, is there any way to defer execution until it is finished/make it synchronous? I'm not too familiar with plenary coroutines. Currently, I'm addressing this with vim.defer_fn, which feels kind of hacky:

mark_file = function(state)
  state.clipboard = state.clipboard or {}
  local function mark_node(node)
    if node.type == "directory" then
      local children = state.tree:get_nodes(node:get_id())
      for _, child in ipairs(children) do
        mark_node(child)
      end
    else
      local id = node:get_id()
      local data = state.clipboard[id]
      if data and data.action == "mark" then
        state.clipboard[id] = nil
      else
        state.clipboard[id] = { action = "mark", node = node }
      end
      require("neo-tree.ui.renderer").redraw(state)
    end
  end
  local node = state.tree:get_node()
  if node then
    require("neo-tree.sources.filesystem.commands").expand_all_nodes(state, node)
    vim.defer_fn(function() mark_node(node) end, 100)
  end
end

[cseickel]

One thing I don't get is that if you want to open multiple files without losing focus of the tree, why would you ever try to use "current" or "float" positions for that? It just doesn't make sense. Are you using a "buffers as tabs" type plugin? If so, maybe the plugin that you use for that has methods to open new buffers without actually showing them in a window.

[Subjective]

Yeah, you're right. I typically use one of the side layouts most of the time. The only reason I asked was because just knowing how buggy my workaround was for the other modes bothered me, and so I went down a rabbit hole trying to get it to work for those edge cases. Anyways, I'm just gonna close this discussion to avoid wasting more of your valuable time. Thanks again for the help!