feat: alpha-dashboard added

README.md

@@ -0,0 +1 @@
+# NeoVim config repository from Ward Truyen 2025

lua/ward/.luarc.json

@@ -0,0 +1,5 @@
+{
+    "diagnostics.globals": [
+        "vim"
+    ]
+}

lua/ward/init.lua

@@ -7,3 +7,10 @@ require("ward.remap")
 
 --$ instal/load Lazy plugin manager
 require("ward.lazy")
+
+--$ Neovide configuration if used
+if vim.g.neovide then
+  vim.g.neovide_opacity = 0.75
+  vim.g.neovide_window_blurred = true
+  vim.o.guifont = "Source Code Pro:h14"
+end

lua/ward/plugins/alpha-dashboard.lua

@@ -0,0 +1,191 @@
+return {
+	"goolord/alpha-nvim",
+	dependencies = {
+		"nvim-telescope/telescope.nvim",
+	-- 	"nvim-telescope/telescope-project.nvim",
+	},
+	priority = 2000,
+	lazy = false,
+	config = function()
+		-- require("telescope").load_extension("project")
+		local alpha = require("alpha")
+		local dashboard = require("alpha.themes.dashboard")
+		local datetime = tonumber(os.date(" %H "))
+		local stats = require("lazy").stats()
+		local total_plugins = stats.count
+		local function button(sc, txt, keybind, keybind_opts)
+			local b = dashboard.button(sc, txt, keybind, keybind_opts)
+			b.opts.hl_shortcut = "MiniIconsPurple"
+			return b
+		end
+		local logo = [[
+                       _
+ _ __   ___  _____   _(_)_ __ ___
+| '_ \ / _ \/ _ \ \ / / | '_ ` _ \
+| | | |  __/ (_) \ V /| | | | | | |
+|_| |_|\___|\___/ \_/ |_|_| |_| |_|
+]]
+		dashboard.section.header.val = vim.split(logo, "\n")
+		dashboard.section.buttons.val = {
+			-- button("p", " Find project", ":lua require'telescope'.extensions.project.project{}<CR>"),
+			button("n", " New file", ":ene <BAR> startinsert <CR>"),
+			button("f", " Find Files", ":Telescope find_files <CR>"),
+			button("o", " Recent Files", "<cmd>Telescope oldfiles<cr>"),
+			button("t", " Find text", ":Telescope live_grep <CR>"),
+			button("m", "  Bookmarks", ":Telescope marks <CR>"),
+			button("c", " Neovim config", "<cmd>e ~/.config/nvim/ | cd %:p:h<cr>"),
+			button("l", "󰒲 Lazy", "<cmd>Lazy<cr>"),
+			button("q", " Quit NVIM", ":qa<CR>"),
+		}
+
+		local function footer()
+			local footer_datetime = os.date("  %m-%d-%Y   %H:%M:%S")
+			local version = vim.version()
+			local nvim_version_info = "   v" .. version.major .. "." .. version.minor .. "." .. version.patch
+			-- local ms = (math.floor(stats.startuptime * 100 + 0.5) / 100)
+			local value = footer_datetime .. "   Plugins " .. total_plugins .. nvim_version_info
+			return value
+		end
+
+		-- Append the footer string below the ASCII art
+		local count = 0
+		for _ in pairs(dashboard.section.header.val) do
+			count = count + 1
+		end
+		local extraline = count - 14
+		print(extraline)
+
+		for _ = 1, extraline do
+			table.insert(dashboard.section.header.val, 1, "")
+		end
+		-- table.insert(dashboard.section.header.val, footer())
+
+		-- dashboard.section.footer.val = require("alpha.fortune")()
+		dashboard.section.footer.val = footer()
+
+		local greeting = function()
+			-- Determine the appropriate greeting based on the hour
+			local mesg
+			local username = os.getenv("USER")
+			if datetime >= 0 and datetime < 6 then
+				mesg = "Dreaming..󰒲 󰒲 "
+			elseif datetime >= 6 and datetime < 12 then
+				mesg = "🌅 Hi " .. username .. ", Good Morning ☀️"
+			elseif datetime >= 12 and datetime < 18 then
+				mesg = "🌞 Hi " .. username .. ", Good Afternoon ☕️"
+			elseif datetime >= 18 and datetime < 21 then
+				mesg = "🌆 Hi " .. username .. ", Good Evening 🌙"
+			else
+				mesg = "Hi " .. username .. ", it's getting late, get some sleep 😴"
+			end
+			return mesg
+		end
+
+		local function capture(cmd, raw)
+			local f = assert(io.popen(cmd, "r"))
+			local s = assert(f:read("*a"))
+			f:close()
+			if raw then
+				return s
+			end
+			s = string.gsub(s, "^%s+", "")
+			s = string.gsub(s, "%s+$", "")
+			s = string.gsub(s, "[\n\r]+", " ")
+			return s
+		end
+
+		local function split(source, sep)
+			local result, i = {}, 1
+			while true do
+				local a, b = source:find(sep)
+				if not a then
+					break
+				end
+				local candidat = source:sub(1, a - 1)
+				if candidat ~= "" then
+					result[i] = candidat
+				end
+				i = i + 1
+				source = source:sub(b + 1)
+			end
+			if source ~= "" then
+				result[i] = source
+			end
+			return result
+		end
+
+		local bottom_section = {
+			type = "text",
+			val = greeting,
+			opts = {
+				position = "center",
+			},
+		}
+
+		local section = {
+			header = dashboard.section.header,
+			bottom_section = bottom_section,
+			buttons = dashboard.section.buttons,
+			footer = dashboard.section.footer,
+		}
+
+		local opts = {
+			layout = {
+				{ type = "padding", val = 1 },
+				section.header,
+				{ type = "padding", val = 1 },
+				section.buttons,
+				{ type = "padding", val = 1 },
+				section.bottom_section,
+				{ type = "padding", val = 1 },
+				section.footer,
+			},
+		}
+		dashboard.opts.opts.noautocmd = true
+
+		-- close Lazy and re-open when the dashboard is ready
+		if vim.o.filetype == "lazy" then
+			vim.cmd.close()
+			vim.api.nvim_create_autocmd("User", {
+				once = true,
+				pattern = "AlphaReady",
+				callback = function()
+					require("lazy").show()
+				end,
+			})
+		end
+
+		alpha.setup(opts)
+
+		-- don't show status line in alpha dashboard
+		vim.api.nvim_create_autocmd({ "User" }, {
+			pattern = { "AlphaReady" },
+			callback = function()
+				vim.cmd([[ set laststatus=0 | autocmd BufUnload <buffer> set laststatus=3 ]])
+			end,
+		})
+
+		-- onefetch header for alpha dashboard if onefetch is installed and git repo is present
+		vim.api.nvim_create_augroup("vimrc_alpha", { clear = true })
+		vim.api.nvim_create_autocmd({ "User" }, {
+			group = "vimrc_alpha",
+			pattern = "AlphaReady",
+			callback = function()
+				if vim.fn.executable("onefetch") == 1 then
+					local header = split(
+						capture(
+							[[onefetch 2>/dev/null | sed 's/\x1B[@A-Z\\\]^_]\|\x1B\[[0-9:;<=>?]*[-!"#$%&'"'"'()*+,.\/]*[][\\@A-Z^_`a-z{|}~]//g']],
+							true
+						),
+						"\n"
+					)
+					if next(header) ~= nil then
+						require("alpha.themes.dashboard").section.header.val = header
+						require("alpha").redraw()
+					end
+				end
+			end,
+			once = true,
+		})
+	end,
+}

