vimrc2

" Options ================================================================ {{{1

" enconding
set encoding=utf-8
scriptencoding utf-8

" forget being compatible with good old vi
set nocompatible

" disable some of the plugings, depending on OS and Vim features available
let g:pathogen_blacklist = []
if !has('python3')
    let g:pathogen_blacklist += ['ultisnips']
endif

" this should be at the beginning to allow pathogen plugin to generate
" runtimepath before other plugings are loaded
if has('nvim')
    runtime bundle2-nvim/vim-pathogen/autoload/pathogen.vim
    execute pathogen#infect('bundle2-nvim/{}')
else
    runtime bundle2-vim/vim-pathogen/autoload/pathogen.vim
    execute pathogen#infect('bundle2-vim/{}')
endif
call pathogen#helptags()

" detect operating system
let s:os = substitute(system('uname'), "\n", '', '')

" detect terminal emulator
let s:term_prog     = substitute(system('printenv TERM_PROGRAM'), "\n", '', '')
let s:term_color    = substitute(system('printenv COLORTERM'), "\n", '', '')
let s:iterm_profile = substitute(system('printenv ITERM_PROFILE'), "\n", '', '')

" Filetype --------------------------------------------------------------- {{{2
"
if has('autocmd')
    filetype plugin indent on
endif

if has('syntax') && !exists('g:syntax_on')
    syntax enable
endif

runtime! ftplugin/man.vim
runtime macros/matchit.vim
runtime macros/justify.vim

" reduce timeout for matchit/matchpair
let g:matchparen_timeout = 5
let g:matchparen_insert_timeout = 5

" Colors  ---------------------------------------------------------------- {{{2
"

" change light/dark theme depending on the time of day
function! MySetBG()
    let hr = strftime('%H%M')
    let time_dark = '1700'
    let time_light = '0730'
    let bgtime_file = glob('~/.vim/light-dark')

    if filereadable(bgtime_file)
        let bgtimes = split(readfile(bgtime_file)[0])
        if !empty(bgtimes)
            let time_light = bgtimes[0]
            let time_dark = bgtimes[1]
        endif
    endif

    if s:iterm_profile =~? '.*dark.*' && s:term_prog !=# 'tmux'
        set background=dark
    elseif s:iterm_profile =~? '.*light.*' && s:term_prog !=# 'tmux'
        set background=light
    elseif hr >= time_dark
        set background=dark
    elseif hr >= time_light
        set background=light
    elseif hr >= 0
        set background=dark
    endif

    if has('nvim')
        if &background == 'light'
            lua require'toggleterm'.setup { shading_factor = 2 }
        else
            lua require'toggleterm'.setup { shading_factor = -30 }
        endif
    endif
endfunction

" enable 256 colors in terminal
if match($TERM, '256color') != -1
    set t_Co=256
endif

let g:lualine_theme = 'dracula'

if s:term_color ==# 'truecolor'
    if s:os ==? 'Linux' && !empty($TMUX)
        set background=dark
    endif

    " enable undercurl in terminal
    "   https://github.com/vim/vim/issues/1306#issuecomment-350887565
    let &t_Cs = "\e[4:3m"
    let &t_Ce = "\e[4:0m"

    " enable 24-bit color support in Vim8/Neovim
    if has('termguicolors')
        let &t_8f = "\<Esc>[38;2;%lu;%lu;%lum"
        let &t_8b = "\<Esc>[48;2;%lu;%lu;%lum"
        set termguicolors

        let g:neosolarized_bold = 1
        let g:neosolarized_italic = 1
        let g:neosolarized_underline = 1
        let g:neosolarized_termBoldAsBright = 1
        let g:neosolarized_vertSplitBgTrans = 1

        if s:iterm_profile =~? '.*solarized.*'
            if has('nvim')
                let g:lualine_theme = 'solarized'
                colorscheme solarized-normal
            else
                colorscheme NeoSolarized
            endif
            call MySetBG()
        else
            set background=dark
            let g:airline_theme='onedark'
            let g:lualine_theme = 'onedark'
            let g:colors_name = 'onedark'
            if has('nvim')
                " disable folded lines BG
                lua require('onedark').setup { style = 'dark', highlights = { ['Folded'] = { bg = 'none' } } }
            endif
            colorscheme onedark
        endif
    else
        if s:term_prog ==# 'iTerm.app' && s:iterm_profile =~? '.*solarized.*'
            colorscheme solarized
        else
            colorscheme chumakd-elflord
        endif
    endif
else
    colorscheme chumakd-elflord
endif

" enable ToggleBG command from solarized plugin for light/dark bg switching
runtime autoload/togglebg.vim

" Allow color schemes to do bright colors without forcing bold.
if &t_Co == 8 && $TERM !~# '^linux\|^Eterm'
  set t_Co=16
endif

" disable Powerline plugin if we don't have full color terminal
" because it makes status line totally black in this mode
if &t_Co == 8
    let g:Powerline_loaded = 1
endif

" Search  ---------------------------------------------------------------- {{{2
"
set ignorecase
set smartcase
set hlsearch
set incsearch
set nowrapscan


" Folding ---------------------------------------------------------------- {{{2
"
set foldcolumn=4
set foldmethod=syntax
set foldopen+=insert,jump

" set 'foldmethod' to 'manual' when entering insert mode
" this improves completion speed in order of magnitude
" from http://vim.wikia.com/wiki/Keep_folds_closed_while_inserting_text
augroup fold_completion_fix
    autocmd!
    autocmd InsertEnter * if !exists('w:last_fdm') | let w:last_fdm=&foldmethod | setlocal foldmethod=manual | endif
    autocmd InsertLeave,WinLeave * if exists('w:last_fdm') | let &l:foldmethod=w:last_fdm | unlet w:last_fdm | endif
augroup END

" Indent ----------------------------------------------------------------- {{{2
"
set autoindent
set nocindent
set nosmartindent

" Tabstop ---------------------------------------------------------------- {{{2
"
set tabstop=4
set softtabstop=4
set shiftwidth=4
set shiftround
set smarttab
set expandtab

" Diff ------------------------------------------------------------------- {{{2
"
if has('mac') && $VIM == '/usr/share/vim'
    " do nothing
elseif has('patch-8.1.0360')
    " most accurate but slowest
    set diffopt+=algorithm:histogram
endif

" Spell ------------------------------------------------------------------ {{{2
"
set spelllang=en_us
set spelllang+=ru
"set spelllang+=ua

" Language --------------------------------------------------------------- {{{2
"

set dictionary=/usr/share/dict/words

" enable keymappings for russian win-like йцукен keyboards
set keymap=russian-jcukenwin

" force insert and search begin in english and non in keymap language
set iminsert=0
set imsearch=0

" enable language map for ru_RU.UTF-8 locale
set langmap=ФИСВУАПРШОЛДЬТЩЗЙКЫЕГМЦЧНЯ;ABCDEFGHIJKLMNOPQRSTUVWXYZ,фисвуапршолдьтщзйкыегмцчня;abcdefghijklmnopqrstuvwxyz,№#,х[,Х{,ъ],Ъ},Ж:,э',Б<,ю.,Ю>,Э\"

" Window ----------------------------------------------------------------- {{{2
"
set ruler

" show statusline even if there is only one window
set laststatus=2

if v:version >= 703
    set statusline=%h%w%q\ %f\ \%m%r\ %=\ <\ ts:%{&ts}\ et:%{&et}\ <\ %{&ft}\ \ \ LN:%3l:%-2v/\ %-4L\ [%P]
else
    set statusline=%h%w\ %f\ \%m%r\ %=\ <\ ts:%{&ts}\ et:%{&et}\ <\ %{&ft}\ \ \ LN:%3l:%-2v/\ %-4L\ [%P]
endif

set tabline=%!MyTabLine2()

set linebreak
let &showbreak='↪ '

set nowrap
set showcmd
set noshowmode
set winminheight=0
set wildmenu

" disable any fillchars for folds and vertical splits
" NOTE: the space after vert: is essential
"set fillchars=fold:\ ,vert:\  " empty space at the end intended
"set fillchars=fold:\ ,vert:┃,diff:╱
set fillchars=fold:\ ,vert:┃,diff:─

" Backup/Undo ------------------------------------------------------------ {{{2
"
set backup
set backupdir=~/.vim/backup,.,~/temp/tmp,~/

if v:version >= 703
  set undofile
  if has('nvim')
      set undodir=~/.vim/undo-neovim,.,~/
  else
      set undodir=~/.vim/undo,.,~/
  endif
endif

" where to place swap files
set directory=.,~/.vim/swap,/var/tmp,/tmp

" Display ---------------------------------------------------------------- {{{2
"
" classic
"set listchars=eol:$,tab:>-,trail:.,extends:>,precedes:<,nbsp:●
" modern (spacevim)
"set listchars=tab:→\ ,eol:↵,trail:·,extends:↷,precedes:↶,nbsp:●
" modern (spacevim + ruby tabs)
set listchars=tab:»·,eol:↵,trail:·,extends:↷,precedes:↶,nbsp:●

" don't update the display while executing macros
set lazyredraw

set novisualbell

" hide the mouse pointer while typing
set mousehide
" disable mouse integration
set mouse=

" when the page starts to scroll, keep the cursor 8 lines from the top and 8
" lines from the bottom
"set scrolloff=8

if v:version >= 703
  " show line numbers relative to cursor position
  set relativenumber
endif
set number
set numberwidth=3

" highlight textwidth column
let s:colorcolumn_default = '81,101,121'
"let &colorcolumn = s:colorcolumn_default
"set colorcolumn=+1
set colorcolumn=

" show as much as possible when last line doesn't fit on screen
set display+=lastline

" max tabs
set tabpagemax=50

" Tags ------------------------------------------------------------------- {{{2
"

" disable preview window
set completeopt-=preview

" when completing by tag, show the whole tag, not just the function name
set showfulltag

set tags=./tags,tags,~/.vim/tags/stl
",~/prg/tags/tags.libc
",~/prg/tags/tags.stl
",~/prg/tags/tags.boost

if has('cscope')
" search tags database before cscope database
set cscopetagorder=1

" show cscope search results in quickfix window
set cscopequickfix=s-,c-,d-,i-,t-,e-
endif

" Edit ------------------------------------------------------------------- {{{2
"

" ask to save/not/cancel if buffer is modified and going to be closed/unvisible
set confirm
set nohidden

" disable virtualedit by default
set virtualedit=

" allow backspace to delete everything
set backspace=indent,eol,start

" disable timeout for mappings
set notimeout
" set timeout for mappings (only used when ':set timeout')
set timeoutlen=500
" set timeout for keycodes
set ttimeoutlen=2  " ttimeoutlen=100

" speed up CursorHold autocommand (used to highlight current word)
set updatetime=500

" speed up completion significantly

" don't allow ^N completion to scan included files by default
" that can be requested directly with i_^x^i
set complete-=i

" don't allow ^N completion to scan tags by default
" that can be requested directly with i_^x^]
set complete-=t

" treat octal numbers as decimal for increment/decrement commands: CTRL-A CTRL-X
set nrformats-=octal

" text and comments formatting, see :help fo-table
set formatoptions=crqol

" delete comment character when joining commented lines
if v:version > 703 || v:version == 703 && has('patch541')
    set formatoptions+=j
endif

" Cmdline ---------------------------------------------------------------- {{{2
"
set history=5000

" set key to invoke completion mode from inside mappings
set wildcharm=<C-X>

" for windoze set the forward slash to be used as path separator
if exists('+shellslash')
    set shellslash
endif

" Extensions ------------------------------------------------------------- {{{2
"

" Python {{{3
if has('nvim')
    " disable python3 for nvim completely
    let g:loaded_python3_provider = 0
else
    let g:pymode_python = 'python3'
endif

" disable python2
let g:loaded_python_provider = 0

if s:os ==? 'Darwin'
    let s:python3_homebrew_default = '/opt/homebrew/bin/python3'
    if filereadable(s:python3_homebrew_default)
        let g:python3_host_prog = s:python3_homebrew_default
    endif
elseif s:os ==? 'Linux'
    let s:python3_linuxbrew_default = '/home/linuxbrew/.linuxbrew/bin/python3'
    let s:python3_linuxbrew_local = $HOME . '/local_install/homebrew/bin/python3'

    if filereadable(s:python3_linuxbrew_default)
        let g:python3_host_prog = s:python3_linuxbrew_default
    elseif filereadable(s:python3_linuxbrew_local)
        let g:python3_host_prog = s:python3_linuxbrew_local
    endif

    let s:pyhome_linuxbrew_default = '/home/linuxbrew/.linuxbrew/opt/python'
    let s:pyhome_linuxbrew_local = $HOME . '/local_install/homebrew/opt/python'

    "if !empty(glob(s:pyhome_linuxbrew_default))
    "    let $PYTHONHOME=s:pyhome_linuxbrew_default
    "elseif !empty(glob(s:pyhome_linuxbrew_local))
    "    let $PYTHONHOME=s:pyhome_linuxbrew_local
    "else
    "    echoerr "Homebrew's PYTHONHOME location cannot be found"
    "endif

    let s:py3dynload_linuxbrew_default = '/home/linuxbrew/.linuxbrew/lib/python3.13/lib-dynload'
    let s:py3dynload_linuxbrew_local = $HOME . '/local_install/homebrew/lib/python3.13/lib-dynload'
    let s:py3dynload_system_new = '/usr/lib/python3.13/lib-dynload'
    let s:py3dynload_system = '/usr/lib/python3.12/lib-dynload'
    let s:py3dynload_system_old = '/usr/lib/python3.11/lib-dynload'

    if has('python3')
        if !empty(glob('/.dockerenv'))
            " ignored inside docker container
        elseif !empty(glob(s:py3dynload_linuxbrew_default))
            python3 import sys; sys.path.append(vim.eval("expand(s:py3dynload_linuxbrew_default)"))
        elseif !empty(glob(s:py3dynload_linuxbrew_local))
            python3 import sys; sys.path.append(vim.eval("expand(s:py3dynload_linuxbrew_local)"))
        elseif !empty(glob(s:py3dynload_system_new)) " lowest priority
            python3 import sys; sys.path.append(vim.eval("expand(s:py3dynload_system_new)"))
        elseif !empty(glob(s:py3dynload_system))
            python3 import sys; sys.path.append(vim.eval("expand(s:py3dynload_system)"))
        elseif !empty(glob(s:py3dynload_system_old)) " lowest priority
            python3 import sys; sys.path.append(vim.eval("expand(s:py3dynload_system_old)"))
        else
            echoerr "Homebrew's lib/python3.13/lib-dynload cannot be found"
        endif
    endif
endif

" Ruby {{{3
if has('nvim')
    " disable ruby for nvim completely
    let g:loaded_ruby_provider = 0
endif

if s:os ==? 'Linux'
    let s:ruby_linuxbrew_default = '/home/linuxbrew/.linuxbrew/bin/ruby'
    let s:ruby_linuxbrew_local = $HOME . '/local_install/homebrew/bin/ruby'

    if filereadable(s:ruby_linuxbrew_default)
        let g:ruby_host_prog = s:ruby_linuxbrew_default
    elseif filereadable(s:ruby_linuxbrew_local)
        let g:ruby_host_prog = s:ruby_linuxbrew_local
    endif
endif

" Other ------------------------------------------------------------------ {{{2
"

" save only opened windows and tabs with :mksession without any
" mapping/options/buffers/etc...
set sessionoptions=tabpages

" search path for gf and ^wf file jump commands
set path+=/usr/local/include,/opt/homebrew/include

" automatically reload file if it has been changed outside of Vim and it
" wasn't modified in Vim
set autoread

" project specific vim config file .exrc
"if getcwd().'/' =~ '^'.$HOME.'/\(prj\|prg/proj\)/'
"  \ || getcwd().'/' =~ '^/Volumes/Projects/prg/proj'
"  \ || getcwd().'/' =~ '^/Volumes/Projects/prj'
"  set secure exrc
"endif

" Plugin options ========================================================= {{{1

" Airline ---------------------------------------------------------------- {{{2
"
" use PowerLine-style unicode symbols for markers
let g:airline_powerline_fonts = 1

if !exists('g:airline_symbols')
    let g:airline_symbols = {}
endif
let g:airline_symbols.colnr = '⇒'
let g:airline_symbols.maxlinenr = ''

" do not draw separators for empty sections
let g:airline_skip_empty_sections = 1

" disable separators, leads to straight section borders
let g:airline_right_sep=''
let g:airline_left_sep=''

" skip default file encoding/format display
let g:airline#parts#ffenc#skip_expected_string='utf-8[unix]'

" enable airline for vim tabs
"let g:airline#extensions#tabline#enabled = 1
let g:airline#extensions#keymap#enabled = 0

" disable tmux status line theme sync
let g:airline#extensions#tmuxline#enabled = 0

" truncate long branch names to a fixed length >
"let g:airline#extensions#branch#displayed_head_limit = 10

" to truncate all path sections but the last one, e.g. a branch
" 'foo/bar/baz' becomes 'f/b/baz', use
let g:airline#extensions#branch#format = 2

" truncate sha1 commits at this number of characters  >
let g:airline#extensions#branch#sha1_len = 12

" nvim uses treesitter context for this
if has('nvim')
    let g:airline#extensions#tagbar#enabled = 0
endif
let g:airline#extensions#obsession#enabled = 1

" do not analyze and display mixed indent and trailing spaces
let g:airline#extensions#whitespace#enabled = 0

"let g:airline_theme='onedark'
let g:airline_theme_patch_func = 'MyAirlineThemePatch'

