;;; evil-vars.el --- Settings and variables -*- lexical-binding: t -*- ;; Author: Vegard Øye ;; Maintainer: Vegard Øye ;; Version: 1.14.0 ;; ;; This file is NOT part of GNU Emacs. ;;; License: ;; This file is part of Evil. ;; ;; Evil is free software: you can redistribute it and/or modify ;; it under the terms of the GNU General Public License as published by ;; the Free Software Foundation, either version 3 of the License, or ;; (at your option) any later version. ;; ;; Evil is distributed in the hope that it will be useful, ;; but WITHOUT ANY WARRANTY; without even the implied warranty of ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ;; GNU General Public License for more details. ;; ;; You should have received a copy of the GNU General Public License ;; along with Evil. If not, see . ;;; Code: (declare-function evil-add-command-properties "evil-common" (command &rest properties)) (declare-function evil-update-insert-state-bindings "evil-maps" (&optional _option-name remove force)) ;;; Hooks (defvar evil-after-load-hook nil "Functions to be run when loading of Evil is finished. This hook can be used the execute some initialization routines when Evil is completely loaded.") (defcustom evil-goto-definition-functions '(evil-goto-definition-imenu evil-goto-definition-semantic evil-goto-definition-xref evil-goto-definition-search) "List of functions run until success by `evil-goto-definition'." :type 'hook :group 'evil) ;;; Initialization (defvar evil-pending-custom-initialize nil "A list of pending initializations for custom variables. Each element is a triple (FUNC VAR VALUE). When Evil is completely loaded then the functions (funcall FUNC VAR VALUE) is called for each element. FUNC should be a function suitable for the :initialize property of `defcustom'.") (defun evil-custom-initialize-pending-reset (var value) "Add a pending customization with `custom-initialize-reset'." (push (list 'custom-initialize-reset var value) evil-pending-custom-initialize)) (defun evil-run-pending-custom-initialize () "Executes the pending initializations. See `evil-pending-custom-initialize'." (dolist (init evil-pending-custom-initialize) (apply (car init) (cdr init))) (remove-hook 'evil-after-load-hook 'evil-run-pending-custom-initialize)) (add-hook 'evil-after-load-hook 'evil-run-pending-custom-initialize) ;;; Setters (defun evil-set-toggle-key (key) "Set `evil-toggle-key' to KEY. KEY must be readable by `read-kbd-macro'." (let ((old-key (read-kbd-macro (if (boundp 'evil-toggle-key) evil-toggle-key "C-z"))) (key (read-kbd-macro key))) (with-no-warnings (dolist (pair '((evil-motion-state-map evil-emacs-state) (evil-insert-state-map evil-emacs-state) (evil-emacs-state-map evil-exit-emacs-state))) (when (boundp (car pair)) (let ((map (symbol-value (car pair))) (fun (cadr pair))) (when (keymapp map) (define-key map key fun) (define-key map old-key nil)))))))) (defun evil-set-custom-state-maps (var pending-var key _make newlist) "Changes the list of special keymaps. VAR is the variable containing the list of keymaps. PENDING-VAR is the variable containing the list of the currently pending keymaps. KEY the special symbol to be stored in the keymaps. MAKE the creation function of the special keymaps. NEWLIST the list of new special keymaps." (set-default pending-var newlist) (when (default-boundp var) (dolist (map (default-value var)) (when (and (boundp (car map)) (keymapp (default-value (car map)))) (define-key (default-value (car map)) (vector key) nil)))) (set-default var newlist) (evil-update-pending-maps)) (defun evil-update-pending-maps (&optional _file) "Tries to set pending special keymaps. This function should be called from an `after-load-functions' hook." (let ((maps '((evil-make-overriding-map . evil-pending-overriding-maps) (evil-make-intercept-map . evil-pending-intercept-maps)))) (while maps (let* ((map (pop maps)) (make (car map)) (pending-var (cdr map)) (pending (symbol-value pending-var)) newlist) (while pending (let* ((map (pop pending)) (kmap (and (boundp (car map)) (keymapp (symbol-value (car map))) (symbol-value (car map)))) (state (cdr map))) (if kmap (funcall make kmap state) (push map newlist)))) (set-default pending-var newlist))))) (defun evil-set-visual-newline-commands (var value) "Set the value of `evil-visual-newline-commands'. Setting this variable changes the properties of the appropriate commands." (with-no-warnings (when (default-boundp var) (dolist (cmd (default-value var)) (evil-set-command-property cmd :exclude-newline nil))) (set-default var value) (dolist (cmd (default-value var)) (evil-set-command-property cmd :exclude-newline t)))) (defun evil-set-custom-motions (var values) "Sets the list of motion commands." (with-no-warnings (when (default-boundp var) (dolist (motion (default-value var)) (evil-add-command-properties motion :keep-visual nil :repeat nil))) (set-default var values) (mapc #'evil-declare-motion (default-value var)))) ;;; Customization group (defgroup evil nil "Extensible vi layer." :group 'emulations :prefix 'evil-) (defcustom evil-auto-indent t "\\ Whether to auto-indent when opening lines with \\[evil-open-below] \ and \\[evil-open-above]." :type 'boolean :group 'evil) (make-variable-buffer-local 'evil-auto-indent) (defcustom evil-shift-width 4 "\\ The number of columns by which a line is shifted. This applies to the shifting operators \\[evil-shift-right] and \ \\[evil-shift-left]." :type 'integer :group 'evil) (make-variable-buffer-local 'evil-shift-width) (defcustom evil-shift-round t "\\ Whether shifting rounds to the nearest multiple. If non-nil, \\[evil-shift-right] and \\[evil-shift-left] adjust line indentation to the nearest multiple of `evil-shift-width'." :type 'boolean :group 'evil) (make-variable-buffer-local 'evil-shift-round) (defcustom evil-indent-convert-tabs t "\\ If non-nil, the \\[evil-indent] operator converts between leading tabs and spaces. Whether tabs are converted to spaces or vice versa depends on the value of `indent-tabs-mode'." :type 'boolean :group 'evil) (defcustom evil-default-cursor t "The default cursor. May be a cursor type as per `cursor-type', a color string as passed to `set-cursor-color', a zero-argument function for changing the cursor, or a list of the above." :type '(set symbol (cons symbol symbol) string function) :group 'evil) (defvar evil-force-cursor nil "Overwrite the current states default cursor.") (defcustom evil-repeat-move-cursor t "\\ Whether repeating commands with \\[evil-repeat] may move the cursor. If nil, the original cursor position is preserved, even if the command normally would have moved the cursor." :type 'boolean :group 'evil) (defcustom evil-cross-lines nil "\\ Whether horizontal motions may move to other lines. If non-nil, certain motions that conventionally operate in a single line may move the cursor to other lines. Otherwise, they are restricted to the current line. This applies to \\[evil-backward-char], \ \\[evil-forward-char], \\[evil-find-char], \ \\[evil-find-char-backward], \\[evil-find-char-to], \ \\[evil-find-char-to-backward], \ \\\\[evil-invert-char]." :type 'boolean :group 'evil) (defcustom evil-backspace-join-lines t "Whether backward delete in insert state may join lines." :type 'boolean :group 'evil) (defcustom evil-move-cursor-back t "Whether the cursor is moved backwards when exiting insert state. If non-nil, the cursor moves \"backwards\" when exiting insert state, so that it ends up on the character to the left. Otherwise it remains in place, on the character to the right." :type 'boolean :group 'evil) (defcustom evil-move-beyond-eol nil "Whether the cursor can move past the end of the line. If non-nil, the cursor is allowed to move one character past the end of the line, as in Emacs." :type 'boolean :group 'evil) (defcustom evil-respect-visual-line-mode nil "\\ Whether movement commands respect `visual-line-mode'. If non-nil, `visual-line-mode' is generally respected when it is on. In this case, motions such as \\[evil-next-line] and \\[evil-previous-line] navigate by visual lines (on the screen) rather than \"physical\" lines (defined by newline characters). If nil, the setting of `visual-line-mode' is ignored. This variable must be set before Evil is loaded." :type 'boolean :group 'evil) (defcustom evil-repeat-find-to-skip-next t "Whether a repeat of t or T should skip an adjacent character." :type 'boolean :group 'evil) (defcustom evil-kbd-macro-suppress-motion-error nil "\\ Whether left/right motions signal errors in keyboard macros. This variable only affects beginning-of-line or end-of-line errors regarding the motions \\[evil-backward-char] and \\[evil-forward-char] respectively. This may be desired since such errors cause macro definition or execution to be terminated. There are four possibilities: - `record': errors are suppressed when recording macros, but not when replaying them. - `replay': errors are suppressed when replaying macros, but not when recording them. - `t': errors are suppressed in both cases. - `nil': errors are never suppressed." :type '(radio (const :tag "No" :value nil) (const :tag "Record" :value record) (const :tag "Replay" :value replay) (const :tag "Both" :value t)) :group 'evil) (defcustom evil-track-eol t "\\ Whether \\[evil-end-of-line] \"sticks\" the cursor to the end of the line. If non-nil, vertical motions after \\[evil-end-of-line] maintain the cursor at the end of the line, even if the target line is longer. This is analogous to `track-eol', but respects Evil's interpretation of end-of-line." :type 'boolean :group 'evil) (defcustom evil-mode-line-format 'before "The position of the state tag in the mode line. If set to `before' or `after', the tag is placed at the beginning or the end of the mode-line, respectively. If nil, there is no tag. Otherwise it should be a cons cell (WHERE . WHICH), where WHERE is either `before' or `after', and WHICH is a symbol in `mode-line-format'. The tag is then placed before or after that symbol, respectively." :type '(radio :value 'before (const before) (const after) (cons :tag "Next to symbol" (choice :value after (const before) (const after)) symbol)) :group 'evil) (defcustom evil-mouse-word 'evil-word "The thing-at-point symbol for double click selection. The double-click starts visual state in a special word selection mode. This symbol is used to determine the words to be selected. Possible values are `evil-word' or `evil-WORD'." :type 'symbol :group 'evil) (defcustom evil-bigword "^ \t\r\n" "The set of characters to be interpreted as WORD boundaries. This is enclosed with square brackets and used as a regular expression. By default, whitespace characters are considered WORD boundaries." :type 'string :group 'evil) (make-variable-buffer-local 'evil-bigword) (defcustom evil-want-fine-undo nil "Whether actions are undone in several steps. There are two possible choices: nil (\"no\") means that all changes made during insert state, including a possible delete after a change operation, are collected in a single undo step. Non-nil (\"yes\") means that undo steps are determined according to Emacs heuristics, and no attempt is made to aggregate changes. For backward compatibility purposes, the value `fine' is interpreted as `nil'. This option was removed because it did not work consistently." :type '(radio (const :tag "No" :value nil) (const :tag "Fine (obsolete)" :value fine) (const :tag "Yes" :value t)) :group 'evil) (defcustom evil-regexp-search t "\\ Whether to use regular expressions for searching in \ \\[evil-search-forward] and \\[evil-search-backward]." :type 'boolean :group 'evil) (defcustom evil-search-wrap t "\\ Whether search with \\[evil-search-forward] and \ \\[evil-search-backward] wraps around the buffer. If this is non-nil, search stops at the buffer boundaries." :type 'boolean :group 'evil) (defcustom evil-flash-delay 2 "\\ Time in seconds to flash search matches after \\[evil-search-next] and \ \\[evil-search-previous]." :type 'number :group 'evil) (defcustom evil-auto-balance-windows t "If non-nil window creation and deletion trigger rebalancing." :type 'boolean :group 'evil) (defcustom evil-split-window-below nil "If non-nil split windows are created below." :type 'boolean :group 'evil) (defcustom evil-vsplit-window-right nil "If non-nil vertically split windows with are created to the right." :type 'boolean :group 'evil) (defcustom evil-esc-delay 0.01 "The time, in seconds, to wait for another key after escape. If no further event arrives during this time, the event is translated to `ESC'. Otherwise, it is translated according to `input-decode-map'. This does not apply in Emacs state, and may also be inhibited by setting `evil-inhibit-esc'." :type 'number :group 'evil) (defvar evil-esc-mode nil "Non-nil if `evil-esc-mode' is enabled.") (defvar evil-esc-map nil "Original ESC prefix map in `input-decode-map'. Used by `evil-esc-mode'.") (defvar evil-inhibit-esc nil "If non-nil, the \\e event will never be translated to 'escape.") (defcustom evil-intercept-esc 'always "Whether Evil should intercept the escape key. In the terminal, escape and a meta key sequence both generate the same event. In order to distingush these, Evil uses `input-decode-map'. It is not necessary to do this in a graphical Emacs session. However, if you prefer to use `C-[' as escape (which is identical to the terminal escape key code), this interception must also happen in graphical Emacs sessions. Set this variable to `always', t (only in the terminal) or nil (never intercept)." :type '(radio (const :tag "Never" :value nil) (const :tag "In terminal only" :value t) (const :tag "Always" :value always)) :group 'evil) (defcustom evil-show-paren-range 0 "The minimal distance between point and a parenthesis which causes the parenthesis to be highlighted." :type 'integer :group 'evil) (defcustom evil-ex-hl-update-delay 0.02 "Time in seconds of idle before updating search highlighting. Setting this to a period shorter than that of keyboard's repeat rate allows highlights to update while scrolling." :type 'number :group 'evil) (defcustom evil-highlight-closing-paren-at-point-states '(not emacs insert replace) "The states in which the closing parenthesis at point should be highlighted. All states listed here highlight the closing parenthesis at point (which is Vim's default behavior). All others highlight the parenthesis before point (which is Emacs default behavior). If this list contains the symbol `not' then its meaning is inverted, i.e. all states listed here highlight the closing parenthesis before point." :type '(repeat symbol) :group 'evil) (defcustom evil-kill-on-visual-paste t "Whether pasting in visual state adds the replaced text to the kill ring, making it the default for the next paste. The default, replicates the default Vim behavior." :type 'boolean :group 'evil) (defcustom evil-want-C-i-jump t "Whether `C-i' jumps forward in the jump list (like Vim). Otherwise, `C-i' inserts a tab character." :type 'boolean :group 'evil :set #'(lambda (sym value) (set-default sym value) (when (boundp 'evil-motion-state-map) (cond ((and (not value) (eq (lookup-key evil-motion-state-map (kbd "C-i")) 'evil-jump-forward)) (define-key evil-motion-state-map (kbd "C-i") nil)) ((and value (not (lookup-key evil-motion-state-map (kbd "C-i")))) (define-key evil-motion-state-map (kbd "C-i") 'evil-jump-forward)))))) (defcustom evil-want-C-u-scroll nil "Whether `C-u' scrolls up (like Vim). Otherwise, `C-u' applies a prefix argument. The binding of `C-u' mirrors Emacs behaviour by default due to the relative ubiquity of prefix arguments." :type 'boolean :group 'evil :set #'(lambda (sym value) (set-default sym value) (when (boundp 'evil-motion-state-map) (cond ((and (not value) (eq (lookup-key evil-motion-state-map (kbd "C-u")) 'evil-scroll-up)) (define-key evil-motion-state-map (kbd "C-u") nil)) ((and value (not (lookup-key evil-motion-state-map (kbd "C-u")))) (define-key evil-motion-state-map (kbd "C-u") 'evil-scroll-up)))))) (defcustom evil-want-C-d-scroll t "Whether `C-d' scrolls down (like Vim)." :type 'boolean :group 'evil :set #'(lambda (sym value) (set-default sym value) (when (boundp 'evil-motion-state-map) (cond ((and (not value) (eq (lookup-key evil-motion-state-map (kbd "C-d")) 'evil-scroll-down)) (define-key evil-motion-state-map (kbd "C-d") nil)) ((and value (not (lookup-key evil-motion-state-map (kbd "C-d")))) (define-key evil-motion-state-map (kbd "C-d") 'evil-scroll-down)))))) (defcustom evil-want-C-u-delete nil "Whether `C-u' deletes back to indentation in insert state. Otherwise, `C-u' applies a prefix argument. The binding of `C-u' mirrors Emacs behaviour by default due to the relative ubiquity of prefix arguments." :type 'boolean :group 'evil :set #'(lambda (sym value) (set-default sym value) (when (boundp 'evil-insert-state-map) (cond ((and (not value) (eq (lookup-key evil-insert-state-map (kbd "C-u")) 'evil-delete-back-to-indentation)) (define-key evil-insert-state-map (kbd "C-u") nil)) ((and value (not (lookup-key evil-insert-state-map (kbd "C-u")))) (define-key evil-insert-state-map (kbd "C-u") 'evil-delete-back-to-indentation)))))) (defcustom evil-want-C-w-delete t "Whether `C-w' deletes a word in Insert state." :type 'boolean :group 'evil :set #'(lambda (sym value) (set-default sym value) (when (boundp 'evil-insert-state-map) (cond ((and (not value) (eq (lookup-key evil-insert-state-map (kbd "C-w")) 'evil-delete-backward-word)) (define-key evil-insert-state-map (kbd "C-w") 'evil-window-map)) ((and value (eq (lookup-key evil-insert-state-map (kbd "C-w")) 'evil-window-map)) (define-key evil-insert-state-map (kbd "C-w") 'evil-delete-backward-word)))))) (defcustom evil-want-C-w-in-emacs-state nil "Whether `C-w' prefixes windows commands in Emacs state." :type 'boolean :group 'evil :set #'(lambda (sym value) (set-default sym value) (when (boundp 'evil-emacs-state-map) (cond ((and (not value) (eq (lookup-key evil-emacs-state-map (kbd "C-w")) 'evil-window-map)) (define-key evil-emacs-state-map (kbd "C-w") nil)) ((and value (not (lookup-key evil-emacs-state-map (kbd "C-w")))) (define-key evil-emacs-state-map (kbd "C-w") 'evil-window-map)))))) (defcustom evil-want-change-word-to-end t "Whether `cw' behaves like `ce'." :type 'boolean :group 'evil) (defcustom evil-want-Y-yank-to-eol nil "Whether `Y' yanks to the end of the line. The default behavior is to yank the whole line, like Vim." :group 'evil :type 'boolean :initialize #'evil-custom-initialize-pending-reset :set #'(lambda (_sym value) (evil-add-command-properties 'evil-yank-line :motion (if value 'evil-end-of-line-or-visual-line 'evil-line-or-visual-line)))) (defcustom evil-disable-insert-state-bindings nil "Whether insert state bindings should be used. Bindings for escape, delete and `evil-toggle-key' are always available. If this is non-nil, default Emacs bindings are by and large accessible in insert state." :group 'evil :type 'boolean :initialize #'evil-custom-initialize-pending-reset :set #'evil-update-insert-state-bindings) (defcustom evil-echo-state t "Whether to signal the current state in the echo area." :type 'boolean :group 'evil) (defcustom evil-complete-all-buffers t "\\ Whether completion looks for matches in all buffers. This applies to \\[evil-complete-next] and \\[evil-complete-previous] \ in insert state." :type 'boolean :group 'evil) (defvar dabbrev-search-these-buffers-only) (defvar dabbrev-case-distinction) (defcustom evil-complete-next-func #'(lambda (arg) (require 'dabbrev) (let ((dabbrev-search-these-buffers-only (unless evil-complete-all-buffers (list (current-buffer)))) dabbrev-case-distinction) (condition-case nil (if (eq last-command this-command) (dabbrev-expand nil) (dabbrev-expand (- (abs (or arg 1))))) (error (dabbrev-expand nil))))) "Completion function used by \ \\\\[evil-complete-next]." :type 'function :group 'evil) (defcustom evil-complete-previous-func #'(lambda (arg) (require 'dabbrev) (let ((dabbrev-search-these-buffers-only (unless evil-complete-all-buffers (list (current-buffer)))) dabbrev-case-distinction) (dabbrev-expand arg))) "Completion function used by \ \\\\[evil-complete-previous]." :type 'function :group 'evil) (defcustom evil-complete-next-minibuffer-func 'minibuffer-complete "Minibuffer completion function used by \ \\\\[evil-complete-next]." :type 'function :group 'evil) (defcustom evil-complete-previous-minibuffer-func 'minibuffer-complete "Minibuffer completion function used by \ \\\\[evil-complete-previous]." :type 'function :group 'evil) (defcustom evil-complete-next-line-func #'(lambda (arg) (let ((hippie-expand-try-functions-list '(try-expand-line try-expand-line-all-buffers))) (hippie-expand arg))) "Minibuffer completion function used by \ \\\\[evil-complete-next-line]." :type 'function :group 'evil) (defcustom evil-complete-previous-line-func evil-complete-next-line-func "Minibuffer completion function used by \ \\\\[evil-complete-previous-line]." :type 'function :group 'evil) (defcustom evil-lookup-func #'woman "Lookup function used by \ \"\\\\[evil-lookup]\"." :type 'function :group 'evil) (defcustom evil-toggle-key "C-z" "The key used to change to and from Emacs state. Must be readable by `read-kbd-macro'. For example: \"C-z\"." :type 'string :group 'evil :set #'(lambda (sym value) (evil-set-toggle-key value) (set-default sym value))) (defcustom evil-default-state 'normal "The default Evil state. This is the state a buffer starts in when it is not otherwise configured (see `evil-set-initial-state' and `evil-buffer-regexps'). The value may be one of `normal', `insert', `visual', `replace', `operator', `motion' and `emacs'." :type 'symbol :group 'evil) (defcustom evil-buffer-regexps '(("^ \\*load\\*" . nil)) "Regular expressions determining the initial state for a buffer. Entries have the form (REGEXP . STATE), where REGEXP is a regular expression matching the buffer's name and STATE is one of `normal', `insert', `visual', `replace', `operator', `motion', `emacs' and `nil'. If STATE is `nil', Evil is disabled in the buffer." :type '(alist :key-type string :value-type symbol) :group 'evil) (defcustom evil-emacs-state-modes '(5x5-mode archive-mode bbdb-mode biblio-selection-mode blackbox-mode bookmark-bmenu-mode bookmark-edit-annotation-mode browse-kill-ring-mode bubbles-mode bzr-annotate-mode calc-mode cfw:calendar-mode completion-list-mode Custom-mode custom-theme-choose-mode debugger-mode delicious-search-mode desktop-menu-blist-mode desktop-menu-mode doc-view-mode dun-mode dvc-bookmarks-mode dvc-diff-mode dvc-info-buffer-mode dvc-log-buffer-mode dvc-revlist-mode dvc-revlog-mode dvc-status-mode dvc-tips-mode ediff-mode ediff-meta-mode efs-mode Electric-buffer-menu-mode emms-browser-mode emms-mark-mode emms-metaplaylist-mode emms-playlist-mode ess-help-mode etags-select-mode fj-mode gc-issues-mode gdb-breakpoints-mode gdb-disassembly-mode gdb-frames-mode gdb-locals-mode gdb-memory-mode gdb-registers-mode gdb-threads-mode gist-list-mode git-rebase-mode gnus-article-mode gnus-browse-mode gnus-group-mode gnus-server-mode gnus-summary-mode gomoku-mode google-maps-static-mode ibuffer-mode jde-javadoc-checker-report-mode magit-cherry-mode magit-diff-mode magit-log-mode magit-log-select-mode magit-popup-mode magit-popup-sequence-mode magit-process-mode magit-reflog-mode magit-refs-mode magit-revision-mode magit-stash-mode magit-stashes-mode magit-status-mode mh-folder-mode monky-mode mpuz-mode mu4e-main-mode mu4e-headers-mode mu4e-view-mode notmuch-hello-mode notmuch-search-mode notmuch-show-mode notmuch-tree-mode occur-mode org-agenda-mode package-menu-mode pdf-outline-buffer-mode pdf-view-mode proced-mode rcirc-mode rebase-mode recentf-dialog-mode reftex-select-bib-mode reftex-select-label-mode reftex-toc-mode sldb-mode slime-inspector-mode slime-thread-control-mode slime-xref-mode snake-mode solitaire-mode sr-buttons-mode sr-mode sr-tree-mode sr-virtual-mode tar-mode tetris-mode tla-annotate-mode tla-archive-list-mode tla-bconfig-mode tla-bookmarks-mode tla-branch-list-mode tla-browse-mode tla-category-list-mode tla-changelog-mode tla-follow-symlinks-mode tla-inventory-file-mode tla-inventory-mode tla-lint-mode tla-logs-mode tla-revision-list-mode tla-revlog-mode tla-tree-lint-mode tla-version-list-mode twittering-mode urlview-mode vc-annotate-mode vc-dir-mode vc-git-log-view-mode vc-hg-log-view-mode vc-svn-log-view-mode vm-mode vm-summary-mode w3m-mode wab-compilation-mode xgit-annotate-mode xgit-changelog-mode xgit-diff-mode xgit-revlog-mode xhg-annotate-mode xhg-log-mode xhg-mode xhg-mq-mode xhg-mq-sub-mode xhg-status-extra-mode) "Modes that should come up in Emacs state." :type '(repeat symbol) :group 'evil) (defcustom evil-insert-state-modes '(comint-mode erc-mode eshell-mode geiser-repl-mode gud-mode inferior-apl-mode inferior-caml-mode inferior-emacs-lisp-mode inferior-j-mode inferior-python-mode inferior-scheme-mode inferior-sml-mode internal-ange-ftp-mode prolog-inferior-mode reb-mode shell-mode slime-repl-mode term-mode wdired-mode) "Modes that should come up in Insert state." :type '(repeat symbol) :group 'evil) (defcustom evil-motion-state-modes '(apropos-mode Buffer-menu-mode calendar-mode color-theme-mode command-history-mode compilation-mode dictionary-mode ert-results-mode help-mode Info-mode Man-mode speedbar-mode undo-tree-visualizer-mode woman-mode) "Modes that should come up in Motion state." :type '(repeat symbol) :group 'evil) (defvar evil-pending-overriding-maps nil "An alist of pending overriding maps.") (defvar evil-pending-intercept-maps nil "An alist of pending intercept maps.") (defcustom evil-overriding-maps '((Buffer-menu-mode-map . nil) (color-theme-mode-map . nil) (comint-mode-map . nil) (compilation-mode-map . nil) (grep-mode-map . nil) (dictionary-mode-map . nil) (ert-results-mode-map . motion) (Info-mode-map . motion) (speedbar-key-map . nil) (speedbar-file-key-map . nil) (speedbar-buffers-key-map . nil)) "Keymaps that should override Evil maps. Entries have the form (MAP-VAR . STATE), where MAP-VAR is a keymap variable and STATE is the state whose bindings should be overridden. If STATE is nil, all states are overridden." :type '(alist :key-type symbol :value-type symbol) :group 'evil :set #'(lambda (_var values) (evil-set-custom-state-maps 'evil-overriding-maps 'evil-pending-overriding-maps 'override-state 'evil-make-overriding-map values)) :initialize 'evil-custom-initialize-pending-reset) (add-hook 'after-load-functions #'evil-update-pending-maps) (defcustom evil-intercept-maps '((edebug-mode-map . nil)) "Keymaps that should intercept Evil maps. Entries have the form (MAP-VAR . STATE), where MAP-VAR is a keymap variable and STATE is the state whose bindings should be intercepted. If STATE is nil, all states are intercepted." :type '(alist :key-type symbol :value-type symbol) :group 'evil :set #'(lambda (_var values) (evil-set-custom-state-maps 'evil-intercept-maps 'evil-pending-intercept-maps 'intercept-state 'evil-make-intercept-map values)) :initialize 'evil-custom-initialize-pending-reset) (defcustom evil-motions '(back-to-indentation backward-char backward-list backward-paragraph backward-sentence backward-sexp backward-up-list backward-word beginning-of-buffer beginning-of-defun beginning-of-line beginning-of-visual-line c-beginning-of-defun c-end-of-defun diff-file-next diff-file-prev diff-hunk-next diff-hunk-prev down-list end-of-buffer end-of-defun end-of-line end-of-visual-line exchange-point-and-mark forward-char forward-list forward-paragraph forward-sentence forward-sexp forward-word goto-last-change ibuffer-backward-line ibuffer-forward-line isearch-abort isearch-cancel isearch-complete isearch-del-char isearch-delete-char isearch-edit-string isearch-exit isearch-highlight-regexp isearch-occur isearch-other-control-char isearch-other-meta-char isearch-printing-char isearch-query-replace isearch-query-replace-regexp isearch-quote-char isearch-repeat-backward isearch-repeat-forward isearch-ring-advance isearch-ring-retreat isearch-toggle-case-fold isearch-toggle-input-method isearch-toggle-regexp isearch-toggle-specified-input-method isearch-toggle-word isearch-yank-char isearch-yank-kill isearch-yank-line isearch-yank-word-or-char keyboard-quit left-char left-word mouse-drag-region mouse-save-then-kill mouse-set-point mouse-set-region mwheel-scroll move-beginning-of-line move-end-of-line next-error next-line paredit-backward paredit-backward-down paredit-backward-up paredit-forward paredit-forward-down paredit-forward-up pop-global-mark pop-tag-mark pop-to-mark-command previous-error previous-line right-char right-word scroll-down scroll-down-command scroll-up scroll-up-command sgml-skip-tag-backward sgml-skip-tag-forward up-list) "Non-Evil commands to initialize to motions." :type '(repeat symbol) :group 'evil :set 'evil-set-custom-motions :initialize 'evil-custom-initialize-pending-reset) (defcustom evil-visual-newline-commands '(LaTeX-section TeX-font) "Commands excluding the trailing newline of a Visual Line selection. These commands work better without this newline." :type '(repeat symbol) :group 'evil :set 'evil-set-visual-newline-commands :initialize 'evil-custom-initialize-pending-reset) (defcustom evil-want-visual-char-semi-exclusive nil "Visual character selection to beginning/end of line is exclusive. If non nil then an inclusive visual character selection which ends at the beginning or end of a line is turned into an exclusive selection. Thus if the selected (inclusive) range ends at the beginning of a line it is changed to not include the first character of that line, and if the selected range ends at the end of a line it is changed to not include the newline character of that line." :type 'boolean :group 'evil) (defcustom evil-text-object-change-visual-type t "Text objects change the current visual state type. If non-nil then a text-object changes the type of the visual state to its default selection type (e.g. a word object always changes to charwise visual state). Otherwise the current visual state type is preserved." :type 'boolean :group 'evil) (defgroup evil-cjk nil "CJK support" :prefix "evil-cjk-" :group 'evil) (defcustom evil-cjk-emacs-word-boundary nil "Determine word boundary exactly the same way as Emacs does." :type 'boolean :group 'evil-cjk) (defcustom evil-cjk-word-separating-categories '(;; Kanji (?C . ?H) (?C . ?K) (?C . ?k) (?C . ?A) (?C . ?G) ;; Hiragana (?H . ?C) (?H . ?K) (?H . ?k) (?H . ?A) (?H . ?G) ;; Katakana (?K . ?C) (?K . ?H) (?K . ?k) (?K . ?A) (?K . ?G) ;; half-width Katakana (?k . ?C) (?k . ?H) (?k . ?K) ; (?k . ?A) (?k . ?G) ;; full-width alphanumeric (?A . ?C) (?A . ?H) (?A . ?K) ; (?A . ?k) (?A . ?G) ;; full-width Greek (?G . ?C) (?G . ?H) (?G . ?K) ; (?G . ?k) (?G . ?A) ) "List of pair (cons) of categories to determine word boundary used in `evil-cjk-word-boundary-p'. See the documentation of `word-separating-categories'. Use `describe-categories' to see the list of categories." :type '(alist :key-type (choice character (const nil)) :value-type (choice character (const nil))) :group 'evil-cjk) (defcustom evil-cjk-word-combining-categories '(;; default value in word-combining-categories (nil . ?^) (?^ . nil) ;; Roman (?r . ?k) (?r . ?A) (?r . ?G) ;; half-width Katakana (?k . ?r) (?k . ?A) (?k . ?G) ;; full-width alphanumeric (?A . ?r) (?A . ?k) (?A . ?G) ;; full-width Greek (?G . ?r) (?G . ?k) (?G . ?A) ) "List of pair (cons) of categories to determine word boundary used in `evil-cjk-word-boundary-p'. See the documentation of `word-combining-categories'. Use `describe-categories' to see the list of categories." :type '(alist :key-type (choice character (const nil)) :value-type (choice character (const nil))) :group 'evil-cjk) (defcustom evil-ex-complete-emacs-commands 'in-turn "TAB-completion for Emacs commands in ex command line. This variable determines when Emacs commands are considered for completion, always, never, or only if no Evil ex command is available for completion." :group 'evil :type '(radio (const :tag "Only if no ex-command." :value in-turn) (const :tag "Never" :value nil) (const :tag "Always" :value t))) (defface evil-ex-commands '(( nil :underline t :slant italic)) "Face for the Evil command in completion in ex mode." :group 'evil) (defface evil-ex-info '(( ((supports :slant)) :slant italic :foreground "red")) "Face for the info message in ex mode." :group 'evil) (defcustom evil-ex-visual-char-range nil "Type of default ex range in visual char state. If non-nil the default range when starting an ex command from character visual state is `<,`> otherwise it is '<,'>. In the first case the ex command will be passed a region covering only the visual selection. In the second case the passed region will be extended to contain full lines." :group 'evil :type 'boolean) ;; Searching (defcustom evil-symbol-word-search nil "If nil then * and # search for words otherwise for symbols." :group 'evil :type 'boolean) (make-variable-buffer-local 'evil-symbol-word-search) (defcustom evil-magic t "Meaning which characters in a pattern are magic. The meaning of those values is the same as in Vim. Note that it only has influence if the Evil search module is chosen in `evil-search-module'." :group 'evil :type '(radio (const :tag "Very magic." :value very-magic) (const :tag "Magic" :value t) (const :tag "Nomagic" :value nil) (const :tag "Very nomagic" :value very-nomagic))) (defcustom evil-ex-search-vim-style-regexp nil "If non-nil Vim-style backslash codes are supported in search patterns. See `evil-transform-vim-style-regexp' for the supported backslash codes. Note that this only affects the search command if `evil-search-module' is set to 'evil-search. The isearch module always uses plain Emacs regular expressions." :type 'boolean :group 'evil) (defcustom evil-ex-interactive-search-highlight 'all-windows "Determine in which windows the interactive highlighting should be shown." :type '(radio (const :tag "All windows." all-windows) (const :tag "Selected window." selected-window) (const :tag "Disable highlighting." nil)) :group 'evil) (defcustom evil-ex-search-persistent-highlight t "If non-nil matches remain highlighted when the search ends." :type 'boolean :group 'evil) (defcustom evil-ex-search-case 'smart "The case behaviour of the search command. Smart case means that the pattern is case sensitive if and only if it contains an upper case letter, otherwise it is case insensitive." :type '(radio (const :tag "Case sensitive." sensitive) (const :tag "Case insensitive." insensitive) (const :tag "Smart case." smart)) :group 'evil) (defcustom evil-ex-substitute-case nil "The case behaviour of the search command. Smart case means that the pattern is case sensitive if and only if it contains an upper case letter, otherwise it is case insensitive. If nil then the setting of `evil-ex-search-case' is used." :type '(radio (const :tag "Same as interactive search." nil) (const :tag "Case sensitive." sensitive) (const :tag "Case insensitive." insensitive) (const :tag "Smart case." smart)) :group 'evil) (defcustom evil-ex-search-interactive t "If t search is interactive." :type 'boolean :group 'evil) (defcustom evil-ex-search-highlight-all t "If t and interactive search is enabled, all matches are highlighted." :type 'boolean :group 'evil) (defcustom evil-ex-substitute-highlight-all t "If t all matches for the substitute pattern are highlighted." :type 'boolean :group 'evil) (defcustom evil-ex-substitute-interactive-replace t "If t and substitute patterns are highlighted, the replacement is shown interactively." :type 'boolean :group 'evil) (defcustom evil-ex-substitute-global nil "If non-nil substitute patterns are global by default. Usually (if this variable is nil) a substitution works only on the first match of a pattern in a line unless the 'g' flag is given, in which case the substitution happens on all matches in a line. If this option is non-nil, this behaviour is reversed: the substitution works on all matches unless the 'g' pattern is specified, then is works only on the first match." :type 'boolean :group 'evil) (defface evil-ex-search '((t :inherit isearch)) "Face for interactive search." :group 'evil) (defface evil-ex-lazy-highlight '((t :inherit lazy-highlight)) "Face for highlighting all matches in interactive search." :group 'evil) (defface evil-ex-substitute-matches '((t :inherit lazy-highlight)) "Face for interactive substitute matches." :group 'evil) (defface evil-ex-substitute-replacement '((((supports :underline)) :underline t :foreground "red")) "Face for interactive replacement text." :group 'evil) (defcustom evil-command-window-height 8 "Height (in lines) of the command line window. Set to 0 to use the default height for `split-window'." :type 'integer :group 'evil) (defcustom evil-display-shell-error-in-message nil "Show error output of a shell command in the error buffer. If this variable is non-nil the error output of a shell command goes to the messages buffer instead of being mixed with the regular output. This happens only if the exit status of the command is non-zero." :type 'boolean :group 'evil) (defcustom evil-want-abbrev-expand-on-insert-exit t "If non-nil abbrevs will be expanded when leaving insert state like in Vim, if `abbrev-mode' is on." :type 'boolean :group 'evil) ;;; Variables (defmacro evil-define-local-var (symbol &optional initvalue docstring) "Define SYMBOL as permanent buffer local variable, and return SYMBOL. The parameters are the same as for `defvar', but the variable SYMBOL is made permanent buffer local." (declare (indent defun) (doc-string 3) (debug (symbolp &optional form stringp))) `(progn (defvar ,symbol ,initvalue ,docstring) (make-variable-buffer-local ',symbol) (put ',symbol 'permanent-local t))) (evil-define-local-var evil-scroll-count 0 "Holds last used prefix for `evil-scroll-up' and `evil-scroll-down'. Determines how many lines should be scrolled. Default value is 0 - scroll half the screen.") (evil-define-local-var evil-state nil "The current Evil state. To change the state, use `evil-change-state' or call the state function (e.g., `evil-normal-state').") ;; these may be used inside `evil-define-state' (evil-define-local-var evil-next-state nil "The Evil state being switched to.") (evil-define-local-var evil-previous-state-alist nil "For Each evil state the Evil state being switched from.") (evil-define-local-var evil-previous-state nil "The Evil state being switched from.") (defvar evil-execute-in-emacs-state-buffer nil "The buffer of the latest `evil-execute-in-emacs-state'. When this command is being executed the current buffer is stored in this variable. This is necessary in case the Emacs-command to be called changes the current buffer.") (evil-define-local-var evil-mode-line-tag nil "Mode-Line indicator for the current state.") (put 'evil-mode-line-tag 'risky-local-variable t) (defvar evil-global-keymaps-alist nil "Association list of keymap variables. Entries have the form (MODE . KEYMAP), where KEYMAP is the variable containing the keymap for MODE.") (defvar evil-local-keymaps-alist nil "Association list of keymap variables that must be reinitialized in each buffer. Entries have the form \(MODE . KEYMAP), where KEYMAP is the variable containing the keymap for MODE.") (defvar evil-minor-mode-keymaps-alist nil "Association list of Evil states to minor-mode keymap alists. Entries have the form (STATE . MODE-MAP-ALIST), where MODE-MAP-ALIST is an alist taking the form of `minor-mode-map-alist'.") (defvar evil-state-properties nil "Specifications made by `evil-define-state'. Entries have the form (STATE . PLIST), where PLIST is a property list specifying various aspects of the state. To access a property, use `evil-state-property'.") (evil-define-local-var evil-mode-map-alist nil "Association list of keymaps to use for Evil modes. Elements have the form (MODE . KEYMAP), with the first keymaps having higher priority.") (defvar evil-command-properties nil "Specifications made by `evil-define-command'.") (defvar evil-change-commands '(evil-change) "Commands that wrap or replace `evil-change'. This list exists to apply an inconsistency with vim's change command to commands that wrap or redefine it. See emacs-evil/evil#916.") (defvar evil-transient-vars '(cua-mode transient-mark-mode select-active-regions) "List of variables pertaining to Transient Mark mode.") (defvar evil-transient-vals nil "Association list of old values for Transient Mark mode variables. Entries have the form (VARIABLE VALUE LOCAL), where LOCAL is whether the variable was previously buffer-local.") (evil-define-local-var evil-no-display nil "If non-nil, various Evil displays are inhibited. Use the macro `evil-without-display' to set this variable.") (defvar evil-type-properties nil "Specifications made by `evil-define-type'. Entries have the form (TYPE . PLIST), where PLIST is a property list specifying functions for handling the type: expanding it, describing it, etc.") (defvar evil-interactive-alist nil "Association list of Evil-specific interactive codes.") (evil-define-local-var evil-motion-marker nil "Marker for storing the starting position of a motion.") (evil-define-local-var evil-this-type nil "Current motion type.") (evil-define-local-var evil-this-type-modified nil "Non-nil iff current motion type has been modified by the user. If the type has been modified, this variable contains the new type.") (evil-define-local-var evil-this-register nil "Current register.") (defvar evil-this-macro nil "Current macro register.") (evil-define-local-var evil-this-operator nil "Current operator.") (evil-define-local-var evil-this-motion nil "Current motion.") (evil-define-local-var evil-this-motion-count nil "Current motion count.") (defvar evil-last-register nil "The last executed register.") (defvar evil-inhibit-operator nil "Inhibit current operator. If an operator calls a motion and the motion sets this variable to t, the operator code is not executed.") (defvar evil-inhibit-operator-value nil "This variable is used to transfer the value of `evil-inhibit-operator' from one local scope to another.") ;; used by `evil-define-operator' (defvar evil-operator-range-beginning nil "Beginning of `evil-operator-range'.") (defvar evil-operator-range-end nil "End of `evil-operator-range'.") (defvar evil-operator-range-type nil "Type of `evil-operator-range'.") (defvar evil-operator-range-motion nil "Motion of `evil-operator-range'.") (defvar evil-restriction-stack nil "List of previous restrictions. Using `evil-with-restriction' stores the previous values of `point-min' and `point-max' as a pair in this list.") (evil-define-local-var evil-markers-alist '((?\( . evil-backward-sentence) (?\) . evil-forward-sentence) (?{ . evil-backward-paragraph) (?} . evil-forward-paragraph) (?' . evil-jump-backward-swap) (?` . evil-jump-backward-swap) (?< . evil-visual-beginning) (?> . evil-visual-goto-end) (?. . (lambda () (let (last-command) (goto-last-change nil))))) "Association list for markers. Entries have the form (CHAR . DATA), where CHAR is the marker's name and DATA is either a marker object as returned by `make-marker', a variable, a movement function, or a cons cell (STRING NUMBER), where STRING is a file path and NUMBER is a buffer position. The global value of this variable holds markers available from every buffer, while the buffer-local value holds markers available only in the current buffer.") (defconst evil-suppress-map (make-keymap) "Full keymap disabling default bindings to `self-insert-command'.") (suppress-keymap evil-suppress-map t) (defvar evil-read-key-map (make-sparse-keymap) "Keymap active during `evil-read-key'. This keymap can be used to bind some commands during the execution of `evil-read-key' which is usually used to read a character argument for some commands, e.g. `evil-replace'.") ;; TODO: customize size of ring (defvar evil-repeat-ring (make-ring 10) "A ring of repeat-informations to repeat the last command.") (defvar evil-repeat-types '((t . evil-repeat-keystrokes) (change . evil-repeat-changes) (motion . evil-repeat-motion) (insert-at-point . evil-repeat-insert-at-point) (ignore . nil)) "An alist of defined repeat-types.") (defvar evil-recording-repeat nil "Whether we are recording a repeat.") (defvar evil-recording-current-command nil "Whether we are recording the current command for repeat.") (defvar evil-repeat-changes nil "Accumulated buffer changes for changed-based commands.") (defvar evil-repeat-info nil "Information accumulated during current repeat.") (defvar evil-repeat-buffer nil "The buffer in which the repeat started. If the buffer is changed, the repeat is cancelled.") (defvar evil-repeat-pos nil "The position of point at the beginning of an change-tracking editing command.") (defvar evil-repeat-keys nil "The keys that invoked the current command.") (defvar evil-last-repeat nil "Information about the latest repeat command. This is a list of three elements (POINT COUNT UNDO-POINTER), where POINT is the position of point before the latest repeat, COUNT the count-argument of the latest repeat command and UNDO-POINTER the head of the undo-list before the last command has been repeated.") (defvar evil-repeat-count nil "The explicit count when repeating a command.") (defvar evil-maybe-remove-spaces nil "Flag to determine if newly inserted spaces should be removed. See the function `evil-maybe-remove-spaces'.") (evil-define-local-var evil-insert-count nil "The explicit count passed to an command starting Insert state.") (evil-define-local-var evil-insert-vcount nil "The information about the number of following lines the insertion should be repeated. This is list (LINE COLUMN COUNT) where LINE is the line-number where the original insertion started and COLUMN is either a number or function determining the column where the repeated insertions should take place. COUNT is number of repeats (including the original insertion).") (defvar evil-insert-skip-empty-lines nil "Non-nil of the current insertion should not take place on lines at which the insertion point is behind the end of the line.") (evil-define-local-var evil-insert-lines nil "Non-nil if the current insertion command is a line-insertion command o or O.") (evil-define-local-var evil-insert-repeat-info nil "Repeat information accumulated during an insertion.") (evil-define-local-var evil-replace-alist nil "Association list of characters overwritten in Replace state. The format is (POS . CHAR).") (evil-define-local-var evil-echo-area-message nil "Previous value of `current-message'.") (defvar evil-write-echo-area nil "If set to t inside `evil-save-echo-area', then the echo area is not restored.") (defvar evil-last-find nil "A pair (FUNCTION . CHAR) describing the lastest character search command.") (defvar evil-last-paste nil "Information about the latest paste. This should be a list (CMD COUNT POINT BEG END FIRSTVISUAL) where CMD is the last paste-command (`evil-paste-before', `evil-paste-after' or `evil-visual-paste'), COUNT is the repeat count of the paste, POINT is the position of point before the paste, BEG end END are the region of the inserted text. FIRSTVISUAL is t if and only if the previous command was the first visual paste (i.e. before any paste-pop).") (evil-define-local-var evil-last-undo-entry nil "Information about the latest undo entry in the buffer. This should be a pair (OBJ . CONS) where OBJ is the entry as an object, and CONS is a copy of the entry.") (evil-define-local-var evil-current-insertion nil "Information about the latest insertion in insert state. This should be a pair (BEG . END) that describes the buffer-region of the newly inserted text.") (defvar evil-last-insertion nil "The last piece of inserted text.") (defvar evil-last-small-deletion nil "The last piece of deleted text. The text should be less than a line.") (defvar evil-was-yanked-without-register t "Whether text being saved to the numbered-register ring was not deleted and not yanked to a specific register.") (defvar evil-paste-count nil "The count argument of the current paste command.") (defvar evil-temporary-undo nil "When undo is disabled in current buffer. Certain commands depending on undo use this variable instead of `buffer-undo-list'.") (evil-define-local-var evil-undo-list-pointer nil "Everything up to this mark is united in the undo-list.") (defvar evil-in-single-undo nil "Set to non-nil if the current undo steps are connected.") (defvar evil-flash-timer nil "Timer for flashing search results.") (defvar evil-search-prompt nil "String to use for search prompt.") (defvar evil-search-forward-history nil "History of forward searches.") (defvar evil-search-backward-history nil "History of backward searches.") (defvar evil-inner-text-objects-map (make-sparse-keymap) "Keymap for inner text objects.") (defvar evil-outer-text-objects-map (make-sparse-keymap) "Keymap for outer text objects.") (defvar evil-window-map (make-sparse-keymap) "Keymap for window-related commands.") (evil-define-local-var evil-input-method nil "Input method used in Insert state and Emacs state.") ;;; Visual state (evil-define-local-var evil-visual-beginning nil "The beginning of the Visual selection, a marker.") (evil-define-local-var evil-visual-end nil "The end of the Visual selection, a marker.") (evil-define-local-var evil-visual-point nil "The position of point in Visual state, a marker.") (evil-define-local-var evil-visual-mark nil "The position of mark in Visual state, a marker.") (evil-define-local-var evil-visual-previous-mark nil "The position of mark before Visual state, a marker.") (evil-define-local-var evil-visual-selection nil "The kind of Visual selection. This is a selection as defined by `evil-define-visual-selection'.") ;; we could infer the direction by comparing `evil-visual-mark' ;; and `evil-visual-point', but destructive operations may ;; displace the markers (evil-define-local-var evil-visual-direction 0 "Whether point follows mark in Visual state. Negative if point precedes mark, otherwise positive. See also the function `evil-visual-direction'.") (evil-define-local-var evil-visual-properties nil "Property list of miscellaneous Visual properties.") (evil-define-local-var evil-visual-region-expanded nil "Whether the region matches the Visual selection. That is, whether the positions of point and mark have been expanded to coincide with the selection's boundaries. This makes the selection available to functions acting on Emacs' region.") (evil-define-local-var evil-visual-overlay nil "Overlay for highlighting the Visual selection. Not used for blockwise selections, in which case see `evil-visual-block-overlays'.") (evil-define-local-var evil-visual-block-overlays nil "Overlays for Visual Block selection, one for each line. They are reused to minimize flicker.") (defvar evil-visual-alist nil "Association list of Visual selection functions. Elements have the form (NAME . FUNCTION).") (evil-define-local-var evil-visual-x-select-timer nil "Timer for updating the X selection in visual state.") (defvar evil-visual-x-select-timeout 0.1 "Time in seconds for the update of the X selection.") (declare-function origami-open-all-nodes "ext:origami.el") (declare-function origami-close-all-nodes "ext:origami.el") (declare-function origami-toggle-node "ext:origami.el") (declare-function origami-open-node "ext:origami.el") (declare-function origami-open-node-recursively "ext:origami.el") (declare-function origami-close-node "ext:origami.el") (defvar evil-fold-list `(((vdiff-mode) :open-all vdiff-open-all-folds :close-all vdiff-close-all-folds :toggle ,(lambda () (call-interactively 'vdiff-toggle-fold)) :open ,(lambda () (call-interactively 'vdiff-open-fold)) :open-rec ,(lambda () (call-interactively 'vdiff-open-fold)) :close ,(lambda () (call-interactively 'vdiff-close-fold))) ((vdiff-3way-mode) :open-all vdiff-open-all-folds :close-all vdiff-close-all-folds :toggle ,(lambda () (call-interactively 'vdiff-toggle-fold)) :open ,(lambda () (call-interactively 'vdiff-open-fold)) :open-rec ,(lambda () (call-interactively 'vdiff-open-fold)) :close ,(lambda () (call-interactively 'vdiff-close-fold))) ((hs-minor-mode) :open-all hs-show-all :close-all hs-hide-all :toggle hs-toggle-hiding :open hs-show-block :open-rec nil :close hs-hide-block) ((hide-ifdef-mode) :open-all show-ifdefs :close-all hide-ifdefs :toggle nil :open show-ifdef-block :open-rec nil :close hide-ifdef-block) ((outline-mode outline-minor-mode org-mode markdown-mode) :open-all show-all :close-all ,(lambda () (with-no-warnings (hide-sublevels 1))) :toggle outline-toggle-children :open ,(lambda () (with-no-warnings (show-entry) (show-children))) :open-rec show-subtree :close hide-subtree) ((origami-mode) :open-all ,(lambda () (origami-open-all-nodes (current-buffer))) :close-all ,(lambda () (origami-close-all-nodes (current-buffer))) :toggle ,(lambda () (origami-toggle-node (current-buffer) (point))) :open ,(lambda () (origami-open-node (current-buffer) (point))) :open-rec ,(lambda () (origami-open-node-recursively (current-buffer) (point))) :close ,(lambda () (origami-close-node (current-buffer) (point))))) "Actions to be performed for various folding operations. The value should be a list of fold handlers, were a fold handler has the format: ((MODES) PROPERTIES) MODES acts as a predicate, containing the symbols of all major or minor modes for which the handler should match. For example: '((outline-minor-mode org-mode) ...) would match for either outline-minor-mode or org-mode, even though the former is a minor mode and the latter is a major. PROPERTIES specifies possible folding actions and the functions to be applied in the event of a match on one (or more) of the MODES; the supported properties are: - `:open-all' Open all folds. - `:close-all' Close all folds. - `:toggle' Toggle the display of the fold at point. - `:open' Open the fold at point. - `:open-rec' Open the fold at point recursively. - `:close' Close the fold at point. Each value must be a function. A value of `nil' will cause the action to be ignored for that respective handler. For example: `((org-mode) :close-all nil :open ,(lambda () (show-entry) (show-children)) :close hide-subtree) would ignore `:close-all' actions and invoke the provided functions on `:open' or `:close'.") ;;; Ex (defvar evil-ex-map (make-sparse-keymap) "Keymap for Ex. Key sequences bound in this map are immediately executed.") (defvar evil-ex-completion-map (make-sparse-keymap) "Completion keymap for Ex.") (defvar evil-ex-initial-input nil "Additional initial content of the ex command line. This content of this variable is appended to the ex command line if ex is started interactively.") (defvar evil-ex-shell-argument-initialized nil "This variable is set to t if shell command completion has been initialized. See `evil-ex-init-shell-argument-completion'.") (defvar evil-ex-commands nil "Association list of command bindings and functions.") (defvar evil-ex-history nil "History of Ex commands.") (defvar evil-ex-current-buffer nil "The buffer from which Ex was started.") (defvar evil-ex-expression nil "The evaluation tree.") (defvar evil-ex-tree nil "The syntax tree.") (defvar evil-ex-command nil "The current Ex command.") (defvar evil-ex-previous-command nil "The previously executed Ex command.") (defvar evil-ex-cmd nil "The current Ex command string.") (defvar evil-ex-point nil "The position of `point' when the ex command has been called.") (defvar evil-ex-range nil "The current range of the Ex command.") (defvar evil-ex-bang nil "The \"!\" argument of the current Ex command.") (defvar evil-ex-argument nil "The current argument of the Ex command.") (defvar evil-ex-argument-handler nil "The argument handler for the current Ex command.") (defvar evil-ex-argument-types nil "Association list of argument handlers.") (defvar evil-previous-shell-command nil "The last shell command.") ;; Searching (defvar evil-ex-search-history nil "The history for the search command.") (defvar evil-ex-search-direction nil "The direction of the current search, either 'forward or 'backward.") (defvar evil-ex-search-count nil "The count if the current search.") (defvar evil-ex-search-start-point nil "The point where the search started.") (defvar evil-ex-search-overlay nil "The overlay for the current search result.") (defvar evil-ex-search-pattern nil "The last search pattern.") (defvar evil-ex-search-offset nil "The last search offset.") (defvar evil-ex-search-match-beg nil "The beginning position of the last match.") (defvar evil-ex-search-match-end nil "The end position of the last match.") (defvar evil-ex-substitute-pattern nil "The last substitute pattern.") (defvar evil-ex-substitute-replacement nil "The last substitute replacement.") (defvar evil-ex-substitute-flags nil "The last substitute flags.") (defvar evil-ex-substitute-current-replacement nil "The actual replacement.") (defvar evil-ex-last-was-search nil "Non-nil if the previous was a search. Otherwise the previous command is assumed as substitute.") ;;; Command line window (defvar evil-command-window-current-buffer nil "The buffer from which the command line window was called.") (evil-define-local-var evil-command-window-execute-fn nil "The command to execute when exiting the command line window.") (evil-define-local-var evil-command-window-cmd-key nil "The key for the command that opened the command line window (:, /, or ?).") ;; The lazy-highlighting framework. (evil-define-local-var evil-ex-active-highlights-alist nil "An alist of currently active highlights.") (evil-define-local-var evil-ex-hl-update-timer nil "Time used for updating highlights.") (defvar evil-ex-search-keymap (make-sparse-keymap) "Keymap used in ex-search-mode.") (define-key evil-ex-search-keymap [escape] 'abort-recursive-edit) (set-keymap-parent evil-ex-search-keymap minibuffer-local-map) (defconst evil-version (eval-when-compile (with-temp-buffer (let ((dir (file-name-directory (or load-file-name byte-compile-current-file)))) ;; git repository (if (and (file-exists-p (concat dir "/.git")) (ignore-errors (zerop (call-process "git" nil '(t nil) nil "rev-parse" "--short" "HEAD")))) (progn (goto-char (point-min)) (concat "evil-git-" (buffer-substring (point-min) (line-end-position)))) ;; no repo, use plain version "1.14.0")))) "The current version of Evil") (defcustom evil-want-integration t "Whether to load evil-integration.el. This variable must be set before Evil is loaded." :type 'boolean :group 'evil) (defcustom evil-want-keybinding t "Whether to load evil-keybindings.el. This loads a set of keybindings for evil in other modes as well as setting the initial evil state in those modes. This variable must be set before evil is loaded." :type 'boolean :group 'evil) (defcustom evil-want-minibuffer nil "Whether to enable Evil in minibuffer(s)." :type 'boolean :group 'evil :set #'(lambda (sym value) (set-default sym value) (if value (add-hook 'minibuffer-setup-hook 'evil-initialize) (remove-hook 'minibuffer-setup-hook 'evil-initialize)))) (defun evil-version () (interactive) (message "Evil version %s" evil-version)) (provide 'evil-vars) ;;; evil-vars.el ends here