Persistent output buffers about cmake-tools.nvim HOT 43 CLOSED

local term_idx                                      -- This is the buffer number of term
local term_channel                                  -- This is the channel number
local term_height = 10                              -- Terminal height
local multiple_terminals_per_tab = false            -- Prefer to keep false, since we will not close it
local keep_single_terminal_per_tab = true           -- Prefer true if you want to keep only one per tab
local keep_terminal_in_tab_static = true            -- Prefer if you want to use a single static instance
local display_single_window_across_instance = false -- Prefer to keep this false
local vert_split = true

local term_name = "my_term" -- name the channel... like CMakeRun
local positon = 'below'     -- This si the location of inital term generation (as we are using vim api)
local cmd = "ls"
local is_startinsert = true

local previous_window = vim.api.nvim_get_current_win() -- This gives us an anchor... a starting point

---------------------------------------------------------

for i, buf_nr in ipairs(vim.api.nvim_list_bufs()) do
    local name = vim.api.nvim_buf_get_name(buf_nr)
    print(i .. " : " .. buf_nr .. ", name: " .. vim.api.nvim_buf_get_name(buf_nr) .. " type: " .. type(name))
    print("buf exists: " .. tostring(string.match(name, term_name) == term_name))
    local matched = string.match(name, term_name) == term_name
    if matched then
        term_idx = buf_nr
        break
    else
        print("-> no test_buf")
    end
    print(" ")
end

-- Create terminal is not created!

local function is_buffer_hidden_in_current_tab(bufname)
    local bufnr = vim.fn.bufnr(bufname)
    for _, winid in ipairs(vim.api.nvim_list_wins()) do
        if vim.api.nvim_win_get_buf(winid) == bufnr then
            return false -- Buffer is shown in a split
        end
    end
    return true -- Buffer is not shown in any split
end

function _G.getWindowsWithBuffer(bufname)
    local windows = {}
    for _, winid in ipairs(vim.api.nvim_list_wins()) do
        local bufnr = vim.api.nvim_win_get_buf(winid)
        local winbufname = vim.api.nvim_buf_get_name(bufnr)
        if winbufname == bufname then
            table.insert(windows, winid)
        end
    end
    return windows
end

function _G.get_windows_displaying_my_buffer_across_all_tabs(bufname)
    local windows = {}
    for _, tabpage in ipairs(vim.api.nvim_list_tabpages()) do
        vim.api.nvim_set_current_tabpage(tabpage)
        for _, window in ipairs(vim.api.nvim_tabpage_list_wins(tabpage)) do
            local win_bufname = vim.api.nvim_buf_get_name(vim.api.nvim_win_get_buf(window))
            if win_bufname:match(bufname) then
                table.insert(windows, window)
            end
        end
    end
    return windows
end

function _G.is_buffer_displayed_in_current_tab(buf_name)
    local current_tabpage = vim.api.nvim_get_current_tabpage()
    for _, window in ipairs(vim.api.nvim_tabpage_list_wins(current_tabpage)) do
        local win_bufnr = vim.api.nvim_win_get_buf(window)
        local win_bufname = vim.api.nvim_buf_get_name(win_bufnr)
        if win_bufname:match(buf_name) then
            return true
        end
    end
    return false
end

function _G.get_windows_for_buffer_in_current_tab(buf_name)
    local windows = {}
    local current_tabpage = vim.api.nvim_get_current_tabpage()
    for _, window in ipairs(vim.api.nvim_tabpage_list_wins(current_tabpage)) do
        local win_bufnr = vim.api.nvim_win_get_buf(window)
        local win_bufname = vim.api.nvim_buf_get_name(win_bufnr)
        if win_bufname:match(buf_name) then
            table.insert(windows, window)
        end
    end
    return windows
end

function _G.get_terminal_buffer_number_and_channel_number(name)
    local bufinfo = vim.api.nvim_list_bufs()
    for _, bufnr in ipairs(bufinfo) do
        local buftype = vim.api.nvim_buf_get_option(bufnr, 'buftype')
        local bufname = vim.api.nvim_buf_get_name(bufnr)
        local filename = vim.fn.fnamemodify(bufname, ':t')
        print("buftype: " .. buftype .. ", bufname: " .. bufname .. ", filename: " .. filename)
        if buftype == 'terminal' and filename == name then
            -- local term_chan = vim.api.nvim_buf_get_var(bufnr, '&channel')
            local term_chan = vim.api.nvim_call_function('nvim_buf_get_var', { bufnr, 'terminal_job_id' })
            return bufnr, term_chan
        end
    end
    return nil, nil
end

function _G.getWindowNumberByBufferName(bufname)
    local bufnr = vim.fn.bufnr(bufname)
    for _, winid in ipairs(vim.api.nvim_list_wins()) do
        if vim.api.nvim_win_get_buf(winid) == bufnr then
            return vim.api.nvim_win_get_number(winid)
        end
    end
    return nil -- Buffer is not open in any window
end