function! MyAirlineThemePatch(palette)
    if g:airline_theme ==# 'dark'
        let a:palette.normal.airline_a = [ '#00005f' , '#8a8a8a' , 17  , 245 ]
        let a:palette.normal.airline_z = [ '#00005f' , '#8a8a8a' , 17  , 245 ]
    endif
endfunction

" Ale -------------------------------------------------------------------- {{{2
"
let g:ale_enabled = has('nvim') ? 0 : 1
let g:airline#extensions#ale#enabled = 1
let g:ale_completion_enabled = 1
let g:ale_lsp_suggestions = 1
let g:ale_detail_to_floating_preview = 1
let g:ale_floating_window_border = ['│', '─', '╭', '╮', '╯', '╰']
let g:ale_floating_preview = 1

" ✗  ⚠  ›  •  ‣  🐞  ❽  ➇  ➣  ➢  ‼︎
let g:ale_sign_error = "‼︎"
let g:ale_sign_warning = "!"

let g:ale_linters_explicit = 1
let g:ale_linters = {
                    \ 'c':    ['clangd'],
                    \ 'cpp':  ['clangd'],
                    \ 'go':   ['gopls'],
                    \ 'rust': ['rls']
                    \}

" disable linting for certain file types
let g:ale_pattern_options = {'\.min\.js$': {'ale_enabled': 0}}

let g:ale_cpp_clang_options = '-std=gnu++17 -Wall'

" Alternate -------------------------------------------------------------- {{{2
"
let g:alternateNoDefaultAlternate=0
let g:alternateRelativeFiles=1
"let g:alternateSearchPath = 'sfr:../source,sfr:../src,sfr:../include,sfr:../inc'

" auto-highlight --------------------------------------------------------- {{{2
"
let g:auto_highlight#disabled_on_start = 1

" Bash syntax ------------------------------------------------------------ {{{2
"
let g:is_bash = 1
let g:sh_fold_enabled= 1

" Clang_complete --------------------------------------------------------- {{{2
"
" default clang completion mapping is i_<C-x><C-u>
"let g:clang_complete_auto = 0
let g:clang_omnicppcomplete_compliance = 1
if s:os ==? 'Darwin'
  let s:libclang_homebrew = '/opt/homebrew/opt/llvm/lib/libclang.dylib'
  let s:libclang_clitools = '/Library/Developer/CommandLineTools/usr/lib/libclang.dylib'
  if filereadable(s:libclang_homebrew)
      let g:clang_library_path = s:libclang_homebrew
  elseif filereadable(s:libclang_clitools)
      let g:clang_library_path = s:libclang_clitools
  else
    echoerr 'libclang.so cannot be found'
  endif
elseif s:os ==? 'Linux'
  let s:libclang_local = $HOME . '/local_install/llvm/current/lib/libclang.so'
  let s:libclang_homebrew = '/home/linuxbrew/.linuxbrew/opt/llvm/lib/libclang.so'
  let s:libclang_nixos = substitute(system('printenv NIX_LIBCLANG'), "\n", '', '')
  let s:libclang_usr_lib = '/usr/lib/llvm-20/lib/libclang-20.so.20'
  let s:libclang_usr_lib_stable = '/usr/lib/llvm-19/lib/libclang-19.so.19'
  if filereadable(s:libclang_local)
    let g:clang_library_path = s:libclang_local
  elseif filereadable(s:libclang_homebrew)
    let g:clang_library_path = s:libclang_homebrew
  elseif filereadable(s:libclang_nixos)
    let g:clang_library_path = s:libclang_nixos
  elseif filereadable(s:libclang_usr_lib)
    let g:clang_library_path = s:libclang_usr_lib
  elseif filereadable(s:libclang_usr_lib_stable)
    let g:clang_library_path = s:libclang_usr_lib_stable
  else
    echoerr 'libclang.so cannot be found'
  endif
endif

" Clang-format ----------------------------------------------------------- {{{2
let g:clang_format#detect_style_file = 1

augroup clang_format
  autocmd!
  autocmd FileType c,cpp,objc map <buffer><Leader>= <Plug>(operator-clang-format)
augroup END

" Copilot (GitHub) ------------------------------------------------------- {{{2
let g:copilot_enabled = 0

" Cscope_quickfix -------------------------------------------------------- {{{2
"
let g:Cscope_OpenQuickfixWindow = 1
let g:Cscope_JumpError = 0
let g:Cscope_PopupMenu = 0
let g:Cscope_ToolsMenu = 0

" DirDiff ---------------------------------------------------------------- {{{2
"
let g:DirDiffEnableMappings = 1
" ignore whitespaces
let g:DirDiffAddArgs = '--ignore-all-space'
"let g:DirDiffExcludes = '/.git/*,.*.swp'

" Dispatch --------------------------------------------------------------- {{{2
let g:dispatch_no_maps = 1

" EasyMotion ------------------------------------------------------------- {{{2
"
"hi EasyMotionTarget cterm=bold ctermbg=NONE ctermfg=red
"hi EasyMotionShade  cterm=NONE ctermbg=NONE ctermfg=darkgray

let g:EasyMotion_leader_key = '<Space><Space>'

" Editorconfig ----------------------------------------------------------- {{{2
"
let g:EditorConfig_exclude_patterns = ['fugitive://.*', 'scp://.*']

" Emmet ------------------------------------------------------------------ {{{2
"
"let g:user_emmet_leader_key = '<C-y>'

" enable emmet only for input and visual modes
"let g:user_emmet_mode='iv'

" enable only for some file types (see after/plugin/emmet.vim)
let g:user_emmet_install_global = 0

" File explorer ---------------------------------------------------------- {{{2
"
let g:netrw_altv = 1

" FZF -------------------------------------------------------------------- {{{2
"
let g:fzf_layout = { 'window': { 'width': 1, 'height': 0.6, 'yoffset': 1 } }

" GitGutter -------------------------------------------------------------- {{{2
"
let g:gitgutter_set_sign_backgrounds = 1
if has('nvim')
    let g:gitgutter_enabled = 0
endif

" Gitv ------------------------------------------------------------------- {{{2
"
let g:Gitv_OpenHorizontal = 0
let g:Gitv_OpenPreviewOnLaunch = 0
let g:Gitv_WipeAllOnClose = 0

" GetLatestVimScripts ---------------------------------------------------- {{{2
"
let g:GetLatestVimScripts_allowautoinstall= 0

" Gundo ------------------------------------------------------------------ {{{2
"
let g:gundo_width = 75
"let g:gundo_preview_bottom = 1
let g:gundo_prefer_python3 = 1

" Javascript ------------------------------------------------------------- {{{2
"
" enable JDoc syntax highlighting
let g:javascript_plugin_jsdoc = 1
" enable Flow syntax highliting
let g:javascript_plugin_flow = 1

" Json ------------------------------------------------------------------- {{{2
"
let g:vim_json_syntax_conceal = 1

" Indent guides ---------------------------------------------------------- {{{2
"
let g:indent_guides_start_level = 2
let g:indent_guides_guide_size = 1
"if g:colors_name == 'solarized' && !has("gui_running")
"    let g:indent_guides_auto_colors = 0
"    augroup indent_guides
"        au!
"        au VimEnter,Colorscheme * :hi IndentGuidesOdd  ctermbg=white
"        au VimEnter,Colorscheme * :hi IndentGuidesEven ctermbg=gray
"    augroup end
"endif

" Latex suite ------------------------------------------------------------ {{{2
"
let g:Tex_DefaultTargetFormat = 'pdf'
let g:Tex_MultipleCompileFormats = 'pdf,dvi'
"let g:Tex_ViewRule_dvi = 'okular'
"let g:Tex_ViewRule_ps  = 'okular'
"let g:Tex_ViewRule_pdf = 'acroread'
"let g:Tex_ViewRule_pdf = 'okular'
let g:Tex_CompileRule_pdf = 'xelatex -interaction=nonstopmode $*'

" Linux coding style ----------------------------------------------------- {{{2
"
" disable because we load it manually, via Bash alias
let g:loaded_linuxsty = 1

" LazyGit ---------------------------------------------------------------- {{{2
"
let g:lazygit_use_neovim_remote = 0

" NERDTree --------------------------------------------------------------- {{{2
"
let g:NERDTreeWinPos = 'right'
let g:NERDTreeHijackNetrw = 0

" store the bookmarks file in ~/.vim
"let NERDTreeBookmarksFile='~/.vim/NERDTreeBookmarks'

" show the bookmarks table on startup
"let NERDTreeShowBookmarks=1

" don't display these kinds of files
let g:NERDTreeIgnore=['\.o$', '\.lo$', '\.ko$', '\.a$', '\.so$']
"let NERDTreeIgnore=[ '\.ncb$', '\.suo$', '\.vcproj\.RIMNET', '\.obj$',
            " \ '\.ilk$', '^BuildLog.htm$', '\.pdb$', '\.idb$',
            " \ '\.embed\.manifest$', '\.embed\.manifest.res$',
            " \ '\.intermediate\.manifest$', '^mt.dep$' ]

" Neo Tree --------------------------------------------------------------- {{{2
"
let g:neo_tree_remove_legacy_commands = 1

" Perl syntax ------------------------------------------------------------ {{{2
"

let g:perl_fold = 1
"let perl_fold_blocks = 1

" enable syntax highlighting for perl POD documentation
let g:perl_include_pod = 1

" Perl-local-lib-path ---------------------------------------------------- {{{2
"
"let g:perl_local_lib_path = 'lib'
"let g:perl_inc_path = system('perl -e "print join qq(,), @INC"')

"if !empty(g:perl_inc_path)
"    let g:perl_local_lib_path = g:perl_local_lib_path .',' . g:perl_inc_path
"endif

"augroup perl_local_lib
"    autocmd!
"    autocmd! FileType perl PerlLocalLibPath
"augroup end

" Perl-support ----------------------------------------------------------- {{{2
"
let g:Perl_Ctrl_j   = 'off'

" Perl6 / Raku ----------------------------------------------------------- {{{2
"
"let g:raku_unicode_abbrevs = 1

" quick-scope ------------------------------------------------------------ {{{2
"
" disabled by default, see plugin mappings
let g:qs_enable = 0

" R ------------------------------------------------------------------ {{{2
"
let g:vimrplugin_r_args = '--no-save --quiet'
let g:vimrplugin_term = 'xterm'
let g:vimrplugin_vimpager = 'horizontal'
let g:vimrplugin_screenplugin = 0
let g:vimrplugin_conqueplugin = 1

" disable the underscore replacement with <-
let g:vimrplugin_underscore = 0

" open .Rout files in a split window
let g:vimrplugin_notab = 1

" show list elements in object browser
"let vimrplugin_open_list = 1

" rsi -------------------------------------------------------------------- {{{2
"
" alt/meta mappings messing up macros execution (<F33>, ESC-p, M-p)
let g:rsi_no_meta = 1

" scratch ---------------------------------------------------------------- {{{2
"
let g:scratch_no_mappings = 1
let g:scratch_persistence_file = $HOME . '/.vim/scratch.txt'
let g:scratch_persistence_always = 1
let g:scratch_autohide = 1
let g:scratch_insert_autohide = 0

" Securemodeline --------------------------------------------------------- {{{2
"
let g:secure_modelines_verbose=1

" Startify --------------------------------------------------------------- {{{2
"
let g:startify_session_dir = '~/.vim/session'
let g:startify_change_to_dir = 0
let g:startify_fortune_use_unicode = 1
let g:startify_custom_header = [
\ '                              __   __      __        ___ __ __',
\ '                             /_/\ /_/\    /__/\     /__//_//_/\',
\ '                             \:\ \\ \ \   \.:\ \    \::\| \| \ \',
\ '                              \:\ \\ \ \   \::\ \    \:.      \ \',
\ '                               \:\_/.:\ \   \__\/_    \:.\-/\  \ \',
\ '                                \ ..::/ /     /__/\    \. \  \  \ \',
\ '                                 \___/_(      \__\/     \__\/ \__\/',
\ ]

" Tagbar ----------------------------------------------------------------- {{{2
"
let g:tagbar_left = 1
let g:tagbar_width = 33
let g:tagbar_sort = 0
let g:tagbar_show_data_type = 1
"let g:tagbar_no_autocmds = 1

" Visual-Multi ----------------------------------------------------------- {{{2
"
"let g:VM_maps['Select Cursor Down'] = '<M-C-Down>'
"let g:VM_maps['Select Cursor Up']   = '<M-C-Up>'
"let g:VM_maps['Add Cursor Down'] = '<M-C-Down>'
"let g:VM_maps['Add Cursor Up']   = '<M-C-Up>'

" Xml -------------------------------------------------------------------- {{{2
"
let g:xml_syntax_folding = 1

" Yankstack -------------------------------------------------------------- {{{2
"
let g:yankstack_yank_keys = ['y', 'Y']

" Ziglang ---------------------------------------------------------------- {{{2
"
let g:zig_fmt_autosave = 1

" Mappings =============================================================== {{{1

" disable default space behavior as right arrow
"noremap <Space> <Nop>

" duplicate space as leader
map <Space> <Leader>

" use space as leader
"let g:mapleader = "\<Space>"
" duplicate \ as leader
"map \ <Leader>

" Shortened commands ----------------------------------------------------- {{{2
"

" let yankstack plugin to know that we remap default Y behavior
" (it has to be done *before* re-defining Y mapping)
if exists('g:yankstack_size')
    call yankstack#setup()
endif

" make 'Y' to be more consistent with 'D','C','S'
nmap Y y$

" search of selected text in visual mode
vmap * y/<C-R>"<CR>
vmap # y?<C-R>"<CR>

" quit all windows (by analogy with ZZ and ZQ)
nmap ZA :qa<CR>

" don't jump to the next occurrence of the word, but just highlight it
nnoremap *   *N
nnoremap g*  g*N
nnoremap #   #N
nnoremap g#  g#N

" a better incremental search
"map g/  <Plug>(incsearch-forward)
"map g?  <Plug>(incsearch-backward)

" Highlight all instances of the current word under the cursor
"nmap <silent> ^ :setl hls<CR>:let @/="<C-r><C-w>"<CR>

" Shift mappings --------------------------------------------------------- {{{2
"

" Ctrl mappings ---------------------------------------------------------- {{{2
"

" ALE
if g:ale_enabled
    imap <C-Space> <Plug>(ale_complete)
endif

" Yankstack
if exists('g:yankstack_size')
    " TODO: change P to p
    nmap <C-P> <Plug>yankstack_substitute_older_paste
endif

" map CTRL-s to do what ',' used to do
nnoremap <C-s> ,
vnoremap <C-s> ,

" Tagselect
" open current file in new tab and do :Tselect on a word  under cursor
"nmap <C-t>] :tab split<CR>:exec("Ts ".expand("<cword>"))<CR>
nnoremap <silent> <C-W>g<C-]> :tab split<CR>:exec("Ts ".expand("<cword>"))<CR>

" move current line up/down
"nmap <C-Up>   :m-2
"nmap <C-Down> :m+

" switch <C-e> between original vim behavior and emacs-like EOL
" see after/plugin/rsi.vim for <C-e> mapping
inoremap <C-z>  <C-o>:call MyToggle_i_Ctrl_e()<CR>

" Maps to make handling windows a bit easier ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {{{3
"

" switch window with full expand
" TODO: change to lowercase
nnoremap <C-J> <C-W>j<C-W>_
nnoremap <C-K> <C-W>k<C-W>_
nnoremap <C-H> <C-W>h<C-W>\|
nnoremap <C-L> <C-W>l<C-W>\|

" adjust window size by one
nnoremap <silent> <C-Left>   <C-W><
nnoremap <silent> <C-Up>     <C-W>+
nnoremap <silent> <C-Down>   <C-W>-
nnoremap <silent> <C-Right>  <C-W>>

" Alt mappings ----------------------------------------------------------- {{{2
"

" intro to Alt keys mapping in vim :h :map-alt-keys

" map Alt-key combinations to escape codes (this is required because all major
" terminals use escape codes for Alt- combinations instead of setting 8th bit
" as vim expects by default)

" these M-hjkl mappings are disabled cause they cause problems with macros
" for some key combinations, like ESC-j, which turns into ê

" we need :exectue here to substitue \e with the actual escape code
"execute "set <M-h>=\eh"
"execute "set <M-j>=\ej"
"execute "set <M-k>=\ek"
"execute "set <M-l>=\el"

" adjust window size (MacOS)
"nnoremap <silent> <M-h>  <C-W><
"nnoremap <silent> <M-j>  <C-W>+
"nnoremap <silent> <M-k>  <C-W>-
"nnoremap <silent> <M-l>  <C-W>>

" adjust window size by five
"noremap <silent> <M-Left>   :vertical resize -5<CR>
"noremap <silent> <M-Up>     :resize +5<CR>
"noremap <silent> <M-Down>   :resize -5<CR>
"noremap <silent> <M-Right>  :vertical resize +5<CR>

" switch between tabs
noremap <silent> <M-Up>     :tabprev<CR>
noremap <silent> <M-Down>   :tabnext<CR>

" move tabs
noremap <silent> <M-Right>  :tabmove +<CR>
noremap <silent> <M-Left>   :tabmove -<CR>

" harpoon
if has('nvim')
nmap <silent> <M-h> :lua require('harpoon.ui').toggle_quick_menu()<CR>
nmap <silent> <M-1> :lua require('harpoon.ui').nav_file(1)<CR>
nmap <silent> <M-2> :lua require('harpoon.ui').nav_file(2)<CR>
nmap <silent> <M-3> :lua require('harpoon.ui').nav_file(3)<CR>
nmap <silent> <M-4> :lua require('harpoon.ui').nav_file(4)<CR>
endif

