#+title: The Helm Manual
# #+subtitle:  Release {{{version}}}
#+subtitle:  Release 3.6.2
#+author:    The Helm Developers
# #+date:      {{{modification-time}}}
#+language:  en

# #+texinfo: @insertcopying

* Table Of Contents                                                     :TOC_3:
- [[#package-helm][Package: helm]]
  - [[#library-helm][Library: helm]]
    - [[#modes-in-library-helm][Modes in library ~helm~]]
    - [[#commands-in-keymap-helm-map][Commands in keymap ~helm-map~]]
    - [[#commands-in-library-helm-excludes-keymaps][Commands in library ~helm~ (excludes keymaps)]]
    - [[#options-in-library-helm][Options in library =helm=]]
    - [[#hooks-in-library-helm][Hooks in library =helm=]]
  - [[#library-helm-adaptive][Library: helm-adaptive]]
    - [[#modes-in-library-helm-adaptive][Modes in library ~helm-adaptive~]]
    - [[#commands-in-library-helm-adaptive-excludes-keymaps][Commands in library ~helm-adaptive~ (excludes keymaps)]]
    - [[#options-in-library-helm-adaptive][Options in library =helm-adaptive=]]
    - [[#hooks-in-library-helm-adaptive][Hooks in library =helm-adaptive=]]
  - [[#library-helm-bookmark][Library: helm-bookmark]]
    - [[#commands-in-keymap-helm-bookmark-find-files-map][Commands in keymap ~helm-bookmark-find-files-map~]]
    - [[#commands-in-keymap-helm-bookmark-map][Commands in keymap ~helm-bookmark-map~]]
    - [[#commands-in-library-helm-bookmark-excludes-keymaps][Commands in library ~helm-bookmark~ (excludes keymaps)]]
    - [[#options-in-library-helm-bookmark][Options in library =helm-bookmark=]]
  - [[#library-helm-buffers][Library: helm-buffers]]
    - [[#commands-in-keymap-helm-buffer-map][Commands in keymap ~helm-buffer-map~]]
    - [[#commands-in-keymap-helm-buffer-not-found-map][Commands in keymap ~helm-buffer-not-found-map~]]
    - [[#commands-in-library-helm-buffers-excludes-keymaps][Commands in library ~helm-buffers~ (excludes keymaps)]]
    - [[#options-in-library-helm-buffers][Options in library =helm-buffers=]]
  - [[#library-helm-color][Library: helm-color]]
    - [[#commands-in-keymap-helm-color-map][Commands in keymap ~helm-color-map~]]
    - [[#commands-in-library-helm-color-excludes-keymaps][Commands in library ~helm-color~ (excludes keymaps)]]
  - [[#library-helm-comint][Library: helm-comint]]
    - [[#commands-in-keymap-helm-comint-prompts-keymap][Commands in keymap ~helm-comint-prompts-keymap~]]
    - [[#commands-in-library-helm-comint-excludes-keymaps][Commands in library ~helm-comint~ (excludes keymaps)]]
    - [[#options-in-library-helm-comint][Options in library =helm-comint=]]
  - [[#library-helm-command][Library: helm-command]]
    - [[#commands-in-keymap-helm-m-x-map][Commands in keymap ~helm-M-x-map~]]
    - [[#commands-in-library-helm-command-excludes-keymaps][Commands in library ~helm-command~ (excludes keymaps)]]
    - [[#options-in-library-helm-command][Options in library =helm-command=]]
    - [[#hooks-in-library-helm-command][Hooks in library =helm-command=]]
  - [[#library-helm-config][Library: helm-config]]
  - [[#library-helm-dabbrev][Library: helm-dabbrev]]
    - [[#commands-in-library-helm-dabbrev-excludes-keymaps][Commands in library ~helm-dabbrev~ (excludes keymaps)]]
    - [[#options-in-library-helm-dabbrev][Options in library =helm-dabbrev=]]
  - [[#library-helm-easymenu][Library: helm-easymenu]]
  - [[#library-helm-elisp][Library: helm-elisp]]
    - [[#commands-in-library-helm-elisp-excludes-keymaps][Commands in library ~helm-elisp~ (excludes keymaps)]]
    - [[#options-in-library-helm-elisp][Options in library =helm-elisp=]]
  - [[#library-helm-elisp-package][Library: helm-elisp-package]]
    - [[#commands-in-keymap-helm-el-package-map][Commands in keymap ~helm-el-package-map~]]
    - [[#commands-in-library-helm-elisp-package-excludes-keymaps][Commands in library ~helm-elisp-package~ (excludes keymaps)]]
    - [[#options-in-library-helm-elisp-package][Options in library =helm-elisp-package=]]
  - [[#library-helm-epa][Library: helm-epa]]
    - [[#modes-in-library-helm-epa][Modes in library ~helm-epa~]]
    - [[#commands-in-library-helm-epa-excludes-keymaps][Commands in library ~helm-epa~ (excludes keymaps)]]
    - [[#options-in-library-helm-epa][Options in library =helm-epa=]]
    - [[#hooks-in-library-helm-epa][Hooks in library =helm-epa=]]
  - [[#library-helm-eshell][Library: helm-eshell]]
    - [[#commands-in-keymap-helm-eshell-prompts-keymap][Commands in keymap ~helm-eshell-prompts-keymap~]]
    - [[#commands-in-library-helm-eshell-excludes-keymaps][Commands in library ~helm-eshell~ (excludes keymaps)]]
    - [[#options-in-library-helm-eshell][Options in library =helm-eshell=]]
    - [[#hooks-in-library-helm-eshell][Hooks in library =helm-eshell=]]
  - [[#library-helm-eval][Library: helm-eval]]
    - [[#commands-in-keymap-helm-eval-expression-map][Commands in keymap ~helm-eval-expression-map~]]
    - [[#commands-in-library-helm-eval-excludes-keymaps][Commands in library ~helm-eval~ (excludes keymaps)]]
    - [[#options-in-library-helm-eval][Options in library =helm-eval=]]
  - [[#library-helm-external][Library: helm-external]]
    - [[#commands-in-library-helm-external-excludes-keymaps][Commands in library ~helm-external~ (excludes keymaps)]]
    - [[#options-in-library-helm-external][Options in library =helm-external=]]
  - [[#library-helm-fd][Library: helm-fd]]
    - [[#commands-in-keymap-helm-fd-map][Commands in keymap ~helm-fd-map~]]
    - [[#options-in-library-helm-fd][Options in library =helm-fd=]]
  - [[#library-helm-files][Library: helm-files]]
    - [[#modes-in-library-helm-files][Modes in library ~helm-files~]]
    - [[#commands-in-keymap-helm-browse-project-map][Commands in keymap ~helm-browse-project-map~]]
    - [[#commands-in-keymap-helm-file-name-history-map][Commands in keymap ~helm-file-name-history-map~]]
    - [[#commands-in-keymap-helm-find-files-map][Commands in keymap ~helm-find-files-map~]]
    - [[#commands-in-keymap-helm-read-file-map][Commands in keymap ~helm-read-file-map~]]
    - [[#commands-in-library-helm-files-excludes-keymaps][Commands in library ~helm-files~ (excludes keymaps)]]
    - [[#options-in-library-helm-files][Options in library =helm-files=]]
    - [[#hooks-in-library-helm-files][Hooks in library =helm-files=]]
  - [[#library-helm-find][Library: helm-find]]
    - [[#commands-in-keymap-helm-find-map][Commands in keymap ~helm-find-map~]]
    - [[#commands-in-library-helm-find-excludes-keymaps][Commands in library ~helm-find~ (excludes keymaps)]]
    - [[#options-in-library-helm-find][Options in library =helm-find=]]
  - [[#library-helm-font][Library: helm-font]]
    - [[#commands-in-keymap-helm-ucs-map][Commands in keymap ~helm-ucs-map~]]
    - [[#commands-in-library-helm-font-excludes-keymaps][Commands in library ~helm-font~ (excludes keymaps)]]
    - [[#options-in-library-helm-font][Options in library =helm-font=]]
  - [[#library-helm-for-files][Library: helm-for-files]]
    - [[#commands-in-library-helm-for-files-excludes-keymaps][Commands in library ~helm-for-files~ (excludes keymaps)]]
    - [[#options-in-library-helm-for-files][Options in library =helm-for-files=]]
  - [[#library-helm-global-bindings][Library: helm-global-bindings]]
    - [[#commands-in-keymap-helm-command-map][Commands in keymap ~helm-command-map~]]
    - [[#options-in-library-helm-global-bindings][Options in library =helm-global-bindings=]]
  - [[#library-helm-grep][Library: helm-grep]]
    - [[#modes-in-library-helm-grep][Modes in library ~helm-grep~]]
    - [[#commands-in-keymap-helm-grep-map][Commands in keymap ~helm-grep-map~]]
    - [[#commands-in-keymap-helm-grep-mode-map][Commands in keymap ~helm-grep-mode-map~]]
    - [[#commands-in-keymap-helm-pdfgrep-map][Commands in keymap ~helm-pdfgrep-map~]]
    - [[#commands-in-library-helm-grep-excludes-keymaps][Commands in library ~helm-grep~ (excludes keymaps)]]
    - [[#options-in-library-helm-grep][Options in library =helm-grep=]]
    - [[#hooks-in-library-helm-grep][Hooks in library =helm-grep=]]
  - [[#library-helm-help][Library: helm-help]]
    - [[#commands-in-library-helm-help-excludes-keymaps][Commands in library ~helm-help~ (excludes keymaps)]]
  - [[#library-helm-id-utils][Library: helm-id-utils]]
    - [[#commands-in-library-helm-id-utils-excludes-keymaps][Commands in library ~helm-id-utils~ (excludes keymaps)]]
    - [[#options-in-library-helm-id-utils][Options in library =helm-id-utils=]]
  - [[#library-helm-imenu][Library: helm-imenu]]
    - [[#commands-in-keymap-helm-imenu-map][Commands in keymap ~helm-imenu-map~]]
    - [[#commands-in-library-helm-imenu-excludes-keymaps][Commands in library ~helm-imenu~ (excludes keymaps)]]
    - [[#options-in-library-helm-imenu][Options in library =helm-imenu=]]
  - [[#library-helm-info][Library: helm-info]]
    - [[#modes-in-library-helm-info][Modes in library ~helm-info~]]
    - [[#commands-in-library-helm-info-excludes-keymaps][Commands in library ~helm-info~ (excludes keymaps)]]
    - [[#options-in-library-helm-info][Options in library =helm-info=]]
  - [[#library-helm-lib][Library: helm-lib]]
    - [[#commands-in-library-helm-lib-excludes-keymaps][Commands in library ~helm-lib~ (excludes keymaps)]]
    - [[#options-in-library-helm-lib][Options in library =helm-lib=]]
    - [[#hooks-in-library-helm-lib][Hooks in library =helm-lib=]]
  - [[#library-helm-locate][Library: helm-locate]]
    - [[#commands-in-keymap-helm-locate-map][Commands in keymap ~helm-locate-map~]]
    - [[#commands-in-library-helm-locate-excludes-keymaps][Commands in library ~helm-locate~ (excludes keymaps)]]
    - [[#options-in-library-helm-locate][Options in library =helm-locate=]]
  - [[#library-helm-man][Library: helm-man]]
    - [[#commands-in-library-helm-man-excludes-keymaps][Commands in library ~helm-man~ (excludes keymaps)]]
    - [[#options-in-library-helm-man][Options in library =helm-man=]]
  - [[#library-helm-misc][Library: helm-misc]]
    - [[#commands-in-library-helm-misc-excludes-keymaps][Commands in library ~helm-misc~ (excludes keymaps)]]
    - [[#options-in-library-helm-misc][Options in library =helm-misc=]]
  - [[#library-helm-mode][Library: helm-mode]]
    - [[#modes-in-library-helm-mode][Modes in library ~helm-mode~]]
    - [[#commands-in-keymap-helm-comp-read-map][Commands in keymap ~helm-comp-read-map~]]
    - [[#commands-in-library-helm-mode-excludes-keymaps][Commands in library ~helm-mode~ (excludes keymaps)]]
    - [[#options-in-library-helm-mode][Options in library =helm-mode=]]
    - [[#hooks-in-library-helm-mode][Hooks in library =helm-mode=]]
  - [[#library-helm-multi-match][Library: helm-multi-match]]
    - [[#modes-in-library-helm-multi-match][Modes in library ~helm-multi-match~]]
    - [[#commands-in-library-helm-multi-match-excludes-keymaps][Commands in library ~helm-multi-match~ (excludes keymaps)]]
    - [[#options-in-library-helm-multi-match][Options in library =helm-multi-match=]]
    - [[#hooks-in-library-helm-multi-match][Hooks in library =helm-multi-match=]]
  - [[#library-helm-net][Library: helm-net]]
    - [[#commands-in-library-helm-net-excludes-keymaps][Commands in library ~helm-net~ (excludes keymaps)]]
    - [[#options-in-library-helm-net][Options in library =helm-net=]]
  - [[#library-helm-occur][Library: helm-occur]]
    - [[#modes-in-library-helm-occur][Modes in library ~helm-occur~]]
    - [[#commands-in-keymap-helm-occur-map][Commands in keymap ~helm-occur-map~]]
    - [[#commands-in-keymap-helm-occur-mode-map][Commands in keymap ~helm-occur-mode-map~]]
    - [[#commands-in-library-helm-occur-excludes-keymaps][Commands in library ~helm-occur~ (excludes keymaps)]]
    - [[#options-in-library-helm-occur][Options in library =helm-occur=]]
    - [[#hooks-in-library-helm-occur][Hooks in library =helm-occur=]]
  - [[#library-helm-regexp][Library: helm-regexp]]
    - [[#commands-in-library-helm-regexp-excludes-keymaps][Commands in library ~helm-regexp~ (excludes keymaps)]]
  - [[#library-helm-ring][Library: helm-ring]]
    - [[#commands-in-keymap-helm-kill-ring-map][Commands in keymap ~helm-kill-ring-map~]]
    - [[#commands-in-library-helm-ring-excludes-keymaps][Commands in library ~helm-ring~ (excludes keymaps)]]
    - [[#options-in-library-helm-ring][Options in library =helm-ring=]]
  - [[#library-helm-semantic][Library: helm-semantic]]
    - [[#commands-in-library-helm-semantic-excludes-keymaps][Commands in library ~helm-semantic~ (excludes keymaps)]]
    - [[#options-in-library-helm-semantic][Options in library =helm-semantic=]]
  - [[#library-helm-shell][Library: helm-shell]]
    - [[#commands-in-library-helm-shell-excludes-keymaps][Commands in library ~helm-shell~ (excludes keymaps)]]
  - [[#library-helm-source][Library: helm-source]]
  - [[#library-helm-sys][Library: helm-sys]]
    - [[#modes-in-library-helm-sys][Modes in library ~helm-sys~]]
    - [[#commands-in-keymap-helm-top-map][Commands in keymap ~helm-top-map~]]
    - [[#commands-in-library-helm-sys-excludes-keymaps][Commands in library ~helm-sys~ (excludes keymaps)]]
    - [[#options-in-library-helm-sys][Options in library =helm-sys=]]
    - [[#hooks-in-library-helm-sys][Hooks in library =helm-sys=]]
  - [[#library-helm-tags][Library: helm-tags]]
    - [[#commands-in-keymap-helm-etags-map][Commands in keymap ~helm-etags-map~]]
    - [[#commands-in-library-helm-tags-excludes-keymaps][Commands in library ~helm-tags~ (excludes keymaps)]]
    - [[#options-in-library-helm-tags][Options in library =helm-tags=]]
  - [[#library-helm-types][Library: helm-types]]
    - [[#commands-in-keymap-helm-generic-files-map][Commands in keymap ~helm-generic-files-map~]]
    - [[#options-in-library-helm-types][Options in library =helm-types=]]
  - [[#library-helm-utils][Library: helm-utils]]
    - [[#modes-in-library-helm-utils][Modes in library ~helm-utils~]]
    - [[#commands-in-library-helm-utils-excludes-keymaps][Commands in library ~helm-utils~ (excludes keymaps)]]
    - [[#options-in-library-helm-utils][Options in library =helm-utils=]]
    - [[#hooks-in-library-helm-utils][Hooks in library =helm-utils=]]
  - [[#library-helm-x-files][Library: helm-x-files]]
    - [[#options-in-library-helm-x-files][Options in library =helm-x-files=]]
- [[#main-index][Main Index]]
- [[#key-index][Key Index]]
- [[#command-and-function-index][Command and Function Index]]
- [[#variable-index][Variable Index]]
- [[#footnotes][Footnotes]]

* Introduction

 People often think helm is just something like ido([[info:Ido]]) but
 displaying completion in a vertical layout instead of an horizontal
 one, it is not, helm is much more powerful than that.

 - Helm is able to complete multiple lists dispatched in different
   sources against a pattern.

 - Helm allows executing an unlimited number of actions on candidates.

 - Helm allows marking candidates to execute chosen action against this
   set of candidates.

 - Helm can display its completion buffer in different window layouts
   and in separate frame.

 # Helm is divided in two distinct categories of commands,

 # #+cindex: helm native commands
 # #+cindex: helmized commands

 # - *helm natives commands* :: these commands are a fresh implementation
 #   of an existing Emacs command and enhance them in useful ways.

 # - *helmized commands* :: these Emacs native commands modified by
 #   helm-mode to provide helm completion and only that.

 # When both are provided e.g ~switch-to-buffer~ vs ~helm-buffers-list~
 # you will prefer the native helm commands generally more featured (more
 # than one action, allows marking candidates, better display etc...).

* Quick Start Guide

** Requirements

 Helm 3.6.2 and later require

   - =Emacs= version >= 25.1
   - =emacs-async=[fn:xxx1]
   - =popup-el=[fn:xxx2]

 # Helm require an =Emacs= version >= 25.1 starting from version 3.6.2.
 # Helm uses few dependencies, actually only  (mandatory) and
 # popup (facultative) but if you install from
 # Melpa[fn:xxx3] you should not care of this.

** Download

 - Home Page ::   https://github.com/emacs-helm/helm

 - Git Url ::

   https://github.com/emacs-helm/helm.git

   git@github.com:emacs-helm/helm.git

 - Tagged Releases :: https://github.com/emacs-helm/helm/tags

** Installation

*** Minimal setup using =straight.el=

 =straight.el=[fn:xxx3]

 Add this to your init file,

 #+begin_src emacs-lisp
  (straight-use-package 'helm)
 #+end_src

 or

 # # #+begin_src emacs-lisp
 # #   (use-package helm
 # #		:straight t
 # #		:config
 # #		[...])
 # # #+end_src

 #+begin_src emacs-lisp
   (use-package helm :straight t)
 #+end_src

 For further information, see =straight.el='s user manual.

 To upgrade =helm=, do {{{kbd(M-x straight-pull-package)}}} and restart
 Emacs.  =straight.el= will rebuild helm for you.

*** Minimal setup using source

 1. Install the pre-requisites

    Install =emacs-async=[fn:xxx1] and =popup-el=[fn:xxx2].  Ensure that they
    are available in ~load-path~.

 2. Download, compile and install the sources

   If you are using =git=,

      #+begin_src sh
	git clone https://github.com/emacs-helm/helm
	cd helm
	make
	sudo make install
      #+end_src

   If you have a tarball[fn:xxx4], say for version =v3.7.1.tar.gz=,
    then you can do

     #+begin_src sh
       wget https://github.com/emacs-helm/helm/archive/refs/tags/v3.7.1.tar.gz
       tar zxvf v3.7.1.tar.gz
       cd helm-3.7.1/
       make
       sudo make install
     #+end_src

  Above steps[fn:xxxx45]

  - installs =helm= in =/usr/local/share/emacs/site-lisp/helm/=

  - creates an executable called =/usr/local/bin/helm=.  This file is in
    fact a symbolic link to to the script =emacs-helm.sh=.

    #+cindex: emacs-helm.sh

 3. Load =helm-config= during Emacs startup

    Now, add one of the following to your init file, and restart Emacs.
    These lines load =helm-autoloads.el=, and ensure that =helm= commands
    are available for use after the restart.

    #+begin_src emacs-lisp
      (add-to-list 'load-path "/path/to/helm/directory")
      (require 'helm-config)
    #+end_src

    or

    #+begin_src emacs-lisp
      (add-to-list 'load-path "/path/to/helm/directory")
      (use-package helm :config (require 'helm-config))
    #+end_src

*** Minimal setup using the Package Manager

 Helm is available on MELPA.[fn:xxx6]

 Release version of Helm is available in the stable repository while
 development version is available in it's sister repo.

 Assuming that you have setup ~package-archives~ to include the MELPA,
 you can install =Helm= with {{{kbd(M-x package-install RET helm
 RET)}}}.

 To upgrade =Helm=, use ~helm-list-elisp-packages~.  This command is
 the Helm equivalent of Emacs' =list-packages=.  Using
 ~helm-list-elisp-packages~, ensures that =helm= is compiled in a clean
 environment.[fn:xxx7]

 # Helm upgrades from MELPA encountered errors because of the way the
 # Emacs package manager fetches and compiles updates for existing
 # packages.

 # To get around these errors, Helm has =emacs-async=[fn:xxx1] as a
 # dependency. =emacs-async= forces compilation in a clean environment,
 # which resolves the compilation errors.

 # When some changes are made in Helm-core and those changes are used in
 # Helm, package.el may install Helm before Helm-core which may create
 # errors depending on changes on Helm-core e.g. New macro, renaming
 # function or macro etc...  In this case you will have a better time
 # uninstalling all (Helm+Helm-core), restarting Emacs and reinstalling
 # Helm.  Installing from source doesn't suffer from this problem.

 # *Note*: always restart Emacs after reinstalling Helm (or other
 # packages) for updates to take effect.

 # ** Upgrading

 # The only thing you have to do is to upgrade from package manager.

 # Helm comes with convenient interface to package.el, see
 # ~helm-list-elisp-packages-no-fetch~ and ~helm-list-elisp-packages~.

 # Use ~helm-list-elisp-packages~ to upgrade Helm.  If you use
 # ~list-packages~ to upgrade, you may run in to issues either at install
 # time or run time.[fn:xxx8]

 # * Upgrade or recompile

 # ** Melpa

 # *** Upgrade

 # *** COMMENT Recompile

 # To recompile Helm (or whatever packages), always recompile from a
 # clean environment, that is from outside you current Emacs, for this
 # use ~helm-list-elisp-packages-no-fetch~, go to installed packages with
 # ~M-I~ and use the recompile package action, from Lisp you can use
 # directly ~async-byte-recompile-directory~, if you installed from
 # source use make. And then RESTART Emacs.

 # ** Straight

** Configuration

Helm comes with a shell script called =emacs-helm.sh=.  This script is
a thin wrapper around =emacs -Q= with barest of Helm configuration.
Use this script to reproduce and report Helm bugs.

It is desirable that you put this script in your PATH for easy access.

If you have installed =Helm= from Git or release tarball, no
additional step is required.  =emacs-helm.sh= is made available under
=/usr/local/share/emacs/site-lisp/helm/=, and can be conveniently
launched with the command =helm=.

If you have used a package manager for installing =helm=, it is
available in =~/.emacs.d/elpa/helm-<VERSION>/emacs-helm.sh=.  Run the
below shell command, to launch a minimal Helm.

 #+begin_src sh
   ln -s ~/src/helm/emacs-helm.sh  ~/bin/helm
 #+end_src

 # =emacs-helm.sh= should also be used when
 # [[https://github.com/emacs-helm/helm/wiki/Bugs][reporting bugs]].

**** COMMENT Set up =emacs-helm.sh=
:PROPERTIES:
:UNNUMBERED: notoc
:END:

 # *Note*: For people using a non standard Elpa directory emacs-helm.sh may
 # fail because it doesn't find its dependency (emacs-async), here's how
 # you can do:

 # #+begin_src sh
 #   cd /your/path/to/helm
 #   make # If not already done.
 #   EMACSLOADPATH="../emacs-async:" ./emacs-helm.sh
 # #+end_src

 # But normally =emacs-helm.sh= should work out of the box with
 # installations of emacs-async= done with package.el, straight.el or from
 # source with the Makefile.

** Quick Try with =emacs-helm.sh=

   #+begin_src emacs-lisp
     ;; This Emacs is Powered by ‘HELM’ using
     ;; emacs program "emacs".
     ;; This is a minimal ‘helm’ configuration to discover ‘helm’ or debug it.
     ;; You can retrieve this minimal configuration in "/tmp/helm-cfg.el".

     ;; Some original Emacs commands are replaced by their ‘helm’ counterparts:

     ;; - ‘find-file’(C-x C-f)            =>‘helm-find-files’
     ;; - ‘occur’(M-s o)                  =>‘helm-occur’
     ;; - ‘list-buffers’(C-x C-b)         =>‘helm-buffers-list’
     ;; - ‘completion-at-point’(M-tab)    =>‘helm-lisp-completion-at-point’[1]
     ;; - ‘apropos-command’(C-h a)        =>‘helm-apropos’
     ;; - ‘dabbrev-expand’(M-/)           =>‘helm-dabbrev’
     ;; - ‘execute-extended-command’(M-x) =>‘helm-M-x’

     ;; Some other Emacs commands are "helmized" by ‘helm-mode’.
     ;; [1] Coming with emacs-24.4, ‘completion-at-point’ is "helmized" by ‘helm-mode’

     ;; which provides Helm completion in many places like ‘shell-mode’.
     ;; Find context help for most Helm commands with ‘C-h m’.

     (require 'helm-config)
     (helm-mode 1)
     (define-key global-map [remap find-file] 'helm-find-files)
     (define-key global-map [remap occur] 'helm-occur)
     (define-key global-map [remap list-buffers] 'helm-buffers-list)
     (define-key global-map [remap dabbrev-expand] 'helm-dabbrev)
     (define-key global-map [remap execute-extended-command] 'helm-M-x)
     (define-key global-map [remap apropos-command] 'helm-apropos)
     (unless (boundp 'completion-in-region-function)
       (define-key lisp-interaction-mode-map [remap completion-at-point] 'helm-lisp-completion-at-point)
       (define-key emacs-lisp-mode-map       [remap completion-at-point] 'helm-lisp-completion-at-point))
   #+end_src

 #+cindex: emacs-helm.sh

 #+begin_src sh
   ~/.emacs.d/elpa/helm-<VERSION>/emacs-helm.sh
 #+end_src

 #+CAPTION: A typical ~helm-M-x~ with =emacs-helm.sh=
 #+ATTR_HTML: :width 800
 #+ATTR_ORG: :width 800
 [[./helm-figures/helm-M-x.png]]

Invoke {{{kbd(M-x helm-M-x RET)}}} and type =helm= to discover Helm
commands.  The =Menu Bar -> Helm= menu item is another way to discover
helm commands.

** How to report Helm Bugs

You can report Helm bug at https://github.com/emacs-helm/helm/issues.

Before you report an issue, ensure that you can reproduce it issue
with [[*Configuration][=emacs-helm.sh=]] script.  Also, remember to
report the version of Helm and your Emacs.

If you cannot run the =emacs-helm.sh= script, be sure to reproduce the
 problem with =emacs -Q=, then installing Helm as described in the
 Install section.

 # You can use the -h argument for help:

 #     : $ helm -h
 #     : Usage: helm [-P} Emacs path [-h} help [--] EMACS ARGS

 # If your emacs binary is not in a standard place i.e. "emacs", you can
 # specify the path with "-P".

** Getting Help

 - [[https://github.com/emacs-helm/helm][Helm on GitHub]]

 - [[http://tuhdo.github.io/helm-intro.html][Tuhdo's Helm tutorial]]

 - [[https://groups.google.com/g/emacs-helm][Helm mailing list]]

 # gmane.emacs.helm.user
 # news://news.gwene.org:119/gmane.emacs.helm.user

 # - [[http://dir.gmane.org/gmane.emacs.helm.user][Helm Gmane]] (=gmane.emacs.helm.user=)

** COMMENT Contributing to the Wiki

 1. Prefer using [[http://orgmode.org/][Org mode]] for Wiki pages.

 2. Install the [[https://github.com/snosov1/toc-org][toc-org]] package
    to automatically generate tables of contents.

 3. Edit the Wiki.

 4. Before saving, run ~toc-org-insert-toc~.

    - Consider adding something like the following to
      ~before-save-hook~ to do this automatically:

 #+begin_src emacs-lisp
   (defun *-org-insert-toc ()
     "Create table of contents (TOC) if current buffer is in
   `org-mode'."
     (when (= major-mode 'org-mode)
       toc-org-insert-toc))
 #+end_src

** A word of advice for experienced Emacs Users

*** Helm Completion v.s. Emacs Completion
    :PROPERTIES:
    :UNNUMBERED: notoc
    :END:

  Differences between the two often trip up new users.

  Emacs completion is based on the *minibuffer*. Helm completion is
  based on the *completion window*.[fn:xxx9]  [fn:xxx10] [fn:xxx11]

  In standard Emacs, interactivity happens in the /minibuffer/.

  - Typing new characters filters candidates in the minibuffer.
    {{{kbd(<tab>)}}} may try to complete the typed characters with a
    valid candidate.

  - Hitting {{{kbd(RET)}}} selects the current candidate from the minibuffer.

  In Helm, interactivity happens in the /completion window/, not the
  minibuffer

  - Typing new characters filters candidates in the completion window.
    Keep typing until the desired candidate is highlighted, or navigate
    to it using {{{kbd(C-n)}}}.

  - Hitting {{{kbd(RET)}}} selects the currently highlighted item in the
    completion window.

*** Helm interaction model
    :PROPERTIES:
    :UNNUMBERED: notoc
    :END:

  Helm's interactivity makes the {{{kbd(<tab>)}}} key redundant for
  completion because the selection candidates are already made visible
  in the Helm completion window. So, *tab completion is not
  supported*. In Helm, {{{kbd(<tab>)}}} is used to view available
  *actions* to be taken on a candidate.

  Because the {{{kbd(<tab>)}}} key is so ingrained in the muscle memory of
  long-time Emacs users, transition to Helm's interactive model
  requires:

  - A conscious visual adjustment to look at the completion window, and

  - A conscious mental adjustment to avoid using the {{{kbd(<tab>)}}}
    key for completion and go straight to {{{kbd(RET)}}} key to select a
    candidate. Helm's approach to completion provides better visual
    cues, takes fewer keystrokes, and is much faster.

** COMMENT Not Now

*** Configure

 # For further configuration like changing bindings in the ~helm-map~ you
 # will likely want to use a delayed method like ~with-eval-after-load~
 # or =use-package= to avoid loading all of Helm at startup.

 As example you can have a look at the maintainer helm config[fn:xxx8].

 To setup specific variables from the helm session you are in, use
 {{{kbd(C-h c)}}}.

 To enable helm completion everywhere in Emacs add this to your init
 file.

 #+begin_src emacs-lisp
   (helm-mode 1)
 #+end_src

*** General Helm Commands

 Helm's functionality needs only a few general key bindings as shown
 below. These are also documented in the mode line.

 # Marking

  # helm-mark-all
  # helm-next-visible-mark
  # helm-prev-visible-mark
  # helm-toggle-all-marks
  # helm-toggle-visible-mark
  # helm-toggle-visible-mark-backward
  #
  # helm-unmark-all

 # Action

  # helm-execute-persistent-action
  # helm-follow-action-backward
  # helm-follow-action-forward
  # helm-select-action

 # - {{{kbd(C-c C-e)}}} (~org-export~) ::

 - {{{kbd(<tab>)}}} or {{{kbd(C-i)}}} (~helm-select-action~) :: lists available actions

 - {{{kbd(C-j)}}} or {{{kbd(C-z)}}} (~helm-execute-persistent-action~) :: invokes the persistent action

 - {{{kbd(M-SPC)}}} (~helm-toggle-visible-mark-backward~)  or {{{kbd(C-SPC)}}} (~helm-toggle-visible-mark-forward~) or {{{kbd(C-@)}}} (~helm-toggle-visible-mark~) :: marks a candidate

 - {{{kbd(C-h m)}}} (~helm-help~) :: displays the embeded help in an org buffer without quitting
   helm session.

 - {{{kbd(RET)}}}   :: runs the first action of action list

*** Yanking text

 Yank symbol at point from ~helm-current-buffer~ (i.e. buffer where a
 helm command was invoked):

 # {{{kbd(M-n)}}} copies symbol at point to minibuffer

 # {{{kbd(C-w)}}} appends word next to point to the minibuffer and advance to next
 # word, hitting {{{kbd(C-_)}}} undo last insertion and rewind yank point in
 # ~helm-current-buffer~

 - {{{kbd(C-w)}}} (~helm-yank-text-at-point~) :: Append word next to
   point to the minibuffer and advance to next word

    (helm-yank-text-at-point ARG)

    Yank text at point in `helm-current-buffer' into minibuffer.

 - {{{kbd(C-_)}}} (~helm-undo-yank-text-at-point~) :: Undo last
   insertion and rewind yank point in ~helm-current-buffer~

    Undo last entry added by `helm-yank-text-at-point'.

*** Preconfigured Helm Commands

 Invoke {{{kbd(M-x helm-M-x RET)}}} and type =helm= to discover Helm
 commands.  The =Menu Bar -> Helm= menu item is another way to discover
 helm commands.

 - ~helm-command-prefix-key~ ::

   #+vindex: helm-command-prefix-key

   *Standard Value*: "C-x c"

   The key ‘helm-command-prefix’ is bound to in the global map.

 - ~helm-minibuffer-history-key~ ::

   #+vindex: helm-minibuffer-history-key

   *Standard Value*: "C-r"

   The key ‘helm-minibuffer-history’ is bound to in minibuffer local maps.

 # #+vindex: helm-command-prefix-key
 ~helm-command-prefix-key~ (default value {{{kbd(C-x c)}}}) is the
 prefix for the preconfigured helm menu.

 ~helm-command-prefix-key~ followed by any regular Emacs key invokes
 the Helm version of the same command.

 For example,

 - {{{kbd(C-x c M-x)}}} runs the command ~helm-M-x~, which is the helm
   version of {{{kbd(M-x)}}} (~execute-extended-command~).

 - {{{kbd(C-x c C-x C-f)}}} runs the command ~helm-find-files~, which
   is the helm version of {{{kbd(C-x C-f)}}} (~find-file~).

 To run the helm version of a command with a key binding, but without
 also typing {{{kbd(C-x c)}}}) (~helm-command-prefix-key~), add the
 following to your init file.

 #+begin_src emacs-lisp
   (global-set-key (kbd "M-x") 'helm-M-x)
 #+end_src

*** Show Helm Commands

 - {{{kbd(C-h m)}}} (~helm-help~) shows Helm commands and currently
   active key bindings.

 # * Browse Other Tools

 # - Invoke {{{kbd(M-x)}}}, then type "helm" to browse other Helm tools.

*** Helm Mode

 # Toggle generic helm completion.

 # If called interactively, toggle ‘Helm mode’.  If the prefix
 # argument is positive, enable the mode, and if it is zero or
 # negative, disable the mode.

 # If called from Lisp, toggle the mode if ARG is ‘toggle’.  Enable
 # the mode if ARG is nil, omitted, or is a positive number.
 # Disable the mode if ARG is a negative number.

 # The mode’s hook is called both when the mode is enabled and when
 # it is disabled.

 # All functions in Emacs that use ‘completing-read’,
 # ‘read-file-name’, ‘completion-in-region’ and friends will use helm
 # interface when this mode is turned on.

 # However you can modify this behavior for functions of your choice
 # with ‘helm-completing-read-handlers-alist’.

 # Called with a positive arg, turn on unconditionally, with a
 # negative arg turn off.
 # You can toggle it with M-x ‘helm-mode’.

 # About ‘ido-mode’:
 # DO NOT enable ‘ido-everywhere’ when using ‘helm-mode’.  Instead of
 # using ‘ido-mode’, add the commands where you want to use ido to
 # ‘helm-completing-read-handlers-alist’ with ‘ido’ as value.

 ~helm-mode~ enables Helm completion globally for any Emacs command
 using ~completing-read~ or ~read-file-name~.

 ~helm-mode~ completes with ~completion-at-point~ and implements
 ~completion-in-region-function~ for ~completing-read-multiple~ for
 Emacs 24.4 and later.

 Helm provides generic functions for completions to replace
 tab-completion in Emacs with no loss of functionality. To use Helm's
 generic functions, first set them in your init file, e.g.:

 #+begin_src emacs-lisp
   (global-set-key (kbd "M-x") #'helm-M-x)
   (global-set-key (kbd "C-x r b") #'helm-filtered-bookmarks)
   (global-set-key (kbd "C-x C-f") #'helm-find-files)
 #+end_src

 Then enable ~helm-mode~ with:

 #+begin_src emacs-lisp
   (helm-mode 1)
 #+end_src

 Or, enable ~helm-mode~ interactively with {{{kbd(M-x helm-mode)}}}.

 - ~helm-mode~ ::

   #+vindex: helm-mode

   (helm-mode &optional ARG)

   Toggle generic helm completion.

   If called interactively, toggle `Helm mode'.  If the prefix
   argument is positive, enable the mode, and if it is zero or
   negative, disable the mode.

   If called from Lisp, toggle the mode if ARG is `toggle'.  Enable
   the mode if ARG is nil, omitted, or is a positive number.
   Disable the mode if ARG is a negative number.

   The mode's hook is called both when the mode is enabled and when
   it is disabled.

   All functions in Emacs that use `completing-read',
   `read-file-name', `completion-in-region' and friends will use helm
   interface when this mode is turned on.

   However you can modify this behavior for functions of your choice
   with `helm-completing-read-handlers-alist'.

   Called with a positive arg, turn on unconditionally, with a
   negative arg turn off.
   You can toggle it with M-x `helm-mode'.

   About `ido-mode':
   DO NOT enable `ido-everywhere' when using `helm-mode'.  Instead of
   using `ido-mode', add the commands where you want to use ido to
   `helm-completing-read-handlers-alist' with `ido' as value.

   Note: This mode is incompatible with Emacs23.

*** Customize helm-mode

 - ~helm-completing-read-handlers-alist~ ::

   #+vindex: helm-completing-read-handlers-alist

   Completing read functions for specific Emacs commands.

   By default ‘helm-mode’ use ‘helm-completing-read-default-handler’ to
   provide helm completion in each ‘completing-read’ or ‘read-file-name’
   found, but other functions can be specified here for specific
   commands. This also allows disabling helm completion for some commands
   when needed.

   Each entry is a cons cell like (EMACS_COMMAND . COMPLETING-READ_HANDLER)
   where key and value are symbols.

   Each key is an Emacs command that use originaly ‘completing-read’.

   Each value maybe a helm function that takes same arguments as
   ‘completing-read’ plus NAME and BUFFER, where NAME is the name of the new
   helm source and BUFFER the name of the buffer we will use, but it can
   be also a function not using helm, in this case the function should
   take the same args as ‘completing-read’ and not be prefixed by "helm-".

   ‘helm’ will use the name of the command calling ‘completing-read’ as
   NAME and BUFFER will be computed as well with NAME but prefixed with
   "*helm-mode-".

   This function prefix name must start by "helm-" when it uses helm,
   otherwise ‘helm’ assumes the function is not a helm function and
   expects the same args as ‘completing-read’, this allows you to define a
   handler not using helm completion.

   Example:

       (defun foo/test ()
	 (interactive)
	 (message "%S" (completing-read "test: " ’(a b c d e))))

       (defun helm-foo/test-completing-read-handler (prompt collection
						     predicate require-match
						     initial-input hist def
						     inherit-input-method
						     name buffer)
	 (helm-comp-read prompt collection :marked-candidates t
					   :name name
					   :buffer buffer))

       (add-to-list ’helm-completing-read-handlers-alist
		    ’(foo/test . helm-foo/test-completing-read-handler))

   We want here to make the regular ‘completing-read’ in ‘foo/test’
   return a list of candidate(s) instead of a single candidate.

   Note that this function will be reused for ALL the ‘completing-read’
   of this command, so it should handle all cases. E.g.,
   if first ‘completing-read’ completes against symbols and
   second ‘completing-read’ should handle only buffer,
   your specialized function should handle both.

   If the value of an entry is nil completion will fall back to
   Emacs vanilla behaviour.
   Example:

   If you want to disable helm completion for ‘describe-function’, use:

       (describe-function . nil)

   Ido is also supported, you can use ‘ido-completing-read’ and
   ‘ido-read-file-name’ as value of an entry or just ’ido.
   Example:
   Enable ido completion for ‘find-file’:

       (find-file . ido)

   same as

       (find-file . ido-read-file-name)

   Note that you don’t need to enable ‘ido-mode’ for this to work, see
   ‘helm-mode’ documentation.

 # #+vindex: helm-completing-read-handlers-alist
 To customize the completion interface or disable completion for
 specific commands in ~helm-mode~, edit
 ~helm-completing-read-handlers-alist~. See {{{kbd(C-h v)}}}
 ~helm-completing-read-handlers-alist~ for details.

**** Use helm-mode and ido-mode

 To use
 [[https://www.gnu.org/software/emacs/manual/html_mono/ido.html][Ido]]
 for some commands and Helm for others, do not enable
 ~ido-mode~. Instead, customize ~helm-completing-read-handlers-alist~
 to specify which command uses Ido.

 For example, suppose we want ~find-file-read-only~ to use Ido and
 ~find-file~ to use Helm. Then:

 1. In your init file, turn on ~helm-mode~.

 2. In the ~helm-mode~ customize group, add a key to
    ~helm-completing-read-handlers-alist~ for ~find-file-read-only~
    with value =ido=, i.e.

 #+begin_src emacs-lisp
   (find-file-read-only . ido)
 #+end_src

 With ~helm-mode~ active, to use Emacs default completion instead of
 either Helm or Ido, use ~nil~ for the key value:

 #+begin_src emacs-lisp
   (find-alternate-file . nil)
 #+end_src

*** Other Useful Extensions

 MELPA and other repositories have many useful extensions, some of
 which are redundant as Helm already provides them. Review if they
 already exist as part of the default Helm package before downloading
 new extensions.

*** Helm With Other Emacs Extensions

*** linum-relative

 ~(helm-linum-relative-mode 1)~ enables ~linum-relative~ in Helm. Helm
 buffers then display line numbered candidates before and after the
 current candidate (highlighted line). {{{kbd(C-x <n>)}}} jumps to =n= lines
 before, before, and {{{kbd(C-c <n>)}}} jumps to =n= lines after, the current
 candidate.

*** Helm Workflow for Files, Directories and Buffers

 # The new Helm workflow uses fewer buffers. Whereas the old workflow
 # opened many Dired buffers stacked in the workspace, the new approach
 # uses virtual Dired buffers without cluttering the buffer list with
 # many Dired buffers.  The decluttering of buffers also helps with
 # running ~helm-locate~ without conflicts; there's also less need to
 # resort to other workarounds, such as running ~helm-multi-files~.

 # The new approach uses ~helm-find-files~ as the starting point, never
 # opens Dired buffers yet provides easy access to common Helm commands,
 # such as =grep=, =locate=, =find=, etc. These Helm commands, moreover,
 # are not limited to the current directory because Helm now allows
 # marking files in other directories before running the commands.

 Other quick jumping off features of ~helm-find-files~:

 - {{{kbd(C-x C-d)}}} (~helm-browse-project~) shows buffers and files in the
   project.

 - {{{kbd(C-c C-d)}}} with prefix argument shows files in this directory and its
   subdirectories recursively.

 When using =helm-ls-git=[fn:xxx12] and =helm-ls-hg=[fn:xxx13] , files under
 version control have a corresponding backend indicator.

 - {{{kbd(C-x C-b)}}} to switch back to the resumed Helm sources.

 - {{{kbd(M-p)}}} to access history of ~helm-find-files~

 - {{{kbd(C-c h)}}} to access the full history of files (~file-name-history~)

 - {{{kbd(C-x C-f)}}} switches back to ~helm-find-files~

* Helm Generic Help

** Basics

# To navigate in this Help buffer see [[Helm help][here]].

Helm narrows down the list of candidates as you type a filter
pattern.  See [[Matching in Helm][Matching in Helm]].

Helm accepts multiple space-separated patterns, each pattern can
be negated with =!=.

Helm also supports fuzzy matching in some places when specified, you
will find several variables to enable fuzzy matching in diverse [[Helm
sources][sources]].

Helm generally uses familiar Emacs keys to navigate the list.
Here follow some of the less obvious bindings:

- {{{kbd(RET)}}} selects the
  candidate from the list, executes the default action upon exiting
  the Helm session.

- {{{kbd(C-j)}}} executes the
  default action but without exiting the Helm session.  Not all
  sources support this.

- {{{kbd(TAB)}}} displays a list of actions
  available on current candidate or all marked candidates.  The
  default binding <tab> is ordinarily used for completion, but that
  would be redundant since Helm completes upon every character
  entered in the prompt.

*Note*: In addition to the default actions list, additional actions
appear depending on the type of the selected candidate(s).  They
are called filtered actions.

*Additional Readings*:

- Fuzzy Matching :: https://github.com/emacs-helm/helm/wiki/Fuzzy-matching
- Helm Completion vs Emacs Completion :: https://github.com/emacs-helm/helm/wiki#helm-completion-vs-emacs-completion

** Helm sources

Helm uses what’s called sources to provide different kinds of
completions.  Each Helm session can handle one or more source.  A
source is an alist object which is build from various classes, see
[[Writing your own Helm sources][here]].

*Additional Readings*:

- Creating a Helm source :: https://github.com/emacs-helm/helm/wiki/Developing#creating-a-source

*** Configure sources

You will find in Helm sources already built and bound to a
variable called generally ~helm-source-<something>~.  In this case
it is an alist and you can change the attributes (keys) values
using ~helm-set-attr~ function in your configuration.  Of course
you have to ensure before calling ~helm-set-attr~ that the file
containing source is loaded, e.g. with ~with-eval-after-load~.  Of
course you can also completely redefine the source but this is
generally not elegant as it duplicate for its most part code
already defined in Helm.

You will find also sources that are not built and even not bound
to any variables because they are rebuilded at each start of a
Helm session.  In this case you can add a defmethod called
~helm-setup-user-source~ to your config:

#+begin_src elisp
    (cl-defmethod helm-setup-user-source ((source helm-moccur-class))
      (setf (slot-value source ’follow) -1))
#+end_src

*Additional Readings*:

- Helm FAQ: Why is a customizable  helm source nil  :: https://github.com/emacs-helm/helm/wiki/FAQ#why-is-a-customizable-helm-source-nil
- Complex Examples Of Configuration :: https://github.com/thierryvolpiatto/emacs-tv-config/blob/master/init-helm.el#L340

** Modify keybindings in Helm

Helm main keymap is ~helm-map~, all keys bound in this map apply
to all Helm sources.  However, most sources have their own keymap,
with each binding overriding its counterpart in ~helm-map~, you
can see all bindings in effect in the [[Commands][Commands]]
section (available only if the source has its own keymap and
documentation of course).

** Matching in Helm

All that you write in minibuffer is interpreted as a regexp or
multiple regexps if separated by a space.  This is true for most
sources unless the developer of the source has disabled it or
have choosen to use fuzzy matching.  Even if a source has fuzzy
matching enabled, Helm will switch to multi match as soon as it
detects a space in the pattern.  It may also switch to multi match
as well if pattern starts with a =^= beginning of line sign.  In
those cases each pattern separated with space should be a regexp
and not a fuzzy pattern.  When using multi match patterns, each
pattern starting with =!= is interpreted as a negation i.e.
match everything but this.

*** Completion-styles

Helm generally fetches its candidates with the ~:candidates~
function up to ~helm-candidate-number-limit~ and then applies
match functions to these candidates according to ~helm-pattern~.
But Helm allows matching candidates directly from the ~:candidates~
function using its own ~completion-styles~.
Helm provides ’helm completion style but also ’helm-flex
completion style for Emacs<27 that don’t have ’flex completion
style, otherwise (emacs-27) ’flex completion style is used to
provide fuzzy aka flex completion.
By default, like in Emacs vanilla, all completion commands (e.g.,
~completion-at-point~) using ~completion-in-region~ or
~completing-read~ use ~completion-styles~.
Some Helm native commands like ~helm-M-x~ do use
~completion-styles~.  Any Helm sources can use ~completion-styles~
by using ~:match-dynamic~ slot and building their ~:candidates~
function with ~helm-dynamic-completion~.

Example:

#+begin_src elisp
  (helm :sources (helm-build-sync-source "test"
		   :candidates (helm-dynamic-completion
				’(foo bar baz foab)
				’symbolp)
		   :match-dynamic t)
	:buffer "*helm test*")

#+end_src

By default Helm sets up ~completion-styles~ and always adds ’helm
to it.  However the flex completion styles are not added.  This is
up to the user if she wants to have such completion to enable
this.
As specified above use ’flex for emacs-27 and ’helm-flex for
emacs-26. Anyway, ’helm-flex is not provided in
~completion-styles-alist~ if ’flex is present.

Finally Helm provides two user variables to control
~completion-styles~ usage: ~helm-completion-style~ and
~helm-completion-syles-alist~.  Both variables are customizable.
The former allows retrieving previous Helm behavior if needed, by
setting it to ~helm~ or ~helm-fuzzy~, default being ~emacs~ which
allows dynamic completion and usage of ~completion-styles~.  The
second allows setting ~helm-completion-style~ per mode and also
specifying ~completion-styles~ per mode (see its docstring).  Note
that these two variables take effect only in helm-mode i.e. in
all that uses ~completion-read~ or ~completion-in-region~, IOW all
helmized commands.  File completion in ~read-file-name~ family
doesn’t obey completion-styles and has its own file completion
implementation. Native Helm commands using ~completion-styles~
doesn’t obey ~helm-completion-style~ and
~helm-completion-syles-alist~ (e.g., ~helm-M-x~).

Also for a better control of styles in native Helm sources (not
helmized by helm-mode) using ~:match-dynamic~,
~helm-dynamic-completion~ provides a STYLES argument that allows
specifying explicitely styles for this source.

*Note*: Some old completion styles are not working fine with Helm
and are disabled by default in
~helm-blacklist-completion-styles~.  They are anyway not useful in
Helm because ’helm style supersedes these styles.

** Helm mode

~helm-mode~ toggles Helm completion in native Emacs functions, so
when you turn ~helm-mode~ on, commands like ~switch-to-buffer~
will use Helm completion instead of the usual Emacs completion
buffer.

*** What gets or does not get =helmized= when ~helm-mode~ is enabled?

Helm provides generic completion on all Emacs functions using
~completing-read~, ~completion-in-region~ and their derivatives,
e.g. ~read-file-name~.  Helm exposes a user variable to control
which function to use for a specific Emacs command:
~helm-completing-read-handlers-alist~.  If the function for a
specific command is nil, it turns off Helm completion.  See the
variable documentation for more infos.

*** Helm functions vs helmized Emacs functions

While there are Helm functions that perform the same completion
as other helmized Emacs functions, e.g. ~switch-to-buffer~ and
~helm-buffers-list~, the native Helm functions like
~helm-buffers-list~ can receive new features that allow marking
candidates, have several actions, etc.  Whereas the helmized Emacs
functions only have Helm completion, Emacs can provide no more
than one action for this function.  This is the intended behavior.

Generally you are better off using the native Helm command than
the helmized Emacs equivalent.

*** Completion behavior with Helm and completion-at-point

Helm is NOT completing dynamically.  That means that when you are
completing some text at point, completion is done against this
text and subsequent characters you add AFTER this text.  This
allows you to use matching methods provided by Helm, that is multi
matching or fuzzy matching (see [[Matching in Helm][Matching in
Helm]]).

Completion is not done dynamically (against ~helm-pattern~)
because backend functions (i.e. ~competion-at-point-functions~)
are not aware of Helm matching methods.

By behaving like this, the benefit is that you can fully use Helm
matching methods but you can’t start a full completion against a
prefix different than the initial text you have at point.  Helm
warns you against this by colorizing the initial input and sends
a user-error message when trying to delete backward text beyond
this limit at first hit on DEL.  A second hit on DEL within a
short delay (1s) quits Helm and delete-backward char in
current-buffer.

** Helm help

{{{kbd(C-x c h h)}}}: Show all Helm documentations concatenated
in one org file.

From a Helm session, just hit {{{kbd(C-h m)}}} to have
the documentation for the current source followed by the global
Helm documentation.

While in the help buffer, most of the Emacs regular key bindings
are available; the most important ones are shown in minibuffer.
However, due to implementation restrictions, no regular Emacs
keymap is used (it runs in a loop when reading the help buffer).
Only simple bindings are available and they are defined in
~helm-help-hkmap~, which is a simple alist of (key . function).
You can define or redefine bindings in help with
~helm-help-define-key~ or by adding/removing entries directly in
~helm-help-hkmap~.
See ~helm-help-hkmap~ for restrictions on bindings and functions.

The documentation of default bindings are:

| Key       | Alternative keys | Command             |
|-----------+------------------+---------------------|
| C-v       | Space next       | Scroll up           |
| M-v       | b prior          | Scroll down         |
| C-s       |                  | Isearch forward     |
| C-r       |                  | Isearch backward    |
| C-a       |                  | Beginning of line   |
| C-e       |                  | End of line         |
| C-f       | right            | Forward char        |
| C-b       | left             | Backward char       |
| C-n       | down             | Next line           |
| C-p       | up               | Previous line       |
| M-a       |                  | Backward sentence   |
| M-e       |                  | Forward sentence    |
| M-f       |                  | Forward word        |
| M-b       |                  | Backward word       |
| M->       |                  | End of buffer       |
| M-<       |                  | Beginning of buffer |
| C-<SPACE> |                  | Toggle mark         |
| C-M-SPACE |                  | Mark sexp           |
| RET       |                  | Follow org link     |
| C-%       |                  | Push org mark       |
| C-&       |                  | Goto org mark-ring  |
| TAB       |                  | Org cycle           |
| M-<TAB>   |                  | Toggle visibility   |
| M-w       |                  | Copy region         |
| q         |                  | Quit                |

** Customize Helm

Helm provides a lot of user variables for extensive customization.
From any Helm session, type {{{kbd(C-h c)}}}
to jump to the current source ~custom~ group.  Helm also has a
special group for faces you can access via {{{kbd(M-x customize-group RET helm-faces)}}}.

*Note*: Some sources may not have their group set and default to
the ~helm~ group.

** Display Helm in windows and frames

You can display the Helm completion buffer in many different
window configurations, see the custom interface to discover the
different windows configurations available (See [[Customize Helm][Customize Helm]] to jump to custom interface).
When using Emacs in a graphic display (i.e. not in a terminal) you can as
well display your Helm buffers in separated frames globally for
all Helm commands or separately for specific Helm commands.
See ~helm-display-function~ and ~helm-commands-using-frame~.

There is a variable to allow reusing frame instead of deleting
and creating a new one at each session, see ~helm-display-buffer-reuse-frame~.
Normally you don’t have to use this, it have been made to workaround
slow frame popup in Emacs-26, to workaround this slowness in Emacs-26 use instead

#+begin_src elisp
    (when (= emacs-major-version 26)
      (setq x-wait-for-event-timeout nil))
#+end_src

*Additional Readings*:

- https://github.com/emacs-helm/helm/wiki/frame

*Warning*:
There is a package called posframe and also one called helm-posframe,
you DO NOT need these packages to display helm buffers in frames.

** Helm’s basic operations and default key bindings

| Key         | Alternative Keys | Command                                                              |
|-------------+------------------+----------------------------------------------------------------------|
| C-p         | Up               | Previous line                                                        |
| C-n         | Down             | Next line                                                            |
| M-v         | prior            | Previous page                                                        |
| C-v         | next             | Next page                                                            |
| Enter[fn:1] |                  | Execute first (default) action / Select [1]                          |
| M-<         |                  | First line                                                           |
| M->         |                  | Last line                                                            |
| C-M-S-v     | M-prior, C-M-y   | Previous page (other-window)                                         |
| C-M-v       | M-next           | Next page (other-window)                                             |
| Tab         | C-i              | Show action list                                                     |
| M-o         | left             | Previous source                                                      |
| C-o         | right            | Next source                                                          |
| C-k[fn:2]   |                  | Delete pattern (with prefix arg delete from point to end or all [2]) |
| C-j         |                  | Persistent action (Execute and keep Helm session)                    |

*Note*: Any of these bindings are from ~helm-map~ and may be
overriten by the map specific to the current source in use (each
source can have its own keymap).

** The actions menu

You can display the action menu in the same window
as helm candidates (default) or in a side window according to
~helm-show-action-window-other-window~ value.

When the action menu popup, the helm prompt is used to narrow
down this menu, no more candidates.

When ~helm-allow-mouse~ is non nil, you can use as well
mouse-3 (right click) in the candidate zone to select actions
with the mouse once your candidate is selected.

** Action transformers

You may be surprized to see your actions list changing depending
on the context.  This happen when a source has an action
transformer function which checks the current selected candidate
and adds specific actions for this candidate.

** Shortcuts for n-th first actions

{{{kbd(<f1>)}}}...{{{kbd(<f12>)}}}: Execute n-th action where n is 1 to 12.

** Shortcuts for executing the default action on the n-th candidate

Helm does not display line numbers by default, with Emacs-26+ you
can enable it permanently in all helm buffers with:

    #+begin_src elisp
      (add-hook ’helm-after-initialize-hook ’helm-init-relative-display-line-numbers)
    #+end_src

You can also toggle line numbers with
{{{kbd(C-c l)}}} in current Helm
buffer.

Of course when enabling ~global-display-line-numbers-mode~ Helm
buffers will have line numbers as well. (Don’t forget to
customize ~display-line-numbers-type~ to relative).

In Emacs versions < to 26 you will have to use linum-relative[fn:3]
package and ~helm-linum-relative-mode~.

Then when line numbers are enabled with one of the methods above
the following keys are available[fn:4]:

{{{kbd(C-x <n>)}}}: Execute default action on the n-th candidate before
currently selected candidate.

{{{kbd(C-c <n>)}}}: Execute default action on the n-th candidate after
current selected candidate.

=n= is limited to 1-9.  For larger jumps use other navigation
keys.

** Mouse control in Helm

A basic support for the mouse is provided when the user sets
~helm-allow-mouse~ to non-nil.

- mouse-1 selects the candidate.
- mouse-2 executes the default action on selected candidate.
- mouse-3 pops up the action menu.

*Note*: When mouse control is enabled in Helm, it also lets you
click around and lose the minibuffer focus: you’ll have to click
on the Helm buffer or the minibuffer to retrieve control of your
Helm session.

** Marked candidates

You can mark candidates to execute an action on all of them
instead of the current selected candidate only.  (See bindings
below.) Most Helm actions operate on marked candidates unless
candidate-marking is explicitely forbidden for a specific source.

- To mark/unmark a candidate, use
  {{{kbd(C-@)}}}.  (See bindings below.) With a
  numeric prefix arg mark ARG candidates forward, if ARG is
  negative mark ARG candidates backward.

- To mark all visible unmarked candidates at once in current
  source use {{{kbd(M-a)}}}.  With a prefix argument, mark all
  candidates in all sources.

- To unmark all visible marked candidates at once use
  {{{kbd(M-U)}}}.

- To mark/unmark all candidates at once use
  {{{kbd(M-m)}}}.  With a prefix argument, mark/unmark
  all candidates in all sources.

*Note*: When multiple candidates are selected across different
sources, only the candidates of the current source will be used
when executing most actions (as different sources can have
different actions).  Some actions support multi-source marking
however.

** Follow candidates

When ~helm-follow-mode~ is on ({{{kbd(C-c C-f)}}}
to toggle it), moving up and down Helm session or updating the
list of candidates will automatically execute the
persistent-action as specified for the current source.

If ~helm-follow-mode-persistent~ is non-nil, the state of the
mode will be restored for the following Helm sessions.

If you just want to follow candidates occasionally without
enabling ~helm-follow-mode~, you can use
{{{kbd(C-<down>)}}} or
{{{kbd(C-<up>)}}} instead.  Conversely, when
~helm-follow-mode~ is enabled, those commands go to previous/next
line without executing the persistent action.

** Frequently Used Commands

| Keys     | Description                                                                       |
|----------+-----------------------------------------------------------------------------------|
| C-t      | Toggle vertical/horizontal split on first hit and swap Helm window on second hit. |
| C-c %    | Exchange minibuffer and header-line.                                              |
| C-x C-f  | Drop into ‘helm-find-files’.                                                      |
| C-c C-k  | Kill display value of candidate and quit (with prefix arg, kill the real value).  |
| C-c C-y  | Yank current selection into pattern.                                              |
| C-c TAB  | Copy selected candidate at point in current buffer.                               |
| C-c C-f  | Toggle automatic execution of persistent action.                                  |
| C-<down> | Run persistent action then select next line.                                      |
| C-<up>   | Run persistent action then select previous line.                                  |
| C-c C-u  | Recalculate and redisplay candidates.                                             |
| C-!      | Toggle candidate updates.                                                         |

** Special yes, no or yes for all answers

You may be prompted in the minibuffer to answer by [y,n,!,q] in
some places for confirmation.

- y  mean yes
- no mean no
- !  mean yes for all
- q  mean quit or abort current operation.

When using ! you will not be prompted for the same thing in
current operation any more, e.g. file deletion, file copy etc...

** Moving in ~helm-buffer~

You can move in ~helm-buffer~ with the usual commands used in
Emacs: ({{{kbd(C-n)}}},
{{{kbd(C-p)}}}, etc.  See above basic
commands.  When ~helm-buffer~ contains more than one source,
change source with {{{kbd(C-o)}}} and
{{{kbd(M-o)}}}.

*Note*: When reaching the end of a source,
{{{kbd(C-n)}}} will *not* go to the next source
when variable ~helm-move-to-line-cycle-in-source~ is non-nil, so
you will have to use {{{kbd(C-o)}}} and
{{{kbd(M-o)}}}.

** Resume previous session from current Helm session

You can use {{{kbd(C-c n)}}} (~helm-run-cycle-resume~) to cycle in
resumables sources.  {{{kbd(C-c n)}}} is a special key set with
~helm-define-key-with-subkeys~ which, after pressing it, allows
you to keep cycling with further {{{kbd(n)}}}.

*Tip*: You can bound the same key in ~global-map~ to
     ~helm-cycle-resume~ with ~helm-define-key-with-subkeys~ to
     let you transparently cycle sessions, Helm fired up or not.
     You can also bind the cycling commands to single key
     presses (e.g., {{{kbd(S-<f1>)}}}) this time with a simple
     ~define-key~.  (Note that {{{kbd(S-<f1>)}}} is not available in
     terminals.)

*Note*: ~helm-define-key-with-subkeys~ is available only once Helm
is loaded.

You can also use
{{{kbd(C-x b)}}} to resume
the previous session, or
{{{kbd(C-x C-b)}}} to have
completion on all resumable buffers.

** Global commands

*** Resume Helm session from outside Helm

{{{kbd(C-x c b)}}} revives the last Helm session.
Binding a key to this command will greatly improve Helm
interactivity, e.g. when quitting Helm accidentally.

You can call {{{kbd(C-x c b)}}} with a prefix argument
to choose (with completion!) which session you’d like to resume.
You can also cycle in these sources with ~helm-cycle-resume~ (see
above).

** Debugging Helm

Helm exposes the special variable ~helm-debug~: setting it to
non-nil will enable Helm logging in a special outline-mode
buffer.  Helm resets the variable to nil at the end of each
session.

For convenience, {{{kbd(C-h C-d)}}}
allows you to turn on debugging for this session only.  To avoid
accumulating log entries while you are typing patterns, you can
use {{{kbd(C-!)}}} to turn off
updating.  When you are ready turn it on again to resume logging.

Once you exit your Helm session you can access the debug buffer
with ~helm-debug-open-last-log~.  It is possible to save logs to
dated files when ~helm-debug-root-directory~ is set to a valid
directory.

*Note*: Be aware that Helm log buffers grow really fast, so use
~helm-debug~ only when needed.

** Writing your own Helm sources

Writing simple sources for your own usage is easy.  When calling
the ~helm~ function, the sources are added the ~:sources~ slot
which can be a symbol or a list of sources.  Sources can be built
with different EIEIO classes depending on what you want to do.  To
simplify this, several ~helm-build-*~ macros are provided.  Below
there are simple examples to start with.

#+begin_src elisp
    ;; Candidates are stored in a list.
    (helm :sources (helm-build-sync-source "test"
		     ;; A function can be used as well
		     ;; to provide candidates.
		     :candidates ’("foo" "bar" "baz"))
	  :buffer "*helm test*")

    ;; Candidates are stored in a buffer.
    ;; Generally faster but doesn’t allow a dynamic updating
    ;; of the candidates list i.e the list is fixed on start.
    (helm :sources (helm-build-in-buffer-source "test"
		     :data ’("foo" "bar" "baz"))
	  :buffer "*helm test*")
#+end_src

*Additional Readings*:

- For source code and complex examples :: https://github.com/emacs-helm/helm/wiki/Developing

** Helm Map

| *Key*         | *Binding*                                | *Comments*                           |
|---------------+------------------------------------------+--------------------------------------|
| C-@           | helm-toggle-visible-mark                 |                                      |
| C-c           | Prefix Command                           |                                      |
| C-g           | helm-keyboard-quit                       |                                      |
| C-h           | Prefix Command                           |                                      |
| TAB           | helm-select-action                       |                                      |
| C-j           | helm-execute-persistent-action           |                                      |
| C-k           | helm-delete-minibuffer-contents          |                                      |
| C-l           | helm-recenter-top-bottom-other-window    |                                      |
| RET           | helm-maybe-exit-minibuffer               |                                      |
| C-n           | helm-next-line                           |                                      |
| C-o           | helm-next-source                         |                                      |
| C-p           | helm-previous-line                       |                                      |
| C-t           | helm-toggle-resplit-and-swap-windows     |                                      |
| C-v           | helm-next-page                           |                                      |
| C-w           | ??                                       |                                      |
| C-x           | Prefix Command                           |                                      |
| ESC           | Prefix Command                           |                                      |
| C-SPC         | helm-toggle-visible-mark-forward         |                                      |
| C-!           | helm-toggle-suspend-update               |                                      |
| C-{           | helm-enlarge-window                      |                                      |
| C-}           | helm-narrow-window                       |                                      |
| C-M-<down>    | helm-scroll-other-window                 |                                      |
| C-M-<up>      | helm-scroll-other-window-down            |                                      |
| C-<down>      | helm-follow-action-forward               |                                      |
| C-<up>        | helm-follow-action-backward              |                                      |
| M-<next>      | helm-scroll-other-window                 |                                      |
| M-<prior>     | helm-scroll-other-window-down            |                                      |
| <XF86Back>    | previous-history-element                 |                                      |
| <XF86Forward> | next-history-element                     |                                      |
| <down>        | helm-next-line                           |                                      |
| <f1>          | ??                                       |                                      |
| <f2>          | ??                                       |                                      |
| <f3>          | ??                                       |                                      |
| <f4>          | ??                                       |                                      |
| <f5>          | ??                                       |                                      |
| <f6>          | ??                                       |                                      |
| <f7>          | ??                                       |                                      |
| <f8>          | ??                                       |                                      |
| <f9>          | ??                                       |                                      |
| <f10>         | ??                                       |                                      |
| <f11>         | ??                                       |                                      |
| <f12>         | ??                                       |                                      |
| <f13>         | ??                                       |                                      |
| <help>        | Prefix Command                           |                                      |
| <left>        | helm-previous-source                     |                                      |
| <next>        | helm-next-page                           |                                      |
| <prior>       | helm-previous-page                       |                                      |
| <right>       | helm-next-source                         |                                      |
| <tab>         | helm-execute-persistent-action           |                                      |
| <up>          | helm-previous-line                       |                                      |
|               |                                          |                                      |
| <help> m      | helm-help                                |                                      |
|               |                                          |                                      |
| C-h C-d       | helm-enable-or-switch-to-debug           |                                      |
| C-h c         | helm-customize-group                     |                                      |
| C-h m         | helm-help                                |                                      |
|               |                                          |                                      |
| C-c C-f       | helm-follow-mode                         |                                      |
| C-c TAB       | helm-copy-to-buffer                      |                                      |
| C-c C-k       | helm-kill-selection-and-quit             |                                      |
| C-c C-u       | helm-refresh                             |                                      |
| C-c C-y       | helm-yank-selection                      |                                      |
| C-c %         | helm-exchange-minibuffer-and-header-line |                                      |
| C-c -         | helm-swap-windows                        |                                      |
| C-c 1         | helm-execute-selection-action-at-nth-+1  |                                      |
| C-c 2         | helm-execute-selection-action-at-nth-+2  |                                      |
| C-c 3         | helm-execute-selection-action-at-nth-+3  |                                      |
| C-c 4         | helm-execute-selection-action-at-nth-+4  |                                      |
| C-c 5         | helm-execute-selection-action-at-nth-+5  |                                      |
| C-c 6         | helm-execute-selection-action-at-nth-+6  |                                      |
| C-c 7         | helm-execute-selection-action-at-nth-+7  |                                      |
| C-c 8         | helm-execute-selection-action-at-nth-+8  |                                      |
| C-c 9         | helm-execute-selection-action-at-nth-+9  |                                      |
| C-c >         | helm-toggle-truncate-line                |                                      |
| C-c ?         | helm-help                                |                                      |
| C-c _         | helm-toggle-full-frame                   |                                      |
| C-c l         | helm-display-line-numbers-mode           |                                      |
| C-c n         | ??                                       |                                      |
|               |                                          |                                      |
| C-x C-b       | helm-resume-list-buffers-after-quit      |                                      |
| C-x C-f       | helm-quit-and-find-file                  |                                      |
| C-x 1         | helm-execute-selection-action-at-nth-+1  |                                      |
| C-x 2         | helm-execute-selection-action-at-nth-+2  |                                      |
| C-x 3         | helm-execute-selection-action-at-nth-+3  |                                      |
| C-x 4         | helm-execute-selection-action-at-nth-+4  |                                      |
| C-x 5         | helm-execute-selection-action-at-nth-+5  |                                      |
| C-x 6         | helm-execute-selection-action-at-nth-+6  |                                      |
| C-x 7         | helm-execute-selection-action-at-nth-+7  |                                      |
| C-x 8         | helm-execute-selection-action-at-nth-+8  |                                      |
| C-x 9         | helm-execute-selection-action-at-nth-+9  |                                      |
| C-x b         | helm-resume-previous-session-after-quit  |                                      |
|               |                                          |                                      |
| C-M-a         | helm-show-all-candidates-in-source       |                                      |
| C-M-e         | helm-display-all-sources                 |                                      |
| C-M-l         | helm-reposition-window-other-window      |                                      |
| C-M-v         | helm-scroll-other-window                 |                                      |
| C-M-y         | helm-scroll-other-window-down            |                                      |
| M-SPC         | helm-toggle-visible-mark-backward        |                                      |
| M-(           | helm-prev-visible-mark                   |                                      |
| M-)           | helm-next-visible-mark                   |                                      |
| M-<           | helm-beginning-of-buffer                 |                                      |
| M->           | helm-end-of-buffer                       |                                      |
| M-U           | helm-unmark-all                          |                                      |
| M-a           | helm-mark-all                            |                                      |
| M-g           | Prefix Command                           |                                      |
| M-m           | helm-toggle-all-marks                    |                                      |
| M-n           | next-history-element                     |                                      |
| M-o           | helm-previous-source                     |                                      |
| M-p           | previous-history-element                 |                                      |
| M-v           | helm-previous-page                       |                                      |
| C-M-S-v       | helm-scroll-other-window-down            |                                      |
|               |                                          |                                      |
| M-g ESC       | Prefix Command                           |                                      |
|               |                                          |                                      |
| M-<           | minibuffer-beginning-of-buffer           | (this binding is currently shadowed) |
| M-g           | Prefix Command                           |                                      |
| M-r           | previous-matching-history-element        |                                      |
| M-s           | next-matching-history-element            | (this binding is currently shadowed) |
|               |                                          |                                      |
| M-g ESC       | Prefix Command                           |                                      |
|               |                                          |                                      |
| M-g M-c       | helm-comint-input-ring                   |                                      |
|               |                                          |                                      |
| M-g M-h       | helm-minibuffer-history                  |                                      |

* Package: helm

** Library: helm

*** Modes in library ~helm~

**** other-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-major-mode~ ::

  #+findex: helm-major-mode

  [INTERNAL] Provide major-mode name in Helm buffers.
  Unuseful when used outside Helm, don't use it.

  This mode runs the hook ~helm-major-mode-hook~, as the final or
  penultimate step during initialization.

  \{helm-major-mode-map}

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm--minor-mode~ ::

  #+findex: helm--minor-mode

  (helm--minor-mode &optional ARG)

  [INTERNAL] Enable keymap in Helm minibuffer.
  Since this mode has no effect when run outside of Helm context,
  please don't use it outside of Helm.

  If called interactively, toggle ~Helm- minor mode~.  If the
  prefix argument is positive, enable the mode, and if it is zero
  or negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

  \{helm-map}

- ~helm--remap-mouse-mode~ ::

  #+findex: helm--remap-mouse-mode

  (helm--remap-mouse-mode &optional ARG)

  [INTERNAL] Prevent escaping helm minibuffer with mouse clicks.
  Do nothing when used outside of helm context.

  If called interactively, toggle ~Helm--Remap-Mouse mode~.  If the
  prefix argument is positive, enable the mode, and if it is zero
  or negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

  WARNING: Do not use this mode yourself, it is internal to Helm.

- ~helm-autoresize-mode~ ::

  #+findex: helm-autoresize-mode

  (helm-autoresize-mode &optional ARG)

  Auto resize helm window when enabled.
  Helm window is re-sized according to ~helm-autoresize-max-height~
  and ~helm-autoresize-min-height~.  Note that when this mode is
  enabled, Helm behaves as if ~helm-always-two-windows~ is enabled.

  If called interactively, toggle ~Helm-Autoresize mode~.  If the
  prefix argument is positive, enable the mode, and if it is zero
  or negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

  See ~fit-window-to-buffer~ for more infos.

*** Commands in keymap ~helm-map~

**** Most Important
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-g)}}} (~helm-keyboard-quit~) ::

  #+findex: helm-keyboard-quit @r{(helm-map)}

  #+kindex: C-g @r{(helm-map)}

  Quit minibuffer in helm.
  If action buffer is displayed, kill it.

- {{{kbd(RET)}}} (~helm-maybe-exit-minibuffer~) ::

  #+findex: helm-maybe-exit-minibuffer @r{(helm-map)}

  #+kindex: RET @r{(helm-map)}

- {{{kbd(C-j)}}} (~helm-execute-persistent-action~) ::

  #+findex: helm-execute-persistent-action @r{(helm-map)}

  #+kindex: C-j @r{(helm-map)}

  (helm-execute-persistent-action &optional ATTR SPLIT)

  Perform the associated action ATTR without quitting helm.

  Arg ATTR default will be ~persistent-action~ or
  ~persistent-action-if~ if unspecified depending on what's found
  in source, but it can be anything else.
  In this case you have to add this new attribute to your source.
  See ~persistent-action~ and ~persistent-action-if~ slot
  documentation in ~helm-source~.

  When ~helm-full-frame~ is non-nil, and ~helm-buffer~ is displayed
  in only one window, the helm window is split to display
  ~helm-select-persistent-action-window~ in other window to
  maintain visibility.  The argument SPLIT can be used to force
  splitting inconditionally, it is unused actually.

- {{{kbd(TAB)}}} (~helm-select-action~) ::

  #+findex: helm-select-action @r{(helm-map)}

  #+kindex: TAB @r{(helm-map)}

  Select an action for the currently selected candidate.
  If action buffer is selected, back to the Helm buffer.

- {{{kbd(C-x 1)}}} (~helm-execute-selection-action-at-nth-+1~) ::

  #+findex: helm-execute-selection-action-at-nth-+1 @r{(helm-map)}

  #+kindex: C-x 1 @r{(helm-map)}

- {{{kbd(C-c 1)}}} (~helm-execute-selection-action-at-nth-+1~) ::

  #+findex: helm-execute-selection-action-at-nth-+1 @r{(helm-map)}

  #+kindex: C-c 1 @r{(helm-map)}

- {{{kbd(C-x 2)}}} (~helm-execute-selection-action-at-nth-+2~) ::

  #+findex: helm-execute-selection-action-at-nth-+2 @r{(helm-map)}

  #+kindex: C-x 2 @r{(helm-map)}

- {{{kbd(C-c 2)}}} (~helm-execute-selection-action-at-nth-+2~) ::

  #+findex: helm-execute-selection-action-at-nth-+2 @r{(helm-map)}

  #+kindex: C-c 2 @r{(helm-map)}

- {{{kbd(C-x 3)}}} (~helm-execute-selection-action-at-nth-+3~) ::

  #+findex: helm-execute-selection-action-at-nth-+3 @r{(helm-map)}

  #+kindex: C-x 3 @r{(helm-map)}

- {{{kbd(C-c 3)}}} (~helm-execute-selection-action-at-nth-+3~) ::

  #+findex: helm-execute-selection-action-at-nth-+3 @r{(helm-map)}

  #+kindex: C-c 3 @r{(helm-map)}

- {{{kbd(C-x 4)}}} (~helm-execute-selection-action-at-nth-+4~) ::

  #+findex: helm-execute-selection-action-at-nth-+4 @r{(helm-map)}

  #+kindex: C-x 4 @r{(helm-map)}

- {{{kbd(C-c 4)}}} (~helm-execute-selection-action-at-nth-+4~) ::

  #+findex: helm-execute-selection-action-at-nth-+4 @r{(helm-map)}

  #+kindex: C-c 4 @r{(helm-map)}

- {{{kbd(C-x 5)}}} (~helm-execute-selection-action-at-nth-+5~) ::

  #+findex: helm-execute-selection-action-at-nth-+5 @r{(helm-map)}

  #+kindex: C-x 5 @r{(helm-map)}

- {{{kbd(C-c 5)}}} (~helm-execute-selection-action-at-nth-+5~) ::

  #+findex: helm-execute-selection-action-at-nth-+5 @r{(helm-map)}

  #+kindex: C-c 5 @r{(helm-map)}

- {{{kbd(C-x 6)}}} (~helm-execute-selection-action-at-nth-+6~) ::

  #+findex: helm-execute-selection-action-at-nth-+6 @r{(helm-map)}

  #+kindex: C-x 6 @r{(helm-map)}

- {{{kbd(C-c 6)}}} (~helm-execute-selection-action-at-nth-+6~) ::

  #+findex: helm-execute-selection-action-at-nth-+6 @r{(helm-map)}

  #+kindex: C-c 6 @r{(helm-map)}

- {{{kbd(C-x 7)}}} (~helm-execute-selection-action-at-nth-+7~) ::

  #+findex: helm-execute-selection-action-at-nth-+7 @r{(helm-map)}

  #+kindex: C-x 7 @r{(helm-map)}

- {{{kbd(C-c 7)}}} (~helm-execute-selection-action-at-nth-+7~) ::

  #+findex: helm-execute-selection-action-at-nth-+7 @r{(helm-map)}

  #+kindex: C-c 7 @r{(helm-map)}

- {{{kbd(C-x 8)}}} (~helm-execute-selection-action-at-nth-+8~) ::

  #+findex: helm-execute-selection-action-at-nth-+8 @r{(helm-map)}

  #+kindex: C-x 8 @r{(helm-map)}

- {{{kbd(C-c 8)}}} (~helm-execute-selection-action-at-nth-+8~) ::

  #+findex: helm-execute-selection-action-at-nth-+8 @r{(helm-map)}

  #+kindex: C-c 8 @r{(helm-map)}

- {{{kbd(C-x 9)}}} (~helm-execute-selection-action-at-nth-+9~) ::

  #+findex: helm-execute-selection-action-at-nth-+9 @r{(helm-map)}

  #+kindex: C-x 9 @r{(helm-map)}

- {{{kbd(C-c 9)}}} (~helm-execute-selection-action-at-nth-+9~) ::

  #+findex: helm-execute-selection-action-at-nth-+9 @r{(helm-map)}

  #+kindex: C-c 9 @r{(helm-map)}

- {{{kbd(C-<tab>)}}} ::
- {{{kbd(C-s)}}} ::
- {{{kbd(C-h h)}}} ::
- {{{kbd(C-h C-h)}}} ::
- {{{kbd(M-s)}}} (~undefined~) ::

  #+findex: undefined @r{(helm-map)}

  #+kindex: C-<tab> @r{(helm-map)}
  #+kindex: C-s @r{(helm-map)}
  #+kindex: C-h h @r{(helm-map)}
  #+kindex: C-h C-h @r{(helm-map)}
  #+kindex: M-s @r{(helm-map)}

  Beep to tell the user this binding is undefined.

- {{{kbd(C-k)}}} (~helm-delete-minibuffer-contents~) ::

  #+findex: helm-delete-minibuffer-contents @r{(helm-map)}

  #+kindex: C-k @r{(helm-map)}

  (helm-delete-minibuffer-contents &optional ARG)

  Delete minibuffer contents.
  When ~helm-delete-minibuffer-contents-from-point~ is non-nil,
  delete minibuffer contents from point instead of deleting all.
  With a prefix arg reverse this behaviour.  When at the end of
  minibuffer, delete all.

- {{{kbd(<help> m)}}} ::
- {{{kbd(C-h m)}}} ::
- {{{kbd(C-c ?)}}} (~helm-help~) ::

  #+findex: helm-help @r{(helm-map)}

  #+kindex: <help> m @r{(helm-map)}
  #+kindex: C-h m @r{(helm-map)}
  #+kindex: C-c ? @r{(helm-map)}

  Generate Helm's help according to ~help-message~ attribute.

  If ~helm-buffer~ is empty, provide completions on ~helm-sources~
  to choose its local documentation.
  If source doesn't have any ~help-message~ attribute, a generic
  message explaining this is added instead.
  The global ~helm-help-message~ is always added after this local
  help.

- {{{kbd(C-h c)}}} (~helm-customize-group~) ::

  #+findex: helm-customize-group @r{(helm-map)}

  #+kindex: C-h c @r{(helm-map)}

  Jump to customization group of current source.

  Default to Helm group when group is not defined in source.

**** Minor Modes
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c l)}}} (~helm-display-line-numbers-mode~) ::

  #+findex: helm-display-line-numbers-mode @r{(helm-map)}

  #+kindex: C-c l @r{(helm-map)}

  (helm-display-line-numbers-mode &optional ARG)

  Toggle display of line numbers in current Helm buffer.

  If called interactively, toggle ~Helm-Display-Line-Numbers mode~.
  If the prefix argument is positive, enable the mode, and if it is
  zero or negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

- {{{kbd(C-c C-f)}}} (~helm-follow-mode~) ::

  #+findex: helm-follow-mode @r{(helm-map)}

  #+kindex: C-c C-f @r{(helm-map)}

  (helm-follow-mode &optional ARG)

  Execute persistent action every time the cursor is moved.

  This mode is source local, i.e. It applies on current source only.
  \<helm-map>
  This mode can be enabled or disabled interactively at anytime during
  a helm session with \[helm-follow-mode].

  When enabling interactively ~helm-follow-mode~ in a source, you
  can keep it enabled for next Emacs sessions by setting
  ~helm-follow-mode-persistent~ to a non-nil value.

  When ~helm-follow-mode~ is called with a prefix arg and
  ~helm-follow-mode-persistent~ is non-nil ~helm-follow-mode~ will
  be persistent only for this Emacs session, but not for the next
  Emacs sessions, i.e. the current source will not be saved to
  ~helm-source-names-using-follow~.

  A prefix arg with ~helm-follow-mode~ already enabled will have no
  effect.

  Note that you can use instead of this mode the commands
  ~helm-follow-action-forward~ and ~helm-follow-action-backward~ at
  anytime in all Helm sessions.

  They are bound by default to \[helm-follow-action-forward] and
  \[helm-follow-action-backward].

**** Control what is displayed
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c >)}}} (~helm-toggle-truncate-line~) ::

  #+findex: helm-toggle-truncate-line @r{(helm-map)}

  #+kindex: C-c > @r{(helm-map)}

  Toggle ~truncate-lines~ value in ~helm-buffer~

- {{{kbd(C-M-e)}}} (~helm-display-all-sources~) ::

  #+findex: helm-display-all-sources @r{(helm-map)}

  #+kindex: C-M-e @r{(helm-map)}

  Display all sources previously hidden by ~helm-set-source-filter~.

- {{{kbd(C-M-a)}}} (~helm-show-all-candidates-in-source~) ::

  #+findex: helm-show-all-candidates-in-source @r{(helm-map)}

  #+kindex: C-M-a @r{(helm-map)}

  (helm-show-all-candidates-in-source ARG)

  Toggle all or only candidate-number-limit cands in current source.
  With a numeric prefix arg show only the ARG number of candidates.
  The prefix arg has no effect when toggling to only
  candidate-number-limit.

**** Control the layout
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c %)}}} (~helm-exchange-minibuffer-and-header-line~) ::

  #+findex: helm-exchange-minibuffer-and-header-line @r{(helm-map)}

  #+kindex: C-c % @r{(helm-map)}

  Display minibuffer in header-line and vice versa for current Helm session.

  This is a toggle command.

- {{{kbd(C-{)}}} (~helm-enlarge-window~) ::

  #+findex: helm-enlarge-window @r{(helm-map)}

  #+kindex: C-@{ @r{(helm-map)}

  Enlarge helm window.

- {{{kbd(C-})}}} (~helm-narrow-window~) ::

  #+findex: helm-narrow-window @r{(helm-map)}

  #+kindex: C-@} @r{(helm-map)}

  Narrow helm window.

- {{{kbd(C-c -)}}} (~helm-swap-windows~) ::

  #+findex: helm-swap-windows @r{(helm-map)}

  #+kindex: C-c - @r{(helm-map)}

  Swap window holding ~helm-buffer~ with other window.

- {{{kbd(C-c _)}}} (~helm-toggle-full-frame~) ::

  #+findex: helm-toggle-full-frame @r{(helm-map)}

  #+kindex: C-c _ @r{(helm-map)}

  (helm-toggle-full-frame &optional ARG)

  Toggle ~helm-buffer~ full-frame view.

- {{{kbd(C-t)}}} (~helm-toggle-resplit-and-swap-windows~) ::

  #+findex: helm-toggle-resplit-and-swap-windows @r{(helm-map)}

  #+kindex: C-t @r{(helm-map)}

  Multi key command to re-split and swap Helm window.
  First call runs ~helm-toggle-resplit-window~,
  and second call within 1s runs ~helm-swap-windows~.

**** Act on Other Window
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-l)}}} (~helm-recenter-top-bottom-other-window~) ::

  #+findex: helm-recenter-top-bottom-other-window @r{(helm-map)}

  #+kindex: C-l @r{(helm-map)}

  (helm-recenter-top-bottom-other-window &optional ARG)

  Run ~recenter-top-bottom~ in other window.
  Meaning of prefix ARG is the same as in ~recenter-top-bottom~.

- {{{kbd(C-M-l)}}} (~helm-reposition-window-other-window~) ::

  #+findex: helm-reposition-window-other-window @r{(helm-map)}

  #+kindex: C-M-l @r{(helm-map)}

  (helm-reposition-window-other-window &optional ARG)

  Run ~reposition-window~ in other window.
  Meaning of prefix ARG is the same as in ~reposition-window~.

- {{{kbd(C-M-<down>)}}} ::
- {{{kbd(M-<next>)}}} ::
- {{{kbd(C-M-v)}}} (~helm-scroll-other-window~) ::

  #+findex: helm-scroll-other-window @r{(helm-map)}

  #+kindex: C-M-<down> @r{(helm-map)}
  #+kindex: M-<next> @r{(helm-map)}
  #+kindex: C-M-v @r{(helm-map)}

  (helm-scroll-other-window &optional ARG)

  Scroll other window upward ARG many lines.
  When arg is not provided scroll ~helm-scroll-amount~ lines.
  See ~scroll-other-window~.

- {{{kbd(C-M-<up>)}}} ::
- {{{kbd(M-<prior>)}}} ::
- {{{kbd(C-M-S-v)}}} ::
- {{{kbd(C-M-y)}}} (~helm-scroll-other-window-down~) ::

  #+findex: helm-scroll-other-window-down @r{(helm-map)}

  #+kindex: C-M-<up> @r{(helm-map)}
  #+kindex: M-<prior> @r{(helm-map)}
  #+kindex: C-M-S-v @r{(helm-map)}
  #+kindex: C-M-y @r{(helm-map)}

  (helm-scroll-other-window-down &optional ARG)

  Scroll other window downward ARG many lines.
  When arg is not provided scroll ~helm-scroll-amount~ lines.
  See ~scroll-other-window-down~.

**** Navigate
:PROPERTIES:
:UNNUMBERED: notoc
:END:

***** Move by line

- {{{kbd(C-p)}}} ::
- {{{kbd(<up>)}}} (~helm-previous-line~) ::

  #+findex: helm-previous-line @r{(helm-map)}

  #+kindex: C-p @r{(helm-map)}
  #+kindex: <up> @r{(helm-map)}

  (helm-previous-line &optional ARG)

  Move selection to the ARG previous line(s).
  Same behavior as ~helm-next-line~ when called with a numeric
  prefix arg.

- {{{kbd(C-n)}}} ::
- {{{kbd(<down>)}}} (~helm-next-line~) ::

  #+findex: helm-next-line @r{(helm-map)}

  #+kindex: C-n @r{(helm-map)}
  #+kindex: <down> @r{(helm-map)}

  (helm-next-line &optional ARG)

  Move selection to the next ARG line(s).
  When numeric prefix arg is > than the number of candidates, then
  move to the last candidate of current source (i.e. don't move to
  next source).

***** Move by page

- {{{kbd(<prior>)}}} ::
- {{{kbd(M-v)}}} (~helm-previous-page~) ::

  #+findex: helm-previous-page @r{(helm-map)}

  #+kindex: <prior> @r{(helm-map)}
  #+kindex: M-v @r{(helm-map)}

  Move selection back with a pageful.

- {{{kbd(C-v)}}} ::
- {{{kbd(<next>)}}} (~helm-next-page~) ::

  #+findex: helm-next-page @r{(helm-map)}

  #+kindex: C-v @r{(helm-map)}
  #+kindex: <next> @r{(helm-map)}

  Move selection forward with a pageful.

***** Move by source

- {{{kbd(<left>)}}} ::
- {{{kbd(M-o)}}} (~helm-previous-source~) ::

  #+findex: helm-previous-source @r{(helm-map)}

  #+kindex: <left> @r{(helm-map)}
  #+kindex: M-o @r{(helm-map)}

  Move selection to the previous source.

- {{{kbd(<right>)}}} ::
- {{{kbd(C-o)}}} (~helm-next-source~) ::

  #+findex: helm-next-source @r{(helm-map)}

  #+kindex: <right> @r{(helm-map)}
  #+kindex: C-o @r{(helm-map)}

  Move selection to the next source.

***** Move to beginning or end of buffer

- {{{kbd(M-<)}}} (~helm-beginning-of-buffer~) ::

  #+findex: helm-beginning-of-buffer @r{(helm-map)}

  #+kindex: M-< @r{(helm-map)}

  Move selection at the top.

- {{{kbd(M->)}}} (~helm-end-of-buffer~) ::

  #+findex: helm-end-of-buffer @r{(helm-map)}

  #+kindex: M-> @r{(helm-map)}

  Move selection at the bottom.

***** Move by mark

- {{{kbd(M-()}}} (~helm-prev-visible-mark~) ::

  #+findex: helm-prev-visible-mark @r{(helm-map)}

  #+kindex: M-( @r{(helm-map)}

  Move previous helm visible mark.

- {{{kbd(M-))}}} (~helm-next-visible-mark~) ::

  #+findex: helm-next-visible-mark @r{(helm-map)}

  #+kindex: M-) @r{(helm-map)}

  (helm-next-visible-mark &optional PREV)

  Move next Helm visible mark.
  If PREV is non-nil move to precedent.

****  Mark
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-a)}}} (~helm-mark-all~) ::

  #+findex: helm-mark-all @r{(helm-map)}

  #+kindex: M-a @r{(helm-map)}

  (helm-mark-all &optional ALL)

  Mark all visible unmarked candidates in current source.

  With a prefix arg mark all visible unmarked candidates in all
  sources.

- {{{kbd(M-U)}}} (~helm-unmark-all~) ::

  #+findex: helm-unmark-all @r{(helm-map)}

  #+kindex: M-U @r{(helm-map)}

  Unmark all candidates in all sources of current helm session.

- {{{kbd(C-@)}}} (~helm-toggle-visible-mark~) ::

  #+findex: helm-toggle-visible-mark @r{(helm-map)}

  #+kindex: C-@ @r{(helm-map)}

  (helm-toggle-visible-mark ARG)

  Toggle Helm visible mark at point ARG times.
  If ARG is negative toggle backward.

- {{{kbd(M-m)}}} (~helm-toggle-all-marks~) ::

  #+findex: helm-toggle-all-marks @r{(helm-map)}

  #+kindex: M-m @r{(helm-map)}

  (helm-toggle-all-marks &optional ALL)

  Toggle all marks.

  Mark all visible candidates of current source or unmark all
  candidates visible or invisible in all sources of current Helm
  session.

  With a prefix argument mark all candidates in all sources.

- {{{kbd(M-SPC)}}} (~helm-toggle-visible-mark-backward~) ::

  #+findex: helm-toggle-visible-mark-backward @r{(helm-map)}

  #+kindex: M-SPC @r{(helm-map)}

- {{{kbd(C-SPC)}}} (~helm-toggle-visible-mark-forward~) ::

  #+findex: helm-toggle-visible-mark-forward @r{(helm-map)}

  #+kindex: C-SPC @r{(helm-map)}

**** Act on Selected Candidates
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c TAB)}}} (~helm-copy-to-buffer~) ::

  #+findex: helm-copy-to-buffer @r{(helm-map)}

  #+kindex: C-c TAB @r{(helm-map)}

  Copy selection or marked candidates to ~helm-current-buffer~.
  Note that the real values of candidates are copied and not the
  display values.

- {{{kbd(C-c C-k)}}} (~helm-kill-selection-and-quit~) ::

  #+findex: helm-kill-selection-and-quit @r{(helm-map)}

  #+kindex: C-c C-k @r{(helm-map)}

  (helm-kill-selection-and-quit ARG)

  Store display value of current selection to kill ring.
  With a prefix arg use real value of current selection.
  Display value is shown in ~helm-buffer~ and real value is used to
  perform actions.

- {{{kbd(C-c C-y)}}} (~helm-yank-selection~) ::

  #+findex: helm-yank-selection @r{(helm-map)}

  #+kindex: C-c C-y @r{(helm-map)}

  (helm-yank-selection ARG)

  Set minibuffer contents to current display selection.
  With a prefix arg set to real value of current selection.

**** Move and Act
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-<up>)}}} (~helm-follow-action-backward~) ::

  #+findex: helm-follow-action-backward @r{(helm-map)}

  #+kindex: C-<up> @r{(helm-map)}

  Go to previous line and execute persistent action.

- {{{kbd(C-<down>)}}} (~helm-follow-action-forward~) ::

  #+findex: helm-follow-action-forward @r{(helm-map)}

  #+kindex: C-<down> @r{(helm-map)}

  Go to next line and execute persistent action.

**** Resume Previous Session (after quitting)
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x b)}}} (~helm-resume-previous-session-after-quit~) ::

  #+findex: helm-resume-previous-session-after-quit @r{(helm-map)}

  #+kindex: C-x b @r{(helm-map)}

  Resume previous Helm session within a running Helm.

**** Suspend Update of Candidates
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-!)}}} (~helm-toggle-suspend-update~) ::

  #+findex: helm-toggle-suspend-update @r{(helm-map)}

  #+kindex: C-! @r{(helm-map)}

  Enable or disable display update in helm.
  This can be useful for example for quietly writing a complex
  regexp without Helm constantly updating.

**** Helm Refresh
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c C-u)}}} (~helm-refresh~) ::

  #+findex: helm-refresh @r{(helm-map)}

  #+kindex: C-c C-u @r{(helm-map)}

  Force recalculation and update of candidates.

**** COMMENT uncategorized uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~ezmenu-byte-code-function~ ::

  #+findex: ezmenu-byte-code-function

**** Find file after Quit
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x C-f)}}} (~helm-quit-and-find-file~) ::

  #+findex: helm-quit-and-find-file @r{(helm-map)}

  #+kindex: C-x C-f @r{(helm-map)}

  Drop into ~helm-find-files~ from ~helm~.
  If current selection is a buffer or a file, ~helm-find-files~
  from its directory.

**** List Buffers after Quitting
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x C-b)}}} (~helm-resume-list-buffers-after-quit~) ::

  #+findex: helm-resume-list-buffers-after-quit @r{(helm-map)}

  #+kindex: C-x C-b @r{(helm-map)}

  List Helm buffers that can be resumed within a running Helm.

**** Debug Helm
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-h C-d)}}} (~helm-enable-or-switch-to-debug~) ::

  #+findex: helm-enable-or-switch-to-debug @r{(helm-map)}

  #+kindex: C-h C-d @r{(helm-map)}

  First hit enable helm debugging, second hit switch to debug buffer.

*** Commands in library ~helm~ (excludes keymaps)

**** Debug
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-debug-open-last-log~ ::

  #+findex: helm-debug-open-last-log

  Open Helm log file or buffer of last Helm session.

- ~helm-debug-output~ ::

  #+findex: helm-debug-output

  Show all Helm-related variables at this time.

**** Select
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-menu-select-action~ ::

  #+findex: helm-menu-select-action

  (helm-menu-select-action EVENT)

  Popup action menu from mouse-3.

- ~helm-mouse-select-candidate~ ::

  #+findex: helm-mouse-select-candidate

  (helm-mouse-select-candidate EVENT)

**** Resume
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-cycle-resume~ ::

  #+findex: helm-cycle-resume

  Cycle in ~helm-buffers~ list and resume when waiting more than 1.2s.

- {{{kbd(C-x c b)}}} (~helm-resume~) ::

  #+findex: helm-resume

  #+kindex: C-x c b

  (helm-resume ARG)

  Resume a previous Helm session.
  Call with a prefix arg to choose among existing Helm
  buffers (sessions).  When calling from Lisp, specify a
  ~buffer-name~ as a string with ARG.

- ~helm-run-cycle-resume~ ::

  #+findex: helm-run-cycle-resume

  Same as ~helm-cycle-resume~ but intended to be called only from Helm.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-configuration~ ::

  #+findex: helm-configuration

  Customize Helm.

- ~helm-confirm-and-exit-minibuffer~ ::

  #+findex: helm-confirm-and-exit-minibuffer

  Maybe ask for confirmation when exiting helm.
  It is similar to ~minibuffer-complete-and-exit~ adapted to Helm.
  If ~minibuffer-completion-confirm~ value is 'confirm, send
  minibuffer confirm message and exit on next hit.  If
  ~minibuffer-completion-confirm~ value is t, don't exit and send
  message 'no match'.

- ~helm-delete-backward-no-update~ ::

  #+findex: helm-delete-backward-no-update

  (helm-delete-backward-no-update ARG)

  Disable update and delete ARG chars backward.
  Update is reenabled when idle 1s.

- ~helm-toggle-resplit-window~ ::

  #+findex: helm-toggle-resplit-window

  Toggle resplit helm window, vertically or horizontally.

*** Options in library =helm=

**** Min
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-tramp-connection-min-time-diff~ ::

  #+vindex: helm-tramp-connection-min-time-diff

  *Standard Value*: 5

  Value of ~tramp-connection-min-time-diff~ for Helm remote processes.
  If set to zero Helm remote processes are not delayed.

  Setting this to a value less than 5 or disabling it with a zero
  value is risky, however on Emacs versions starting at 24.5 it
  seems it is now possible to disable it.

  Anyway at any time in Helm you can suspend your processes while
  typing by hitting  ~C-!~.

  Only async sources than use a sentinel calling
  ~helm-process-deferred-sentinel-hook~ are affected by this.

**** Windows
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-always-two-windows~ ::

  #+vindex: helm-always-two-windows

  *Standard Value*: nil

  When non-nil Helm uses two windows in this frame.

  I.e. ~helm-buffer~ in one window and ~helm-current-buffer~
  in the other.

  Note: this has no effect when ~helm-split-window-inside-p~ is
  non-nil, or when ~helm-split-window-default-side~ is set to
  ’same.

  When ~helm-autoresize-mode~ is enabled, setting this to nil
  will have no effect.

  Also when non-nil it overrides the effect of
  ~helm-split-window-default-side~ set to ~other~.

**** Functions
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-save-configuration-functions~ ::

  #+vindex: helm-save-configuration-functions

  *Standard Value*:

  #+begin_src emacs-lisp
    (set-window-configuration . current-window-configuration)
  #+end_src

  Functions used to restore or save configurations for frames and windows.
  Specified as a pair of functions, where car is the restore
  function and cdr is the save function.

  To save and restore frame configuration, set this variable to
  ’(set-frame-configuration . current-frame-configuration)

  NOTE: This may not work properly with own-frame minibuffer
  settings.  Older versions saves/restores frame configuration, but
  the default has changed now to avoid flickering.

**** Candidate
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-candidate-number-limit~ ::

  #+vindex: helm-candidate-number-limit

  *Standard Value*: 100

  Global limit for number of candidates displayed.
  When the pattern is empty, the number of candidates shown will be
  as set here instead of the entire list, which may be hundreds or
  thousands.  Since narrowing and filtering rapidly reduces
  available candidates, having a small list will keep the interface
  responsive.

  Set this value to nil for no limit.

- ~helm-candidate-separator~ ::

  #+vindex: helm-candidate-separator

  *Standard Value*: ――――――――――――――――――――――――――――――――――――――

  Candidates separator of ~multiline~ source.

**** Minibuffer
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-delete-minibuffer-contents-from-point~ ::

  #+vindex: helm-delete-minibuffer-contents-from-point

  *Standard Value*: t

  When non-nil, ~helm-delete-minibuffer-contents~ deletes region from ~point~.
  Otherwise it deletes ~minibuffer-contents~.
  See documentation for ~helm-delete-minibuffer-contents~.

- ~helm-prevent-escaping-from-minibuffer~ ::

  #+vindex: helm-prevent-escaping-from-minibuffer

  *Standard Value*: t

  Prevent escaping from minibuffer with ~other-window~ during the Helm session.

**** Width
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-left-margin-width~ ::

  #+vindex: helm-left-margin-width

  *Standard Value*: 0

  ~left-margin-width~ value for the ~helm-buffer~.

**** Delay
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-cycle-resume-delay~ ::

  #+vindex: helm-cycle-resume-delay

  *Standard Value*: 1.0

  Delay used before resuming in ~helm-run-cycle-resume~.

- ~helm-exit-idle-delay~ ::

  #+vindex: helm-exit-idle-delay

  *Standard Value*: 0

  Idle time before exiting minibuffer while Helm is updating.
  Has no affect when helm-buffer is up to date (i.e. exit without
  delay in this condition).

**** Mouse
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-allow-mouse~ ::

  #+vindex: helm-allow-mouse

  *Standard Value*: nil

  Allow mouse usage during the Helm session when non-nil.

  Note that this also allows moving out of minibuffer when clicking
  outside of ~helm-buffer~, so it is up to you to get back to Helm
  by clicking back in ~helm-buffer~ or minibuffer.

**** Source
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-source-names-using-follow~ ::

  #+vindex: helm-source-names-using-follow

  *Standard Value*: nil

  A list of source names to have follow enabled.
  This list of source names will be used only
  when ~helm-follow-mode-persistent~ is non-nil.

  You don’t have to customize this yourself unless you really want
  and know what you are doing, instead just set
  ~helm-follow-mode-persistent~ to non-nil and as soon as you turn
  on or off ~helm-follow-mode~ (C-c C-f) in a source, Helm will
  save or remove source name in this variable.

**** Search
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-case-fold-search~ ::

  #+vindex: helm-case-fold-search

  *Standard Value*: smart

  Adds ’smart’ option to ~case-fold-search~.
  Smart option ignores case for searches as long as there are no
  upper case characters in the pattern.

  Use nil or t to turn off smart behavior and use
  ~case-fold-search~ behavior.

  Default is smart.

  NOTE: Case fold search has no effect when searching asynchronous
  sources, which relies on customized features implemented directly
  into their execution process. See helm-grep.el for an example.

- ~helm-file-name-case-fold-search~ ::

  #+vindex: helm-file-name-case-fold-search

  *Standard Value*: smart

  Local setting of ~helm-case-fold-search~ for reading filenames.

  See ~helm-case-fold-search~ for more info.

**** Action
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-action-at-nth-negative-prefix-key~ ::

  #+vindex: helm-action-at-nth-negative-prefix-key

  *Standard Value*: C-x %d

  The prefix key to execute default action on nth <-n> candidate.

  This is a format spec where %d will be replaced by the candidate
  number.

  NOTE: ~setq~ have no effect until you restart Emacs, use
  customize for immediate effect.

- ~helm-action-at-nth-positive-prefix-key~ ::

  #+vindex: helm-action-at-nth-positive-prefix-key

  *Standard Value*: C-c %d

  The prefix key to execute default action on nth <+n> candidate.

  This is a format spec where %d will be replaced by the candidate
  number.

  NOTE: ~setq~ have no effect until you restart Emacs, use
  customize for immediate effect.

**** Fuzzy
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-fuzzy-match-fn~ ::

  #+vindex: helm-fuzzy-match-fn

  *Standard Value*: helm-fuzzy-match

  The function for fuzzy matching in ~helm-source-sync~ based sources.

- ~helm-fuzzy-matching-highlight-fn~ ::

  #+vindex: helm-fuzzy-matching-highlight-fn

  *Standard Value*: helm-fuzzy-default-highlight-match

  The function to highlight fuzzy matches.

- ~helm-fuzzy-search-fn~ ::

  #+vindex: helm-fuzzy-search-fn

  *Standard Value*: helm-fuzzy-search

  The function for fuzzy matching in ~helm-source-in-buffer~ based sources.

- ~helm-fuzzy-sort-fn~ ::

  #+vindex: helm-fuzzy-sort-fn

  *Standard Value*: helm-fuzzy-matching-default-sort-fn

  The sort transformer function used in fuzzy matching.

**** Autoresize
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-autoresize-max-height~ ::

  #+vindex: helm-autoresize-max-height

  *Standard Value*: 40

  Specify maximum height and defaults to percent of Helm window’s frame height.

  See ~fit-window-to-buffer~ for more infos.

- ~helm-autoresize-min-height~ ::

  #+vindex: helm-autoresize-min-height

  *Standard Value*: 10

  Specify minimum height and defaults to percent of Helm window’s frame height.

  If nil, ~window-min-height~ is used.
  See ~fit-window-to-buffer~ for details.

**** Line
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-header-line-space-before-prompt~ ::

  #+vindex: helm-header-line-space-before-prompt

  *Standard Value*: left-fringe

  Specify the space before prompt in header-line.

  This will be used when ~helm-echo-input-in-header-line~ is
  non-nil.

  Value can be one of the symbols ’left-fringe or ’left-margin or
  an integer specifying the number of spaces before prompt.  Note
  that on input longer that ~window-width~ the continuation string
  will be shown on left side of window without taking care of
  this.

- ~helm-move-to-line-cycle-in-source~ ::

  #+vindex: helm-move-to-line-cycle-in-source

  *Standard Value*: nil

  Cycle to the beginning or end of the list after reaching the bottom or top.
  This applies when using ~helm-next/previous-line~.

**** Input
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-echo-input-in-header-line~ ::

  #+vindex: helm-echo-input-in-header-line

  *Standard Value*: nil

  Send current input to header-line when non-nil.

- ~helm-inherit-input-method~ ::

  #+vindex: helm-inherit-input-method

  *Standard Value*: t

  Inherit ~current-input-method~ from ~current-buffer~ when non-nil.
  The default is to enable this by default and then toggle
  ~toggle-input-method~.

- ~helm-input-idle-delay~ ::

  #+vindex: helm-input-idle-delay

  *Standard Value*: 0.01

  Idle time before updating, specified in seconds.

- ~helm-input-method-verbose-flag~ ::

  #+vindex: helm-input-method-verbose-flag

  *Standard Value*: nil

  The default value for ~input-method-verbose-flag~ used in Helm minibuffer.
  It is nil by default, which does not turn off input method. Helm
  updates and exits without interruption -- necessary for complex
  methods.

  If set to any other value as per ~input-method-verbose-flag~,
  then use ~C-\~ to disable the ~current-input-method~ to exit or
  update Helm.

**** Mode
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm--minor-mode-hook~ ::

  #+vindex: helm--minor-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm--minor-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

- ~helm--remap-mouse-mode-hook~ ::

  #+vindex: helm--remap-mouse-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm--remap-mouse-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

- ~helm-autoresize-mode-hook~ ::

  #+vindex: helm-autoresize-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm-autoresize-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

- ~helm-follow-mode-persistent~ ::

  #+vindex: helm-follow-mode-persistent

  *Standard Value*: nil

  When non-nil, save last state of ~helm-follow-mode~ for the next Emacs sessions.

  Each time you turn on or off ~helm-follow-mode~, the current
  source name will be stored or removed from
  ~helm-source-names-using-follow~.

  Note that this may be disabled in some places where it is unsafe
  to use because persistent action is changing according to
  context.

**** Default
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-sources-using-default-as-input~ ::

  #+vindex: helm-sources-using-default-as-input

  *Standard Value*:

  #+begin_src emacs-lisp
    (helm-source-imenu helm-source-imenu-all helm-source-info-elisp helm-source-etags-select helm-source-man-pages helm-source-occur helm-source-moccur helm-source-grep-ag helm-source-grep-git helm-source-grep)
  #+end_src

  List of Helm sources that need to use ~helm-maybe-use-default-as-input~.
  When a source is a member of this list, default ~thing-at-point~
  will be used as input.

**** Frame Use
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-use-frame-when-more-than-two-windows~ ::

  #+vindex: helm-use-frame-when-more-than-two-windows

  *Standard Value*: nil

  Display Helm buffer in frame when more than two windows.

- ~helm-use-undecorated-frame-option~ ::

  #+vindex: helm-use-undecorated-frame-option

  *Standard Value*: t

  Display Helm frame undecorated when non nil.

  This option has no effect with Emacs versions lower than 26.

**** Frame Color
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-frame-background-color~ ::

  #+vindex: helm-frame-background-color

  *Standard Value*: nil

  Background color for Helm frames, a string.
  Fallback to default face background when nil.

- ~helm-frame-foreground-color~ ::

  #+vindex: helm-frame-foreground-color

  *Standard Value*: nil

  Foreground color for Helm frames, a string.
  Fallback to default face foreground when nil

**** Frame uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-actions-inherit-frame-settings~ ::

  #+vindex: helm-actions-inherit-frame-settings

  *Standard Value*: t

  Actions inherit Helm frame settings of initial command when non nil.

- ~helm-commands-using-frame~ ::

  #+vindex: helm-commands-using-frame

  *Standard Value*: nil

  A list of commands where ~helm-buffer~ is displayed in a frame.

- ~helm-frame-alpha~ ::

  #+vindex: helm-frame-alpha

  *Standard Value*: nil

  Alpha parameter for Helm frames, an integer.
  Fallback to 100 when nil.

- ~helm-full-frame~ ::

  #+vindex: helm-full-frame

  *Standard Value*: nil

  Use current window for showing candidates.
  If t, then Helm does not pop-up a new window.

**** Window When
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-use-frame-when-dedicated-window~ ::

  #+vindex: helm-use-frame-when-dedicated-window

  *Standard Value*: nil

  Display Helm buffer in frame when Helm is started from a dedicated window.

**** Window Other
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-show-action-window-other-window~ ::

  #+vindex: helm-show-action-window-other-window

  *Standard Value*: nil

  Show action buffer beside ~helm-buffer~ when non-nil.

  If nil don’t split and replace helm-buffer by the action buffer
  in same window.
  If left display the action buffer at the left of helm-buffer.
  If right or any other value, split at right.

  Note that this may not fit well with some Helm window
  configurations, so it have only effect when
  ~helm-always-two-windows~ is non-nil.

**** Window Split
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-reuse-last-window-split-state~ ::

  #+vindex: helm-reuse-last-window-split-state

  *Standard Value*: nil

  Use the same state of window split, vertical or horizontal.
  ~helm-toggle-resplit-window~ for the next helm session will use
  the same window scheme as the previous session unless
  ~helm-split-window-default-side~ is ’same or ’other.

- ~helm-split-window-default-side~ ::

  #+vindex: helm-split-window-default-side

  *Standard Value*: below

  The default side to display ~helm-buffer~.
  Must be one acceptable arg for ~split-window~ SIDE,
  that is ~below~, ~above~, ~left~ or ~right~.

  Other acceptable values are ~same~ which always displays
  ~helm-buffer~ in current window and ~other~ that displays
  ~helm-buffer~ below if only one window or in
  ~other-window-for-scrolling~ when available.

  A nil value has same effect as ~below~. If ~helm-full-frame~ is
  non-nil, it take precedence over this setting.

  See also ~helm-split-window-inside-p~ and
  ~helm-always-two-windows~ that take precedence over this.

  NOTE: this has no effect if
  ~helm-split-window-preferred-function~ is not
  ~helm-split-window-default-fn~ unless this new function can
  handle this.

- ~helm-split-window-in-side-p~ ::

  #+vindex: helm-split-window-in-side-p

  *Standard Value*: nil

  Force split inside selected window when non-nil.
  See also ~helm-split-window-default-side~.

  NOTE: this has no effect if
  ~helm-split-window-preferred-function~ is not
  ~helm-split-window-default-fn~ unless this new function can
  handle this.

- ~helm-split-window-inside-p~ ::

  #+vindex: helm-split-window-inside-p

  *Standard Value*: nil

  Force split inside selected window when non-nil.
  See also ~helm-split-window-default-side~.

  NOTE: this has no effect if
  ~helm-split-window-preferred-function~ is not
  ~helm-split-window-default-fn~ unless this new function can
  handle this.

- ~helm-split-window-other-side-when-one-window~ ::

  #+vindex: helm-split-window-other-side-when-one-window

  *Standard Value*: below

  The default side to display ~helm-buffer~ when (1)
  ~helm-split-window-default-side~ is ’other and (2)
  the current frame only has one window. Possible values
  are acceptable args for ~split-window~ SIDE, that is ~below~,
  ~above~, ~left~ or ~right~.

  If ~helm-full-frame~ is non-nil, it takes precedence over this
  setting.

  See also ~helm-split-window-inside-p~ and ~helm-always-two-windows~ that
  takes precedence over this.

  NOTE: this has no effect if
  ~helm-split-window-preferred-function~ is not
  ~helm-split-window-default-fn~ unless this new function can
  handle this.

- ~helm-split-window-preferred-function~ ::

  #+vindex: helm-split-window-preferred-function

  *Standard Value*: helm-split-window-default-fn

  Default function used for splitting window.

**** Window uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-completion-window-scroll-margin~ ::

  #+vindex: helm-completion-window-scroll-margin

  *Standard Value*: 5

  ~scroll-margin~ to use for Helm completion window.
  Set to 0 to disable.
  NOTE: This has no effect when ~helm-display-source-at-screen-top~
  id is non-nil.

**** Display Line
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-display-header-line~ ::

  #+vindex: helm-display-header-line

  *Standard Value*: t

  Display header-line when non nil.

- ~helm-display-line-numbers-mode-hook~ ::

  #+vindex: helm-display-line-numbers-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm-display-line-numbers-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

**** Display Function
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-display-function~ ::

  #+vindex: helm-display-function

  *Standard Value*: helm-default-display-buffer

  Function used to display ~helm-buffer~.

  Local value in ~helm-buffer~ will take precedence on this default
  value.  Commands that are in ~helm-commands-using-frame~ will have
  ~helm-buffer~ displayed in frame, ~helm-display-function~ being
  ignored.
  If no local value is found and current command is not one of
  ~helm-commands-using-frame~ use this default value.
  The function in charge of deciding which value use is
  ~helm-resolve-display-function~.

  To set it locally to ~helm-buffer~ in Helm sources use
  ~helm-set-local-variable~ in init function or use
  :display-function slot in ~helm~ call.

**** Display Default
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-default-prompt-display-function~ ::

  #+vindex: helm-default-prompt-display-function

  *Standard Value*: helm-set-default-prompt-display

  The function to use to set face of fake cursor in header-line.

**** Display Buffer Width
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-display-buffer-width~ ::

  #+vindex: helm-display-buffer-width

  *Standard Value*: 72

  Frame width when displaying helm-buffer in own frame.

**** Display Buffer Height
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-display-buffer-height~ ::

  #+vindex: helm-display-buffer-height

  *Standard Value*: 20

  Frame height when displaying helm-buffer in own frame.

**** Display Buffer Default
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-default-display-buffer-alist~ ::

  #+vindex: helm-default-display-buffer-alist

  *Standard Value*: nil

  Additional alist to pass to ~display-buffer~ action.
  See (info "(elisp) Action Alists for Buffer Display").

  It has no effect when ~helm-always-two-windows~ is non-nil and
  may override other settings like ~helm-split-window-inside-p~.
  Note that window-height and window-width have to be configured in
  ~helm-display-buffer-height~ and ~helm-display-buffer-width~.

- ~helm-default-display-buffer-functions~ ::

  #+vindex: helm-default-display-buffer-functions

  *Standard Value*: nil

  Action functions to pass to ~display-buffer~.
  See (info "(elisp) Action Functions for Buffer Display").

  It has no effect when ~helm-always-two-windows~ is non-nil and
  may override other settings like ~helm-split-window-inside-p~.

- ~helm-display-buffer-default-height~ ::

  #+vindex: helm-display-buffer-default-height

  *Standard Value*: nil

  Initial height of ~helm-buffer~, specified as an integer or a function.

  The function should take one arg and be responsible for re-sizing
  the window; function’s return value is ignored.  Note that this
  has no effect when the split is vertical.  See ~display-buffer~
  for more info.

- ~helm-display-buffer-default-width~ ::

  #+vindex: helm-display-buffer-default-width

  *Standard Value*: nil

  Initial width of ~helm-buffer~, specified as an integer or a function.

  The function should take one arg and be responsible for re-sizing
  the window; function’s return value is ignored.  Note that this
  have no effect when the split is horizontal.  See ~display-buffer~
  for more info.

**** Display Buffer uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-display-buffer-reuse-frame~ ::

  #+vindex: helm-display-buffer-reuse-frame

  *Standard Value*: nil

  When non nil Helm frame is not deleted and reused in next sessions.

  This was used to workaround a bug in Emacs where frames where
  popping up slowly, now that the bug have been fixed upstream
  (emacs-27) probably you don’t want to use this any more.  On
  emacs-26 set ~x-wait-for-event-timeout~ to nil to have your
  frames popping up fast.

**** Display uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-display-source-at-screen-top~ ::

  #+vindex: helm-display-source-at-screen-top

  *Standard Value*: t

  Display candidates at the top of screen.
  This happens with ~helm-next-source~ and ~helm-previous-source~.
  NOTE: When non-nil (default), disable
  ~helm-completion-window-scroll-margin~.

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm--remap-mouse-mode~ ::

  #+vindex: helm--remap-mouse-mode

  *Standard Value*: nil

  (helm--remap-mouse-mode &optional ARG)

  [INTERNAL] Prevent escaping helm minibuffer with mouse clicks.
  Do nothing when used outside of helm context.

  If called interactively, toggle ~Helm--Remap-Mouse mode~.  If the
  prefix argument is positive, enable the mode, and if it is zero
  or negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

  WARNING: Do not use this mode yourself, it is internal to Helm.

- ~helm-autoresize-mode~ ::

  #+vindex: helm-autoresize-mode

  *Standard Value*: nil

  (helm-autoresize-mode &optional ARG)

  Auto resize helm window when enabled.
  Helm window is re-sized according to ~helm-autoresize-max-height~
  and ~helm-autoresize-min-height~.  Note that when this mode is
  enabled, Helm behaves as if ~helm-always-two-windows~ is enabled.

  If called interactively, toggle ~Helm-Autoresize mode~.  If the
  prefix argument is positive, enable the mode, and if it is zero
  or negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

  See ~fit-window-to-buffer~ for more infos.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-debug-root-directory~ ::

  #+vindex: helm-debug-root-directory

  *Standard Value*: nil

  When non-nil, save Helm log messages to a file in this directory.
  When nil log messages are saved to a buffer instead.  Log message
  are saved only when ~helm-debug~ is non-nil, so setting this
  doesn’t enable debugging by itself.

  See ~helm-log-save-maybe~ for more info.

- ~helm-samewindow~ ::

  #+vindex: helm-samewindow

  *Standard Value*: nil

  Use current window for showing candidates.
  If t, then Helm does not pop-up a new window.

- ~helm-truncate-lines~ ::

  #+vindex: helm-truncate-lines

  *Standard Value*: nil

  The value of ~truncate-lines~ when Helm starts.
  You can toggle later ~truncate-lines~ with
  C-c >.

*** Hooks in library =helm=

**** Run
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-log-run-hook~ ::

  #+vindex: helm-log-run-hook

  *Standard Value*:

**** Exit
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-confirm-and-exit-hook~ ::

  #+vindex: helm-confirm-and-exit-hook

  *Standard Value*:

**** Temp
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~with-helm-temp-hook~ ::

  #+vindex: with-helm-temp-hook

  *Standard Value*:

**** Hooks
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm--run-init-hooks~ ::

  #+vindex: helm--run-init-hooks

  *Standard Value*:

- ~helm--temp-hooks~ ::

  #+vindex: helm--temp-hooks

  *Standard Value*:

  #+begin_src emacs-lisp
    ((helm--hook94 . helm-after-update-hook))
  #+end_src

  Store temporary hooks added by ~with-helm-temp-hook~.

**** Minibuffer
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-exit-minibuffer-hook~ ::

  #+vindex: helm-exit-minibuffer-hook

  *Standard Value*:

  #+begin_src emacs-lisp
    (helm-files-save-file-name-history)
  #+end_src

  Runs just before exiting the minibuffer.

  This hook runs when Helm exits the minibuffer normally (e.g., via
  candidate selection), but does NOT run if Helm exits the
  minibuffer abnormally (e.g. via ~helm-keyboard-quit~).

- ~helm-minibuffer-set-up-hook~ ::

  #+vindex: helm-minibuffer-set-up-hook

  *Standard Value*: nil

  Hook that runs at minibuffer initialization.
  A hook useful for modifying minibuffer settings in Helm.

  An example that hides the minibuffer when using
  ~helm-echo-input-in-header-line~:

	(add-hook ’helm-minibuffer-set-up-hook #’helm-hide-minibuffer-maybe)

  Note that we check ~helm-echo-input-in-header-line~ value
  from ~helm-buffer~ which allows detecting possible local
  value of this var.

**** Autoresize
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm--autoresize-hook~ ::

  #+vindex: helm--autoresize-hook

  *Standard Value*:

**** Before
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-before-initialize-hook~ ::

  #+vindex: helm-before-initialize-hook

  *Standard Value*: nil

  Runs before Helm initialization.
  This hook runs before init functions in ~helm-sources~, which is
  before creation of ~helm-buffer~.  Set local variables for
  ~helm-buffer~ that need a value from ~current-buffer~ with
  ~helm-set-local-variable~.

- ~helm-move-selection-before-hook~ ::

  #+vindex: helm-move-selection-before-hook

  *Standard Value*: nil

  Runs before moving selection in ~helm-buffer~.

**** Update
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-before-update-hook~ ::

  #+vindex: helm-before-update-hook

  *Standard Value*: nil

  Runs before updating the Helm buffer with the new input pattern.

- ~helm-update-hook~ ::

  #+vindex: helm-update-hook

  *Standard Value*:

  #+begin_src emacs-lisp
    (helm--maybe-update-keymap helm-match-line-cleanup-maybe helm-revive-visible-mark helm-confirm-and-exit-hook)
  #+end_src

  Runs after updating the Helm buffer with the new input pattern.

**** Action
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-before-action-hook~ ::

  #+vindex: helm-before-action-hook

  *Standard Value*:

  #+begin_src emacs-lisp
    (helm-ff-before-action-hook-fn)
  #+end_src

  Runs before executing action.
  Unlike ~helm-cleanup-hook~, this hook runs before Helm closes the
  minibuffer and also before performing an action.

- ~helm-select-action-hook~ ::

  #+vindex: helm-select-action-hook

  *Standard Value*: nil

  Runs when opening the action buffer.

**** Mode
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm--minor-mode-hook~ ::

  #+vindex: helm--minor-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm--minor-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

- ~helm--remap-mouse-mode-hook~ ::

  #+vindex: helm--remap-mouse-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm--remap-mouse-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

- ~helm-autoresize-mode-hook~ ::

  #+vindex: helm-autoresize-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm-autoresize-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

- ~helm-display-line-numbers-mode-hook~ ::

  #+vindex: helm-display-line-numbers-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm-display-line-numbers-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

- ~helm-major-mode-hook~ ::

  #+vindex: helm-major-mode-hook

  *Standard Value*: nil

  Hook run after entering Hmm mode.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

**** After Action
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-after-action-hook~ ::

  #+vindex: helm-after-action-hook

  *Standard Value*:

  #+begin_src emacs-lisp
    (helm-match-line-cleanup-pulse)
  #+end_src

  Runs after executing action.

- ~helm-after-persistent-action-hook~ ::

  #+vindex: helm-after-persistent-action-hook

  *Standard Value*:

  #+begin_src emacs-lisp
    (helm-find-files--reset-level-tree helm-match-line-update helm-persistent-autoresize-hook)
  #+end_src

  Runs after executing persistent action.

**** After Update
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-after-update-hook~ ::

  #+vindex: helm-after-update-hook

  *Standard Value*:

  #+begin_src emacs-lisp
    (helm--maybe-update-keymap helm-match-line-cleanup-maybe helm-revive-visible-mark helm-confirm-and-exit-hook)
  #+end_src

  Runs after updating the Helm buffer with the new input pattern.

- ~with-helm-after-update-hook~ ::

  #+vindex: with-helm-after-update-hook

  *Standard Value*:

**** After uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-after-initialize-hook~ ::

  #+vindex: helm-after-initialize-hook

  *Standard Value*:

  #+begin_src emacs-lisp
    (helm-reset-yank-point)
  #+end_src

  Runs after Helm initialization.
  This hook runs after ~helm-buffer~ is created but not from
  ~helm-buffer~.  The hook needs to specify in which buffer to
  run.

- ~helm-after-preselection-hook~ ::

  #+vindex: helm-after-preselection-hook

  *Standard Value*: nil

  Runs after pre-selection in ~helm-buffer~.

- ~helm-move-selection-after-hook~ ::

  #+vindex: helm-move-selection-after-hook

  *Standard Value*: nil

  Runs after moving selection in ~helm-buffer~.

- ~helm-resume-after-hook~ ::

  #+vindex: helm-resume-after-hook

  *Standard Value*:

  #+begin_src emacs-lisp
    (helm-ff--update-resume-after-hook)
  #+end_src

  A hook that runs after resuming a Helm session.
  The hook should takes one arg SOURCES.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-async-outer-limit-hook~ ::

  #+vindex: helm-async-outer-limit-hook

  *Standard Value*: nil

  A hook that runs in async sources when process output comes out of ~candidate-number-limit~.
  Should be set locally to ~helm-buffer~ with ~helm-set-local-variable~.

- ~helm-cleanup-hook~ ::

  #+vindex: helm-cleanup-hook

  *Standard Value*:

  #+begin_src emacs-lisp
    (helm-ff-save-history helm-find-files--reset-level-tree helm-match-line-cleanup helm-handle-winner-boring-buffers helm-reset-yank-point)
  #+end_src

  Runs after exiting the minibuffer and before performing an
  action.

  This hook runs even if Helm exits the minibuffer abnormally (e.g.
  via ~helm-keyboard-quit~).

- ~helm-process-deferred-sentinel-hook~ ::

  #+vindex: helm-process-deferred-sentinel-hook

  *Standard Value*:

- ~helm-quit-hook~ ::

  #+vindex: helm-quit-hook

  *Standard Value*: nil

  A hook that runs when quitting Helm.

- ~helm-window-configuration-hook~ ::

  #+vindex: helm-window-configuration-hook

  *Standard Value*: nil

  Runs when switching to and from the action buffer.
  Should run also at end of ~helm-display-function~.

** Library: helm-adaptive

*** Modes in library ~helm-adaptive~

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-adaptive-mode~ ::

  #+findex: helm-adaptive-mode

  (helm-adaptive-mode &optional ARG)

  Toggle adaptive sorting in all sources.

  If called interactively, toggle ~Helm-Adaptive mode~.  If the
  prefix argument is positive, enable the mode, and if it is zero
  or negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

*** Commands in library ~helm-adaptive~ (excludes keymaps)

**** History
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-adaptive-save-history~ ::

  #+findex: helm-adaptive-save-history

  (helm-adaptive-save-history &optional ARG)

  Save history information to the file given by ~helm-adaptive-history-file~.

- ~helm-reset-adaptive-history~ ::

  #+findex: helm-reset-adaptive-history

  Delete all ~helm-adaptive-history~ and his file.
  Useful when you have a old or corrupted
  ~helm-adaptive-history-file~.

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-adaptive-mode~ ::

  #+findex: helm-adaptive-mode

  (helm-adaptive-mode &optional ARG)

  Toggle adaptive sorting in all sources.

  If called interactively, toggle ~Helm-Adaptive mode~.  If the
  prefix argument is positive, enable the mode, and if it is zero
  or negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

*** Options in library =helm-adaptive=

**** Mode
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-adaptive-mode-hook~ ::

  #+vindex: helm-adaptive-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm-adaptive-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

**** History
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-adaptive-history-file~ ::

  #+vindex: helm-adaptive-history-file

  *Standard Value*: ~/.emacs.d/helm-adaptive-history

  Path of file where history information is stored.
  When nil history is not saved nor restored after Emacs restart
  unless you save/restore ~helm-adaptive-history~ with something
  else like psession or desktop.

- ~helm-adaptive-history-length~ ::

  #+vindex: helm-adaptive-history-length

  *Standard Value*: 50

  Maximum number of candidates stored for a source.

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-adaptive-mode~ ::

  #+vindex: helm-adaptive-mode

  *Standard Value*: nil

  (helm-adaptive-mode &optional ARG)

  Toggle adaptive sorting in all sources.

  If called interactively, toggle ~Helm-Adaptive mode~.  If the
  prefix argument is positive, enable the mode, and if it is zero
  or negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-adaptive-sort-by-frequent-recent-usage~ ::

  #+vindex: helm-adaptive-sort-by-frequent-recent-usage

  *Standard Value*: t

  Try to sort on an average of frequent and recent usage when non-nil.

  When nil sort on frequency usage only.

  Only frequency:
  When candidate have low frequency, you have to hit on it many
  times to make it going up on top.

  Frequency+recent:
  Even with a low frequency, candidate go up on top. If a candidate
  have a high frequency but it is not used since some time, it goes
  down slowly, but as soon you reuse it it go up on top quickly.

*** Hooks in library =helm-adaptive=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-adaptive-mode-hook~ ::

  #+vindex: helm-adaptive-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm-adaptive-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

** Library: helm-bookmark

*** Commands in keymap ~helm-bookmark-find-files-map~

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x C-d)}}} (~helm-bookmark-run-browse-project~) ::

  #+findex: helm-bookmark-run-browse-project @r{(helm-bookmark-find-files-map)}

  #+kindex: C-x C-d @r{(helm-bookmark-find-files-map)}

  Run ~helm-bookmark-browse-project~ from keyboard.

*** Commands in keymap ~helm-bookmark-map~

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-d)}}} (~helm-bookmark-run-delete~) ::

  #+findex: helm-bookmark-run-delete @r{(helm-bookmark-map)}

  #+kindex: C-d @r{(helm-bookmark-map)}

  Delete bookmark from keyboard.

- {{{kbd(M-e)}}} (~helm-bookmark-run-edit~) ::

  #+findex: helm-bookmark-run-edit @r{(helm-bookmark-map)}

  #+kindex: M-e @r{(helm-bookmark-map)}

  Run ~helm-bookmark-edit-bookmark~ from keyboard.

- {{{kbd(C-c C-o)}}} (~helm-bookmark-run-jump-other-frame~) ::

  #+findex: helm-bookmark-run-jump-other-frame @r{(helm-bookmark-map)}

  #+kindex: C-c C-o @r{(helm-bookmark-map)}

  Jump to bookmark other frame from keyboard.

- {{{kbd(C-c o)}}} (~helm-bookmark-run-jump-other-window~) ::

  #+findex: helm-bookmark-run-jump-other-window @r{(helm-bookmark-map)}

  #+kindex: C-c o @r{(helm-bookmark-map)}

  Jump to bookmark from keyboard.

- {{{kbd(C-])}}} (~helm-bookmark-toggle-filename~) ::

  #+findex: helm-bookmark-toggle-filename @r{(helm-bookmark-map)}

  #+kindex: C-] @r{(helm-bookmark-map)}

  Toggle bookmark location visibility.

*** Commands in library ~helm-bookmark~ (excludes keymaps)

**** Bookmarks
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-bookmarks~ ::

  #+findex: helm-bookmarks

  Preconfigured ~helm~ for bookmarks.

- {{{kbd(C-x c C-x r b)}}} (~helm-filtered-bookmarks~) ::

  #+findex: helm-filtered-bookmarks

  #+kindex: C-x c C-x r b

  Preconfigured ~helm~ for bookmarks (filtered by category).
  Optional source ~helm-source-bookmark-addressbook~ is loaded only
  if external addressbook-bookmark package is installed.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-bookmark-rename~ ::

  #+findex: helm-bookmark-rename

  (helm-bookmark-rename OLD &optional NEW BATCH)

  Change bookmark's name from OLD to NEW.
  Interactively:
   If called from the keyboard, then prompt for OLD.
   If called from the menubar, select OLD from a menu.
  If NEW is nil, then prompt for its string value.

  If BATCH is non-nil, then do not rebuild the menu list.

  While the user enters the new name, repeated ~C-w~ inserts
  consecutive words from the buffer into the new bookmark name.

*** Options in library =helm-bookmark=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-bookmark-default-filtered-sources~ ::

  #+vindex: helm-bookmark-default-filtered-sources

  *Standard Value*:

  #+begin_src emacs-lisp
    (helm-source-bookmark-org helm-source-bookmark-files&dirs helm-source-bookmark-helm-find-files helm-source-bookmark-info helm-source-bookmark-gnus helm-source-bookmark-man helm-source-bookmark-images helm-source-bookmark-w3m helm-source-bookmark-uncategorized helm-source-bookmark-set)
  #+end_src

  List of sources to use in ~helm-filtered-bookmarks~.

- ~helm-bookmark-show-location~ ::

  #+vindex: helm-bookmark-show-location

  *Standard Value*: nil

  Show location of bookmark on display.

** Library: helm-buffers

*** Commands in keymap ~helm-buffer-map~

**** Control what you see
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c a)}}} (~helm-buffers-toggle-show-hidden-buffers~) ::

  #+findex: helm-buffers-toggle-show-hidden-buffers @r{(helm-buffer-map)}

  #+kindex: C-c a @r{(helm-buffer-map)}

- {{{kbd(C-])}}} (~helm-toggle-buffers-details~) ::

  #+findex: helm-toggle-buffers-details @r{(helm-buffer-map)}

  #+kindex: C-] @r{(helm-buffer-map)}

**** Browse Project
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x C-d)}}} (~helm-buffers-run-browse-project~) ::

  #+findex: helm-buffers-run-browse-project @r{(helm-buffer-map)}

  #+kindex: C-x C-d @r{(helm-buffer-map)}

  Run ~helm-buffers-browse-project~ from key.

**** Switch to Buffer in other frame, window or tab
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c C-o)}}} (~helm-buffer-switch-other-frame~) ::

  #+findex: helm-buffer-switch-other-frame @r{(helm-buffer-map)}

  #+kindex: C-c C-o @r{(helm-buffer-map)}

  Run switch to other frame action from ~helm-source-buffers-list~.

- {{{kbd(C-c o)}}} (~helm-buffer-switch-other-window~) ::

  #+findex: helm-buffer-switch-other-window @r{(helm-buffer-map)}

  #+kindex: C-c o @r{(helm-buffer-map)}

  Run switch to other window action from ~helm-source-buffers-list~.

- {{{kbd(C-c C-t)}}} (~helm-buffers-switch-to-buffer-new-tab~) ::

  #+findex: helm-buffers-switch-to-buffer-new-tab @r{(helm-buffer-map)}

  #+kindex: C-c C-t @r{(helm-buffer-map)}

  Run switch to buffer in other tab action from ~helm-source-buffers-list~.

**** Run Occur
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-s)}}} (~helm-buffers-run-occur~) ::

  #+findex: helm-buffers-run-occur @r{(helm-buffer-map)}

  #+kindex: C-s @r{(helm-buffer-map)}

  Run ~helm-multi-occur-as-action~ by key.

**** Query Replace on Buffers' contents
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-%)}}} (~helm-buffer-run-query-replace~) ::

  #+findex: helm-buffer-run-query-replace @r{(helm-buffer-map)}

  #+kindex: M-% @r{(helm-buffer-map)}

  Run Query replace action from ~helm-source-buffers-list~.

- {{{kbd(C-M-%)}}} (~helm-buffer-run-query-replace-regexp~) ::

  #+findex: helm-buffer-run-query-replace-regexp @r{(helm-buffer-map)}

  #+kindex: C-M-% @r{(helm-buffer-map)}

  Run Query replace regexp action from ~helm-source-buffers-list~.

**** Mark similar Buffers
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-M-SPC)}}} (~helm-buffers-mark-similar-buffers~) ::

  #+findex: helm-buffers-mark-similar-buffers @r{(helm-buffer-map)}

  #+kindex: C-M-SPC @r{(helm-buffer-map)}

  Mark All buffers that have same property ~type~ than current.
  I.e. same color.

**** Save Buffer
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x C-s)}}} (~helm-buffer-save-persistent~) ::

  #+findex: helm-buffer-save-persistent @r{(helm-buffer-map)}

  #+kindex: C-x C-s @r{(helm-buffer-map)}

  Save buffer without quitting Helm.

- {{{kbd(C-x s)}}} (~helm-buffer-run-save-some-buffers~) ::

  #+findex: helm-buffer-run-save-some-buffers @r{(helm-buffer-map)}

  #+kindex: C-x s @r{(helm-buffer-map)}

  Save unsaved file buffers without quitting Helm.

**** Run Diff and friends
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-=)}}} (~helm-buffer-diff-persistent~) ::

  #+findex: helm-buffer-diff-persistent @r{(helm-buffer-map)}

  #+kindex: C-= @r{(helm-buffer-map)}

  Toggle diff buffer without quitting helm.

- {{{kbd(C-c =)}}} (~helm-buffer-run-ediff~) ::

  #+findex: helm-buffer-run-ediff @r{(helm-buffer-map)}

  #+kindex: C-c = @r{(helm-buffer-map)}

  Run ediff action from ~helm-source-buffers-list~.

- {{{kbd(M-=)}}} (~helm-buffer-run-ediff-merge~) ::

  #+findex: helm-buffer-run-ediff-merge @r{(helm-buffer-map)}

  #+kindex: M-= @r{(helm-buffer-map)}

  Run ediff action from ~helm-source-buffers-list~.

**** Kill Buffers
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c d)}}} (~helm-buffer-run-kill-persistent~) ::

  #+findex: helm-buffer-run-kill-persistent @r{(helm-buffer-map)}

  #+kindex: C-c d @r{(helm-buffer-map)}

  Kill buffer without quitting Helm.

- {{{kbd(M-D)}}} (~helm-buffer-run-kill-buffers~) ::

  #+findex: helm-buffer-run-kill-buffers @r{(helm-buffer-map)}

  #+kindex: M-D @r{(helm-buffer-map)}

  Run kill buffer action from ~helm-source-buffers-list~.

**** Rename Buffer
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-R)}}} (~helm-buffer-run-rename-buffer~) ::

  #+findex: helm-buffer-run-rename-buffer @r{(helm-buffer-map)}

  #+kindex: M-R @r{(helm-buffer-map)}

  Run rename buffer action from ~helm-source-buffers-list~.

**** Revert Buffer
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-G)}}} (~helm-buffer-revert-persistent~) ::

  #+findex: helm-buffer-revert-persistent @r{(helm-buffer-map)}

  #+kindex: M-G @r{(helm-buffer-map)}

  Revert buffer without quitting helm.

**** Goto line
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-g M-g)}}} (~helm-buffer-run-goto-line~) ::

  #+findex: helm-buffer-run-goto-line @r{(helm-buffer-map)}

  #+kindex: M-g M-g @r{(helm-buffer-map)}

  Switch to buffer at line number.

**** Run ZGrep
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-g s)}}} (~helm-buffer-run-zgrep~) ::

  #+findex: helm-buffer-run-zgrep @r{(helm-buffer-map)}

  #+kindex: M-g s @r{(helm-buffer-map)}

  Run Grep action from ~helm-source-buffers-list~.

*** Commands in keymap ~helm-buffer-not-found-map~

**** Create new Buffers in other frame or window
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c C-o)}}} (~helm-buffers-not-found-run-switch-of~) ::

  #+findex: helm-buffers-not-found-run-switch-of @r{(helm-buffer-not-found-map)}

  #+kindex: C-c C-o @r{(helm-buffer-not-found-map)}

  Run create new buffer other frame action from keymap.

- {{{kbd(C-c o)}}} (~helm-buffers-not-found-run-switch-ow~) ::

  #+findex: helm-buffers-not-found-run-switch-ow @r{(helm-buffer-not-found-map)}

  #+kindex: C-c o @r{(helm-buffer-not-found-map)}

  Run create new buffer other window action from keymap.

*** Commands in library ~helm-buffers~ (excludes keymaps)

**** Mini
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-mini~ ::

  #+findex: helm-mini

  Preconfigured ~helm~ displaying ~helm-mini-default-sources~.

- ~helm-quit-and-helm-mini~ ::

  #+findex: helm-quit-and-helm-mini

  Drop into ~helm-mini~ from ~helm~.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-buffer-run-grep~ ::

  #+findex: helm-buffer-run-grep

  Run Grep action from ~helm-source-buffers-list~.

- {{{kbd(C-x c C-x C-b)}}} ::
- {{{kbd(C-x C-b)}}} (~helm-buffers-list~) ::

  #+findex: helm-buffers-list

  #+kindex: C-x c C-x C-b
  #+kindex: C-x C-b

  Preconfigured ~helm~ to list buffers.

*** Options in library =helm-buffers=

**** Buffer List
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-boring-buffer-regexp-list~ ::

  #+vindex: helm-boring-buffer-regexp-list

  *Standard Value*:

  #+begin_src emacs-lisp
    ("\\` " "\\`\\*helm" "\\`\\*Echo Area" "\\`\\*Minibuf")
  #+end_src

  The regexp list that match boring buffers.
  Buffer candidates matching these regular expression will be
  filtered from the list of candidates if the
  ~helm-skip-boring-buffers~ candidate transformer is used.

- ~helm-buffer-list-reorder-fn~ ::

  #+vindex: helm-buffer-list-reorder-fn

  *Standard Value*: helm-buffers-reorder-buffer-list

  A function in charge of ordering the initial buffer list.
  It takes two arguments VISIBLES buffers and OTHERS buffers.
  Arg VISIBLES handles the buffers visibles in this frame.
  Arg OTHERS handles all the other buffers.
  You can write a function that reorder VISIBLES and OTHERS as you
  want.
  Default function returns OTHERS buffers on top and VISIBLES
  buffer at the end.  See ~helm-buffers-reorder-buffer-list~.

- ~helm-white-buffer-regexp-list~ ::

  #+vindex: helm-white-buffer-regexp-list

  *Standard Value*: nil

  The regexp list of not boring buffers.
  These buffers will be displayed even if they match one of
  ~helm-boring-buffer-regexp-list~.

**** Buffer uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-buffer--pretty-names~ ::

  #+vindex: helm-buffer--pretty-names

  *Standard Value*:

  #+begin_src emacs-lisp
    ((dired-mode . "Dired")
     (lisp-interaction-mode . "Lisp Inter"))
  #+end_src

  An alist specifying pretty names for modes.
  Most of the time buffer’s ~mode-name~ is a string so no need to
  add it here as there is no need to compute it, but sometimes it
  may be a mode-line specification which may be costly to compute,
  in this case add here the pretty name as a string to avoid this
  costly computation.  Also if some pretty names are too long you
  can add your own abbreviation here.

- ~helm-buffer-details-flag~ ::

  #+vindex: helm-buffer-details-flag

  *Standard Value*: t

  Always show details in buffer list when non-nil.

- ~helm-buffer-max-length~ ::

  #+vindex: helm-buffer-max-length

  *Standard Value*: 20

  Max length of buffer names before truncate.
  When disabled (nil) use the longest ~buffer-name~ length found.

- ~helm-buffer-skip-remote-checking~ ::

  #+vindex: helm-buffer-skip-remote-checking

  *Standard Value*: nil

  Ignore checking for ~file-exists-p~ on remote files.

**** Buffers uncategorized uncategorized uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-buffers-column-separator~ ::

  #+vindex: helm-buffers-column-separator

  *Standard Value*:

  Separator for columns in buffer listing.

- ~helm-buffers-end-truncated-string~ ::

  #+vindex: helm-buffers-end-truncated-string

  *Standard Value*: ...

  The string to display at end of truncated buffer names.

- ~helm-buffers-favorite-modes~ ::

  #+vindex: helm-buffers-favorite-modes

  *Standard Value*:

  #+begin_src emacs-lisp
    (lisp-interaction-mode emacs-lisp-mode text-mode org-mode)
  #+end_src

  List of preferred mode to open new buffers with.

- ~helm-buffers-fuzzy-matching~ ::

  #+vindex: helm-buffers-fuzzy-matching

  *Standard Value*: nil

  Fuzzy matching buffer names when non-nil.
  Only buffer names are fuzzy matched when this is enabled,
  ~major-mode~ matching is not affected by this.

- ~helm-buffers-left-margin-width~ ::

  #+vindex: helm-buffers-left-margin-width

  *Standard Value*: 0

  ~left-margin-width~ value for ~helm-mini~ and ~helm-buffers-list~.

- ~helm-buffers-maybe-switch-to-tab~ ::

  #+vindex: helm-buffers-maybe-switch-to-tab

  *Standard Value*: nil

  Switch to buffer in its tab when non nil.
  This has no effect when ~tab-bar-mode~ is not available.

- ~helm-buffers-sort-fn~ ::

  #+vindex: helm-buffers-sort-fn

  *Standard Value*: helm-fuzzy-matching-default-sort-fn

  The sort function to use in ~helm-buffers-list~.

  Default to ~helm-fuzzy-sort-fn~ you can use
  ~helm-fuzzy-matching-sort-fn-preserve-ties-order~ as alternative if
  you want to keep the recentest order when narrowing candidates.

- ~helm-buffers-truncate-lines~ ::

  #+vindex: helm-buffers-truncate-lines

  *Standard Value*: t

  Truncate lines in ~helm-buffers-list~ when non-nil.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-mini-default-sources~ ::

  #+vindex: helm-mini-default-sources

  *Standard Value*:

  #+begin_src emacs-lisp
    (helm-source-buffers-list helm-source-recentf helm-source-buffer-not-found)
  #+end_src

  Default sources list used in ~helm-mini~.

  When adding a source here it is up to you to ensure the library
  of this source is accessible and properly loaded.

** Library: helm-color

*** Commands in keymap ~helm-color-map~

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c n)}}} (~helm-color-run-insert-name~) ::

  #+findex: helm-color-run-insert-name @r{(helm-color-map)}

  #+kindex: C-c n @r{(helm-color-map)}

  Insert name of color from ~helm-source-colors~.

- {{{kbd(C-c r)}}} (~helm-color-run-insert-rgb~) ::

  #+findex: helm-color-run-insert-rgb @r{(helm-color-map)}

  #+kindex: C-c r @r{(helm-color-map)}

  Insert RGB of color from ~helm-source-colors~.

- {{{kbd(C-c N)}}} (~helm-color-run-kill-name~) ::

  #+findex: helm-color-run-kill-name @r{(helm-color-map)}

  #+kindex: C-c N @r{(helm-color-map)}

  Kill name of color from ~helm-source-colors~.

- {{{kbd(C-c R)}}} (~helm-color-run-kill-rgb~) ::

  #+findex: helm-color-run-kill-rgb @r{(helm-color-map)}

  #+kindex: C-c R @r{(helm-color-map)}

  Kill RGB of color from ~helm-source-colors~.

*** Commands in library ~helm-color~ (excludes keymaps)

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c c)}}} (~helm-colors~) ::

  #+findex: helm-colors

  #+kindex: C-x c c

  Preconfigured ~helm~ for color.

** Library: helm-comint

*** Commands in keymap ~helm-comint-prompts-keymap~

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c C-o)}}} (~helm-comint-prompts-other-frame~) ::

  #+findex: helm-comint-prompts-other-frame @r{(helm-comint-prompts-keymap)}

  #+kindex: C-c C-o @r{(helm-comint-prompts-keymap)}

- {{{kbd(C-c o)}}} (~helm-comint-prompts-other-window~) ::

  #+findex: helm-comint-prompts-other-window @r{(helm-comint-prompts-keymap)}

  #+kindex: C-c o @r{(helm-comint-prompts-keymap)}

*** Commands in library ~helm-comint~ (excludes keymaps)

**** Prompts
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-comint-prompts~ ::

  #+findex: helm-comint-prompts

  Pre-configured ~helm~ to browse the prompts of the current comint buffer.

- ~helm-comint-prompts-all~ ::

  #+findex: helm-comint-prompts-all

  Pre-configured ~helm~ to browse the prompts of all comint sessions.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-comint-input-ring~ ::

  #+findex: helm-comint-input-ring

  Preconfigured ~helm~ that provide completion of ~comint~ history.

*** Options in library =helm-comint=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-comint-max-offset~ ::

  #+vindex: helm-comint-max-offset

  *Standard Value*: 400

  Max number of chars displayed per candidate in comint-input-ring browser.
  When t, don’t truncate candidate, show all.
  By default it is approximatively the number of bits contained in
  five lines of 80 chars each i.e 80*5.
  Note that if you set this to nil multiline will be disabled, i.e
  you will not have anymore separators between candidates.

- ~helm-comint-mode-list~ ::

  #+vindex: helm-comint-mode-list

  *Standard Value*:

  #+begin_src emacs-lisp
    (comint-mode slime-repl-mode sly-mrepl-mode sql-interactive-mode)
  #+end_src

  Supported modes for prompt navigation.
  Derived modes (e.g., Geiser’s REPL) are automatically supported.

- ~helm-comint-next-prompt-function~ ::

  #+vindex: helm-comint-next-prompt-function

  *Standard Value*:

  #+begin_src emacs-lisp
    ((sly-mrepl-mode lambda nil
		     (sly-mrepl-next-prompt)
		     (point)))
  #+end_src

  Alist of (MODE . NEXT-PROMPT-FUNCTION) to use.
   If the current major mode is a key in this list, the associated
   function will be used to navigate the prompts.
   The function must return the point after the prompt.
   Otherwise (comint-next-prompt 1) will be used.

- ~helm-comint-prompts-promptidx-p~ ::

  #+vindex: helm-comint-prompts-promptidx-p

  *Standard Value*: t

  Show prompt number.

** Library: helm-command

*** Commands in keymap ~helm-M-x-map~

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-u)}}} (~helm-M-x-universal-argument~) ::

  #+findex: helm-M-x-universal-argument @r{(helm-M-x-map)}

  #+kindex: C-u @r{(helm-M-x-map)}

  Same as ~universal-argument~ but for ~helm-M-x~.

*** Commands in library ~helm-command~ (excludes keymaps)

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c M-x)}}} ::
- {{{kbd(<execute>)}}} ::
- {{{kbd(<menu>)}}} ::
- {{{kbd(M-x)}}} (~helm-M-x~) ::

  #+findex: helm-M-x

  #+kindex: C-x c M-x
  #+kindex: <execute>
  #+kindex: <menu>
  #+kindex: M-x

  (helm-M-x ARG)

  Preconfigured ~helm~ for Emacs commands.
  It is ~helm~ replacement of regular ~M-x~
  ~execute-extended-command~.

  Unlike regular ~M-x~ Emacs vanilla ~execute-extended-command~
  command, the prefix args if needed, can be passed AFTER starting
  ~helm-M-x~.  When a prefix arg is passed BEFORE starting
  ~helm-M-x~, the first ~C-u~ while in ~helm-M-x~ session will
  disable it.

  You can get help on each command by persistent action.

*** Options in library =helm-command=

**** X
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-M-x-always-save-history~ ::

  #+vindex: helm-M-x-always-save-history

  *Standard Value*: nil

  ~helm-M-x~ save command in ~extended-command-history~ even when it fails.

- ~helm-M-x-reverse-history~ ::

  #+vindex: helm-M-x-reverse-history

  *Standard Value*: nil

  The history source of ~helm-M-x~ appear in second position when non-nil.

- ~helm-M-x-use-completion-styles~ ::

  #+vindex: helm-M-x-use-completion-styles

  *Standard Value*: nil

  Use ~completion-styles~ and dynamic completion when non nil.
  It is disable by default as it is a regression starting from Emacs-27.

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-mode~ ::

  #+vindex: helm-mode

  *Standard Value*: t

  (helm-mode &optional ARG)

  Toggle generic helm completion.

  If called interactively, toggle ~Helm mode~.  If the prefix
  argument is positive, enable the mode, and if it is zero or
  negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

  All functions in Emacs that use ~completing-read~,
  ~read-file-name~, ~completion-in-region~ and friends will use helm
  interface when this mode is turned on.

  However you can modify this behavior for functions of your choice
  with ~helm-completing-read-handlers-alist~.

  Called with a positive arg, turn on unconditionally, with a
  negative arg turn off.
  You can toggle it with M-x ~helm-mode~.

  About ~ido-mode~:
  DO NOT enable ~ido-everywhere~ when using ~helm-mode~.  Instead of
  using ~ido-mode~, add the commands where you want to use ido to
  ~helm-completing-read-handlers-alist~ with ~ido~ as value.

  Note: This mode is incompatible with Emacs23.

*** Hooks in library =helm-command=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-M-x--before-action-hook~ ::

  #+vindex: helm-M-x--before-action-hook

  *Standard Value*:

- ~helm-M-x--move-selection-after-hook~ ::

  #+vindex: helm-M-x--move-selection-after-hook

  *Standard Value*:

** Library: helm-config

** Library: helm-dabbrev

*** Commands in library ~helm-dabbrev~ (excludes keymaps)

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-/)}}} (~helm-dabbrev~) ::

  #+findex: helm-dabbrev

  #+kindex: M-/

  Preconfigured helm for dynamic abbreviations.

*** Options in library =helm-dabbrev=

**** Search
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-dabbrev-always-search-all~ ::

  #+vindex: helm-dabbrev-always-search-all

  *Standard Value*: t

  Always search in all buffers when non--nil.
  Note that even if nil, a search in all buffers will occur if the
  length of candidates is <= than
  ~helm-dabbrev-max-length-result~.

- ~helm-dabbrev-case-fold-search~ ::

  #+vindex: helm-dabbrev-case-fold-search

  *Standard Value*: smart

  Set ~case-fold-search~ in ~helm-dabbrev~.
  Same as ~helm-case-fold-search~ but for ~helm-dabbrev~.
  Note that this is not affecting searching in Helm buffer, but the
  initial search for all candidates in buffer(s).

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-dabbrev-candidates-number-limit~ ::

  #+vindex: helm-dabbrev-candidates-number-limit

  *Standard Value*: 1000

  Maximum number of candidates to collect.

  The higher this number is, the slower the computation of
  candidates will be.  You can use safely a higher value with
  emacs-26+.
  Note that this have nothing to do with
  ~helm-candidate-number-limit~, this means that computation of
  candidates stop when this value is reached but only
  ~helm-candidate-number-limit~ candidates are displayed in the
  Helm buffer.

- ~helm-dabbrev-cycle-threshold~ ::

  #+vindex: helm-dabbrev-cycle-threshold

  *Standard Value*: 5

  Number of time helm-dabbrev cycle before displaying helm completion.
  When nil or 0 disable cycling.

- ~helm-dabbrev-ignored-buffers-regexps~ ::

  #+vindex: helm-dabbrev-ignored-buffers-regexps

  *Standard Value*:

  #+begin_src emacs-lisp
    ("\\*helm" "\\*Messages" "\\*Echo Area" "\\*Buffer List")
  #+end_src

  List of regexps matching names of buffers that ~helm-dabbrev~ should not check.

- ~helm-dabbrev-lineno-around~ ::

  #+vindex: helm-dabbrev-lineno-around

  *Standard Value*: 30

  Search first in this number of lines before and after point.

- ~helm-dabbrev-major-mode-assoc~ ::

  #+vindex: helm-dabbrev-major-mode-assoc

  *Standard Value*: nil

  Major mode association alist.

  This allow helm-dabbrev searching in buffers with the associated
  ~major-mode~.
  E.g. (emacs-lisp-mode . lisp-interaction-mode)

  will allow searching in the lisp-interaction-mode buffer when
  ~current-buffer~ is an ~emacs-lisp-mode~ buffer and vice versa
  i.e. no need to provide (lisp-interaction-mode .
  emacs-lisp-mode) association.

  When nil check is the searched buffer has same ~major-mode~ than
  the ~current-buffer~.

  This has no effect when ~helm-dabbrev-related-buffer-fn~ is nil
  or of course bound to a function that doesn’t handle this var.

- ~helm-dabbrev-related-buffer-fn~ ::

  #+vindex: helm-dabbrev-related-buffer-fn

  *Standard Value*: helm-dabbrev--same-major-mode-p

  A function that decide if a buffer to search in its related to ~current-buffer~.

  This is actually determined by comparing ~major-mode~ of the
  buffer to search and the ~current-buffer~.

  The function take one arg, the buffer which is current, look at
  ~helm-dabbrev--same-major-mode-p~ for an example.

  When nil all buffers are considered related to ~current-buffer~.

** Library: helm-easymenu

** Library: helm-elisp

*** Commands in library ~helm-elisp~ (excludes keymaps)

**** Lisp
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-lisp-indent~ ::

  #+findex: helm-lisp-indent

**** Point
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-complete-file-name-at-point~ ::

  #+findex: helm-complete-file-name-at-point

  (helm-complete-file-name-at-point &optional FORCE)

  Preconfigured Helm to complete file name at point.

- {{{kbd(C-x c <tab>)}}} (~helm-lisp-completion-at-point~) ::

  #+findex: helm-lisp-completion-at-point

  #+kindex: C-x c <tab>

  Preconfigured Helm for Lisp symbol completion at point.

- ~helm-lisp-completion-or-file-name-at-point~ ::

  #+findex: helm-lisp-completion-or-file-name-at-point

  Preconfigured Helm to complete Lisp symbol or filename at point.
  Filename completion happens if string start after or between a
  double quote.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c a)}}} ::
- {{{kbd(C-h a)}}} ::
- {{{kbd(<f1> a)}}} ::
- {{{kbd(<help> a)}}} (~helm-apropos~) ::

  #+findex: helm-apropos

  #+kindex: C-x c a
  #+kindex: C-h a
  #+kindex: <f1> a
  #+kindex: <help> a

  (helm-apropos DEFAULT)

  Preconfigured Helm to describe commands, functions, variables and faces.
  In non interactives calls DEFAULT argument should be provided as
  a string, i.e. the ~symbol-name~ of any existing symbol.

- ~helm-complex-command-history~ ::

  #+findex: helm-complex-command-history

  Preconfigured ~helm~ for complex command history.

- ~helm-locate-library~ ::

  #+findex: helm-locate-library

  Preconfigured helm to locate elisp libraries.

- ~helm-manage-advice~ ::

  #+findex: helm-manage-advice

  Preconfigured ~helm~ to disable/enable function advices.

- ~helm-sexp-eval-1~ ::

  #+findex: helm-sexp-eval-1

- ~helm-timers~ ::

  #+findex: helm-timers

  Preconfigured ~helm~ for timers.

*** Options in library =helm-elisp=

**** Fuzzy
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-locate-library-fuzzy-match~ ::

  #+vindex: helm-locate-library-fuzzy-match

  *Standard Value*: t

  Enable fuzzy-matching in ~helm-locate-library~ when non--nil.

**** Apropos
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-apropos-defaut-info-lookup-sources~ ::

  #+vindex: helm-apropos-defaut-info-lookup-sources

  *Standard Value*:

  #+begin_src emacs-lisp
    (helm-source-info-elisp helm-source-info-cl helm-source-info-eieio)
  #+end_src

  A list of sources to look into when searching info page of a symbol.

- ~helm-apropos-fuzzy-match~ ::

  #+vindex: helm-apropos-fuzzy-match

  *Standard Value*: nil

  Enable fuzzy matching for ~helm-apropos~ when non-nil.

**** Completion
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-lisp-fuzzy-completion~ ::

  #+vindex: helm-lisp-fuzzy-completion

  *Standard Value*: nil

  Enable fuzzy matching in emacs-lisp completion when non-nil.
  NOTE: This enables fuzzy matching in Helm native implementation of
  elisp completion, but not on helmized elisp completion, i.e. fuzzy
  completion is not available in ~completion-at-point~.

- ~helm-show-completion-min-window-height~ ::

  #+vindex: helm-show-completion-min-window-height

  *Standard Value*: 7

  Minimum completion window height used in show completion.
  This is used in macro ~with-helm-show-completion~.

- ~helm-turn-on-show-completion~ ::

  #+vindex: helm-turn-on-show-completion

  *Standard Value*: t

  Display candidate in ~current-buffer~ while moving selection when non--nil.

**** Function
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-apropos-function-list~ ::

  #+vindex: helm-apropos-function-list

  *Standard Value*:

  #+begin_src emacs-lisp
    (helm-def-source--emacs-commands helm-def-source--emacs-functions helm-def-source--eieio-classes helm-def-source--eieio-generic helm-def-source--emacs-variables helm-def-source--emacs-faces)
  #+end_src

  A list of functions that build helm sources to use in ~helm-apropos~.

- ~helm-elisp-help-function~ ::

  #+vindex: helm-elisp-help-function

  *Standard Value*: helm-elisp-show-help

  Function for displaying help for Lisp symbols.

- ~helm-lisp-quoted-function-list~ ::

  #+vindex: helm-lisp-quoted-function-list

  *Standard Value*:

  #+begin_src emacs-lisp
    (funcall apply mapc cl-mapc mapcar cl-mapcar callf callf2 cl-callf cl-callf2 fset fboundp fmakunbound symbol-function)
  #+end_src

  List of function where quoted function completion happen.
  E.g. give only function names after (funcall ’.

- ~helm-lisp-unquoted-function-list~ ::

  #+vindex: helm-lisp-unquoted-function-list

  *Standard Value*:

  #+begin_src emacs-lisp
    #'defadvice
  #+end_src

  List of function where unquoted function completion happen.
  E.g. give only function names after (function .

- ~helm-show-completion-display-function~ ::

  #+vindex: helm-show-completion-display-function

  *Standard Value*: helm-display-buffer-in-own-frame

  The function used to display helm completion buffer.

  This function is used by ~with-helm-show-completion~, when nil
  fallback to ~helm-default-display-buffer~.

  Default is to use a separate frame on graphic display and
  ~helm-show-completion-default-display-function~ on non graphic
  display.

** Library: helm-elisp-package

*** Commands in keymap ~helm-el-package-map~

**** uncategorized Run
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c @)}}} (~helm-el-run-visit-homepage~) ::

  #+findex: helm-el-run-visit-homepage @r{(helm-el-package-map)}

  #+kindex: C-c @ @r{(helm-el-package-map)}

**** uncategorized Package Run
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c i)}}} (~helm-el-run-package-install~) ::

  #+findex: helm-el-run-package-install @r{(helm-el-package-map)}

  #+kindex: C-c i @r{(helm-el-package-map)}

- {{{kbd(C-c r)}}} (~helm-el-run-package-reinstall~) ::

  #+findex: helm-el-run-package-reinstall @r{(helm-el-package-map)}

  #+kindex: C-c r @r{(helm-el-package-map)}

- {{{kbd(C-c d)}}} (~helm-el-run-package-uninstall~) ::

  #+findex: helm-el-run-package-uninstall @r{(helm-el-package-map)}

  #+kindex: C-c d @r{(helm-el-package-map)}

- {{{kbd(C-c u)}}} (~helm-el-run-package-upgrade~) ::

  #+findex: helm-el-run-package-upgrade @r{(helm-el-package-map)}

  #+kindex: C-c u @r{(helm-el-package-map)}

- {{{kbd(C-c U)}}} (~helm-el-run-package-upgrade-all~) ::

  #+findex: helm-el-run-package-upgrade-all @r{(helm-el-package-map)}

  #+kindex: C-c U @r{(helm-el-package-map)}

**** uncategorized Package Show
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-A)}}} (~helm-el-package-show-all~) ::

  #+findex: helm-el-package-show-all @r{(helm-el-package-map)}

  #+kindex: M-A @r{(helm-el-package-map)}

- {{{kbd(M-B)}}} (~helm-el-package-show-built-in~) ::

  #+findex: helm-el-package-show-built-in @r{(helm-el-package-map)}

  #+kindex: M-B @r{(helm-el-package-map)}

- {{{kbd(M-I)}}} (~helm-el-package-show-installed~) ::

  #+findex: helm-el-package-show-installed @r{(helm-el-package-map)}

  #+kindex: M-I @r{(helm-el-package-map)}

- {{{kbd(M-O)}}} (~helm-el-package-show-uninstalled~) ::

  #+findex: helm-el-package-show-uninstalled @r{(helm-el-package-map)}

  #+kindex: M-O @r{(helm-el-package-map)}

- {{{kbd(M-U)}}} (~helm-el-package-show-upgrade~) ::

  #+findex: helm-el-package-show-upgrade @r{(helm-el-package-map)}

  #+kindex: M-U @r{(helm-el-package-map)}

*** Commands in library ~helm-elisp-package~ (excludes keymaps)

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c @)}}} (~helm-list-elisp-packages~) ::

  #+findex: helm-list-elisp-packages

  #+kindex: C-x c @

  (helm-list-elisp-packages ARG)

  Preconfigured ~helm~ for listing and handling Emacs packages.

- ~helm-list-elisp-packages-no-fetch~ ::

  #+findex: helm-list-elisp-packages-no-fetch

  (helm-list-elisp-packages-no-fetch ARG)

  Preconfigured Helm for Emacs packages.

  Same as ~helm-list-elisp-packages~ but don't fetch packages on
  remote.  Called with a prefix ARG always fetch packages on
  remote.

*** Options in library =helm-elisp-package=

**** Package
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-el-package-autoremove-on-start~ ::

  #+vindex: helm-el-package-autoremove-on-start

  *Standard Value*: nil

  Try to autoremove no more needed packages on startup.
  See ~package-autoremove~.

- ~helm-el-package-initial-filter~ ::

  #+vindex: helm-el-package-initial-filter

  *Standard Value*: all

  Show only installed, upgraded or all packages at startup.

- ~helm-el-package-upgrade-on-start~ ::

  #+vindex: helm-el-package-upgrade-on-start

  *Standard Value*: nil

  Show package upgrades on startup when non nil.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-el-truncate-lines~ ::

  #+vindex: helm-el-truncate-lines

  *Standard Value*: t

  Truncate lines in ~helm-buffer~ when non-nil.

** Library: helm-epa

*** Modes in library ~helm-epa~

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-epa-mode~ ::

  #+findex: helm-epa-mode

  (helm-epa-mode &optional ARG)

  Enable helm completion on gpg keys in epa functions.

  If called interactively, toggle ~Helm-Epa mode~.  If the prefix
  argument is positive, enable the mode, and if it is zero or
  negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

*** Commands in library ~helm-epa~ (excludes keymaps)

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-epa-mode~ ::

  #+findex: helm-epa-mode

  (helm-epa-mode &optional ARG)

  Enable helm completion on gpg keys in epa functions.

  If called interactively, toggle ~Helm-Epa mode~.  If the prefix
  argument is positive, enable the mode, and if it is zero or
  negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-epa-list-keys~ ::

  #+findex: helm-epa-list-keys

  List all gpg keys.
  This is the helm interface for ~epa-list-keys~.

*** Options in library =helm-epa=

**** Mode
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-epa-mode-hook~ ::

  #+vindex: helm-epa-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm-epa-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-epa-mode~ ::

  #+vindex: helm-epa-mode

  *Standard Value*: nil

  (helm-epa-mode &optional ARG)

  Enable helm completion on gpg keys in epa functions.

  If called interactively, toggle ~Helm-Epa mode~.  If the prefix
  argument is positive, enable the mode, and if it is zero or
  negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-epa-actions~ ::

  #+vindex: helm-epa-actions

  *Standard Value*:

  #+begin_src emacs-lisp
    (("Show key" . epa--show-key)
     ("encrypt file with key" . helm-epa-encrypt-file)
     ("Copy keys to kill ring" . helm-epa-kill-keys-armor)
     ("Delete keys" . helm-epa-delete-keys))
  #+end_src

  Actions for ~helm-epa-list-keys~.

*** Hooks in library =helm-epa=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-epa-mode-hook~ ::

  #+vindex: helm-epa-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm-epa-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

** Library: helm-eshell

*** Commands in keymap ~helm-eshell-prompts-keymap~

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c C-o)}}} (~helm-eshell-prompts-other-frame~) ::

  #+findex: helm-eshell-prompts-other-frame @r{(helm-eshell-prompts-keymap)}

  #+kindex: C-c C-o @r{(helm-eshell-prompts-keymap)}

- {{{kbd(C-c o)}}} (~helm-eshell-prompts-other-window~) ::

  #+findex: helm-eshell-prompts-other-window @r{(helm-eshell-prompts-keymap)}

  #+kindex: C-c o @r{(helm-eshell-prompts-keymap)}

*** Commands in library ~helm-eshell~ (excludes keymaps)

**** Eshell
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-eshell-history~ ::

  #+findex: helm-eshell-history

  Preconfigured Helm for Eshell history.

- ~helm-eshell-prompts~ ::

  #+findex: helm-eshell-prompts

  Pre-configured ~helm~ to browse the prompts of the current Eshell.

- ~helm-eshell-prompts-all~ ::

  #+findex: helm-eshell-prompts-all

  Pre-configured ~helm~ to browse the prompts of all Eshell sessions.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-esh-pcomplete~ ::

  #+findex: helm-esh-pcomplete

  Preconfigured ~helm~ to provide Helm completion in Eshell.

*** Options in library =helm-eshell=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-eshell-fuzzy-match~ ::

  #+vindex: helm-eshell-fuzzy-match

  *Standard Value*: nil

  Enable fuzzy matching in ~helm-esh-pcomplete~ when non-nil.

- ~helm-eshell-prompts-promptidx-p~ ::

  #+vindex: helm-eshell-prompts-promptidx-p

  *Standard Value*: t

  Show prompt number.

*** Hooks in library =helm-eshell=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-eshell--quit-hook-fn~ ::

  #+vindex: helm-eshell--quit-hook-fn

  *Standard Value*:

** Library: helm-eval

*** Commands in keymap ~helm-eval-expression-map~

**** uncategorized Helm
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-<tab>)}}} ::
- {{{kbd(C-x c <tab>)}}} (~helm-lisp-completion-at-point~) ::

  #+findex: helm-lisp-completion-at-point @r{(helm-eval-expression-map)}

  #+kindex: C-<tab> @r{(helm-eval-expression-map)}
  #+kindex: C-x c <tab> @r{(helm-eval-expression-map)}

  Preconfigured Helm for Lisp symbol completion at point.

**** uncategorized Char
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(<left>)}}} ::
- {{{kbd(C-b)}}} (~backward-char~) ::

  #+findex: backward-char @r{(helm-eval-expression-map)}

  #+kindex: <left> @r{(helm-eval-expression-map)}
  #+kindex: C-b @r{(helm-eval-expression-map)}

  (backward-char &optional N)

  Move point N characters backward (forward if N is negative).
  On attempt to pass beginning or end of buffer, stop and signal error.
  Interactively, N is the numeric prefix argument.
  If N is omitted or nil, move point 1 character backward.

  Depending on the bidirectional context, the movement may be to the
  right or to the left on the screen.  This is in contrast with
  \[left-char], which see.

- {{{kbd(<right>)}}} ::
- {{{kbd(C-f)}}} (~forward-char~) ::

  #+findex: forward-char @r{(helm-eval-expression-map)}

  #+kindex: <right> @r{(helm-eval-expression-map)}
  #+kindex: C-f @r{(helm-eval-expression-map)}

  (forward-char &optional N)

  Move point N characters forward (backward if N is negative).
  On reaching end or beginning of buffer, stop and signal error.
  Interactively, N is the numeric prefix argument.
  If N is omitted or nil, move point 1 character forward.

  Depending on the bidirectional context, the movement may be to the
  right or to the left on the screen.  This is in contrast with
  \[right-char], which see.

**** uncategorized Line
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-<return>)}}} (~helm-eval-new-line-and-indent~) ::

  #+findex: helm-eval-new-line-and-indent @r{(helm-eval-expression-map)}

  #+kindex: C-<return> @r{(helm-eval-expression-map)}

- {{{kbd(M-<tab>)}}} (~lisp-indent-line~) ::

  #+findex: lisp-indent-line @r{(helm-eval-expression-map)}

  #+kindex: M-<tab> @r{(helm-eval-expression-map)}

  (lisp-indent-line &optional INDENT)

  Indent current line as Lisp code.

- {{{kbd(<down>)}}} ::
- {{{kbd(C-n)}}} (~next-line~) ::

  #+findex: next-line @r{(helm-eval-expression-map)}

  #+kindex: <down> @r{(helm-eval-expression-map)}
  #+kindex: C-n @r{(helm-eval-expression-map)}

  (next-line &optional ARG TRY-VSCROLL)

  Move cursor vertically down ARG lines.
  Interactively, vscroll tall lines if ~auto-window-vscroll~ is enabled.
  Non-interactively, use TRY-VSCROLL to control whether to vscroll tall
  lines: if either ~auto-window-vscroll~ or TRY-VSCROLL is nil, this
  function will not vscroll.

  ARG defaults to 1.

  If there is no character in the target line exactly under the current column,
  the cursor is positioned after the character in that line that spans this
  column, or at the end of the line if it is not long enough.
  If there is no line in the buffer after this one, behavior depends on the
  value of ~next-line-add-newlines~.  If non-nil, it inserts a newline character
  to create a line, and moves the cursor to that line.  Otherwise it moves the
  cursor to the end of the buffer.

  If the variable ~line-move-visual~ is non-nil, this command moves
  by display lines.  Otherwise, it moves by buffer lines, without
  taking variable-width characters or continued lines into account.
  See \[next-logical-line] for a command that always moves by buffer lines.

  The command \[set-goal-column] can be used to create
  a semipermanent goal column for this command.
  Then instead of trying to move exactly vertically (or as close as possible),
  this command moves to the specified goal column (or as close as possible).
  The goal column is stored in the variable ~goal-column~, which is nil
  when there is no goal column.  Note that setting ~goal-column~
  overrides ~line-move-visual~ and causes this command to move by buffer
  lines rather than by display lines.

- {{{kbd(<up>)}}} ::
- {{{kbd(C-p)}}} (~previous-line~) ::

  #+findex: previous-line @r{(helm-eval-expression-map)}

  #+kindex: <up> @r{(helm-eval-expression-map)}
  #+kindex: C-p @r{(helm-eval-expression-map)}

  (previous-line &optional ARG TRY-VSCROLL)

  Move cursor vertically up ARG lines.
  Interactively, vscroll tall lines if ~auto-window-vscroll~ is enabled.
  Non-interactively, use TRY-VSCROLL to control whether to vscroll tall
  lines: if either ~auto-window-vscroll~ or TRY-VSCROLL is nil, this
  function will not vscroll.

  ARG defaults to 1.

  If there is no character in the target line exactly over the current column,
  the cursor is positioned after the character in that line that spans this
  column, or at the end of the line if it is not long enough.

  If the variable ~line-move-visual~ is non-nil, this command moves
  by display lines.  Otherwise, it moves by buffer lines, without
  taking variable-width characters or continued lines into account.
  See \[previous-logical-line] for a command that always moves by buffer lines.

  The command \[set-goal-column] can be used to create
  a semipermanent goal column for this command.
  Then instead of trying to move exactly vertically (or as close as possible),
  this command moves to the specified goal column (or as close as possible).
  The goal column is stored in the variable ~goal-column~, which is nil
  when there is no goal column.  Note that setting ~goal-column~
  overrides ~line-move-visual~ and causes this command to move by buffer
  lines rather than by display lines.

*** Commands in library ~helm-eval~ (excludes keymaps)

**** Eval
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-eval-expression~ ::

  #+findex: helm-eval-expression

  (helm-eval-expression ARG)

  Preconfigured ~helm~ for ~helm-source-evaluation-result~.

- {{{kbd(C-x c C-:)}}} (~helm-eval-expression-with-eldoc~) ::

  #+findex: helm-eval-expression-with-eldoc

  #+kindex: C-x c C-:

  Preconfigured ~helm~ for ~helm-source-evaluation-result~ with ~eldoc~ support.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c C-,)}}} (~helm-calcul-expression~) ::

  #+findex: helm-calcul-expression

  #+kindex: C-x c C-,

  Preconfigured ~helm~ for ~helm-source-calculation-result~.

*** Options in library =helm-eval=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-eldoc-in-minibuffer-show-fn~ ::

  #+vindex: helm-eldoc-in-minibuffer-show-fn

  *Standard Value*: helm-show-info-in-mode-line

  A function to display eldoc info.
  Should take one arg: the string to display.

- ~helm-show-info-in-mode-line-delay~ ::

  #+vindex: helm-show-info-in-mode-line-delay

  *Standard Value*: 12

  Eldoc will show info in mode-line during this delay if user is idle.

** Library: helm-external

*** Commands in library ~helm-external~ (excludes keymaps)

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c C-c C-x)}}} (~helm-run-external-command~) ::

  #+findex: helm-run-external-command

  #+kindex: C-x c C-c C-x

  (helm-run-external-command PROGRAM)

  Preconfigured ~helm~ to run External PROGRAM asyncronously from Emacs.
  If program is already running exit with error.
  You can set your own list of commands with
  ~helm-external-commands-list~.

*** Options in library =helm-external=

**** External
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-default-external-file-browser~ ::

  #+vindex: helm-default-external-file-browser

  *Standard Value*: nautilus

  Default external file browser for your system.
  Directories will be opened externally with it when opening file
  externally in ~helm-find-files~.
  Set to nil if you do not have an external file browser or do not
  want to use it.
  Windows users should set that to "explorer.exe".

- ~helm-external-programs-associations~ ::

  #+vindex: helm-external-programs-associations

  *Standard Value*: nil

  Alist to store externals programs associated with file extension.
  This variable overhide setting in .mailcap file.
  E.g.: ’(("jpg" . "gqview") ("pdf" . "xpdf"))

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-raise-command~ ::

  #+vindex: helm-raise-command

  *Standard Value*: nil

  A shell command to jump to a window running specific program.
  Need external program wmctrl.
  This will be use with ~format~, so use something like "wmctrl -xa %s".

** Library: helm-fd

*** Commands in keymap ~helm-fd-map~

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(DEL)}}} (~helm-delete-backward-no-update~) ::

  #+findex: helm-delete-backward-no-update @r{(helm-fd-map)}

  #+kindex: DEL @r{(helm-fd-map)}

  (helm-delete-backward-no-update ARG)

  Disable update and delete ARG chars backward.
  Update is reenabled when idle 1s.

- {{{kbd(M-<down>)}}} (~helm-fd-next-directory~) ::

  #+findex: helm-fd-next-directory @r{(helm-fd-map)}

  #+kindex: M-<down> @r{(helm-fd-map)}

  Move to next directory in a helm-fd source.

- {{{kbd(M-<up>)}}} (~helm-fd-previous-directory~) ::

  #+findex: helm-fd-previous-directory @r{(helm-fd-map)}

  #+kindex: M-<up> @r{(helm-fd-map)}

  Move to previous directory in a helm-fd source.

*** Options in library =helm-fd=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-fd-switches~ ::

  #+vindex: helm-fd-switches

  *Standard Value*:

  #+begin_src emacs-lisp
    ("--hidden" "--type" "f" "--type" "d" "--color" "always")
  #+end_src

  A list of options to pass to fd shell command.

** Library: helm-files

*** Modes in library ~helm-files~

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ff--delete-async-modeline-mode~ ::

  #+findex: helm-ff--delete-async-modeline-mode

  (helm-ff--delete-async-modeline-mode &optional ARG)

  Notify mode-line that an async process run.

  If called interactively, toggle `Helm-Ff--Delete-Async-Modeline
  mode'.  If the prefix argument is positive, enable the mode, and
  if it is zero or negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

*** Commands in keymap ~helm-browse-project-map~

**** Run Grep on Project
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-g a)}}} (~helm-browse-project-run-ag~) ::

  #+findex: helm-browse-project-run-ag @r{(helm-browse-project-map)}

  #+kindex: M-g a @r{(helm-browse-project-map)}

  Run ~helm-grep~ AG from ~helm-browse-project~.

*** Commands in keymap ~helm-file-name-history-map~

**** Act on File name history
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x C-f)}}} (~helm-ff-file-name-history-run-ff~) ::

  #+findex: helm-ff-file-name-history-run-ff @r{(helm-file-name-history-map)}

  #+kindex: C-x C-f @r{(helm-file-name-history-map)}

  Switch back to current HFF session with selection as preselect.

- {{{kbd(C-c d)}}} (~helm-file-name-history-show-or-hide-deleted~) ::

  #+findex: helm-file-name-history-show-or-hide-deleted @r{(helm-file-name-history-map)}

  #+kindex: C-c d @r{(helm-file-name-history-map)}

*** Commands in keymap ~helm-find-files-map~

**** Control filtering behaviour
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-_)}}} (~helm-ff-undo~) ::

  #+findex: helm-ff-undo @r{(helm-find-files-map)}

  #+kindex: C-_ @r{(helm-find-files-map)}

  Undo minibuffer in ~helm-find-files~.
  Ensure disabling ~helm-ff-auto-update-flag~ before undoing.

- {{{kbd(C-<backspace>)}}} ::
- {{{kbd(C-c DEL)}}} (~helm-ff-run-toggle-auto-update~) ::

  #+findex: helm-ff-run-toggle-auto-update @r{(helm-find-files-map)}

  #+kindex: C-<backspace> @r{(helm-find-files-map)}
  #+kindex: C-c DEL @r{(helm-find-files-map)}

**** RET
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(RET)}}} (~helm-ff-RET~) ::

  #+findex: helm-ff-RET @r{(helm-find-files-map)}

  #+kindex: RET @r{(helm-find-files-map)}

  Default action for RET in ~helm-find-files~.

  Behave differently depending on ~helm-selection~:

  - candidate basename is "." => open it in dired.
  - candidate is a directory    => expand it.
  - candidate is a file         => open it.

**** Move up or down the directory tree
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(<left>)}}} ::
- {{{kbd(C-l)}}} (~helm-find-files-up-one-level~) ::

  #+findex: helm-find-files-up-one-level @r{(helm-find-files-map)}

  #+kindex: <left> @r{(helm-find-files-map)}
  #+kindex: C-l @r{(helm-find-files-map)}

  (helm-find-files-up-one-level ARG)

  Go up one level like unix command ~cd ..~.
  If prefix numeric arg is given go ARG level up.

- {{{kbd(C-r)}}} (~helm-find-files-down-last-level~) ::

  #+findex: helm-find-files-down-last-level @r{(helm-find-files-map)}

  #+kindex: C-r @r{(helm-find-files-map)}

  Retrieve previous paths reached by ~C-l~ in helm-find-files.

**** Sort the listing
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(S-<f1>)}}} (~helm-ff-sort-alpha~) ::

  #+findex: helm-ff-sort-alpha @r{(helm-find-files-map)}

  #+kindex: S-<f1> @r{(helm-find-files-map)}

- {{{kbd(S-<f2>)}}} (~helm-ff-sort-by-newest~) ::

  #+findex: helm-ff-sort-by-newest @r{(helm-find-files-map)}

  #+kindex: S-<f2> @r{(helm-find-files-map)}

- {{{kbd(S-<f3>)}}} (~helm-ff-sort-by-size~) ::

  #+findex: helm-ff-sort-by-size @r{(helm-find-files-map)}

  #+kindex: S-<f3> @r{(helm-find-files-map)}

**** List directories or files only
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(S-<f4>)}}} (~helm-ff-toggle-dirs-only~) ::

  #+findex: helm-ff-toggle-dirs-only @r{(helm-find-files-map)}

  #+kindex: S-<f4> @r{(helm-find-files-map)}

  Show only directories in helm-find-files.

- {{{kbd(S-<f5>)}}} (~helm-ff-toggle-files-only~) ::

  #+findex: helm-ff-toggle-files-only @r{(helm-find-files-map)}

  #+kindex: S-<f5> @r{(helm-find-files-map)}

  Show only files in helm-find-files.

**** Configure display
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-])}}} (~helm-ff-run-toggle-basename~) ::

  #+findex: helm-ff-run-toggle-basename @r{(helm-find-files-map)}

  #+kindex: C-] @r{(helm-find-files-map)}

**** Visit files in other window or frame
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c C-o)}}} (~helm-ff-run-switch-other-frame~) ::

  #+findex: helm-ff-run-switch-other-frame @r{(helm-find-files-map)}

  #+kindex: C-c C-o @r{(helm-find-files-map)}

  Run switch to other frame action from ~helm-source-find-files~.

- {{{kbd(C-c o)}}} (~helm-ff-run-switch-other-window~) ::

  #+findex: helm-ff-run-switch-other-window @r{(helm-find-files-map)}

  #+kindex: C-c o @r{(helm-find-files-map)}

  Run switch to other window action from ~helm-source-find-files~.
  When a prefix arg is provided, split is done vertically.

- {{{kbd(C-c C-t)}}} (~helm-ff-find-file-other-tab~) ::

  #+findex: helm-ff-find-file-other-tab @r{(helm-find-files-map)}

  #+kindex: C-c C-t @r{(helm-find-files-map)}

  Run find file in other tab action from ~helm-source-buffers-list~.

- {{{kbd(C-c r)}}} (~helm-ff-run-find-file-as-root~) ::

  #+findex: helm-ff-run-find-file-as-root @r{(helm-find-files-map)}

  #+kindex: C-c r @r{(helm-find-files-map)}

**** Kill Buffers
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-K)}}} (~helm-ff-run-kill-buffer-persistent~) ::

  #+findex: helm-ff-run-kill-buffer-persistent @r{(helm-find-files-map)}

  #+kindex: M-K @r{(helm-find-files-map)}

  Execute ~helm-ff-kill-buffer-fname~ without quitting.

**** Open files externally
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x C-v)}}} (~helm-ff-run-find-alternate-file~) ::

  #+findex: helm-ff-run-find-alternate-file @r{(helm-find-files-map)}

  #+kindex: C-x C-v @r{(helm-find-files-map)}

- {{{kbd(C-c C-x)}}} (~helm-ff-run-open-file-externally~) ::

  #+findex: helm-ff-run-open-file-externally @r{(helm-find-files-map)}

  #+kindex: C-c C-x @r{(helm-find-files-map)}

  Run open file externally command action from ~helm-source-find-files~.

- {{{kbd(C-c X)}}} (~helm-ff-run-open-file-with-default-tool~) ::

  #+findex: helm-ff-run-open-file-with-default-tool @r{(helm-find-files-map)}

  #+kindex: C-c X @r{(helm-find-files-map)}

  Run open file externally command action from ~helm-source-find-files~.

- {{{kbd(C-c C-v)}}} (~helm-ff-run-preview-file-externally~) ::

  #+findex: helm-ff-run-preview-file-externally @r{(helm-find-files-map)}

  #+kindex: C-c C-v @r{(helm-find-files-map)}

**** Copy files
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-C)}}} (~helm-ff-run-copy-file~) ::

  #+findex: helm-ff-run-copy-file @r{(helm-find-files-map)}

  #+kindex: M-C @r{(helm-find-files-map)}

  Run Copy file action from ~helm-source-find-files~.

- {{{kbd(M-V)}}} (~helm-ff-run-rsync-file~) ::

  #+findex: helm-ff-run-rsync-file @r{(helm-find-files-map)}

  #+kindex: M-V @r{(helm-find-files-map)}

  Run Rsync file action from ~helm-source-find-files~.

**** Run Query-Replace on Filenames
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-@)}}} (~helm-ff-run-query-replace-fnames-on-marked~) ::

  #+findex: helm-ff-run-query-replace-fnames-on-marked @r{(helm-find-files-map)}

  #+kindex: M-@ @r{(helm-find-files-map)}

- {{{kbd(M-R)}}} (~helm-ff-run-rename-file~) ::

  #+findex: helm-ff-run-rename-file @r{(helm-find-files-map)}

  #+kindex: M-R @r{(helm-find-files-map)}

  Run Rename file action from ~helm-source-find-files~.

**** Run Query-Replace on Buffers' Content
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-%)}}} (~helm-ff-run-query-replace~) ::

  #+findex: helm-ff-run-query-replace @r{(helm-find-files-map)}

  #+kindex: M-% @r{(helm-find-files-map)}

- {{{kbd(C-M-%)}}} (~helm-ff-run-query-replace-regexp~) ::

  #+findex: helm-ff-run-query-replace-regexp @r{(helm-find-files-map)}

  #+kindex: C-M-% @r{(helm-find-files-map)}

**** Touch files
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-T)}}} (~helm-ff-run-touch-files~) ::

  #+findex: helm-ff-run-touch-files @r{(helm-find-files-map)}

  #+kindex: M-T @r{(helm-find-files-map)}

  Used to interactively run touch file action from keyboard.

**** Delete Persistently
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-D)}}} (~helm-ff-run-delete-file~) ::

  #+findex: helm-ff-run-delete-file @r{(helm-find-files-map)}

  #+kindex: M-D @r{(helm-find-files-map)}

  Run Delete file action from ~helm-source-find-files~.

- {{{kbd(C-c d)}}} (~helm-ff-persistent-delete~) ::

  #+findex: helm-ff-persistent-delete @r{(helm-find-files-map)}

  #+kindex: C-c d @r{(helm-find-files-map)}

  Delete current candidate without quitting.

**** Operate on Images
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M--)}}} (~helm-ff-decrease-image-size-persistent~) ::

  #+findex: helm-ff-decrease-image-size-persistent @r{(helm-find-files-map)}

  #+kindex: M-- @r{(helm-find-files-map)}

  Decrease image size without quitting helm.

- {{{kbd(M-+)}}} (~helm-ff-increase-image-size-persistent~) ::

  #+findex: helm-ff-increase-image-size-persistent @r{(helm-find-files-map)}

  #+kindex: M-+ @r{(helm-find-files-map)}

  Increase image size without quitting helm.

- {{{kbd(M-l)}}} (~helm-ff-rotate-left-persistent~) ::

  #+findex: helm-ff-rotate-left-persistent @r{(helm-find-files-map)}

  #+kindex: M-l @r{(helm-find-files-map)}

  Rotate image left without quitting helm.

- {{{kbd(M-r)}}} (~helm-ff-rotate-right-persistent~) ::

  #+findex: helm-ff-rotate-right-persistent @r{(helm-find-files-map)}

  #+kindex: M-r @r{(helm-find-files-map)}

  Rotate image right without quitting helm.

**** Run Grep and friends
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-g g)}}} (~helm-ff-run-git-grep~) ::

  #+findex: helm-ff-run-git-grep @r{(helm-find-files-map)}

  #+kindex: M-g g @r{(helm-find-files-map)}

  Run git-grep action from ~helm-source-find-files~.

- {{{kbd(C-s)}}} ::
- {{{kbd(M-g s)}}} (~helm-ff-run-grep~) ::

  #+findex: helm-ff-run-grep @r{(helm-find-files-map)}

  #+kindex: C-s @r{(helm-find-files-map)}
  #+kindex: M-g s @r{(helm-find-files-map)}

  Run Grep action from ~helm-source-find-files~.

- {{{kbd(M-g a)}}} (~helm-ff-run-grep-ag~) ::

  #+findex: helm-ff-run-grep-ag @r{(helm-find-files-map)}

  #+kindex: M-g a @r{(helm-find-files-map)}

- {{{kbd(M-g i)}}} (~helm-ff-run-gid~) ::

  #+findex: helm-ff-run-gid @r{(helm-find-files-map)}

  #+kindex: M-g i @r{(helm-find-files-map)}

- {{{kbd(M-g p)}}} (~helm-ff-run-pdfgrep~) ::

  #+findex: helm-ff-run-pdfgrep @r{(helm-find-files-map)}

  #+kindex: M-g p @r{(helm-find-files-map)}

  Run Pdfgrep action from ~helm-source-find-files~.

- {{{kbd(M-g z)}}} (~helm-ff-run-zgrep~) ::

  #+findex: helm-ff-run-zgrep @r{(helm-find-files-map)}

  #+kindex: M-g z @r{(helm-find-files-map)}

  Run Grep action from ~helm-source-find-files~.

**** Run find or locate
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c /)}}} (~helm-ff-run-find-sh-command~) ::

  #+findex: helm-ff-run-find-sh-command @r{(helm-find-files-map)}

  #+kindex: C-c / @r{(helm-find-files-map)}

  Run find shell command action with key from ~helm-find-files~.

- {{{kbd(C-x C-f)}}} (~helm-ff-run-locate~) ::

  #+findex: helm-ff-run-locate @r{(helm-find-files-map)}

  #+kindex: C-x C-f @r{(helm-find-files-map)}

  Run locate action from ~helm-source-find-files~.

- {{{kbd(C-/)}}} (~helm-ff-run-fd~) ::

  #+findex: helm-ff-run-fd @r{(helm-find-files-map)}

  #+kindex: C-/ @r{(helm-find-files-map)}

  Run fd shell command action with key from ~helm-find-files~.

**** Show Properties
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-i)}}} (~helm-ff-properties-persistent~) ::

  #+findex: helm-ff-properties-persistent @r{(helm-find-files-map)}

  #+kindex: M-i @r{(helm-find-files-map)}

  Show properties without quitting helm.

**** Browse File name history
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c h)}}} (~helm-ff-file-name-history~) ::

  #+findex: helm-ff-file-name-history @r{(helm-find-files-map)}

  #+kindex: C-c h @r{(helm-find-files-map)}

  Switch to ~file-name-history~ without quitting ~helm-find-files~.

- {{{kbd(M-p)}}} (~helm-find-files-history~) ::

  #+findex: helm-find-files-history @r{(helm-find-files-map)}

  #+kindex: M-p @r{(helm-find-files-map)}

  (helm-find-files-history ARG &key (COMP-READ t))

  The ~helm-find-files~ history.
  Show the first ~helm-ff-history-max-length~ elements of
  ~helm-ff-history~ in an ~helm-comp-read~.

**** Attach files to an Email
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c C-a)}}} (~helm-ff-run-mail-attach-files~) ::

  #+findex: helm-ff-run-mail-attach-files @r{(helm-find-files-map)}

  #+kindex: C-c C-a @r{(helm-find-files-map)}

  Run mail attach files command action from ~helm-source-find-files~.

- {{{kbd(C-x C-q)}}} (~helm-ff-run-marked-files-in-dired~) ::

  #+findex: helm-ff-run-marked-files-in-dired @r{(helm-find-files-map)}

  #+kindex: C-x C-q @r{(helm-find-files-map)}

  Execute ~helm-marked-files-in-dired~ interactively.

**** Operate on Elisp files
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-B)}}} (~helm-ff-run-byte-compile-file~) ::

  #+findex: helm-ff-run-byte-compile-file @r{(helm-find-files-map)}

  #+kindex: M-B @r{(helm-find-files-map)}

  Run Byte compile file action from ~helm-source-find-files~.

- {{{kbd(M-L)}}} (~helm-ff-run-load-file~) ::

  #+findex: helm-ff-run-load-file @r{(helm-find-files-map)}

  #+kindex: M-L @r{(helm-find-files-map)}

  Run Load file action from ~helm-source-find-files~.

**** Run Ediff and Emerge
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c =)}}} (~helm-ff-run-ediff-file~) ::

  #+findex: helm-ff-run-ediff-file @r{(helm-find-files-map)}

  #+kindex: C-c = @r{(helm-find-files-map)}

  Run Ediff file action from ~helm-source-find-files~.

- {{{kbd(M-=)}}} (~helm-ff-run-ediff-merge-file~) ::

  #+findex: helm-ff-run-ediff-merge-file @r{(helm-find-files-map)}

  #+kindex: M-= @r{(helm-find-files-map)}

  Run Ediff merge file action from ~helm-source-find-files~.

**** uncategorized Ff Run File
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c p)}}} (~helm-ff-run-print-file~) ::

  #+findex: helm-ff-run-print-file @r{(helm-find-files-map)}

  #+kindex: C-c p @r{(helm-find-files-map)}

  Run Print file action from ~helm-source-find-files~.

**** Link files
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-H)}}} (~helm-ff-run-hardlink-file~) ::

  #+findex: helm-ff-run-hardlink-file @r{(helm-find-files-map)}

  #+kindex: M-H @r{(helm-find-files-map)}

  Run Hardlink file action from ~helm-source-find-files~.

- {{{kbd(M-Y)}}} (~helm-ff-run-relsymlink-file~) ::

  #+findex: helm-ff-run-relsymlink-file @r{(helm-find-files-map)}

  #+kindex: M-Y @r{(helm-find-files-map)}

  Run Symlink file action from ~helm-source-find-files~.

- {{{kbd(M-S)}}} (~helm-ff-run-symlink-file~) ::

  #+findex: helm-ff-run-symlink-file @r{(helm-find-files-map)}

  #+kindex: M-S @r{(helm-find-files-map)}

  Run Symlink file action from ~helm-source-find-files~.

**** uncategorized Ff Run uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x C-d)}}} (~helm-ff-run-browse-project~) ::

  #+findex: helm-ff-run-browse-project @r{(helm-find-files-map)}

  #+kindex: C-x C-d @r{(helm-find-files-map)}

- {{{kbd(C-c i)}}} (~helm-ff-run-complete-fn-at-point~) ::

  #+findex: helm-ff-run-complete-fn-at-point @r{(helm-find-files-map)}

  #+kindex: C-c i @r{(helm-find-files-map)}

  Run complete file name action from ~helm-source-find-files~.

- {{{kbd(M-.)}}} (~helm-ff-run-etags~) ::

  #+findex: helm-ff-run-etags @r{(helm-find-files-map)}

  #+kindex: M-. @r{(helm-find-files-map)}

  Run Etags command action from ~helm-source-find-files~.

- {{{kbd(C-c @)}}} (~helm-ff-run-insert-org-link~) ::

  #+findex: helm-ff-run-insert-org-link @r{(helm-find-files-map)}

  #+kindex: C-c @ @r{(helm-find-files-map)}

**** Manage Helm Find Files Sessioin
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x r m)}}} (~helm-ff-bookmark-set~) ::

  #+findex: helm-ff-bookmark-set @r{(helm-find-files-map)}

  #+kindex: C-x r m @r{(helm-find-files-map)}

  Record ~helm-find-files~ session in bookmarks.

- {{{kbd(C-x r b)}}} (~helm-find-files-switch-to-bookmark~) ::

  #+findex: helm-find-files-switch-to-bookmark @r{(helm-find-files-map)}

  #+kindex: C-x r b @r{(helm-find-files-map)}

  Switch to helm-bookmark for ~helm-find-files~ from ~helm-find-files.~

**** Run Eshell
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-e)}}} (~helm-ff-run-switch-to-shell~) ::

  #+findex: helm-ff-run-switch-to-shell @r{(helm-find-files-map)}

  #+kindex: M-e @r{(helm-find-files-map)}

  Run switch to eshell action from ~helm-source-find-files~.

- {{{kbd(M-!)}}} (~helm-ff-run-eshell-command-on-file~) ::

  #+findex: helm-ff-run-eshell-command-on-file @r{(helm-find-files-map)}

  #+kindex: M-! @r{(helm-find-files-map)}

  Run eshell command on file action from ~helm-source-find-files~.

*** Commands in keymap ~helm-read-file-map~

**** Control what is displayed
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-])}}} (~helm-ff-run-toggle-basename~) ::

  #+findex: helm-ff-run-toggle-basename @r{(helm-read-file-map)}

  #+kindex: C-] @r{(helm-read-file-map)}

**** RET
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(RET)}}} (~helm-ff-RET~) ::

  #+findex: helm-ff-RET @r{(helm-read-file-map)}

  #+kindex: RET @r{(helm-read-file-map)}

  Default action for RET in ~helm-find-files~.

  Behave differently depending on ~helm-selection~:

  - candidate basename is "." => open it in dired.
  - candidate is a directory    => expand it.
  - candidate is a file         => open it.

**** Return empty string
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-<return>)}}} ::
- {{{kbd(M-RET)}}} (~helm-cr-empty-string~) ::

  #+findex: helm-cr-empty-string @r{(helm-read-file-map)}

  #+kindex: C-<return> @r{(helm-read-file-map)}
  #+kindex: M-RET @r{(helm-read-file-map)}

  Return empty string.

**** Undo Minibuffer
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-_)}}} (~helm-ff-undo~) ::

  #+findex: helm-ff-undo @r{(helm-read-file-map)}

  #+kindex: C-_ @r{(helm-read-file-map)}

  Undo minibuffer in ~helm-find-files~.
  Ensure disabling ~helm-ff-auto-update-flag~ before undoing.

**** Go up and down directory tree
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-r)}}} (~helm-find-files-down-last-level~) ::

  #+findex: helm-find-files-down-last-level @r{(helm-read-file-map)}

  #+kindex: C-r @r{(helm-read-file-map)}

  Retrieve previous paths reached by ~C-l~ in helm-find-files.

- {{{kbd(<left>)}}} ::
- {{{kbd(C-l)}}} ::
- {{{kbd(C-.)}}} (~helm-find-files-up-one-level~) ::

  #+findex: helm-find-files-up-one-level @r{(helm-read-file-map)}

  #+kindex: <left> @r{(helm-read-file-map)}
  #+kindex: C-l @r{(helm-read-file-map)}
  #+kindex: C-. @r{(helm-read-file-map)}

  (helm-find-files-up-one-level ARG)

  Go up one level like unix command ~cd ..~.
  If prefix numeric arg is given go ARG level up.

**** File name history
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c h)}}} (~helm-ff-file-name-history~) ::

  #+findex: helm-ff-file-name-history @r{(helm-read-file-map)}

  #+kindex: C-c h @r{(helm-read-file-map)}

  Switch to ~file-name-history~ without quitting ~helm-find-files~.

**** Toggle Auto-update
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-<backspace>)}}} ::
- {{{kbd(C-c DEL)}}} (~helm-ff-run-toggle-auto-update~) ::

  #+findex: helm-ff-run-toggle-auto-update @r{(helm-read-file-map)}

  #+kindex: C-<backspace> @r{(helm-read-file-map)}
  #+kindex: C-c DEL @r{(helm-read-file-map)}

*** Commands in library ~helm-files~ (excludes keymaps)

**** Delete
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-delete-tramp-connection~ ::

  #+findex: helm-delete-tramp-connection

  Allow deleting tramp connection or marked tramp connections at once.

  This replace ~tramp-cleanup-connection~ which is partially broken
  in Emacs < to 25.1.50.1 (See Emacs bug http://debbugs.gnu.org/cgi/bugreport.cgi?bug=24432).

  It allows additionally to delete more than one connection at
  once.

**** Ff
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ff-RET-must-match~ ::

  #+findex: helm-ff-RET-must-match

  Same as ~helm-ff-RET~ but used in must-match map.

- ~helm-ff-TAB~ ::

  #+findex: helm-ff-TAB

  (helm-ff-TAB ARG)

  Default action for TAB in ~helm-find-files~.

  Behave differently depending on ~helm-selection~:

  - candidate basename is "." => open the action menu.
  - candidate is a directory    => expand it.
  - candidate is a file         => open action menu.

  Called with a prefix arg open menu unconditionally.

- ~helm-ff-delete-char-backward~ ::

  #+findex: helm-ff-delete-char-backward

  Go up one level or disable HFF auto update and delete char backward.

  Going up one level works only when pattern is a directory endings
  with "/", otherwise this command deletes char backward.

  Going up one level can be disabled if necessary by deleting "/"
  at end of pattern using \<helm-map>\[backward-char] and
  \[helm-delete-minibuffer-contents].

- ~helm-ff-kill-rsync-process~ ::

  #+findex: helm-ff-kill-rsync-process

  (helm-ff-kill-rsync-process PROCESS)

  Kill rsync process PROCESS.

  When called interactively prompt user with completion when more than
  one process.

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ff--delete-async-modeline-mode~ ::

  #+findex: helm-ff--delete-async-modeline-mode

  (helm-ff--delete-async-modeline-mode &optional ARG)

  Notify mode-line that an async process run.

  If called interactively, toggle `Helm-Ff--Delete-Async-Modeline
  mode'.  If the prefix argument is positive, enable the mode, and
  if it is zero or negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-browse-project~ ::

  #+findex: helm-browse-project

  (helm-browse-project ARG)

  Preconfigured helm to browse projects.
  Browse files and see status of project with its VCS.
  Only HG and GIT are supported for now.
  Fall back to ~helm-browse-project-find-files~ if current
  directory is not under control of one of those VCS.
  With a prefix ARG browse files recursively, with two prefix ARG
  rebuild the cache.
  If the current directory is found in the cache, start
  ~helm-browse-project-find-files~ even with no prefix ARG.
  NOTE: The prefix ARG have no effect on the VCS controlled
  directories.

  Needed dependencies for VCS:
  <https://github.com/emacs-helm/helm-ls-git>
  and
  <https://github.com/emacs-helm/helm-ls-hg>.

- {{{kbd(C-x c C-x C-f)}}} ::
- {{{kbd(<open>)}}} ::
- {{{kbd(C-x C-f)}}} (~helm-find-files~) ::

  #+findex: helm-find-files

  #+kindex: C-x c C-x C-f
  #+kindex: <open>
  #+kindex: C-x C-f

  (helm-find-files ARG)

  Preconfigured ~helm~ for helm implementation of ~find-file~.
  Called with a prefix arg show history if some.
  Don't call it from programs, use ~helm-find-files-1~ instead.
  This is the starting point for nearly all actions you can do on
  files.

- ~helm-projects-history~ ::

  #+findex: helm-projects-history

  (helm-projects-history ARG)

*** Options in library =helm-files=

**** On
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-substitute-in-filename-stay-on-remote~ ::

  #+vindex: helm-substitute-in-filename-stay-on-remote

  *Standard Value*: nil

  Don’t switch back to local filesystem when expanding pattern with / or ~/.

**** List
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-list-directory-function~ ::

  #+vindex: helm-list-directory-function

  *Standard Value*: helm-list-dir-external

  The function used in ~helm-find-files~ to list remote directories.

  Actually Helm provides two functions to do this:
  ~helm-list-dir-lisp~ and ~helm-list-dir-external~.

  Using ~helm-list-dir-external~ will provide a similar display to
  what is provided with local files i.e. colorized symlinks,
  executables files etc., whereas using ~helm-list-dir-lisp~ will
  allow colorizing only directories but it is more portable.

  NOTE: ~helm-list-dir-external~ needs ls and awk as dependencies.
  Also the ls version installed on the remote side should support
  the same arguments as the GNU/ls version, which are -A -1 -F -b
  and -Q.  So even if you are using a GNU/ls version locally and you
  want to connect e.g. on a Freebsd server, you may have failures
  due to the incompatible ls version installed on remote server.  In
  such case use ~helm-list-dir-lisp~ which works everywhere but is
  slower and less featured (only directories colorized).

**** Rsync
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-rsync-percent-sign~ ::

  #+vindex: helm-rsync-percent-sign

  *Standard Value*: ％

  Percentage unicode sign to use in Rsync reporter.

- ~helm-rsync-switches~ ::

  #+vindex: helm-rsync-switches

  *Standard Value*:

  #+begin_src emacs-lisp
    ("-a" "-z" "-h" "-s" "--info=all2")
  #+end_src

  Rsync options to use with HFF Rsync action.
  Note: Using "--info=all2" allows having the name of the file
  currently transfered in an help-echo in mode-line, if you use
  "--info=progress2" you will not have this information.

**** Mode
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-rsync-no-mode-line-update~ ::

  #+vindex: helm-rsync-no-mode-line-update

  *Standard Value*: nil

  When non nil don’t update mode-line when rsync is running.
  This is useful if you display the progress bar somewhere else,
  e.g. with minibuffer-line in minibuffer, in this case updating
  mode-line may create flickering in other frame’s mode-line.

**** Files Find
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-browse-project-default-find-files-fn~ ::

  #+vindex: helm-browse-project-default-find-files-fn

  *Standard Value*: helm-browse-project-fd-find-files

  The default function to retrieve files in a non-vc directory.

  A function that takes a directory name as only arg.

- ~helm-find-files-actions~ ::

  #+vindex: helm-find-files-actions

  *Standard Value*:

  #+begin_src emacs-lisp
    (("Find File" . helm-find-file-or-marked)
     ("Find file in Dired" . helm-point-file-in-dired)
     ("View file" . view-file)
     ("Query replace fnames on marked ~M-@~" . helm-ff-query-replace-fnames-on-marked)
     ("Marked files in dired ~C-x C-q, C-u wdired~" . helm-marked-files-in-dired)
     ("Query replace contents on marked ~M-%~" . helm-ff-query-replace)
     ("Query replace regexp contents on marked ~C-M-%~" . helm-ff-query-replace-regexp)
     ("Attach file(s) to mail buffer ~C-c C-a~" . helm-ff-mail-attach-files)
     ("Serial rename files" . helm-ff-serial-rename)
     ("Serial rename by symlinking files" . helm-ff-serial-rename-by-symlink)
     ("Serial rename by copying files" . helm-ff-serial-rename-by-copying)
     ("Open file with default tool" . helm-open-file-with-default-tool)
     ("Find file in hex dump" . hexl-find-file)
     ("Browse project ~C-x C-d~" . helm-ff-browse-project)
     ("Complete at point ~C-c i~" . helm-insert-file-name-completion-at-point)
     ("Insert as org link ~C-c @~" . helm-files-insert-as-org-link)
     ("Find shell command ~C-c /~" . helm-ff-find-sh-command)
     ("Fd shell command (C-/)" . helm-ff-fd)
     ("Add marked files to file-cache" . helm-ff-cache-add-file)
     ("Open file externally ~C-c C-x, C-u to choose~" . helm-open-file-externally)
     ("Grep File(s) ~C-s, C-u Recurse~" . helm-find-files-grep)
     ("Grep current directory with AG ~M-g a, C-u select type~" . helm-find-files-ag)
     ("Git grep ~M-g g, C-u from root~" . helm-ff-git-grep)
     ("Zgrep File(s) ~M-g z, C-u Recurse~" . helm-ff-zgrep)
     ("Pdf Grep File(s)" . helm-ff-pdfgrep)
     ("Gid ~M-g i~" . helm-ff-gid)
     ("Switch to Eshell ~M-e~" . helm-ff-switch-to-shell)
     ("Etags ~M-., C-u reload tag file~" . helm-ff-etags-select)
     ("Eshell command on file(s) ~M-!, C-u take all marked as arguments.~" . helm-find-files-eshell-command-on-file)
     ("Find file as root ~C-c r~" . helm-find-file-as-root)
     ("Find alternate file ~C-x C-v~" . find-alternate-file)
     ("Ediff File ~C-c =~" . helm-find-files-ediff-files)
     ("Ediff Merge File ~M-=~" . helm-find-files-ediff-merge-files)
     ("Delete File(s) ~M-D~ (C-u reverse trash)" . helm-ff-delete-files)
     ("Touch File(s) ~M-T~" . helm-ff-touch-files)
     ("Copy file(s) ~M-C, C-u to follow~" . helm-find-files-copy)
     ("Rsync file(s) ~M-V~ (C-u edit command)" . helm-find-files-rsync)
     ("Rename file(s) ~M-R, C-u to follow~" . helm-find-files-rename)
     ("Backup files" . helm-find-files-backup)
     ("Symlink files(s) ~M-S, C-u to follow~" . helm-find-files-symlink)
     ("Relsymlink file(s) ~M-Y, C-u to follow~" . helm-find-files-relsymlink)
     ("Hardlink file(s) ~M-H, C-u to follow~" . helm-find-files-hardlink)
     ("Find file other window ~C-c o~" . helm-find-files-other-window)
     ("Find file other frame ~C-c C-o~" . find-file-other-frame)
     ("Find file other tab ~C-c C-t~" . find-file-other-tab)
     ("Print File ~C-c p, C-u to refresh~" . helm-ff-print)
     ("Locate ~C-x C-f, C-u to specify locate db~" . helm-ff-locate))
  #+end_src

  Actions for ~helm-find-files~.

- ~helm-find-files-after-init-hook~ ::

  #+vindex: helm-find-files-after-init-hook

  *Standard Value*: nil

  Hook that run after initialization of ~helm-find-files~.

- ~helm-find-files-before-init-hook~ ::

  #+vindex: helm-find-files-before-init-hook

  *Standard Value*: nil

  Hook that run before initialization of ~helm-find-files~.

- ~helm-find-files-bookmark-prefix~ ::

  #+vindex: helm-find-files-bookmark-prefix

  *Standard Value*: Helm-find-files:

  bookmark name prefix of ~helm-find-files~ sessions.

- ~helm-find-files-ignore-thing-at-point~ ::

  #+vindex: helm-find-files-ignore-thing-at-point

  *Standard Value*: nil

  Use only ~default-directory~ as default input in ~helm-find-files~.
  I.e. text under cursor in ~current-buffer~ is ignored.
  Note that when non-nil you will be unable to complete filename at
  point in ~current-buffer~.

**** Files uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-files-save-history-extra-sources~ ::

  #+vindex: helm-files-save-history-extra-sources

  *Standard Value*:

  #+begin_src emacs-lisp
    ("Find" "Locate" "Recentf" "Files from Current Directory" "File Cache")
  #+end_src

  Extras source that save candidate to ~file-name-history~.

- ~helm-trash-remote-files~ ::

  #+vindex: helm-trash-remote-files

  *Standard Value*: nil

  Allow trashing remote files when non-nil.

  Trashing remote files with tramp doesn’t work out of the box
  unless the ’trash-cli’ package is installed.  This is why trashing
  remote files from Helm is disabled by default.

  Tramp is using external ’trash’ command in its ~delete-file~ and
  ~delete-directory~ handlers when using
  ~delete-by-moving-to-trash~, which is documented nowhere in
  Emacs.

  If you want to enable this you will have to install the ’trash’
  command on remote (and/or locally if you want to trash as root).
  On Ubuntu-based distributions it is ’trash-cli’.

**** Ff Mode
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ff-preferred-shell-mode~ ::

  #+vindex: helm-ff-preferred-shell-mode

  *Standard Value*: eshell-mode

  Shell to use to switch to a shell buffer from ~helm-find-files~.
  Possible values are ~shell-mode~, ~eshell-mode~ and ~term-mode~.
  This affects ~M-e~ keybinding.

**** Ff List
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ff-printer-list~ ::

  #+vindex: helm-ff-printer-list

  *Standard Value*: nil

  A list of available printers on your system.
  When non-nil let you choose a printer to print file.
  Otherwise when nil the variable ~printer-name~ will be used.
  On Unix based systems (lpstat command needed) you don’t need to
  set this, ~helm-ff-find-printers~ will find a list of available
  printers for you.

**** Ff Allow
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ff-allow-recursive-deletes~ ::

  #+vindex: helm-ff-allow-recursive-deletes

  *Standard Value*: nil

  When ’always don’t prompt for recursive deletion of directories.
  When nil, will ask for recursive deletion.
  Note that when deleting multiple directories you can answer !
  when prompted to avoid being asked for next directories, so it
  is probably better to not modify this variable.

**** Ff Guess
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ff-guess-ffap-filenames~ ::

  #+vindex: helm-ff-guess-ffap-filenames

  *Standard Value*: nil

  Use ffap to guess local filenames at point in ~helm-find-files~.
  This doesn’t disable url or mail at point, see
  ~helm-ff-guess-ffap-urls~ for this.

- ~helm-ff-guess-ffap-urls~ ::

  #+vindex: helm-ff-guess-ffap-urls

  *Standard Value*: t

  Use ffap to guess local urls at point in ~helm-find-files~.
  This doesn’t disable guessing filenames at point, see
  ~helm-ff-guess-ffap-filenames~ for this.
  See also ~ffap-url-unwrap-remote~ that may override this
  variable.

**** Ff Level
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ff-DEL-up-one-level-maybe~ ::

  #+vindex: helm-ff-DEL-up-one-level-maybe

  *Standard Value*: nil

  Use DEL to maybe go up one level when non nil.

  Going up one level works only when pattern is a directory endings
  with "/", otherwise this command deletes char backward.

  When nil always delete char backward.

**** Ff Delete
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ff--delete-async-modeline-mode-hook~ ::

  #+vindex: helm-ff--delete-async-modeline-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm-ff--delete-async-modeline-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

**** Ff Update
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ff-reset-filters-on-update~ ::

  #+vindex: helm-ff-reset-filters-on-update

  *Standard Value*: t

  Reset filter variables when changing directory.
  When filtering directories/files only, switch back to a "show all" view
  when moving out of directory when non nil.

**** Ff History
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ff-history-max-length~ ::

  #+vindex: helm-ff-history-max-length

  *Standard Value*: 100

  Number of elements shown in ~helm-find-files~ history.

**** Ff Initial
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ff-auto-update-initial-value~ ::

  #+vindex: helm-ff-auto-update-initial-value

  *Standard Value*: nil

  Auto update when only one candidate directory is matched.
  Default value when starting ~helm-find-files~ is nil to not
  confuse new users.
  For a better experience with ~helm-find-files~ set this to
  non-nil and use C-<backspace> to toggle it.

- ~helm-ff-initial-sort-method~ ::

  #+vindex: helm-ff-initial-sort-method

  *Standard Value*: nil

  Sort method to use when initially listing a directory.
  Note that this doesn’t affect the listing when matching inside
  the directory (i.e. filenames).

**** Ff Preselect
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ff-no-preselect~ ::

  #+vindex: helm-ff-no-preselect

  *Standard Value*: nil

  When non-nil ~helm-find-files~ starts at root of current directory.

- ~helm-ff-up-one-level-preselect~ ::

  #+vindex: helm-ff-up-one-level-preselect

  *Standard Value*: t

  Always preselect previous directory when going one level up.

  When non-nil ~candidate-number-limit~ source value is modified
  dynamically when going one level up if the position of previous
  candidate in its directory is > to
  ~helm-ff-candidate-number-limit~.

  It can be helpful to disable this and reduce
  ~helm-ff-candidate-number-limit~ if you often navigate across
  very large directories.

**** Ff File
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ff-allow-non-existing-file-at-point~ ::

  #+vindex: helm-ff-allow-non-existing-file-at-point

  *Standard Value*: nil

  Use non existing file-at-point as initial input in ~helm-find-files~.

- ~helm-ff-file-compressed-list~ ::

  #+vindex: helm-ff-file-compressed-list

  *Standard Value*:

  #+begin_src emacs-lisp
    ("gz" "bz2" "zip" "7z")
  #+end_src

  Minimal list of compressed files extension.

- ~helm-ff-file-name-history-use-recentf~ ::

  #+vindex: helm-ff-file-name-history-use-recentf

  *Standard Value*: nil

  Use ~recentf-list~ instead of ~file-name-history~ in ~helm-find-files~.

**** Ff Image
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ff-display-image-native~ ::

  #+vindex: helm-ff-display-image-native

  *Standard Value*: nil

  Use native ~image-mode~ when non nil.

  You should use this only with Emacs>= 27 and ~image-auto-resize~
  enabled to have images resized properly.  When this is enabled,
  you have new commands to zoom in/out images.  See
  ~image-transform-resize~ and ~image-auto-resize~.  Otherwise,
  when nil ~image-dired~ is used, using imagemagick as backend.
  NOTE: If you see image-mode is eating too much memory, you better have
  to set this to nil (default).

- ~helm-ff-rotate-image-switch~ ::

  #+vindex: helm-ff-rotate-image-switch

  *Standard Value*:

  #+begin_src emacs-lisp
    ("-i")
  #+end_src

  Options used with ~helm-ff-rotate-image-program~.
  If you are using Mogrify or Jpegtran mandatory option is
  "-rotate", with Exiftran mandatory option is "-i".

**** Ff Program
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ff-exif-data-program~ ::

  #+vindex: helm-ff-exif-data-program

  *Standard Value*: exiftran

  Program used to extract exif data of an image file.

- ~helm-ff-exif-data-program-args~ ::

  #+vindex: helm-ff-exif-data-program-args

  *Standard Value*: -d

  Arguments used for ~helm-ff-exif-data-program~.

- ~helm-ff-rotate-image-program~ ::

  #+vindex: helm-ff-rotate-image-program

  *Standard Value*: exiftran

  External program used to rotate images.
  When nil and ~helm-ff-display-image-native~ is enabled, fallback to
  ~image-rotate~ without modification of exif data i.e. rotation is not
  persistent otherwise an error is returned when not using
  ~helm-ff-display-image-native~ i.e. using image-dired.

**** Ff Files
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ff-delete-files-function~ ::

  #+vindex: helm-ff-delete-files-function

  *Standard Value*: helm-delete-marked-files

  The function to use by default to delete files.

  Default is to delete files synchronously, other choice is to
  delete files asynchronously.

  BE AWARE that when deleting async you will not be warned about
  recursive deletion of directories, IOW non-empty directories will
  be deleted with no warnings in background!!!

  It is the function that will be used when using
  ~M-D~ from
  ~helm-find-files~.

- ~helm-ff-signal-error-on-dot-files~ ::

  #+vindex: helm-ff-signal-error-on-dot-files

  *Standard Value*: t

  Signal error when file is ~.~ or ~..~ on file deletion when non-nil.
  Default is non-nil.
  WARNING: Setting this to nil is unsafe and can cause deletion of
  a whole tree.

- ~helm-ff-skip-boring-files~ ::

  #+vindex: helm-ff-skip-boring-files

  *Standard Value*: nil

  Non-nil to skip boring files.
  I.e. the files matching regexps in ~helm-boring-file-regexp-list~.
  This takes effect in ~helm-find-files~ and file completion used by
  ~helm-mode~ i.e. ~helm-read-file-name~.
  Note that when non-nil this will slow down slightly ~helm-find-files~.

- ~helm-ff-skip-git-ignored-files~ ::

  #+vindex: helm-ff-skip-git-ignored-files

  *Standard Value*: nil

  Non-nil to skip git ignored files.
  This take effect only in ~helm-find-files~.
  Check is not done on remote files.
  Note that when non-nil this will slow down slightly
  ~helm-find-files~.

**** Ff uncategorized uncategorized uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ff-avfs-directory~ ::

  #+vindex: helm-ff-avfs-directory

  *Standard Value*: ~/.avfs

  The default avfs directory, usually ’~/.avfs’.
  When this is set you will be able to expand archive filenames
  with ~C-j~ inside an avfs directory mounted with mountavfs.
  See <http://sourceforge.net/projects/avf/>.

- ~helm-ff-candidate-number-limit~ ::

  #+vindex: helm-ff-candidate-number-limit

  *Standard Value*: 5000

  The ~helm-candidate-number-limit~ for ~helm-find-files~ and friends.
  Note that when going one level up with
  ~C-l~ the
  length of directory will be used instead if it is higher than
  this value.  This is to avoid failing to preselect the previous
  directory/file if this one is situated lower than
  ~helm-ff-candidate-number-limit~ num candidate.

- ~helm-ff-fuzzy-matching~ ::

  #+vindex: helm-ff-fuzzy-matching

  *Standard Value*: t

  Enable fuzzy matching for ~helm-find-files~ when non--nil.
  See ~helm-ff--transform-pattern-for-completion~ for more info.

- ~helm-ff-goto-first-real-dired-exceptions~ ::

  #+vindex: helm-ff-goto-first-real-dired-exceptions

  *Standard Value*:

  #+begin_src emacs-lisp
    (dired-goto-file)
  #+end_src

  Dired commands that are allowed moving to first real candidate.

- ~helm-ff-kill-or-find-buffer-fname-fn~ ::

  #+vindex: helm-ff-kill-or-find-buffer-fname-fn

  *Standard Value*: helm-ff-kill-or-find-buffer-fname

  Default function used to expand non-directory filenames in ~helm-find-files~.

  This variable will take effect only in ~helm-find-files~.  It
  affects the behavior of persistent-action on filenames and
  non-existing filenames.

  The default is to expand filename on first hit on
  C-j, pop buffer in
  other window on second hit and finally kill this buffer on third
  hit.  This is very handy to create several new buffers, or when
  navigating, show quickly the buffer of file to see its contents
  briefly before killing it and continue navigating.

  However some users may not want this, so to disable this behaviour
  just set this to ~ignore~ function.

  Of course you can also write your own function to do something
  else.

- ~helm-ff-lynx-style-map~ ::

  #+vindex: helm-ff-lynx-style-map

  *Standard Value*: t

  Use arrow keys to navigate with ~helm-find-files~.
  Note that if you define this variable with ~setq~ your change
  will have no effect, use customize instead.

- ~helm-ff-newfile-prompt-p~ ::

  #+vindex: helm-ff-newfile-prompt-p

  *Standard Value*: t

  Whether Prompt or not when creating new file.
  This set ~ffap-newfile-prompt~.

- ~helm-ff-search-library-in-sexp~ ::

  #+vindex: helm-ff-search-library-in-sexp

  *Standard Value*: nil

  Search for library in ~require~ and ~declare-function~ sexp.

- ~helm-ff-transformer-show-only-basename~ ::

  #+vindex: helm-ff-transformer-show-only-basename

  *Standard Value*: t

  Show only basename of candidates in ~helm-find-files~.
  This can be toggled at anytime from ~helm-find-files~ with C-].

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ff--delete-async-modeline-mode~ ::

  #+vindex: helm-ff--delete-async-modeline-mode

  *Standard Value*: nil

  (helm-ff--delete-async-modeline-mode &optional ARG)

  Notify mode-line that an async process run.

  If called interactively, toggle `Helm-Ff--Delete-Async-Modeline
  mode'.  If the prefix argument is positive, enable the mode, and
  if it is zero or negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-dwim-target~ ::

  #+vindex: helm-dwim-target

  *Standard Value*: nil

  Default target directory for file actions.

  Define the directory where you want to start navigating for the
  target directory when copying, renaming, etc..  You can use the
  ~default-directory~ of ~next-window~, the current
  ~default-directory~ or have completion on all the directories
  belonging to each window.

- ~helm-modes-using-escaped-strings~ ::

  #+vindex: helm-modes-using-escaped-strings

  *Standard Value*:

  #+begin_src emacs-lisp
    (eshell-mode shell-mode term-mode)
  #+end_src

  Modes that requires string’s insertion to be escaped.

- ~helm-mounted-network-directories~ ::

  #+vindex: helm-mounted-network-directories

  *Standard Value*: nil

  A list of directories used for mounting remotes filesystem.

  When nil ~helm-file-on-mounted-network-p~ always return nil
  otherwise check if a file is in one of these directories.

  Remote filesystem are generally mounted with sshfs.

- ~helm-tooltip-hide-delay~ ::

  #+vindex: helm-tooltip-hide-delay

  *Standard Value*: 25

  Hide tooltips automatically after this many seconds.

- ~helm-tramp-verbose~ ::

  #+vindex: helm-tramp-verbose

  *Standard Value*: 0

  Just like ~tramp-verbose~ but specific to Helm.
  When set to 0 don’t show tramp messages in Helm.
  If you want to have the default tramp messages set it to 3.

*** Hooks in library =helm-files=

**** After
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-find-files-after-init-hook~ ::

  #+vindex: helm-find-files-after-init-hook

  *Standard Value*: nil

  Hook that run after initialization of ~helm-find-files~.

**** Before
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-find-files-before-init-hook~ ::

  #+vindex: helm-find-files-before-init-hook

  *Standard Value*: nil

  Hook that run before initialization of ~helm-find-files~.

**** Ff
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ff--delete-async-modeline-mode-hook~ ::

  #+vindex: helm-ff--delete-async-modeline-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm-ff--delete-async-modeline-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

- ~helm-ff--update-resume-after-hook~ ::

  #+vindex: helm-ff--update-resume-after-hook

  *Standard Value*:

- ~helm-ff-before-action-hook-fn~ ::

  #+vindex: helm-ff-before-action-hook-fn

  *Standard Value*:

- ~helm-ff-setup-update-hook~ ::

  #+vindex: helm-ff-setup-update-hook

  *Standard Value*:

** Library: helm-find

*** Commands in keymap ~helm-find-map~

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(DEL)}}} (~helm-delete-backward-no-update~) ::

  #+findex: helm-delete-backward-no-update @r{(helm-find-map)}

  #+kindex: DEL @r{(helm-find-map)}

  (helm-delete-backward-no-update ARG)

  Disable update and delete ARG chars backward.
  Update is reenabled when idle 1s.

*** Commands in library ~helm-find~ (excludes keymaps)

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c /)}}} (~helm-find~) ::

  #+findex: helm-find

  #+kindex: C-x c /

  (helm-find ARG)

  Preconfigured ~helm~ for the find shell command.

  Recursively find files whose names are matched by all specified
  globbing PATTERNs under the current directory using the external
  program specified in ~find-program~ (usually "find").  Every
  input PATTERN is silently wrapped into two stars: *PATTERN*.

  With prefix argument, prompt for a directory to search.

  When user option ~helm-findutils-search-full-path~ is non-nil,
  match against complete paths, otherwise, against file names
  without directory part.

  The (possibly empty) list of globbing PATTERNs can be followed by
  the separator "*" plus any number of additional arguments that
  are passed to "find" literally.

*** Options in library =helm-find=

**** Findutils
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-findutils-search-full-path~ ::

  #+vindex: helm-findutils-search-full-path

  *Standard Value*: nil

  Search in full path with shell command find when non-nil.
  I.e. use the -path/ipath arguments of find instead of
  -name/iname.

- ~helm-findutils-skip-boring-files~ ::

  #+vindex: helm-findutils-skip-boring-files

  *Standard Value*: t

  Ignore boring files in find command results.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-find-noerrors~ ::

  #+vindex: helm-find-noerrors

  *Standard Value*: nil

  Prevent showing error messages in helm buffer when non nil.

** Library: helm-font

*** Commands in keymap ~helm-ucs-map~

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-<left>)}}} (~helm-ucs-persistent-backward~) ::

  #+findex: helm-ucs-persistent-backward @r{(helm-ucs-map)}

  #+kindex: C-<left> @r{(helm-ucs-map)}

- {{{kbd(C-<backspace>)}}} (~helm-ucs-persistent-delete~) ::

  #+findex: helm-ucs-persistent-delete @r{(helm-ucs-map)}

  #+kindex: C-<backspace> @r{(helm-ucs-map)}

- {{{kbd(C-<right>)}}} (~helm-ucs-persistent-forward~) ::

  #+findex: helm-ucs-persistent-forward @r{(helm-ucs-map)}

  #+kindex: C-<right> @r{(helm-ucs-map)}

- {{{kbd(C-c SPC)}}} (~helm-ucs-persistent-insert-space~) ::

  #+findex: helm-ucs-persistent-insert-space @r{(helm-ucs-map)}

  #+kindex: C-c SPC @r{(helm-ucs-map)}

*** Commands in library ~helm-font~ (excludes keymaps)

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c F)}}} (~helm-select-xfont~) ::

  #+findex: helm-select-xfont

  #+kindex: C-x c F

  Preconfigured ~helm~ to select Xfont.

- {{{kbd(C-x c 8)}}} (~helm-ucs~) ::

  #+findex: helm-ucs

  #+kindex: C-x c 8

  (helm-ucs ARG)

  Preconfigured ~helm~ for ~ucs-names~.

  Called with a prefix arg force reloading cache.

*** Options in library =helm-font=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ucs-actions~ ::

  #+vindex: helm-ucs-actions

  *Standard Value*:

  #+begin_src emacs-lisp
    (("Insert character" . helm-ucs-insert-char)
     ("Insert character name" . helm-ucs-insert-name)
     ("Insert character code in hex" . helm-ucs-insert-code)
     ("Kill marked characters" . helm-ucs-kill-char)
     ("Kill name" . helm-ucs-kill-name)
     ("Kill code" . helm-ucs-kill-code))
  #+end_src

  Actions for ~helm-source-ucs~.

- ~helm-ucs-recent-size~ ::

  #+vindex: helm-ucs-recent-size

  *Standard Value*: 10

  Number of recent chars to keep.

** Library: helm-for-files

*** Commands in library ~helm-for-files~ (excludes keymaps)

**** Files
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-for-files~ ::

  #+findex: helm-for-files

  Preconfigured ~helm~ for opening files.
  Run all sources defined in ~helm-for-files-preferred-list~.

- {{{kbd(C-x c f)}}} (~helm-multi-files~) ::

  #+findex: helm-multi-files

  #+kindex: C-x c f

  Preconfigured helm like ~helm-for-files~ but running locate only on demand.

  Allow toggling back and forth from locate to others sources with
  ~helm-multi-files-toggle-locate-binding~ key.
  This avoids launching locate needlessly when what you are
  searching for is already found.

- ~helm-multi-files-toggle-to-locate~ ::

  #+findex: helm-multi-files-toggle-to-locate

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c C-c f)}}} (~helm-recentf~) ::

  #+findex: helm-recentf

  #+kindex: C-x c C-c f

  Preconfigured ~helm~ for ~recentf~.

*** Options in library =helm-for-files=

**** Fuzzy
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-file-cache-fuzzy-match~ ::

  #+vindex: helm-file-cache-fuzzy-match

  *Standard Value*: nil

  Enable fuzzy matching in ~helm-source-file-cache~ when non--nil.

**** Recentf
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-recentf-fuzzy-match~ ::

  #+vindex: helm-recentf-fuzzy-match

  *Standard Value*: nil

  Enable fuzzy matching in ~helm-source-recentf~ when non-nil.

- ~helm-turn-on-recentf~ ::

  #+vindex: helm-turn-on-recentf

  *Standard Value*: t

  Automatically turn on ~recentf-mode~ when non-nil.

**** Files
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-for-files-preferred-list~ ::

  #+vindex: helm-for-files-preferred-list

  *Standard Value*:

  #+begin_src emacs-lisp
    (helm-source-buffers-list helm-source-recentf helm-source-bookmarks helm-source-file-cache helm-source-files-in-current-dir helm-source-locate)
  #+end_src

  Your preferred sources for ~helm-for-files~ and ~helm-multi-files~.

  When adding a source here it is up to you to ensure the library
  of this source is accessible and properly loaded.

- ~helm-for-files-tramp-not-fancy~ ::

  #+vindex: helm-for-files-tramp-not-fancy

  *Standard Value*: t

  Colorize remote files when non nil.

  Be aware that a nil value will make tramp display very slow.

- ~helm-multi-files-toggle-locate-binding~ ::

  #+vindex: helm-multi-files-toggle-locate-binding

  *Standard Value*: C-c p

  Default binding to switch back and forth locate in ~helm-multi-files~.

** Library: helm-global-bindings

*** Commands in keymap ~helm-command-map~

**** View Helm Documentation
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(h h)}}} ::
- {{{kbd(C-x c h h)}}} (~helm-documentation~) ::

  #+findex: helm-documentation @r{(helm-command-map)}

  #+kindex: h h @r{(helm-command-map)}
  #+kindex: C-x c h h @r{(helm-command-map)}

  Preconfigured ~helm~ for Helm documentation.
  With a prefix arg refresh the documentation.

  Find here the documentation of all documented sources.

**** Execute Extended Command
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-x)}}} ::
- {{{kbd(C-x c M-x)}}} ::
- {{{kbd(<execute>)}}} ::
- {{{kbd(<menu>)}}} (~helm-M-x~) ::

  #+findex: helm-M-x @r{(helm-command-map)}

  #+kindex: M-x @r{(helm-command-map)}
  #+kindex: C-x c M-x @r{(helm-command-map)}
  #+kindex: <execute> @r{(helm-command-map)}
  #+kindex: <menu> @r{(helm-command-map)}

  (helm-M-x ARG)

  Preconfigured ~helm~ for Emacs commands.
  It is ~helm~ replacement of regular ~M-x~
  ~execute-extended-command~.

  Unlike regular ~M-x~ Emacs vanilla ~execute-extended-command~
  command, the prefix args if needed, can be passed AFTER starting
  ~helm-M-x~.  When a prefix arg is passed BEFORE starting
  ~helm-M-x~, the first ~C-u~ while in ~helm-M-x~ session will
  disable it.

  You can get help on each command by persistent action.

**** Find Files
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x C-f)}}} ::
- {{{kbd(C-x c C-x C-f)}}} ::
- {{{kbd(<open>)}}} (~helm-find-files~) ::

  #+findex: helm-find-files @r{(helm-command-map)}

  #+kindex: C-x C-f @r{(helm-command-map)}
  #+kindex: C-x c C-x C-f @r{(helm-command-map)}
  #+kindex: <open> @r{(helm-command-map)}

  (helm-find-files ARG)

  Preconfigured ~helm~ for helm implementation of ~find-file~.
  Called with a prefix arg show history if some.
  Don't call it from programs, use ~helm-find-files-1~ instead.
  This is the starting point for nearly all actions you can do on
  files.

- {{{kbd(f)}}} ::
- {{{kbd(C-x c f)}}} (~helm-multi-files~) ::

  #+findex: helm-multi-files @r{(helm-command-map)}

  #+kindex: f @r{(helm-command-map)}
  #+kindex: C-x c f @r{(helm-command-map)}

  Preconfigured helm like ~helm-for-files~ but running locate only on demand.

  Allow toggling back and forth from locate to others sources with
  ~helm-multi-files-toggle-locate-binding~ key.
  This avoids launching locate needlessly when what you are
  searching for is already found.

**** Visit recent Files
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c f)}}} ::
- {{{kbd(C-x c C-c f)}}} (~helm-recentf~) ::

  #+findex: helm-recentf @r{(helm-command-map)}

  #+kindex: C-c f @r{(helm-command-map)}
  #+kindex: C-x c C-c f @r{(helm-command-map)}

  Preconfigured ~helm~ for ~recentf~.

**** Run Find
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(/)}}} ::
- {{{kbd(C-x c /)}}} (~helm-find~) ::

  #+findex: helm-find @r{(helm-command-map)}

  #+kindex: / @r{(helm-command-map)}
  #+kindex: C-x c / @r{(helm-command-map)}

  (helm-find ARG)

  Preconfigured ~helm~ for the find shell command.

  Recursively find files whose names are matched by all specified
  globbing PATTERNs under the current directory using the external
  program specified in ~find-program~ (usually "find").  Every
  input PATTERN is silently wrapped into two stars: *PATTERN*.

  With prefix argument, prompt for a directory to search.

  When user option ~helm-findutils-search-full-path~ is non-nil,
  match against complete paths, otherwise, against file names
  without directory part.

  The (possibly empty) list of globbing PATTERNs can be followed by
  the separator "*" plus any number of additional arguments that
  are passed to "find" literally.

**** Run locate
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(l)}}} ::
- {{{kbd(C-x c l)}}} (~helm-locate~) ::

  #+findex: helm-locate @r{(helm-command-map)}

  #+kindex: l @r{(helm-command-map)}
  #+kindex: C-x c l @r{(helm-command-map)}

  (helm-locate ARG)

  Preconfigured ~helm~ for Locate.
  Note: you can add locate options after entering pattern.
  See 'man locate' for valid options and also ~helm-locate-command~.

  You can specify a local database with prefix argument ARG.
  With two prefix arg, refresh the current local db or create it if
  it doesn't exists.

  To create a user specific db, use
  "updatedb -l 0 -o db_path -U directory".
  Where db_path is a filename matched by
  ~helm-locate-db-file-regexp~.

**** List Buffers
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x C-b)}}} ::
- {{{kbd(C-x c C-x C-b)}}} (~helm-buffers-list~) ::

  #+findex: helm-buffers-list @r{(helm-command-map)}

  #+kindex: C-x C-b @r{(helm-command-map)}
  #+kindex: C-x c C-x C-b @r{(helm-command-map)}

  Preconfigured ~helm~ to list buffers.

**** Browse kill-ring
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-y)}}} ::
- {{{kbd(C-x c M-y)}}} (~helm-show-kill-ring~) ::

  #+findex: helm-show-kill-ring @r{(helm-command-map)}

  #+kindex: M-y @r{(helm-command-map)}
  #+kindex: C-x c M-y @r{(helm-command-map)}

  Preconfigured ~helm~ for ~kill-ring~.
  It is drop-in replacement of ~yank-pop~.

  First call open the kill-ring browser, next calls move to next line.

**** List Bookmarks
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x r b)}}} ::
- {{{kbd(C-x c C-x r b)}}} (~helm-filtered-bookmarks~) ::

  #+findex: helm-filtered-bookmarks @r{(helm-command-map)}

  #+kindex: C-x r b @r{(helm-command-map)}
  #+kindex: C-x c C-x r b @r{(helm-command-map)}

  Preconfigured ~helm~ for bookmarks (filtered by category).
  Optional source ~helm-source-bookmark-addressbook~ is loaded only
  if external addressbook-bookmark package is installed.

**** List Registers
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x r i)}}} ::
- {{{kbd(C-x c C-x r i)}}} (~helm-register~) ::

  #+findex: helm-register @r{(helm-command-map)}

  #+kindex: C-x r i @r{(helm-command-map)}
  #+kindex: C-x c C-x r i @r{(helm-command-map)}

  Preconfigured ~helm~ for Emacs registers.

**** Mark Ring
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c SPC)}}} ::
- {{{kbd(C-x c C-c SPC)}}} (~helm-all-mark-rings~) ::

  #+findex: helm-all-mark-rings @r{(helm-command-map)}

  #+kindex: C-c SPC @r{(helm-command-map)}
  #+kindex: C-x c C-c SPC @r{(helm-command-map)}

  Preconfigured ~helm~ for ~helm-source-global-mark-ring~ and ~helm-source-mark-ring~.

**** Run Occur
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-s o)}}} ::
- {{{kbd(C-x c M-s o)}}} (~helm-occur~) ::

  #+findex: helm-occur @r{(helm-command-map)}

  #+kindex: M-s o @r{(helm-command-map)}
  #+kindex: C-x c M-s o @r{(helm-command-map)}

  Preconfigured helm for searching lines matching pattern in ~current-buffer~.

  When ~helm-source-occur~ is member of
  ~helm-sources-using-default-as-input~ which is the default,
  symbol at point is searched at startup.

  When a region is marked search only in this region by narrowing.

  To search in multiples buffers start from one of the commands listing
  buffers (i.e. a helm command using ~helm-source-buffers-list~ like
  ~helm-mini~) and use the multi occur buffers action.

  This is the helm implementation that collect lines matching pattern
  like vanilla Emacs ~occur~ but have nothing to do with it, the search
  engine beeing completely different and also much faster.

**** Run Grep and friends
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-g a)}}} ::
- {{{kbd(C-x c M-g a)}}} (~helm-do-grep-ag~) ::

  #+findex: helm-do-grep-ag @r{(helm-command-map)}

  #+kindex: M-g a @r{(helm-command-map)}
  #+kindex: C-x c M-g a @r{(helm-command-map)}

  (helm-do-grep-ag ARG)

  Preconfigured ~helm~ for grepping with AG in ~default-directory~.
  With prefix arg prompt for type if available with your AG
  version.

- {{{kbd(M-g i)}}} ::
- {{{kbd(C-x c M-g i)}}} (~helm-gid~) ::

  #+findex: helm-gid @r{(helm-command-map)}

  #+kindex: M-g i @r{(helm-command-map)}
  #+kindex: C-x c M-g i @r{(helm-command-map)}

  Preconfigured ~helm~ for ~gid~ command line of ~ID-Utils~.
  Need A database created with the command ~mkid~ above
  ~default-directory~.
  Need id-utils as dependency which provide ~mkid~, ~gid~ etc..
  See <https://www.gnu.org/software/idutils/>.

**** Imenu
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(e)}}} ::
- {{{kbd(C-x c e)}}} (~helm-etags-select~) ::

  #+findex: helm-etags-select @r{(helm-command-map)}

  #+kindex: e @r{(helm-command-map)}
  #+kindex: C-x c e @r{(helm-command-map)}

  (helm-etags-select REINIT)

  Preconfigured helm for etags.
  If called with a prefix argument REINIT
  or if any of the tag files have been modified, reinitialize cache.

  This function aggregates three sources of tag files:

    1) An automatically located file in the parent directories,
       by ~helm-etags-get-tag-file~.
    2) ~tags-file-name~, which is commonly set by ~find-tag~ command.
    3) ~tags-table-list~ which is commonly set by ~visit-tags-table~ command.

- {{{kbd(i)}}} ::
- {{{kbd(C-x c i)}}} (~helm-imenu~) ::

  #+findex: helm-imenu @r{(helm-command-map)}

  #+kindex: i @r{(helm-command-map)}
  #+kindex: C-x c i @r{(helm-command-map)}

  Preconfigured ~helm~ for ~imenu~.

- {{{kbd(I)}}} ::
- {{{kbd(C-x c I)}}} (~helm-imenu-in-all-buffers~) ::

  #+findex: helm-imenu-in-all-buffers @r{(helm-command-map)}

  #+kindex: I @r{(helm-command-map)}
  #+kindex: C-x c I @r{(helm-command-map)}

  Preconfigured ~helm~ for fetching imenu entries in all buffers with similar mode as current.
  A mode is similar as current if it is the same, it is derived
  i.e. ~derived-mode-p~ or it have an association in
  ~helm-imenu-all-buffer-assoc~.

**** Lisp Completion at Point
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(<tab>)}}} ::
- {{{kbd(C-x c <tab>)}}} (~helm-lisp-completion-at-point~) ::

  #+findex: helm-lisp-completion-at-point @r{(helm-command-map)}

  #+kindex: <tab> @r{(helm-command-map)}
  #+kindex: C-x c <tab> @r{(helm-command-map)}

  Preconfigured Helm for Lisp symbol completion at point.

**** Calculate Expression
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-,)}}} ::
- {{{kbd(C-x c C-,)}}} (~helm-calcul-expression~) ::

  #+findex: helm-calcul-expression @r{(helm-command-map)}

  #+kindex: C-, @r{(helm-command-map)}
  #+kindex: C-x c C-, @r{(helm-command-map)}

  Preconfigured ~helm~ for ~helm-source-calculation-result~.

- {{{kbd(C-:)}}} ::
- {{{kbd(C-x c C-:)}}} (~helm-eval-expression-with-eldoc~) ::

  #+findex: helm-eval-expression-with-eldoc @r{(helm-command-map)}

  #+kindex: C-: @r{(helm-command-map)}
  #+kindex: C-x c C-: @r{(helm-command-map)}

  Preconfigured ~helm~ for ~helm-source-evaluation-result~ with ~eldoc~ support.

- {{{kbd(r)}}} ::
- {{{kbd(C-x c r)}}} (~helm-regexp~) ::

  #+findex: helm-regexp @r{(helm-command-map)}

  #+kindex: r @r{(helm-command-map)}
  #+kindex: C-x c r @r{(helm-command-map)}

  Preconfigured helm to build regexps.
  ~query-replace-regexp~ can be run from there against found regexp.

**** Get help for thing at point
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(h i)}}} ::
- {{{kbd(C-x c h i)}}} (~helm-info-at-point~) ::

  #+findex: helm-info-at-point @r{(helm-command-map)}

  #+kindex: h i @r{(helm-command-map)}
  #+kindex: C-x c h i @r{(helm-command-map)}

  Preconfigured ~helm~ for searching info at point.

**** View Emacs manauals
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(h r)}}} ::
- {{{kbd(C-x c h r)}}} (~helm-info-emacs~) ::

  #+findex: helm-info-emacs @r{(helm-command-map)}

  #+kindex: h r @r{(helm-command-map)}
  #+kindex: C-x c h r @r{(helm-command-map)}

  Predefined helm for emacs info.

- {{{kbd(h g)}}} ::
- {{{kbd(C-x c h g)}}} (~helm-info-gnus~) ::

  #+findex: helm-info-gnus @r{(helm-command-map)}

  #+kindex: h g @r{(helm-command-map)}
  #+kindex: C-x c h g @r{(helm-command-map)}

  Predefined helm for gnus info.

**** Get Elisp Help
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(a)}}} ::
- {{{kbd(C-x c a)}}} ::
- {{{kbd(C-h a)}}} ::
- {{{kbd(<f1> a)}}} ::
- {{{kbd(<help> a)}}} (~helm-apropos~) ::

  #+findex: helm-apropos @r{(helm-command-map)}

  #+kindex: a @r{(helm-command-map)}
  #+kindex: C-x c a @r{(helm-command-map)}
  #+kindex: C-h a @r{(helm-command-map)}
  #+kindex: <f1> a @r{(helm-command-map)}
  #+kindex: <help> a @r{(helm-command-map)}

  (helm-apropos DEFAULT)

  Preconfigured Helm to describe commands, functions, variables and faces.
  In non interactives calls DEFAULT argument should be provided as
  a string, i.e. the ~symbol-name~ of any existing symbol.

**** List Manpages
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(m)}}} ::
- {{{kbd(C-x c m)}}} (~helm-man-woman~) ::

  #+findex: helm-man-woman @r{(helm-command-map)}

  #+kindex: m @r{(helm-command-map)}
  #+kindex: C-x c m @r{(helm-command-map)}

  (helm-man-woman ARG)

  Preconfigured ~helm~ for Man and Woman pages.
  With a prefix arg reinitialize the cache.

**** List Emacs Processes
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(p)}}} ::
- {{{kbd(C-x c p)}}} (~helm-list-emacs-process~) ::

  #+findex: helm-list-emacs-process @r{(helm-command-map)}

  #+kindex: p @r{(helm-command-map)}
  #+kindex: C-x c p @r{(helm-command-map)}

  Preconfigured ~helm~ for Emacs process.

**** List Emacs Lisp Packages
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(@)}}} ::
- {{{kbd(C-x c @)}}} (~helm-list-elisp-packages~) ::

  #+findex: helm-list-elisp-packages @r{(helm-command-map)}

  #+kindex: @ @r{(helm-command-map)}
  #+kindex: C-x c @ @r{(helm-command-map)}

  (helm-list-elisp-packages ARG)

  Preconfigured ~helm~ for listing and handling Emacs packages.

**** Resume Helm Session
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(b)}}} ::
- {{{kbd(C-x c b)}}} (~helm-resume~) ::

  #+findex: helm-resume @r{(helm-command-map)}

  #+kindex: b @r{(helm-command-map)}
  #+kindex: C-x c b @r{(helm-command-map)}

  (helm-resume ARG)

  Resume a previous Helm session.
  Call with a prefix arg to choose among existing Helm
  buffers (sessions).  When calling from Lisp, specify a
  ~buffer-name~ as a string with ARG.

**** Run Exernal Command
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c C-x)}}} ::
- {{{kbd(C-x c C-c C-x)}}} (~helm-run-external-command~) ::

  #+findex: helm-run-external-command @r{(helm-command-map)}

  #+kindex: C-c C-x @r{(helm-command-map)}
  #+kindex: C-x c C-c C-x @r{(helm-command-map)}

  (helm-run-external-command PROGRAM)

  Preconfigured ~helm~ to run External PROGRAM asyncronously from Emacs.
  If program is already running exit with error.
  You can set your own list of commands with
  ~helm-external-commands-list~.

**** Search the Web
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c g)}}} ::
- {{{kbd(C-x c C-c g)}}} (~helm-google-suggest~) ::

  #+findex: helm-google-suggest @r{(helm-command-map)}

  #+kindex: C-c g @r{(helm-command-map)}
  #+kindex: C-x c C-c g @r{(helm-command-map)}

  Preconfigured ~helm~ for Google search with Google suggest.

- {{{kbd(s)}}} ::
- {{{kbd(C-x c s)}}} (~helm-surfraw~) ::

  #+findex: helm-surfraw @r{(helm-command-map)}

  #+kindex: s @r{(helm-command-map)}
  #+kindex: C-x c s @r{(helm-command-map)}

  (helm-surfraw PATTERN ENGINE)

  Preconfigured ~helm~ to search PATTERN with search ENGINE.

****  Run Top
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(t)}}} ::
- {{{kbd(C-x c t)}}} (~helm-top~) ::

  #+findex: helm-top @r{(helm-command-map)}

  #+kindex: t @r{(helm-command-map)}
  #+kindex: C-x c t @r{(helm-command-map)}

  Preconfigured ~helm~ for top command.

**** List Unicode names
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(8)}}} ::
- {{{kbd(C-x c 8)}}} (~helm-ucs~) ::

  #+findex: helm-ucs @r{(helm-command-map)}

  #+kindex: 8 @r{(helm-command-map)}
  #+kindex: C-x c 8 @r{(helm-command-map)}

  (helm-ucs ARG)

  Preconfigured ~helm~ for ~ucs-names~.

  Called with a prefix arg force reloading cache.

**** Select XFont
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(F)}}} ::
- {{{kbd(C-x c F)}}} (~helm-select-xfont~) ::

  #+findex: helm-select-xfont @r{(helm-command-map)}

  #+kindex: F @r{(helm-command-map)}
  #+kindex: C-x c F @r{(helm-command-map)}

  Preconfigured ~helm~ to select Xfont.

**** List Colors
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(c)}}} ::
- {{{kbd(C-x c c)}}} (~helm-colors~) ::

  #+findex: helm-colors @r{(helm-command-map)}

  #+kindex: c @r{(helm-command-map)}
  #+kindex: C-x c c @r{(helm-command-map)}

  Preconfigured ~helm~ for color.

*** Options in library =helm-global-bindings=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-command-prefix-key~ ::

  #+vindex: helm-command-prefix-key

  *Standard Value*: C-x c

  The key ~helm-command-prefix~ is bound to in the global map.

- ~helm-minibuffer-history-key~ ::

  #+vindex: helm-minibuffer-history-key

  *Standard Value*: C-r

  The key ~helm-minibuffer-history~ is bound to in minibuffer local maps.

** Library: helm-grep

*** Modes in library ~helm-grep~

**** other-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-grep-mode~ ::

  #+findex: helm-grep-mode

  Major mode to provide actions in helm grep saved buffer.

  Special commands:
  \{helm-grep-mode-map}

  In addition to any hooks its parent mode ~special-mode~ might have
  run, this mode runs the hook ~helm-grep-mode-hook~, as the final or
  penultimate step during initialization.

*** Commands in keymap ~helm-grep-map~

**** uncategorized Goto
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-<down>)}}} (~helm-goto-next-file~) ::

  #+findex: helm-goto-next-file @r{(helm-grep-map)}

  #+kindex: M-<down> @r{(helm-grep-map)}

  Go to previous file in Helm grep/etags buffers.

- {{{kbd(M-<up>)}}} (~helm-goto-precedent-file~) ::

  #+findex: helm-goto-precedent-file @r{(helm-grep-map)}

  #+kindex: M-<up> @r{(helm-grep-map)}

  Go to previous file in Helm grep/etags buffers.

**** uncategorized Grep
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(<left>)}}} (~helm-grep-run-default-action~) ::

  #+findex: helm-grep-run-default-action @r{(helm-grep-map)}

  #+kindex: <left> @r{(helm-grep-map)}

  Run grep default action from ~helm-do-grep-1~.

- {{{kbd(C-c C-o)}}} (~helm-grep-run-other-frame-action~) ::

  #+findex: helm-grep-run-other-frame-action @r{(helm-grep-map)}

  #+kindex: C-c C-o @r{(helm-grep-map)}

  Run grep goto other frame action from ~helm-do-grep-1~.

- {{{kbd(C-c o)}}} (~helm-grep-run-other-window-action~) ::

  #+findex: helm-grep-run-other-window-action @r{(helm-grep-map)}

  #+kindex: C-c o @r{(helm-grep-map)}

  Run grep goto other window action from ~helm-do-grep-1~.

- {{{kbd(C-x C-s)}}} (~helm-grep-run-save-buffer~) ::

  #+findex: helm-grep-run-save-buffer @r{(helm-grep-map)}

  #+kindex: C-x C-s @r{(helm-grep-map)}

  Run grep save results action from ~helm-do-grep-1~.

**** uncategorized uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(DEL)}}} (~helm-delete-backward-no-update~) ::

  #+findex: helm-delete-backward-no-update @r{(helm-grep-map)}

  #+kindex: DEL @r{(helm-grep-map)}

  (helm-delete-backward-no-update ARG)

  Disable update and delete ARG chars backward.
  Update is reenabled when idle 1s.

*** Commands in keymap ~helm-grep-mode-map~

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-<down>)}}} ::
- {{{kbd(M-N)}}} (~helm-gm-next-file~) ::

  #+findex: helm-gm-next-file @r{(helm-grep-mode-map)}

  #+kindex: M-<down> @r{(helm-grep-mode-map)}
  #+kindex: M-N @r{(helm-grep-mode-map)}

- {{{kbd(M-<up>)}}} ::
- {{{kbd(M-P)}}} (~helm-gm-precedent-file~) ::

  #+findex: helm-gm-precedent-file @r{(helm-grep-mode-map)}

  #+kindex: M-<up> @r{(helm-grep-mode-map)}
  #+kindex: M-P @r{(helm-grep-mode-map)}

- {{{kbd(RET)}}} (~helm-grep-mode-jump~) ::

  #+findex: helm-grep-mode-jump @r{(helm-grep-mode-map)}

  #+kindex: RET @r{(helm-grep-mode-map)}

- {{{kbd(C-o)}}} (~helm-grep-mode-jump-other-window~) ::

  #+findex: helm-grep-mode-jump-other-window @r{(helm-grep-mode-map)}

  #+kindex: C-o @r{(helm-grep-mode-map)}

- {{{kbd(C-<up>)}}} ::
- {{{kbd(M-p)}}} (~helm-grep-mode-jump-other-window-backward~) ::

  #+findex: helm-grep-mode-jump-other-window-backward @r{(helm-grep-mode-map)}

  #+kindex: C-<up> @r{(helm-grep-mode-map)}
  #+kindex: M-p @r{(helm-grep-mode-map)}

  (helm-grep-mode-jump-other-window-backward ARG)

- {{{kbd(C-<down>)}}} ::
- {{{kbd(M-n)}}} (~helm-grep-mode-jump-other-window-forward~) ::

  #+findex: helm-grep-mode-jump-other-window-forward @r{(helm-grep-mode-map)}

  #+kindex: C-<down> @r{(helm-grep-mode-map)}
  #+kindex: M-n @r{(helm-grep-mode-map)}

  (helm-grep-mode-jump-other-window-forward ARG)

*** Commands in keymap ~helm-pdfgrep-map~

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(DEL)}}} (~helm-delete-backward-no-update~) ::

  #+findex: helm-delete-backward-no-update @r{(helm-pdfgrep-map)}

  #+kindex: DEL @r{(helm-pdfgrep-map)}

  (helm-delete-backward-no-update ARG)

  Disable update and delete ARG chars backward.
  Update is reenabled when idle 1s.

- {{{kbd(M-<down>)}}} (~helm-goto-next-file~) ::

  #+findex: helm-goto-next-file @r{(helm-pdfgrep-map)}

  #+kindex: M-<down> @r{(helm-pdfgrep-map)}

  Go to previous file in Helm grep/etags buffers.

- {{{kbd(M-<up>)}}} (~helm-goto-precedent-file~) ::

  #+findex: helm-goto-precedent-file @r{(helm-pdfgrep-map)}

  #+kindex: M-<up> @r{(helm-pdfgrep-map)}

  Go to previous file in Helm grep/etags buffers.

*** Commands in library ~helm-grep~ (excludes keymaps)

**** Do
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c M-g a)}}} (~helm-do-grep-ag~) ::

  #+findex: helm-do-grep-ag

  #+kindex: C-x c M-g a

  (helm-do-grep-ag ARG)

  Preconfigured ~helm~ for grepping with AG in ~default-directory~.
  With prefix arg prompt for type if available with your AG
  version.

- ~helm-grep-do-git-grep~ ::

  #+findex: helm-grep-do-git-grep

  (helm-grep-do-git-grep ARG)

  Preconfigured ~helm~ for git-grepping ~default-directory~.
  With a prefix arg ARG git-grep the whole repository.

**** Mode
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-grep-mode-mouse-jump~ ::

  #+findex: helm-grep-mode-mouse-jump

  (helm-grep-mode-mouse-jump EVENT)

**** other-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-grep-mode~ ::

  #+findex: helm-grep-mode

  Major mode to provide actions in helm grep saved buffer.

  Special commands:
  \{helm-grep-mode-map}

  In addition to any hooks its parent mode ~special-mode~ might have
  run, this mode runs the hook ~helm-grep-mode-hook~, as the final or
  penultimate step during initialization.

*** Options in library =helm-grep=

**** Style
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-grep-file-path-style~ ::

  #+vindex: helm-grep-file-path-style

  *Standard Value*: basename

  File path display style when grep results are displayed.
  Possible value are:
      basename: displays only the filename, none of the directory path
      absolute: displays absolute path
      relative: displays relative path from root grep directory.

- ~helm-grep-use-ioccur-style-keys~ ::

  #+vindex: helm-grep-use-ioccur-style-keys

  *Standard Value*: t

  Use Arrow keys to jump to occurences.
  Note that if you define this variable with ~setq~ your change
  will have no effect, use customize instead.

**** Zgrep
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-zgrep-file-extension-regexp~ ::

  #+vindex: helm-zgrep-file-extension-regexp

  *Standard Value*: .*\(\.gz\|\.bz\|\.xz\|\.lzma\)$

  Default file extensions zgrep will search in.

**** Ignored
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-grep-ignored-directories~ ::

  #+vindex: helm-grep-ignored-directories

  *Standard Value*:

  #+begin_src emacs-lisp
    ("SCCS/" "RCS/" "CVS/" "MCVS/" ".svn/" ".git/" ".hg/" ".bzr/" "_MTN/" "_darcs/" "{arch}/" ".gvfs/")
  #+end_src

  List of names of sub-directories which ~helm-grep~ shall not recurse into.

- ~helm-grep-ignored-files~ ::

  #+vindex: helm-grep-ignored-files

  *Standard Value*:

  #+begin_src emacs-lisp
    (".#*" "*.o" "*~" "*.bin" "*.lbin" "*.so" "*.a" "*.ln" "*.blg" "*.bbl" "*.elc" "*.lof" "*.glo" "*.idx" "*.lot" "*.fmt" "*.tfm" "*.class" "*.fas" "*.lib" "*.mem" "*.x86f" "*.sparcf" "*.dfsl" "*.pfsl" "*.d64fsl" "*.p64fsl" "*.lx64fsl" "*.lx32fsl" "*.dx64fsl" "*.dx32fsl" "*.fx64fsl" "*.fx32fsl" "*.sx64fsl" "*.sx32fsl" "*.wx64fsl" "*.wx32fsl" "*.fasl" "*.ufsl" "*.fsl" "*.dxl" "*.lo" "*.la" "*.gmo" "*.mo" "*.toc" "*.aux" "*.cp" "*.fn" "*.ky" "*.pg" "*.tp" "*.vr" "*.cps" "*.fns" "*.kys" "*.pgs" "*.tps" "*.vrs" "*.pyc" "*.pyo")
  #+end_src

  List of file names which ~helm-grep~ shall exclude.

**** Switches
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-grep-ag-pipe-cmd-switches~ ::

  #+vindex: helm-grep-ag-pipe-cmd-switches

  *Standard Value*: nil

  A list of additional parameters to pass to grep-ag pipe command.
  Use parameters compatibles with the backend you are using
  (i.e. AG for AG, PT for PT or RG for RG)

  You probably don’t need to use this unless you know what you are
  doing.

- ~helm-grep-pipe-cmd-switches~ ::

  #+vindex: helm-grep-pipe-cmd-switches

  *Standard Value*: nil

  A list of additional parameters to pass to grep pipe command.
  This will be used to pipe command for multiple pattern matching
  for grep, zgrep ack-grep and git-grep backends.
  If you add extra args for ack-grep, use ack-grep options, for
  others (grep, zgrep and git-grep) use grep options.
  Here are the commands where you may want to add switches:

      grep --color=always
      ack-grep --smart-case --color

  You probably don’t need to use this unless you know what you are
  doing.

**** Command Default
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-default-zgrep-command~ ::

  #+vindex: helm-default-zgrep-command

  *Standard Value*: zgrep --color=always -a -n%cH -e %p %f

  Default command for Zgrep.
  See ~helm-grep-default-command~ for infos on format specs.
  Option --color=always is supported and can be used safely to
  replace the Helm internal match highlighting.  See
  ~helm-grep-default-command~ for more infos.

- ~helm-grep-default-command~ ::

  #+vindex: helm-grep-default-command

  *Standard Value*: grep --color=always -a -d skip %e -n%cH -e %p %f

  Default grep format command for ~helm-do-grep-1~.
  Where:
  ’%e’ format spec is for --exclude or --include grep options or
       ack-grep --type option.               (Not mandatory)

  ’%c’ format spec is for case-fold-search,
       whether to use the -i option of grep. (Not mandatory)
       When you specify this spec, helm grep will use smartcase
       that is when a upcase character is found in pattern case will
       be respected and no ’-i’ option will be used, otherwise, when
       no upcase character is found in pattern always use ’-i’.
       If you don’t want this behavior, don’t use this spec and
       specify or not the ’-i’ option.
       Note that with ack-grep this is not needed, just specify
       the ’--smart-case’ option.

  ’%p’ format spec is for pattern.           (Mandatory)

  ’%f’ format spec is for filenames.         (Mandatory)

  If your grep version doesn’t support the --exclude/include args
  don’t specify the ’%e’ format spec.

  Helm also support ack-grep and git-grep.  The following is a
  default command example for ack-grep:

  (setq helm-grep-default-command "ack-grep -Hn --color --smart-case --no-group %e %p %f"
	 helm-grep-default-recurse-command "ack-grep -H --color --smart-case --no-group %e %p %f")

  You can ommit the %e spec if you don’t want to be prompted for
  types.

  NOTE: Helm for ack-grep support ANSI sequences, so you can remove
  the "--no-color" option safely (recommended).
  However you should specify --color to enable multi matches highlighting
  because ack disable it when output is piped.

  Same for grep you can use safely the option "--color=always" (default).
  You can customize the color of matches using GREP_COLORS env var.
  e.g: (setenv "GREP_COLORS" "ms=30;43:mc=30;43:sl=01;37:cx=:fn=35:ln=32:bn=32:se=36")

  To enable ANSI color in git-grep just add "--color=always".
  To customize the ANSI color in git-grep, GREP_COLORS have no effect,
  you will have to setup this in your .gitconfig:

      [color "grep"]
	  match = black yellow

  Where "black" is the foreground and "yellow" the background.
  See the git documentation for more infos.

  ~helm-grep-default-command~ and
  ~helm-grep-default-recurse-command~ are independent, so you can
  enable ~helm-grep-default-command~ with ack-grep and
  ~helm-grep-default-recurse-command~ with grep if you want to be
  faster on recursive grep.

  NOTE: Remote grepping is not available with ack-grep, and badly
	supported with grep because tramp handles badly repeated
	remote processes in a short delay (< to 5s).

- ~helm-grep-default-recurse-command~ ::

  #+vindex: helm-grep-default-recurse-command

  *Standard Value*: grep --color=always -a -d recurse %e -n%cH -e %p %f

  Default recursive grep format command for ~helm-do-grep-1~.
  See ~helm-grep-default-command~ for format specs and infos about
  ack-grep.

- ~helm-pdfgrep-default-command~ ::

  #+vindex: helm-pdfgrep-default-command

  *Standard Value*: pdfgrep --color always -niH %s %s

  Default command for pdfgrep.
  Option "--color always" is supported starting Helm version
  1.7.8.  When used matches will be highlighted according to
  GREP_COLORS env var.

- ~helm-pdfgrep-default-read-command~ ::

  #+vindex: helm-pdfgrep-default-read-command

  *Standard Value*: nil

  Default command to read pdf files from pdfgrep.
  Where ’%f’ format spec is filename and ’%p’ is page number.
  E.g. In Ubuntu you can set it to:

      "evince --page-label=%p ’%f’"

  If set to nil either ~doc-view-mode~ or ~pdf-view-mode~ will be
  used instead of an external command.

- ~helm-pdfgrep-default-recurse-command~ ::

  #+vindex: helm-pdfgrep-default-recurse-command

  *Standard Value*: pdfgrep --color always -rniH %s %s

  Default recurse command for pdfgrep.
  Option "--color always" is supported starting Helm version
  1.7.8.  When used matches will be highlighted according to
  GREP_COLORS env var.

**** Command uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-grep-ag-command~ ::

  #+vindex: helm-grep-ag-command

  *Standard Value*: ag --line-numbers -S --color --nogroup %s %s %s

  The default command for AG, PT or RG.

  Takes three format specs, the first for type(s), the second for
  pattern and the third for directory.

  You can use safely "--color" (used by default) with AG RG and
  PT.

  NOTE: Usage of "--color=never" is discouraged as it uses Elisp
  to colorize matched items which is slower than using the native
  colorization of backend, however it is still supported.

  For ripgrep here is the command line to use:

      rg --color=always --smart-case --no-heading --line-number %s %s %s

  And to customize colors (always for ripgrep) use something like this:

      rg --color=always --colors ’match:bg:yellow’ --colors ’match:fg:black’
  --smart-case --no-heading --line-number %s %s %s

  This will change color for matched items from foreground red (the
  default) to a yellow background with a black foreground.  Note
  that your color settings for RG will not work properly with
  multiples pattern if you have configured colors in rg config file
  instead of command line. For more enhanced settings of ansi
  colors see https://github.com/emacs-helm/helm/issues/2313

  You must use an output format that fit with helm grep, that is:

      "filename:line-number:string"

  The option "--nogroup" allow this.
  The option "--line-numbers" is also mandatory except with
  PT (not supported).
  For RG the options "--no-heading" and "--line-number" are the
  ones to use.

  When modifying the default colors of matches with e.g.
  "--color-match" option of AG or "--colors" option of ripgrep
  you may want to modify as well ~helm-grep-ag-pipe-cmd-switches~
  to have all matches colorized with the same color in multi
  match.

  Of course you can use several other options, see the man page of the
  backend you are using.

- ~helm-grep-git-grep-command~ ::

  #+vindex: helm-grep-git-grep-command

  *Standard Value*: git --no-pager grep -n%cH --color=always --full-name -e %p -- %f

  The git grep default command line.
  The option "--color=always" can be used safely.
  The color of matched items can be customized in your .gitconfig
  See ~helm-grep-default-command~ for more infos.

  The "--exclude-standard" and "--no-index" switches allow
  skipping unwanted files specified in ~/.gitignore_global and
  searching files not already staged (not enabled by default).

  You have also to enable this in global ".gitconfig" with
      "git config --global core.excludesfile ~/.gitignore_global".

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-grep-actions~ ::

  #+vindex: helm-grep-actions

  *Standard Value*:

  #+begin_src emacs-lisp
    (("Find File" . helm-grep-action)
     ("Find file other frame" . helm-grep-other-frame)
     ("Save results in grep buffer" . helm-grep-save-results)
     ("Find file other window (C-u vertically)" . helm-grep-other-window))
  #+end_src

  Actions for helm grep.

- ~helm-grep-input-idle-delay~ ::

  #+vindex: helm-grep-input-idle-delay

  *Standard Value*: 0.1

  Idle time before updating, specified in seconds.
  A lower value (default) means Helm will display the results
  faster. Increasing it to a higher value (e.g. 0.6) prevents the
  buffer from flickering when updating.

- ~helm-grep-max-length-history~ ::

  #+vindex: helm-grep-max-length-history

  *Standard Value*: 100

  Max number of elements to save in ~helm-grep-history~.

- ~helm-grep-preferred-ext~ ::

  #+vindex: helm-grep-preferred-ext

  *Standard Value*: nil

  This file extension will be preselected for grep.

- ~helm-grep-save-buffer-name-no-confirm~ ::

  #+vindex: helm-grep-save-buffer-name-no-confirm

  *Standard Value*: nil

  When *hgrep* already exists, auto append suffix.

- ~helm-grep-truncate-lines~ ::

  #+vindex: helm-grep-truncate-lines

  *Standard Value*: t

  When nil the grep line that appears will not be truncated.

*** Hooks in library =helm-grep=

**** Init
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-grep-after-init-hook~ ::

  #+vindex: helm-grep-after-init-hook

  *Standard Value*: nil

  Hook that runs after initialization of the Helm buffer.

- ~helm-grep-before-init-hook~ ::

  #+vindex: helm-grep-before-init-hook

  *Standard Value*: nil

  Hook that runs before initialization of the Helm buffer.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-grep-mode-hook~ ::

  #+vindex: helm-grep-mode-hook

  *Standard Value*: nil

  Hook run after entering helm-grep mode.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

** Library: helm-help

*** Commands in library ~helm-help~ (excludes keymaps)

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c h h)}}} (~helm-documentation~) ::

  #+findex: helm-documentation

  #+kindex: C-x c h h

  Preconfigured ~helm~ for Helm documentation.
  With a prefix arg refresh the documentation.

  Find here the documentation of all documented sources.

** Library: helm-id-utils

*** Commands in library ~helm-id-utils~ (excludes keymaps)

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c M-g i)}}} (~helm-gid~) ::

  #+findex: helm-gid

  #+kindex: C-x c M-g i

  Preconfigured ~helm~ for ~gid~ command line of ~ID-Utils~.
  Need A database created with the command ~mkid~ above
  ~default-directory~.
  Need id-utils as dependency which provide ~mkid~, ~gid~ etc..
  See <https://www.gnu.org/software/idutils/>.

*** Options in library =helm-id-utils=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-gid-db-file-name~ ::

  #+vindex: helm-gid-db-file-name

  *Standard Value*: ID

  Name of a database file created by ~mkid~ command from ~ID-utils~.

- ~helm-gid-program~ ::

  #+vindex: helm-gid-program

  *Standard Value*: gid

  Name of gid command (usually ~gid~).
  For Mac OS X users, if you install GNU coreutils, the name ~gid~
  might be occupied by ~id~ from GNU coreutils, and you should set
  it to correct name (or absolute path).  For example, if using
  MacPorts to install id-utils, it should be ~gid32~.

** Library: helm-imenu

*** Commands in keymap ~helm-imenu-map~

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-<down>)}}} (~helm-imenu-next-section~) ::

  #+findex: helm-imenu-next-section @r{(helm-imenu-map)}

  #+kindex: M-<down> @r{(helm-imenu-map)}

- {{{kbd(M-<up>)}}} (~helm-imenu-previous-section~) ::

  #+findex: helm-imenu-previous-section @r{(helm-imenu-map)}

  #+kindex: M-<up> @r{(helm-imenu-map)}

*** Commands in library ~helm-imenu~ (excludes keymaps)

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c i)}}} (~helm-imenu~) ::

  #+findex: helm-imenu

  #+kindex: C-x c i

  Preconfigured ~helm~ for ~imenu~.

- {{{kbd(C-x c I)}}} (~helm-imenu-in-all-buffers~) ::

  #+findex: helm-imenu-in-all-buffers

  #+kindex: C-x c I

  Preconfigured ~helm~ for fetching imenu entries in all buffers with similar mode as current.
  A mode is similar as current if it is the same, it is derived
  i.e. ~derived-mode-p~ or it have an association in
  ~helm-imenu-all-buffer-assoc~.

*** Options in library =helm-imenu=

**** All
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-imenu-all-buffer-assoc~ ::

  #+vindex: helm-imenu-all-buffer-assoc

  *Standard Value*: nil

  Major mode association alist for ~helm-imenu-in-all-buffers~.
  Allow ~helm-imenu-in-all-buffers~ searching in these associated
  buffers even if they are not derived from each other.  The alist
  is bidirectional, i.e. no need to add ’((foo . bar) (bar . foo)),
  only ’((foo . bar)) is needed.

- ~helm-imenu-in-all-buffers-separate-sources~ ::

  #+vindex: helm-imenu-in-all-buffers-separate-sources

  *Standard Value*: t

  Display imenu index of each buffer in its own source when non-nil.

  When nil all candidates are displayed in a single source.

  NOTE: Each source will have as name "Imenu <buffer-name>".
  ~helm-source-imenu-all~ will not be set, however it will continue
  to be used as a flag for using default as input.  If you do not
  want this behavior, remove it from
  ~helm-sources-using-default-as-input~ even if not using a single
  source to display imenu in all buffers.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-imenu-delimiter~ ::

  #+vindex: helm-imenu-delimiter

  *Standard Value*:  /

  Delimit types of candidates and their value in ~helm-buffer~.

- ~helm-imenu-execute-action-at-once-if-one~ ::

  #+vindex: helm-imenu-execute-action-at-once-if-one

  *Standard Value*: helm-imenu--execute-action-at-once-p

  Goto the candidate when only one is remaining.

- ~helm-imenu-extra-modes~ ::

  #+vindex: helm-imenu-extra-modes

  *Standard Value*: nil

  Extra modes where ~helm-imenu-in-all-buffers~ should look into.

- ~helm-imenu-fuzzy-match~ ::

  #+vindex: helm-imenu-fuzzy-match

  *Standard Value*: nil

  Enable fuzzy matching in ~helm-source-imenu~.

- ~helm-imenu-lynx-style-map~ ::

  #+vindex: helm-imenu-lynx-style-map

  *Standard Value*: nil

  Use Arrow keys to jump to occurences.

- ~helm-imenu-type-faces~ ::

  #+vindex: helm-imenu-type-faces

  *Standard Value*:

  #+begin_src emacs-lisp
    (("^Variables$" . font-lock-variable-name-face)
     ("^\\(Function\\|Functions\\|Defuns\\)$" . font-lock-function-name-face)
     ("^\\(Types\\|Provides\\|Requires\\|Classes\\|Class\\|Includes\\|Imports\\|Misc\\|Code\\)$" . font-lock-type-face))
  #+end_src

  Faces for showing type in helm-imenu.
  This is a list of cons cells.  The cdr of each cell is a face to
  be used, and it can also just be like '(:foreground
  "yellow").  Each car is a regexp match pattern of the imenu type
  string.

** Library: helm-info

*** Modes in library ~helm-info~

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-info-nxml-mode~ ::

  #+findex: helm-info-nxml-mode

  Predefined helm for nxml-mode info.

- ~helm-info-octave-mode~ ::

  #+findex: helm-info-octave-mode

  Predefined helm for octave-mode info.

- ~helm-info-todo-mode~ ::

  #+findex: helm-info-todo-mode

  Predefined helm for todo-mode info.

- ~helm-info-vhdl-mode~ ::

  #+findex: helm-info-vhdl-mode

  Predefined helm for vhdl-mode info.

*** Commands in library ~helm-info~ (excludes keymaps)

**** Cvs
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-info-cvs~ ::

  #+findex: helm-info-cvs

  Predefined helm for cvs info.

- ~helm-info-pcl-cvs~ ::

  #+findex: helm-info-pcl-cvs

  Predefined helm for pcl-cvs info.

**** Grub
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-info-grub~ ::

  #+findex: helm-info-grub

  Predefined helm for grub info.

- ~helm-info-grub-dev~ ::

  #+findex: helm-info-grub-dev

  Predefined helm for grub-dev info.

**** Find
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-info-find~ ::

  #+findex: helm-info-find

  Predefined helm for find info.

- ~helm-info-find-maint~ ::

  #+findex: helm-info-find-maint

  Predefined helm for find-maint info.

**** Manual
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-info-helm-manual~ ::

  #+findex: helm-info-helm-manual

  Predefined helm for helm-manual info.

- ~helm-info-helm-manual-1~ ::

  #+findex: helm-info-helm-manual-1

  Predefined helm for helm-manual-1 info.

**** Automake
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-info-automake-1~ ::

  #+findex: helm-info-automake-1

  Predefined helm for automake-1 info.

- ~helm-info-automake-history~ ::

  #+findex: helm-info-automake-history

  Predefined helm for automake-history info.

**** Lzip
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-info-lzip~ ::

  #+findex: helm-info-lzip

  Predefined helm for lzip info.

- ~helm-info-lzip-compressor~ ::

  #+findex: helm-info-lzip-compressor

  Predefined helm for lzip-compressor info.

- ~helm-info-lzip-decompressor~ ::

  #+findex: helm-info-lzip-decompressor

  Predefined helm for lzip-decompressor info.

**** Emacs
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c h r)}}} (~helm-info-emacs~) ::

  #+findex: helm-info-emacs

  #+kindex: C-x c h r

  Predefined helm for emacs info.

- ~helm-info-emacs-gnutls~ ::

  #+findex: helm-info-emacs-gnutls

  Predefined helm for emacs-gnutls info.

- ~helm-info-emacs-mime~ ::

  #+findex: helm-info-emacs-mime

  Predefined helm for emacs-mime info.

**** R uncategorized uncategorized uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-info-R-FAQ~ ::

  #+findex: helm-info-R-FAQ

  Predefined helm for R-FAQ info.

- ~helm-info-R-admin~ ::

  #+findex: helm-info-R-admin

  Predefined helm for R-admin info.

- ~helm-info-R-data~ ::

  #+findex: helm-info-R-data

  Predefined helm for R-data info.

- ~helm-info-R-exts~ ::

  #+findex: helm-info-R-exts

  Predefined helm for R-exts info.

- ~helm-info-R-intro~ ::

  #+findex: helm-info-R-intro

  Predefined helm for R-intro info.

- ~helm-info-R-ints~ ::

  #+findex: helm-info-R-ints

  Predefined helm for R-ints info.

- ~helm-info-R-lang~ ::

  #+findex: helm-info-R-lang

  Predefined helm for R-lang info.

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-info-nxml-mode~ ::

  #+findex: helm-info-nxml-mode

  Predefined helm for nxml-mode info.

- ~helm-info-octave-mode~ ::

  #+findex: helm-info-octave-mode

  Predefined helm for octave-mode info.

- ~helm-info-todo-mode~ ::

  #+findex: helm-info-todo-mode

  Predefined helm for todo-mode info.

- ~helm-info-vhdl-mode~ ::

  #+findex: helm-info-vhdl-mode

  Predefined helm for vhdl-mode info.

**** uncategorized uncategorized uncategorized uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-info~ ::

  #+findex: helm-info

  (helm-info &optional REFRESH)

  Preconfigured ~helm~ for searching Info files' indices.

  With a prefix argument \[universal-argument], set REFRESH to
  non-nil.

  Optional parameter REFRESH, when non-nil, re-evaluates
  ~helm-default-info-index-list~.  If the variable has been
  customized, set it to its saved value.  If not, set it to its
  standard value. See ~custom-reevaluate-setting~ for more.

  REFRESH is useful when new Info files are installed.  If
  ~helm-default-info-index-list~ has not been customized, the new
  Info files are made available.

- {{{kbd(C-x c h i)}}} (~helm-info-at-point~) ::

  #+findex: helm-info-at-point

  #+kindex: C-x c h i

  Preconfigured ~helm~ for searching info at point.

- ~helm-info-auth~ ::

  #+findex: helm-info-auth

  Predefined helm for auth info.

- ~helm-info-autosprintf~ ::

  #+findex: helm-info-autosprintf

  Predefined helm for autosprintf info.

- ~helm-info-autotype~ ::

  #+findex: helm-info-autotype

  Predefined helm for autotype info.

- ~helm-info-bc~ ::

  #+findex: helm-info-bc

  Predefined helm for bc info.

- ~helm-info-bovine~ ::

  #+findex: helm-info-bovine

  Predefined helm for bovine info.

- ~helm-info-bzip2~ ::

  #+findex: helm-info-bzip2

  Predefined helm for bzip2 info.

- ~helm-info-calc~ ::

  #+findex: helm-info-calc

  Predefined helm for calc info.

- ~helm-info-ccmode~ ::

  #+findex: helm-info-ccmode

  Predefined helm for ccmode info.

- ~helm-info-cl~ ::

  #+findex: helm-info-cl

  Predefined helm for cl info.

- ~helm-info-com_err~ ::

  #+findex: helm-info-com_err

  Predefined helm for com_err info.

- ~helm-info-coreutils~ ::

  #+findex: helm-info-coreutils

  Predefined helm for coreutils info.

- ~helm-info-cvsclient~ ::

  #+findex: helm-info-cvsclient

  Predefined helm for cvsclient info.

- ~helm-info-dbus~ ::

  #+findex: helm-info-dbus

  Predefined helm for dbus info.

- ~helm-info-dc~ ::

  #+findex: helm-info-dc

  Predefined helm for dc info.

- ~helm-info-diffutils~ ::

  #+findex: helm-info-diffutils

  Predefined helm for diffutils info.

- ~helm-info-dired-x~ ::

  #+findex: helm-info-dired-x

  Predefined helm for dired-x info.

- ~helm-info-dvipng~ ::

  #+findex: helm-info-dvipng

  Predefined helm for dvipng info.

- ~helm-info-dvips~ ::

  #+findex: helm-info-dvips

  Predefined helm for dvips info.

- ~helm-info-ebrowse~ ::

  #+findex: helm-info-ebrowse

  Predefined helm for ebrowse info.

- ~helm-info-ed~ ::

  #+findex: helm-info-ed

  Predefined helm for ed info.

- ~helm-info-ede~ ::

  #+findex: helm-info-ede

  Predefined helm for ede info.

- ~helm-info-ediff~ ::

  #+findex: helm-info-ediff

  Predefined helm for ediff info.

- ~helm-info-edt~ ::

  #+findex: helm-info-edt

  Predefined helm for edt info.

- ~helm-info-eieio~ ::

  #+findex: helm-info-eieio

  Predefined helm for eieio info.

- ~helm-info-eintr~ ::

  #+findex: helm-info-eintr

  Predefined helm for eintr info.

- ~helm-info-elisp~ ::

  #+findex: helm-info-elisp

  Predefined helm for elisp info.

- ~helm-info-emms~ ::

  #+findex: helm-info-emms

  Predefined helm for emms info.

- ~helm-info-epa~ ::

  #+findex: helm-info-epa

  Predefined helm for epa info.

- ~helm-info-erc~ ::

  #+findex: helm-info-erc

  Predefined helm for erc info.

- ~helm-info-ert~ ::

  #+findex: helm-info-ert

  Predefined helm for ert info.

- ~helm-info-eshell~ ::

  #+findex: helm-info-eshell

  Predefined helm for eshell info.

- ~helm-info-eudc~ ::

  #+findex: helm-info-eudc

  Predefined helm for eudc info.

- ~helm-info-eww~ ::

  #+findex: helm-info-eww

  Predefined helm for eww info.

- ~helm-info-fastjar~ ::

  #+findex: helm-info-fastjar

  Predefined helm for fastjar info.

- ~helm-info-flex~ ::

  #+findex: helm-info-flex

  Predefined helm for flex info.

- ~helm-info-flymake~ ::

  #+findex: helm-info-flymake

  Predefined helm for flymake info.

- ~helm-info-fontname~ ::

  #+findex: helm-info-fontname

  Predefined helm for fontname info.

- ~helm-info-forms~ ::

  #+findex: helm-info-forms

  Predefined helm for forms info.

- ~helm-info-gettext~ ::

  #+findex: helm-info-gettext

  Predefined helm for gettext info.

- ~helm-info-global~ ::

  #+findex: helm-info-global

  Predefined helm for global info.

- ~helm-info-gnupg~ ::

  #+findex: helm-info-gnupg

  Predefined helm for gnupg info.

- {{{kbd(C-x c h g)}}} (~helm-info-gnus~) ::

  #+findex: helm-info-gnus

  #+kindex: C-x c h g

  Predefined helm for gnus info.

- ~helm-info-gpm~ ::

  #+findex: helm-info-gpm

  Predefined helm for gpm info.

- ~helm-info-grep~ ::

  #+findex: helm-info-grep

  Predefined helm for grep info.

- ~helm-info-gzip~ ::

  #+findex: helm-info-gzip

  Predefined helm for gzip info.

- ~helm-info-helm~ ::

  #+findex: helm-info-helm

  Predefined helm for helm info.

- ~helm-info-helm-bugs~ ::

  #+findex: helm-info-helm-bugs

  Predefined helm for helm-bugs info.

- ~helm-info-helm-devel~ ::

  #+findex: helm-info-helm-devel

  Predefined helm for helm-devel info.

- ~helm-info-htmlfontify~ ::

  #+findex: helm-info-htmlfontify

  Predefined helm for htmlfontify info.

- ~helm-info-idlwave~ ::

  #+findex: helm-info-idlwave

  Predefined helm for idlwave info.

- ~helm-info-ido~ ::

  #+findex: helm-info-ido

  Predefined helm for ido info.

- ~helm-info-idutils~ ::

  #+findex: helm-info-idutils

  Predefined helm for idutils info.

- ~helm-info-info~ ::

  #+findex: helm-info-info

  Predefined helm for info info.

- ~helm-info-info-stnd~ ::

  #+findex: helm-info-info-stnd

  Predefined helm for info-stnd info.

- ~helm-info-kpathsea~ ::

  #+findex: helm-info-kpathsea

  Predefined helm for kpathsea info.

- ~helm-info-latex2man~ ::

  #+findex: helm-info-latex2man

  Predefined helm for latex2man info.

- ~helm-info-libffi~ ::

  #+findex: helm-info-libffi

  Predefined helm for libffi info.

- ~helm-info-m4~ ::

  #+findex: helm-info-m4

  Predefined helm for m4 info.

- ~helm-info-mairix-el~ ::

  #+findex: helm-info-mairix-el

  Predefined helm for mairix-el info.

- ~helm-info-message~ ::

  #+findex: helm-info-message

  Predefined helm for message info.

- ~helm-info-mh-e~ ::

  #+findex: helm-info-mh-e

  Predefined helm for mh-e info.

- ~helm-info-nano~ ::

  #+findex: helm-info-nano

  Predefined helm for nano info.

- ~helm-info-nettle~ ::

  #+findex: helm-info-nettle

  Predefined helm for nettle info.

- ~helm-info-newsticker~ ::

  #+findex: helm-info-newsticker

  Predefined helm for newsticker info.

- ~helm-info-org~ ::

  #+findex: helm-info-org

  Predefined helm for org info.

- ~helm-info-pgg~ ::

  #+findex: helm-info-pgg

  Predefined helm for pgg info.

- ~helm-info-rcirc~ ::

  #+findex: helm-info-rcirc

  Predefined helm for rcirc info.

- ~helm-info-rcs~ ::

  #+findex: helm-info-rcs

  Predefined helm for rcs info.

- ~helm-info-reftex~ ::

  #+findex: helm-info-reftex

  Predefined helm for reftex info.

- ~helm-info-remember~ ::

  #+findex: helm-info-remember

  Predefined helm for remember info.

- ~helm-info-rluserman~ ::

  #+findex: helm-info-rluserman

  Predefined helm for rluserman info.

- ~helm-info-sasl~ ::

  #+findex: helm-info-sasl

  Predefined helm for sasl info.

- ~helm-info-sc~ ::

  #+findex: helm-info-sc

  Predefined helm for sc info.

- ~helm-info-sed~ ::

  #+findex: helm-info-sed

  Predefined helm for sed info.

- ~helm-info-semantic~ ::

  #+findex: helm-info-semantic

  Predefined helm for semantic info.

- ~helm-info-ses~ ::

  #+findex: helm-info-ses

  Predefined helm for ses info.

- ~helm-info-sharutils~ ::

  #+findex: helm-info-sharutils

  Predefined helm for sharutils info.

- ~helm-info-sieve~ ::

  #+findex: helm-info-sieve

  Predefined helm for sieve info.

- ~helm-info-smtpmail~ ::

  #+findex: helm-info-smtpmail

  Predefined helm for smtpmail info.

- ~helm-info-spd-say~ ::

  #+findex: helm-info-spd-say

  Predefined helm for spd-say info.

- ~helm-info-speech-dispatcher~ ::

  #+findex: helm-info-speech-dispatcher

  Predefined helm for speech-dispatcher info.

- ~helm-info-speedbar~ ::

  #+findex: helm-info-speedbar

  Predefined helm for speedbar info.

- ~helm-info-srecode~ ::

  #+findex: helm-info-srecode

  Predefined helm for srecode info.

- ~helm-info-ssip~ ::

  #+findex: helm-info-ssip

  Predefined helm for ssip info.

- ~helm-info-tds~ ::

  #+findex: helm-info-tds

  Predefined helm for tds info.

- ~helm-info-texi2html~ ::

  #+findex: helm-info-texi2html

  Predefined helm for texi2html info.

- ~helm-info-texinfo~ ::

  #+findex: helm-info-texinfo

  Predefined helm for texinfo info.

- ~helm-info-time~ ::

  #+findex: helm-info-time

  Predefined helm for time info.

- ~helm-info-tlbuild~ ::

  #+findex: helm-info-tlbuild

  Predefined helm for tlbuild info.

- ~helm-info-tramp~ ::

  #+findex: helm-info-tramp

  Predefined helm for tramp info.

- ~helm-info-url~ ::

  #+findex: helm-info-url

  Predefined helm for url info.

- ~helm-info-vip~ ::

  #+findex: helm-info-vip

  Predefined helm for vip info.

- ~helm-info-viper~ ::

  #+findex: helm-info-viper

  Predefined helm for viper info.

- ~helm-info-wdiff~ ::

  #+findex: helm-info-wdiff

  Predefined helm for wdiff info.

- ~helm-info-web2c~ ::

  #+findex: helm-info-web2c

  Predefined helm for web2c info.

- ~helm-info-wget~ ::

  #+findex: helm-info-wget

  Predefined helm for wget info.

- ~helm-info-widget~ ::

  #+findex: helm-info-widget

  Predefined helm for widget info.

- ~helm-info-wisent~ ::

  #+findex: helm-info-wisent

  Predefined helm for wisent info.

- ~helm-info-woman~ ::

  #+findex: helm-info-woman

  Predefined helm for woman info.

- ~helm-info-xboard~ ::

  #+findex: helm-info-xboard

  Predefined helm for xboard info.

*** Options in library =helm-info=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-default-info-index-list~ ::

  #+vindex: helm-default-info-index-list

  *Standard Value*:

  #+begin_src emacs-lisp
    ("helm-bugs" "helm-devel" "helm-manual-1" "helm-manual" "helm" "emms" "R-FAQ" "R-admin" "R-data" "R-exts" "R-intro" "R-ints" "R-lang" "auth" "automake-1" "automake-history" "autosprintf" "autotype" "bc" "bovine" "bzip2" "calc" "ccmode" "cl" "com_err" "coreutils" "cvs" "cvsclient" "dbus" "dc" "diffutils" "dired-x" "dvipng" "dvips" "ebrowse" "ed" "ede" "ediff" "edt" "eieio" "eintr" "elisp" "emacs-gnutls" "emacs-mime" "emacs" "epa" "erc" "ert" "eshell" "eudc" "eww" "fastjar" "find-maint" "find" "flex" "flymake" "fontname" "forms" "gettext" "global" "gnupg" "gnus" "gpm" "grep" "grub-dev" "grub" "gzip" "htmlfontify" "idlwave" "ido" "idutils" "info-stnd" "info" "kpathsea" "latex2man" "libffi" "lzip-compressor" "lzip-decompressor" "lzip" "m4" "mairix-el" "message" "mh-e" "nano" "nettle" "newsticker" "nxml-mode" "octave-mode" "org" "pcl-cvs" "pgg" "rcirc" "rcs" "reftex" "remember" "rluserman" "sasl" "sc" "sed" "semantic" "ses" "sharutils" "sieve" "smtpmail" "spd-say" "speech-dispatcher" "speedbar" "srecode" "ssip" "tds" "texi2html" "texinfo" "time" "tlbuild" "todo-mode" "tramp" "url" "vhdl-mode" "vip" "viper" "wdiff" "web2c" "wget" "widget" "wisent" "woman" "xboard")
  #+end_src

  Info files to search in with ~helm-info~.

- ~helm-info-default-sources~ ::

  #+vindex: helm-info-default-sources

  *Standard Value*:

  #+begin_src emacs-lisp
    (helm-source-info-elisp helm-source-info-cl helm-source-info-eieio helm-source-info-pages)
  #+end_src

  Default sources to use for looking up symbols at point in Info
  files with ~helm-info-at-point~.

** Library: helm-lib

*** Commands in library ~helm-lib~ (excludes keymaps)

**** Point
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-undo-yank-text-at-point~ ::

  #+findex: helm-undo-yank-text-at-point

  Undo last entry added by ~helm-yank-text-at-point~.

- ~helm-yank-text-at-point~ ::

  #+findex: helm-yank-text-at-point

  (helm-yank-text-at-point ARG)

  Yank text at point in ~helm-current-buffer~ into minibuffer.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm--advice-wdired-finish-edit~ ::

  #+findex: helm--advice-wdired-finish-edit

*** Options in library =helm-lib=

**** File
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-boring-file-regexp-list~ ::

  #+vindex: helm-boring-file-regexp-list

  *Standard Value*:

  #+begin_src emacs-lisp
    ("\\.o$" "~$" "\\.bin$" "\\.lbin$" "\\.so$" "\\.a$" "\\.ln$" "\\.blg$" "\\.bbl$" "\\.elc$" "\\.lof$" "\\.glo$" "\\.idx$" "\\.lot$" "\\.svn\\(/\\|$\\)" "\\.hg\\(/\\|$\\)" "\\.git\\(/\\|$\\)" "\\.bzr\\(/\\|$\\)" "CVS\\(/\\|$\\)" "_darcs\\(/\\|$\\)" "_MTN\\(/\\|$\\)" "\\.fmt$" "\\.tfm$" "\\.class$" "\\.fas$" "\\.lib$" "\\.mem$" "\\.x86f$" "\\.sparcf$" "\\.dfsl$" "\\.pfsl$" "\\.d64fsl$" "\\.p64fsl$" "\\.lx64fsl$" "\\.lx32fsl$" "\\.dx64fsl$" "\\.dx32fsl$" "\\.fx64fsl$" "\\.fx32fsl$" "\\.sx64fsl$" "\\.sx32fsl$" "\\.wx64fsl$" "\\.wx32fsl$" "\\.fasl$" "\\.ufsl$" "\\.fsl$" "\\.dxl$" "\\.lo$" "\\.la$" "\\.gmo$" "\\.mo$" "\\.toc$" "\\.aux$" "\\.cp$" "\\.fn$" "\\.ky$" "\\.pg$" "\\.tp$" "\\.vr$" "\\.cps$" "\\.fns$" "\\.kys$" "\\.pgs$" "\\.tps$" "\\.vrs$" "\\.pyc$" "\\.pyo$")
  #+end_src

  A list of regexps matching boring files.

  This list is build by default on ~completion-ignored-extensions~.
  The directory names should end with "/?" e.g. "\.git/?" and
  the file names should end with "$" e.g. "\.o$".

  These regexps may be used to match the entire path, not just the
  file name, so for example to ignore files with a prefix
  ".bak.", use "\.bak\..*$" as the regexp.

  NOTE: When modifying this, be sure to use customize interface or
  the customize functions e.g. ~customize-set-variable~ and NOT
  ~setq~.

- ~helm-file-globstar~ ::

  #+vindex: helm-file-globstar

  *Standard Value*: t

  Same as globstar bash shopt option.
  When non-nil a pattern beginning with two stars will expand
  recursively.
  Directories expansion is not supported yet.

**** Help
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-help-default-prompt~ ::

  #+vindex: helm-help-default-prompt

  *Standard Value*: [SPC,C-v,next:ScrollUp  b,M-v,prior:ScrollDown TAB:Cycle M-TAB:All C-s/r:Isearch q:Quit]

  The prompt used in ~helm-help~.

- ~helm-help-full-frame~ ::

  #+vindex: helm-help-full-frame

  *Standard Value*: t

  Display help window in full frame when non nil.

  Even when nil probably the same result (full frame) can be
  reached by tweaking ~display-buffer-alist~, but it is much more
  convenient to use a simple boolean value here.

- ~helm-help-hkmap~ ::

  #+vindex: helm-help-hkmap

  *Standard Value*:

  #+begin_src emacs-lisp
    (("C-v" . helm-help-scroll-up)
     ("SPC" . helm-help-scroll-up)
     ("<next>" . helm-help-scroll-up)
     ("M-v" . helm-help-scroll-down)
     ("b" . helm-help-scroll-down)
     ("<prior>" . helm-help-scroll-down)
     ("C-s" . isearch-forward)
     ("C-r" . isearch-backward)
     ("C-a" . move-beginning-of-line)
     ("C-e" . move-end-of-line)
     ("C-f" . forward-char)
     ("<right>" . forward-char)
     ("C-b" . backward-char)
     ("<left>" . backward-char)
     ("C-n" . helm-help-next-line)
     ("C-p" . helm-help-previous-line)
     ("<down>" . helm-help-next-line)
     ("<up>" . helm-help-previous-line)
     ("M-a" . backward-sentence)
     ("M-e" . forward-sentence)
     ("M-f" . forward-word)
     ("M-b" . backward-word)
     ("M->" . end-of-buffer)
     ("M-<" . beginning-of-buffer)
     ("C-SPC" . helm-help-toggle-mark)
     ("C-M-SPC" . mark-sexp)
     ("TAB" . org-cycle)
     ("C-m" . helm-help-org-open-at-point)
     ("C-&" . helm-help-org-mark-ring-goto)
     ("C-%" . org-mark-ring-push)
     ("M-TAB" . helm-help-org-cycle)
     ("M-w" . helm-help-copy-region-as-kill)
     ("q" . helm-help-quit))
  #+end_src

  Alist of (KEY . FUNCTION) for ~helm-help~.

  This is not a standard keymap, just an alist where it is possible to
  define a simple KEY (a string with no spaces) associated with a
  FUNCTION. More complex key like "C-x C-x" are not supported.
  Interactive functions will be called interactively whereas other
  functions will be called with funcall except commands that are in
  ~helm-help-not-interactive-command~.
  For convenience you can add bindings here with ~helm-help-define-key~.

**** Function
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-describe-function-function~ ::

  #+vindex: helm-describe-function-function

  *Standard Value*: describe-function

  Function used to describe functions in Helm.

- ~helm-describe-variable-function~ ::

  #+vindex: helm-describe-variable-function

  *Standard Value*: describe-variable

  Function used to describe variables in Helm.

- ~helm-yank-text-at-point-function~ ::

  #+vindex: helm-yank-text-at-point-function

  *Standard Value*: nil

  The function used to forward point with ~helm-yank-text-at-point~.
  With a nil value, fallback to default ~forward-word~.
  The function should take one arg, an integer like ~forward-word~.
  NOTE: Using ~forward-symbol~ here is not very useful as it is
  already provided by M-n.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-advice-push-mark~ ::

  #+vindex: helm-advice-push-mark

  *Standard Value*: t

  Override ~push-mark~ with a version avoiding duplicates when non-nil.

- ~helm-scroll-amount~ ::

  #+vindex: helm-scroll-amount

  *Standard Value*: nil

  Scroll amount when scrolling other window in a helm session.
  It is used by ~helm-scroll-other-window~
  and ~helm-scroll-other-window-down~.

  If you prefer scrolling line by line, set this value to 1.

*** Hooks in library =helm-lib=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-help-mode-after-hook~ ::

  #+vindex: helm-help-mode-after-hook

  *Standard Value*: nil

  A hook that runs when helm-help exits.

- ~helm-help-mode-before-hook~ ::

  #+vindex: helm-help-mode-before-hook

  *Standard Value*: nil

  A hook that runs before helm-help starts.

** Library: helm-locate

*** Commands in keymap ~helm-locate-map~

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(DEL)}}} (~helm-delete-backward-no-update~) ::

  #+findex: helm-delete-backward-no-update @r{(helm-locate-map)}

  #+kindex: DEL @r{(helm-locate-map)}

  (helm-delete-backward-no-update ARG)

  Disable update and delete ARG chars backward.
  Update is reenabled when idle 1s.

*** Commands in library ~helm-locate~ (excludes keymaps)

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c l)}}} (~helm-locate~) ::

  #+findex: helm-locate

  #+kindex: C-x c l

  (helm-locate ARG)

  Preconfigured ~helm~ for Locate.
  Note: you can add locate options after entering pattern.
  See 'man locate' for valid options and also ~helm-locate-command~.

  You can specify a local database with prefix argument ARG.
  With two prefix arg, refresh the current local db or create it if
  it doesn't exists.

  To create a user specific db, use
  "updatedb -l 0 -o db_path -U directory".
  Where db_path is a filename matched by
  ~helm-locate-db-file-regexp~.

- ~helm-projects-find-files~ ::

  #+findex: helm-projects-find-files

  (helm-projects-find-files UPDATE)

  Find files with locate in ~helm-locate-project-list~.
  With a prefix arg refresh the database in each project.

*** Options in library =helm-locate=

**** Fuzzy
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-locate-fuzzy-match~ ::

  #+vindex: helm-locate-fuzzy-match

  *Standard Value*: nil

  Enable fuzzy matching in ~helm-locate~.
  Note that when this is enabled searching is done on basename.

- ~helm-locate-fuzzy-sort-fn~ ::

  #+vindex: helm-locate-fuzzy-sort-fn

  *Standard Value*: helm-locate-default-fuzzy-sort-fn

  Default fuzzy matching sort function for locate.

**** Db
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ff-locate-db-filename~ ::

  #+vindex: helm-ff-locate-db-filename

  *Standard Value*: locate.db

  The basename of the locatedb file you use locally in your directories.
  When this is set and Helm finds such a file in the directory from
  where you launch locate, it will use this file and will not
  prompt you for a db file.
  Note that this happen only when locate is launched with a prefix
  arg.

- ~helm-locate-db-file-regexp~ ::

  #+vindex: helm-locate-db-file-regexp

  *Standard Value*: m?locate.db$

  Default regexp to match locate database.
  If nil Search in all files.

**** Command
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-locate-command~ ::

  #+vindex: helm-locate-command

  *Standard Value*: nil

  A list of arguments for locate program.

  Helm will calculate a default value for your system on startup
  unless ~helm-locate-command~ is non-nil.

  Here are the default values it will use according to your system:

  Gnu/linux:     "locate %s -e -A --regex %s"
  berkeley-unix: "locate %s %s"
  windows-nt:    "es %s %s"
  Others:        "locate %s %s"

  This string will be passed to format so it should end with ~%s~.
  The first format spec is used for the "-i" value of locate/es,
  so don’t set it directly but use ~helm-locate-case-fold-search~
  for this.

  The last option must be the one preceding pattern i.e "-r" or
  "--regex".

  You will be able to pass other options such as "-b" or "l"
  during Helm invocation after entering pattern only when multi
  matching, not when fuzzy matching.

  Note that the "-b" option is added automatically by Helm when
  var ~helm-locate-fuzzy-match~ is non-nil and switching back from
  multimatch to fuzzy matching (this is done automatically when a
  space is detected in pattern).

- ~helm-locate-create-db-command~ ::

  #+vindex: helm-locate-create-db-command

  *Standard Value*: updatedb -l 0 -o '%s' -U '%s'

  Command used to create a locale locate db file.

- ~helm-locate-recursive-dirs-command~ ::

  #+vindex: helm-locate-recursive-dirs-command

  *Standard Value*: locate -i -e -A --regex '^%s' '%s.*$'

  Command used for recursive directories completion in ~helm-find-files~.

  For Windows and ~es~ use something like "es -r ^%s.*%s.*$"

  The two format specs are mandatory.

  If for some reasons you can’t use locate because your filesystem
  doesn’t have a database, you can use find command from findutils
  but be aware that it will be much slower.  See ~helm-find-files~
  embedded help for more infos.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-locate-case-fold-search~ ::

  #+vindex: helm-locate-case-fold-search

  *Standard Value*: smart

  It have the same meaning as ~helm-case-fold-search~.
  The -i option of locate will be used depending of value of
  ~helm-pattern~ when this is set to ’smart.
  When nil "-i" will not be used at all and when non-nil it will
  always be used.
  NOTE: the -i option of the "es" command used on windows does
  the opposite of "locate" command.

- ~helm-locate-project-list~ ::

  #+vindex: helm-locate-project-list

  *Standard Value*: nil

  A list of directories, your projects.
  When set, allow browsing recursively files in all directories of
  this list with ~helm-projects-find-files~.

** Library: helm-man

*** Commands in library ~helm-man~ (excludes keymaps)

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c m)}}} (~helm-man-woman~) ::

  #+findex: helm-man-woman

  #+kindex: C-x c m

  (helm-man-woman ARG)

  Preconfigured ~helm~ for Man and Woman pages.
  With a prefix arg reinitialize the cache.

*** Options in library =helm-man=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-man-format-switches~ ::

  #+vindex: helm-man-format-switches

  *Standard Value*: -l %s

  Arguments to pass to the ~manual-entry~ function.
  Arguments are passed to ~manual-entry~ with ~format.~

- ~helm-man-or-woman-function~ ::

  #+vindex: helm-man-or-woman-function

  *Standard Value*: Man-getpage-in-background

  Default command to display a man page.

** Library: helm-misc

*** Commands in library ~helm-misc~ (excludes keymaps)

**** Commands
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-ratpoison-commands~ ::

  #+findex: helm-ratpoison-commands

  Preconfigured ~helm~ to execute ratpoison commands.

- ~helm-stumpwm-commands~ ::

  #+findex: helm-stumpwm-commands

  Preconfigured helm for stumpwm commands.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-insert-latex-math~ ::

  #+findex: helm-insert-latex-math

  Preconfigured helm for latex math symbols completion.

- ~helm-world-time~ ::

  #+findex: helm-world-time

  Preconfigured ~helm~ to show world time.
  Default action change TZ environment variable locally to emacs.

*** Options in library =helm-misc=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-minibuffer-history-must-match~ ::

  #+vindex: helm-minibuffer-history-must-match

  *Standard Value*: t

  Allow inserting non matching elements when nil or ’confirm.

- ~helm-time-zone-home-location~ ::

  #+vindex: helm-time-zone-home-location

  *Standard Value*: Paris

  The time zone of your home.

- ~helm-timezone-actions~ ::

  #+vindex: helm-timezone-actions

  *Standard Value*:

  #+begin_src emacs-lisp
    (("Set timezone env (TZ)" lambda
      (candidate)
      (setenv "TZ" candidate)))
  #+end_src

  Actions for helm-timezone.

** Library: helm-mode

*** Modes in library ~helm-mode~

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-mode~ ::

  #+findex: helm-mode

  (helm-mode &optional ARG)

  Toggle generic helm completion.

  If called interactively, toggle ~Helm mode~.  If the prefix
  argument is positive, enable the mode, and if it is zero or
  negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

  All functions in Emacs that use ~completing-read~,
  ~read-file-name~, ~completion-in-region~ and friends will use helm
  interface when this mode is turned on.

  However you can modify this behavior for functions of your choice
  with ~helm-completing-read-handlers-alist~.

  Called with a positive arg, turn on unconditionally, with a
  negative arg turn off.
  You can toggle it with M-x ~helm-mode~.

  About ~ido-mode~:
  DO NOT enable ~ido-everywhere~ when using ~helm-mode~.  Instead of
  using ~ido-mode~, add the commands where you want to use ido to
  ~helm-completing-read-handlers-alist~ with ~ido~ as value.

  Note: This mode is incompatible with Emacs23.

*** Commands in keymap ~helm-comp-read-map~

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-<return>)}}} ::
- {{{kbd(M-RET)}}} (~helm-cr-empty-string~) ::

  #+findex: helm-cr-empty-string @r{(helm-comp-read-map)}

  #+kindex: C-<return> @r{(helm-comp-read-map)}
  #+kindex: M-RET @r{(helm-comp-read-map)}

  Return empty string.

- {{{kbd(DEL)}}} (~helm-mode-delete-char-backward-maybe~) ::

  #+findex: helm-mode-delete-char-backward-maybe @r{(helm-comp-read-map)}

  #+kindex: DEL @r{(helm-comp-read-map)}

  Delete char backward when text is not the prefix helm is completing against.
  First call warns user about deleting prefix completion.
  Second call deletes backward char in current-buffer and quits helm completion,
  letting the user start a new completion with a new prefix.

*** Commands in library ~helm-mode~ (excludes keymaps)

**** Backward
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-mode-delete-char-backward-1~ ::

  #+findex: helm-mode-delete-char-backward-1

- ~helm-mode-delete-char-backward-2~ ::

  #+findex: helm-mode-delete-char-backward-2

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-mode~ ::

  #+findex: helm-mode

  (helm-mode &optional ARG)

  Toggle generic helm completion.

  If called interactively, toggle ~Helm mode~.  If the prefix
  argument is positive, enable the mode, and if it is zero or
  negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

  All functions in Emacs that use ~completing-read~,
  ~read-file-name~, ~completion-in-region~ and friends will use helm
  interface when this mode is turned on.

  However you can modify this behavior for functions of your choice
  with ~helm-completing-read-handlers-alist~.

  Called with a positive arg, turn on unconditionally, with a
  negative arg turn off.
  You can toggle it with M-x ~helm-mode~.

  About ~ido-mode~:
  DO NOT enable ~ido-everywhere~ when using ~helm-mode~.  Instead of
  using ~ido-mode~, add the commands where you want to use ido to
  ~helm-completing-read-handlers-alist~ with ~ido~ as value.

  Note: This mode is incompatible with Emacs23.

*** Options in library =helm-mode=

**** Read
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-comp-read-case-fold-search~ ::

  #+vindex: helm-comp-read-case-fold-search

  *Standard Value*: smart

  Default Local setting of ~helm-case-fold-search~ for ~helm-comp-read~.
  See ~helm-case-fold-search~ for more info.

**** Alist
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-completing-read-handlers-alist~ ::

  #+vindex: helm-completing-read-handlers-alist

  *Standard Value*:

  #+begin_src emacs-lisp
    ((find-tag . helm-completing-read-default-find-tag)
     (xref-find-definitions . helm-completing-read-default-find-tag)
     (xref-find-references . helm-completing-read-default-find-tag)
     (ggtags-find-tag-dwim . helm-completing-read-default-find-tag)
     (tmm-menubar)
     (find-file)
     (execute-extended-command)
     (dired-do-rename . helm-read-file-name-handler-1)
     (dired-do-copy . helm-read-file-name-handler-1)
     (dired-do-symlink . helm-read-file-name-handler-1)
     (dired-do-relsymlink . helm-read-file-name-handler-1)
     (dired-do-hardlink . helm-read-file-name-handler-1)
     (basic-save-buffer . helm-read-file-name-handler-1)
     (write-file . helm-read-file-name-handler-1)
     (write-region . helm-read-file-name-handler-1))
  #+end_src

  Completing read functions for specific Emacs commands.

  By default ~helm-mode~ use ~helm-completing-read-default-handler~ to
  provide helm completion in each ~completing-read~ or ~read-file-name~
  found, but other functions can be specified here for specific
  commands. This also allows disabling helm completion for some commands
  when needed.

  Each entry is a cons cell like (EMACS_COMMAND . COMPLETING-READ_HANDLER)
  where key and value are symbols.

  Each key is an Emacs command that use originaly ~completing-read~.

  Each value maybe a helm function that takes same arguments as
  ~completing-read~ plus NAME and BUFFER, where NAME is the name of the new
  helm source and BUFFER the name of the buffer we will use, but it can
  be also a function not using helm, in this case the function should
  take the same args as ~completing-read~ and not be prefixed by "helm-".

  ~helm~ will use the name of the command calling ~completing-read~ as
  NAME and BUFFER will be computed as well with NAME but prefixed with
  "*helm-mode-".

  This function prefix name must start by "helm-" when it uses helm,
  otherwise ~helm~ assumes the function is not a helm function and
  expects the same args as ~completing-read~, this allows you to define a
  handler not using helm completion.

  Example:

      (defun foo/test ()
	(interactive)
	(message "%S" (completing-read "test: " ’(a b c d e))))

      (defun helm-foo/test-completing-read-handler (prompt collection
						    predicate require-match
						    initial-input hist def
						    inherit-input-method
						    name buffer)
	(helm-comp-read prompt collection :marked-candidates t
					  :name name
					  :buffer buffer))

      (add-to-list ’helm-completing-read-handlers-alist
		   ’(foo/test . helm-foo/test-completing-read-handler))

  We want here to make the regular ~completing-read~ in ~foo/test~
  return a list of candidate(s) instead of a single candidate.

  Note that this function will be reused for ALL the ~completing-read~
  of this command, so it should handle all cases. E.g.,
  if first ~completing-read~ completes against symbols and
  second ~completing-read~ should handle only buffer,
  your specialized function should handle both.

  If the value of an entry is nil completion will fall back to
  Emacs vanilla behaviour.
  Example:

  If you want to disable helm completion for ~describe-function~, use:

      (describe-function . nil)

  Ido is also supported, you can use ~ido-completing-read~ and
  ~ido-read-file-name~ as value of an entry or just ’ido.
  Example:
  Enable ido completion for ~find-file~:

      (find-file . ido)

  same as

      (find-file . ido-read-file-name)

  Note that you don’t need to enable ~ido-mode~ for this to work, see
  ~helm-mode~ documentation.

**** Mode
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-mode-fuzzy-match~ ::

  #+vindex: helm-mode-fuzzy-match

  *Standard Value*: nil

  Enable fuzzy matching in ~helm-mode~ globally.

  This is deprecated, use instead helm-fuzzy as ~helm-completion-style~ or
  even better ’emacs as ~helm-completion-style~ and add ’flex to
  ~completion-styles~ (emacs-27) or ’helm-flex if ’flex is not available
  in ~completion-styles-alist~ (emacs-26).

- ~helm-mode-hook~ ::

  #+vindex: helm-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

- ~helm-mode-reverse-history~ ::

  #+vindex: helm-mode-reverse-history

  *Standard Value*: t

  Display history source after current source when non nil.

  Apply only in ~helm-mode~ handled commands.

**** Completion
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-completion-in-region-default-sort-fn~ ::

  #+vindex: helm-completion-in-region-default-sort-fn

  *Standard Value*: helm-completion-in-region-sort-fn

  The default sort function to sort candidates in completion-in-region.

  When nil no sorting is done.
  The function is a ~filtered-candidate-transformer~ function which takes
  two args CANDIDATES and SOURCE.
  The function must use the flag ~helm-completion--sorting-done~ and
  return CANDIDATES unchanged when the flag is nil.
  See default function ~helm-completion-in-region-sort-fn~ as example.
  It will be used only when ~helm-completion-style~ is either Emacs or
  helm, otherwise when helm-fuzzy style is used, the fuzzy sort function
  will be used.

- ~helm-completion-mark-suffix~ ::

  #+vindex: helm-completion-mark-suffix

  *Standard Value*: t

  Push mark at end of suffix when non nil.

- ~helm-completion-style~ ::

  #+vindex: helm-completion-style

  *Standard Value*: helm

  Style of completion to use in ~completion-in-region~.

  This affects only ~completion-at-point~ and friends, and
  the ~completing-read~ using the default handler
  i.e. ~helm-completing-read-default-handler~.

  NB: This has nothing to do with ~completion-styles~, it is independent from
  helm, but when using ’emacs as helm-completion-style helm
  will use the ~completion-styles~ for its completions.
  Up to the user to configure ~completion-styles~.

  There are three possible values to use:

  - helm, use multi match regular helm completion.

  - helm-fuzzy, use fuzzy matching.  Note that as usual when
    entering a space helm switch to multi matching mode.

  - emacs, use regular Emacs completion according to
    ~completion-styles~.  Note that even in this style, helm allows using
    multi match.  Emacs-27 provides a style called ~flex~ that can be used
    aside ~helm~ style (see ~completion-styles-alist~).  When ~flex~ style
    is not available (Emacs<27) helm provides ~helm-flex~ style which is similar to
    ~flex~ and helm fuzzy matching.

  For a better experience, if you don’t know what to use, set
  ~completion-styles~ to ’(flex) if you are using emacs-27 or to
  ’(helm-flex) if you are using emacs-26 and keep ’emacs as default
  value for ~helm-completion-style~.  Advanced users can also have a
  look to ~completion-category-overrides~ to set styles according to category.

  Please use custom interface or ~customize-set-variable~ to set this,
  NOT ~setq~.

- ~helm-completion-styles-alist~ ::

  #+vindex: helm-completion-styles-alist

  *Standard Value*:

  #+begin_src emacs-lisp
    ((gud-mode . helm))
  #+end_src

  Allow configuring ~helm-completion-style~ per mode.

  Each entry is a cons cell like (mode . style) where style must be a
  suitable value for ~helm-completion-style~.
  When specifying emacs as style for a mode, ~completion-styles~ can be
  specified by using a cons cell specifying completion-styles to use
  with helm emacs style, e.g. (foo-mode . (emacs helm flex)) will set
  ~completion-styles~ to ’(helm flex) for foo-mode.  This affects only
  completions happening in buffers and not minibuffer completions,
  i.e. completing-read’s.

- ~helm-mode-handle-completion-in-region~ ::

  #+vindex: helm-mode-handle-completion-in-region

  *Standard Value*: t

  Whether to replace or not ~completion-in-region-function~.
  This enables support for ~completing-read-multiple~ and ~completion-at-point~
  when non--nil.

- ~helm-mode-no-completion-in-region-in-modes~ ::

  #+vindex: helm-mode-no-completion-in-region-in-modes

  *Standard Value*: nil

  A list of modes that do not want helm for ~completion-in-region~.

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-mode~ ::

  #+vindex: helm-mode

  *Standard Value*: t

  (helm-mode &optional ARG)

  Toggle generic helm completion.

  If called interactively, toggle ~Helm mode~.  If the prefix
  argument is positive, enable the mode, and if it is zero or
  negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

  All functions in Emacs that use ~completing-read~,
  ~read-file-name~, ~completion-in-region~ and friends will use helm
  interface when this mode is turned on.

  However you can modify this behavior for functions of your choice
  with ~helm-completing-read-handlers-alist~.

  Called with a positive arg, turn on unconditionally, with a
  negative arg turn off.
  You can toggle it with M-x ~helm-mode~.

  About ~ido-mode~:
  DO NOT enable ~ido-everywhere~ when using ~helm-mode~.  Instead of
  using ~ido-mode~, add the commands where you want to use ido to
  ~helm-completing-read-handlers-alist~ with ~ido~ as value.

  Note: This mode is incompatible with Emacs23.

*** Hooks in library =helm-mode=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-mode--ido-everywhere-hook~ ::

  #+vindex: helm-mode--ido-everywhere-hook

  *Standard Value*:

- ~helm-mode-hook~ ::

  #+vindex: helm-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

- ~helm-mode-minibuffer-setup-hook-black-list~ ::

  #+vindex: helm-mode-minibuffer-setup-hook-black-list

  *Standard Value*:

  #+begin_src emacs-lisp
    (minibuffer-completion-help)
  #+end_src

  Incompatible ~minibuffer-setup-hook~ functions go here.
  A list of symbols.  ~helm-mode~ is rejecting all lambda’s, byte-code fns
  and all functions belonging in this list from ~minibuffer-setup-hook~.
  This is mainly needed to prevent "*Completions*" buffers to popup.

** Library: helm-multi-match

*** Modes in library ~helm-multi-match~

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-migemo-mode~ ::

  #+findex: helm-migemo-mode

  (helm-migemo-mode &optional ARG)

  Enable migemo in helm.
  It will be available in the sources handling it,
  i.e. the sources which have the slot :migemo with non--nil value.

  If called interactively, toggle ~Helm-Migemo mode~.  If the
  prefix argument is positive, enable the mode, and if it is zero
  or negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

*** Commands in library ~helm-multi-match~ (excludes keymaps)

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-migemo-mode~ ::

  #+findex: helm-migemo-mode

  (helm-migemo-mode &optional ARG)

  Enable migemo in helm.
  It will be available in the sources handling it,
  i.e. the sources which have the slot :migemo with non--nil value.

  If called interactively, toggle ~Helm-Migemo mode~.  If the
  prefix argument is positive, enable the mode, and if it is zero
  or negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

*** Options in library =helm-multi-match=

**** Migemo
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-migemo-mode-hook~ ::

  #+vindex: helm-migemo-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm-migemo-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-migemo-mode~ ::

  #+vindex: helm-migemo-mode

  *Standard Value*: nil

  (helm-migemo-mode &optional ARG)

  Enable migemo in helm.
  It will be available in the sources handling it,
  i.e. the sources which have the slot :migemo with non--nil value.

  If called interactively, toggle ~Helm-Migemo mode~.  If the
  prefix argument is positive, enable the mode, and if it is zero
  or negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-mm-matching-method~ ::

  #+vindex: helm-mm-matching-method

  *Standard Value*: multi3

  Matching method for helm match plugin.
  You can set here different methods to match candidates in helm.
  Here are the possible value of this symbol and their meaning:
  - multi1: Respect order, prefix of pattern must match.
  - multi2: Same but with partial match.
  - multi3: The best, multiple regexp match, allow negation.
  - multi3p: Same but prefix must match.

  Default is multi3, you should keep this for a better experience.

  Note that multi1 and multi3p are incompatible with fuzzy matching
  in file completion and by the way fuzzy matching will be disabled there
  when these options are used.

*** Hooks in library =helm-multi-match=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-migemo-mode-hook~ ::

  #+vindex: helm-migemo-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm-migemo-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

** Library: helm-net

*** Commands in library ~helm-net~ (excludes keymaps)

**** Browse
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-browse-url-chromium~ ::

  #+findex: helm-browse-url-chromium

  (helm-browse-url-chromium URL &optional IGNORE)

  Browse URL with Google Chrome browser.

- ~helm-browse-url-conkeror~ ::

  #+findex: helm-browse-url-conkeror

  (helm-browse-url-conkeror URL &optional IGNORE)

  Browse URL with conkeror browser.

- ~helm-browse-url-firefox~ ::

  #+findex: helm-browse-url-firefox

  (helm-browse-url-firefox URL &optional IGNORE)

  Same as ~browse-url-firefox~ but detach from Emacs.

  So when you quit Emacs you can keep your Firefox session open and
  not be prompted to kill the Firefox process.

  NOTE: Probably not supported on some systems (e.g., Windows).

- ~helm-browse-url-next~ ::

  #+findex: helm-browse-url-next

  (helm-browse-url-next URL &optional IGNORE)

  Browse URL with next browser.

- ~helm-browse-url-opera~ ::

  #+findex: helm-browse-url-opera

  (helm-browse-url-opera URL &optional IGNORE)

  Browse URL with Opera browser and detach from Emacs.

  So when you quit Emacs you can keep your Opera session open and
  not be prompted to kill the Opera process.

  NOTE: Probably not supported on some systems (e.g., Windows).

- ~helm-browse-url-uzbl~ ::

  #+findex: helm-browse-url-uzbl

  (helm-browse-url-uzbl URL &optional IGNORE)

  Browse URL with uzbl browser.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c C-c g)}}} (~helm-google-suggest~) ::

  #+findex: helm-google-suggest

  #+kindex: C-x c C-c g

  Preconfigured ~helm~ for Google search with Google suggest.

- {{{kbd(C-x c s)}}} (~helm-surfraw~) ::

  #+findex: helm-surfraw

  #+kindex: C-x c s

  (helm-surfraw PATTERN ENGINE)

  Preconfigured ~helm~ to search PATTERN with search ENGINE.

*** Options in library =helm-net=

**** Function
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-surfraw-default-browser-function~ ::

  #+vindex: helm-surfraw-default-browser-function

  *Standard Value*: nil

  The browse url function you prefer to use with surfraw.
  When nil, fallback to ~browse-url-browser-function~.

**** Curl
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-net-curl-switches~ ::

  #+vindex: helm-net-curl-switches

  *Standard Value*:

  #+begin_src emacs-lisp
    ("-s" "-L")
  #+end_src

  Arguments list passed to curl when using ~helm-net-prefer-curl~.

- ~helm-net-prefer-curl~ ::

  #+vindex: helm-net-prefer-curl

  *Standard Value*: nil

  When non--nil use CURL external program to fetch data.
  Otherwise ~url-retrieve-synchronously~ is used.

**** Url
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-browse-url-firefox-new-window~ ::

  #+vindex: helm-browse-url-firefox-new-window

  *Standard Value*: -new-tab

  Allow choosing to browse url in new window or new tab.
  Can be "-new-tab" (default) or "-new-window".

- ~helm-home-url~ ::

  #+vindex: helm-home-url

  *Standard Value*: https://www.google.com

  Default url to use as home url.

- ~helm-surfraw-duckduckgo-url~ ::

  #+vindex: helm-surfraw-duckduckgo-url

  *Standard Value*: https://duckduckgo.com/lite/?q=%s&kp=1

  The Duckduckgo url.
  This is a format string, don’t forget the ~%s~.
  If you have personal settings saved on duckduckgo you should have
  a personal url, see your settings on duckduckgo.

**** Suggest Url
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-search-suggest-action-imdb-url~ ::

  #+vindex: helm-search-suggest-action-imdb-url

  *Standard Value*: http://www.imdb.com/find?s=all&q=%s

  The IMDb search url.
  This is a format string, don’t forget the ~%s~.

- ~helm-search-suggest-action-wikipedia-url~ ::

  #+vindex: helm-search-suggest-action-wikipedia-url

  *Standard Value*: https://en.wikipedia.org/wiki/Special:Search?search=%s

  The Wikipedia search url.
  This is a format string, don’t forget the ~%s~.

- ~helm-search-suggest-action-youtube-url~ ::

  #+vindex: helm-search-suggest-action-youtube-url

  *Standard Value*: https://www.youtube.com/results?aq=f&search_query=%s

  The Youtube search url.
  This is a format string, don’t forget the ~%s~.

**** Suggest Google Url
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-google-suggest-search-url~ ::

  #+vindex: helm-google-suggest-search-url

  *Standard Value*: https://encrypted.google.com/search?ie=utf-8&oe=utf-8&q=%s

  URL used for Google searching.
  This is a format string, don’t forget the ~%s~.

- ~helm-google-suggest-url~ ::

  #+vindex: helm-google-suggest-url

  *Standard Value*: https://encrypted.google.com/complete/search?output=toolbar&q=%s

  URL used for looking up Google suggestions.
  This is a format string, don’t forget the ~%s~.

- ~helm-search-suggest-action-google-maps-url~ ::

  #+vindex: helm-search-suggest-action-google-maps-url

  *Standard Value*: https://maps.google.com/maps?f=q&source=s_q&q=%s

  The Google Maps search url.
  This is a format string, don’t forget the ~%s~.

- ~helm-search-suggest-action-google-news-url~ ::

  #+vindex: helm-search-suggest-action-google-news-url

  *Standard Value*: https://www.google.com/search?safe=off&prmd=nvlifd&source=lnms&tbs=nws:1&q=%s

  The Google News search url.
  This is a format string, don’t forget the ~%s~.

**** Suggest Google uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-google-suggest-actions~ ::

  #+vindex: helm-google-suggest-actions

  *Standard Value*:

  #+begin_src emacs-lisp
    (("Google Search" . helm-google-suggest-action)
     ("Wikipedia" lambda
      (candidate)
      (helm-search-suggest-perform-additional-action helm-search-suggest-action-wikipedia-url candidate))
     ("Youtube" lambda
      (candidate)
      (helm-search-suggest-perform-additional-action helm-search-suggest-action-youtube-url candidate))
     ("IMDb" lambda
      (candidate)
      (helm-search-suggest-perform-additional-action helm-search-suggest-action-imdb-url candidate))
     ("Google Maps" lambda
      (candidate)
      (helm-search-suggest-perform-additional-action helm-search-suggest-action-google-maps-url candidate))
     ("Google News" lambda
      (candidate)
      (helm-search-suggest-perform-additional-action helm-search-suggest-action-google-news-url candidate)))
  #+end_src

  List of actions for google suggest sources.

- ~helm-google-suggest-default-browser-function~ ::

  #+vindex: helm-google-suggest-default-browser-function

  *Standard Value*: nil

  The browse url function you prefer to use with Google suggest.
  When nil, use the first browser function available
  See ~helm-browse-url-default-browser-alist~.

- ~helm-google-suggest-use-curl-p~ ::

  #+vindex: helm-google-suggest-use-curl-p

  *Standard Value*: nil

  When non--nil use CURL external program to fetch data.
  Otherwise ~url-retrieve-synchronously~ is used.

** Library: helm-occur

*** Modes in library ~helm-occur~

**** other-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-occur-mode~ ::

  #+findex: helm-occur-mode

  Major mode to provide actions in helm moccur saved buffer.

  Special commands:
  \{helm-occur-mode-map}

  In addition to any hooks its parent mode ~special-mode~ might have
  run, this mode runs the hook ~helm-occur-mode-hook~, as the final or
  penultimate step during initialization.

*** Commands in keymap ~helm-occur-map~

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c C-o)}}} (~helm-occur-run-goto-line-of~) ::

  #+findex: helm-occur-run-goto-line-of @r{(helm-occur-map)}

  #+kindex: C-c C-o @r{(helm-occur-map)}

  Run goto line new frame action from ~helm-occur~.

- {{{kbd(C-c o)}}} (~helm-occur-run-goto-line-ow~) ::

  #+findex: helm-occur-run-goto-line-ow @r{(helm-occur-map)}

  #+kindex: C-c o @r{(helm-occur-map)}

  Run goto line other window action from ~helm-occur~.

- {{{kbd(C-x C-s)}}} (~helm-occur-run-save-buffer~) ::

  #+findex: helm-occur-run-save-buffer @r{(helm-occur-map)}

  #+kindex: C-x C-s @r{(helm-occur-map)}

  Run moccur save results action from ~helm-moccur~.

*** Commands in keymap ~helm-occur-mode-map~

**** uncategorized File
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-<down>)}}} ::
- {{{kbd(M-N)}}} (~helm-gm-next-file~) ::

  #+findex: helm-gm-next-file @r{(helm-occur-mode-map)}

  #+kindex: M-<down> @r{(helm-occur-mode-map)}
  #+kindex: M-N @r{(helm-occur-mode-map)}

- {{{kbd(M-<up>)}}} ::
- {{{kbd(M-P)}}} (~helm-gm-precedent-file~) ::

  #+findex: helm-gm-precedent-file @r{(helm-occur-mode-map)}

  #+kindex: M-<up> @r{(helm-occur-mode-map)}
  #+kindex: M-P @r{(helm-occur-mode-map)}

**** uncategorized Occur
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(RET)}}} (~helm-occur-mode-goto-line~) ::

  #+findex: helm-occur-mode-goto-line @r{(helm-occur-mode-map)}

  #+kindex: RET @r{(helm-occur-mode-map)}

- {{{kbd(C-o)}}} (~helm-occur-mode-goto-line-ow~) ::

  #+findex: helm-occur-mode-goto-line-ow @r{(helm-occur-mode-map)}

  #+kindex: C-o @r{(helm-occur-mode-map)}

- {{{kbd(C-<up>)}}} ::
- {{{kbd(M-p)}}} (~helm-occur-mode-goto-line-ow-backward~) ::

  #+findex: helm-occur-mode-goto-line-ow-backward @r{(helm-occur-mode-map)}

  #+kindex: C-<up> @r{(helm-occur-mode-map)}
  #+kindex: M-p @r{(helm-occur-mode-map)}

  (helm-occur-mode-goto-line-ow-backward ARG)

- {{{kbd(C-<down>)}}} ::
- {{{kbd(M-n)}}} (~helm-occur-mode-goto-line-ow-forward~) ::

  #+findex: helm-occur-mode-goto-line-ow-forward @r{(helm-occur-mode-map)}

  #+kindex: C-<down> @r{(helm-occur-mode-map)}
  #+kindex: M-n @r{(helm-occur-mode-map)}

  (helm-occur-mode-goto-line-ow-forward ARG)

- {{{kbd(C-c b)}}} (~helm-occur-mode-resume-session~) ::

  #+findex: helm-occur-mode-resume-session @r{(helm-occur-mode-map)}

  #+kindex: C-c b @r{(helm-occur-mode-map)}

*** Commands in library ~helm-occur~ (excludes keymaps)

**** Mode
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-occur-mode-mouse-goto-line~ ::

  #+findex: helm-occur-mode-mouse-goto-line

  (helm-occur-mode-mouse-goto-line EVENT)

**** Isearch
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-multi-occur-from-isearch~ ::

  #+findex: helm-multi-occur-from-isearch

  Invoke ~helm-multi-occur~ from isearch.

  With a prefix arg, reverse the behavior of
  ~helm-moccur-always-search-in-current~.
  The prefix arg can be set before calling
  ~helm-multi-occur-from-isearch~ or during the buffer selection.

  To use this bind it to a key in ~isearch-mode-map~.

- ~helm-occur-from-isearch~ ::

  #+findex: helm-occur-from-isearch

  Invoke ~helm-occur~ from isearch.

  To use this bind it to a key in ~isearch-mode-map~.

**** other-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-occur-mode~ ::

  #+findex: helm-occur-mode

  Major mode to provide actions in helm moccur saved buffer.

  Special commands:
  \{helm-occur-mode-map}

  In addition to any hooks its parent mode ~special-mode~ might have
  run, this mode runs the hook ~helm-occur-mode-hook~, as the final or
  penultimate step during initialization.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c M-s o)}}} ::
- {{{kbd(M-s o)}}} (~helm-occur~) ::

  #+findex: helm-occur

  #+kindex: C-x c M-s o
  #+kindex: M-s o

  Preconfigured helm for searching lines matching pattern in ~current-buffer~.

  When ~helm-source-occur~ is member of
  ~helm-sources-using-default-as-input~ which is the default,
  symbol at point is searched at startup.

  When a region is marked search only in this region by narrowing.

  To search in multiples buffers start from one of the commands listing
  buffers (i.e. a helm command using ~helm-source-buffers-list~ like
  ~helm-mini~) and use the multi occur buffers action.

  This is the helm implementation that collect lines matching pattern
  like vanilla Emacs ~occur~ but have nothing to do with it, the search
  engine beeing completely different and also much faster.

- ~helm-occur-right~ ::

  #+findex: helm-occur-right

  ~helm-occur~ action for right arrow.
  This is used when ~helm-occur-use-ioccur-style-keys~ is enabled.
  If follow is enabled (default) go to next source, otherwise execute
  persistent action.

- ~helm-occur-run-default-action~ ::

  #+findex: helm-occur-run-default-action

- ~helm-occur-visible-buffers~ ::

  #+findex: helm-occur-visible-buffers

  Run helm-occur on all visible buffers in frame.

*** Options in library =helm-occur=

**** uncategorized uncategorized uncategorized uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-occur-actions~ ::

  #+vindex: helm-occur-actions

  *Standard Value*:

  #+begin_src emacs-lisp
    (("Go to Line" . helm-occur-goto-line)
     ("Goto line other window (C-u vertically)" . helm-occur-goto-line-ow)
     ("Goto line new frame" . helm-occur-goto-line-of)
     ("Save buffer" . helm-occur-save-results))
  #+end_src

  Actions for helm-occur.

- ~helm-occur-always-search-in-current~ ::

  #+vindex: helm-occur-always-search-in-current

  *Standard Value*: nil

  Helm multi occur always search in current buffer when non--nil.

- ~helm-occur-auto-update-on-resume~ ::

  #+vindex: helm-occur-auto-update-on-resume

  *Standard Value*: nil

  Allow auto updating helm-occur buffer when outdated.
  noask => Always update without asking
  nil   => Don’t update but signal buffer needs update
  never => Never update and do not signal buffer needs update
  Any other non--nil value update after confirmation.

- ~helm-occur-buffer-substring-fn-for-modes~ ::

  #+vindex: helm-occur-buffer-substring-fn-for-modes

  *Standard Value*:

  #+begin_src emacs-lisp
    ((mu4e-headers-mode . buffer-substring))
  #+end_src

  Function to use to display buffer contents for major-mode.

  Can be one of ~buffer-substring~ or ~buffer-substring-no-properties~.

  Note that when using ~buffer-substring~ initialization will be slower.

- ~helm-occur-candidate-number-limit~ ::

  #+vindex: helm-occur-candidate-number-limit

  *Standard Value*: 99999

  Value of ~helm-candidate-number-limit~ for helm-occur.

- ~helm-occur-keep-closest-position~ ::

  #+vindex: helm-occur-keep-closest-position

  *Standard Value*: t

  When non nil select closest candidate from point after update.
  This happen only in ~helm-source-occur~ which is always related to ~current-buffer~.

- ~helm-occur-truncate-lines~ ::

  #+vindex: helm-occur-truncate-lines

  *Standard Value*: t

  Truncate lines in occur buffer when non nil.

- ~helm-occur-use-ioccur-style-keys~ ::

  #+vindex: helm-occur-use-ioccur-style-keys

  *Standard Value*: nil

  Similar to ~helm-grep-use-ioccur-style-keys~ but for multi occur.

  Note that if you define this variable with ~setq~ your change will
  have no effect, use customize instead.

*** Hooks in library =helm-occur=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-occur-mode-hook~ ::

  #+vindex: helm-occur-mode-hook

  *Standard Value*: nil

  Hook run after entering helm-moccur mode.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

** Library: helm-regexp

*** Commands in library ~helm-regexp~ (excludes keymaps)

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c r)}}} (~helm-regexp~) ::

  #+findex: helm-regexp

  #+kindex: C-x c r

  Preconfigured helm to build regexps.
  ~query-replace-regexp~ can be run from there against found regexp.

** Library: helm-ring

*** Commands in keymap ~helm-kill-ring-map~

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-D)}}} (~helm-kill-ring-delete~) ::

  #+findex: helm-kill-ring-delete @r{(helm-kill-ring-map)}

  #+kindex: M-D @r{(helm-kill-ring-map)}

  Delete marked candidates from ~kill-ring~.

  This is a command for ~helm-kill-ring-map~.

- {{{kbd(C-c C-k)}}} (~helm-kill-ring-kill-selection~) ::

  #+findex: helm-kill-ring-kill-selection @r{(helm-kill-ring-map)}

  #+kindex: C-c C-k @r{(helm-kill-ring-map)}

  Store the real value of candidate in kill-ring.
  Same as ~helm-kill-selection-and-quit~ called with a prefix arg.

- {{{kbd(C-c d)}}} (~helm-kill-ring-run-persistent-delete~) ::

  #+findex: helm-kill-ring-run-persistent-delete @r{(helm-kill-ring-map)}

  #+kindex: C-c d @r{(helm-kill-ring-map)}

  Delete current candidate without quitting.

- {{{kbd(C-s)}}} (~helm-kill-ring-run-search-from-string~) ::

  #+findex: helm-kill-ring-run-search-from-string @r{(helm-kill-ring-map)}

  #+kindex: C-s @r{(helm-kill-ring-map)}

- {{{kbd(C-])}}} (~helm-kill-ring-toggle-truncated~) ::

  #+findex: helm-kill-ring-toggle-truncated @r{(helm-kill-ring-map)}

  #+kindex: C-] @r{(helm-kill-ring-map)}

  Toggle truncated view of candidates in helm kill-ring browser.

*** Commands in library ~helm-ring~ (excludes keymaps)

**** Ring
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c M-y)}}} (~helm-show-kill-ring~) ::

  #+findex: helm-show-kill-ring

  #+kindex: C-x c M-y

  Preconfigured ~helm~ for ~kill-ring~.
  It is drop-in replacement of ~yank-pop~.

  First call open the kill-ring browser, next calls move to next line.

**** Mark
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c C-c SPC)}}} (~helm-all-mark-rings~) ::

  #+findex: helm-all-mark-rings

  #+kindex: C-x c C-c SPC

  Preconfigured ~helm~ for ~helm-source-global-mark-ring~ and ~helm-source-mark-ring~.

- ~helm-global-mark-ring~ ::

  #+findex: helm-global-mark-ring

  Preconfigured ~helm~ for ~helm-source-global-mark-ring~.

- ~helm-mark-ring~ ::

  #+findex: helm-mark-ring

  Preconfigured ~helm~ for ~helm-source-mark-ring~.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-execute-kmacro~ ::

  #+findex: helm-execute-kmacro

  Preconfigured helm for keyboard macros.
  Define your macros with ~f3~ and ~f4~.
  See (info "(emacs) Keyboard Macros") for detailed infos.
  This command is useful when used with persistent action.

- {{{kbd(C-x c C-x r i)}}} (~helm-register~) ::

  #+findex: helm-register

  #+kindex: C-x c C-x r i

  Preconfigured ~helm~ for Emacs registers.

*** Options in library =helm-ring=

**** Offset
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-register-max-offset~ ::

  #+vindex: helm-register-max-offset

  *Standard Value*: 160

  Max size of string register entries before truncating.

**** Kill
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-kill-ring-actions~ ::

  #+vindex: helm-kill-ring-actions

  *Standard Value*:

  #+begin_src emacs-lisp
    (("Yank marked" . helm-kill-ring-action-yank)
     ("Delete marked" . helm-kill-ring-action-delete)
     ("Search from candidate" . helm-kill-ring-search-from-string))
  #+end_src

  List of actions for kill ring source.

- ~helm-kill-ring-max-offset~ ::

  #+vindex: helm-kill-ring-max-offset

  *Standard Value*: 400

  Max number of chars displayed per candidate in kill-ring browser.
  When ~t~, don’t truncate candidate, show all.
  By default it is approximatively the number of bits contained in five lines
  of 80 chars each, i.e. 80*5.
  Note that if you set this to nil multiline will be disabled, i.e. you
  will not have separators between candidates any more.

- ~helm-kill-ring-separator~ ::

  #+vindex: helm-kill-ring-separator

  *Standard Value*:

  The separator used to separate marked candidates when yanking.

- ~helm-kill-ring-threshold~ ::

  #+vindex: helm-kill-ring-threshold

  *Standard Value*: 3

  Minimum length of a candidate to be listed by ~helm-source-kill-ring~.

** Library: helm-semantic

*** Commands in library ~helm-semantic~ (excludes keymaps)

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-semantic~ ::

  #+findex: helm-semantic

  (helm-semantic ARG)

  Preconfigured ~helm~ for ~semantic~.
  If ARG is supplied, pre-select symbol at point instead of current.

- ~helm-semantic-or-imenu~ ::

  #+findex: helm-semantic-or-imenu

  (helm-semantic-or-imenu ARG)

  Preconfigured helm for ~semantic~ or ~imenu~.
  If ARG is supplied, pre-select symbol at point instead of current
  semantic tag in scope.

  If ~semantic-mode~ is active in the current buffer, then use
  semantic for generating tags, otherwise fall back to ~imenu~.
  Fill in the symbol at point by default.

*** Options in library =helm-semantic=

**** Style
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-semantic-display-style~ ::

  #+vindex: helm-semantic-display-style

  *Standard Value*:

  #+begin_src emacs-lisp
    ((python-mode . semantic-format-tag-summarize)
     (c-mode . semantic-format-tag-concise-prototype-c-mode)
     (emacs-lisp-mode . semantic-format-tag-abbreviate-emacs-lisp-mode))
  #+end_src

  Function to present a semantic tag according to ~major-mode~.

  It is an alist where the ~car~ of each element is a ~major-mode~ and
  the ~cdr~ a ~semantic-format-tag-*~ function.

  If no function is found for current ~major-mode~, fall back to
  ~semantic-format-tag-summarize~ default function.

  You can have more or less informations depending of the ~semantic-format-tag-*~
  function you choose.

  All the supported functions are prefixed with "semantic-format-tag-",
  you have completion on these functions with ~C-M i~ in the customize interface.

- ~helm-semantic-lynx-style-map~ ::

  #+vindex: helm-semantic-lynx-style-map

  *Standard Value*: nil

  Use Arrow keys to jump to occurences.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-semantic-fuzzy-match~ ::

  #+vindex: helm-semantic-fuzzy-match

  *Standard Value*: nil

  Enable fuzzy matching in ~helm-source-semantic~.

** Library: helm-shell

*** Commands in library ~helm-shell~ (excludes keymaps)

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-shell-prompts~ ::

  #+findex: helm-shell-prompts

  Pre-configured ~helm~ to browse the prompts of the current comint buffer.

- ~helm-shell-prompts-all~ ::

  #+findex: helm-shell-prompts-all

  Pre-configured ~helm~ to browse the prompts of all comint sessions.

** Library: helm-source

** Library: helm-sys

*** Modes in library ~helm-sys~

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-top-poll-mode~ ::

  #+findex: helm-top-poll-mode

  (helm-top-poll-mode &optional ARG)

  Refresh automatically helm top buffer once enabled.

  If called interactively, toggle ~Helm-Top-Poll mode~.  If the
  prefix argument is positive, enable the mode, and if it is zero
  or negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

*** Commands in keymap ~helm-top-map~

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-C)}}} (~helm-top-run-sort-by-com~) ::

  #+findex: helm-top-run-sort-by-com @r{(helm-top-map)}

  #+kindex: M-C @r{(helm-top-map)}

- {{{kbd(M-P)}}} (~helm-top-run-sort-by-cpu~) ::

  #+findex: helm-top-run-sort-by-cpu @r{(helm-top-map)}

  #+kindex: M-P @r{(helm-top-map)}

- {{{kbd(M-M)}}} (~helm-top-run-sort-by-mem~) ::

  #+findex: helm-top-run-sort-by-mem @r{(helm-top-map)}

  #+kindex: M-M @r{(helm-top-map)}

- {{{kbd(M-U)}}} (~helm-top-run-sort-by-user~) ::

  #+findex: helm-top-run-sort-by-user @r{(helm-top-map)}

  #+kindex: M-U @r{(helm-top-map)}

*** Commands in library ~helm-sys~ (excludes keymaps)

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-top-poll-mode~ ::

  #+findex: helm-top-poll-mode

  (helm-top-poll-mode &optional ARG)

  Refresh automatically helm top buffer once enabled.

  If called interactively, toggle ~Helm-Top-Poll mode~.  If the
  prefix argument is positive, enable the mode, and if it is zero
  or negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c p)}}} (~helm-list-emacs-process~) ::

  #+findex: helm-list-emacs-process

  #+kindex: C-x c p

  Preconfigured ~helm~ for Emacs process.

- {{{kbd(C-x c t)}}} (~helm-top~) ::

  #+findex: helm-top

  #+kindex: C-x c t

  Preconfigured ~helm~ for top command.

- ~helm-xrandr-set~ ::

  #+findex: helm-xrandr-set

  Preconfigured helm for xrandr.

*** Options in library =helm-sys=

**** Command
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-top-command~ ::

  #+vindex: helm-top-command

  *Standard Value*: env COLUMNS=%s top -b -n 1

  Top command used to display output of top.
  A format string where %s will be replaced with ~frame-width~.

  To use ’top’ command, a version supporting batch mode (-b option)
  is needed. On Mac OSX ’top’ command doesn’t support this, so the
  ’ps’ command is used instead by default.

  Normally ’top’ command output have 12 columns, but in some
  versions you may have less than this, so you can either customize
  top to use 12 columns with the interactives ’f’ and ’W’ commands
  of top, or modify ~helm-top-sort-columns-alist~ to fit with the
  number of columns your ’top’ command is using.

  If you modify ’ps’ command be sure that ’pid’ comes in first and
  "env COLUMNS=%s" is specified at beginning of command. Ensure
  also that no elements contain spaces (e.g., use start_time and
  not start). Same as for ’top’: you can customize
  ~helm-top-sort-columns-alist~ to make sort commands working
  properly according to your settings.

**** Poll
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-top-poll-delay~ ::

  #+vindex: helm-top-poll-delay

  *Standard Value*: 1.5

  Helm top poll after this delay when ~helm-top-poll-mode~ is enabled.
  The minimal delay allowed is 1.5, if less than this helm-top will use 1.5.

- ~helm-top-poll-delay-post-command~ ::

  #+vindex: helm-top-poll-delay-post-command

  *Standard Value*: 1.0

  Helm top stop polling during this delay.
  This delay is added to ~helm-top-poll-delay~ after Emacs stops
  being idle.

- ~helm-top-poll-mode-hook~ ::

  #+vindex: helm-top-poll-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm-top-poll-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

- ~helm-top-poll-preselection~ ::

  #+vindex: helm-top-poll-preselection

  *Standard Value*: linum

  Stay on same line or follow candidate when ~helm-top-poll~ updates display.
  Possible values are ’candidate or ’linum.
  This affects also sorting functions in the same way.

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-top-poll-mode~ ::

  #+vindex: helm-top-poll-mode

  *Standard Value*: nil

  (helm-top-poll-mode &optional ARG)

  Refresh automatically helm top buffer once enabled.

  If called interactively, toggle ~Helm-Top-Poll mode~.  If the
  prefix argument is positive, enable the mode, and if it is zero
  or negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-top-sort-columns-alist~ ::

  #+vindex: helm-top-sort-columns-alist

  *Standard Value*:

  #+begin_src emacs-lisp
    ((com . 11)
     (mem . 9)
     (cpu . 8)
     (user . 1))
  #+end_src

  Allow defining which column to use when sorting output of top/ps command.
  Only com, mem, cpu and user are sorted, so no need to put something else there,
  it will have no effect.
  Note that column numbers are counted from zero, i.e. column 1 is the nth 0 column.

*** Hooks in library =helm-sys=

**** Poll
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-top-initialize-poll-hooks~ ::

  #+vindex: helm-top-initialize-poll-hooks

  *Standard Value*:

- ~helm-top-poll-mode-hook~ ::

  #+vindex: helm-top-poll-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm-top-poll-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-top-after-init-hook~ ::

  #+vindex: helm-top-after-init-hook

  *Standard Value*: nil

  Local hook for helm-top.

** Library: helm-tags

*** Commands in keymap ~helm-etags-map~

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c C-o)}}} (~helm-etags-run-switch-other-frame~) ::

  #+findex: helm-etags-run-switch-other-frame @r{(helm-etags-map)}

  #+kindex: C-c C-o @r{(helm-etags-map)}

  Run switch to other frame action from ~helm-source-etags-select~.

- {{{kbd(C-c o)}}} (~helm-etags-run-switch-other-window~) ::

  #+findex: helm-etags-run-switch-other-window @r{(helm-etags-map)}

  #+kindex: C-c o @r{(helm-etags-map)}

  Run switch to other window action from ~helm-source-etags-select~.

- {{{kbd(M-<down>)}}} (~helm-goto-next-file~) ::

  #+findex: helm-goto-next-file @r{(helm-etags-map)}

  #+kindex: M-<down> @r{(helm-etags-map)}

  Go to previous file in Helm grep/etags buffers.

- {{{kbd(M-<up>)}}} (~helm-goto-precedent-file~) ::

  #+findex: helm-goto-precedent-file @r{(helm-etags-map)}

  #+kindex: M-<up> @r{(helm-etags-map)}

  Go to previous file in Helm grep/etags buffers.

*** Commands in library ~helm-tags~ (excludes keymaps)

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-x c e)}}} (~helm-etags-select~) ::

  #+findex: helm-etags-select

  #+kindex: C-x c e

  (helm-etags-select REINIT)

  Preconfigured helm for etags.
  If called with a prefix argument REINIT
  or if any of the tag files have been modified, reinitialize cache.

  This function aggregates three sources of tag files:

    1) An automatically located file in the parent directories,
       by ~helm-etags-get-tag-file~.
    2) ~tags-file-name~, which is commonly set by ~find-tag~ command.
    3) ~tags-table-list~ which is commonly set by ~visit-tags-table~ command.

*** Options in library =helm-tags=

**** File
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-etags-tag-file-name~ ::

  #+vindex: helm-etags-tag-file-name

  *Standard Value*: TAGS

  Etags tag file name.

- ~helm-etags-tag-file-search-limit~ ::

  #+vindex: helm-etags-tag-file-search-limit

  *Standard Value*: 10

  The limit level of directory to search tag file.
  Don’t search tag file deeply if outside this value.

**** Match
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-etags-fuzzy-match~ ::

  #+vindex: helm-etags-fuzzy-match

  *Standard Value*: nil

  Use fuzzy matching in ~helm-etags-select~.

- ~helm-etags-match-part-only~ ::

  #+vindex: helm-etags-match-part-only

  *Standard Value*: tag

  Allow choosing the tag part of CANDIDATE in ~helm-source-etags-select~.
  A tag looks like this:
      filename: (defun foo
  You can choose matching against the tag part (i.e "(defun foo"),
  or against the whole candidate (i.e "(filename:5:(defun foo").

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-etags-execute-action-at-once-if-one~ ::

  #+vindex: helm-etags-execute-action-at-once-if-one

  *Standard Value*: t

  Whether to jump straight to the selected tag if there’s only
  one match.

** Library: helm-types

*** Commands in keymap ~helm-generic-files-map~

**** uncategorized Run Files
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c C-a)}}} (~helm-ff-run-mail-attach-files~) ::

  #+findex: helm-ff-run-mail-attach-files @r{(helm-generic-files-map)}

  #+kindex: C-c C-a @r{(helm-generic-files-map)}

  Run mail attach files command action from ~helm-source-find-files~.

- {{{kbd(C-x C-q)}}} (~helm-ff-run-marked-files-in-dired~) ::

  #+findex: helm-ff-run-marked-files-in-dired @r{(helm-generic-files-map)}

  #+kindex: C-x C-q @r{(helm-generic-files-map)}

  Execute ~helm-marked-files-in-dired~ interactively.

**** uncategorized Run Switch
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c C-o)}}} (~helm-ff-run-switch-other-frame~) ::

  #+findex: helm-ff-run-switch-other-frame @r{(helm-generic-files-map)}

  #+kindex: C-c C-o @r{(helm-generic-files-map)}

  Run switch to other frame action from ~helm-source-find-files~.

- {{{kbd(C-c o)}}} (~helm-ff-run-switch-other-window~) ::

  #+findex: helm-ff-run-switch-other-window @r{(helm-generic-files-map)}

  #+kindex: C-c o @r{(helm-generic-files-map)}

  Run switch to other window action from ~helm-source-find-files~.
  When a prefix arg is provided, split is done vertically.

**** uncategorized Run File Open
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-c C-x)}}} (~helm-ff-run-open-file-externally~) ::

  #+findex: helm-ff-run-open-file-externally @r{(helm-generic-files-map)}

  #+kindex: C-c C-x @r{(helm-generic-files-map)}

  Run open file externally command action from ~helm-source-find-files~.

- {{{kbd(C-c X)}}} (~helm-ff-run-open-file-with-default-tool~) ::

  #+findex: helm-ff-run-open-file-with-default-tool @r{(helm-generic-files-map)}

  #+kindex: C-c X @r{(helm-generic-files-map)}

  Run open file externally command action from ~helm-source-find-files~.

**** uncategorized Run File Ediff
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-=)}}} (~helm-ff-run-ediff-file~) ::

  #+findex: helm-ff-run-ediff-file @r{(helm-generic-files-map)}

  #+kindex: C-= @r{(helm-generic-files-map)}

  Run Ediff file action from ~helm-source-find-files~.

- {{{kbd(C-c =)}}} (~helm-ff-run-ediff-merge-file~) ::

  #+findex: helm-ff-run-ediff-merge-file @r{(helm-generic-files-map)}

  #+kindex: C-c = @r{(helm-generic-files-map)}

  Run Ediff merge file action from ~helm-source-find-files~.

**** uncategorized Run File uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-B)}}} (~helm-ff-run-byte-compile-file~) ::

  #+findex: helm-ff-run-byte-compile-file @r{(helm-generic-files-map)}

  #+kindex: M-B @r{(helm-generic-files-map)}

  Run Byte compile file action from ~helm-source-find-files~.

- {{{kbd(M-C)}}} (~helm-ff-run-copy-file~) ::

  #+findex: helm-ff-run-copy-file @r{(helm-generic-files-map)}

  #+kindex: M-C @r{(helm-generic-files-map)}

  Run Copy file action from ~helm-source-find-files~.

- {{{kbd(M-D)}}} (~helm-ff-run-delete-file~) ::

  #+findex: helm-ff-run-delete-file @r{(helm-generic-files-map)}

  #+kindex: M-D @r{(helm-generic-files-map)}

  Run Delete file action from ~helm-source-find-files~.

- {{{kbd(C-c r)}}} (~helm-ff-run-find-file-as-root~) ::

  #+findex: helm-ff-run-find-file-as-root @r{(helm-generic-files-map)}

  #+kindex: C-c r @r{(helm-generic-files-map)}

- {{{kbd(M-H)}}} (~helm-ff-run-hardlink-file~) ::

  #+findex: helm-ff-run-hardlink-file @r{(helm-generic-files-map)}

  #+kindex: M-H @r{(helm-generic-files-map)}

  Run Hardlink file action from ~helm-source-find-files~.

- {{{kbd(M-L)}}} (~helm-ff-run-load-file~) ::

  #+findex: helm-ff-run-load-file @r{(helm-generic-files-map)}

  #+kindex: M-L @r{(helm-generic-files-map)}

  Run Load file action from ~helm-source-find-files~.

- {{{kbd(M-R)}}} (~helm-ff-run-rename-file~) ::

  #+findex: helm-ff-run-rename-file @r{(helm-generic-files-map)}

  #+kindex: M-R @r{(helm-generic-files-map)}

  Run Rename file action from ~helm-source-find-files~.

- {{{kbd(M-S)}}} (~helm-ff-run-symlink-file~) ::

  #+findex: helm-ff-run-symlink-file @r{(helm-generic-files-map)}

  #+kindex: M-S @r{(helm-generic-files-map)}

  Run Symlink file action from ~helm-source-find-files~.

**** uncategorized Run uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(C-s)}}} ::
- {{{kbd(M-g s)}}} (~helm-ff-run-grep~) ::

  #+findex: helm-ff-run-grep @r{(helm-generic-files-map)}

  #+kindex: C-s @r{(helm-generic-files-map)}
  #+kindex: M-g s @r{(helm-generic-files-map)}

  Run Grep action from ~helm-source-find-files~.

- {{{kbd(C-c @)}}} (~helm-ff-run-insert-org-link~) ::

  #+findex: helm-ff-run-insert-org-link @r{(helm-generic-files-map)}

  #+kindex: C-c @ @r{(helm-generic-files-map)}

- {{{kbd(M-g p)}}} (~helm-ff-run-pdfgrep~) ::

  #+findex: helm-ff-run-pdfgrep @r{(helm-generic-files-map)}

  #+kindex: M-g p @r{(helm-generic-files-map)}

  Run Pdfgrep action from ~helm-source-find-files~.

- {{{kbd(C-])}}} (~helm-ff-run-toggle-basename~) ::

  #+findex: helm-ff-run-toggle-basename @r{(helm-generic-files-map)}

  #+kindex: C-] @r{(helm-generic-files-map)}

- {{{kbd(M-g z)}}} (~helm-ff-run-zgrep~) ::

  #+findex: helm-ff-run-zgrep @r{(helm-generic-files-map)}

  #+kindex: M-g z @r{(helm-generic-files-map)}

  Run Grep action from ~helm-source-find-files~.

**** uncategorized uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- {{{kbd(M-i)}}} (~helm-ff-properties-persistent~) ::

  #+findex: helm-ff-properties-persistent @r{(helm-generic-files-map)}

  #+kindex: M-i @r{(helm-generic-files-map)}

  Show properties without quitting helm.

*** Options in library =helm-types=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-type-bookmark-actions~ ::

  #+vindex: helm-type-bookmark-actions

  *Standard Value*:

  #+begin_src emacs-lisp
    (("Jump to bookmark" . helm-bookmark-jump)
     ("Jump to BM other window" . helm-bookmark-jump-other-window)
     ("Jump to BM other frame" . helm-bookmark-jump-other-frame)
     ("Bookmark edit annotation" . bookmark-edit-annotation)
     ("Bookmark show annotation" . bookmark-show-annotation)
     ("Delete bookmark(s)" . helm-delete-marked-bookmarks)
     ("Edit Bookmark" . helm-bookmark-edit-bookmark)
     ("Rename bookmark" . helm-bookmark-rename)
     ("Relocate bookmark" . bookmark-relocate))
  #+end_src

  Default actions for type bookmarks.

- ~helm-type-buffer-actions~ ::

  #+vindex: helm-type-buffer-actions

  *Standard Value*:

  #+begin_src emacs-lisp
    (("Switch to buffer(s)" . helm-buffer-switch-buffers)
     ("Switch to buffer(s) other window ~C-c o~" . helm-buffer-switch-buffers-other-window)
     ("Switch to buffer other frame ~C-c C-o~" . switch-to-buffer-other-frame)
     ("Switch to buffer other tab ~C-c C-t~" . helm-buffers-switch-to-buffer-other-tab)
     ("Switch to buffer at line number" . helm-switch-to-buffer-at-linum)
     ("Browse project ~C-x C-d~" . helm-buffers-browse-project)
     ("Query replace regexp ~C-M-%~" . helm-buffer-query-replace-regexp)
     ("Query replace ~M-%~" . helm-buffer-query-replace)
     ("View buffer" . view-buffer)
     ("Display buffer" . display-buffer)
     ("Rename buffer ~M-R~" . helm-buffers-rename-buffer)
     ("Grep buffer(s) ~M-g s~ (C-u grep all buffers)" . helm-zgrep-buffers)
     ("Multi occur buffer(s) ~C-s (C-u search also in current)~" . helm-multi-occur-as-action)
     ("Revert buffer(s) ~M-G~" . helm-revert-marked-buffers)
     ("Insert buffer" . insert-buffer)
     ("Kill buffer(s) ~M-D~" . helm-kill-marked-buffers)
     ("Diff with file ~C-=~" . diff-buffer-with-file)
     ("Ediff Marked buffers ~C-c =~" . helm-ediff-marked-buffers)
     ("Ediff Merge marked buffers ~M-=~" .
      #[257 "\300\301\"\207"
	    [helm-ediff-marked-buffers t]
	    4 "\n\n(fn CANDIDATE)"]))
  #+end_src

  Default actions for type buffers.

- ~helm-type-command-actions~ ::

  #+vindex: helm-type-command-actions

  *Standard Value*:

  #+begin_src emacs-lisp
    (("Execute command" . helm-M-x-execute-command)
     ("Describe function" . helm-describe-function)
     ("Find function" . xref-find-definitions)
     ("Info lookup" . helm-info-lookup-symbol)
     ("Debug on entry" . debug-on-entry)
     ("Cancel debug on entry" . cancel-debug-on-entry)
     ("Trace function" . trace-function)
     ("Trace function (background)" . trace-function-background)
     ("Untrace function" . untrace-function))
  #+end_src

  Default actions for type command.

- ~helm-type-file-actions~ ::

  #+vindex: helm-type-file-actions

  *Standard Value*:

  #+begin_src emacs-lisp
    (("Find file" . helm-find-file-or-marked)
     ("Find file as root" . helm-find-file-as-root)
     ("Find file other window" . helm-find-files-other-window)
     ("Find file other frame" . find-file-other-frame)
     ("Open dired in file's directory" . helm-open-dired)
     ("Attach file(s) to mail buffer ~C-c C-a~" . helm-ff-mail-attach-files)
     ("Marked files in dired" . helm-marked-files-in-dired)
     ("Grep File(s) ~C-u recurse~" . helm-find-files-grep)
     ("Zgrep File(s) ~C-u Recurse~" . helm-ff-zgrep)
     ("Pdfgrep File(s)" . helm-ff-pdfgrep)
     ("Insert as org link" . helm-files-insert-as-org-link)
     ("Checksum File" . helm-ff-checksum)
     ("Ediff File" . helm-find-files-ediff-files)
     ("Ediff Merge File" . helm-find-files-ediff-merge-files)
     ("View file" . view-file)
     ("Insert file" . insert-file)
     ("Add marked files to file-cache" . helm-ff-cache-add-file)
     ("Delete file(s)" . helm-ff-delete-files)
     ("Copy file(s) ~M-C, C-u to follow~" . helm-find-files-copy)
     ("Rename file(s) ~M-R, C-u to follow~" . helm-find-files-rename)
     ("Symlink files(s) ~M-S, C-u to follow~" . helm-find-files-symlink)
     ("Relsymlink file(s) ~C-u to follow~" . helm-find-files-relsymlink)
     ("Hardlink file(s) ~M-H, C-u to follow~" . helm-find-files-hardlink)
     ("Open file externally (C-u to choose)" . helm-open-file-externally)
     ("Open file with default tool" . helm-open-file-with-default-tool)
     ("Find file in hex dump" . hexl-find-file))
  #+end_src

  Default actions for type files.

- ~helm-type-function-actions~ ::

  #+vindex: helm-type-function-actions

  *Standard Value*:

  #+begin_src emacs-lisp
    (("Describe function" . helm-describe-function)
     ("Find function" . xref-find-definitions)
     ("Info lookup" . helm-info-lookup-symbol)
     ("Debug on entry" . debug-on-entry)
     ("Cancel debug on entry" . cancel-debug-on-entry)
     ("Trace function" . trace-function)
     ("Trace function (background)" . trace-function-background)
     ("Untrace function" . untrace-function))
  #+end_src

  Default actions for type functions.

- ~helm-type-timers-actions~ ::

  #+vindex: helm-type-timers-actions

  *Standard Value*:

  #+begin_src emacs-lisp
    (("Cancel Timer" lambda
      (_timer)
      (let
	  ((mkd
	    (helm-marked-candidates)))
	(cl-loop for timer in mkd do
		 (cancel-timer timer))))
     ("Describe Function" lambda
      (tm)
      (describe-function
       (timer--function tm)))
     ("Find Function" lambda
      (tm)
      (helm-aif
	  (timer--function tm)
	  (if
	      (or
	       (byte-code-function-p it)
	       (helm-subr-native-elisp-p it))
	      (message "Can't find anonymous function ~%s~" it)
	    (find-function it)))))
  #+end_src

  Default actions for type timers.

** Library: helm-utils

*** Modes in library ~helm-utils~

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-popup-tip-mode~ ::

  #+findex: helm-popup-tip-mode

  (helm-popup-tip-mode &optional ARG)

  Show help-echo informations in a popup tip at end of line.

  If called interactively, toggle ~Helm-Popup-Tip mode~.  If the
  prefix argument is positive, enable the mode, and if it is zero
  or negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

*** Commands in library ~helm-utils~ (excludes keymaps)

**** All
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-display-all-sources~ ::

  #+findex: helm-display-all-sources

  Display all sources previously hidden by ~helm-set-source-filter~.

- ~helm-show-all-candidates-in-source~ ::

  #+findex: helm-show-all-candidates-in-source

  (helm-show-all-candidates-in-source ARG)

  Toggle all or only candidate-number-limit cands in current source.
  With a numeric prefix arg show only the ARG number of candidates.
  The prefix arg has no effect when toggling to only
  candidate-number-limit.

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-popup-tip-mode~ ::

  #+findex: helm-popup-tip-mode

  (helm-popup-tip-mode &optional ARG)

  Show help-echo informations in a popup tip at end of line.

  If called interactively, toggle ~Helm-Popup-Tip mode~.  If the
  prefix argument is positive, enable the mode, and if it is zero
  or negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-quit-and-find-file~ ::

  #+findex: helm-quit-and-find-file

  Drop into ~helm-find-files~ from ~helm~.
  If current selection is a buffer or a file, ~helm-find-files~
  from its directory.

*** Options in library =helm-utils=

**** Window
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-window-prefer-horizontal-split~ ::

  #+vindex: helm-window-prefer-horizontal-split

  *Standard Value*: nil

  Maybe switch to other window vertically when non nil.

  Possible values are t, nil and ~decide~.

  When t switch vertically.
  When nil switch horizontally.
  When ~decide~ try to guess if it is possible to switch vertically
  according to the setting of ~split-width-threshold~ and the size of
  the window from where splitting is done.

  Note that when using ~decide~ and ~split-width-threshold~ is nil, the
  behavior is the same as with a nil value.

**** Resize
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-resize-on-pa-text-height~ ::

  #+vindex: helm-resize-on-pa-text-height

  *Standard Value*: 12

  The size of the helm-window when resizing on persistent action.

**** Buffers
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-buffers-to-resize-on-pa~ ::

  #+vindex: helm-buffers-to-resize-on-pa

  *Standard Value*: nil

  A list of helm buffers where the helm-window should be reduced on persistent actions.

**** Function
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-html-decode-entities-function~ ::

  #+vindex: helm-html-decode-entities-function

  *Standard Value*: helm-html-decode-entities-string

  Function used to decode HTML entities in HTML bookmarks.
  Helm comes by default with ~helm-html-decode-entities-string~, if you need something
  more sophisticated you can use ~w3m-decode-entities-string~ if available.

  In Emacs itself org-entities seem broken and ~xml-substitute-numeric-entities~
  supports only numeric entities.

- ~helm-window-show-buffers-function~ ::

  #+vindex: helm-window-show-buffers-function

  *Standard Value*: helm-window-default-split-fn

  The default function to use when opening several buffers at once.
  It is typically used to rearrange windows.

**** Highlight
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-highlight-matches-around-point-max-lines~ ::

  #+vindex: helm-highlight-matches-around-point-max-lines

  *Standard Value*:

  #+begin_src emacs-lisp
    (15 . 15)
  #+end_src

  Number of lines around point where matched items are highlighted.

  Possible value are:
  - A cons cell (x . y)
    Match x lines before point and y lines after point.
  - An integer
    Positive means this number lines after point.
    Negative means this number lines before point.
    A zero value means highlight only inside matched lines.
  - The symbol never
    Means do not highlight matched items.

- ~helm-highlight-number-lines-around-point~ ::

  #+vindex: helm-highlight-number-lines-around-point

  *Standard Value*:

  #+begin_src emacs-lisp
    (15 . 15)
  #+end_src

  Number of lines around point where matched items are highlighted.

  Possible value are:
  - A cons cell (x . y)
    Match x lines before point and y lines after point.
  - An integer
    Positive means this number lines after point.
    Negative means this number lines before point.
    A zero value means highlight only inside matched lines.
  - The symbol never
    Means do not highlight matched items.

**** Popup
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-popup-tip-mode-hook~ ::

  #+vindex: helm-popup-tip-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm-popup-tip-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

- ~helm-sources-using-help-echo-popup~ ::

  #+vindex: helm-sources-using-help-echo-popup

  *Standard Value*:

  #+begin_src emacs-lisp
    ("Ack-Grep" "AG" "RG" "Gid" "Git-Grep")
  #+end_src

  Show the buffer name or the filename in a popup at selection.

**** minor-mode-p
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-popup-tip-mode~ ::

  #+vindex: helm-popup-tip-mode

  *Standard Value*: nil

  (helm-popup-tip-mode &optional ARG)

  Show help-echo informations in a popup tip at end of line.

  If called interactively, toggle ~Helm-Popup-Tip mode~.  If the
  prefix argument is positive, enable the mode, and if it is zero
  or negative, disable the mode.

  If called from Lisp, toggle the mode if ARG is ~toggle~.  Enable
  the mode if ARG is nil, omitted, or is a positive number.
  Disable the mode if ARG is a negative number.

  The mode's hook is called both when the mode is enabled and when
  it is disabled.

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-default-kbsize~ ::

  #+vindex: helm-default-kbsize

  *Standard Value*: 1024.0

  Default Kbsize to use for showing files size.
  It is a float, usually 1024.0 but could be 1000.0 on some systems.

- ~helm-su-or-sudo~ ::

  #+vindex: helm-su-or-sudo

  *Standard Value*: sudo

  What command to use for root access.

*** Hooks in library =helm-utils=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-find-many-files-after-hook~ ::

  #+vindex: helm-find-many-files-after-hook

  *Standard Value*: nil

  Hook that runs at end of ~helm-find-many-files~.

- ~helm-goto-line-before-hook~ ::

  #+vindex: helm-goto-line-before-hook

  *Standard Value*:

  #+begin_src emacs-lisp
    (helm-save-current-pos-to-mark-ring)
  #+end_src

  Run before jumping to line.
  This hook runs when jumping from ~helm-goto-line~, ~helm-etags-default-action~,
  and ~helm-imenu-default-action~.
  This allows you to retrieve a previous position after using the different helm
  tools for searching (etags, grep, gid, (m)occur etc...).
  By default positions are added to ~mark-ring~.
  You can also add to register by using (or adding)
  ~helm-save-pos-to-register-before-jump~ instead. In this case
  last position is added to the register ~helm-save-pos-before-jump-register~.

- ~helm-persistent-autoresize-hook~ ::

  #+vindex: helm-persistent-autoresize-hook

  *Standard Value*:

- ~helm-popup-tip-mode-hook~ ::

  #+vindex: helm-popup-tip-mode-hook

  *Standard Value*: nil

  Hook run after entering or leaving ~helm-popup-tip-mode~.
  No problems result if this variable is not bound.
  ~add-hook~ automatically binds it.  (This is true for all hook variables.)

** Library: helm-x-files

*** Options in library =helm-x-files=

**** uncategorized
:PROPERTIES:
:UNNUMBERED: notoc
:END:

- ~helm-session-fuzzy-match~ ::

  #+vindex: helm-session-fuzzy-match

  *Standard Value*: nil

  Enable fuzzy matching in ~helm-source-session~ when non--nil.

* Main Index
:PROPERTIES:
:INDEX:    cp
:DESCRIPTION: An index of Helm's concepts and features.
:END:

* Key Index
:PROPERTIES:
:DESCRIPTION: Key bindings and where they are described.
:INDEX:    ky
:END:

* Command and Function Index
:PROPERTIES:
:DESCRIPTION: Command names and some internal functions.
:INDEX:    fn
:END:

* Variable Index
:PROPERTIES:
:DESCRIPTION: Variables mentioned in the manual.
:INDEX:    vr
:END:

This is not a complete index of variables and faces, only the ones
that are mentioned in the manual.  For a more complete list, use
{{{kbd(M-x org-customize)}}} and then click yourself through the tree.

* Export Setup                                                          :noexport:

#+setupfile: doc-setup.org
#+options: H:4

#+export_file_name: helm.texi

#+texinfo_dir_category: Emacs Add-ons
#+texinfo_dir_title:  Helm Manual: (helm)
#+texinfo_dir_desc: Helm Manual

#+STARTUP: showeverything
#+STARTUP: inlineimages
#+EXCLUDE_TAGS: TOC_3

# (info (org-texinfo-export-to-info))

* Footnotes

[fn:xxx1] [[https://github.com/jwiegley/emacs-async][emacs-async]]

[fn:xxx2] [[https://github.com/auto-complete/popup-el][popup-el]]

[fn:xxx3] https://github.com/raxod502/straight.el

[fn:xxx4]  https://github.com/emacs-helm/helm/releases

[fn:xxxx45]  Above steps assume that you have installed =emacs-async=
 is in a standard location.  If this is not the case, you need to tell
 =make= program where it is available using =EMACSLOADPATH=[fn:xxx5].

      #+begin_src sh
	git clone https://github.com/emacs-helm/helm
	cd helm
	EMACSLOADPATH="/path/to/emacs-async:" make
	make
	sudo make install
      #+end_src

 If you want to install =helm= in a path other than =/usr/local/=, pass
 that target path through a =PREFIX= variable.

 # *Note*: make install will NOT work on Windows system, but you can move
 # your helm directory to your ~load-path~ e.g. /site-lisp and run =make=
 # there.

 # *Note*: make install will NOT work on Windows system, but you can move
 # your helm directory to your ~load-path~ e.g. /site-lisp and run =make=
 # there.

[fn:xxx5] Don't forget the final =:= to use an absolute path (like
=/home/you/foo/bar:=) instead of an abbreviated path like
(=~/foo/bar:=), specify =EMACSLOADPATH=.

[fn:xxx6] https://melpa.org

[fn:xxx7] Helm uses async package to compile itself from Melpa.  Ensure
that ~async-bytecomp-package-mode~ is enabled by default.  If this
isn't so, add helm to ~async-bytecomp-allowed-packages~.

[fn:xxx8] https://raw.githubusercontent.com/thierryvolpiatto/emacs-config/main/init-helm.el

[fn:xxx9] [[https://github.com/emacs-helm/helm/issues/495][Different way of invoking commands]]

[fn:xxx10] [[https://groups.google.com/g/emacs-helm/c/zaBbg2tFAuM][Finding files]]

[fn:xxx11] [[https://github.com/emacs-helm/helm/issues/222][Lack of tab completion]]

[fn:xxx12][[https://github.com/emacs-helm/helm-ls-git][ helm-ls-git]]

[fn:xxx13] [[https://github.com/emacs-helm/helm-ls-hg][helm-ls-hg]]

[fn:xxx14][[http://melpa.org/#/helm][ MELPA]]

[fn:xxx15] [[http://stable.melpa.org/#/helm][MELPA Stable]]

[fn:xxx16] https://github.com/emacs-helm/helm/tags

[fn:xxx17] [[http://melpa.org/#/helm][Melpa ]]

[fn:xxx18] helm-core have a new macro foo and helm use now
this macro, ~list-packages~ will try to install and compile first helm
and then helm-core resulting in an error like =void function foo...=.

# These footnotes are from `helm-manual.org'

[fn:1] Behavior may change depending context in some source e.g. ~helm-find-files~.

[fn:2] Delete from point to end or all depending on the value of
~helm-delete-minibuffer-contents-from-point~.

[fn:3] https://github.com/coldnew/linum-relative

[fn:4] Note that the key bindings are always available even if line
numbers are not displayed.  They are just useless in this case.