lua/ward/plugins/autocomplete.lua

@@ -1,9 +1,9 @@
---$ autocomplete for C++ Rust and Lua
+--$ autocomplete for C++, Rust, Lua, etc
 --$ URL: https://github.com/hrsh7th/nvim-cmp
 --$ help: nvim-cmp
 return {
   "hrsh7th/nvim-cmp",
-  event = "InsertEnter",
+  -- event = "InsertEnter",
   dependencies = {
     -- Snippet Engine & its associated nvim-cmp source
     {

lua/ward/plugins/bufdel.lua

@@ -0,0 +1,13 @@
+--$ This allows buffers to be closed but not the window
+--$ URL: https://github.com/ojroques/nvim-bufdel
+return {
+  "ojroques/nvim-bufdel",
+  version = "*",
+  config = function()
+    require('bufdel').setup {
+      next = 'tabs',
+      quit = false,
+    }
+    vim.keymap.set("n", "<leader>bc", vim.cmd.BufDel)
+  end,
+}

lua/ward/plugins/catppucin.lua

@@ -6,7 +6,11 @@ return {
   priority = 1000,
 
   config = function()
-    require("catppuccin").setup({})
+    require("catppuccin").setup({
+      transparent_backgroud = true,
+      term_colors = true,
+    })
     vim.cmd.colorscheme("catppuccin")
+    LineNumberColors()
   end,
 }

lua/ward/plugins/dap-ui.lua

@@ -0,0 +1,32 @@
+-- NOTE: Debug Adapter Protocol User interface, start and close automaticly config
+return {
+  "rcarriga/nvim-dap-ui",
+  dependencies = { "mfussenegger/nvim-dap", "nvim-neotest/nvim-nio" },
+  config = function()
+    local dap, dapui = require("dap"), require("dapui")
+    dapui.setup()
+    dap.listeners.before.attach.dapui_config = function()
+      dapui.open()
+    end
+    dap.listeners.before.launch.dapui_config = function()
+      dapui.open()
+    end
+    dap.listeners.before.event_terminated.dapui_config = function()
+      dapui.close()
+    end
+    dap.listeners.before.event_exited.dapui_config = function()
+      dapui.close()
+    end
+
+    vim.api.nvim_create_autocmd("LspAttach", {
+      group = vim.api.nvim_create_augroup("UserDapUIConfig", {}),
+      callback = function(event)
+        local wk = require("which-key")
+        wk.add({
+          { "<leader>dd", desc = "Toggle DAP UI" },
+        })
+        vim.keymap.set('n', '<Leader>dd', function() require('dapui').toggle() end)
+      end,
+    })
+  end,
+}

lua/ward/plugins/dap.lua

@@ -0,0 +1,120 @@
+-- NOTE: Debug Adapter Protocol
+-- URL: https://github.com/mfussenegger/nvim-dap/wiki/Debug-Adapter-installation
+return {
+  "mfussenegger/nvim-dap",
+  config = function()
+    -- NOTE: Check out this for guide
+    vim.fn.sign_define("DapBreakpoint", { text = "", texthl = "DiagnosticSignError", linehl = "", numhl = "" })
+
+    -- These dap keybinds only load when an LSP is attatched to the buffer.
+    vim.api.nvim_create_autocmd("LspAttach", {
+      group = vim.api.nvim_create_augroup("UserDapConfig", {}),
+      callback = function(event)
+        local wk = require("which-key")
+        wk.add({
+          { "<leader>d",     group = "DAP" },
+          { "<leader>dd",    desc = "Toggle DAP UI" },
+          { "<leader>db",    desc = "Toggle breakpoint" },
+          { "<leader>dB",    desc = "Set breakpoint" },
+          { "<leader>dm",    desc = "message point" },
+          { "<leader>dr",    desc = "Open repl" },
+          { "<leader>dl",    desc = "Run last" },
+          { "<leader>dh",    desc = "Hover widgets" },
+          { "<leader>dp",    desc = "Preview widgets" },
+          { "<leader>df",    desc = "Float frames" },
+          { "<leader>ds",    desc = "Float scopes" },
+          { "<leader>d<F5>", desc = "Debug start/continue" },
+          { "<leader>d<F6>", desc = "Debug step over" },
+          { "<leader>d<F7>", desc = "Debug step into" },
+          { "<leader>d<F8>", desc = "Debug step out" },
+        })
+        vim.keymap.set('n', '<F5>', function() require('dap').continue() end)
+        vim.keymap.set('n', '<F6>', function() require('dap').step_over() end)
+        vim.keymap.set('n', '<F7>', function() require('dap').step_into() end)
+        vim.keymap.set('n', '<F8>', function() require('dap').step_out() end)
+        vim.keymap.set('n', '<Leader>db', function() require('dap').toggle_breakpoint() end)
+        vim.keymap.set('n', '<Leader>dB', function() require('dap').set_breakpoint() end)
+        vim.keymap.set('n', '<Leader>dm',
+          function() require('dap').set_breakpoint(nil, nil, vim.fn.input('Log point message: ')) end)
+        vim.keymap.set('n', '<Leader>dr', function() require('dap').repl.open() end)
+        vim.keymap.set('n', '<Leader>dl', function() require('dap').run_last() end)
+        vim.keymap.set({ 'n', 'v' }, '<Leader>dh', function()
+          require('dap.ui.widgets').hover()
+        end)
+        vim.keymap.set({ 'n', 'v' }, '<Leader>dp', function()
+          require('dap.ui.widgets').preview()
+        end)
+        vim.keymap.set('n', '<Leader>df', function()
+          local widgets = require('dap.ui.widgets')
+          widgets.centered_float(widgets.frames)
+        end)
+        vim.keymap.set('n', '<Leader>ds', function()
+          local widgets = require('dap.ui.widgets')
+          widgets.centered_float(widgets.scopes)
+        end)
+      end,
+    })
+
+
+
+    -- configure C/C++
+    -- NOTE: Make sure to install the needed files/exectubles through mason
+    local dap = require("dap")
+    dap.adapters.gdb = {
+      type = "executable",
+      command = "gdb",
+      args = { "--interpreter=dap", "-eval-command", "set print pretty on" },
+    }
+
+    dap.configurations.cpp = {
+      {
+        name = "Launch",
+        type = "gdb",
+        request = "launch",
+        program = function()
+          local storedValue = vim.g['mydap_program']
+          local preFill = vim.fn.getcwd() .. "/"
+          if storedValue ~= nil then preFill = storedValue end
+          local newValue = vim.fn.input("Path to executable: ", preFill, "file")
+          vim.g['mydap_program'] = newValue
+          return newValue
+        end,
+        args = function()
+          local storedValue = vim.g['mydap_args']
+          local preFill = ""
+          if storedValue ~= nil then preFill = storedValue end
+          local newValue = vim.fn.input("Arguements: ", preFill)
+          vim.g['mydap_args'] = newValue
+          return newValue
+        end,
+        cwd = "${workspaceFolder}",
+        stopAtBeginningOfMainSubprogram = false,
+      },
+      {
+        name = "Select and attach to process",
+        type = "gdb",
+        request = "attach",
+        program = function()
+          return vim.fn.input('Path to executable: ', vim.fn.getcwd() .. '/', 'file')
+        end,
+        pid = function()
+          local name = vim.fn.input('Executable name (filter): ')
+          return require("dap.utils").pick_process({ filter = name })
+        end,
+        cwd = '${workspaceFolder}'
+      },
+      {
+        name = 'Attach to gdbserver :1234',
+        type = 'gdb',
+        request = 'attach',
+        target = 'localhost:1234',
+        program = function()
+          return vim.fn.input('Path to executable: ', vim.fn.getcwd() .. '/', 'file')
+        end,
+        cwd = '${workspaceFolder}'
+      },
+    }
+
+    dap.configurations.c = dap.configurations.cpp
+  end,
+}

lua/ward/plugins/gitsigns.lua

@@ -1,3 +1,4 @@
+--Note: this will show what part of a file was changed deleted or added in a git repo
 return {
   "lewis6991/gitsigns.nvim",
   -- event = "BufReadPre",
@@ -13,7 +14,11 @@ return {
         -- untracked = { text = "┆" },
       },
       numhl  = true,      -- Toggle with `:Gitsigns toggle_numhl`
-      linehl     = true, -- Toggle with `:Gitsigns toggle_linehl`
+      linehl = false,     -- Toggle with `:Gitsigns toggle_linehl`
     }
+
+    vim.keymap.set('n', '<Leader>xs', function()
+      require("gitsigns").refresh();
+    end, { desc = "Gitsigns refresh" })
   end,
 }

lua/ward/plugins/lsp-config.lua

@@ -1,3 +1,5 @@
+-- NOTE: this adds a Language Server Provider for source files like C++, Java/-Script, etc.
+--        It will check the code for errors, warnings, variables and structures and give suggestions.
 return {
   "neovim/nvim-lspconfig",
   version = "*",
@@ -26,9 +28,23 @@ return {
     }
 
     lspconfig.clangd.setup({
+      keys = {
+        { "<leader>pc", "<cmd>ClangdSwitchSourceHeader<cr>", desc = "Switch Source/Header (C/C++)" },
+      },
       cmd = {
         "clangd",
         "--offset-encoding=utf-16",
+        "--background-index",
+        "--clang-tidy",
+        "--header-insertion=iwyu",
+        "--completion-style=detailed",
+        "--function-arg-placeholders",
+        "-j4",
+        "--fallback-style=llvm",
+      },
+      filetypes = { "c", "cpp", "objc", "objcpp", "cuda", "proto", "hpp" },
+      init_options = {
+        fallbackFlags = { '-std=c17' },
       },
       handlers = handlers,
     })
@@ -88,6 +104,11 @@ return {
         --  To jump back, press <C-t>.
         map("gd", require("telescope.builtin").lsp_definitions, "[G]oto [D]efinition")
 
+        -- WARN: This is not Goto Definition, this is Goto Declaration.
+        --  For example, in C this would take you to the header.
+        map("gD", vim.lsp.buf.declaration, "[G]oto [D]eclaration")
+
+
         -- Find references for the word under your cursor.
         map("gr", require("telescope.builtin").lsp_references, "[G]oto [R]eferences")
 
@@ -100,6 +121,11 @@ return {
         --  the definition of its *type*, not where it was *defined*.
         map("<leader>ld", require("telescope.builtin").lsp_type_definitions, "Type [D]efinition")
 
+        -- Jump to the type of the word under your cursor.
+        --  Useful when you're not sure what type a variable is and you want to see
+        --  the definition of its *type*, not where it was *defined*.
+        map("<leader>lD", vim.lsp.buf.declaration, "Go to [D]eclaration")
+
         -- Fuzzy find all the symbols in your current document.
         --  Symbols are things like variables, functions, types, etc.
         map("<leader>ls", require("telescope.builtin").lsp_document_symbols, "document [S]ymbols")
@@ -114,6 +140,7 @@ return {
           require("telescope.builtin").lsp_dynamic_workspace_symbols,
           "[W]orkspace symbols"
         )
+        map("<leader>li", vim.cmd.LspInfo, "Show lsp info")
         map("<leader>lp", vim.diagnostic.goto_prev, "Go to [P]revious diagnostic message")
 
         map("<leader>ln", vim.diagnostic.goto_next, "Go to [N]ext diagnostic message")
@@ -134,10 +161,6 @@ return {
         -- Opens a popup that displays documentation about the word under your cursor
         --  See `:help K` for why this keymap.
 
-        -- WARN: This is not Goto Definition, this is Goto Declaration.
-        --  For example, in C this would take you to the header.
-        map("gD", vim.lsp.buf.declaration, "[G]oto [D]eclaration")
-
         map("<leader>th", function()
           vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled({ bufnr = event.buf }))
         end, "[T]oggle Inlay [H]ints")

lua/ward/plugins/mason.lua

@@ -2,17 +2,18 @@
 --$ URL: https://github.com/williamboman/mason.nvim
 --$ :Mason
 return {
-  "williamboman/mason.nvim",
-
+  {
+    "mason-org/mason-lspconfig.nvim",
+    opts = {},
+    dependencies = {
+      {
+        "mason-org/mason.nvim",
         config = function()
           require("mason").setup()
+          vim.keymap.set("n", "<leader>xm", vim.cmd.Mason, { desc = "Mason" })
         end,
-
-  opts = {
-    ensure_installed = {
-      "clangd",
-      "clang-format",
-      "codelldb",
+      },
+      "neovim/nvim-lspconfig",
     },
   },
 }

lua/ward/plugins/nvim-tree.lua

@@ -15,9 +15,34 @@ return {
     require("nvim-tree").setup({
       view = {
         width = 32,
+        relativenumber = true,
       },
+      filters = {
+        git_ignored = false,
+      },
+      actions = {
+        open_file = {
+          quit_on_open = true,
+        },
+      },
+      on_attach = function(bufnr)
+        local api = require "nvim-tree.api"
+
+        local function opts(desc)
+          return { desc = "nvim-tree: " .. desc, buffer = bufnr, noremap = true, silent = true, nowait = true }
+        end
+
+        -- default mappings
+        api.config.mappings.default_on_attach(bufnr)
+
+        -- custom mappings
+        vim.keymap.set('n', '<Esc>', vim.cmd.NvimTreeClose, opts('Close Explorer'))
+        -- vim.keymap.set('n', '<C-t>', api.tree.change_root_to_parent, opts('Up'))
+        vim.keymap.set('n', '?', api.tree.toggle_help, opts('Help'))
+      end,
     })
-    vim.keymap.set("n", "<leader>e", vim.cmd.NvimTreeToggle)
+
+    vim.keymap.set("n", "<leader>e", vim.cmd.NvimTreeToggle, { desc = "Explorer" })
     vim.api.nvim_create_autocmd({ "QuitPre" }, { callback = function() vim.cmd("NvimTreeClose") end, })
   end,
 }

lua/ward/plugins/render-markdown.lua

@@ -0,0 +1,9 @@
+-- NOTE: This plugin activly shows the result of your markdown while you're typing it
+-- URL: https://https://github.com/MeanderingProgrammer/render-markdown.nvim
+return {
+    'MeanderingProgrammer/render-markdown.nvim',
+    -- dependencies = { 'nvim-treesitter/nvim-treesitter', 'echasnovski/mini.nvim' }, -- if you use the mini.nvim suite
+    -- dependencies = { 'nvim-treesitter/nvim-treesitter', 'echasnovski/mini.icons' }, -- if you use standalone mini plugins
+    dependencies = { 'nvim-treesitter/nvim-treesitter', 'nvim-tree/nvim-web-devicons' }, -- if you prefer nvim-web-devicons
+    opts = {},
+}

lua/ward/plugins/telescope.lua

@@ -10,19 +10,23 @@ return {
     require('telescope').setup()
 
     local builtin = require('telescope.builtin')
-    vim.keymap.set('n', '<leader>pf', builtin.find_files, {})
-    vim.keymap.set('n', '<leader>pg', builtin.git_files, {})
-    vim.keymap.set('n', '<leader>pws', function()
+    local wk = require("which-key")
+    wk.add({
+      { "<leader>p", group = "Project" },
+    })
+    vim.keymap.set('n', '<leader>pf', builtin.find_files, { desc = "Find file" })
+    vim.keymap.set('n', '<leader>pg', builtin.git_files, { desc = "Git files" })
+    vim.keymap.set('n', '<leader>pw', function()
       local word = vim.fn.expand("<cword>")
       builtin.grep_string({ search = word })
-    end)
-    vim.keymap.set('n', '<leader>pWs', function()
+    end, { desc = "Grep word search" })
+    vim.keymap.set('n', '<leader>pW', function()
       local word = vim.fn.expand("<cWORD>")
       builtin.grep_string({ search = word })
-    end)
+    end, { desc = "Grep WORD search" })
     vim.keymap.set('n', '<leader>ps', function()
       builtin.grep_string({ search = vim.fn.input("Grep > ") })
-    end)
+    end, { desc = "Grep string search" })
     vim.keymap.set('n', '<leader>vh', builtin.help_tags, { desc = "Search [H]elp" })
     vim.keymap.set('n', '<leader>vk', builtin.keymaps, { desc = "Search [K]eymaps" })
   end

lua/ward/plugins/toggleterm.lua

@@ -16,7 +16,7 @@ return{
         return 20
       end,
     })
-    vim.keymap.set('n', '<leader>t', ":ToggleTerm name=BottomTerm<cr>")
+    vim.keymap.set('n', '<leader>`', ":ToggleTerm name=BottomTerm<cr>", { desc = "ToggleTerm" })
     --vim.keymap.set('n', '<leader>tv', ":ToggleTerm direction=vertical name=VerticalTerm<cr>")
     --vim.keymap.set('n', '<leader>tf', ":ToggleTerm direction=float name=FloatTerm<cr>")
   end,

lua/ward/plugins/trouble.lua

@@ -0,0 +1,39 @@
+--$ URL: https://github.com/folke/trouble.nvim
+--# :help trouble
+return {
+  "folke/trouble.nvim",
+  opts = {}, -- for default options, refer to the configuration section for custom setup.
+  cmd = "Trouble",
+  keys = {
+    {
+      "<leader>tx",
+      "<cmd>Trouble diagnostics toggle<cr>",
+      desc = "Diagnostics (Trouble)",
+    },
+    {
+      "<leader>tq",
+      "<cmd>Trouble diagnostics toggle filter.buf=0<cr>",
+      desc = "Buffer Diagnostics (Trouble)",
+    },
+    {
+      "<leader>ts",
+      "<cmd>Trouble symbols toggle focus=false<cr>",
+      desc = "Symbols (Trouble)",
+    },
+    {
+      "<leader>tl",
+      "<cmd>Trouble lsp toggle focus=false win.position=right<cr>",
+      desc = "LSP Definitions / references / ... (Trouble)",
+    },
+    {
+      "<leader>tL",
+      "<cmd>Trouble loclist toggle<cr>",
+      desc = "Location List (Trouble)",
+    },
+    {
+      "<leader>tq",
+      "<cmd>Trouble qflist toggle<cr>",
+      desc = "Quickfix List (Trouble)",
+    },
+  },
+}

lua/ward/plugins/which-key.lua

@@ -21,33 +21,18 @@ return {
     --# Structure of my standard keys
     local wk = require("which-key")
     wk.add({
-      {"<leader>w", desc = "Write"},
-      {"<leader>q", desc = "Quit"},
-      {"<leader>e", desc = "Explore"},
-      {"<leader><TAB>", desc = "Switch window"},
-      {"<leader>n", desc = "Next buffer"},
-      {"<leader>b", group = "Buffers"}, -- group
-      {"<leader>bn", desc = "Next buffer"},
-      {"<leader>bp", desc = "Pervious buffer"},
-      {"<leader>bb", desc = "Pervious buffer"},
-      {"<leader>bl", desc = "Buffer list"},
-      {"<leader>bc", desc = "Close buffer"},
-      {"<leader>t", group = "Terminal"},
-      {"<leader>tt", desc = "Bottom Terminal"},
-      {"<leader>tv", desc = "Vertical Terminal"},
-      {"<leader>tf", desc = "Floating Terminal"},
-      {"<leader>p", group = "Project"},
-      {"<leader>pf", desc = "Find file"},
-      {"<leader>pg", desc = "Git files"},
-      {"<leader>ps", desc = "Grep string search"},
-      {"<leader>pw", desc = "Grep word search"},
-      {"<leader>pW", desc = "Grep WORD search"},
+      { "<leader>b",  group = "Buffers" },
+      { "<leader>t",  group = "Trouble" },
       { "<leader>v",  group = "Vim" },
-      {"<leader>vh", desc = "Help search" },
-      {"<leader>vm", "<Cmd>marks<Cr>", desc = "Marks", },
-      {"<leader>vr", "<Cmd>registers<Cr>", desc = "Registers" },
-      {"<leader>h", "<Cmd>nohlsearch<Cr>", desc = "Stop Highlight" },
       { "<leader>l",  group = "LSP" },
+      { "<leader>x",  group = "Plugins" },
+      { "<leader>xl", vim.cmd.Lazy,      desc = "Lazy" },
+      { "<leader>xw", vim.cmd.WhichKey,  desc = "Which-key" },
+      { "<leader>w", function()
+          wk.show({ keys = "<c-w>" })
+        end,
+        desc = "Windows"
+      },
     })
   end,
 }

lua/ward/remap.lua

@@ -3,22 +3,26 @@
 vim.g.mapleader = " "
 vim.g.maplocalleader = "\\"
 
-vim.keymap.set("n", "<leader>w", vim.cmd.w)
-vim.keymap.set("n", "<leader>q", vim.cmd.q)
-vim.keymap.set("n", "<leader>bn", vim.cmd.bnext)
-vim.keymap.set("n", "<leader>n", vim.cmd.bnext)
-vim.keymap.set("n", "<leader>bp", vim.cmd.bprevious)
-vim.keymap.set("n", "<leader>bb", vim.cmd.bprevious)
-vim.keymap.set("n", "<leader>bl", vim.cmd.buffers)
-vim.keymap.set("n", "<leader>bc", vim.cmd.bdelete)
-vim.keymap.set("n", "<leader>e", vim.cmd.Ex)
-vim.keymap.set("n", "<leader><TAB>", [[<C-w>w]])
-vim.keymap.set("n", "<leader>vm", "<Cmd>marks<Cr>")
-vim.keymap.set("n", "<leader>vr", "<Cmd>registers<Cr>")
-vim.keymap.set("n", "<leader>h", "<Cmd>nohlsearch<Cr>")
+vim.keymap.set("n", "<leader>bn", vim.cmd.bnext, { desc = "Next buffer" })
+vim.keymap.set("n", "<leader>n", vim.cmd.bnext, { desc = "Next buffer" })
+vim.keymap.set("n", "<leader>bw", vim.cmd.w, { desc = "Write buffer" })
+vim.keymap.set("n", "<leader>bp", vim.cmd.bprevious, { desc = "Previous buffer" })
+vim.keymap.set("n", "<leader>bb", vim.cmd.bprevious, { desc = "Previous buffer" })
+vim.keymap.set("n", "<leader>bl", vim.cmd.buffers, { desc = "List buffers" })
+vim.keymap.set("n", "<leader>bc", vim.cmd.bdelete, { desc = "Close buffer" })
+vim.keymap.set("n", "<leader>e", vim.cmd.Ex, { desc = "Explore" })
+vim.keymap.set("n", "<leader>vq", vim.cmd.qall, { desc = "Quit vim" })
+vim.keymap.set("n", "<leader>vm", "<Cmd>marks<Cr>", {desc = "Marks"})
+vim.keymap.set("n", "<leader>vr", "<Cmd>registers<Cr>", {desc = "Registers"})
+vim.keymap.set("n", "<leader>h", "<Cmd>nohlsearch<Cr>", {desc = "Stop Highlight"})
+vim.keymap.set("n", "<leader><TAB>", [[<C-w>w]], { desc = "Next Window" })
+-- vim.keymap.set("n", "<leader>wh", [[<C-w>h]], { desc = "Window left" })
+-- vim.keymap.set("n", "<leader>wl", [[<C-w>l]], { desc = "Window right" })
+-- vim.keymap.set("n", "<leader>wj", [[<C-w>j]], { desc = "Window down" })
+-- vim.keymap.set("n", "<leader>wk", [[<C-w>k]], { desc = "Window up" })
 
 --"$ map exit terminal mode to Escape
-vim.keymap.set("t", "<Esc>", [[<C-\><C-n>]])
+vim.keymap.set("t", "<Esc>", [[<C-\><C-n>]], { desc = "Escape terminal" })
 
 --"$ normal mappings
 --"$ up/down half a page centered
@@ -27,7 +31,12 @@ vim.keymap.set("n", "<C-u>", [[<C-u>zz]])
 --nnoremap <C-d> <C-d>zz
 --nnoremap <C-u> <C-u>zz
 --"$centered next/prev find
-vim.keymap.set("n", "n", [[nzzv]])
-vim.keymap.set("n", "N", [[Nzzv]])
+vim.keymap.set("n", "n", [[nzz]])
+vim.keymap.set("n", "N", [[Nzz]])
 --nnoremap n nzzzv
 --nnoremap N Nzzzv
+
+vim.keymap.set({ "n", "x", "c", "v" }, "<C-S-C>", '"+y', { desc = "Copy system clipboard" }) -- ctrl+shift+c
+vim.keymap.set({ "i", "c" }, "<C-S-V>", '<C-R>+', { desc = "Paste system clipboard" })       -- ctrl+shift+v
+vim.keymap.set({ "n", "x" }, "<C-S-V>", '"+P', { desc = "Paste system clipboard" })          -- ctrl+shift+v
+vim.keymap.set({ "i", "n", "x", "c", "v" }, "<C-S>", vim.cmd.w)                                   -- save=crtl+s

lua/ward/setup.lua

@@ -1,6 +1,6 @@
 vim.g.have_nerd_font = true       -- use nerd_font
 
-vim.opt.clipboard = 'unnamedplus' -- use system keyboard for yank
+vim.opt.clipboard = "unnamedplus" -- use system keyboard for yank
 
 vim.opt.nu = true                 -- set line numbers
 vim.opt.relativenumber = true     -- use relative line numbers
@@ -17,8 +17,20 @@ vim.opt.wrap = false
 --vim.opt.colorcolumn= 110
 vim.api.nvim_set_option_value("colorcolumn", "110", {})
 
-vim.opt.confirm = true
-vim.opt.hlsearch = true
+vim.opt.confirm = true   -- confirm on quit with unsave changes
+vim.opt.hlsearch = true  -- highlight search
 vim.opt.incsearch = true -- incremental search
 
 vim.opt.termguicolors = true
+
+--set shell=/usr/bin/zsh
+vim.opt.shell='/usr/bin/zsh'
+
+-- Sets colors to line numbers Above, Current and Below  in this order
+function LineNumberColors()
+  vim.api.nvim_set_hl(0, "LineNrAbove", { fg = "#51B3EC", bold = false })
+  vim.api.nvim_set_hl(0, "LineNr", { fg = white, bold = true })
+  vim.api.nvim_set_hl(0, "LineNrBelow", { fg = "#FB508F", bold = false })
+end
+
+LineNumberColors()

makefile

@@ -0,0 +1,33 @@
+NVIM_CONFIG=~/.config/nvim/#
+
+default : print-help
+help : print-help
+
+print-help :
+	@echo -e "Help!?!?"
+	@echo -e "Use 'make instal' to instal this config to your home config"
+	@echo -e "Use 'make instal-optionals' to instal additional interesting packages: nvim, neovide, wl-clipboard"
+	@echo -e "Use 'make instal-zsh-optionals' to instal additional interesting packages: zsh, easy-zsh-config, oh-my-posh"
+	@echo -e "Use 'make code' to get code from your config to this project"
+	@echo -e "ConfigPath=$(NVIM_CONFIG)"
+
+instal :
+	@echo -e "Installing to $(NVIM_CONFIG)"
+	cp ./*.lua $(NVIM_CONFIG)
+	cp -r ./lua $(NVIM_CONFIG)
+
+instal-optionals :
+	sudo pacman -S --needed vim nvim tree
+	sudo pacman -S --needed wl-clipboard #Use clipboard in wayland
+#	sudo pacman -S --needed xsel #Use clipboard in X11
+	sudo pacman -S --needed neovide #Neovim in graphical enviorment
+
+instal-zsh-optionals :
+	sudo pacman -S --needed zsh #zsh shell environment
+	yay -S --needed easy-zsh-config #zsh suggestion/command-completion and syntax higlighting
+	yay -S --needed oh-my-posh #zsh theme provider
+
+code :
+	@echo -e "Getting code from $(NVIM_CONFIG)"
+	cp $(NVIM_CONFIG)*.lua ./
+	cp -r $(NVIM_CONFIG)lua ./