" zen-mode
if has('nvim')
    noremap <silent> <M-z>  :ZenMode<CR>
    " zoom full screen
    noremap <silent> <M-Z>  :lua require('zen-mode').toggle({ window = {width = 1} })<CR>
endif

" \ mappings ------------------------------------------------------------- {{{2
"

" a (alternate) ~~~~~~~~~~~~~ {{{3
nmap <silent> <Leader>aa :A<CR>
nmap <silent> <Leader>as :AS<CR>
nmap <silent> <Leader>av :AV<CR>
nmap <silent> <Leader>at :AT<CR>

" d (diffview) ~~~~~~~~~~~~~ {{{3
nmap <Leader>dd :DiffviewOpen<CR>
nmap <Leader>di :DiffviewOpen<CR>
nmap <Leader>dh :DiffviewOpen HEAD<CR>
nmap <Leader>d~ :DiffviewOpen HEAD~<CR>
nmap <Leader>dt :DiffviewToggleFiles<CR>

" D (Profiling) ~~~~~~~~~~~~~ {{{3
"nnoremap <silent> <leader>DD :exe ':profile start profile.log'<cr>:exe ':profile func *'<cr>:exe ':profile file *'<cr>
"nnoremap <silent> <leader>DP :exe ':profile pause'<cr>
"nnoremap <silent> <leader>DC :exe ':profile continue'<cr>
"nnoremap <silent> <leader>DQ :exe ':profile pause'<cr>:noautocmd qall!<cr>

" D (DAP) ~~~~~~~~~~~~~~~~~~~ {{{3
if has('nvim')
command! DapSession lua require('dap').session()
command! DapSessions lua require('dap').sessions()
command! DapStatus lua require('dap').status()
command! DapFocusFrame lua require('dap').focus_frame()
command! DapPause lua require('dap').pause()
command! DapListBreakpoints lua require('dap').list_breakpoints()
command! DapClearBreakpoints lua require('dap').clear_breakpoints()

nnoremap <silent> <leader>Db :lua require('dap').toggle_breakpoint()<cr>
nnoremap <silent> <leader>DB :lua require('dap').set_breakpoint()<cr>
nnoremap <silent> <leader>Dc :lua require('dap').continue()<cr>
nnoremap <silent> <leader>DC :lua require('dap').run_to_cursor()<cr>
nnoremap <silent> <leader>DF :lua require('dap').focus_frame()<cr>
nnoremap <silent> <leader>Di :lua require('dap').step_into()<cr>
nnoremap <silent> <leader>Dl :lua require('dap').list_breakpoints()<cr>
nnoremap <silent> <leader>Do :lua require('dap').step_over()<cr>
nnoremap <silent> <leader>DO :lua require('dap').step_out()<cr>
nnoremap <silent> <leader>DP :lua require('dap').pause()<cr>
nnoremap <silent> <leader>Dr :lua require('dap').repl.toggle()<cr>
nnoremap <silent> <leader>Dv :DapVirtualTextToggle<cr>

nnoremap <silent> <leader>DU :lua require('dap').up()<cr>
nnoremap <silent> <leader>DD :lua require('dap').down()<cr>

command! DapUIToggle lua require('dapui').toggle()
command! DapUIToggleBreakpoints lua require('dapui').toggle({layout = 1})
command! DapUIToggleStack lua require('dapui').toggle({layout = 2})
command! DapUIToggleRepl lua require('dapui').toggle({layout = 3})
command! DapUIToggleConsole lua require('dapui').toggle({layout = 4})

"nnoremap <silent> <leader>Dh :lua require('dap.ui.widgets').hover()<cr>
"nnoremap <silent> <leader>Dp :lua require('dap.ui.widgets').preview()<cr>
nnoremap <silent> <leader>Duu :DapUIToggle<cr>
nnoremap <silent> <leader>Dub :DapUIToggleBreakpoints<cr>
nnoremap <silent> <leader>Dus :DapUIToggleStack<cr>
nnoremap <silent> <leader>Dur :DapUIToggleRepl<cr>
nnoremap <silent> <leader>Duc :DapUIToggleConsole<cr>

lua << EOF
    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)
EOF
endif

" j (harpoon) ~~~~~~~~~~~~~ {{{3
"
if has('nvim')
nmap <silent> <Leader>na :lua require('harpoon.mark').add_file()<CR>
nmap <silent> <Leader>nn :lua require('harpoon.ui').nav_next()<CR>
nmap <silent> <Leader>np :lua require('harpoon.ui').nav_prev()<CR>
endif

" k (dash) ~~~~~~~~~~~~~~~~~~ {{{3
"
nmap <Leader>k <Plug>DashSearch
nmap <Leader>K <Plug>DashGlobalSearch

" l (lsp) ~~~~~~~~~~~~~~~~~ {{{3
"

if has('nvim')
nmap <silent> <Leader>le :Telescope diagnostics<CR>
nmap <silent> <Leader>ld :Telescope lsp_definitions<CR>
nmap <silent> <Leader>lD :Telescope lsp_type_definitions<CR>
nmap <silent> <Leader>li :Telescope lsp_implementations<CR>
nmap <silent> <Leader>lr :Telescope lsp_references<CR>
" symbols
nmap <silent> <Leader>ls :Telescope lsp_document_symbols<CR>
nmap <silent> <Leader>lS :Telescope lsp_dynamic_workspace_symbols<CR>
endif

" s (startify) ~~~~~~~~~~~~ {{{3
"
nmap <silent> <Leader>so :SLoad <C-X>
nmap <silent> <Leader>sc :SClose<CR>
nmap <silent> <Leader>ss :SSave<CR>
nmap <silent> <Leader>sl :Startify<CR>

" t (telescope) ~~~~~~~~~~~ {{{3
"
if has('nvim')
nmap <silent> <Leader>tt :Telescope builtin include_extensions=true<CR>

nmap <silent> <Leader>ta :Telescope keymaps<CR>
nmap <silent> <Leader>tA :Telescope aerial<CR>
nmap <silent> <Leader>tb :Telescope buffers<CR>
nmap <silent> <Leader>tB :Telescope telescope-tabs list_tabs<CR>
nmap <silent> <Leader>tc :Telescope conflicts<CR>
nmap <silent> <Leader>tf :Telescope find_files<CR>
nmap <silent> <Leader>tF :Telescope file_browser<CR>
nmap <silent> <Leader>th :Telescope help_tags<CR>
nmap <silent> <Leader>tH :Telescope helpgrep<CR>
nmap <silent> <Leader>tj :Telescope jumplist<CR>
nmap <silent> <Leader>tk :Telescope keymaps<CR>
nmap <silent> <Leader>tl :Telescope current_buffer_fuzzy_find<CR>
nmap <silent> <Leader>tL :Telescope loclist<CR>
nmap <silent> <Leader>tm :Telescope marks<CR>
nmap <silent> <Leader>tM :Telescope man_pages<CR>
nmap <silent> <Leader>to :Telescope oldfiles<CR>
nmap <silent> <Leader>tO :Telescope vim_options<CR>
nmap <silent> <Leader>tr :Telescope registers<CR>
nmap <silent> <Leader>tq :Telescope quickfix<CR>
nmap <silent> <Leader>tQ :Telescope quickfixhistory<CR>
nmap <silent> <Leader>ts :Telescope luasnip<CR>
nmap <silent> <Leader>tS :Telescope treesitter<CR>
nmap <silent> <Leader>tT :Telescope toggleterm_manager<CR>
nmap <silent> <Leader>ty :Telescope yank_history<CR>
nmap <silent> <Leader>tu :Telescope undo<CR>
endif

" T (trouble) ~~~~~~~~~~~ {{{3
"
nmap <silent> <Leader>Tr <cmd>TroubleToggle lsp_references<cr>
nmap <silent> <Leader>Td <cmd>TroubleToggle document_diagnostics<cr>
nmap <silent> <Leader>TD <cmd>TroubleToggle workspace_diagnostics<cr>

" , mappings ------------------------------------------------------------- {{{2
"

" b (blockdiff) ~~~~~~~~~~~~~ {{{3
"

" BlockDiff
vmap ,b1 :call BlockDiff_GetBlock1()<CR>
vmap ,b2 :call BlockDiff_GetBlock2()<CR>

" c (camelcasemotion) ~~~~~~~ {{{3
"

" CamelCaseMotion
map <silent> ,,w <Plug>CamelCaseMotion_w
map <silent> ,,b <Plug>CamelCaseMotion_b
map <silent> ,,e <Plug>CamelCaseMotion_e

" c (cd/cscope) ~~~~~~~~~~~~~ {{{3
"

" cd to the directory containing the file in the buffer
nmap <silent> ,cd :lcd %:h<CR>:pwd<CR>

" reload cscope database
nmap <silent> ,csr :call MyCscopeReload()<CR>

" cc (close) ~~~~~~~~~~~~~~~~ {{{3
"

" close current window
noremap <silent> ,cc :close<CR>

" close neighbour windows
noremap <silent> ,cj :wincmd j<CR>:close<CR>
noremap <silent> ,ck :wincmd k<CR>:close<CR>
noremap <silent> ,ch :wincmd h<CR>:close<CR>
noremap <silent> ,cl :wincmd l<CR>:close<CR>

" close current tab
noremap <silent> ,ct :tabclose<CR>

" close lOcation window
noremap <silent> ,co :lclose<CR>

" close preview window
noremap <silent> ,cp :pclose<CR>

" close quickfix window (not used now becaue QF is toggled by ,tq)
"noremap <silent> ,cw :cclose<CR>

" d ~~~~~~~~~~~~~~~~~~~~~~~~~ {{{3
"

if has('nvim') && !g:ale_enabled
    nmap ,dd gd
    nmap ,dD gb
    nmap ,DD gs
    nmap ,Dd gV
    nmap ,dh gh
    nmap ,di gI
    nmap ,dl <leader>K
    nmap ,dr gr
    nmap ,dR gR
else
    nmap ,dd <Plug>(ale_go_to_definition)
    nmap ,dD <Plug>(ale_go_to_definition_in_tab)
    nmap ,DD <Plug>(ale_go_to_definition_in_split)
    nmap ,Dd <Plug>(ale_go_to_definition_in_vsplit)

    nmap gd <Plug>(ale_go_to_definition)
    nmap gb <Plug>(ale_go_to_definition_in_tab)
    nmap gs <Plug>(ale_go_to_definition_in_split)
    nmap gV <Plug>(ale_go_to_definition_in_vsplit)

    nmap ,dh <Plug>(ale_hover)
    nmap gh <Plug>(ale_hover)

    nmap ,di <Plug>(ale_go_to_implementation)
    nmap ,dI <Plug>(ale_go_to_implementation_in_tab)
    nmap ,DI <Plug>(ale_go_to_implementation_in_split)
    nmap ,Di <Plug>(ale_go_to_implementation_in_vsplit)

    nmap gI <Plug>(ale_go_to_implementation)

    "nmap ,di <Plug>(ale_detail)
    nmap ,dl <Plug>(ale_detail)
    nmap <leader>K <Plug>(ale_detail)

    "nmap ,dr <Plug>(ale_find_references)
    nmap ,dr :ALEFindReferences -quickfix -relative<cr>
    nmap ,dR :ALEFindReferences -tab -relative<cr>
    nmap ,DR :ALEFindReferences -split -relative<cr>
    nmap ,Dr :ALEFindReferences -vsplit -relative<cr>

    nmap gr :ALEFindReferences -quickfix -relative<cr>
    nmap gR :ALEFindReferences -tab -relative<cr>

    nmap ,ds :ALESymbolSearch <c-r>=expand("<cword>")<cr><cr>
    xmap ,ds y:ALESymbolSearch <c-r>"<cr>

    nmap <leader>lS :ALESymbolSearch <c-r>=expand("<cword>")<cr><cr>
    xmap <leader>lS y:ALESymbolSearch <c-r>"<cr>

    nmap ,dt <Plug>(ale_go_to_type_definition)
    nmap ,dT <Plug>(ale_go_to_type_definition_in_tab)
    nmap ,DT <Plug>(ale_go_to_type_definition_in_split)
    nmap ,Dt <Plug>(ale_go_to_type_definition_in_vsplit)

    nmap <leader>lt <Plug>(ale_go_to_type_definition)
    nmap <leader>lT <Plug>(ale_go_to_type_definition_in_tab)
endif

" Delete all buffers
"nmap <silent> ,da :exec "1," . bufnr('$') . "bd"<cr>

" e (edit) ~~~~~~~~~~~~~~~~~~ {{{3
"

" edit buffer with file from the same directory as current one
" allowing to autocomplete the name with <Tab>
"nmap <silent> ,ee :e %:p:h/<C-X>
nmap <silent> ,ee :e %:p:h/

" edit scratch file
nmap <silent> ,es :edit  <C-R>=g:scratch_persistence_file<CR><CR>
nmap <silent> ,eS :split <C-R>=g:scratch_persistence_file<CR><CR>

" f (FZF) ~~~~~~~~~~~~~~~~~~~ {{{3
"

" rename some commands which conflicts with other plugins
command!  -bang -nargs=*  FZFtags  call fzf#vim#tags(<q-args>, <bang>0)
command!  -bar -bang      FZFhelptags  call fzf#vim#helptags(<bang>0)

" FZF files w/o preview window
command!  -bang -nargs=? -complete=dir  FZFfiles  call fzf#vim#files(<q-args>, {}, <bang>0)

nmap ,fa :Maps<CR>
nmap ,fb :Buffers<CR>
nmap ,fc :BCommits<CR>
nmap ,fC :Commands<CR>
nmap ,ff :FZFfiles<CR>
nmap ,fg :GFiles<CR>
" git status files (changed)
nmap ,fG :GFiles?<CR>
" command history
nmap ,fh :History:<CR>
nmap ,f: :History:<CR>
nmap ,fH :FZFhelptags<CR>
" keymaps
nmap ,fk :Maps<CR>
nmap ,fl :BLines<CR>
nmap ,fL :Lines<CR>
" MRU files history
nmap ,fm :History<CR>
nmap ,fM :Marks<CR>

nmap ,fr :Rg<CR>

" search history
nmap ,fs :History/<CR>
nmap ,f/ :History/<CR>
nmap ,fS :Snippets<CR>
nmap ,ft :FZFtags<CR>
nmap ,fT :BTags<CR>
nmap ,fw :Windows<CR>
nmap ,fy :Filetypes<CR>

" g (grep/git) ~~~~~~~~~~~~~~ {{{3
"

" Search the current file for what's currently in the search
" register and display matches
nmap <silent> ,//
      \ :vimgrep /<C-r>// %<CR>:ccl<CR>:cwin<CR><C-W>J:nohls<CR>

" selected text
vmap <silent> ,//
      \ y:vimgrep /<C-R>"/ %<CR>:ccl<CR>:cwin<CR><C-W>J:nohls<CR>

" Search the current file for the word under the cursor and display matches
nmap <silent> ,/w
      \ :vimgrep /<C-r><C-w>/ %<CR>:ccl<CR>:cwin<CR><C-W>J:nohls<CR>

" Search the current file for the WORD under the cursor and display matches
nmap <silent> ,/W
      \ :vimgrep /<C-r><C-a>/ %<CR>:ccl<CR>:cwin<CR><C-W>J:nohls<CR>

" Fugitive/Git
nmap <silent> ,gb :Git blame<CR>
nmap <silent> ,gd :Gvdiffsplit<CR>
nmap <silent> ,gD :vert Git diff<CR>
nmap <silent> ,gg :Glgrep -q <C-r><C-w><CR>
nmap <silent> ,gG :Ggrep -q <C-r><C-w><CR>
nmap <silent> ,gl :Gitv!<CR>
nmap <silent> ,gL :GV!<CR>
vmap <silent> ,gL :GV!<CR>
nmap <silent> ,go :GV?<CR>
vmap <silent> ,go :GV?<CR>
nmap <silent> ,gs :Git<CR>
nmap <silent> ,gS :Neotree git_status<CR>
if has('nvim')
nmap <silent> ,gt :lua require("neogit").action("log", "log_current")()<CR>
nmap <silent> ,gT :Gitv<CR>
else
nmap <silent> ,gt :Gitv<CR>
nmap <silent> ,gT :GV<CR>
endif
nmap <silent> ,gw :Gwrite<CR>

" LazyGit
"nmap <silent> ,GG :LazyGit<CR>
"nmap <silent> ,GC :LazyGitCurrentFile<CR>
nmap <silent> ,GG :LazyGitCurrentFile<CR>

" hjkl ~~~~~~~~~~~~~~~~~~~~~~ {{{3
"

" switch between windows
noremap <silent> ,h :wincmd h<CR>
noremap <silent> ,j :wincmd j<CR>
noremap <silent> ,k :wincmd k<CR>
noremap <silent> ,l :wincmd l<CR>

" m (make) ~~~~~~~~~~~~~~~~~~ {{{3
"

" Make the directory that contains the file in the current buffer.
" This is useful when you edit a file in a directory that doesn't
" (yet) exist
"nmap <silent> ,md :!mkdir -p %:p:h<CR>

" run make in current directory
nmap ,m :Make<CR>
nmap ,M :call MyMlxMakeOvs()<CR>

" o (lOcation window) ~~~~~~~ {{{3
"

" open location window
noremap <silent> ,ol :lopen<CR>
noremap <silent> ,oo :lopen<CR>

" p (prev) ~~~~~~~~~~~~~~~~~~ {{{3
"