function _G.closeWindowsByBufferName(bufname)
    local previous_window = vim.api.nvim_get_current_win()

    for _, tabpage in ipairs(vim.api.nvim_list_tabpages()) do
        vim.api.nvim_set_current_tabpage(tabpage)
        for _, window in ipairs(vim.api.nvim_tabpage_list_wins(tabpage)) do
            local win_bufname = vim.api.nvim_buf_get_name(vim.api.nvim_win_get_buf(window))
            if win_bufname:match(bufname) then
                vim.api.nvim_set_current_win(window)
                hide_window()
                vim.api.nvim_set_current_win(previous_window)
                return
            end
        end
    end

    vim.api.nvim_set_current_win(previous_window)
end

local function send_commands_to_terminal(buffer_preset_name, data, is_startinsert, focus_win_nr)
    local bufnr, chan = get_terminal_buffer_number_and_channel_number(buffer_preset_name)
    if chan > 0 then
        vim.api.nvim_chan_send(chan, data .. string.char(13))
    else
        print("chan error!")
    end
    print("previous_window: ")
    print(focus_win_nr)
    vim.api.nvim_set_current_win(focus_win_nr)
    if is_startinsert then
        vim.cmd('startinsert')
    end
end

local function set_new_window_for_buffer(split_win, buffer_idx, dimension)
    if split_win == true then
        vim.cmd('split')
    end
    vim.api.nvim_win_set_buf(0, buffer_idx)
    if vert_split == true then
        vim.api.nvim_win_set_height(0, dimension)
    else
        vim.api.nvim_win_set_width(0, dimension)
    end
    vim.cmd('setlocal noequalalways') -- Avoid resizing the split
    return vim.api.nvim_get_current_win()
end


if term_idx then
    print('terminal buffer exists!')
    -- If user wants only a single buffer across all tabgroups, we skip the logic after this block
    if display_single_window_across_instance == true then
        print('single terminal across tabs!')
        -- Close all windows displaying the terminal buffer
        closeWindowsByBufferName(term_name)
        -- Now split window and launch the task
        local terminal_window = set_new_window_for_buffer(true, term_idx, term_height)
        send_commands_to_terminal(term_name, cmd, is_startinsert, terminal_window)
        --
        -- Next, we check if the user wants single buffer per tab
    elseif keep_single_terminal_per_tab == true then
        if is_buffer_hidden_in_current_tab(term_name) == true then
            print("terminal buffer is hidden!")
            -- Since the buffer is hidden, we open it below the current split
            local terminal_window = set_new_window_for_buffer(true, term_idx, term_height)
            send_commands_to_terminal(term_name, cmd, is_startinsert, previous_window)
            -- Else: Terminal is not hidden in current tabpage
        else
            print("terminal buffer is not hidden!.....")
            -- Since, it is open in another window, we check how many windows display the buffer
            -- Check if user wants to keep the terminal window in this buffer as static
            if keep_terminal_in_tab_static == true then
                print("running cmake task")
                local terminal_window = get_windows_for_buffer_in_current_tab(term_name)[1]
                send_commands_to_terminal(term_name, cmd, is_startinsert, previous_window)
            else --- If user wants location of the single window tab as [[ NOT ]] static location
                print("User wants to replace the loaction of the terminal in this current tab")
                -- If terminal is displayed in a split in the current tab and close it, reopen below the current window
                -- close all the windows/split that display our terminal and reopen
                local windows_that_display_terminal_in_current_tab = get_windows_for_buffer_in_current_tab(term_name)
                for _, win_nr in ipairs(windows_that_display_terminal_in_current_tab) do
                    vim.api.nvim_win_close(win_nr, { force = false }) -- do not force close
                end
                -- Now we re-open a single window below the current window and run the cmake task
                local terminal_window = set_new_window_for_buffer(true, term_idx, term_height)
                send_commands_to_terminal(term_name, cmd, is_startinsert, previous_window)

                -- If the current window in already our terminal, then simply run the terminal cmake tasks,
                -- else close terminal window in this current tab and reopen below current split
            end
        end
    else -- Multiple buffers per tabpage
        if term_idx == vim.api.nvim_get_current_buf() then
            print("run task without splitting")
            set_new_window_for_buffer(false, term_idx, term_height)
            send_commands_to_terminal(term_name, cmd, is_startinsert, previous_window)
        else
            print('create window, load  buffer and run task')
            set_new_window_for_buffer(true, term_idx, term_height)
            send_commands_to_terminal(term_name, cmd, is_startinsert, previous_window)
        end
    end
else
    -- terminal does not exist, as we create the terminal first and immediately name it.
    -- Next time when we get the terminal, we use it's name to get it
    vim.cmd(':' .. positon .. ' :sp' .. ' | :term')
    print("newly creating terminal")
    term_channel = vim.api.nvim_buf_get_option(0, 'channel') -- get terminal channel. Next time, get channel number by name
    vim.api.nvim_buf_set_name(0, term_name)                  -- immediately set name
    set_new_window_for_buffer(false, 0, term_height)
    send_commands_to_terminal(term_name, cmd, is_startinsert, previous_window)
end


local term_buffer_nr, term_channel_nr = get_terminal_buffer_number_and_channel_number('my_term')

print("term_buffer_nr: " .. term_buffer_nr .. ", term_channel_nr: " .. term_channel_nr)