avy-0.5.0/ 0000755 0001752 0001753 00000000000 13466261260 010752 5 ustar elpa elpa avy-0.5.0/targets/ 0000755 0001752 0001753 00000000000 13466260675 012434 5 ustar elpa elpa avy-0.5.0/targets/checkdoc.el 0000644 0001752 0001753 00000000155 13466260675 014522 0 ustar elpa elpa ;; Copyright (C) 2019 Free Software Foundation, Inc.
(checkdoc-file "avy-test.el")
(checkdoc-file "avy.el")
avy-0.5.0/targets/avy-init.el 0000644 0001752 0001753 00000001715 13465634146 014517 0 ustar elpa elpa ;;; avy-init.el --- bare avy init
;; Copyright (C) 2015 Free Software Foundation, Inc.
;; Author: Oleh Krehel
;; This file is part of GNU Emacs.
;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see .
(add-to-list 'load-path default-directory)
(mapc #'byte-compile-file '("avy.el"))
(require 'avy)
(global-set-key (kbd "C-c j") 'avy-goto-char)
(global-set-key (kbd "C-'") 'avy-goto-char-2)
avy-0.5.0/.dir-locals.el 0000644 0001752 0001753 00000000460 13210077756 013405 0 ustar elpa elpa ;;; Directory Local Variables
;;; For more information see (info "(emacs) Directory Variables")
((emacs-lisp-mode
(indent-tabs-mode . nil)
(outline-regexp . ";;\\([;*]+ [^\s\t\n]\\|###autoload\\)\\|(")
(sentence-end-double-space . t)
;; (lisp-indent-function . common-lisp-indent-function)
))
avy-0.5.0/ChangeLog 0000644 0001752 0001753 00000003203 13466261045 012523 0 ustar elpa elpa 2019-05-13 Stefan Monnier
* avy/targets/checkdoc.el, ivy/doc/scripts.el: copyright tweak
2019-05-11 Oleh Krehel
Merge commit '0e59474430cbfbe7caf2a41cf7935fc613648c49' from avy
2017-11-30 Oleh Krehel
Merge commit '4a2cee03519f98cf95b29905dec2566a39ff717e' from swiper
2017-04-08 Oleh Krehel
Merge commit 'ace01d5603ddf49b025eb811b612af72ec38dcfb' from swiper
2016-07-11 Paul Eggert
Fix some quoting problems in doc strings
Most of these are minor issues involving, e.g., quoting `like this'
instead of 'like this'. A few involve escaping ` and ' with a preceding
\= when the characters should not be turned into curved single quotes.
2016-01-23 Oleh Krehel
Merge commit '11fbd70347a8cc62817c6d4ebf2291471ebdd607' from avy
2015-06-25 Oleh Krehel
Merge commit '8d38a898f23b3105c5d098f0cfb6c3383547e394' from avy
2015-05-19 Oleh Krehel
Merge commit '199c52606dcd614cb856bbcaca13b5fada0772b6' from avy
2015-05-09 Oleh Krehel
Merge commit 'e242f04e32c7d874c779fb83c86aa5bdbc508f18' from avy
Conflicts:
packages/avy/avy.el
2015-05-08 Stefan Monnier
* avy.el: Fix up author email and top-level require.
2015-05-08 Oleh Krehel
Add 'packages/avy/' from commit
'32003515c8efa2cf38b62c45499dae30bc7cacb8'
git-subtree-dir: packages/avy git-subtree-mainline:
74b34f2bbb929a1caf5cf753e59c54c3ccb74f50 git-subtree-split:
32003515c8efa2cf38b62c45499dae30bc7cacb8
avy-0.5.0/README.md 0000644 0001752 0001753 00000012765 13465634146 012252 0 ustar elpa elpa [![MELPA](https://melpa.org/packages/avy-badge.svg)](https://melpa.org/#/avy)
[![MELPA Stable](https://stable.melpa.org/packages/avy-badge.svg)](https://stable.melpa.org/#/avy)
## Introduction
`avy` is a GNU Emacs package for jumping to visible text using a char-based decision tree. See also [ace-jump-mode](https://github.com/winterTTr/ace-jump-mode) and [vim-easymotion](https://github.com/Lokaltog/vim-easymotion) - `avy` uses the same idea.
![logo](https://raw.githubusercontent.com/wiki/abo-abo/avy/images/avy-avatar-1.png)
## Command overview
You can bind some of these useful commands in your config.
### `avy-goto-char`
> Input one char, jump to it with a tree.
```elisp
(global-set-key (kbd "C-:") 'avy-goto-char)
```
After C-: b:
![avy-goto-char](https://raw.githubusercontent.com/wiki/nloyola/avy/images/avy-goto-char.png)
### `avy-goto-char-2`
> Input two consecutive chars, jump to the first one with a tree.
The advantage over the previous one is less candidates for the tree search. And it's not too inconvenient to enter two consecutive chars instead of one.
```elisp
(global-set-key (kbd "C-'") 'avy-goto-char-2)
```
After C-' bu:
![avy-goto-char-2](http://oremacs.com/download/avi-goto-char-2.png)
### `avy-goto-char-timer`
> Input an arbitrary amount of consecutive chars, jump to the first one with a tree.
This is a more flexible version of `avy-goto-char-2`. First part works similarly to `isearch`: you type a query and it's highlighted dynamically on the screen. When you stop typing for `avy-timeout-seconds` (0.5s by default), you'll be able to select one of the candidates with `avy`. As you're inputting characters, you can use `C-h` (backspace) or `DEL` (delete) to
forget the last typed character and `RET` to end the input sequence immediately and select a candidate.
### `avy-goto-line`
> Input zero chars, jump to a line start with a tree.
```elisp
(global-set-key (kbd "M-g f") 'avy-goto-line)
```
After M-g f:
![avy-goto-line](http://oremacs.com/download/avi-goto-line.png)
You can actually replace the M-g g binding of `goto-line`, since if you enter a digit for `avy-goto-line`, it will switch to `goto-line` with that digit already entered.
### `avy-goto-word-1`
> Input one char at word start, jump to a word start with a tree.
```elisp
(global-set-key (kbd "M-g w") 'avy-goto-word-1)
```
After M-g wb:
![avy-goto-word-1](http://oremacs.com/download/avi-goto-word-1.png)
### `avy-goto-word-0`
> Input zero chars, jump to a word start with a tree.
Compared to `avy-goto-word-1`, there are a lot more candidates. But at a least there's not need to input the initial char.
```elisp
(global-set-key (kbd "M-g e") 'avy-goto-word-0)
```
After M-g e:
![avy-goto-word-0](http://oremacs.com/download/avi-goto-word-0.png)
### Org-mode commands
* `avy-org-goto-heading-timer`: Type part of an Org heading. When you stop typing, if only one heading on the screen matches, it will be jumped to; if more than one matches, you can jump to a heading with Avy. This is like `avy-goto-char-timer` but for Org headings.
* `avy-org-refile-as-child`: With point in an entry you want to refile, run this command, select a heading with Avy, and the entry will be refiled as its first child heading. This makes it quick and easy to refile to headings that are visible on-screen, even to other windows or buffers.
### Other commands
There are some more commands which you can explore yourself by looking at the code.
### Bindings
You add this to your config to bind some stuff:
```elisp
(avy-setup-default)
(global-set-key (kbd "C-c C-j") 'avy-resume)
```
It will bind, for example, `avy-isearch` to C-' in `isearch-mode-map`, so that you can select one of the currently visible `isearch` candidates using `avy`.
### Customization
See the comprehensive custom variable list on [the defcustom wiki page](https://github.com/abo-abo/avy/wiki/defcustom).
See how to write your own avy commands on [the custom-commands wiki page](https://github.com/abo-abo/avy/wiki/custom-commands).
## Contributing
### Copyright Assignment
Avy is subject to the same [copyright assignment](http://www.gnu.org/prep/maintain/html_node/Copyright-Papers.html) policy as Emacs itself, org-mode, CEDET and other packages in [GNU ELPA](http://elpa.gnu.org/packages/). Any [legally significant](http://www.gnu.org/prep/maintain/html_node/Legally-Significant.html#Legally-Significant) contributions can only be accepted after the author has completed their paperwork. Please see [the request form](http://git.savannah.gnu.org/cgit/gnulib.git/tree/doc/Copyright/request-assign.future) if you want to proceed.
The copyright assignment isn't a big deal, it just says that the copyright for your submitted changes to Emacs belongs to the FSF. This assignment works for all projects related to Emacs. To obtain it, you need to send one email, then send one letter (if you live in the US, it's digital), and wait for some time (in my case, I had to wait for one month).
### Style
The basic code style guide is to use `(setq indent-tabs-mode nil)`. It is provided for you in [.dir-locals.el](https://github.com/abo-abo/avy/blob/master/.dir-locals.el), please obey it.
Before submitting the change, run `make compile` and `make test` to make sure that it doesn't introduce new compile warnings or test failures. Also run `make checkdoc` to see that your changes obey the documentation guidelines.
Use your own judgment for the commit messages, I recommend a verbose style using `magit-commit-add-log`.
avy-0.5.0/avy-test.el 0000644 0001752 0001753 00000003301 13465634146 013053 0 ustar elpa elpa ;;; avy-test.el --- Tests for avy
;; Copyright (C) 2015 Free Software Foundation, Inc.
;; Author: Oleh Krehel
;; This file is part of GNU Emacs.
;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see .
;;; Commentary:
;;
;;; Code:
(require 'ert)
(require 'avy)
(ert-deftest avy-subdiv ()
(should
(equal (avy-subdiv 5 4)
'(1 1 1 2)))
(should
(equal (avy-subdiv 10 4)
'(1 1 4 4)))
(should
(equal (avy-subdiv 16 4)
'(4 4 4 4)))
(should
(equal (avy-subdiv 17 4)
'(4 4 4 5)))
(should
(equal (avy-subdiv 27 4)
'(4 4 4 15)))
(should
(equal (avy-subdiv 50 4)
'(4 14 16 16)))
(should
(equal (avy-subdiv 65 4)
'(16 16 16 17))))
(ert-deftest avy-tree ()
(should
(equal
(avy-tree '(0 1 2 3 4 5 6 7 8 9 10)
'(?a ?s ?d ?f ?g ?h ?j ?k ?l))
'((97 leaf . 0)
(115 leaf . 1)
(100 leaf . 2)
(102 leaf . 3)
(103 leaf . 4)
(104 leaf . 5)
(106 leaf . 6)
(107 leaf . 7)
(108 (97 leaf . 8)
(115 leaf . 9)
(100 leaf . 10))))))
(provide 'avy-test)
;;; avy-test.el ends here
avy-0.5.0/avy-pkg.el 0000644 0001752 0001753 00000000372 13466261260 012654 0 ustar elpa elpa ;; Generated package description from avy.el
(define-package "avy" "0.5.0" "Jump to arbitrary positions in visible text and select text quickly." '((emacs "24.1") (cl-lib "0.5")) :url "https://github.com/abo-abo/avy" :keywords '("point" "location"))
avy-0.5.0/Makefile 0000644 0001752 0001753 00000000546 13465634146 012425 0 ustar elpa elpa emacs ?= emacs
# EMACS = emacs-24.3
LOAD = -l avy.el -l avy-test.el
.PHONY: all test clean checkdoc
all: compile test checkdoc
test:
$(emacs) -batch $(LOAD) -f ert-run-tests-batch-and-exit
checkdoc:
$(emacs) -batch -l targets/checkdoc.el
compile:
$(emacs) -batch -l targets/avy-init.el
run:
$(emacs) -Q -l targets/avy-init.el
clean:
rm -f *.elc
avy-0.5.0/avy.el 0000644 0001752 0001753 00000234435 13465634146 012114 0 ustar elpa elpa ;;; avy.el --- Jump to arbitrary positions in visible text and select text quickly. -*- lexical-binding: t -*-
;; Copyright (C) 2015-2019 Free Software Foundation, Inc.
;; Author: Oleh Krehel
;; URL: https://github.com/abo-abo/avy
;; Version: 0.5.0
;; Package-Requires: ((emacs "24.1") (cl-lib "0.5"))
;; Keywords: point, location
;; This file is part of GNU Emacs.
;; This file is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 3, or (at your option)
;; any later version.
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; For a full copy of the GNU General Public License
;; see .
;;; Commentary:
;;
;; With Avy, you can move point to any position in Emacs – even in a
;; different window – using very few keystrokes. For this, you look at
;; the position where you want point to be, invoke Avy, and then enter
;; the sequence of characters displayed at that position.
;;
;; If the position you want to jump to can be determined after only
;; issuing a single keystroke, point is moved to the desired position
;; immediately after that keystroke. In case this isn't possible, the
;; sequence of keystrokes you need to enter is comprised of more than
;; one character. Avy uses a decision tree where each candidate position
;; is a leaf and each edge is described by a character which is distinct
;; per level of the tree. By entering those characters, you navigate the
;; tree, quickly arriving at the desired candidate position, such that
;; Avy can move point to it.
;;
;; Note that this only makes sense for positions you are able to see
;; when invoking Avy. These kinds of positions are supported:
;;
;; * character positions
;; * word or subword start positions
;; * line beginning positions
;; * link positions
;; * window positions
;;
;; If you're familiar with the popular `ace-jump-mode' package, this
;; package does all that and more, without the implementation
;; headache.
;;; Code:
(require 'cl-lib)
(require 'ring)
;;* Customization
(defgroup avy nil
"Jump to things tree-style."
:group 'convenience
:prefix "avy-")
(defcustom avy-keys '(?a ?s ?d ?f ?g ?h ?j ?k ?l)
"Default keys for jumping.
Any key is either a character representing a self-inserting
key (letters, digits, punctuation, etc.) or a symbol denoting a
non-printing key like an arrow key (left, right, up, down). For
non-printing keys, a corresponding entry in
`avy-key-to-char-alist' must exist in order to visualize the key
in the avy overlays.
If `avy-style' is set to words, make sure there are at least three
keys different than the following: a, e, i, o, u, y"
:type '(repeat :tag "Keys" (choice
(character :tag "char")
(symbol :tag "non-printing key"))))
(defconst avy--key-type
'(choice :tag "Command"
(const avy-goto-char)
(const avy-goto-char-2)
(const avy-isearch)
(const avy-goto-line)
(const avy-goto-subword-0)
(const avy-goto-subword-1)
(const avy-goto-word-0)
(const avy-goto-word-1)
(const avy-copy-line)
(const avy-copy-region)
(const avy-move-line)
(const avy-move-region)
(const avy-kill-whole-line)
(const avy-kill-region)
(const avy-kill-ring-save-whole-line)
(const avy-kill-ring-save-region)
(function :tag "Other command")))
(defcustom avy-keys-alist nil
"Alist of avy-jump commands to `avy-keys' overriding the default `avy-keys'."
:type `(alist
:key-type ,avy--key-type
:value-type (repeat :tag "Keys" character)))
(defcustom avy-orders-alist '((avy-goto-char . avy-order-closest))
"Alist of candidate ordering functions.
Usually, candidates appear in their point position order."
:type `(alist
:key-type ,avy--key-type
:value-type function))
(defcustom avy-words
'("am" "by" "if" "is" "it" "my" "ox" "up"
"ace" "act" "add" "age" "ago" "aim" "air" "ale" "all" "and" "ant" "any"
"ape" "apt" "arc" "are" "arm" "art" "ash" "ate" "awe" "axe" "bad" "bag"
"ban" "bar" "bat" "bay" "bed" "bee" "beg" "bet" "bid" "big" "bit" "bob"
"bot" "bow" "box" "boy" "but" "cab" "can" "cap" "car" "cat" "cog" "cop"
"cow" "cry" "cup" "cut" "day" "dew" "did" "die" "dig" "dim" "dip" "dog"
"dot" "dry" "dub" "dug" "dye" "ear" "eat" "eel" "egg" "ego" "elf" "eve"
"eye" "fan" "far" "fat" "fax" "fee" "few" "fin" "fit" "fix" "flu" "fly"
"foe" "fog" "for" "fox" "fry" "fun" "fur" "gag" "gap" "gas" "gel" "gem"
"get" "gig" "gin" "gnu" "god" "got" "gum" "gun" "gut" "guy" "gym" "had"
"hag" "ham" "has" "hat" "her" "hid" "him" "hip" "his" "hit" "hop" "hot"
"how" "hub" "hue" "hug" "hut" "ice" "icy" "imp" "ink" "inn" "ion" "ire"
"ivy" "jab" "jam" "jar" "jaw" "jet" "job" "jog" "joy" "key" "kid" "kit"
"lag" "lap" "lay" "let" "lid" "lie" "lip" "lit" "lob" "log" "lot" "low"
"mad" "man" "map" "mat" "may" "men" "met" "mix" "mob" "mop" "mud" "mug"
"nag" "nap" "new" "nil" "nod" "nor" "not" "now" "nun" "oak" "odd" "off"
"oil" "old" "one" "orb" "ore" "ork" "our" "out" "owl" "own" "pad" "pan"
"par" "pat" "paw" "pay" "pea" "pen" "pet" "pig" "pin" "pit" "pod" "pot"
"pry" "pub" "pun" "put" "rag" "ram" "ran" "rat" "raw" "ray" "red" "rib"
"rim" "rip" "rob" "rod" "rot" "row" "rub" "rug" "rum" "run" "sad" "sat"
"saw" "say" "sea" "see" "sew" "she" "shy" "sin" "sip" "sit" "six" "ski"
"sky" "sly" "sob" "son" "soy" "spy" "sum" "sun" "tab" "tad" "tag" "tan"
"tap" "tar" "tax" "tea" "the" "tie" "tin" "tip" "toe" "ton" "too" "top"
"toy" "try" "tub" "two" "urn" "use" "van" "war" "was" "wax" "way" "web"
"wed" "wet" "who" "why" "wig" "win" "wit" "woe" "won" "wry" "you" "zap"
"zip" "zoo")
"Words to use in case `avy-style' is set to `words'.
Every word should contain at least one vowel i.e. one of the following
characters: a, e, i, o, u, y
They do not have to be sorted but no word should be a prefix of another one."
:type '(repeat string))
(defcustom avy-style 'at-full
"The default method of displaying the overlays.
Use `avy-styles-alist' to customize this per-command."
:type '(choice
(const :tag "Pre" pre)
(const :tag "At" at)
(const :tag "At Full" at-full)
(const :tag "Post" post)
(const :tag "De Bruijn" de-bruijn)
(const :tag "Words" words)))
(defcustom avy-styles-alist nil
"Alist of avy-jump commands to the style for each command.
If the commands isn't on the list, `avy-style' is used."
:type '(alist
:key-type (choice :tag "Command"
(const avy-goto-char)
(const avy-goto-char-2)
(const avy-isearch)
(const avy-goto-line)
(const avy-goto-subword-0)
(const avy-goto-subword-1)
(const avy-goto-word-0)
(const avy-goto-word-1)
(const avy-copy-line)
(const avy-copy-region)
(const avy-move-line)
(const avy-move-region)
(const avy-kill-whole-line)
(const avy-kill-region)
(const avy-kill-ring-save-whole-line)
(const avy-kill-ring-save-region)
(function :tag "Other command"))
:value-type (choice
(const :tag "Pre" pre)
(const :tag "At" at)
(const :tag "At Full" at-full)
(const :tag "Post" post)
(const :tag "De Bruijn" de-bruijn)
(const :tag "Words" words))))
(defcustom avy-dispatch-alist
'((?x . avy-action-kill-move)
(?X . avy-action-kill-stay)
(?t . avy-action-teleport)
(?m . avy-action-mark)
(?n . avy-action-copy)
(?y . avy-action-yank)
(?i . avy-action-ispell)
(?z . avy-action-zap-to-char))
"List of actions for `avy-handler-default'.
Each item is (KEY . ACTION). When KEY not on `avy-keys' is
pressed during the dispatch, ACTION is set to replace the default
`avy-action-goto' once a candidate is finally selected."
:type
'(alist
:key-type (choice (character :tag "Char"))
:value-type (choice
(const :tag "Mark" avy-action-mark)
(const :tag "Copy" avy-action-copy)
(const :tag "Kill and move point" avy-action-kill-move)
(const :tag "Kill" avy-action-kill-stay))))
(defcustom avy-background nil
"When non-nil, a gray background will be added during the selection."
:type 'boolean)
(defcustom avy-all-windows t
"Determine the list of windows to consider in search of candidates."
:type
'(choice
(const :tag "All Frames" all-frames)
(const :tag "This Frame" t)
(const :tag "This Window" nil)))
(defcustom avy-case-fold-search t
"Non-nil if searches should ignore case."
:type 'boolean)
(defcustom avy-word-punc-regexp "[!-/:-@[-`{-~]"
"Regexp of punctuation chars that count as word starts for `avy-goto-word-1'.
When nil, punctuation chars will not be matched.
\"[!-/:-@[-\\=`{-~]\" will match all printable punctuation chars."
:type 'regexp)
(defcustom avy-goto-word-0-regexp "\\b\\sw"
"Regexp that determines positions for `avy-goto-word-0'."
:type '(choice
(const :tag "Default" "\\b\\sw")
(const :tag "Symbol" "\\_<\\(\\sw\\|\\s_\\)")
(const :tag "Not whitespace" "[^ \r\n\t]+")
(regexp :tag "Regex")))
(defcustom avy-ignored-modes '(image-mode doc-view-mode pdf-view-mode)
"List of modes to ignore when searching for candidates.
Typically, these modes don't use the text representation."
:type 'list)
(defcustom avy-single-candidate-jump t
"In case there is only one candidate jumps directly to it."
:type 'boolean)
(defcustom avy-del-last-char-by '(8 127)
"List of event types, i.e. key presses, that delete the last
character read. The default represents `C-h' and `DEL'. See
`event-convert-list'."
:type 'list)
(defvar avy-ring (make-ring 20)
"Hold the window and point history.")
(defvar avy-translate-char-function #'identity
"Function to translate user input key into another key.
For example, to make SPC do the same as ?a, use
\(lambda (c) (if (= c 32) ?a c)).")
(defface avy-lead-face-0
'((t (:foreground "white" :background "#4f57f9")))
"Face used for first non-terminating leading chars.")
(defface avy-lead-face-1
'((t (:foreground "white" :background "gray")))
"Face used for matched leading chars.")
(defface avy-lead-face-2
'((t (:foreground "white" :background "#f86bf3")))
"Face used for leading chars.")
(defface avy-lead-face
'((t (:foreground "white" :background "#e52b50")))
"Face used for the leading chars.")
(defface avy-background-face
'((t (:foreground "gray40")))
"Face for whole window background during selection.")
(defface avy-goto-char-timer-face
'((t (:inherit highlight)))
"Face for matches during reading chars using `avy-goto-char-timer'.")
(defconst avy-lead-faces '(avy-lead-face
avy-lead-face-0
avy-lead-face-2
avy-lead-face
avy-lead-face-0
avy-lead-face-2)
"Face sequence for `avy--overlay-at-full'.")
(defvar avy-key-to-char-alist '((left . ?◀)
(right . ?▶)
(up . ?▲)
(down . ?▼)
(prior . ?△)
(next . ?▽))
"An alist from non-character keys to printable chars used in avy overlays.
This alist must contain all keys used in `avy-keys' which are not
self-inserting keys and thus aren't read as characters.")
;;* Internals
;;** Tree
(defmacro avy-multipop (lst n)
"Remove LST's first N elements and return them."
`(if (<= (length ,lst) ,n)
(prog1 ,lst
(setq ,lst nil))
(prog1 ,lst
(setcdr
(nthcdr (1- ,n) (prog1 ,lst (setq ,lst (nthcdr ,n ,lst))))
nil))))
(defun avy--de-bruijn (keys n)
"De Bruijn sequence for alphabet KEYS and subsequences of length N."
(let* ((k (length keys))
(a (make-list (* n k) 0))
sequence)
(cl-labels ((db (T p)
(if (> T n)
(if (eq (% n p) 0)
(setq sequence
(append sequence
(cl-subseq a 1 (1+ p)))))
(setf (nth T a) (nth (- T p) a))
(db (1+ T) p)
(cl-loop for j from (1+ (nth (- T p) a)) to (1- k) do
(setf (nth T a) j)
(db (1+ T) T)))))
(db 1 1)
(mapcar (lambda (n)
(nth n keys))
sequence))))
(defun avy--path-alist-1 (lst seq-len keys)
"Build a De Bruin sequence from LST.
SEQ-LEN is how many elements of KEYS it takes to identify a match."
(let ((db-seq (avy--de-bruijn keys seq-len))
prev-pos prev-seq prev-win path-alist)
;; The De Bruijn seq is cyclic, so append the seq-len - 1 first chars to
;; the end.
(setq db-seq (nconc db-seq (cl-subseq db-seq 0 (1- seq-len))))
(cl-labels ((subseq-and-pop ()
(when (nth (1- seq-len) db-seq)
(prog1 (cl-subseq db-seq 0 seq-len)
(pop db-seq)))))
(while lst
(let* ((cur (car lst))
(pos (cond
;; ace-window has matches of the form (pos . wnd)
((integerp (car cur)) (car cur))
;; avy-jump have form ((start . end) . wnd)
((consp (car cur)) (caar cur))
(t (error "Unexpected match representation: %s" cur))))
(win (cdr cur))
(path (if prev-pos
(let ((diff (if (eq win prev-win)
(- pos prev-pos)
0)))
(when (and (> diff 0) (< diff seq-len))
(while (and (nth (1- seq-len) db-seq)
(not
(eq 0
(cl-search
(cl-subseq prev-seq diff)
(cl-subseq db-seq 0 seq-len)))))
(pop db-seq)))
(subseq-and-pop))
(subseq-and-pop))))
(if (not path)
(setq lst nil
path-alist nil)
(push (cons path (car lst)) path-alist)
(setq prev-pos pos
prev-seq path
prev-win win
lst (cdr lst))))))
(nreverse path-alist)))
(defun avy-order-closest (x)
(abs (- (caar x) (point))))
(defvar avy-command nil
"Store the current command symbol.
E.g. 'avy-goto-line or 'avy-goto-char.")
(defun avy-tree (lst keys)
"Coerce LST into a balanced tree.
The degree of the tree is the length of KEYS.
KEYS are placed appropriately on internal nodes."
(let* ((len (length keys))
(order-fn (cdr (assq avy-command avy-orders-alist)))
(lst (if order-fn
(cl-sort lst #'< :key order-fn)
lst)))
(cl-labels
((rd (ls)
(let ((ln (length ls)))
(if (< ln len)
(cl-pairlis keys
(mapcar (lambda (x) (cons 'leaf x)) ls))
(let ((ks (copy-sequence keys))
res)
(dolist (s (avy-subdiv ln len))
(push (cons (pop ks)
(if (eq s 1)
(cons 'leaf (pop ls))
(rd (avy-multipop ls s))))
res))
(nreverse res))))))
(rd lst))))
(defun avy-subdiv (n b)
"Distribute N in B terms in a balanced way."
(let* ((p (1- (floor (+ (log n b) 1e-6))))
(x1 (expt b p))
(x2 (* b x1))
(delta (- n x2))
(n2 (/ delta (- x2 x1)))
(n1 (- b n2 1)))
(append
(make-list n1 x1)
(list
(- n (* n1 x1) (* n2 x2)))
(make-list n2 x2))))
(defun avy-traverse (tree walker &optional recur-key)
"Traverse TREE generated by `avy-tree'.
WALKER is a function that takes KEYS and LEAF.
RECUR-KEY is used in recursion.
LEAF is a member of LST argument of `avy-tree'.
KEYS is the path from the root of `avy-tree' to LEAF."
(dolist (br tree)
(let ((key (cons (car br) recur-key)))
(if (eq (cadr br) 'leaf)
(funcall walker key (cddr br))
(avy-traverse (cdr br) walker key)))))
(defvar avy-action nil
"Function to call at the end of select.")
(defun avy-handler-default (char)
"The default handler for a bad CHAR."
(let (dispatch)
(cond ((setq dispatch (assoc char avy-dispatch-alist))
(setq avy-action (cdr dispatch))
(throw 'done 'restart))
((memq char '(27 ?\C-g))
;; exit silently
(throw 'done 'exit))
((eq char ??)
(avy-show-dispatch-help)
(throw 'done 'restart))
((mouse-event-p char)
(signal 'user-error (list "Mouse event not handled" char)))
(t
(message "No such candidate: %s, hit `C-g' to quit."
(if (characterp char) (string char) char))))))
(defun avy-show-dispatch-help ()
"Display action shortucts in echo area."
(let ((len (length "avy-action-")))
(message "%s" (mapconcat
(lambda (x)
(format "%s: %s"
(propertize
(char-to-string (car x))
'face 'aw-key-face)
(substring (symbol-name (cdr x)) len)))
avy-dispatch-alist
" "))))
(defvar avy-handler-function 'avy-handler-default
"A function to call for a bad `read-key' in `avy-read'.")
(defvar avy-current-path ""
"Store the current incomplete path during `avy-read'.")
(defun avy-mouse-event-window (char)
"If CHAR is a mouse event, return the window of the event if any or the selected window.
Return nil if not a mouse event."
(when (mouse-event-p char)
(cond ((windowp (posn-window (event-start char)))
(posn-window (event-start char)))
((framep (posn-window (event-start char)))
(frame-selected-window (posn-window (event-start char))))
(t (selected-window)))))
(defun avy-read (tree display-fn cleanup-fn)
"Select a leaf from TREE using consecutive `read-key'.
DISPLAY-FN should take CHAR and LEAF and signify that LEAFs
associated with CHAR will be selected if CHAR is pressed. This is
commonly done by adding a CHAR overlay at LEAF position.
CLEANUP-FN should take no arguments and remove the effects of
multiple DISPLAY-FN invocations."
(catch 'done
(setq avy-current-path "")
(while tree
(let ((avy--leafs nil))
(avy-traverse tree
(lambda (path leaf)
(push (cons path leaf) avy--leafs)))
(dolist (x avy--leafs)
(funcall display-fn (car x) (cdr x))))
(let ((char (funcall avy-translate-char-function (read-key)))
window
branch)
(funcall cleanup-fn)
(if (setq window (avy-mouse-event-window char))
(throw 'done (cons char window))
;; Ensure avy-current-path stores the full path prior to
;; exit so other packages can utilize its value.
(setq avy-current-path
(concat avy-current-path (string (avy--key-to-char char))))
(if (setq branch (assoc char tree))
(if (eq (car (setq tree (cdr branch))) 'leaf)
(throw 'done (cdr tree)))
(funcall avy-handler-function char)))))))
(defun avy-read-de-bruijn (lst keys)
"Select from LST dispatching on KEYS."
;; In theory, the De Bruijn sequence B(k,n) has k^n subsequences of length n
;; (the path length) usable as paths, thus that's the lower bound. Due to
;; partially overlapping matches, not all subsequences may be usable, so it's
;; possible that the path-len must be incremented, e.g., if we're matching
;; for x and a buffer contains xaxbxcx only every second subsequence is
;; usable for the four matches.
(catch 'done
(let* ((path-len (ceiling (log (length lst) (length keys))))
(alist (avy--path-alist-1 lst path-len keys)))
(while (not alist)
(cl-incf path-len)
(setq alist (avy--path-alist-1 lst path-len keys)))
(let* ((len (length (caar alist)))
(i 0))
(setq avy-current-path "")
(while (< i len)
(dolist (x (reverse alist))
(avy--overlay-at-full (reverse (car x)) (cdr x)))
(let ((char (funcall avy-translate-char-function (read-key))))
(avy--remove-leading-chars)
(setq alist
(delq nil
(mapcar (lambda (x)
(when (eq (caar x) char)
(cons (cdr (car x)) (cdr x))))
alist)))
(setq avy-current-path
(concat avy-current-path (string (avy--key-to-char char))))
(cl-incf i)
(unless alist
(funcall avy-handler-function char))))
(cdar alist)))))
(defun avy-read-words (lst words)
"Select from LST using WORDS."
(catch 'done
(let ((num-words (length words))
(num-entries (length lst))
alist)
;; If there are not enough words to cover all the candidates,
;; we use a De Bruijn sequence to generate the remaining ones.
(when (< num-words num-entries)
(let ((keys avy-keys)
(bad-keys '(?a ?e ?i ?o ?u ?y))
(path-len 1)
(num-remaining (- num-entries num-words))
tmp-alist)
;; Delete all keys which could lead to duplicates.
;; We want at least three keys left to work with.
(dolist (x bad-keys)
(when (memq x keys)
(setq keys (delq ?a keys))))
(when (< (length keys) 3)
(signal 'user-error
'("Please add more keys to the variable `avy-keys'.")))
;; Generate the sequence and add the keys to the existing words.
(while (not tmp-alist)
(cl-incf path-len)
(setq tmp-alist (avy--path-alist-1 lst path-len keys)))
(while (>= (cl-decf num-remaining) 0)
(push (mapconcat 'string (caar tmp-alist) nil) (cdr (last words)))
(setq tmp-alist (cdr tmp-alist)))))
(dolist (x lst)
(push (cons (string-to-list (pop words)) x) alist))
(setq avy-current-path "")
(while (or (> (length alist) 1)
(caar alist))
(dolist (x (reverse alist))
(avy--overlay-at-full (reverse (car x)) (cdr x)))
(let ((char (funcall avy-translate-char-function (read-key))))
(avy--remove-leading-chars)
(setq alist
(delq nil
(mapcar (lambda (x)
(when (eq (caar x) char)
(cons (cdr (car x)) (cdr x))))
alist)))
(setq avy-current-path
(concat avy-current-path (string (avy--key-to-char char))))
(unless alist
(funcall avy-handler-function char))))
(cdar alist))))
;;** Rest
(defun avy-window-list ()
"Return a list of windows depending on `avy-all-windows'."
(cond ((eq avy-all-windows 'all-frames)
(cl-mapcan #'window-list (frame-list)))
((eq avy-all-windows t)
(window-list))
((null avy-all-windows)
(list (selected-window)))
(t
(error "Unrecognized option: %S" avy-all-windows))))
(defcustom avy-all-windows-alt nil
"The alternative `avy-all-windows' for use with \\[universal-argument]."
:type '(choice
(const :tag "Current window" nil)
(const :tag "All windows on the current frame" t)
(const :tag "All windows on all frames" all-frames)))
(defmacro avy-dowindows (flip &rest body)
"Depending on FLIP and `avy-all-windows' run BODY in each or selected window."
(declare (indent 1)
(debug (form body)))
`(let ((avy-all-windows (if ,flip
avy-all-windows-alt
avy-all-windows)))
(dolist (wnd (avy-window-list))
(with-selected-window wnd
(unless (memq major-mode avy-ignored-modes)
,@body)))))
(defun avy-resume ()
"Stub to hold last avy command.
Commands using `avy-with' macro can be resumed."
(interactive))
(defmacro avy-with (command &rest body)
"Set `avy-keys' according to COMMAND and execute BODY.
Set `avy-style' according to COMMMAND as well."
(declare (indent 1)
(debug (form body)))
`(let ((avy-keys (or (cdr (assq ',command avy-keys-alist))
avy-keys))
(avy-style (or (cdr (assq ',command avy-styles-alist))
avy-style))
(avy-command ',command))
(setq avy-action nil)
(setf (symbol-function 'avy-resume)
(lambda ()
(interactive)
,@body))
,@body))
(defun avy-action-goto (pt)
"Goto PT."
(let ((frame (window-frame (selected-window))))
(unless (equal frame (selected-frame))
(select-frame-set-input-focus frame)
(raise-frame frame))
(goto-char pt)))
(defun avy-forward-item ()
(if (eq avy-command 'avy-goto-line)
(end-of-line)
(forward-sexp))
(point))
(defun avy-action-mark (pt)
"Mark sexp at PT."
(goto-char pt)
(set-mark (point))
(avy-forward-item))
(defun avy-action-copy (pt)
"Copy sexp starting on PT."
(save-excursion
(let (str)
(goto-char pt)
(avy-forward-item)
(setq str (buffer-substring pt (point)))
(kill-new str)
(message "Copied: %s" str)))
(let ((dat (ring-ref avy-ring 0)))
(select-frame-set-input-focus
(window-frame (cdr dat)))
(select-window (cdr dat))
(goto-char (car dat))))
(defun avy-action-yank (pt)
"Yank sexp starting at PT at the current point."
(avy-action-copy pt)
(yank)
t)
(defun avy-action-kill-move (pt)
"Kill sexp at PT and move there."
(goto-char pt)
(avy-forward-item)
(kill-region pt (point))
(message "Killed: %s" (current-kill 0))
(point))
(defun avy-action-kill-stay (pt)
"Kill sexp at PT."
(save-excursion
(goto-char pt)
(avy-forward-item)
(kill-region pt (point))
(just-one-space))
(message "Killed: %s" (current-kill 0))
(select-window
(cdr
(ring-ref avy-ring 0)))
t)
(defun avy-action-zap-to-char (pt)
"Kill from point up to PT."
(if (> pt (point))
(kill-region (point) pt)
(kill-region pt (point))))
(defun avy-action-teleport (pt)
"Kill sexp starting on PT and yank into the current location."
(avy-action-kill-stay pt)
(select-window
(cdr
(ring-ref avy-ring 0)))
(save-excursion
(yank))
t)
(declare-function flyspell-correct-word-before-point "flyspell")
(defun avy-action-ispell (pt)
"Auto correct word at PT."
(save-excursion
(goto-char pt)
(cond
((eq avy-command 'avy-goto-line)
(ispell-region
(line-beginning-position)
(line-end-position)))
((bound-and-true-p flyspell-mode)
(flyspell-correct-word-before-point))
((looking-at-p "\\b")
(ispell-word))
(t
(progn
(backward-word)
(when (looking-at-p "\\b")
(ispell-word)))))))
(defvar avy-pre-action #'avy-pre-action-default
"Function to call before `avy-action' is called.")
(defun avy-pre-action-default (res)
(avy-push-mark)
(when (and (consp res)
(windowp (cdr res)))
(let* ((window (cdr res))
(frame (window-frame window)))
(unless (equal frame (selected-frame))
(select-frame-set-input-focus frame))
(select-window window))))
(defun avy--process-1 (candidates overlay-fn &optional cleanup-fn)
(let ((len (length candidates)))
(cond ((= len 0)
nil)
((and (= len 1) avy-single-candidate-jump)
(car candidates))
(t
(unwind-protect
(progn
(avy--make-backgrounds
(avy-window-list))
(cond ((eq avy-style 'de-bruijn)
(avy-read-de-bruijn
candidates avy-keys))
((eq avy-style 'words)
(avy-read-words
candidates avy-words))
(t
(avy-read (avy-tree candidates avy-keys)
overlay-fn
(or cleanup-fn #'avy--remove-leading-chars)))))
(avy--done))))))
(defvar avy-last-candidates nil
"Store the last candidate list.")
(defun avy--last-candidates-cycle (advancer)
(let* ((avy-last-candidates
(cl-remove-if-not
(lambda (x) (equal (cdr x) (selected-window)))
avy-last-candidates))
(min-dist
(apply #'min
(mapcar (lambda (x) (abs (- (caar x) (point)))) avy-last-candidates)))
(pos
(cl-position-if
(lambda (x)
(= (- (caar x) (point)) min-dist))
avy-last-candidates)))
(funcall advancer pos avy-last-candidates)))
(defun avy-prev ()
"Go to the previous candidate of the last `avy-read'."
(interactive)
(avy--last-candidates-cycle
(lambda (pos lst)
(when (> pos 0)
(goto-char (caar (nth (1- pos) lst)))))))
(defun avy-next ()
"Go to the next candidate of the last `avy-read'."
(interactive)
(avy--last-candidates-cycle
(lambda (pos lst)
(when (< pos (1- (length lst)))
(goto-char (caar (nth (1+ pos) lst)))))))
(defun avy-process (candidates &optional overlay-fn cleanup-fn)
"Select one of CANDIDATES using `avy-read'.
Use OVERLAY-FN to visualize the decision overlay.
CLEANUP-FN should take no arguments and remove the effects of
multiple OVERLAY-FN invocations."
(setq overlay-fn (or overlay-fn (avy--style-fn avy-style)))
(setq cleanup-fn (or cleanup-fn #'avy--remove-leading-chars))
(unless (and (consp (car candidates))
(windowp (cdar candidates)))
(setq candidates
(mapcar (lambda (x) (cons x (selected-window)))
candidates)))
(setq avy-last-candidates (copy-sequence candidates))
(let ((original-cands (copy-sequence candidates))
(res (avy--process-1 candidates overlay-fn cleanup-fn)))
(cond
((null res)
(message "zero candidates")
t)
((eq res 'restart)
(avy-process original-cands overlay-fn cleanup-fn))
;; ignore exit from `avy-handler-function'
((eq res 'exit))
(t
(funcall avy-pre-action res)
(setq res (car res))
(funcall (or avy-action 'avy-action-goto)
(if (consp res)
(car res)
res))
res))))
(define-obsolete-function-alias 'avy--process 'avy-process
"0.4.0")
(defvar avy--overlays-back nil
"Hold overlays for when `avy-background' is t.")
(defun avy--make-backgrounds (wnd-list)
"Create a dim background overlay for each window on WND-LIST."
(when avy-background
(setq avy--overlays-back
(mapcar (lambda (w)
(let ((ol (make-overlay
(window-start w)
(window-end w)
(window-buffer w))))
(overlay-put ol 'face 'avy-background-face)
(overlay-put ol 'window w)
ol))
wnd-list))))
(defun avy--done ()
"Clean up overlays."
(mapc #'delete-overlay avy--overlays-back)
(setq avy--overlays-back nil)
(avy--remove-leading-chars))
(defun avy--visible-p (s)
(let ((invisible (get-char-property s 'invisible)))
(or (null invisible)
(eq t buffer-invisibility-spec)
(null (assoc invisible buffer-invisibility-spec)))))
(defun avy--next-visible-point ()
"Return the next closest point without `invisible' property."
(let ((s (point)))
(while (and (not (= (point-max) (setq s (next-char-property-change s))))
(not (avy--visible-p s))))
s))
(defun avy--next-invisible-point ()
"Return the next closest point with `invisible' property."
(let ((s (point)))
(while (and (not (= (point-max) (setq s (next-char-property-change s))))
(avy--visible-p s)))
s))
(defun avy--find-visible-regions (rbeg rend)
"Return a list of all visible regions between RBEG and REND."
(setq rbeg (max rbeg (point-min)))
(setq rend (min rend (point-max)))
(when (< rbeg rend)
(let (visibles beg)
(save-excursion
(save-restriction
(narrow-to-region rbeg rend)
(setq beg (goto-char (point-min)))
(while (not (= (point) (point-max)))
(goto-char (avy--next-invisible-point))
(push (cons beg (point)) visibles)
(setq beg (goto-char (avy--next-visible-point))))
(nreverse visibles))))))
(defun avy--regex-candidates (regex &optional beg end pred group)
"Return all elements that match REGEX.
Each element of the list is ((BEG . END) . WND)
When PRED is non-nil, it's a filter for matching point positions.
When GROUP is non-nil, (BEG . END) should delimit that regex group."
(setq group (or group 0))
(let ((case-fold-search (or avy-case-fold-search
(string= regex (downcase regex))))
candidates)
(avy-dowindows current-prefix-arg
(dolist (pair (avy--find-visible-regions
(or beg (window-start))
(or end (window-end (selected-window) t))))
(save-excursion
(goto-char (car pair))
(while (re-search-forward regex (cdr pair) t)
(when (avy--visible-p (1- (point)))
(when (or (null pred)
(funcall pred))
(push (cons (cons (match-beginning group)
(match-end group))
wnd) candidates)))))))
(nreverse candidates)))
(defvar avy--overlay-offset 0
"The offset to apply in `avy--overlay'.")
(defvar avy--overlays-lead nil
"Hold overlays for leading chars.")
(defun avy--remove-leading-chars ()
"Remove leading char overlays."
(mapc #'delete-overlay avy--overlays-lead)
(setq avy--overlays-lead nil))
(defun avy--old-str (pt wnd)
"Return a one-char string at PT in WND."
(let ((old-str (with-selected-window wnd
(buffer-substring pt (1+ pt)))))
(if avy-background
(propertize old-str 'face 'avy-background-face)
old-str)))
(defun avy--overlay (str beg end wnd &optional compose-fn)
"Create an overlay with STR from BEG to END in WND.
COMPOSE-FN is a lambda that concatenates the old string at BEG with STR."
(let ((eob (with-selected-window wnd (point-max))))
(when (<= beg eob)
(let* ((beg (+ beg avy--overlay-offset))
(ol (make-overlay beg (or end (1+ beg)) (window-buffer wnd)))
(old-str (if (eq beg eob) "" (avy--old-str beg wnd)))
(os-line-prefix (get-text-property 0 'line-prefix old-str))
(os-wrap-prefix (get-text-property 0 'wrap-prefix old-str))
other-ol)
(when os-line-prefix
(add-text-properties 0 1 `(line-prefix ,os-line-prefix) str))
(when os-wrap-prefix
(add-text-properties 0 1 `(wrap-prefix ,os-wrap-prefix) str))
(when (setq other-ol (cl-find-if
(lambda (o) (overlay-get o 'goto-address))
(overlays-at beg)))
(add-text-properties
0 (length old-str)
`(face ,(overlay-get other-ol 'face)) old-str))
(overlay-put ol 'window wnd)
(overlay-put ol 'category 'avy)
(overlay-put ol (if (eq beg eob)
'after-string
'display)
(funcall
(or compose-fn #'concat)
str old-str))
(push ol avy--overlays-lead)))))
(defcustom avy-highlight-first nil
"When non-nil highlight the first decision char with `avy-lead-face-0'.
Do this even when the char is terminating."
:type 'boolean)
(defun avy--key-to-char (c)
"If C is no character, translate it using `avy-key-to-char-alist'."
(cond ((characterp c) c)
((cdr (assoc c avy-key-to-char-alist)))
((mouse-event-p c) c)
(t
(error "Unknown key %s" c))))
(defun avy-candidate-beg (leaf)
"Return the start position for LEAF."
(cond ((numberp leaf)
leaf)
((consp (car leaf))
(caar leaf))
(t
(car leaf))))
(defun avy-candidate-end (leaf)
"Return the end position for LEAF."
(cond ((numberp leaf)
leaf)
((consp (car leaf))
(cdar leaf))
(t
(car leaf))))
(defun avy-candidate-wnd (leaf)
"Return the window for LEAF."
(if (consp leaf)
(cdr leaf)
(selected-window)))
(defun avy--overlay-pre (path leaf)
"Create an overlay with PATH at LEAF.
PATH is a list of keys from tree root to LEAF.
LEAF is normally ((BEG . END) . WND)."
(let* ((path (mapcar #'avy--key-to-char path))
(str (propertize (apply #'string (reverse path))
'face 'avy-lead-face)))
(when (or avy-highlight-first (> (length str) 1))
(set-text-properties 0 1 '(face avy-lead-face-0) str))
(setq str (concat
(propertize avy-current-path
'face 'avy-lead-face-1)
str))
(avy--overlay
str
(avy-candidate-beg leaf) nil
(avy-candidate-wnd leaf))))
(defun avy--overlay-at (path leaf)
"Create an overlay with PATH at LEAF.
PATH is a list of keys from tree root to LEAF.
LEAF is normally ((BEG . END) . WND)."
(let* ((path (mapcar #'avy--key-to-char path))
(str (propertize
(string (car (last path)))
'face 'avy-lead-face)))
(avy--overlay
str
(avy-candidate-beg leaf) nil
(avy-candidate-wnd leaf)
(lambda (str old-str)
(cond ((string= old-str "\n")
(concat str "\n"))
;; add padding for wide-width character
((eq (string-width old-str) 2)
(concat str " "))
(t
str))))))
(defun avy--overlay-at-full (path leaf)
"Create an overlay with PATH at LEAF.
PATH is a list of keys from tree root to LEAF.
LEAF is normally ((BEG . END) . WND)."
(let* ((path (mapcar #'avy--key-to-char path))
(str (propertize
(apply #'string (reverse path))
'face 'avy-lead-face))
(len (length path))
(beg (avy-candidate-beg leaf))
(wnd (cdr leaf))
end)
(dotimes (i len)
(set-text-properties i (1+ i)
`(face ,(nth i avy-lead-faces))
str))
(when (eq avy-style 'de-bruijn)
(setq str (concat
(propertize avy-current-path
'face 'avy-lead-face-1)
str))
(setq len (length str)))
(with-selected-window wnd
(save-excursion
(goto-char beg)
(let* ((lep (if (bound-and-true-p visual-line-mode)
(save-excursion
(end-of-visual-line)
(point))
(line-end-position)))
;; `end-of-visual-line' is bugged sometimes
(lep (if (< lep beg)
(line-end-position)
lep))
(len-and-str (avy--update-offset-and-str len str lep)))
(setq len (car len-and-str))
(setq str (cdr len-and-str))
(setq end (if (= beg lep)
(1+ beg)
(min (+ beg
(if (eq (char-after) ?\t)
1
len))
lep)))
(when (and (bound-and-true-p visual-line-mode)
(> len (- end beg))
(not (eq lep beg)))
(setq len (- end beg))
(let ((old-str (apply #'string (reverse path))))
(setq str
(substring
(propertize
old-str
'face
(if (= (length old-str) 1)
'avy-lead-face
'avy-lead-face-0))
0 len)))))))
(avy--overlay
str beg end wnd
(lambda (str old-str)
(cond ((string= old-str "\n")
(concat str "\n"))
((string= old-str "\t")
(concat str (make-string (max (- tab-width len) 0) ?\ )))
(t
;; add padding for wide-width character
(if (eq (string-width old-str) 2)
(concat str " ")
str)))))))
(defun avy--overlay-post (path leaf)
"Create an overlay with PATH at LEAF.
PATH is a list of keys from tree root to LEAF.
LEAF is normally ((BEG . END) . WND)."
(let* ((path (mapcar #'avy--key-to-char path))
(str (propertize (apply #'string (reverse path))
'face 'avy-lead-face)))
(when (or avy-highlight-first (> (length str) 1))
(set-text-properties 0 1 '(face avy-lead-face-0) str))
(setq str (concat
(propertize avy-current-path
'face 'avy-lead-face-1)
str))
(avy--overlay
str
(avy-candidate-end leaf) nil
(avy-candidate-wnd leaf))))
(defun avy--update-offset-and-str (offset str lep)
"Recalculate the length of the new overlay at point.
OFFSET is the previous overlay length.
STR is the overlay string that we wish to add.
LEP is the line end position.
We want to add an overlay between point and END=point+OFFSET.
When other overlays already exist between point and END, set
OFFSET to be the difference between the start of the first
overlay and point. This is equivalent to truncating our new
overlay, so that it doesn't intersect with overlays that already
exist."
(let* ((wnd (selected-window))
(beg (point))
(oov (delq nil
(mapcar
(lambda (o)
(and (eq (overlay-get o 'category) 'avy)
(eq (overlay-get o 'window) wnd)
(overlay-start o)))
(overlays-in beg (min (+ beg offset) lep))))))
(when oov
(setq offset (- (apply #'min oov) beg))
(setq str (substring str 0 offset)))
(let ((other-ov (cl-find-if
(lambda (o)
(and (eq (overlay-get o 'category) 'avy)
(eq (overlay-start o) beg)
(not (eq (overlay-get o 'window) wnd))))
(overlays-in (point) (min (+ (point) offset) lep)))))
(when (and other-ov
(> (overlay-end other-ov)
(+ beg offset)))
(setq str (concat str (buffer-substring
(+ beg offset)
(overlay-end other-ov))))
(setq offset (- (overlay-end other-ov)
beg))))
(cons offset str)))
(defun avy--style-fn (style)
"Transform STYLE symbol to a style function."
(cl-case style
(pre #'avy--overlay-pre)
(at #'avy--overlay-at)
(at-full 'avy--overlay-at-full)
(post #'avy--overlay-post)
(de-bruijn #'avy--overlay-at-full)
(words #'avy--overlay-at-full)
(ignore #'ignore)
(t (error "Unexpected style %S" style))))
(cl-defun avy-jump (regex &key window-flip beg end action pred)
"Jump to REGEX.
The window scope is determined by `avy-all-windows'.
When WINDOW-FLIP is non-nil, do the opposite of `avy-all-windows'.
BEG and END narrow the scope where candidates are searched.
ACTION is a function that takes point position as an argument.
When PRED is non-nil, it's a filter for matching point positions."
(setq avy-action (or action avy-action))
(let ((avy-all-windows
(if window-flip
(not avy-all-windows)
avy-all-windows)))
(avy-process
(avy--regex-candidates regex beg end pred))))
(defun avy--generic-jump (regex window-flip &optional beg end)
"Jump to REGEX.
The window scope is determined by `avy-all-windows'.
When WINDOW-FLIP is non-nil, do the opposite of `avy-all-windows'.
BEG and END narrow the scope where candidates are searched."
(declare (obsolete avy-jump "0.4.0"))
(let ((avy-all-windows
(if window-flip
(not avy-all-windows)
avy-all-windows)))
(avy-process
(avy--regex-candidates regex beg end))))
;;* Commands
;;;###autoload
(defun avy-goto-char (char &optional arg)
"Jump to the currently visible CHAR.
The window scope is determined by `avy-all-windows' (ARG negates it)."
(interactive (list (read-char "char: " t)
current-prefix-arg))
(avy-with avy-goto-char
(avy-jump
(if (= 13 char)
"\n"
(regexp-quote (string char)))
:window-flip arg)))
;;;###autoload
(defun avy-goto-char-in-line (char)
"Jump to the currently visible CHAR in the current line."
(interactive (list (read-char "char: " t)))
(avy-with avy-goto-char
(avy-jump
(regexp-quote (string char))
:beg (line-beginning-position)
:end (line-end-position))))
;;;###autoload
(defun avy-goto-char-2 (char1 char2 &optional arg beg end)
"Jump to the currently visible CHAR1 followed by CHAR2.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'.
BEG and END narrow the scope where candidates are searched."
(interactive (list (read-char "char 1: " t)
(read-char "char 2: " t)
current-prefix-arg
nil nil))
(when (eq char1 ?
)
(setq char1 ?\n))
(when (eq char2 ?
)
(setq char2 ?\n))
(avy-with avy-goto-char-2
(avy-jump
(regexp-quote (string char1 char2))
:window-flip arg
:beg beg
:end end)))
;;;###autoload
(defun avy-goto-char-2-above (char1 char2 &optional arg)
"Jump to the currently visible CHAR1 followed by CHAR2.
This is a scoped version of `avy-goto-char-2', where the scope is
the visible part of the current buffer up to point.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'."
(interactive (list (read-char "char 1: " t)
(read-char "char 2: " t)
current-prefix-arg))
(avy-with avy-goto-char-2-above
(avy-goto-char-2
char1 char2 arg
(window-start) (point))))
;;;###autoload
(defun avy-goto-char-2-below (char1 char2 &optional arg)
"Jump to the currently visible CHAR1 followed by CHAR2.
This is a scoped version of `avy-goto-char-2', where the scope is
the visible part of the current buffer following point.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'."
(interactive (list (read-char "char 1: " t)
(read-char "char 2: " t)
current-prefix-arg))
(avy-with avy-goto-char-2-below
(avy-goto-char-2
char1 char2 arg
(point) (window-end (selected-window) t))))
;;;###autoload
(defun avy-isearch ()
"Jump to one of the current isearch candidates."
(interactive)
(avy-with avy-isearch
(let ((avy-background nil))
(avy-process
(avy--regex-candidates (if isearch-regexp
isearch-string
(regexp-quote isearch-string))))
(isearch-done))))
;;;###autoload
(defun avy-goto-word-0 (arg &optional beg end)
"Jump to a word start.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'.
BEG and END narrow the scope where candidates are searched."
(interactive "P")
(avy-with avy-goto-word-0
(avy-jump avy-goto-word-0-regexp
:window-flip arg
:beg beg
:end end)))
(defun avy-goto-word-0-above (arg)
"Jump to a word start between window start and point.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'."
(interactive "P")
(avy-with avy-goto-word-0
(avy-goto-word-0 arg (window-start) (point))))
(defun avy-goto-word-0-below (arg)
"Jump to a word start between point and window end.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'."
(interactive "P")
(avy-with avy-goto-word-0
(avy-goto-word-0 arg (point) (window-end (selected-window) t))))
;;;###autoload
(defun avy-goto-word-1 (char &optional arg beg end symbol)
"Jump to the currently visible CHAR at a word start.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'.
BEG and END narrow the scope where candidates are searched.
When SYMBOL is non-nil, jump to symbol start instead of word start."
(interactive (list (read-char "char: " t)
current-prefix-arg))
(avy-with avy-goto-word-1
(let* ((str (string char))
(regex (cond ((string= str ".")
"\\.")
((and avy-word-punc-regexp
(string-match avy-word-punc-regexp str))
(regexp-quote str))
((<= char 26)
str)
(t
(concat
(if symbol "\\_<" "\\b")
str)))))
(avy-jump regex
:window-flip arg
:beg beg
:end end))))
;;;###autoload
(defun avy-goto-word-1-above (char &optional arg)
"Jump to the currently visible CHAR at a word start.
This is a scoped version of `avy-goto-word-1', where the scope is
the visible part of the current buffer up to point.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'."
(interactive (list (read-char "char: " t)
current-prefix-arg))
(avy-with avy-goto-word-1
(avy-goto-word-1 char arg (window-start) (point))))
;;;###autoload
(defun avy-goto-word-1-below (char &optional arg)
"Jump to the currently visible CHAR at a word start.
This is a scoped version of `avy-goto-word-1', where the scope is
the visible part of the current buffer following point.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'."
(interactive (list (read-char "char: " t)
current-prefix-arg))
(avy-with avy-goto-word-1
(avy-goto-word-1 char arg (point) (window-end (selected-window) t))))
;;;###autoload
(defun avy-goto-symbol-1 (char &optional arg)
"Jump to the currently visible CHAR at a symbol start.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'."
(interactive (list (read-char "char: " t)
current-prefix-arg))
(avy-with avy-goto-symbol-1
(avy-goto-word-1 char arg nil nil t)))
;;;###autoload
(defun avy-goto-symbol-1-above (char &optional arg)
"Jump to the currently visible CHAR at a symbol start.
This is a scoped version of `avy-goto-symbol-1', where the scope is
the visible part of the current buffer up to point.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'."
(interactive (list (read-char "char: " t)
current-prefix-arg))
(avy-with avy-goto-symbol-1-above
(avy-goto-word-1 char arg (window-start) (point) t)))
;;;###autoload
(defun avy-goto-symbol-1-below (char &optional arg)
"Jump to the currently visible CHAR at a symbol start.
This is a scoped version of `avy-goto-symbol-1', where the scope is
the visible part of the current buffer following point.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'."
(interactive (list (read-char "char: " t)
current-prefix-arg))
(avy-with avy-goto-symbol-1-below
(avy-goto-word-1 char arg (point) (window-end (selected-window) t) t)))
(declare-function subword-backward "subword")
(defvar subword-backward-regexp)
(defcustom avy-subword-extra-word-chars '(?{ ?= ?} ?* ?: ?> ?<)
"A list of characters that should temporarily match \"\\w\".
This variable is used by `avy-goto-subword-0' and `avy-goto-subword-1'."
:type '(repeat character))
;;;###autoload
(defun avy-goto-subword-0 (&optional arg predicate beg end)
"Jump to a word or subword start.
The window scope is determined by `avy-all-windows' (ARG negates it).
When PREDICATE is non-nil it's a function of zero parameters that
should return true.
BEG and END narrow the scope where candidates are searched."
(interactive "P")
(require 'subword)
(avy-with avy-goto-subword-0
(let ((case-fold-search nil)
(subword-backward-regexp
"\\(\\(\\W\\|[[:lower:][:digit:]]\\)\\([!-/:@`~[:upper:]]+\\W*\\)\\|\\W\\w+\\)")
candidates)
(avy-dowindows arg
(let ((syn-tbl (copy-syntax-table)))
(dolist (char avy-subword-extra-word-chars)
(modify-syntax-entry char "w" syn-tbl))
(with-syntax-table syn-tbl
(let ((ws (or beg (window-start)))
window-cands)
(save-excursion
(goto-char (or end (window-end (selected-window) t)))
(subword-backward)
(while (> (point) ws)
(when (or (null predicate)
(and predicate (funcall predicate)))
(unless (not (avy--visible-p (point)))
(push (cons (point) (selected-window)) window-cands)))
(subword-backward))
(and (= (point) ws)
(or (null predicate)
(and predicate (funcall predicate)))
(not (get-char-property (point) 'invisible))
(push (cons (point) (selected-window)) window-cands)))
(setq candidates (nconc candidates window-cands))))))
(avy-process candidates))))
;;;###autoload
(defun avy-goto-subword-1 (char &optional arg)
"Jump to the currently visible CHAR at a subword start.
The window scope is determined by `avy-all-windows' (ARG negates it).
The case of CHAR is ignored."
(interactive (list (read-char "char: " t)
current-prefix-arg))
(avy-with avy-goto-subword-1
(let ((char (downcase char)))
(avy-goto-subword-0
arg (lambda ()
(and (char-after)
(eq (downcase (char-after)) char)))))))
;;;###autoload
(defun avy-goto-word-or-subword-1 ()
"Forward to `avy-goto-subword-1' or `avy-goto-word-1'.
Which one depends on variable `subword-mode'."
(interactive)
(if (bound-and-true-p subword-mode)
(call-interactively #'avy-goto-subword-1)
(call-interactively #'avy-goto-word-1)))
(defvar visual-line-mode)
(defcustom avy-indent-line-overlay nil
"When non-nil, `avy-goto-line' will display the line overlay next to the first non-whitespace character of each line."
:type 'boolean)
(defun avy--line-cands (&optional arg beg end bottom-up)
"Get candidates for selecting a line.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'.
BEG and END narrow the scope where candidates are searched.
When BOTTOM-UP is non-nil, display avy candidates from top to bottom"
(let (candidates)
(avy-dowindows arg
(let ((ws (or beg (window-start))))
(save-excursion
(save-restriction
(narrow-to-region ws (or end (window-end (selected-window) t)))
(goto-char (point-min))
(while (< (point) (point-max))
(when (member (get-char-property
(max (1- (point)) ws) 'invisible) '(nil org-link))
(push (cons
(if (eq avy-style 'post)
(line-end-position)
(save-excursion
(when avy-indent-line-overlay
(skip-chars-forward " \t"))
(point)))
(selected-window)) candidates))
(if visual-line-mode
(progn
(setq temporary-goal-column 0)
(line-move-visual 1 t))
(forward-line 1)))))))
(if bottom-up
candidates
(nreverse candidates))))
(defun avy--linum-strings ()
"Get strings for `avy-linum-mode'."
(let* ((lines (mapcar #'car (avy--line-cands)))
(line-tree (avy-tree lines avy-keys))
(line-list nil))
(avy-traverse
line-tree
(lambda (path _leaf)
(let ((str (propertize (apply #'string (reverse path))
'face 'avy-lead-face)))
(when (> (length str) 1)
(set-text-properties 0 1 '(face avy-lead-face-0) str))
(push str line-list))))
(nreverse line-list)))
(defvar linum-available)
(defvar linum-overlays)
(defvar linum-format)
(declare-function linum--face-width "linum")
(define-minor-mode avy-linum-mode
"Minor mode that uses avy hints for `linum-mode'."
:group 'avy
(if avy-linum-mode
(progn
(require 'linum)
(advice-add 'linum-update-window :around 'avy--linum-update-window)
(linum-mode 1))
(advice-remove 'linum-update-window 'avy--linum-update-window)
(linum-mode -1)))
(defun avy--linum-update-window (_ win)
"Update line numbers for the portion visible in window WIN."
(goto-char (window-start win))
(let ((line (line-number-at-pos))
(limit (window-end win t))
(fmt (cond ((stringp linum-format) linum-format)
((eq linum-format 'dynamic)
(let ((w (length (number-to-string
(count-lines (point-min) (point-max))))))
(concat "%" (number-to-string w) "d")))))
(width 0)
(avy-strs (when avy-linum-mode
(avy--linum-strings))))
(run-hooks 'linum-before-numbering-hook)
;; Create an overlay (or reuse an existing one) for each
;; line visible in this window, if necessary.
(while (and (not (eobp)) (< (point) limit))
(let* ((str
(cond (avy-linum-mode
(pop avy-strs))
(fmt
(propertize (format fmt line) 'face 'linum))
(t
(funcall linum-format line))))
(visited (catch 'visited
(dolist (o (overlays-in (point) (point)))
(when (equal-including-properties
(overlay-get o 'linum-str) str)
(unless (memq o linum-overlays)
(push o linum-overlays))
(setq linum-available (delq o linum-available))
(throw 'visited t))))))
(setq width (max width (length str)))
(unless visited
(let ((ov (if (null linum-available)
(make-overlay (point) (point))
(move-overlay (pop linum-available) (point) (point)))))
(push ov linum-overlays)
(overlay-put ov 'before-string
(propertize " " 'display `((margin left-margin) ,str)))
(overlay-put ov 'linum-str str))))
;; Text may contain those nasty intangible properties, but that
;; shouldn't prevent us from counting those lines.
(let ((inhibit-point-motion-hooks t))
(forward-line))
(setq line (1+ line)))
(when (display-graphic-p)
(setq width (ceiling
(/ (* width 1.0 (linum--face-width 'linum))
(frame-char-width)))))
(set-window-margins win width (cdr (window-margins win)))))
(defun avy--line (&optional arg beg end bottom-up)
"Select a line.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'.
BEG and END narrow the scope where candidates are searched.
When BOTTOM-UP is non-nil, display avy candidates from top to bottom"
(let ((avy-action #'identity)
(avy-style (if avy-linum-mode
(progn
(message "Goto line:")
'ignore)
avy-style)))
(avy-process
(avy--line-cands arg beg end bottom-up))))
;;;###autoload
(defun avy-goto-line (&optional arg)
"Jump to a line start in current buffer.
When ARG is 1, jump to lines currently visible, with the option
to cancel to `goto-line' by entering a number.
When ARG is 4, negate the window scope determined by
`avy-all-windows'.
Otherwise, forward to `goto-line' with ARG."
(interactive "p")
(setq arg (or arg 1))
(if (not (memq arg '(1 4)))
(progn
(goto-char (point-min))
(forward-line (1- arg)))
(avy-with avy-goto-line
(let* ((avy-handler-old avy-handler-function)
(avy-handler-function
(lambda (char)
(if (or (< char ?0)
(> char ?9))
(funcall avy-handler-old char)
(let ((line (read-from-minibuffer
"Goto line: " (string char))))
(when line
(avy-push-mark)
(save-restriction
(widen)
(goto-char (point-min))
(forward-line (1- (string-to-number line))))
(throw 'done 'exit))))))
(r (avy--line (eq arg 4))))
(unless (eq r t)
(avy-action-goto r))))))
;;;###autoload
(defun avy-goto-line-above (&optional offset bottom-up)
"Goto visible line above the cursor.
OFFSET changes the distance between the closest key to the cursor and
the cursor
When BOTTOM-UP is non-nil, display avy candidates from top to bottom"
(interactive)
(if offset
(setq offset (+ 2 (- offset))))
(let* ((avy-all-windows nil)
(r (avy--line nil (window-start)
(line-beginning-position (or offset 1))
bottom-up)))
(unless (eq r t)
(avy-action-goto r))))
;;;###autoload
(defun avy-goto-line-below (&optional offset bottom-up)
"Goto visible line below the cursor.
OFFSET changes the distance between the closest key to the cursor and
the cursor
When BOTTOM-UP is non-nil, display avy candidates from top to bottom"
(interactive)
(if offset
(setq offset (+ offset 1)))
(let* ((avy-all-windows nil)
(r (avy--line
nil (line-beginning-position (or offset 2))
(window-end (selected-window) t)
bottom-up)))
(unless (eq r t)
(avy-action-goto r))))
(defcustom avy-line-insert-style 'above
"How to insert the newly copied/cut line."
:type '(choice
(const :tag "Above" above)
(const :tag "Below" below)))
;;;###autoload
(defun avy-goto-end-of-line (&optional arg)
"Call `avy-goto-line' and move to the end of the line."
(interactive "p")
(avy-goto-line arg)
(end-of-line))
;;;###autoload
(defun avy-copy-line (arg)
"Copy a selected line above the current line.
ARG lines can be used."
(interactive "p")
(let ((initial-window (selected-window)))
(avy-with avy-copy-line
(let* ((start (avy--line))
(str (buffer-substring-no-properties
start
(save-excursion
(goto-char start)
(move-end-of-line arg)
(point)))))
(select-window initial-window)
(cond ((eq avy-line-insert-style 'above)
(beginning-of-line)
(save-excursion
(insert str "\n")))
((eq avy-line-insert-style 'below)
(end-of-line)
(insert "\n" str)
(beginning-of-line))
(t
(user-error "Unexpected `avy-line-insert-style'")))))))
;;;###autoload
(defun avy-move-line (arg)
"Move a selected line above the current line.
ARG lines can be used."
(interactive "p")
(let ((initial-window (selected-window)))
(avy-with avy-move-line
(let ((start (avy--line)))
(save-excursion
(goto-char start)
(kill-whole-line arg))
(select-window initial-window)
(cond ((eq avy-line-insert-style 'above)
(beginning-of-line)
(save-excursion
(insert
(current-kill 0))))
((eq avy-line-insert-style 'below)
(end-of-line)
(newline)
(save-excursion
(insert (substring (current-kill 0) 0 -1))))
(t
(user-error "Unexpected `avy-line-insert-style'")))))))
;;;###autoload
(defun avy-copy-region (arg)
"Select two lines and copy the text between them to point.
The window scope is determined by `avy-all-windows' or
`avy-all-windows-alt' when ARG is non-nil."
(interactive "P")
(let ((initial-window (selected-window)))
(avy-with avy-copy-region
(let* ((beg (save-selected-window
(avy--line arg)))
(end (avy--line arg))
(str (buffer-substring-no-properties
beg
(save-excursion
(goto-char end)
(line-end-position)))))
(select-window initial-window)
(cond ((eq avy-line-insert-style 'above)
(beginning-of-line)
(save-excursion
(insert str "\n")))
((eq avy-line-insert-style 'below)
(end-of-line)
(newline)
(save-excursion
(insert str)))
(t
(user-error "Unexpected `avy-line-insert-style'")))))))
;;;###autoload
(defun avy-move-region ()
"Select two lines and move the text between them above the current line."
(interactive)
(avy-with avy-move-region
(let* ((initial-window (selected-window))
(beg (avy--line))
(end (avy--line))
text)
(when (> beg end)
(cl-rotatef beg end))
(setq end (save-excursion
(goto-char end)
(1+ (line-end-position))))
(setq text (buffer-substring beg end))
(move-beginning-of-line nil)
(delete-region beg end)
(select-window initial-window)
(insert text))))
;;;###autoload
(defun avy-kill-region (arg)
"Select two lines and kill the region between them.
The window scope is determined by `avy-all-windows' or
`avy-all-windows-alt' when ARG is non-nil."
(interactive "P")
(let ((initial-window (selected-window)))
(avy-with avy-kill-region
(let* ((beg (save-selected-window
(list (avy--line arg) (selected-window))))
(end (list (avy--line arg) (selected-window))))
(cond
((not (numberp (car beg)))
(user-error "Fail to select the beginning of region"))
((not (numberp (car end)))
(user-error "Fail to select the end of region"))
;; Restrict operation to same window. It's better if it can be
;; different windows but same buffer; however, then the cloned
;; buffers with different narrowed regions might cause problem.
((not (equal (cdr beg) (cdr end)))
(user-error "Selected points are not in the same window"))
((< (car beg) (car end))
(save-excursion
(kill-region
(car beg)
(progn (goto-char (car end)) (forward-visible-line 1) (point)))))
(t
(save-excursion
(kill-region
(progn (goto-char (car beg)) (forward-visible-line 1) (point))
(car end)))))))
(select-window initial-window)))
;;;###autoload
(defun avy-kill-ring-save-region (arg)
"Select two lines and save the region between them to the kill ring.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'."
(interactive "P")
(let ((initial-window (selected-window)))
(avy-with avy-kill-ring-save-region
(let* ((beg (save-selected-window
(list (avy--line arg) (selected-window))))
(end (list (avy--line arg) (selected-window))))
(cond
((not (numberp (car beg)))
(user-error "Fail to select the beginning of region"))
((not (numberp (car end)))
(user-error "Fail to select the end of region"))
((not (equal (cdr beg) (cdr end)))
(user-error "Selected points are not in the same window"))
((< (car beg) (car end))
(save-excursion
(kill-ring-save
(car beg)
(progn (goto-char (car end)) (forward-visible-line 1) (point)))))
(t
(save-excursion
(kill-ring-save
(progn (goto-char (car beg)) (forward-visible-line 1) (point))
(car end)))))))
(select-window initial-window)))
;;;###autoload
(defun avy-kill-whole-line (arg)
"Select line and kill the whole selected line.
With a numerical prefix ARG, kill ARG line(s) starting from the
selected line. If ARG is negative, kill backward.
If ARG is zero, kill the selected line but exclude the trailing
newline.
\\[universal-argument] 3 \\[avy-kil-whole-line] kill three lines
starting from the selected line. \\[universal-argument] -3
\\[avy-kill-whole-line] kill three lines backward including the
selected line."
(interactive "P")
(let ((initial-window (selected-window)))
(avy-with avy-kill-whole-line
(let* ((start (avy--line)))
(if (not (numberp start))
(user-error "Fail to select the line to kill")
(save-excursion (goto-char start)
(kill-whole-line arg)))))
(select-window initial-window)))
;;;###autoload
(defun avy-kill-ring-save-whole-line (arg)
"Select line and save the whole selected line as if killed, but don’t kill it.
This command is similar to `avy-kill-whole-line', except that it
saves the line(s) as if killed, but does not kill it(them).
With a numerical prefix ARG, kill ARG line(s) starting from the
selected line. If ARG is negative, kill backward.
If ARG is zero, kill the selected line but exclude the trailing
newline."
(interactive "P")
(let ((initial-window (selected-window)))
(avy-with avy-kill-ring-save-whole-line
(let* ((start (avy--line)))
(if (not (numberp start))
(user-error "Fail to select the line to kill")
(save-excursion
(let ((kill-read-only-ok t)
(buffer-read-only t))
(goto-char start)
(kill-whole-line arg))))))
(select-window initial-window)))
;;;###autoload
(defun avy-setup-default ()
"Setup the default shortcuts."
(eval-after-load "isearch"
'(define-key isearch-mode-map (kbd "C-'") 'avy-isearch)))
(defcustom avy-timeout-seconds 0.5
"How many seconds to wait for the second char."
:type 'float)
(defcustom avy-enter-times-out t
"Whether enter exits avy-goto-char-timer early. If nil it matches newline"
:type 'boolean)
(defun avy--read-candidates (&optional re-builder)
"Read as many chars as possible and return their occurrences.
At least one char must be read, and then repeatedly one next char
may be read if it is entered before `avy-timeout-seconds'. DEL
deletes the last char entered, and RET exits with the currently
read string immediately instead of waiting for another char for
`avy-timeout-seconds'.
The format of the result is the same as that of `avy--regex-candidates'.
This function obeys `avy-all-windows' setting.
RE-BUILDER is a function that takes a string and returns a regex.
When nil, `regexp-quote' is used.
If a group is captured, the first group is highlighted.
Otherwise, the whole regex is highlighted."
(let ((str "")
(re-builder (or re-builder #'regexp-quote))
char break overlays regex)
(unwind-protect
(progn
(avy--make-backgrounds
(avy-window-list))
(while (and (not break)
(setq char
(read-char (format "%d char%s: "
(length overlays)
(if (string= str "")
str
(format " (%s)" str)))
t
(and (not (string= str ""))
avy-timeout-seconds))))
;; Unhighlight
(dolist (ov overlays)
(delete-overlay ov))
(setq overlays nil)
(cond
;; Handle RET
((= char 13)
(if avy-enter-times-out
(setq break t)
(setq str (concat str (list ?\n)))))
;; Handle C-h, DEL
((memq char avy-del-last-char-by)
(let ((l (length str)))
(when (>= l 1)
(setq str (substring str 0 (1- l))))))
;; Handle ESC
((= char 27)
(keyboard-quit))
(t
(setq str (concat str (list char)))))
;; Highlight
(when (>= (length str) 1)
(let ((case-fold-search
(or avy-case-fold-search (string= str (downcase str))))
found)
(avy-dowindows current-prefix-arg
(dolist (pair (avy--find-visible-regions
(window-start)
(window-end (selected-window) t)))
(save-excursion
(goto-char (car pair))
(setq regex (funcall re-builder str))
(while (re-search-forward regex (cdr pair) t)
(unless (not (avy--visible-p (1- (point))))
(let* ((idx (if (= (length (match-data)) 4) 1 0))
(ov (make-overlay
(match-beginning idx) (match-end idx))))
(setq found t)
(push ov overlays)
(overlay-put
ov 'window (selected-window))
(overlay-put
ov 'face 'avy-goto-char-timer-face)))))))
;; No matches at all, so there's surely a typo in the input.
(unless found (beep)))))
(nreverse (mapcar (lambda (ov)
(cons (cons (overlay-start ov)
(overlay-end ov))
(overlay-get ov 'window)))
overlays)))
(dolist (ov overlays)
(delete-overlay ov))
(avy--done))))
;;;###autoload
(defun avy-goto-char-timer (&optional arg)
"Read one or many consecutive chars and jump to the first one.
The window scope is determined by `avy-all-windows' (ARG negates it)."
(interactive "P")
(let ((avy-all-windows (if arg
(not avy-all-windows)
avy-all-windows)))
(avy-with avy-goto-char-timer
(avy-process
(avy--read-candidates)))))
(defun avy-push-mark ()
"Store the current point and window."
(let ((inhibit-message t))
(ring-insert avy-ring
(cons (point) (selected-window)))
(unless (region-active-p)
(push-mark))))
(defun avy-pop-mark ()
"Jump back to the last location of `avy-push-mark'."
(interactive)
(let (res)
(condition-case nil
(progn
(while (not (window-live-p
(cdr (setq res (ring-remove avy-ring 0))))))
(let* ((window (cdr res))
(frame (window-frame window)))
(when (and (frame-live-p frame)
(not (eq frame (selected-frame))))
(select-frame-set-input-focus frame))
(select-window window)
(goto-char (car res))))
(error
(set-mark-command 4)))))
;; ** Org-mode
(defvar org-reverse-note-order)
(declare-function org-refile "org")
(declare-function org-back-to-heading "org")
(declare-function org-reveal "org")
(defvar org-after-refile-insert-hook)
(defun avy-org-refile-as-child ()
"Refile current heading as first child of heading selected with `avy.'"
;; Inspired by `org-teleport': http://kitchingroup.cheme.cmu.edu/blog/2016/03/18/Org-teleport-headlines/
(interactive)
(let* ((org-reverse-note-order t)
(marker (save-excursion
(avy-with avy-goto-line
(unless (eq 't (avy-jump (rx bol (1+ "*") (1+ space))))
;; `avy-jump' returns t when aborted with C-g.
(point-marker)))))
(filename (buffer-file-name (or (buffer-base-buffer (marker-buffer marker))
(marker-buffer marker))))
(rfloc (list nil filename nil marker))
;; Ensure the refiled heading is visible.
(org-after-refile-insert-hook (if (member 'org-reveal org-after-refile-insert-hook)
org-after-refile-insert-hook
(cons #'org-reveal org-after-refile-insert-hook))))
(when marker
;; Only attempt refile if avy session was not aborted.
(org-refile nil nil rfloc))))
(defun avy-org-goto-heading-timer (&optional arg)
"Read one or many characters and jump to matching Org headings.
The window scope is determined by `avy-all-windows' (ARG negates it)."
(interactive "P")
(let ((avy-all-windows (if arg
(not avy-all-windows)
avy-all-windows)))
(avy-with avy-goto-char-timer
(avy-process
(avy--read-candidates
(lambda (input)
(format "^\\*+ .*\\(%s\\)" input))))
(org-back-to-heading))))
(provide 'avy)
;;; avy.el ends here
avy-0.5.0/doc/ 0000755 0001752 0001753 00000000000 13465634146 011525 5 ustar elpa elpa avy-0.5.0/doc/Changelog.org 0000644 0001752 0001753 00000046572 13465634146 014143 0 ustar elpa elpa * 0.3.0
** Fixes
*** Candidate window reversal
See [[https://github.com/abo-abo/avy/issues/27][#27]].
*** Jumping to newlines with =at-full= style
See [[https://github.com/abo-abo/avy/issues/5][#5]].
*** Stop =at-full= style from shifting text sometimes
See [[https://github.com/abo-abo/avy/issues/5][#5]].
*** Fix =at-full= interaction with tabs
When at a tab, visualize it using =tab-width= spaces.
See [[https://github.com/abo-abo/avy/issues/43][#43]].
*** Fix overlay issue when the same buffer is in two windows
See [[https://github.com/abo-abo/avy/issues/47][#47]] and http://debbugs.gnu.org/cgi/bugreport.cgi?bug=20607.
*** Quote punctuation chars
See [[https://github.com/abo-abo/avy/issues/63][#63]].
*** Update screenshot for =avy-goto-char= in README.md
Use ~C-:~ as the new suggested binding instead of the pi char.
See [[https://github.com/abo-abo/avy/issues/64][#64]].
** New Features
*** =avy-goto-line= can now break into =goto-line=
Just enter a digit and you'll be transferred into =goto-line= prompt
with that digit already entered. This means that you can just bind
~M-g g~ to =avy-goto-line= without losing anything.
See [[https://github.com/abo-abo/avy/issues/29][#29]].
*** =avy-goto-line= now works with all kinds of overlay styles
Any of the following do something different now:
#+begin_src elisp
(setq avy-styles-alist
'((avy-goto-line . post)))
(setq avy-styles-alist
'((avy-goto-line . at)))
(setq avy-styles-alist
'((avy-goto-line . at-full)))
(setq avy-styles-alist
'((avy-goto-line . pre)))
#+end_src
See [[https://github.com/abo-abo/ace-link/issues/17][#17]].
*** New defcustom =avy-case-fold-search=
Non-nil when searches should ignore case, so e.g. =avy-goto-char= "b"
will match both "b" and "B". On by default. Use this to turn off this
behavior:
#+begin_src elisp
(setq avy-case-fold-search nil)
#+end_src
See [[https://github.com/abo-abo/avy/issues/34][#34]].
*** New command =avy-goto-word-or-subword-1=
Enter one char, and select a visible word or subword that starts with
it, depending on =subword-mode=. Move the point there.
See [[https://github.com/abo-abo/avy/issues/33][#33]].
*** =avy-move-line= should remove empty line after original one is moved
See [[https://github.com/abo-abo/avy/issues/40][#40]].
*** =avy-move-line= now takes a prefix arg
Use e.g. ~M-3~ before =avy-move-line= to move 3 lines at once.
*** Most commands can be used non-interactively
Example:
#+begin_src elisp
(defun avy-goto-lp ()
(interactive)
(avy-goto-char ?\())
#+end_src
This command only goes to the "(" character. This is actually very
similar to [[http://oremacs.com/lispy/#lispy-ace-paren][=lispy-ace-paren=]], except the implementation is only one
line.
See [[https://github.com/abo-abo/avy/issues/44][#44]].
*** (almost) all defcustoms are explained on the wiki
See [[https://github.com/abo-abo/avy/wiki/defcustom][the defcustom wiki page]].
*** Allow all operations to work across frames
You have to customize =avy-all-windows= for this. By default, it's set
to work on all windows on the current frame.
To make it work only on the current window, use:
#+begin_src elisp
(setq avy-all-windows nil)
#+end_src
To make it work on all frames, use:
#+begin_src elisp
(setq avy-all-windows 'all-frames)
#+end_src
*** New command =avy-goto-char-in-line=
This is =avy-goto-char= reduced only to the current line. Few
candidates means very short decision chars path.
See [[https://github.com/abo-abo/avy/issues/49][#49]].
*** New overlay style =de-bruijn=
How to use it:
#+begin_src elisp
(setq avy-style 'de-bruijn)
#+end_src
What it does: when your leading chars are clumped up together, it's
impossible to overlay the decision path without shifting the buffer
text a bit. For example, with the word "buffer", you =avy-goto-char= "b", and:
- the path for the first "f" is "aj"
- the path for the second "f" is "ak"
It's not possible to overlay 4 characters over "ff" in "buffer". But
to with =de-bruijn= style, which results in the path being "aj" and
"jk". It's possible to overlay "ajk" just fine.
Pros and cons of =de-bruijn= over other styles:
- a pro is that it's possible to display the full decision path for
clumped up chars, which is truncated for other styles
- a con is that the decision path is of the same length (e.g. 2 or 3)
for all candidates, while with other styles it's possible to have a
few candidates with a shorter path.
See [[https://github.com/abo-abo/avy/issues/51][#51]] and [[https://github.com/abo-abo/avy/issues/5][#5]].
*** New defcustom =avy-ignored-modes=
This is meant for visual modes like =doc-view-mode= or =image-mode=
that can have a huge number of chars in a single window. Which results
in a huge number of candidates even in other windows.
Current setting:
#+begin_src elisp
(setq avy-ignored-modes '(image-mode doc-view-mode pdf-view-mode))
#+end_src
See [[https://github.com/abo-abo/avy/issues/57][#57]].
*** New tutorial on writing custom commands
See the [[https://github.com/abo-abo/avy/wiki/custom-commands][the custom-commands wiki page]] and [[https://github.com/abo-abo/avy/issues/55][#55]].
*** New face setup
New variable =avy-lead-faces= will determine the faces used to color
the current decision depth you're in. For example, if to select a
particular candidate you need to press "abc":
- "a" will be highlighted with a face that corresponds to depth 3
- "b" will be highlighted with a face that corresponds to depth 2
- "c" will be highlighted with a face that corresponds to depth 1
But if another candidate needs "ef":
- "e" will be highlighted with a face that corresponds to depth 2
- "f" will be highlighted with a face that corresponds to depth 1
See [[https://github.com/abo-abo/avy/issues/53][#53]].
*** New variable =avy-translate-char-function=
You can use this, for example, to interpret one character as another in =avy-keys=.
Example:
#+begin_src elisp
(setq avy-translate-char-function
(lambda (c) (if (= c 32) ?a c)))
#+end_src
This will translate ~SPC~ (32) into ~a~. So you can press either ~a~ or ~SPC~ to mean "a".
*** =avy-isearch= works for different styles
See [[https://github.com/abo-abo/avy/issues/61][#61]].
*** Switch the default style from =pre= to =at-full=
I've come to like =at-full= more than =pre= over time. The difference
is that =pre= hides no chars in your buffer, while =at-full= doesn't
shift text.
Use this to restore the previous default behavior:
#+begin_src elisp
(setq avy-style 'pre)
#+end_src
* 0.4.0
** Fixes
*** =avy-goto-char-timer= obeys =avy-styles-alist=
See [[https://github.com/abo-abo/avy/issues/67][#67]].
*** Add =de-bruijn= to the defcustom of =avy-styles-alist=
See [[https://github.com/abo-abo/avy/issues/73][#73]].
*** Respect the current input method for target chars
See [[https://github.com/abo-abo/avy/issues/76][#76]].
*** =avy-goto-subword-0= shouldn't offer invisible chars
See [[https://github.com/abo-abo/avy/issues/90][#90]].
*** Better =case-fold-search= handling
See [[https://github.com/abo-abo/avy/issues/87][#87]].
*** Add misc punctuation to subword commands
See [[https://github.com/abo-abo/avy/issues/93][#93]].
*** Add padding for wide-width chars (ex. Japanese and Chinese)
See [[https://github.com/abo-abo/avy/issues/96][#96]].
*** =avy-goto-line=
**** Push mark for numeric line
See [[https://github.com/abo-abo/avy/issues/74][#74]].
**** Allow numeric prefix arg
The old behavior remains for ARG 1 or 4. For all other ARG, simply go
to that line.
See [[https://github.com/abo-abo/avy/issues/86][#86]].
**** Work for =visual-line-mode=
See [[https://github.com/abo-abo/avy/issues/91][#91]].
**** Don't error on end of buffer
See [[https://github.com/abo-abo/avy/issues/91][#91]].
**** Obey =avy-background=
See [[https://github.com/abo-abo/avy/issues/94][#94]].
**** Fix for narrowed regions
See [[https://github.com/abo-abo/avy/issues/122][#122]], [[https://github.com/abo-abo/avy/issues/123][#123]].
**** Don't modify =avy-action=
See [[https://github.com/abo-abo/avy/issues/124][#124]].
*** =avy-goto-char-timer=
**** May read as many chars as you want
See [[https://github.com/abo-abo/avy/issues/97][#97]].
**** Highlight matches while reading chars
See [[https://github.com/abo-abo/avy/issues/98][#98]].
**** Highlight depending on =avy-all-windows=
See [[https://github.com/abo-abo/avy/issues/104][#104]].
**** Make faster for =org-mode=
See [[https://github.com/abo-abo/avy/issues/100][#100]].
**** Add case fold search
See [[https://github.com/abo-abo/avy/issues/128][#128]].
*** =avy-copy-region=
**** Keep the same selectors for the second pass
See [[https://github.com/abo-abo/avy/issues/120][#120]], [[https://github.com/abo-abo/avy/issues/121][#121]].
**** Copy/move to initial window
See [[https://github.com/abo-abo/avy/issues/131][#131]].
*** Search only in the visible region
See [[https://github.com/abo-abo/avy/issues/108][#108]], [[https://github.com/abo-abo/avy/issues/109][#109]].
*** Fix jumping to the last char of a folded Org outline
See [[https://github.com/abo-abo/avy/issues/108][#108]].
*** Fix for both =org-indent-mode= and =visual-line-mode=
See [[https://github.com/abo-abo/avy/issues/110][#110]].
*** Beep when there are no matches
See [[https://github.com/abo-abo/avy/issues/111][#111]].
*** Simplify overlay code
Most functions reuse =avy--overlay= now.
*** Fix de-bruijn "no catch for tag"
See [[https://github.com/abo-abo/avy/issues/116][#116]].
*** Fix overlays at =point-max=
See [[https://github.com/abo-abo/avy/issues/125][#125]].
*** Improve =case-fold-search= condition
See [[https://github.com/abo-abo/avy/issues/126][#126]].
*** Don't shorten selector string for =visual-line-mode= and =bolp=
See [[https://github.com/abo-abo/avy/issues/129][#129]].
*** Fix interaction with =goto-address-mode=
** New Features
*** Allow non-printing keys in =avy-keys=
Now you can set avy-keys also to the arrow keys and page up/down, e.g.
#+begin_src elisp
(setq avy-keys '(left right up down prior next))
#+end_src
and those will be displayed as ▲, ▼, ◀, ▶, △, ▽ in the overlays. The
display is controlled by the variable =avy-key-to-char-alist=.
See [[https://github.com/abo-abo/avy/issues/77][#77]].
*** Allow to switch action midway from goto to kill/mark/copy
For example, suppose you have:
#+begin_src elisp
(global-set-key (kbd "M-t") 'avy-goto-word-1)
#+end_src
- To jump to a certain word starting with "w" (e.g. first one on
screen): ~M-t w a~
- To copy the word instead of jumping to it: ~M-t w na~.
- To mark the word after jumping to it: ~M-t w ma~.
- To kill the word after jumping to it: ~M-t w xa~.
You can customize =avy-dispatch-alist= to modify these actions.
See [[https://github.com/abo-abo/avy/issues/78][#78]].
*** New command =avy-pop-mark=
Goes back to the last location of =push-mark=:
- has its own history,
- handles multiple frames.
See [[https://github.com/abo-abo/avy/issues/81][#81]] [[https://github.com/abo-abo/avy/issues/88][#88]] [[https://github.com/abo-abo/avy/issues/69][#69]].
*** New commands =avy-goto-line-above= and =avy-goto-line-below=
See [[https://github.com/abo-abo/avy/issues/106][#106]].
*** New defcustom =avy-line-insert-style=
Allows to modify the behavior of =avy-copy-line=, =avy-move-line=, and =avy-copy-region=.
See [[https://github.com/abo-abo/avy/issues/117][#117]].
*** New defcustom =avy-all-windows-alt=
Allows to customize the behavior of =universal-argument= modifying
=avy-all-windows=.
See [[https://github.com/abo-abo/avy/issues/118][#118]].
*** New defcustom =avy-subword-extra-word-chars=
Allows to customize the behavior of =avy-goto-subword-0= and
=avy-goto-subword-1= by adding extra chars that should match as word
constituents.
See [[https://github.com/abo-abo/avy/issues/116][#116]].
* 0.5.0
** Fixes
*** el:avy-action-copy
Save selected window and frame. See [[https://github.com/abo-abo/avy/issues/133][#133]].
Copy line for el:avy-goto-line. See [[https://github.com/abo-abo/avy/issues/191][#191]].
*** el:avy-read
Make ~C-g~ and ~ESC~ fail silently when reading char. See [[https://github.com/abo-abo/avy/issues/137][#137]].
Display error message on mouse clicks. See [[https://github.com/abo-abo/avy/issues/226][#226]].
Update el:avy-current-path before returning. See [[https://github.com/abo-abo/avy/issues/226][#226]].
Quit on ~ESC~. See [[https://github.com/abo-abo/avy/issues/249][#249]].
Fix for el:org-toggle-link-display. See [[https://github.com/abo-abo/avy/issues/261][#261]].
Fix for el:buffer-invisibility-spec being t. See [[https://github.com/abo-abo/avy/issues/264][#264]].
Allow "invisible" 'org-link. See [[https://github.com/abo-abo/avy/issues/269][#269]].
*** el:avy-goto-word-1
Works for "^A"-"^Z", see [[https://github.com/abo-abo/avy/issues/167][#167]].
*** el:avy-goto-subword-0
Add char at window start if empty, See [[https://github.com/abo-abo/avy/issues/145][#145]].
Add option to limit scope. See [[https://github.com/abo-abo/avy/issues/235][#235]].
*** el:avy-goto-subword-1
Check el:char-after. See [[https://github.com/abo-abo/avy/issues/163][#163]].
*** el:avy-isearch
Escape regex. See [[https://github.com/abo-abo/avy/issues/147][#147]].
*** el:avy-goto-char-2
Translate ~RET~ to ~C-j~. See [[https://github.com/abo-abo/avy/issues/153][#153]].
*** el:avy-action-goto
Add el:raise-frame.
*** el:avy-goto-char-timer
Allow ~C-h~ to delete. See [[https://github.com/abo-abo/avy/issues/193][#193]].
Obey el:avy-background for the initial search. See [[https://github.com/abo-abo/avy/issues/259][#259]].
*** el:avy-goto-line
Fix for empty buffer. See [[https://github.com/abo-abo/avy/issues/238][#238]].
Add ability to display candidates from bottom to top. See [[https://github.com/abo-abo/avy/issues/236][#236]].
*** el:avy--overlay-at-full
More consistent face order.
See [[https://github.com/abo-abo/avy/issues/270][#270]].
*** documentation
See [[https://github.com/abo-abo/avy/issues/223][#223]], [[https://github.com/abo-abo/avy/issues/226][#226]], [[https://github.com/abo-abo/avy/issues/218][#218]], [[https://github.com/abo-abo/avy/issues/245][#245]], [[https://github.com/abo-abo/avy/issues/262][#262]].
** New Features
*** API
New functions have been added as drop-in replacements of double-dash (private) avy
functions that were used in other packages and configs. Please replace the references to
the obsolete functions.
**** el:avy-jump
New API function to replace el:avy--generic-jump. See [[https://github.com/abo-abo/avy/issues/265][#265]], [[https://github.com/abo-abo/avy/issues/267][#267]].
**** el:avy-process
New API function to replace el:avy--process. See [[https://github.com/abo-abo/avy/issues/266][#266]].
*** New actions
**** el:avy-action-kill-stay
Kill a word with el:avy-goto-char without moving there.
Bound to ~X~.
**** el:avy-action-ispell
Auto-correct word at point. See [[https://github.com/abo-abo/avy/issues/142][#142]], [[https://github.com/abo-abo/avy/issues/160][#160]], [[https://github.com/abo-abo/avy/issues/161][#161]].
Bound to ~i~.
**** el:avy-action-yank
Yank sexp starting at selected point at the current point. See [[https://github.com/abo-abo/avy/issues/183][#183]].
Bound to ~y~.
**** el:avy-action-teleport
Kill sexp starting on selected point and yank into the current location. See [[https://github.com/abo-abo/avy/issues/207][#207]].
Bound to ~t~.
**** el:avy-action-zap-to-char
Kill from point up to selected point. See [[https://github.com/abo-abo/avy/issues/234][#234]].
Bound to ~z~.
*** New defcustoms
**** New el:avy-style setting: 'words
Use this setting:
#+begin_src elisp
(setq avy-style 'words)
#+end_src
And you'll see overlays like "by", "if", "is", "it", "my" for 2-letter sequences, and
"can", "car", "cog" for 3-letter sequences. You might find them easier to type than "hla",
"lls" and "jhl". But you will have to adjust your el:avy-dispatch-alist, e.g. to use only
upper case characters.
See [[https://github.com/abo-abo/avy/issues/210][#210]], [[https://github.com/abo-abo/avy/issues/219][#219]].
**** el:avy-orders-alist
Use it to customize the order of candidates with relation to point. The default is for
el:avy-goto-char to have the shortest overlay for candidates closest to point.
See [[https://github.com/abo-abo/avy/issues/242][#242]].
**** el:avy-indent-line-overlay
When non-nil el:avy-goto-line will display the line overlay next to the first
non-whitespace character of each line. See [[https://github.com/abo-abo/avy/issues/244][#244]].
**** el:avy-single-candidate-jump
When non-nil, and there is only one candidate, jump there. See [[https://github.com/abo-abo/avy/issues/250][#250]].
**** el:avy-del-last-char-by
Customize keys which delete the last read char. The defaults are ~C-h~ and ~DEL~. See [[https://github.com/abo-abo/avy/issues/251][#251]].
**** el:avy-goto-word-0-regexp
Customize el:avy-goto-word-0. See [[https://github.com/abo-abo/avy/issues/136][#136]], [[https://github.com/abo-abo/avy/issues/156][#156]].
**** el:avy-pre-action
Function to all before el:avy-action. See [[https://github.com/abo-abo/avy/issues/260][#260]].
**** el:avy-enter-times-out
When non-nil (the default), ~RET~ exists el:avy-goto-char-timer early.
When nil, it matches a newline.
See [[https://github.com/abo-abo/avy/issues/220][#220]], [[https://github.com/abo-abo/avy/issues/225][#225]].
*** New commands
**** el:avy-move-region
Select two lines and move the text between them above the current line.
See [[https://github.com/abo-abo/avy/issues/75][#75]], [[https://github.com/abo-abo/avy/issues/187][#187]], [[https://github.com/abo-abo/avy/issues/188][#188]].
**** el:avy-goto-end-of-line
Call el:avy-goto-line and move to the end of the line. See [[https://github.com/abo-abo/avy/issues/240][#240]].
**** el:avy-linum-mode
Minor mode that uses avy hints for el:linum-mode.
**** el:avy-resume
Holds last command avy command after user input. This is a quick way to bring back the
same markers after a jump. See [[https://github.com/abo-abo/avy/issues/157][#157]], [[https://github.com/abo-abo/avy/issues/165][#165]].
**** el:avy-next
Go to the next candidate after el:avy-read.
Example config:
#+begin_src elisp
(defhydra hydra-avy-cycle ()
("j" avy-next "next")
("k" avy-prev "prev")
("q" nil "quit"))
(global-set-key (kbd "C-M-'") 'hydra-avy-cycle/body)
#+end_src
After e.g. el:avy-goto-char or el:avy-goto-char-timer, use the above hydra to cycle
between the last candidates. See [[https://github.com/abo-abo/avy/issues/254][#254]].
**** *-above and *-below variants
Command versions restricted to matches before or after the point.
See [[https://github.com/abo-abo/avy/issues/148][#148]]:
- el:avy-goto-char-2-above
- el:avy-goto-char-2-below
See [[https://github.com/abo-abo/avy/issues/151][#151]]:
- el:avy-goto-word-1-above
- el:avy-goto-word-1-below
See [[https://github.com/abo-abo/avy/issues/156][#156]]:
- el:avy-goto-symbol-1-above
- el:avy-goto-symbol-1-below
See [[https://github.com/abo-abo/avy/issues/186][#186]]:
- el:avy-goto-word-0-below
- el:avy-goto-word-0-above
**** kill and save region functionality
New avy-enabled commands:
- el:avy-kill-whole-line
- el:avy-kill-region
- el:avy-kill-ring-save-whole-line
- el:avy-kill-ring-save-region
See [[https://github.com/abo-abo/avy/issues/158][#158]].
**** org-mode functionality
New avy-enabled commands:
- el:avy-org-refile-as-child
- el:avy-org-goto-heading-timer
See [[https://github.com/abo-abo/avy/issues/214][#214]], [[https://github.com/abo-abo/avy/issues/258][#258]].
*** el:avy-goto-char-timer
Show the number of matches so far in the prompt. See [[https://github.com/abo-abo/avy/issues/253][#253]].
*** el:avy-read
Ignore mistyping when no candidates are available. See [[https://github.com/abo-abo/avy/issues/256][#256]].
When the overlays are shown, press ~?~ to get dispatch help.