" go to previous (last accessed) window.
" this is the same as ,wp mapping, just shorter
noremap <silent> ,p :wincmd p<CR>

" r (run/remove) ~~~~~~~~~~~~ {{{3
"

" Run the command that was just yanked
"nmap <silent> ,rc :@"<cr>

" remove trailing spaces
nmap <silent> ,rs :%s/\s\+$//<CR>

" s (scroll/swap/split) ~~~~~ {{{3
"

" Show all available VIM servers
"nmap <silent> ,ss :echo serverlist()<CR>

" make vertical scrolling easier
nmap <silent> ,se 10<C-e>
nmap <silent> ,sy 10<C-y>

" make horizontal scrolling easier
nmap <silent> ,sl 5zl
nmap <silent> ,sh 5zh

" Swap two words
nmap <silent> ,sw :s/\(\%#\w\+\)\(\_W\+\)\(\w\+\)/\3\2\1/<CR>`'

" split buffer with file from the same directory as current one
" allowing to autocomplete the name with <Tab>
"nmap <silent> ,sp :sp %:p:h/<C-X>
"nmap <silent> ,sv :vertical split %:p:h/<C-X>
nmap <silent> ,sp :sp %:p:h/
nmap <silent> ,sv :vertical split %:p:h/

" t (toggles) ~~~~~~~~~~~~~~ {{{3
"

" toggle ack/ag
nmap <silent> ,ta :call MyToggleAckAg()<CR>
" disable gutter area (folds, signs, line nums)
nmap <silent> ,tA :call MyToggleGutterArea()<CR>

" toggle scrollbind
nmap <silent> ,tb :set invscrollbind<CR>:set scrollbind?<CR>
" toggle background dark theme
nmap <silent> ,tB :MyToggleOnedarkColors<CR>

" toggle textwidth column highlighting
if v:version >= 703
    "nmap <silent> ,tc :call MyToggleColorcolumn()<CR>
    nmap <silent> ,tc :call MyToggleColorcolumnGlobal()<CR>
endif
" toggle cursor column highliting
nmap <silent> ,tC :call MyToggleCursorColumnHl()<CR>

" Diagnostics
nmap <silent> ,td :TroubleToggle<CR>
" LSP diagnostics virt text
nmap <silent> ,tD :MyToggleLSPdiagVirtText<CR>

" ALE
nmap <silent> ,te :ALEToggle<CR>

" toggle search inside folds
"nmap <silent> ,tf :call MyToggleFoldSearch()<CR>
nmap <silent> ,tf :call MyToggleFolding()<CR>
" toggle fold marker between syntax and git merge markers
nmap <silent> ,tF :call MyToggleFoldMarker()<CR>

" colorscheme solarized
nmap <silent> ,tg :call MyToggleBG()<CR>
nmap <silent> ,tG :call MyToggleMono()<CR>

" disable current highlight search
nmap <silent> ,th :nohlsearch<CR>
" toggle auto-highlight cword
nmap <silent> ,tH :ToggleAutoHighlightWord<CR>

" illuminate / highlight current token under the cursor
if has('nvim')
    nmap <silent> ,ti :IlluminateToggle<CR>
else
    nmap <silent> ,ti :IlluminationToggle<CR>
endif
" indent lines
nmap <silent> ,tI :IBLToggle<CR>

" toggle timeout option, (de)activates which-Key plugin
nmap <silent> ,tk :set invtimeout<CR>:set timeout?<CR>
nmap <silent> ,tK :WhichKey<CR>

" toggle list option
nmap <silent> ,tL :set invlist<CR>:set list?<CR>
" toggle location list window
nmap <silent> ,tl :call MyToggleLocationList2()<CR>

" toggle marks signs
nmap <silent> ,tm :SignatureToggleSigns<CR>

" toggle current line number or 0
nmap <silent> ,tN :set invnumber<CR>:set number?<CR>
" toggle relative line numbers or absolute
nmap <silent> ,tn :set invrelativenumber<CR>:set relativenumber?<CR>

" toggle copilot
nmap <silent> ,to :MyToggleCopilot<CR>

" toggle paste mode
nmap <silent> ,tp :set invpaste<CR>:set paste?<CR>

" toggle read-only mode
nmap <silent> ,tr  :set invreadonly<CR>:set readonly?<CR>

" toggle spell check
nmap <silent> ,ts :set invspell<CR>:set spell?<CR>
" scratch buffer
nmap <silent> ,tS <Plug>(scratch-insert-reuse)

nmap <silent> ,tt :call MyToggleTabstop()<CR>
nmap <silent> ,tT :call MyToggleTextwidthAutoWrap()<CR>

nmap <silent> ,tq :call MyToggleQuickFix()<CR>
nmap <silent> ,tQ :call MyBqfToggle()<CR>

"nmap <silent> ,tu :GitGutterToggle<CR>
"nmap <silent> ,tU :GitGutterFold<CR>
"nmap <silent> ,tu :GundoToggle<CR>
nmap <silent> ,tu :UndotreeToggle<CR>
nmap <silent> ,tU :Telescope undo<CR>

nmap <silent> ,tv :call MyToggleVirtualEdit()<CR>

" toggle text wrapping
nmap <silent> ,tw :set invwrap<CR>:set wrap?<CR>

" toggle airline whitespace warnings
nmap <silent> ,tW :AirlineToggleWhitespace<CR>

" toggle text width
nmap <silent> ,t0 :set textwidth=0<CR>:set tw?<CR>
nmap <silent> ,t1 :set textwidth=100<CR>:set tw?<CR>
nmap <silent> ,t5 :set textwidth=50<CR>:set tw?<CR>
nmap <silent> ,t72 :set textwidth=72<CR>:set tw?<CR>
nmap <silent> ,t78 :set textwidth=78<CR>:set tw?<CR>
nmap <silent> ,t8 :set textwidth=80<CR>:set tw?<CR>

" u (update) ~~~~~~~~~~~~~~~~ {{{3
"

" save current buffer
nmap ,u :update<CR>

" Underline the current line with '='
"nmap <silent> ,ul :t.\|s/./=/g\|set nohls<cr>

" v (vimrc) ~~~~~~~~~~~~~~~~~ {{{3
"

" edit the vimrc file
if has('nvim')
    nmap <silent> ,ve :e $HOME/.vim/vimrc2<CR>
else
    nmap <silent> ,ve :e $MYVIMRC<CR>
endif
nmap <silent> ,vs :so $MYVIMRC<CR>

" w (window) ~~~~~~~~~~~~~~~~ {{{3
"

" TODO: use noremap only when it's really needed

" make windows sizes equal
noremap <silent> ,w= :wincmd =<CR>

" edit new empty buffer in current window
noremap <silent> ,we :enew<CR>

" full expand current window
noremap <silent> ,wf :wincmd _<CR>

" split new empty buffer
noremap <silent> ,wn :below new<CR>

" split new empty buffer vertically
noremap <silent> ,wN :vertical belowright new<CR>

" close other windows
noremap <silent> ,wo :wincmd o<CR>

" go to previous (last accessed) window.
noremap <silent> ,wp :wincmd p<CR>

" split window
noremap <silent> ,ws :wincmd s<CR>

" open empty buffer in new tab
nmap <silent> ,wt :tabnew <CR>

" split window vertically
noremap <silent> ,wv :wincmd v<CR>

" exchange current and pervious windows
noremap <silent> ,wx :wincmd x<CR>

" Cmdline editing -------------------------------------------------------- {{{2
"

" remap <C-f> (which is used to open command-line window) to <C-z>
set cedit=<C-z>

" allow command line editing like emacs
cnoremap <M-b>  <S-Left>
cnoremap <M-f>  <S-Right>
cnoremap <ESC>b <S-Left>
cnoremap <ESC>f <S-Right>
" following mappings are now provided by vim-rsi plugin:
"cnoremap <C-A>  <Home>
"cnoremap <C-B>  <Left>
"cnoremap <C-F>  <Right>

" allow command line completion with Alt key
cnoremap <M-p>  <Up>
cnoremap <M-n>  <Down>
cnoremap <ESC>p <Up>
cnoremap <ESC>n <Down>

" Fn keys appings -------------------------------------------------------- {{{2
"

" Neovim:
"   S-F* keys recognized as F12+n e.g. S-F1->F13 S-F12->F24
"   C-F* keys recognized as F12*2+n e.g. C-F1->F25 C-F12->F36
"   M-F* keys recognized as F12*3+n e.g. M-F1->F37 M-F12->F48

" build ctags/cscope for Asm/C/C++/Perl/Python/Shell/Make project in current dir
nmap <F2> :Startify<CR>
nmap <S-F2> :!mktags -s -aAceEHjJlLmMpPrSTVx<CR>
if has('nvim')
    nmap <F14> <S-F2>
endif

" Telescope
nmap <F3> :Telescope<CR>

" TagList/Tagbar
if has('nvim')
	nmap <F4>   :Outline<CR>
	nmap <S-F4> :AerialToggle<CR>
	nmap <C-F4> :TagbarToggle<CR>
	nmap <M-F4> :TagbarToggle<CR>
    nmap <F16> <S-F4>
    nmap <F28> <C-F4>
    nmap <F40> <M-F4>
else
	nmap <F4>   :TagbarToggle<CR>
	nmap <S-F4> :TagbarForceUpdate<CR>
endif

" SignatureToggleSigns
nmap <F5>   :SignatureListBufferMarks<CR>
nmap <S-F5> :SignatureListGlobalMarks<CR>
if has('nvim')
    nmap <F17> <S-F5>
endif

" DAP
nmap <F6>   :lua require('dap').step_over()<CR>
nmap <S-F6> :lua require('dap').step_into()<CR>
if has('nvim')
    nmap <F18> <S-F6>
endif

" Trouble
nmap <F7>   :TroubleToggle<CR>
" litee-callree
nmap <S-F7> :LTPanel<CR>
if has('nvim')
    nmap <F19> <S-F7>
endif

" NERDTree
nmap <F8>   :NERDTreeToggle<CR>
nmap <S-F8> :NERDTree %:p:h<CR>
if has('nvim')
    nmap <F20> <S-F8>
endif

if has('nvim')
nmap <F21> <S-F9>
nmap <F9>   :Neotree toggle<CR>
nmap <S-F9> :Neotree reveal_force_cwd<CR>

else " vim

" Show syntax highlighting groups for word under cursor
nmap <F9> :call <SID>SynStack()<CR>

" find highlight group of symbol under cursor
nmap <silent> <S-F9> :echo "hi<" . synIDattr(synID(line("."),col("."),1),"name")
      \ . '> trans<' . synIDattr(synID(line("."),col("."),0),"name")
      \ . "> lo<" . synIDattr(synIDtrans(synID(line("."),col("."),1)),"name")
      \ . ">" . " FG:" . synIDattr(synIDtrans(synID(line("."),col("."),1)),"fg#")
      \ . " BG:" . synIDattr(synIDtrans(synID(line("."),col("."),1)),"bg#")<CR>
endif

" Commands =============================================================== {{{1
"

" show current highlight groups in new buffer
command! Hitest    runtime syntax/hitest.vim
command! Colortest runtime syntax/colortest.vim

" Auto commands  ========================================================= {{{1
"

" enable relative line numbers in tagbar window
if v:version >= 703
    augroup tagbar_lineno
        au!
        au! Filetype tagbar nested :set relativenumber
    augroup END
endif

augroup color_column
    au!
    au! WinEnter Trouble :setlocal colorcolumn=
    au! BufEnter * :if &buftype ==# 'nofile' && &colorcolumn | setlocal colorcolumn= | endif
augroup END

" Abbreviations ========================================================== {{{1
"

" fix constant spelling mistakes
iab teh       the
iab Teh       The
iab taht      that
iab Taht      That
iab alos      also
iab Alos      Also
iab aslo      also
iab Aslo      Also
iab becuase   because
iab Becuase   Because
iab bianry    binary
iab Bianry    Binary
iab bianries  binaries
iab Bianries  Binaries
iab charcter  character
iab Charcter  Character
iab charcters characters
iab Charcters Characters
iab exmaple   example
iab Exmaple   Example
iab exmaples  examples
iab Exmaples  Examples
iab shoudl    should
iab Shoudl    Should
iab seperate  separate
iab Seperate  Separate
iab fone      phone
iab Fone      Phone

" Colors ================================================================= {{{1
"

" Generated from c:/pdsrc/xterm-222/256colres.h by allcolors.pl
hi x016_Grey0 ctermfg=16 guifg=#000000
hi x017_NavyBlue ctermfg=17 guifg=#00005f
hi x018_DarkBlue ctermfg=18 guifg=#000087
hi x019_Blue3 ctermfg=19 guifg=#0000af
hi x020_Blue3 ctermfg=20 guifg=#0000d7
hi x021_Blue1 ctermfg=21 guifg=#0000ff
hi x022_DarkGreen ctermfg=22 guifg=#005f00
hi x023_DeepSkyBlue4 ctermfg=23 guifg=#005f5f
hi x024_DeepSkyBlue4 ctermfg=24 guifg=#005f87
hi x025_DeepSkyBlue4 ctermfg=25 guifg=#005faf
hi x026_DodgerBlue3 ctermfg=26 guifg=#005fd7
hi x027_DodgerBlue2 ctermfg=27 guifg=#005fff
hi x028_Green4 ctermfg=28 guifg=#008700
hi x029_SpringGreen4 ctermfg=29 guifg=#00875f
hi x030_Turquoise4 ctermfg=30 guifg=#008787
hi x031_DeepSkyBlue3 ctermfg=31 guifg=#0087af
hi x032_DeepSkyBlue3 ctermfg=32 guifg=#0087d7
hi x033_DodgerBlue1 ctermfg=33 guifg=#0087ff
hi x034_Green3 ctermfg=34 guifg=#00af00
hi x035_SpringGreen3 ctermfg=35 guifg=#00af5f
hi x036_DarkCyan ctermfg=36 guifg=#00af87
hi x037_LightSeaGreen ctermfg=37 guifg=#00afaf
hi x038_DeepSkyBlue2 ctermfg=38 guifg=#00afd7
hi x039_DeepSkyBlue1 ctermfg=39 guifg=#00afff
hi x040_Green3 ctermfg=40 guifg=#00d700
hi x041_SpringGreen3 ctermfg=41 guifg=#00d75f
hi x042_SpringGreen2 ctermfg=42 guifg=#00d787
hi x043_Cyan3 ctermfg=43 guifg=#00d7af
hi x044_DarkTurquoise ctermfg=44 guifg=#00d7d7
hi x045_Turquoise2 ctermfg=45 guifg=#00d7ff
hi x046_Green1 ctermfg=46 guifg=#00ff00
hi x047_SpringGreen2 ctermfg=47 guifg=#00ff5f
hi x048_SpringGreen1 ctermfg=48 guifg=#00ff87
hi x049_MediumSpringGreen ctermfg=49 guifg=#00ffaf
hi x050_Cyan2 ctermfg=50 guifg=#00ffd7
hi x051_Cyan1 ctermfg=51 guifg=#00ffff
hi x052_DarkRed ctermfg=52 guifg=#5f0000
hi x053_DeepPink4 ctermfg=53 guifg=#5f005f
hi x054_Purple4 ctermfg=54 guifg=#5f0087
hi x055_Purple4 ctermfg=55 guifg=#5f00af
hi x056_Purple3 ctermfg=56 guifg=#5f00d7
hi x057_BlueViolet ctermfg=57 guifg=#5f00ff
hi x058_Orange4 ctermfg=58 guifg=#5f5f00
hi x059_Grey37 ctermfg=59 guifg=#5f5f5f
hi x060_MediumPurple4 ctermfg=60 guifg=#5f5f87
hi x061_SlateBlue3 ctermfg=61 guifg=#5f5faf
hi x062_SlateBlue3 ctermfg=62 guifg=#5f5fd7
hi x063_RoyalBlue1 ctermfg=63 guifg=#5f5fff
hi x064_Chartreuse4 ctermfg=64 guifg=#5f8700
hi x065_DarkSeaGreen4 ctermfg=65 guifg=#5f875f
hi x066_PaleTurquoise4 ctermfg=66 guifg=#5f8787
hi x067_SteelBlue ctermfg=67 guifg=#5f87af
hi x068_SteelBlue3 ctermfg=68 guifg=#5f87d7
hi x069_CornflowerBlue ctermfg=69 guifg=#5f87ff
hi x070_Chartreuse3 ctermfg=70 guifg=#5faf00
hi x071_DarkSeaGreen4 ctermfg=71 guifg=#5faf5f
hi x072_CadetBlue ctermfg=72 guifg=#5faf87
hi x073_CadetBlue ctermfg=73 guifg=#5fafaf
hi x074_SkyBlue3 ctermfg=74 guifg=#5fafd7
hi x075_SteelBlue1 ctermfg=75 guifg=#5fafff
hi x076_Chartreuse3 ctermfg=76 guifg=#5fd700
hi x077_PaleGreen3 ctermfg=77 guifg=#5fd75f
hi x078_SeaGreen3 ctermfg=78 guifg=#5fd787
hi x079_Aquamarine3 ctermfg=79 guifg=#5fd7af
hi x080_MediumTurquoise ctermfg=80 guifg=#5fd7d7
hi x081_SteelBlue1 ctermfg=81 guifg=#5fd7ff
hi x082_Chartreuse2 ctermfg=82 guifg=#5fff00
hi x083_SeaGreen2 ctermfg=83 guifg=#5fff5f
hi x084_SeaGreen1 ctermfg=84 guifg=#5fff87
hi x085_SeaGreen1 ctermfg=85 guifg=#5fffaf
hi x086_Aquamarine1 ctermfg=86 guifg=#5fffd7
hi x087_DarkSlateGray2 ctermfg=87 guifg=#5fffff
hi x088_DarkRed ctermfg=88 guifg=#870000
hi x089_DeepPink4 ctermfg=89 guifg=#87005f
hi x090_DarkMagenta ctermfg=90 guifg=#870087
hi x091_DarkMagenta ctermfg=91 guifg=#8700af
hi x092_DarkViolet ctermfg=92 guifg=#8700d7
hi x093_Purple ctermfg=93 guifg=#8700ff
hi x094_Orange4 ctermfg=94 guifg=#875f00
hi x095_LightPink4 ctermfg=95 guifg=#875f5f
hi x096_Plum4 ctermfg=96 guifg=#875f87
hi x097_MediumPurple3 ctermfg=97 guifg=#875faf
hi x098_MediumPurple3 ctermfg=98 guifg=#875fd7
hi x099_SlateBlue1 ctermfg=99 guifg=#875fff
hi x100_Yellow4 ctermfg=100 guifg=#878700
hi x101_Wheat4 ctermfg=101 guifg=#87875f
hi x102_Grey53 ctermfg=102 guifg=#878787
hi x103_LightSlateGrey ctermfg=103 guifg=#8787af
hi x104_MediumPurple ctermfg=104 guifg=#8787d7
hi x105_LightSlateBlue ctermfg=105 guifg=#8787ff
hi x106_Yellow4 ctermfg=106 guifg=#87af00
hi x107_DarkOliveGreen3 ctermfg=107 guifg=#87af5f
hi x108_DarkSeaGreen ctermfg=108 guifg=#87af87
hi x109_LightSkyBlue3 ctermfg=109 guifg=#87afaf
hi x110_LightSkyBlue3 ctermfg=110 guifg=#87afd7
hi x111_SkyBlue2 ctermfg=111 guifg=#87afff
hi x112_Chartreuse2 ctermfg=112 guifg=#87d700
hi x113_DarkOliveGreen3 ctermfg=113 guifg=#87d75f
hi x114_PaleGreen3 ctermfg=114 guifg=#87d787
hi x115_DarkSeaGreen3 ctermfg=115 guifg=#87d7af
hi x116_DarkSlateGray3 ctermfg=116 guifg=#87d7d7
hi x117_SkyBlue1 ctermfg=117 guifg=#87d7ff
hi x118_Chartreuse1 ctermfg=118 guifg=#87ff00
hi x119_LightGreen ctermfg=119 guifg=#87ff5f
hi x120_LightGreen ctermfg=120 guifg=#87ff87
hi x121_PaleGreen1 ctermfg=121 guifg=#87ffaf
hi x122_Aquamarine1 ctermfg=122 guifg=#87ffd7
hi x123_DarkSlateGray1 ctermfg=123 guifg=#87ffff
hi x124_Red3 ctermfg=124 guifg=#af0000
hi x125_DeepPink4 ctermfg=125 guifg=#af005f
hi x126_MediumVioletRed ctermfg=126 guifg=#af0087
hi x127_Magenta3 ctermfg=127 guifg=#af00af
hi x128_DarkViolet ctermfg=128 guifg=#af00d7
hi x129_Purple ctermfg=129 guifg=#af00ff
hi x130_DarkOrange3 ctermfg=130 guifg=#af5f00
hi x131_IndianRed ctermfg=131 guifg=#af5f5f
hi x132_HotPink3 ctermfg=132 guifg=#af5f87
hi x133_MediumOrchid3 ctermfg=133 guifg=#af5faf
hi x134_MediumOrchid ctermfg=134 guifg=#af5fd7
hi x135_MediumPurple2 ctermfg=135 guifg=#af5fff
hi x136_DarkGoldenrod ctermfg=136 guifg=#af8700
hi x137_LightSalmon3 ctermfg=137 guifg=#af875f
hi x138_RosyBrown ctermfg=138 guifg=#af8787
hi x139_Grey63 ctermfg=139 guifg=#af87af
hi x140_MediumPurple2 ctermfg=140 guifg=#af87d7
hi x141_MediumPurple1 ctermfg=141 guifg=#af87ff
hi x142_Gold3 ctermfg=142 guifg=#afaf00
hi x143_DarkKhaki ctermfg=143 guifg=#afaf5f
hi x144_NavajoWhite3 ctermfg=144 guifg=#afaf87
hi x145_Grey69 ctermfg=145 guifg=#afafaf
hi x146_LightSteelBlue3 ctermfg=146 guifg=#afafd7
hi x147_LightSteelBlue ctermfg=147 guifg=#afafff
hi x148_Yellow3 ctermfg=148 guifg=#afd700
hi x149_DarkOliveGreen3 ctermfg=149 guifg=#afd75f
hi x150_DarkSeaGreen3 ctermfg=150 guifg=#afd787
hi x151_DarkSeaGreen2 ctermfg=151 guifg=#afd7af
hi x152_LightCyan3 ctermfg=152 guifg=#afd7d7
hi x153_LightSkyBlue1 ctermfg=153 guifg=#afd7ff
hi x154_GreenYellow ctermfg=154 guifg=#afff00
hi x155_DarkOliveGreen2 ctermfg=155 guifg=#afff5f
hi x156_PaleGreen1 ctermfg=156 guifg=#afff87
hi x157_DarkSeaGreen2 ctermfg=157 guifg=#afffaf
hi x158_DarkSeaGreen1 ctermfg=158 guifg=#afffd7
hi x159_PaleTurquoise1 ctermfg=159 guifg=#afffff
hi x160_Red3 ctermfg=160 guifg=#d70000
hi x161_DeepPink3 ctermfg=161 guifg=#d7005f
hi x162_DeepPink3 ctermfg=162 guifg=#d70087
hi x163_Magenta3 ctermfg=163 guifg=#d700af
hi x164_Magenta3 ctermfg=164 guifg=#d700d7
hi x165_Magenta2 ctermfg=165 guifg=#d700ff
hi x166_DarkOrange3 ctermfg=166 guifg=#d75f00
hi x167_IndianRed ctermfg=167 guifg=#d75f5f
hi x168_HotPink3 ctermfg=168 guifg=#d75f87
hi x169_HotPink2 ctermfg=169 guifg=#d75faf
hi x170_Orchid ctermfg=170 guifg=#d75fd7
hi x171_MediumOrchid1 ctermfg=171 guifg=#d75fff
hi x172_Orange3 ctermfg=172 guifg=#d78700
hi x173_LightSalmon3 ctermfg=173 guifg=#d7875f
hi x174_LightPink3 ctermfg=174 guifg=#d78787
hi x175_Pink3 ctermfg=175 guifg=#d787af
hi x176_Plum3 ctermfg=176 guifg=#d787d7
hi x177_Violet ctermfg=177 guifg=#d787ff
hi x178_Gold3 ctermfg=178 guifg=#d7af00
hi x179_LightGoldenrod3 ctermfg=179 guifg=#d7af5f
hi x180_Tan ctermfg=180 guifg=#d7af87
hi x181_MistyRose3 ctermfg=181 guifg=#d7afaf
hi x182_Thistle3 ctermfg=182 guifg=#d7afd7
hi x183_Plum2 ctermfg=183 guifg=#d7afff
hi x184_Yellow3 ctermfg=184 guifg=#d7d700
hi x185_Khaki3 ctermfg=185 guifg=#d7d75f
hi x186_LightGoldenrod2 ctermfg=186 guifg=#d7d787
hi x187_LightYellow3 ctermfg=187 guifg=#d7d7af
hi x188_Grey84 ctermfg=188 guifg=#d7d7d7
hi x189_LightSteelBlue1 ctermfg=189 guifg=#d7d7ff
hi x190_Yellow2 ctermfg=190 guifg=#d7ff00
hi x191_DarkOliveGreen1 ctermfg=191 guifg=#d7ff5f
hi x192_DarkOliveGreen1 ctermfg=192 guifg=#d7ff87
hi x193_DarkSeaGreen1 ctermfg=193 guifg=#d7ffaf
hi x194_Honeydew2 ctermfg=194 guifg=#d7ffd7
hi x195_LightCyan1 ctermfg=195 guifg=#d7ffff
hi x196_Red1 ctermfg=196 guifg=#ff0000
hi x197_DeepPink2 ctermfg=197 guifg=#ff005f
hi x198_DeepPink1 ctermfg=198 guifg=#ff0087
hi x199_DeepPink1 ctermfg=199 guifg=#ff00af
hi x200_Magenta2 ctermfg=200 guifg=#ff00d7
hi x201_Magenta1 ctermfg=201 guifg=#ff00ff
hi x202_OrangeRed1 ctermfg=202 guifg=#ff5f00
hi x203_IndianRed1 ctermfg=203 guifg=#ff5f5f
hi x204_IndianRed1 ctermfg=204 guifg=#ff5f87
hi x205_HotPink ctermfg=205 guifg=#ff5faf
hi x206_HotPink ctermfg=206 guifg=#ff5fd7
hi x207_MediumOrchid1 ctermfg=207 guifg=#ff5fff
hi x208_DarkOrange ctermfg=208 guifg=#ff8700
hi x209_Salmon1 ctermfg=209 guifg=#ff875f
hi x210_LightCoral ctermfg=210 guifg=#ff8787
hi x211_PaleVioletRed1 ctermfg=211 guifg=#ff87af
hi x212_Orchid2 ctermfg=212 guifg=#ff87d7
hi x213_Orchid1 ctermfg=213 guifg=#ff87ff
hi x214_Orange1 ctermfg=214 guifg=#ffaf00
hi x215_SandyBrown ctermfg=215 guifg=#ffaf5f
hi x216_LightSalmon1 ctermfg=216 guifg=#ffaf87
hi x217_LightPink1 ctermfg=217 guifg=#ffafaf
hi x218_Pink1 ctermfg=218 guifg=#ffafd7
hi x219_Plum1 ctermfg=219 guifg=#ffafff
hi x220_Gold1 ctermfg=220 guifg=#ffd700
hi x221_LightGoldenrod2 ctermfg=221 guifg=#ffd75f
hi x222_LightGoldenrod2 ctermfg=222 guifg=#ffd787
hi x223_NavajoWhite1 ctermfg=223 guifg=#ffd7af
hi x224_MistyRose1 ctermfg=224 guifg=#ffd7d7
hi x225_Thistle1 ctermfg=225 guifg=#ffd7ff
hi x226_Yellow1 ctermfg=226 guifg=#ffff00
hi x227_LightGoldenrod1 ctermfg=227 guifg=#ffff5f
hi x228_Khaki1 ctermfg=228 guifg=#ffff87
hi x229_Wheat1 ctermfg=229 guifg=#ffffaf
hi x230_Cornsilk1 ctermfg=230 guifg=#ffffd7
hi x231_Grey100 ctermfg=231 guifg=#ffffff
hi x232_Grey3 ctermfg=232 guifg=#080808
hi x233_Grey7 ctermfg=233 guifg=#121212
hi x234_Grey11 ctermfg=234 guifg=#1c1c1c
hi x235_Grey15 ctermfg=235 guifg=#262626
hi x236_Grey19 ctermfg=236 guifg=#303030
hi x237_Grey23 ctermfg=237 guifg=#3a3a3a
hi x238_Grey27 ctermfg=238 guifg=#444444
hi x239_Grey30 ctermfg=239 guifg=#4e4e4e
hi x240_Grey35 ctermfg=240 guifg=#585858
hi x241_Grey39 ctermfg=241 guifg=#626262
hi x242_Grey42 ctermfg=242 guifg=#6c6c6c
hi x243_Grey46 ctermfg=243 guifg=#767676
hi x244_Grey50 ctermfg=244 guifg=#808080
hi x245_Grey54 ctermfg=245 guifg=#8a8a8a
hi x246_Grey58 ctermfg=246 guifg=#949494
hi x247_Grey62 ctermfg=247 guifg=#9e9e9e
hi x248_Grey66 ctermfg=248 guifg=#a8a8a8
hi x249_Grey70 ctermfg=249 guifg=#b2b2b2
hi x250_Grey74 ctermfg=250 guifg=#bcbcbc
hi x251_Grey78 ctermfg=251 guifg=#c6c6c6
hi x252_Grey82 ctermfg=252 guifg=#d0d0d0
hi x253_Grey85 ctermfg=253 guifg=#dadada
hi x254_Grey89 ctermfg=254 guifg=#e4e4e4
hi x255_Grey93 ctermfg=255 guifg=#eeeeee

" Functions ============================================================== {{{1
"

" Reload cscope db ------------------------------------------------------- {{{2
function! MyCscopeReload()
    cs kill 0
    cs add cscope.out
endfunction

" Syntax highlighting --------------------------------------------------- {{{2

" show syntax highlighting groups for word under cursor
function! <SID>SynStack()
  if !exists('*synstack')
    return
  endif
  " vint: -ProhibitUnnecessaryDoubleQuote
  echo map(synstack(line('.'), col('.')), 'synIDattr(v:val, "name")')
  " vint: +ProhibitUnnecessaryDoubleQuote
endfunc

function! MyHiShow()
    call <SID>SynStack()
endfunction
command! MyHiShow call MyHiShow()

highlight link gitvSubject GitvSubj

" example how to toggle a var w/o using temp value
"let &background = ( &background == "dark"? "light" : "dark" )

" List files of particular type ------------------------------------------ {{{2
function! MyAgFindFilesOfType(ftype)
    let l:old_ackprg = g:ackprg
    let g:ackprg = 'ag --vimgrep --silent --max-count 1 --' . a:ftype
    call ack#Ack('grep', '^')
    let g:ackprg = l:old_ackprg
endfunction
command! -nargs=1 AckFtype call MyAgFindFilesOfType(<q-args>)

" MLX remote make -------------------------------------------------------- {{{2
function! MyMlxMake()
    let l:old_makeprg = &makeprg
    set makeprg=mlx-build-linux
    :Make
    let &makeprg = l:old_makeprg
endfunction

function! MyMlxMakeOvs()
    let l:old_makeprg = &makeprg
    set makeprg=mlx-build-ovs
    :Make
    let &makeprg = l:old_makeprg
endfunction

" Toggle tabstop, shiftwidth, expandtab for current buffer between 4 and 8 {{{2
function! MyToggleTabstop()
    if &tabstop == 4
        setl tabstop=8 softtabstop=8 shiftwidth=8 noexpandtab
    elseif &tabstop == 8
        setl tabstop=4 softtabstop=4 shiftwidth=4 expandtab
    endif
    echo 'tabstop(' &tabstop ')' 'shiftwidth(' &shiftwidth ')' 'expandtab(' &expandtab ')'
endfunction

" Toggle formatoptions t {{{2
function! MyToggleTextwidthAutoWrap()
    if &formatoptions =~# 't'
        setl formatoptions-=t
        echo 'formatoptions-=t'
    else
        setl formatoptions+=t
        echo 'formatoptions+=t'
    endif
endfunction

" Toggle quickfix window ------------------------------------------------- {{{2
function! MyToggleQuickFix()
    for l:i in range(1, winnr('$'))
        let l:bnum = winbufnr(l:i)
        if getbufvar(l:bnum, '&buftype') ==# 'quickfix'
            cclose
            return
        endif
    endfor

    copen
endfunction

function! MyBqfToggle()
    BqfAutoToggle
endfunction

" Toggle location window ------------------------------------------------- {{{2
function! MyToggleLocationList()
    if empty(filter(getwininfo(), 'v:val.loclist'))
        try
            lopen
        catch /E776/
            echohl WarningMsg
            echo "LocationList is empty"
            echohl None
            return
        endtry
    else
        lclose
    endif
endfunction

" https://github.com/Valloric/ListToggle/blob/master/plugin/listtoggle.vim
function! MyToggleLocationList2()
    let buffer_count_before = len(filter(range(1, bufnr('$')), 'bufwinnr(v:val) != -1'))

    silent! lclose
    if buffer_count_before == len(filter(range(1, bufnr('$')), 'bufwinnr(v:val) != -1'))
        silent! lopen
    endif
endfunction

" Toggle column highlighting --------------------------------------------- {{{2
if v:version >= 703
    " Toggle textwidth end column highlighting
    function! MyToggleColorcolumn()
      if empty(&colorcolumn)
          setl colorcolumn=+1
      else
          setl colorcolumn=
      endif
      set colorcolumn?
    endfunction

    " Toggle textwidth end column highlighting (all windows)
    function! MyToggleColorcolumnGlobal()
      if empty(&colorcolumn)
          let &colorcolumn = s:colorcolumn_default
      else
          set colorcolumn=
      endif
      set colorcolumn?
    endfunction
    command! MyToggleColorcolumnGlobal call MyToggleColorcolumnGlobal()
endif

" Toggle virtual edit ---------------------------------------------------- {{{2
function! MyToggleVirtualEdit()
    if &virtualedit ==# 'all'
        set virtualedit=
    elseif empty(&virtualedit)
        set virtualedit=\all
    endif
    set virtualedit?
endfunction

" Toggle fold marker ----------------------------------------------------- {{{2
let s:old_fdm = ''
function! MyToggleFoldMarker()
    if &foldmarker ==# '{{{,}}}'
        let s:old_fdm = &foldmethod
        setl foldmethod=marker foldmarker=<<<<<<<,>>>>>>>
    else
        let &foldmethod = s:old_fdm
        setl foldmarker={{{,}}}
    endif
    set foldmethod? foldmarker?
endfunction

" Toggle cursor/column highlight ----------------------------------------- {{{2
augroup toggle_cursor_hl
    autocmd!
augroup END

function! MyToggleCursorColumnHl()
    if &cursorline && &cursorcolumn
        autocmd! toggle_cursor_hl WinLeave *
        autocmd! toggle_cursor_hl WinEnter *
        set nocursorline nocursorcolumn
        echo 'disabled'
    else
        autocmd toggle_cursor_hl WinLeave * set nocursorline nocursorcolumn
        autocmd toggle_cursor_hl WinEnter * set cursorline cursorcolumn
        set cursorline cursorcolumn
        echo 'enabled'
    endif
endfunction

" Toggle fold search ----------------------------------------------------- {{{2
function! MyToggleFoldSearch()
    if &foldopen =~# 'search'
        setl foldopen-=search
        echo 'foldopen-=search'
    else
        setl foldopen+=search
        echo 'foldopen+=search'
    endif
endfunction

command! MyToggleFoldSearch call MyToggleFoldSearch()

" Toggle folding --------------------------------------------------------- {{{2
function! MyToggleFolding()
    if &foldenable
        set nofoldenable
        set foldcolumn=0
    else
        set foldcolumn=4
        set foldenable
    endif
endfunction

command! MyToggleFolding call MyToggleFolding()

" Toggle ack/ag search --------------------------------------------------- {{{2
let s:old_ackprg = ''
function! MyToggleAckAg()
    if s:old_ackprg !=# ''
        let s:tmp = g:ackprg
        let g:ackprg = s:old_ackprg
        let s:old_ackprg = s:tmp
    else
        let s:old_ackprg = g:ackprg
        let g:ackprg = 'ag --vimgrep'
    endif
    echo split(g:ackprg)[0]
endfunction

" Toggle gutter (line num, fold marks, git gutter) ----------------------- {{{2
function! MyToggleGutterArea()
    if &relativenumber
        let s:old_foldcolumn = &foldcolumn
        let s:old_signcolumn = &signcolumn
        let s:old_number = &number
        set signcolumn=no
    else
        let &signcolumn = s:old_signcolumn
    endif

    set invrelativenumber
    let &foldcolumn = &relativenumber * s:old_foldcolumn

    if &foldcolumn
        let &number = s:old_number
    else
        set nonumber
    endif
endfunction

" Toggle BG -------------------------------------------------------------- {{{2
"   origin: https://github.com/altercation/vim-colors-solarized/blob/master/autoload/togglebg.vim
function! MyTogBG()
    let &background = ( &background == "dark"? "light" : "dark" )
    if has('nvim')
        if &background == 'light'
            lua require'toggleterm'.setup { shading_factor = 2 }
        else
            lua require'toggleterm'.setup { shading_factor = -30 }
        endif
    endif
    if exists("g:colors_name")
        exe "colorscheme " . g:colors_name
    endif
endfunction

function! MyHlFix()
    " use thiner vertical window frames
    highlight! VertSplit guibg=NONE
    " better style for TS context
    "highlight! link TreesitterContext LineNr
    " better style for LSP hover
    "highlight! link NormalFloat LineNr

    "highlight link AutoHighlightWord CursorLineNr

    "highlight! link IlluminatedWordText Question
    "highlight! link IlluminatedWordRead Question
    "highlight! link IlluminatedWordWrite Question
    highlight! link IlluminatedWordText Todo
    highlight! link IlluminatedWordRead Todo
    highlight! link IlluminatedWordWrite Todo
endfunction

function! MyToggleBG()
    call MyTogBG()
    call MyHlFix()
endfunction

function! MyToggleMono()
    if exists("g:colors_name")
        let l:cn = ''
        if g:colors_name =~# '-normal$'
            let l:cn = substitute(g:colors_name, '-normal$', '-mono', '')
            exe "colorscheme " . l:cn
        elseif g:colors_name =~# '-mono$'
            let l:cn = substitute(g:colors_name, '-mono$', '-normal', '')
            exe "colorscheme " . l:cn
        else
            echo 'Mono theme is missing'
            return
        endif
        let g:colors_name = l:cn
        call MyHlFix()
    else
        echowarn 'Current colorscheme is not supported'
    endif
endfunction

" Toggle Doom colors ----------------------------------------------------- {{{2
let s:old_colorscheme = has('nvim') ? 'solarized-normal' : 'NeoSolarized'
let s:old_background = 'light'
let s:old_lualine_theme = 'solarized'

function! MyToggleDoomColorsVim()
    if exists("g:colors_name")
        if g:colors_name ==# 'doom-one'
            let g:airline_theme='solarized'
            exe "colorscheme " . s:old_colorscheme
            let g:colors_name = s:old_colorscheme
            exe "set background=" . s:old_background
        else
            let s:old_colorscheme = g:colors_name
            let s:old_background = &background
            let g:airline_theme='onedark'
            colorscheme doom-one
            let g:colors_name = 'doom-one'
            set background=dark
        endif
        call MyHlFix()
    else
        echowarn 'Current colorscheme is not supported'
    endif
endfunction

function! MyToggleDoomColorsNVim()
    if exists("g:colors_name")
        if g:colors_name ==# 'doom-one'
            exe "set background=" . s:old_background
            exe "colorscheme " . s:old_colorscheme
            let g:colors_name = s:old_colorscheme
            lua require('lualine').setup{options={theme=vim.g.lualine_theme}}
        else
            let s:old_colorscheme = g:colors_name
            let s:old_background = &background
            set background=dark
            colorscheme doom-one
            let g:colors_name = 'doom-one'
            lua require('lualine').setup{options={theme='dracula'}}
        endif
        call MyHlFix()
    else
        echowarn 'Current colorscheme is not supported'
    endif
endfunction

if has('nvim')
    command! MyToggleDoomColors call MyToggleDoomColorsNVim()
else
    command! MyToggleDoomColors call MyToggleDoomColorsVim()
endif
command! DoomColorTheme MyToggleDoomColors

function! MyToggleOnedarkColorsVim()
    if exists("g:colors_name")
        if g:colors_name ==# 'onedark'
            let g:airline_theme='solarized'
            exe "colorscheme " . s:old_colorscheme
            let g:colors_name = s:old_colorscheme
            exe "set background=" . s:old_background
        else
            let s:old_colorscheme = g:colors_name
            let s:old_background = &background
            let g:airline_theme='onedark'
            colorscheme onedark
            let g:colors_name = 'onedark'
            set background=dark
        endif
        call MyHlFix()
    else
        echowarn 'Current colorscheme is not supported'
    endif
endfunction

function! MyToggleOnedarkColorsNVim()
    if exists("g:colors_name")
        if g:colors_name ==# 'onedark'
            exe "set background=" . s:old_background
            exe "colorscheme " . s:old_colorscheme
            let g:colors_name = s:old_colorscheme
            if g:lualine_theme ==# 'onedark'
                let g:lualine_theme = s:old_lualine_theme
            endif
            lua require('lualine').setup{options={theme=vim.g.lualine_theme}}
        else
            let s:old_colorscheme = g:colors_name
            let s:old_background = &background
            set background=dark
            colorscheme onedark
            let g:colors_name = 'onedark'
            lua require('lualine').setup{options={theme='onedark'}}
        endif
        call MyHlFix()
    else
        echowarn 'Current colorscheme is not supported'
    endif
endfunction

if has('nvim')
    command! MyToggleOnedarkColors call MyToggleOnedarkColorsNVim()
else
    command! MyToggleOnedarkColors call MyToggleOnedarkColorsVim()
endif
command! OnedarkColorTheme MyToggleOnedarkColors

" Toggle Nvim LSP virtual diagnostics ------------------------------------ {{{2
if has('nvim')
let s:lsp_diagnostic_virt_text = 1

function! MyToggleLSPdiagVirtText()
    if s:lsp_diagnostic_virt_text
        lua vim.diagnostic.config({ virtual_text = false })
        let s:lsp_diagnostic_virt_text = 0
    else
        lua vim.diagnostic.config({ virtual_text = true })
        let s:lsp_diagnostic_virt_text = 1
    endif
endfunction

command! MyToggleLSPdiagVirtText call MyToggleLSPdiagVirtText()
endif " has('nvim')

" Toggle Nvim LSP completion --------------------------------------------- {{{2
if has('nvim')
let s:nvim_cmp_enabled = 1

function! MyToggleLSPcmp()
    if s:nvim_cmp_enabled
        lua require('cmp').setup { enabled = false }
        let s:nvim_cmp_enabled = 0
        echo 'nvim-cmp disabled'
    else
        lua require('cmp').setup { enabled = true }
        let s:nvim_cmp_enabled = 1
        echo 'nvim-cmp enabled'
    endif
endfunction

command! MyToggleLSPcmp call MyToggleLSPcmp()
endif " has('nvim')

" Toggle italic comments ------------------------------------------------- {{{2
let s:comment_style = 'italic'

function! MyToggleCommentsItalic()
    if s:comment_style ==# 'italic'
        highlight Comment gui=NONE
        highlight @comment gui=NONE
        let s:comment_style = 'NONE'
    else
        highlight Comment gui=italic
        highlight @comment gui=italic
        let s:comment_style = 'italic'
    endif
endfunction

command! MyToggleCommentsItalic call MyToggleCommentsItalic()

" Toggle copilot --------------------------------------------------------- {{{2
function! MyToggleCopilot()
    if g:copilot_enabled
        Copilot disable
        echo 'copilot disabled'
    else
        Copilot enable
        echo 'copilot enabled'
    endif
endfunction

command! MyToggleCopilot call MyToggleCopilot()

" Set work project styling ----------------------------------------------- {{{2
function! MySetWorkStyling()
    set textwidth=80
    set colorcolumn=+1
    set makeprg=m0vg\ run\ 'make\ -C\ /data/mero'
    aug c_tab | au! FileType c  :setl tabstop=8 shiftwidth=8 noexpandtab
    cd ~/prj/mero
endfunction
command! MySetWorkStyling call MySetWorkStyling()

" Toggle i_Ctrl-e -------------------------------------------------------- {{{2
let g:ictrle_orig = 0
function! MyToggle_i_Ctrl_e()
    if g:ictrle_orig
        let g:ictrle_orig = 0
        echo 'i_C-e: end-of-line'
    else
        let g:ictrle_orig = 1
        echo 'i_C-e: copy from below'
    endif
endfunction

" tabline  --------------------------------------------------------------- {{{2
"   origin: https://github.com/mkitt/tabline.vim.git
function! MyTabLine2()
  let l:s = ''

  if exists('g:loaded_obsession')
      let l:s .= '%{ObsessionStatus()}'
  endif

  for i in range(tabpagenr('$'))
      let l:tab = i + 1
      let l:winnr = tabpagewinnr(l:tab)
      let l:buflist = tabpagebuflist(l:tab)
      let l:bufnr = l:buflist[l:winnr - 1]
      let l:bufname = bufname(l:bufnr)
      let l:buftype = getbufvar(l:bufnr, '&buftype')
      let l:bufmodified = getbufvar(l:bufnr, "&mod")

      let l:s .= '%' . l:tab . 'T'
      let l:s .= (l:tab == tabpagenr() ? '%#TabLineSel#' : '%#TabLine#')
      let l:s .= ' ' . l:tab .':'
      let l:s .= l:bufname !=# '' ? '['. fnamemodify(l:bufname, ':t')
             \ : l:buftype !=# '' ? '['. l:buftype
             \ : '[No Name'

      if l:bufmodified
          let l:s .= ' ●'
      endif
      let l:s .= '] '
  endfor

  let l:s .= '%#TabLineFill#'

  return l:s
endfunction

" Nvim =================================================================== {{{1
"

if has('nvim')

let g:loaded_node_provider = 0
let g:loaded_perl_provider = 0

" TreeSitter ------------------------------------------------------------- {{{2
"
lua << EOF

-- treesitter {{{3
require'nvim-treesitter'.install {
    'awk'
    , 'bash'
    , 'c'
    , 'c_sharp'
    , 'clojure'
    , 'cmake'
    , 'comment'
    , 'cpp'
    , 'css'
    , 'csv'
    , 'cuda'
    , 'dhall'
    , 'diff'
    , 'dockerfile'
    , 'dot'
    , 'doxygen'
    , 'editorconfig'
    , 'elixir'
    , 'elm'
    , 'erlang'
    , 'fish'
    , 'git_config'
    , 'git_rebase'
    , 'git_rebase'
    , 'gitattributes'
    , 'gitcommit'
    , 'gitignore'
    , 'gleam'
    , 'gnuplot'
    , 'go'
    , 'gpg'
    , 'graphql'
    , 'haskell'
    , 'helm'
    , 'html'
    , 'http'
    , 'hurl'
    , 'ini'
    , 'javascript'
    , 'jq'
    , 'jsdoc'
    , 'json'
    , 'json5'
    , 'julia'
    , 'just'
    , 'kconfig'
    , 'latex'
    , 'liquid'
    , 'llvm'
    , 'lua'
    , 'luadoc'
    , 'make'
    , 'markdown_inline'
    , 'markdown'
    , 'mermaid'
    , 'meson'
    , 'muttrc'
    , 'nginx'
    , 'ninja'
    , 'nix'
    , 'objdump'
    , 'perl'
    , 'pod'
    , 'powershell'
    , 'printf'
    , 'python'
    , 'r'
    , 'racket'
    , 'regex'
    , 'rst'
    , 'ruby'
    , 'rust'
    , 'scheme'
    , 'scss'
    , 'sql'
    , 'ssh_config'
    , 'strace'
    , 'systemtap'
    , 'terraform'
    , 'thrift'
    , 'tmux'
    , 'toml'
    , 'tsv'
    , 'typescript'
    , 'udev'
    , 'vim'
    , 'vimdoc'
    , 'xml'
    , 'yaml'
    , 'zig'
}

require'nvim-treesitter'.setup {
  -- Install parsers synchronously (only applied to `ensure_installed`)
  sync_install = true,

  -- Automatically install missing parsers when entering buffer
  -- Recommendation: set to false if you don't have `tree-sitter` CLI installed locally
  auto_install = false,

  -- List of parsers to ignore installing (for "all")
  --ignore_install = { "javascript" },

  ---- If you need to change the installation directory of the parsers (see -> Advanced Setup)
  --parser_install_dir = "/some/path/to/store/parsers", -- Remember to run vim.opt.runtimepath:append("/some/path/to/store/parsers")!

  highlight = {
    -- `false` will disable the whole extension
    enable = true,
    --enable = { "c", "cpp" },

    -- NOTE: these are the names of the parsers and not the filetype. (for example if you want to
    -- disable highlighting for the `tex` filetype, you need to include `latex` in this list as this is
    -- the name of the parser)
    -- list of language that will be disabled
    --disable = { "c", "rust" },
    -- Or use a function for more flexibility, e.g. to disable slow treesitter highlight for large files
    --disable = function(lang, buf)
    --    local max_filesize = 100 * 1024 -- 100 KB
    --    local ok, stats = pcall(vim.loop.fs_stat, vim.api.nvim_buf_get_name(buf))
    --    if ok and stats and stats.size > max_filesize then
    --        return true
    --    end
    --end,

    -- Setting this to true will run `:h syntax` and tree-sitter at the same time.
    -- Set this to `true` if you depend on 'syntax' being enabled (like for indentation).
    -- Using this option may slow down your editor, and you may see some duplicate highlights.
    -- Instead of true it can also be a list of languages
    additional_vim_regex_highlighting = false,
    --additional_vim_regex_highlighting = true,
  },
  --incremental_selection = {
    --enable = true,
    --keymaps = {
    --  init_selection = "gnn",
    --  node_incremental = "grn",
    --  scope_incremental = "grc",
    --  node_decremental = "grm",
    --},
  --},
  --indent = {
  --  enable = true,
  --},
}

vim.api.nvim_create_autocmd('FileType', {
  callback = function(args)
    local treesitter = require('nvim-treesitter')
    local lang = vim.treesitter.language.get_lang(args.match)
    if vim.list_contains(treesitter.get_available(), lang) then
      if not vim.list_contains(treesitter.get_installed(), lang) then
        treesitter.install(lang):wait()
      end

      vim.treesitter.start(args.buf)
    end
  end,
  desc = "Enable nvim-treesitter and install parser if not installed"
})

-- treesitter-context {{{3
require'treesitter-context'.setup {
    enable = true, -- Enable this plugin (Can be enabled/disabled later via commands)
    max_lines = 2, -- How many lines the window should span. Values <= 0 mean no limit.
    trim_scope = 'inner', -- Which context lines to discard if `max_lines` is exceeded. Choices: 'inner', 'outer'
    min_window_height = 4, -- Minimum editor window height to enable context. Values <= 0 mean no limit.
    patterns = { -- Match patterns for TS nodes. These get wrapped to match at word boundaries.
        -- For all filetypes
        -- Note that setting an entry here replaces all other patterns for this entry.
        -- By setting the 'default' entry below, you can control which nodes you want to
        -- appear in the context window.
        default = {
            'class',
            'function',
            'method',
            'for',
            'while',
            'if',
            'switch',
            'case',
            'interface',
            'struct',
            'enum',
        },
        -- Patterns for specific filetypes
        -- If a pattern is missing, *open a PR* so everyone can benefit.
        tex = {
            'chapter',
            'section',
            'subsection',
            'subsubsection',
        },
        haskell = {
            'adt'
        },
        rust = {
            'impl_item',

        },
        terraform = {
            'block',
            'object_elem',
            'attribute',
        },
        scala = {
            'object_definition',
        },
        vhdl = {
            'process_statement',
            'architecture_body',
            'entity_declaration',
        },
        markdown = {
            'section',
        },
        elixir = {
            'anonymous_function',
            'arguments',
            'block',
            'do_block',
            'list',
            'map',
            'tuple',
            'quoted_content',
        },
        json = {
            'pair',
        },
        typescript = {
            'export_statement',
        },
        yaml = {
            'block_mapping_pair',
        },
    },
    exact_patterns = {
        -- Example for a specific filetype with Lua patterns
        -- Treat patterns.rust as a Lua pattern (i.e "^impl_item$" will
        -- exactly match "impl_item" only)
        -- rust = true,
    },

    -- [!] The options below are exposed but shouldn't require your attention,
    --     you can safely ignore them.

    zindex = 20, -- The Z-index of the context window
    mode = 'topline',  -- Line used to calculate context. Choices: 'cursor', 'topline'
    -- Separator between context and content. Should be a single character string, like '-'.
    -- When separator is set, the context will only show up when there are at least 2 lines above cursorline.
    separator = nil,
}

-- treesitter-context-commentstring {{{3
require'ts_context_commentstring'.setup {
    enable = true,
}

-- nvim-treesitter-textobjects {{{3
require'nvim-treesitter-textobjects'.setup {
    select = {
      enable = true,
      -- Automatically jump forward to textobjects, similar to targets.vim
      lookahead = true,
      keymaps = {
        ["aa"] = "@parameter.outer",
        ["ia"] = "@parameter.inner",
        ["af"] = "@function.outer",
        ["if"] = "@function.inner",
        ["ac"] = "@class.outer",
        ["ic"] = { query = "@class.inner", desc = "Select inner part of a class region" },
        ["as"] = { query = "@scope", query_group = "locals", desc = "Select language scope" },
      },
      -- choose the select mode (default is charwise 'v')
      selection_modes = {
        ['@parameter.outer'] = 'v', -- charwise
        ['@parameter.inner'] = 'v', -- charwise
        ['@function.outer'] = 'V', -- linewise
        ['@class.outer'] = '<c-v>', -- blockwise
      },
      -- If set to `true` (default is `false`) then any textobject is
      -- extended to include preceding or succeeding whitespace. Succeeding
      -- whitespace has priority in order to act similarly to eg the built-in
      -- `ap`.
      include_surrounding_whitespace = true,
    },
    swap = {
      enable = true,
      swap_next = {
        ["<leader>x"] = "@parameter.inner",
      },
      swap_previous = {
        ["<leader>X"] = "@parameter.inner",
      },
    },
    move = {
      enable = true,
      set_jumps = true, -- whether to set jumps in the jumplist
      goto_next_start = {
        [']m'] = '@function.outer',
      },
      goto_next_end = {
        [']M'] = '@function.outer',
      },
      goto_previous_start = {
        ['[m'] = '@function.outer',
      },
      goto_previous_end = {
        ['[M'] = '@function.outer',
      },
    },
    lsp_interop = {
      enable = true,
      border = 'none',
      floating_preview_opts = {},
      peek_definition_code = {
        ["<leader>df"] = "@function.outer",
        ["<leader>dF"] = "@class.outer",
      },
    },
}

-- keymaps
vim.keymap.set({ "x", "o" }, "aa", function()
require "nvim-treesitter-textobjects.select".select_textobject("@parameter.outer", "textobjects")
end)
vim.keymap.set({ "x", "o" }, "ia", function()
require "nvim-treesitter-textobjects.select".select_textobject("@parameter.inner", "textobjects")
end)
vim.keymap.set({ "x", "o" }, "af", function()
require "nvim-treesitter-textobjects.select".select_textobject("@function.outer", "textobjects")
end)
vim.keymap.set({ "x", "o" }, "if", function()
require "nvim-treesitter-textobjects.select".select_textobject("@function.inner", "textobjects")
end)
vim.keymap.set({ "x", "o" }, "ac", function()
require "nvim-treesitter-textobjects.select".select_textobject("@class.outer", "textobjects")
end)
vim.keymap.set({ "x", "o" }, "ic", function()
require "nvim-treesitter-textobjects.select".select_textobject("@class.inner", "textobjects")
end)

EOF

" options {{{3
set foldmethod=expr
set foldexpr=v:lua.vim.treesitter.foldexpr()

"highlight! link TreesitterContext LineNr

" LSP -------------------------------------------------------------------- {{{2
"

" unmap grn
" unmap gra
" unmap grr
" unmap gri
" unmap grt
" unmap gO

lua << EOF

-- nvim-lspconfig {{{3

-- Mappings.
-- See `:help vim.diagnostic.*` for documentation on any of the below functions
local opts = { noremap=true, silent=true }
vim.keymap.set('n', '<leader>lE', vim.diagnostic.open_float, opts)
vim.keymap.set('n', '[d', vim.diagnostic.goto_prev, opts)
vim.keymap.set('n', ']d', vim.diagnostic.goto_next, opts)
vim.keymap.set('n', '[e', vim.diagnostic.goto_prev, opts)
vim.keymap.set('n', ']e', vim.diagnostic.goto_next, opts)
vim.keymap.set('n', '<leader>lq', vim.diagnostic.setloclist, opts)

-- unmap unwanted default LSP keymaps added since nvim 0.11
vim.keymap.del('n', 'grn')
vim.keymap.del({'n', 'v'}, 'gra')
vim.keymap.del('n', 'grr')
vim.keymap.del('n', 'gri')
vim.keymap.del('n', 'grt')
vim.keymap.del('n', 'gO')

-- Use an on_attach function to only map the following keys
-- after the language server attaches to the current buffer
local on_attach = function(client, bufnr)
  -- Enable completion triggered by <c-x><c-o>
  vim.api.nvim_buf_set_option(bufnr, 'omnifunc', 'v:lua.vim.lsp.omnifunc')

  -- Use LSP for folding
  --if client:supports_method('textDocument/foldingRange') then
  --    vim.wo[vim.api.nvim_get_current_win()][0].foldexpr = 'v:lua.vim.lsp.foldexpr()'
  --end

  -- Mappings.
  -- See `:help vim.lsp.*` for documentation on any of the below functions
  local bufopts = { noremap=true, silent=true, buffer=bufnr }
  vim.keymap.set('n', 'gd', vim.lsp.buf.definition, bufopts)
  vim.keymap.set('n', 'gD', vim.lsp.buf.declaration, bufopts)
  vim.keymap.set('n', 'gs', ':aboveleft split | lua vim.lsp.buf.definition()<CR>', bufopts)
  vim.keymap.set('n', 'gS', ':aboveleft split | lua vim.lsp.buf.declaration()<CR>', bufopts)
  vim.keymap.set('n', 'gV', ':vsplit | lua vim.lsp.buf.definition()<CR>', bufopts)
  vim.keymap.set('n', 'gb', ':tab split | lua vim.lsp.buf.definition()<CR>', bufopts)
  vim.keymap.set('n', 'gh', vim.lsp.buf.hover, bufopts)
  vim.keymap.set('n', 'gI', vim.lsp.buf.implementation, bufopts)
  vim.keymap.set('n', 'gC', vim.lsp.buf.incoming_calls, bufopts)
  vim.keymap.set('n', 'gO', vim.lsp.buf.outgoing_calls, bufopts)
  --vim.keymap.set('n', 'gr', vim.lsp.buf.references, bufopts)
  vim.keymap.set('n', 'gr', function() vim.lsp.buf.references(nil, { loclist=true }) end, bufopts)
  vim.keymap.set('n', 'gR', ':tab split | lua vim.lsp.buf.references()<CR>', bufopts)
  vim.keymap.set('n', '<leader>lk', vim.lsp.buf.signature_help, bufopts)
  vim.keymap.set('n', '<leader>lt', vim.lsp.buf.type_definition, bufopts)
  vim.keymap.set('n', '<leader>lT', ':aboveleft split | lua vim.lsp.buf.type_definition()<CR>', bufopts)
  vim.keymap.set('n', '<leader>lR', vim.lsp.buf.rename, bufopts)
  vim.keymap.set('n', '<leader>la', vim.lsp.buf.code_action, bufopts)
  vim.keymap.set('n', '<leader>lf', function() vim.lsp.buf.format { async = true } end, bufopts)
  vim.keymap.set('n', '<leader>wa', vim.lsp.buf.add_workspace_folder, bufopts)
  vim.keymap.set('n', '<leader>wr', vim.lsp.buf.remove_workspace_folder, bufopts)
  vim.keymap.set('n', '<leader>wl', function()
    print(vim.inspect(vim.lsp.buf.list_workspace_folders()))
  end, bufopts)
end

-- nvim-cmp {{{3
local cmp = require'cmp'
local cmp_capabilities = require('cmp_nvim_lsp').default_capabilities()
local luasnip = require'luasnip'

cmp.setup {
    mapping = cmp.mapping.preset.insert({
        ['<C-b>'] = cmp.mapping.scroll_docs(-4),
        ['<C-f>'] = cmp.mapping.scroll_docs(4),
        ['<C-Space>'] = cmp.mapping.complete(),
        ['<C-e>'] = cmp.mapping.abort(),
        ['<CR>'] = cmp.mapping.confirm({ select = false }),

        -- luasnip
        ['<C-s>'] = cmp.mapping(function(fallback)
            if cmp.visible() then
                cmp.select_next_item()
            elseif luasnip.expand_or_locally_jumpable() then
                luasnip.expand_or_jump()
            elseif has_words_before() then
                cmp.complete()
            else
                fallback()
            end
        end, { 'i', 's' }),

        ['<M-s>'] = cmp.mapping(function(fallback)
            if cmp.visible() then
                cmp.select_prev_item()
            elseif luasnip.jumpable(-1) then
                luasnip.jump(-1)
            else
                fallback()
            end
        end, { 'i', 's' }),

    }),
    snippet = {
      expand = function(args)
         require('luasnip').lsp_expand(args.body)
      end,
    },
    sources = cmp.config.sources({
        { name = 'nvim_lsp', keyword_length = 10 },
        { name = 'nvim_lsp_signature_help' },
        { name = 'nvim_lua' },
        { name = 'luasnip', keyword_length = 3 },
    },{
      { name = 'buffer', keyword_length = 10 },
    }),
    -- display type info in the main list
    formatting = {
        format = function(entry, vim_item)
            vim_item.menu = entry:get_completion_item().detail
            return vim_item
        end
    },
}

-- nvim-lspconfig-bashls {{{3
vim.lsp.config['bashls'] = {
  capabilities = cmp_capabilities,
  on_attach = on_attach,
  filetypes = { 'sh', 'bash' },
}
vim.lsp.enable('bashls')

-- nvim-lspconfig-clangd {{{3
vim.lsp.config['clangd'] = {
  capabilities = cmp_capabilities,
  on_attach = on_attach,
  --cmd = { 'clangd', '--enable-config', '--log=verbose' }
  cmd = { 'clangd', '--enable-config' },
}
vim.lsp.enable('clangd')

-- nvim-lspconfig-elixir {{{3
function lsp_path(name)
    local full_path =  vim.fn.stdpath('data') .. '/mason/bin/' .. name
    if vim.fn.glob(full_path) ~= '' then
        return full_path
    end

    full_path = vim.fn.exepath(name)
    if full_path ~= '' then
        return full_path
    end

    return nil
end

if lsp_path('elixir-ls') then
vim.lsp.config['elixirls'] = {
  capabilities = cmp_capabilities,
  on_attach = on_attach,
  cmd = { lsp_path('elixir-ls') },
}
vim.lsp.enable('elixir-ls')
end

-- nvim-lspconfig-gleam {{{3
vim.lsp.config['gleam'] = {
  capabilities = cmp_capabilities,
  on_attach = on_attach,
}
vim.lsp.enable('gleam')

-- nvim-lspconfig-lua {{{3
vim.lsp.config['lua_ls'] = {
  capabilities = cmp_capabilities,
  settings = {
    Lua = {
      diagnostics = {
        globals = { 'vim' }
      },
      telemetry = {
        enable = false
      }
    }
  },
  on_attach = on_attach
}
vim.lsp.enable('lua_ls')

-- nvim-lspconfig-rust-analyzer {{{3
vim.lsp.config['rust_analyzer'] = {
  on_attach = on_attach,
  settings = {
    ['rust-analyzer'] = {
      inlayHints = {
        typeHintsWithVariable = true
      },
      workspace = {
        symbol = {
          search = {
            kind = "all_symbols"
          }
        }
      }
    }
  }
}
vim.lsp.enable('rust_analyzer')

-- nvim-lspconfig-zig {{{3
if lsp_path('zls') then
vim.lsp.config['zls'] = {
  capabilities = cmp_capabilities,
  on_attach = on_attach,
  cmd = { lsp_path('zls') },
}
vim.lsp.enable('zls')
end

-- nvim-lspconfig-yaml {{{3
vim.lsp.config['yamlls'] = {
  settings = {
    yaml = {
      schemaStore = {
        url = "https://www.schemastore.org/api/json/catalog.json",
        enable = true,
      }
    }
  },
  on_attach = on_attach
}
vim.lsp.enable('yamlls')

-- nvim-lsp-file-operations {{{3
require'lsp-file-operations'.setup()

-- luasnip {{{3
require'luasnip.loaders.from_vscode'.lazy_load()

-- aerial {{{3
require'aerial'.setup {
  layout = {
    max_width = { 45, 0.25 },
    default_direction = "prefer_left",
  },
  nerd_font = false,
  show_guides = true,
}

-- outline {{{3
require'outline'.setup {
  outline_window = {
    position = 'left',
    relative_width = false,
    width = 45,
  },
  keymaps = {
    close = {},
  },
  symbols = {
    icons = {
      Method = { icon = '', hl = 'Function' },
      Function = { icon = 'ƒ', hl = 'Function' },
      StaticMethod = { icon = ' ', hl = 'Function' },
    },
  },
}

-- trouble {{{3
require'trouble'.setup {
    icons = false,
    fold_open = '▾', -- icon used for open folds
    fold_closed = '▸', -- icon used for closed folds
    --indent_lines = false, -- add an indent guide below the fold icons
    signs = {
        error = '🅴',
        warning = '🆆',
        hint = '', --   󱐋 󰠠 󱐌      󰋼   
        information = '➮',
        other = '¿',
    },
    --use_diagnostic_signs = false -- enabling this will use the signs defined in your lsp client
}

-- litee {{{3
require'litee.lib'.setup {
    panel = {
        orientation = 'right',
        panel_size  = 60
    }
}
require'litee.calltree'.setup()

-- lspsaga {{{3
--require'lspsaga'.init_lsp_saga {
--  show_outline = {
--    win_position = 'right',
--    win_width = 60,
--    auto_enter = false,
--    auto_preview = false,
--    virt_text = '┃',
--    jump_key = 'o',
--    auto_refresh = true,
--  },
--}

EOF

" options {{{3

" LSP signs
sign define DiagnosticSignError texthl=DiagnosticSignError numhl=DiffDelete text=🅴
sign define DiagnosticSignWarn texthl=DiagnosticSignWarn numhl=DiffChange text=🆆
sign define DiagnosticSignInfo texthl=DiagnosticSignInfo numhl=DiffText text=➮
sign define DiagnosticSignHint texthl=DiagnosticSignHint numhl=DiffAdd text=

" hover window style
"highlight! link FloatBorder Normal
"highlight! link NormalFloat LineNr

" Mason ------------------------------------------------------------------ {{{2
"
lua require'mason'.setup()

" DAP -------------------------------------------------------------------- {{{2
"
lua << EOF

vim.fn.sign_define('DapStopped', {text='➤', texthl='CursorLineNr', linehl='CursorLine', numhl=''})
vim.fn.sign_define('DapBreakpoint', {text='●', texthl='DiffDelete', linehl='', numhl=''})
vim.fn.sign_define('DapBreakpointCondition', {text='⊜', texthl='DiffDelete', linehl='', numhl=''})
vim.fn.sign_define('DapLogPoint', {text='㏒', texthl='CursorLineNr', linehl='', numhl=''})
vim.fn.sign_define('DapBreakpointRejected', {text='✗', texthl='DiffDelete', linehl='', numhl=''})


local dap = require('dap')

-- c/c++ {{{3
dap.adapters.cppdbg = {
  id = 'cppdbg',
  type = 'executable',
  command = vim.fn.stdpath('data') .. '/mason/bin/OpenDebugAD7',
}

dap.configurations.c = {
  {
    name = 'Launch file',
    type = 'cppdbg',
    request = 'launch',
    program = function()
      return vim.fn.input('Path to executable: ', vim.fn.getcwd() .. '/', 'file')
    end,
    cwd = '${workspaceFolder}',
    stopAtEntry = true,
    setupCommands = {
      {
        text = '-enable-pretty-printing',
        description =  'enable pretty printing',
        ignoreFailures = false
      },
    },
  },
  {
    name = 'Attach to process <PID>',
    type = 'cppdbg',
    request = 'attach',
    mode = 'local',
    program = function()
      exe_path = vim.fn.getcwd() .. '/'
      if vim.env.NVIM_DAP_PROG_PATH then
        exe_path = vim.env.NVIM_DAP_PROG_PATH
      end
      return vim.fn.input('Path to executable: ', exe_path, 'file')
    end,
    processId = function()
      default_name = ''
      if vim.env.NVIM_DAP_PROG_PATH then
        default_name = vim.fs.basename(vim.env.NVIM_DAP_PROG_PATH)
      end
      name = vim.fn.input('Process name to attach: ', default_name)
      return require('dap.utils').pick_process({
        filter = function(proc) return vim.fn.match(proc.name, name) ~= -1 end
      })
    end,
    cwd = '${workspaceFolder}',
    stopAtConnect = true,
    setupCommands = {
      {
        text = '-enable-pretty-printing',
        description =  'enable pretty printing',
        ignoreFailures = false
      },
    },
  },
}
dap.configurations.cpp = dap.configurations.c

-- elixir {{{3
dap.adapters.mix_task = {
  type = 'executable',
  command = vim.fn.stdpath('data') .. '/mason/bin/elixir-ls-debugger',
  args = {}
}

dap.configurations.elixir = {
  {
    type = 'mix_task',
    name = 'mix test',
    task = 'test',
    taskArgs = {'--trace'},
    request = 'launch',
    startApps = true, -- for Phoenix projects
    projectDir = '${workspaceFolder}',
    requireFiles = {
      'test/**/test_helper.exs',
      'test/**/*_test.exs'
    }
  },
}

-- UI {{{3
require'dapui'.setup {
    controls = {
      element = 'repl',
      enabled = false,
      icons = {
        disconnect = '',
        pause = '',
        play = '',
        run_last = '',
        step_back = '',
        step_into = '',
        step_out = '',
        step_over = '',
        terminate = ''
      }
    },
    element_mappings = {},
    expand_lines = true,
    floating = {
      max_height = 0.9,
      max_width = 0.5, -- Floats will be treated as percentage of your screen.
      border = 'rounded',
      mappings = {
        close = { 'q', '<Esc>' }
      }
    },
    force_buffers = true,
    icons = {
      collapsed = '▸',
      current_frame = '⦿',
      expanded = '▾'
    },
    layouts = {
      {
        elements = {
          { id = 'breakpoints', size = 0.25 },
          { id = 'scopes', size = 0.75 },
        },
        position = 'left',
        size = 60
      },{
        elements = {
          { id = 'stacks', size = 1 },
        },
        position = 'bottom',
        size = 15
      },{
        elements = {
          { id = 'repl', size = 1 },
        },
        position = 'bottom',
        size = 10
      },{
        elements = {
          { id = 'console', size = 1 },
        },
        position = 'top',
        size = 5
      }
    },
    mappings = {
      edit = 'e',
      expand = { '<CR>' },
      open = 'o',
      remove = 'd',
      repl = 'r',
      toggle = 't'
    },
}

require'nvim-dap-virtual-text'.setup()
EOF

"augroup dap_repl
"    au!
"    au! FileType dap-repl :lua require('dap.ext.autocompl').attach()
"augroup END

" Telescope -------------------------------------------------------------- {{{2
"
lua << EOF
require'telescope'.setup {
  defaults = {
    layout_strategy = 'flex',
    --layout_config = { height = 0.9, width = 0.9 },
  },
  extensions = {
    aerial = {
      -- Display symbols as <root>.<parent>.<symbol>
      show_nesting = {
        ['_'] = false, -- This key will be the default
        json = true,   -- You can set the option for specific filetypes
        yaml = true,
      }
    },
    file_browser = {
      theme = 'ivy',
      -- disables netrw and use telescope-file-browser in its place
      hijack_netrw = false,
    },
    toggleterm_manager,
    undo = {
      layout_strategy = 'vertical',
    },
  },
}
EOF

" extensions {{{3
lua require'telescope'.load_extension('aerial')
lua require'telescope'.load_extension('conflicts')
lua require'telescope'.load_extension('dap')
lua require'telescope'.load_extension('file_browser')
lua require'telescope'.load_extension('helpgrep')
lua require'telescope'.load_extension('lazygit')
lua require'telescope'.load_extension('luasnip')
lua require'telescope'.load_extension('toggleterm_manager')
lua require'telescope'.load_extension('telescope-tabs')
lua require'telescope'.load_extension('undo')

" Colors ----------------------------------------------------------------- {{{2
"
lua << EOF

-- solarized.nvim {{{3
--require'solarized.solarized-normal.highlights'
--vim.cmd[[ colorscheme solarized-normal ]]

-- onedark.nvim {{{3
require('onedark').setup {
    style = 'dark',
    highlights = {
      ['Folded'] = { bg = 'none' }
    }
}

EOF

" doom-one.nvim {{{3
let g:doom_one_cursor_coloring = 1
let g:doom_one_terminal_colors = 1
let g:doom_one_italic_comments = 1
let g:doom_one_enable_treesitter = 1
let g:doom_one_diagnostics_text_color = 1
"let g:doom_one_transparent_background = 1

" Pumblend transparency
"let g:doom_one_pumblend_enable = false
"let g:doom_one_pumblend_transparency = 20

" Plugins integration
let g:doom_one_plugin_neorg = 1
let g:doom_one_plugin_barbar = 1
let g:doom_one_plugin_telescope = 1
let g:doom_one_plugin_neogit = 1
let g:doom_one_plugin_nvim_tree = 1
let g:doom_one_plugin_dashboard = 1
let g:doom_one_plugin_startify = 1
let g:doom_one_plugin_whichkey = 1
let g:doom_one_plugin_indent_blankline = 1
let g:doom_one_plugin_vim_illuminate = 1
let g:doom_one_plugin_lspsaga = 1

" Other plugins ---------------------------------------------------------- {{{2
"

" devicons {{{3
lua require'nvim-web-devicons'.setup()

" mini.icons {{{3
lua require'mini.icons'.setup()

" lualine {{{3
lua << END
require('lualine').setup {
  options = {
    icons_enabled = true,
    theme = vim.g.lualine_theme,
    component_separators = { left = '', right = ''},
    section_separators = { left = '', right = ''},
  },
  sections = {
    lualine_a = {'mode'},
    lualine_b = {'branch', 'diff', { 'diagnostics', symbols = {error = '', warn = '', info = '', hint = ''}, }},
    lualine_c = {
        {'filename',
         path = 1,
         symbols = {
           modified = '[+]',
           readonly = '',
         }
        },
        { 'lsp_progress',
          --spinner_symbols = { '◐','◓','◑','◒' },
        },
    },
    lualine_x = { 'vim.bo.fileformat == "unix" and "" or vim.bo.fileformat',
                  'vim.bo.fileencoding == "utf-8" and "" or vim.bo.fileencoding',
                  'filetype' },
    --lualine_y = {'location'},
    --lualine_z = {'progress', 'vim.fn.line("$")'},
    lualine_y = {'vim.fn.line("$")'},
    lualine_z = {'location', 'progress'},
  },
  inactive_sections = {
    lualine_c = { {'filename', path = 1} },
  },
  extensions = {'fugitive', 'fzf', 'man', 'nerdtree', 'quickfix', 'symbols-outline'},
  --refresh = {
  --  statusline = 100,
  --}
}
END

" hop {{{3
lua require'hop'.setup()
nmap <Space><Space>W :HopWordMW<CR>
nmap <Space><Space>w :HopWordAC<CR>
nmap <Space><Space>b :HopWordBC<CR>
nmap <Space><Space>f :HopChar1AC<CR>
nmap <Space><Space>F :HopChar1BC<CR>
nmap <Space><Space>t :HopChar1MW<CR>
nmap <Space><Space>l :HopLine<CR>
nmap <Space><Space>e :HopAnywhereAC<CR>
nmap <Space><Space>ge :HopAnywhereBC<CR>
nmap <Space><Space>E :HopAnywhere<CR>

" illuminate {{{3
lua << EOF
require'illuminate'.configure {
    min_count_to_highlight = 2,
}
-- disable by default
require'illuminate'.pause()
EOF

"highlight! link IlluminatedWordText Question
"highlight! link IlluminatedWordRead Question
"highlight! link IlluminatedWordWrite Question
highlight! link IlluminatedWordText Todo
highlight! link IlluminatedWordRead Todo
highlight! link IlluminatedWordWrite Todo

" comment {{{3
lua << EOF
require'Comment'.setup {
    padding = false,
    toggler = {
        line = 'gxx',
        block = 'gXX',
    },
    opleader = {
        line = 'gx',
        block = 'gX',
    },
    mappings = {
        basic = true,
        extra = false,
    },
}
EOF

" yanky {{{3
lua << EOF
require'yanky'.setup {
  ring = {
    history_length = 100,
    storage = 'shada',
    sync_with_numbered_registers = true,
    cancel_event = 'update',
  },
  system_clipboard = {
    sync_with_ring = false,
  },
  preserve_cursor_position = {
    enabled = false,
  },
}
--vim.keymap.set({'n','x'}, 'y', '<Plug>(YankyYank)')
--vim.keymap.set({'n','x'}, 'p', '<Plug>(YankyPutAfter)')
--vim.keymap.set({'n','x'}, 'P', '<Plug>(YankyPutBefore)')
--vim.keymap.set('n', '<c-n>', '<Plug>(YankyCycleForward)')
--vim.keymap.set('n', '<c-p>', '<Plug>(YankyCycleBackward)')
EOF

lua require'telescope'.load_extension('yank_history')

nmap y <Plug>(YankyYank)
xmap y <Plug>(YankyYank)

nmap p <Plug>(YankyPutAfter)
xmap p <Plug>(YankyPutAfter)
nmap P <Plug>(YankyPutBefore)
xmap P <Plug>(YankyPutBefore)

nmap <c-n> <Plug>(YankyCycleForward)
nmap <c-p> <Plug>(YankyCycleBackward)

" which-key {{{3
lua << EOF
require'which-key'.setup {
    delay = function(ctx)
      return ctx.plugin and 0 or 500
    end,
    plugins = {
      presets = {
        operators = false, -- adds help for operators like d, y, ...
        motions = false, -- adds help for motions
        text_objects = true, -- help for text objects triggered after entering an operator
        windows = false, -- default bindings on <c-w>
        nav = false, -- misc bindings to work with windows
        z = false, -- bindings for folds, spelling and others prefixed with z
        g = false, -- bindings for prefixed with g
      },
    },
}
EOF

" gitsigns {{{3
lua << EOF
require'gitsigns'.setup {
  on_attach = function(bufnr)
    local gs = package.loaded.gitsigns

    local function map(mode, l, r, opts)
      opts = opts or {}
      opts.buffer = bufnr
      vim.keymap.set(mode, l, r, opts)
    end

    -- Navigation
    map('n', ']c', function()
      if vim.wo.diff then return ']c' end
      vim.schedule(function() gs.next_hunk() end)
      return '<Ignore>'
    end, {expr=true})

    map('n', '[c', function()
      if vim.wo.diff then return '[c' end
      vim.schedule(function() gs.prev_hunk() end)
      return '<Ignore>'
    end, {expr=true})

    -- Actions
    map('n', '<leader>hs', gs.stage_hunk)
    map('n', '<leader>hr', gs.reset_hunk)
    map('v', '<leader>hs', function() gs.stage_hunk {vim.fn.line('.'), vim.fn.line('v')} end)
    map('v', '<leader>hr', function() gs.reset_hunk {vim.fn.line('.'), vim.fn.line('v')} end)
    map('n', '<leader>hS', gs.stage_buffer)
    map('n', '<leader>hu', gs.undo_stage_hunk)
    map('n', '<leader>hR', gs.reset_buffer)
    map('n', '<leader>hp', gs.preview_hunk)
    map('n', '<leader>hb', function() gs.blame_line{full=true} end)
    map('n', '<leader>hB', gs.toggle_current_line_blame)
    map('n', '<leader>hd', gs.diffthis)
    --map('n', '<leader>hD', function() gs.diffthis('~') end)
    --map('n', '<leader>hl', gs.toggle_deleted)
    map('n', '<leader>hD', gs.toggle_deleted)
    -- show changes against different base (default is index)
    map('n', '<leader>hh', function() gs.change_base('HEAD') end)
    map('n', '<leader>h~', function() gs.change_base('~') end)
    map('n', '<leader>hi', function() gs.reset_base() end)
    -- global base change
    map('n', '<leader>HH', function() gs.change_base('HEAD', true) end)
    map('n', '<leader>H~', function() gs.change_base('~', true) end)
    map('n', '<leader>HI', function() gs.reset_base(true) end)

    -- Text object
    map({'o', 'x'}, 'ih', ':<C-U>Gitsigns select_hunk<CR>')
  end
}
EOF

" diffview {{{3
lua << EOF
require'diffview'.setup {
  view = {
    merge_tool = { layout = 'diff4_mixed' }
  },
  file_panel = {
    win_config = { position = "right" }
  }
}
EOF

" gitlineage {{{3
lua require'gitlineage'.setup()

" blame {{{3
lua require'blame'.setup()

" indent-blankline {{{3
lua << EOF
require'ibl'.setup {
  enabled = false,
}
EOF

" neo-tree {{{3
lua << EOF
require'neo-tree'.setup {
  sources = {
    'filesystem',
    'buffers',
    'git_status',
    'document_symbols',
  },
  window = {
    position = 'right',
  },
  filesystem = {
    hijack_netrw_behavior = "disabled",
  },
}
EOF

" nvim-tree {{{3
lua << EOF
require'nvim-tree'.setup {
    hijack_netrw = false,
    sort = {
        sorter = 'case_sensitive',
    },
    view = {
        side = 'right',
        width = 30,
    },
}
EOF

" colorizer {{{3
lua << EOF
require'colorizer'.setup {
  filetypes = {
    'css',
    'html',
    'javascript',
    'lua',
  },
  user_default_options = {
      names = false,
  },
}
EOF

" todo-comments {{{3
lua << EOF
require'todo-comments'.setup {
  signs = false,
  gui_style = {
    fg = 'BOLD',
  },
  highlight = {
    multiline = false,
    keyword = 'fg',
    after = '',
  },
  colors = {
    info = { 'Todo' }
  }
}

vim.keymap.set('n', ']T', function() require('todo-comments').jump_next() end,
                          { desc = 'Next todo comment' })

vim.keymap.set('n', '[T', function() require('todo-comments').jump_prev() end,
                          { desc = 'Previous todo comment' })
EOF

" neogit {{{3
lua << EOF
require'neogit'.setup {
    graph_style = 'unicode',
}

--local neogit = require('neogit')
--
--vim.keymap.set('n', ',gt',
--    neogit.action('log', 'log_current')
--)
EOF

" toggleterm {{{3
lua << EOF
require'toggleterm'.setup {
    size = 30,
    open_mapping = [[<M-t>]],
    insert_mappings = false,
    on_create = function(term)
        vim.bo[term.bufnr].bufhidden = 'hide'
        vim.wo.foldcolumn = '0'
    end,
}
EOF

" harpoon {{{3
"lua << EOF
"require'harpoon'.setup()
"EOF

" bqf {{{3
lua << EOF
require'bqf'.setup {
    auto_enable = false,
    preview = {
        winblend = 0,
    },
}
EOF

" zen-mode {{{3
lua << EOF
require'zen-mode'.setup {
    window = {
        backdrop = 1,
        width = function()
            factor = 0.9
            if vim.o.columns <= 100 then factor = 1
            elseif vim.o.columns >= 200 then factor = 0.5
            elseif vim.o.columns >= 170 then factor = 0.65
            elseif vim.o.columns >= 150 then factor = 0.75 end
            return vim.fn.ceil(vim.o.columns * factor)
        end,
    },
    plugins = {
        options = {
            --laststatus = 3, -- enable status line
            ruler = true,
            showcmd = true,
        },
    },
}
EOF

" tabby {{{3
lua << EOF
local theme = {
    fill = 'TabLineFill',
    head = 'TabLine',
    current_tab = 'TabLineSel',
    tab = 'TabLine',
    win = 'TabLine',
    tail = 'TabLine',
}

local api = require('tabby.module.api')
local devicons = require('nvim-web-devicons')

function get_tab_name(tab)
    return string.gsub(tab.name(), '%[..%]', '')
end

function get_tab_window_count(tab)
    local count = #tab.wins().wins

    return count > 1 and '[' .. count .. ']' or ''
end

local function get_modified(tab)
    local win_ids = api.get_tab_wins(tab.id)

    for _, win_id in ipairs(win_ids) do
        if pcall(vim.api.nvim_win_get_buf, win_id) then
            local bufid = vim.api.nvim_win_get_buf(win_id)

            if vim.api.nvim_buf_get_option(bufid, 'modified') then
                return '󰏫'
            end
        end
    end

    return ''
end

local function get_current_buffer_icon()
    local current_buffer_filename = vim.fn.expand('%:t')
    local current_buffer_extension = vim.fn.expand('%:e')

    return devicons.get_icon(current_buffer_filename, current_buffer_extension, { default = true })
end

require'tabby'.setup {
    preset = 'tab_only',
    line = function(line)
    return {
        {
          { '   ', hl = theme.head },
        },
        line.tabs().foreach(function(tab)
          local hl = tab.is_current() and theme.current_tab or theme.tab
          return {
            line.sep('', hl, theme.fill),
            '|' .. tab.number() .. '| ',
            devicons.get_icon(get_tab_name(tab), nil, { default = true }),
            get_tab_name(tab),
            get_tab_window_count(tab),
            get_modified(tab),
            line.sep('', hl, theme.fill),
            hl = hl,
            margin = ' ',
          }
        end),
        line.spacer(),
        {
          { ' ', get_current_buffer_icon(), '  ', hl = theme.tail },
        },
        hl = theme.fill,
      }
    end,
}
EOF

" yazi {{{3
lua << EOF
require'yazi'.setup()
EOF

" csvview {{{3
lua << EOF
require'csvview'.setup()
EOF

endif " has('nvim')

" vimrc.local ============================================================ {{{1
"
let s:vimrc_local = $MYVIMRC . '.local'
if filereadable(s:vimrc_local)
    execute 'source ' . s:vimrc_local
endif

" modeline =============================================================== {{{1
" vim: foldmethod=marker
"
" 1}}}