From 00dabe92dc2a87f52391dc077218079d074d61a9 Mon Sep 17 00:00:00 2001 From: Kien Nguyen Tuan Date: Thu, 31 Oct 2024 10:46:31 +0700 Subject: [PATCH] add nvim event --- vim-neovim/nvim-events.md | 1629 +++++++++++++++++++++++++++++++++++++ 1 file changed, 1629 insertions(+) create mode 100644 vim-neovim/nvim-events.md diff --git a/vim-neovim/nvim-events.md b/vim-neovim/nvim-events.md new file mode 100644 index 0000000..7059ea6 --- /dev/null +++ b/vim-neovim/nvim-events.md @@ -0,0 +1,1629 @@ +# Nvim Events + +Source: + +Nvim recognizes the following events. Names are case-insensitive. + +
+BufAdd + +``` +Just after creating a new buffer which is +added to the buffer list, or adding a buffer +to the buffer list, a buffer in the buffer +list was renamed. +Not triggered for the initial buffers created +during startup. +Before |BufEnter|. +NOTE: Current buffer "%" may be different from +the buffer being created "". +``` +
+ +
+BufDelete + +``` +Before deleting a buffer from the buffer list. +The BufUnload may be called first (if the +buffer was loaded). +Also used just before a buffer in the buffer +list is renamed. +NOTE: Current buffer "%" may be different from +the buffer being deleted "" and "". +Do not change to another buffer. +``` +
+ +
+BufEnter + +``` +After entering a buffer. Useful for setting +options for a file type. Also executed when +starting to edit a buffer. +After |BufAdd|. +After |BufReadPost|. +``` +
+ +
+BufFilePost + +``` +After changing the name of the current buffer +with the ":file" or ":saveas" command. +``` +
+ +
+BufFilePre + +``` +Before changing the name of the current buffer +with the ":file" or ":saveas" command. +``` +
+ +
+BufHidden + +``` +Before a buffer becomes hidden: when there are +no longer windows that show the buffer, but +the buffer is not unloaded or deleted. + +Not used for ":qa" or ":q" when exiting Vim. +NOTE: current buffer "%" may be different from +the buffer being unloaded "". +``` +
+ +
+BufLeave + +``` +Before leaving to another buffer. Also when +leaving or closing the current window and the +new current window is not for the same buffer. + +Not used for ":qa" or ":q" when exiting Vim. +``` +
+ +
+BufModifiedSet + +``` +After the `'modified'` value of a buffer has +been changed. +``` +
+ +
+BufNew + +``` +Just after creating a new buffer. Also used +just after a buffer has been renamed. When +the buffer is added to the buffer list BufAdd +will be triggered too. +NOTE: Current buffer "%" may be different from +the buffer being created "". +``` +
+ +
+BufNewFile + +``` +When starting to edit a file that doesn't +exist. Can be used to read in a skeleton +file. +``` +
+ +
+BufRead or BufReadPost + +``` +When starting to edit a new buffer, after +reading the file into the buffer, before +processing modelines. See |BufWinEnter| to do +something after processing modelines. +Also triggered: +- when writing an unnamed buffer in a way that + the buffer gets a name +- after successfully recovering a file +- for the "filetypedetect" group when + executing ":filetype detect" +Not triggered: +- for the `:read file` command +- when the file doesn't exist +``` +
+ +
+BufReadCmd + +``` +Before starting to edit a new buffer. Should +read the file into the buffer. |Cmd-event| +``` +
+ +
+BufReadPre + +``` +When starting to edit a new buffer, before +reading the file into the buffer. Not used +if the file doesn't exist. +``` +
+ +
+BufUnload + +``` +Before unloading a buffer, when the text in +the buffer is going to be freed. +After BufWritePost. +Before BufDelete. +Triggers for all loaded buffers when Vim is +going to exit. +NOTE: Current buffer "%" may be different from +the buffer being unloaded "". +Do not switch buffers or windows! +Not triggered when exiting and v:dying is 2 or +more. +``` +
+ +
+BufWinEnter + +``` +After a buffer is displayed in a window. This +may be when the buffer is loaded (after +processing modelines) or when a hidden buffer +is displayed (and is no longer hidden). + +Not triggered for |:split| without arguments, +since the buffer does not change, or :split +with a file already open in a window. +Triggered for ":split" with the name of the +current buffer, since it reloads that buffer. +``` +
+ +
+BufWinLeave + +``` +Before a buffer is removed from a window. +Not when it's still visible in another window. +Also triggered when exiting. +Before BufUnload, BufHidden. +NOTE: Current buffer "%" may be different from +the buffer being unloaded "". +Not triggered when exiting and v:dying is 2 or +more. +``` +
+ +
+BufWipeout + +``` +Before completely deleting a buffer. The +BufUnload and BufDelete events may be called +first (if the buffer was loaded and was in the +buffer list). Also used just before a buffer +is renamed (also when it's not in the buffer +list). +NOTE: Current buffer "%" may be different from +the buffer being deleted "". +Do not change to another buffer. +``` +
+ +
+BufWrite or BufWritePre + +``` +Before writing the whole buffer to a file. +``` +
+ +
+BufWriteCmd + +``` +Before writing the whole buffer to a file. +Should do the writing of the file and reset +'modified' if successful, unless '+' is in +'cpo' and writing to another file |cpo-+|. +The buffer contents should not be changed. +When the command resets 'modified' the undo +information is adjusted to mark older undo +states as 'modified', like |:write| does. +|Cmd-event| +``` +
+ +
+BufWritePost + +``` +After writing the whole buffer to a file +(should undo the commands for BufWritePre). +``` +
+ +
+ChanInfo + +``` +State of channel changed, for instance the +client of a RPC channel described itself. +Sets these |v:event| keys: + info +See |nvim_get_chan_info()| for the format of +the info Dictionary. +``` +
+ +
+ChanOpen + +``` +Just after a channel was opened. +Sets these |v:event| keys: + info +See |nvim_get_chan_info()| for the format of +the info Dictionary. +``` +
+ +
+CmdUndefined + +``` +When a user command is used but it isn't +defined. Useful for defining a command only +when it's used. The pattern is matched +against the command name. Both and + expand to the command name. +NOTE: Autocompletion won't work until the +command is defined. An alternative is to +always define the user command and have it +invoke an autoloaded function. See |autoload|. +``` +
+ +
+CmdlineChanged + +``` +After a change was made to the text inside +command line. Be careful not to mess up the +command line, it may cause Vim to lock up. + expands to the |cmdline-char|. +``` +
+ +
+CmdlineEnter + +``` +After entering the command-line (including +non-interactive use of ":" in a mapping: use +|| instead to avoid this). + expands to the |cmdline-char|. +Sets these |v:event| keys: + cmdlevel + cmdtype +``` +
+ +
+CmdlineLeave + +``` +Before leaving the command-line (including +non-interactive use of ":" in a mapping: use +|| instead to avoid this). + expands to the |cmdline-char|. +Sets these |v:event| keys: + abort (mutable) + cmdlevel + cmdtype +Note: `abort` can only be changed from false +to true: cannot execute an already aborted +cmdline by changing it to false. +``` +
+ +
+CmdwinEnter + +``` +After entering the command-line window. +Useful for setting options specifically for +this special type of window. + expands to a single character, +indicating the type of command-line. +|cmdwin-char| +``` +
+ +
+CmdwinLeave + +``` +Before leaving the command-line window. +Useful to clean up any global setting done +with CmdwinEnter. + expands to a single character, +indicating the type of command-line. +|cmdwin-char| +``` +
+ +
+ColorScheme + +``` +After loading a color scheme. |:colorscheme| +Not triggered if the color scheme is not +found. +The pattern is matched against the +colorscheme name. can be used for the +name of the actual file where this option was +set, and for the new colorscheme +name. +``` +
+ +
+ColorSchemePre + +``` +Before loading a color scheme. |:colorscheme| +Useful to setup removing things added by a +color scheme, before another one is loaded. +``` +
+ +
+CompleteChanged + +``` +CompleteChanged +After each time the Insert mode completion +menu changed. Not fired on popup menu hide, +use |CompleteDonePre| or |CompleteDone| for +that. + +Sets these |v:event| keys: + completed_itemSee |complete-items|. + heightnr of items visible + widthscreen cells + rowtop screen row + colleftmost screen column + sizetotal nr of items + scrollbarTRUE if visible + +Non-recursive (event cannot trigger itself). +Cannot change the text. |textlock| + +The size and position of the popup are also +available by calling |pum_getpos()|. +``` +
+ +
+CompleteDonePre + +``` +After Insert mode completion is done. Either +when something was completed or abandoning +completion. |ins-completion| +|complete_info()| can be used, the info is +cleared after triggering CompleteDonePre. +The |v:completed_item| variable contains +information about the completed item. +``` +
+ +
+CompleteDone + +``` +After Insert mode completion is done. Either +when something was completed or abandoning +completion. |ins-completion| +|complete_info()| cannot be used, the info is +cleared before triggering CompleteDone. Use +CompleteDonePre if you need it. +|v:completed_item| gives the completed item. +``` +
+ +
+CursorHold + +``` +When the user doesn't press a key for the time +specified with 'updatetime'. Not triggered +until the user has pressed a key (i.e. doesn't +fire every 'updatetime' ms if you leave Vim to +make some coffee. :) See |CursorHold-example| +for previewing tags. +This event is only triggered in Normal mode. +It is not triggered when waiting for a command +argument to be typed, or a movement after an +operator. +While recording the CursorHold event is not +triggered. |q| + +Internally the autocommand is triggered by the + key. In an expression mapping +|getchar()| may see this character. + +Note: Interactive commands cannot be used for +this event. There is no hit-enter prompt, +the screen is updated directly (when needed). +Note: In the future there will probably be +another option to set the time. +Hint: to force an update of the status lines +use: > +:let &ro = &ro +``` +
+ +
+CursorHoldI + +``` +Like CursorHold, but in Insert mode. Not +triggered when waiting for another key, e.g. +after CTRL-V, and not in CTRL-X mode +|insert_expand|. +``` +
+ +
+CursorMoved + +``` +After the cursor was moved in Normal or Visual +mode or to another window. Also when the text +of the cursor line has been changed, e.g. with +"x", "rx" or "p". +Not always triggered when there is typeahead, +while executing commands in a script file, or +when an operator is pending. Always triggered +when moving to another window. +For an example see |match-parens|. +Note: Cannot be skipped with |:noautocmd|. +Careful: This is triggered very often, don't +do anything that the user does not expect or +that is slow. +``` +
+ +
+CursorMovedI + +``` +After the cursor was moved in Insert mode. +Not triggered when the popup menu is visible. +Otherwise the same as CursorMoved. +``` +
+ +
+DiffUpdated + +``` +After diffs have been updated. Depending on +what kind of diff is being used (internal or +external) this can be triggered on every +change or when doing |:diffupdate|. +``` +
+ +
+DirChanged + +``` +After the |current-directory| was changed. +The pattern can be: +"window" to trigger on `:lcd` +"tabpage" to trigger on `:tcd` +"global" to trigger on `:cd` +"auto" to trigger on 'autochdir'. +Sets these |v:event| keys: + cwd: current working directory + scope: "global", "tabpage", "window" + changed_window: v:true if we fired the event + switching window (or tab) + is set to the new directory name. +Non-recursive (event cannot trigger itself). +``` +
+ +
+DirChangedPre + +``` +When the |current-directory| is going to be +changed, as with |DirChanged|. +The pattern is like with |DirChanged|. +Sets these |v:event| keys: + directory: new working directory + scope: "global", "tabpage", "window" + changed_window: v:true if we fired the event + switching window (or tab) + is set to the new directory name. +Non-recursive (event cannot trigger itself). +``` +
+ +
+ExitPre + +``` +When using `:quit`, `:wq` in a way it makes +Vim exit, or using `:qall`, just after +|QuitPre|. Can be used to close any +non-essential window. Exiting may still be +cancelled if there is a modified buffer that +isn't automatically saved, use |VimLeavePre| +for really exiting. +See also |QuitPre|, |WinClosed|. +``` +
+ +
+FileAppendCmd + +``` +Before appending to a file. Should do the +appending to the file. Use the '[ and '] +marks for the range of lines. |Cmd-event| +``` +
+ +
+FileAppendPost + +``` +After appending to a file. +``` +
+ +
+FileAppendPre + +``` +Before appending to a file. Use the '[ and '] +marks for the range of lines. +``` +
+ +
+FileChangedRO + +``` +Before making the first change to a read-only +file. Can be used to checkout the file from +a source control system. Not triggered when +the change was caused by an autocommand. +Triggered when making the first change in +a buffer or the first change after 'readonly' +was set, just before the change is applied to +the text. +WARNING: If the autocommand moves the cursor +the effect of the change is undefined. + +Cannot switch buffers. You can reload the +buffer but not edit another one. + +If the number of lines changes saving for undo +may fail and the change will be aborted. +``` +
+ +
+FileChangedShell + +``` +When Vim notices that the modification time of +a file has changed since editing started. +Also when the file attributes of the file +change or when the size of the file changes. +|timestamp| +Triggered for each changed file, after: +- executing a shell command +- |:checktime| +- |FocusGained| + +Not used when 'autoread' is set and the buffer +was not changed. If a FileChangedShell +autocommand exists the warning message and +prompt is not given. +|v:fcs_reason| indicates what happened. Set +|v:fcs_choice| to control what happens next. +NOTE: Current buffer "%" may be different from +the buffer that was changed "". + +Cannot switch, jump to or delete buffers. +Non-recursive (event cannot trigger itself). +``` +
+ +
+FileChangedShellPost + +``` +After handling a file that was changed outside +of Vim. Can be used to update the statusline. +``` +
+ +
+FileReadCmd + +``` +Before reading a file with a ":read" command. +Should do the reading of the file. |Cmd-event| +``` +
+ +
+FileReadPost + +``` +After reading a file with a ":read" command. +Note that Vim sets the '[ and '] marks to the +first and last line of the read. This can be +used to operate on the lines just read. +``` +
+ +
+FileReadPre + +``` +Before reading a file with a ":read" command. +``` +
+ +
+FileType + +``` +When the 'filetype' option has been set. The +pattern is matched against the filetype. + is the name of the file where this +option was set. is the new value of +'filetype'. +Cannot switch windows or buffers. +See |filetypes|. +``` +
+ +
+FileWriteCmd + +``` +Before writing to a file, when not writing the +whole buffer. Should do the writing to the +file. Should not change the buffer. Use the +'[ and '] marks for the range of lines. +|Cmd-event| +``` +
+ +
+FileWritePost + +``` +After writing to a file, when not writing the +whole buffer. +``` +
+ +
+FileWritePre + +``` +Before writing to a file, when not writing the +whole buffer. Use the '[ and '] marks for the +range of lines. +``` +
+ +
+FilterReadPost + +``` +After reading a file from a filter command. +Vim checks the pattern against the name of +the current buffer as with FilterReadPre. +Not triggered when 'shelltemp' is off. +``` +
+ +
+FilterReadPre + +``` +Before reading a file from a filter command. +Vim checks the pattern against the name of +the current buffer, not the name of the +temporary file that is the output of the +filter command. +Not triggered when 'shelltemp' is off. +``` +
+ +
+FilterWritePost + +``` +After writing a file for a filter command or +making a diff with an external diff (see +|DiffUpdated| for internal diff). +Vim checks the pattern against the name of +the current buffer as with FilterWritePre. +Not triggered when 'shelltemp' is off. +``` +
+ +
+FilterWritePre + +``` +Before writing a file for a filter command or +making a diff with an external diff. +Vim checks the pattern against the name of +the current buffer, not the name of the +temporary file that is the output of the +filter command. +Not triggered when 'shelltemp' is off. +``` +
+ +
+FocusGained + +``` +Nvim got focus. +``` +
+ +
+FocusLost + +``` +Nvim lost focus. Also (potentially) when +a GUI dialog pops up. +``` +
+ +
+FuncUndefined + +``` +When a user function is used but it isn't +defined. Useful for defining a function only +when it's used. The pattern is matched +against the function name. Both and + are set to the name of the function. +NOTE: When writing Vim scripts a better +alternative is to use an autoloaded function. +See |autoload-functions|. +``` +
+ +
+UIEnter + +``` +After a UI connects via |nvim_ui_attach()|, or +after builtin TUI is started, after |VimEnter|. +Sets these |v:event| keys: + chan: 0 for builtin TUI + 1 for |--embed| + |channel-id| of the UI otherwise +``` +
+ +
+UILeave + +``` +After a UI disconnects from Nvim, or after +builtin TUI is stopped, after |VimLeave|. +Sets these |v:event| keys: + chan: 0 for builtin TUI + 1 for |--embed| + |channel-id| of the UI otherwise +``` +
+ +
+InsertChange + +``` +When typing while in Insert or +Replace mode. The |v:insertmode| variable +indicates the new mode. +Be careful not to move the cursor or do +anything else that the user does not expect. +``` +
+ +
+InsertCharPre + +``` +When a character is typed in Insert mode, +before inserting the char. +The |v:char| variable indicates the char typed +and can be changed during the event to insert +a different character. When |v:char| is set +to more than one character this text is +inserted literally. + +Cannot change the text. |textlock| +Not triggered when 'paste' is set. +``` +
+ +
+InsertEnter + +``` +Just before starting Insert mode. Also for +Replace mode and Virtual Replace mode. The +|v:insertmode| variable indicates the mode. +Be careful not to do anything else that the +user does not expect. +The cursor is restored afterwards. If you do +not want that set |v:char| to a non-empty +string. +``` +
+ +
+InsertLeavePre + +``` +Just before leaving Insert mode. Also when +using CTRL-O |i_CTRL-O|. Be careful not to +change mode or use `:normal`, it will likely +cause trouble. +``` +
+ +
+InsertLeave + +``` +Just after leaving Insert mode. Also when +using CTRL-O |i_CTRL-O|. But not for |i_CTRL-C|. +``` +
+ +
+MenuPopup + +``` +Just before showing the popup menu (under the +right mouse button). Useful for adjusting the +menu for what is under the cursor or mouse +pointer. +The pattern is matched against one or two +characters representing the mode: +n Normal +v Visual +o Operator-pending +i Insert +c Command line +tl Terminal +``` +
+ +
+ModeChanged + +``` +After changing the mode. The pattern is +matched against `'old_mode:new_mode'`, for +example match against `*:c` to simulate +|CmdlineEnter|. +The following values of |v:event| are set: +old_mode The mode before it changed. +new_mode The new mode as also returned +by |mode()| called with a +non-zero argument. +When ModeChanged is triggered, old_mode will +have the value of new_mode when the event was +last triggered. +This will be triggered on every minor mode +change. +Usage example to use relative line numbers +when entering visual mode: > +:au ModeChanged [vV\x16]*:* let &l:rnu = mode() =~# '^[vV\x16]' +:au ModeChanged *:[vV\x16]* let &l:rnu = mode() =~# '^[vV\x16]' +:au WinEnter,WinLeave * let &l:rnu = mode() =~# '^[vV\x16]' +``` +
+ +
+OptionSet + +``` +After setting an option (except during +|startup|). The |autocmd-pattern| is matched +against the long option name. || +indicates what option has been set. + +|v:option_type| indicates whether it's global +or local scoped. +|v:option_command| indicates what type of +set/let command was used (follow the tag to +see the table). +|v:option_new| indicates the newly set value. +|v:option_oldlocal| has the old local value. +|v:option_oldglobal| has the old global value. +|v:option_old| indicates the old option value. + +|v:option_oldlocal| is only set when |:set| +or |:setlocal| or a |modeline| was used to set +the option. Similarly |v:option_oldglobal| is +only set when |:set| or |:setglobal| was used. + +Note that when setting a |global-local| string +option with |:set|, then |v:option_old| is the +old global value. However, for all other kinds +of options (local string options, global-local +number options, ...) it is the old local +value. + +OptionSet is not triggered on startup and for +the 'key' option for obvious reasons. + +Usage example: Check for the existence of the +directory in the 'backupdir' and 'undodir' +options, create the directory if it doesn't +exist yet. + +Note: Do not reset the same option during this +autocommand, that may break plugins. You can +always use |:noautocmd| to prevent triggering +OptionSet. + +Non-recursive: |:set| in the autocommand does +not trigger OptionSet again. +``` +
+ +
+QuickFixCmdPre + +``` +Before a quickfix command is run (|:make|, +|:lmake|, |:grep|, |:lgrep|, |:grepadd|, +|:lgrepadd|, |:vimgrep|, |:lvimgrep|, +|:vimgrepadd|, |:lvimgrepadd|, +|:cfile|, |:cgetfile|, |:caddfile|, |:lfile|, +|:lgetfile|, |:laddfile|, |:helpgrep|, +|:lhelpgrep|, |:cexpr|, |:cgetexpr|, +|:caddexpr|, |:cbuffer|, |:cgetbuffer|, +|:caddbuffer|). +The pattern is matched against the command +being run. When |:grep| is used but 'grepprg' +is set to "internal" it still matches "grep". +This command cannot be used to set the +'makeprg' and 'grepprg' variables. +If this command causes an error, the quickfix +command is not executed. +``` +
+ +
+QuickFixCmdPost + +``` +Like QuickFixCmdPre, but after a quickfix +command is run, before jumping to the first +location. For |:cfile| and |:lfile| commands +it is run after the error file is read and +before moving to the first error. +See |QuickFixCmdPost-example|. +``` +
+ +
+QuitPre + +``` +When using `:quit`, `:wq` or `:qall`, before +deciding whether it closes the current window +or quits Vim. For `:wq` the buffer is written +before QuitPre is triggered. Can be used to +close any non-essential window if the current +window is the last ordinary window. +See also |ExitPre|, |WinClosed|. +``` +
+ +
+RemoteReply + +``` +When a reply from a Vim that functions as +server was received server2client(). The +pattern is matched against the {serverid}. + is equal to the {serverid} from which +the reply was sent, and is the actual +reply string. +Note that even if an autocommand is defined, +the reply should be read with remote_read() +to consume it. +``` +
+ +
+SearchWrapped + +``` +After making a search with |n| or |N| if the +search wraps around the document back to +the start/finish respectively. +``` +
+ +
+RecordingEnter + +``` +When a macro starts recording. +The pattern is the current file name, and +|reg_recording()| is the current register that +is used. +``` +
+ +
+RecordingLeave + +``` +When a macro stops recording. +The pattern is the current file name, and +|reg_recording()| is the recorded +register. +|reg_recorded()| is only updated after this +event. +Sets these |v:event| keys: + regcontents + regname +``` +
+ +
+SessionLoadPost + +``` +After loading the session file created using +the |:mksession| command. +``` +
+ +
+ShellCmdPost + +``` +After executing a shell command with |:!cmd|, +|:make| and |:grep|. Can be used to check for +any changed files. +For non-blocking shell commands, see +|job-control|. +``` +
+ +
+Signal + +``` +After Nvim receives a signal. The pattern is +matched against the signal name. Only +"SIGUSR1" and "SIGWINCH" are supported. Example: > + autocmd Signal SIGUSR1 call some#func() +``` +
+ +
+ShellFilterPost + +``` +After executing a shell command with +":{range}!cmd", ":w !cmd" or ":r !cmd". +Can be used to check for any changed files. +``` +
+ +
+SourcePre + +``` +Before sourcing a vim/lua file. |:source| + is the name of the file being sourced. +``` +
+ +
+SourcePost + +``` +After sourcing a vim/lua file. |:source| + is the name of the file being sourced. +Not triggered when sourcing was interrupted. +Also triggered after a SourceCmd autocommand +was triggered. +``` +
+ +
+SourceCmd + +``` +When sourcing a vim/lua file. |:source| + is the name of the file being sourced. +The autocommand must source this file. +|Cmd-event| +``` +
+ +
+SpellFileMissing + +``` +When trying to load a spell checking file and +it can't be found. The pattern is matched +against the language. is the +language, 'encoding' also matters. See +|spell-SpellFileMissing|. +``` +
+ +
+StdinReadPost + +``` +During startup, after reading from stdin into +the buffer, before executing modelines. |--| +``` +
+ +
+StdinReadPre + +``` +During startup, before reading from stdin into +the buffer. |--| +``` +
+ +
+SwapExists + +``` +Detected an existing swap file when starting +to edit a file. Only when it is possible to +select a way to handle the situation, when Vim +would ask the user what to do. +The |v:swapname| variable holds the name of +the swap file found, the file being +edited. |v:swapcommand| may contain a command +to be executed in the opened file. +The commands should set the |v:swapchoice| +variable to a string with one character to +tell Vim what should be done next: +'o' open read-only +'e' edit the file anyway +'r' recover +'d' delete the swap file +'q' quit, don't edit the file +'a' abort, like hitting CTRL-C +When set to an empty string the user will be +asked, as if there was no SwapExists autocmd. + +Cannot change to another buffer, change +the buffer name or change directory. +``` +
+ +
+Syntax + +``` +When the 'syntax' option has been set. The +pattern is matched against the syntax name. + expands to the name of the file where +this option was set. expands to the +new value of 'syntax'. +See |:syn-on|. +``` +
+ +
+TabEnter + +``` +Just after entering a tab page. |tab-page| +After WinEnter. +Before BufEnter. +``` +
+ +
+TabLeave + +``` +Just before leaving a tab page. |tab-page| +After WinLeave. +``` +
+ +
+TabNew + +``` +When creating a new tab page. |tab-page| +After WinEnter. +Before TabEnter. +``` +
+ +
+TabNewEntered + +``` +After entering a new tab page. |tab-page| +After BufEnter. +``` +
+ +
+TabClosed + +``` +After closing a tab page. expands to +the tab page number. +``` +
+ +
+TermOpen + +``` +When a |terminal| job is starting. Can be +used to configure the terminal buffer. +``` +
+ +
+TermEnter + +``` +After entering |Terminal-mode|. +After TermOpen. +``` +
+ +
+TermLeave + +``` +After leaving |Terminal-mode|. +After TermClose. +``` +
+ +
+TermClose + +``` +When a |terminal| job ends. +Sets these |v:event| keys: + status +``` +
+ +
+TermResponse + +``` +After the response to t_RV is received from +the terminal. The value of |v:termresponse| +can be used to do things depending on the +terminal version. May be triggered halfway +through another event (file I/O, a shell +command, or anything else that takes time). +``` +
+ +
+TextChanged + +``` +After a change was made to the text in the +current buffer in Normal mode. That is after +|b:changedtick| has changed (also when that +happened before the TextChanged autocommand +was defined). +Not triggered when there is typeahead or when +an operator is pending. +Note: Cannot be skipped with `:noautocmd`. +Careful: This is triggered very often, don't +do anything that the user does not expect or +that is slow. +``` +
+ +
+TextChangedI + +``` +After a change was made to the text in the +current buffer in Insert mode. +Not triggered when the popup menu is visible. +Otherwise the same as TextChanged. +``` +
+ +
+TextChangedP + +``` +After a change was made to the text in the +current buffer in Insert mode, only when the +popup menu is visible. Otherwise the same as +TextChanged. +``` +
+ +
+TextChangedT + +``` +After a change was made to the text in the +current buffer in |Terminal-mode|. Otherwise +the same as TextChanged. +``` +
+ +
+TextYankPost + +``` +Just after a |yank| or |deleting| command, but not +if the black hole register |quote_| is used nor +for |setreg()|. Pattern must be *. +Sets these |v:event| keys: + inclusive + operator + regcontents + regname + regtype + visual +The `inclusive` flag combined with the |'[| +and |']| marks can be used to calculate the +precise region of the operation. + +Non-recursive (event cannot trigger itself). +Cannot change the text. |textlock| +``` +
+ +
+User + +``` +Not executed automatically. Use |:doautocmd| +to trigger this, typically for "custom events" +in a plugin. Example: > + :autocmd User MyPlugin echom 'got MyPlugin event' + :doautocmd User MyPlugin +``` +
+ +
+UserGettingBored + +``` +When the user presses the same key 42 times. +Just kidding! :-) +``` +
+ +
+VimEnter + +``` +After doing all the startup stuff, including +loading vimrc files, executing the "-c cmd" +arguments, creating all windows and loading +the buffers in them. +Just before this event is triggered the +|v:vim_did_enter| variable is set, so that you +can do: > + if v:vim_did_enter + call s:init() + else + au VimEnter * call s:init() + endif +``` +
+ +
+VimLeave + +``` +Before exiting Vim, just after writing the +.shada file. Executed only once, like +VimLeavePre. +Use |v:dying| to detect an abnormal exit. +Use |v:exiting| to get the exit code. +Not triggered if |v:dying| is 2 or more. +``` +
+ +
+VimLeavePre + +``` +Before exiting Vim, just before writing the +.shada file. This is executed only once, +if there is a match with the name of what +happens to be the current buffer when exiting. +Mostly useful with a "*" pattern. > + :autocmd VimLeavePre * call CleanupStuff() +Use |v:dying| to detect an abnormal exit. +Use |v:exiting| to get the exit code. +Not triggered if |v:dying| is 2 or more. +``` +
+ +
+VimResized + +``` +After the Vim window was resized, thus 'lines' +and/or 'columns' changed. Not when starting +up though. +``` +
+ +
+VimResume + +``` +After Nvim resumes from |suspend| state. +``` +
+ +
+VimSuspend + +``` +Before Nvim enters |suspend| state. +``` +
+ +
+WinClosed + +``` +When closing a window, just before it is +removed from the window layout. The pattern +is matched against the |window-ID|. Both + and are set to the |window-ID|. +After WinLeave. +Non-recursive (event cannot trigger itself). +See also |ExitPre|, |QuitPre|. +``` +
+ +
+WinEnter + +``` +After entering another window. Not done for +the first window, when Vim has just started. +Useful for setting the window height. +If the window is for another buffer, Vim +executes the BufEnter autocommands after the +WinEnter autocommands. +Note: For split and tabpage commands the +WinEnter event is triggered after the split +or tab command but before the file is loaded. +``` +
+ +
+WinLeave + +``` +Before leaving a window. If the window to be +entered next is for a different buffer, Vim +executes the BufLeave autocommands before the +WinLeave autocommands (but not for ":new"). +Not used for ":qa" or ":q" when exiting Vim. +Before WinClosed. +``` +
+ +
+WinNew + +``` +When a new window was created. Not done for +the first window, when Vim has just started. +Before WinEnter. +``` +
+ +
+WinScrolled + +``` +After any window in the current tab page +scrolled the text (horizontally or vertically) +or changed width or height. See +|win-scrolled-resized|. + +The pattern is matched against the |window-ID| +of the first window that scrolled or resized. +Both and are set to the +|window-ID|. + +|v:event| is set with information about size +and scroll changes. |WinScrolled-event| + +Only starts triggering after startup finished +and the first screen redraw was done. +Does not trigger when defining the first +WinScrolled or WinResized event, but may +trigger when adding more. + +Non-recursive: the event will not trigger +while executing commands for the WinScrolled +event. However, if the command causes a +window to scroll or change size, then another +WinScrolled event will be triggered later. +``` +
+ +
+WinResized + +``` +After a window in the current tab page changed +width or height. +See |win-scrolled-resized|. + +|v:event| is set with information about size +changes. |WinResized-event| + +Same behavior as |WinScrolled| for the +pattern, triggering and recursiveness. +``` +