|
46083
|
1 ;;; kmacro.el --- enhanced keyboard macros
|
|
|
2
|
|
46085
|
3 ;; Copyright (C) 2002 Free Software Foundation, Inc.
|
|
46083
|
4
|
|
|
5 ;; Author: Kim F. Storm <storm@cua.dk>
|
|
46085
|
6 ;; Keywords: keyboard convenience
|
|
46083
|
7
|
|
|
8 ;; This file is part of GNU Emacs.
|
|
|
9
|
|
|
10 ;; GNU Emacs is free software; you can redistribute it and/or modify
|
|
|
11 ;; it under the terms of the GNU General Public License as published by
|
|
|
12 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
|
13 ;; any later version.
|
|
|
14
|
|
|
15 ;; GNU Emacs is distributed in the hope that it will be useful,
|
|
|
16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
18 ;; GNU General Public License for more details.
|
|
|
19
|
|
|
20 ;; You should have received a copy of the GNU General Public License
|
|
|
21 ;; along with GNU Emacs; see the file COPYING. If not, write to the
|
|
|
22 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
23 ;; Boston, MA 02111-1307, USA.
|
|
|
24
|
|
|
25 ;;; Commentary:
|
|
|
26
|
|
|
27 ;; The kmacro package is an alternative user interface to emacs'
|
|
|
28 ;; keyboard macro functionality. This functionality is normally bound
|
46099
d441fc235798
Passed it through checkdoc. Moved `provide' to the end, where it belongs.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
29 ;; to C-x (, C-x ), and C-x e, but these bindings are too hard to
|
|
46083
|
30 ;; type to be really useful for doing small repeated tasks.
|
|
|
31
|
|
|
32 ;; With kmacro, two function keys are dedicated to keyboard macros,
|
|
47094
|
33 ;; by default F3 and F4. Personally, I prefer F1 and F2, but those
|
|
46083
|
34 ;; keys already have default bindings.
|
|
|
35 ;;
|
|
47094
|
36 ;; To start defining a keyboard macro, use F3. To end the macro,
|
|
|
37 ;; use F4, and to call the macro also use F4. This makes it very
|
|
46083
|
38 ;; easy to repeat a macro immediately after defining it.
|
|
|
39 ;;
|
|
47094
|
40 ;; You can call the macro repeatedly by pressing F4 multiple times, or
|
|
46083
|
41 ;; you can give a numeric prefix argument specifying the number of
|
|
|
42 ;; times to repeat the macro. Macro execution automatically
|
|
|
43 ;; terminates when point reaches the end of the buffer or if an error
|
|
|
44 ;; is signalled by ringing the bell.
|
|
|
45
|
|
47094
|
46 ;; When you define a macro with F3/F4, it is automatically added to
|
|
|
47 ;; the head of the "keyboard macro ring", and F4 actually executes the
|
|
46961
|
48 ;; first element of the macro ring.
|
|
|
49 ;;
|
|
|
50 ;; Note: an empty macro is never added to the macro ring.
|
|
|
51 ;;
|
|
47094
|
52 ;; You can execute the second element on the macro ring with C-u F4 or
|
|
46961
|
53 ;; C-x C-k C-l, you can use C-x C-k C-p and C-x C-k C-n to cycle
|
|
|
54 ;; through the macro ring, and you can swap the first and second
|
|
|
55 ;; elements with C-x C-k C-t. To delete the first element in the
|
|
|
56 ;; macro ring, use C-x C-k C-d.
|
|
|
57 ;;
|
|
|
58 ;;
|
|
|
59 ;; You can also use C-x C-k C-s to start a macro, and C-x C-k C-k to
|
|
|
60 ;; end it; then use C-k to execute it immediately, or C-x C-k C-k to
|
|
|
61 ;; execute it later.
|
|
|
62 ;;
|
|
|
63 ;; In general, immediately after using C-x C-k followed by one of C-k,
|
|
|
64 ;; C-l, C-p, or C-n, you can further cycle the macro ring using C-p or
|
|
|
65 ;; C-n, execute the first or second macro using C-k or C-l, delete
|
|
|
66 ;; the head macro with C-d, or edit the current macro with C-e without
|
|
|
67 ;; repeating the C-x C-k prefix.
|
|
|
68
|
|
47094
|
69 ;; If you enter F3 while defining the macro, the numeric value of
|
|
46083
|
70 ;; `kmacro-counter' is inserted using the `kmacro-counter-format', and
|
|
|
71 ;; `kmacro-counter' is incremented by 1 (or the numeric prefix value
|
|
47094
|
72 ;; of F3).
|
|
46083
|
73 ;;
|
|
|
74 ;; The initial value of `kmacro-counter' is 0, or the numeric prefix
|
|
47094
|
75 ;; value given to F3 when starting the macro.
|
|
46083
|
76 ;;
|
|
47094
|
77 ;; Now, each time you call the macro using F4, the current
|
|
46083
|
78 ;; value of `kmacro-counter' is inserted and incremented, making it
|
|
|
79 ;; easy to insert incremental numbers in the buffer.
|
|
|
80 ;;
|
|
|
81 ;; Example:
|
|
|
82 ;;
|
|
47094
|
83 ;; The following sequence: M-5 F3 x M-2 F3 y F4 F4 F4 F4
|
|
46083
|
84 ;; inserts the following string: x5yx7yx9yx11y
|
|
|
85
|
46099
d441fc235798
Passed it through checkdoc. Moved `provide' to the end, where it belongs.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
86 ;; A macro can also be called using a mouse click, default S-mouse-3.
|
|
46083
|
87 ;; This calls the macro at the point where you click the mouse.
|
|
|
88
|
|
46961
|
89 ;; You can edit the last macro using C-x C-k C-e.
|
|
46083
|
90
|
|
47094
|
91 ;; You can append to the last macro using C-u F3.
|
|
46083
|
92
|
|
46961
|
93 ;; You can set the macro counter using C-x C-k C-c, add to it using C-x C-k C-a,
|
|
|
94 ;; and you can set the macro counter format with C-x C-k C-f.
|
|
46083
|
95
|
|
|
96 ;; The following key bindings are performed:
|
|
49597
|
97 ;;
|
|
46083
|
98 ;; Normal While defining macro
|
|
|
99 ;; --------------------------- ------------------------------
|
|
47094
|
100 ;; f3 Define macro Insert current counter value
|
|
46083
|
101 ;; Prefix arg specifies initial and increase counter by prefix
|
|
|
102 ;; counter value (default 0) (default increment: 1)
|
|
|
103 ;;
|
|
47094
|
104 ;; C-u f3 APPENDs to last macro
|
|
49597
|
105 ;;
|
|
|
106 ;; f4 Call last macro End macro
|
|
46083
|
107 ;; Prefix arg specifies number
|
|
|
108 ;; of times to execute macro.
|
|
|
109 ;;
|
|
47094
|
110 ;; C-u f4 Swap last and head of macro ring.
|
|
49597
|
111 ;;
|
|
46083
|
112 ;; S-mouse-3 Set point at click and End macro and execute macro at
|
|
|
113 ;; execute last macro. click.
|
|
|
114
|
|
|
115 ;;; Code:
|
|
|
116
|
46099
d441fc235798
Passed it through checkdoc. Moved `provide' to the end, where it belongs.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
117 ;; Customization:
|
|
46083
|
118
|
|
|
119 (defgroup kmacro nil
|
|
|
120 "Simplified keyboard macro user interface."
|
|
|
121 :group 'keyboard
|
|
|
122 :group 'convenience
|
|
|
123 :link '(emacs-commentary-link :tag "Commentary" "kmacro.el")
|
|
|
124 :link '(emacs-library-link :tag "Lisp File" "kmacro.el"))
|
|
|
125
|
|
46961
|
126 (defcustom kmacro-call-mouse-event 'S-mouse-3
|
|
|
127 "The mouse event used by kmacro to call a macro.
|
|
|
128 Set to nil if no mouse binding is desired."
|
|
|
129 :type 'symbol
|
|
|
130 :group 'kmacro)
|
|
|
131
|
|
|
132 (defcustom kmacro-ring-max 8
|
|
|
133 "Maximum number of keyboard macros to save in macro ring."
|
|
|
134 :type 'integer
|
|
|
135 :group 'kmacro)
|
|
|
136
|
|
|
137
|
|
|
138 (defcustom kmacro-execute-before-append t
|
|
|
139 "Controls whether appending to a macro starts by executing the macro.
|
|
|
140 If non-nil, using a single \\[universal-argument] prefix executes the macro
|
|
|
141 before appending, while more than one \\[universal-argument] prefix does not
|
|
|
142 execute the macro.
|
|
|
143 Otherwise, a single \\[universal-argument] prefix does not execute the
|
|
|
144 macro, while more than one \\[universal-argument] prefix causes the
|
|
|
145 macro to be executed before appending to it."
|
|
|
146 :type 'boolean
|
|
|
147 :group 'kmacro)
|
|
|
148
|
|
|
149
|
|
|
150 (defcustom kmacro-repeat-no-prefix t
|
|
|
151 "Allow repeating certain macro commands without entering the C-x C-k prefix."
|
|
46083
|
152 :type 'boolean
|
|
|
153 :group 'kmacro)
|
|
|
154
|
|
47094
|
155 (defcustom kmacro-call-repeat-key t
|
|
|
156 "Allow repeating macro call using last key or a specific key."
|
|
|
157 :type '(choice (const :tag "Disabled" nil)
|
|
|
158 (const :tag "Last key" t)
|
|
|
159 (character :tag "Character" :value ?e)
|
|
|
160 (symbol :tag "Key symbol" :value RET))
|
|
|
161 :group 'kmacro)
|
|
|
162
|
|
|
163 (defcustom kmacro-call-repeat-with-arg nil
|
|
|
164 "Repeat macro call with original arg when non-nil; repeat once if nil."
|
|
|
165 :type 'boolean
|
|
|
166 :group 'kmacro)
|
|
|
167
|
|
47310
|
168 (defcustom kmacro-step-edit-mini-window-height 0.75
|
|
|
169 "Override `max-mini-window-height' when step edit keyboard macro."
|
|
|
170 :type 'number
|
|
|
171 :group 'kmacro)
|
|
46961
|
172
|
|
|
173 ;; Keymap
|
|
46083
|
174
|
|
46961
|
175 (defvar kmacro-keymap
|
|
|
176 (let ((map (make-sparse-keymap)))
|
|
47448
|
177 (define-key map "s" 'kmacro-start-macro)
|
|
47094
|
178 (define-key map "\C-k" 'kmacro-end-or-call-macro-repeat)
|
|
|
179 (define-key map "\C-e" 'kmacro-edit-macro-repeat)
|
|
|
180 (define-key map "\r" 'kmacro-edit-macro)
|
|
47310
|
181 (define-key map " " 'kmacro-step-edit-macro)
|
|
46961
|
182 (define-key map "l" 'kmacro-edit-lossage)
|
|
|
183 (define-key map "\C-i" 'kmacro-insert-counter)
|
|
|
184 (define-key map "\C-a" 'kmacro-add-counter)
|
|
47094
|
185 (define-key map "\C-v" 'kmacro-view-macro-repeat)
|
|
|
186 (define-key map "\C-l" 'kmacro-call-ring-2nd-repeat)
|
|
46961
|
187 (define-key map "\C-r" 'kmacro-view-ring-2nd)
|
|
|
188 (define-key map "\C-n" 'kmacro-cycle-ring-next)
|
|
|
189 (define-key map "\C-p" 'kmacro-cycle-ring-previous)
|
|
|
190 (define-key map "\C-f" 'kmacro-set-format)
|
|
|
191 (define-key map "\C-c" 'kmacro-set-counter)
|
|
|
192 (define-key map "\C-t" 'kmacro-swap-ring)
|
|
47448
|
193 (define-key map "b" 'kmacro-bind-to-key)
|
|
46961
|
194 (define-key map "\C-d" 'kmacro-delete-ring-head)
|
|
|
195 ;; Compatibility bindings
|
|
|
196 (define-key map "q" 'kbd-macro-query)
|
|
|
197 (define-key map "n" 'name-last-kbd-macro)
|
|
|
198 (define-key map "e" 'edit-kbd-macro)
|
|
46972
|
199 (define-key map "r" 'apply-macro-to-region-lines)
|
|
46961
|
200 map)
|
|
|
201 "Keymap for keyboard macro commands.")
|
|
|
202 (defalias 'kmacro-keymap kmacro-keymap)
|
|
46083
|
203
|
|
46961
|
204 ;;; Provide some binding for startup:
|
|
|
205 ;;;###autoload (global-set-key "\C-x(" 'kmacro-start-macro)
|
|
|
206 ;;;###autoload (global-set-key "\C-x)" 'kmacro-end-macro)
|
|
47310
|
207 ;;;###autoload (global-set-key "\C-xe" 'kmacro-end-and-call-macro)
|
|
47094
|
208 ;;;###autoload (global-set-key [f3] 'kmacro-start-macro-or-insert-counter)
|
|
|
209 ;;;###autoload (global-set-key [f4] 'kmacro-end-or-call-macro)
|
|
46961
|
210 ;;;###autoload (global-set-key "\C-x\C-k" 'kmacro-keymap)
|
|
|
211 ;;;###autoload (autoload 'kmacro-keymap "kmacro" "Keymap for keyboard macro commands." t 'keymap)
|
|
46083
|
212
|
|
46961
|
213 (if kmacro-call-mouse-event
|
|
|
214 (global-set-key (vector kmacro-call-mouse-event) 'kmacro-end-call-mouse))
|
|
|
215
|
|
|
216
|
|
|
217
|
|
|
218 ;;; Keyboard macro counter
|
|
46083
|
219
|
|
|
220 (defvar kmacro-counter 0
|
46099
d441fc235798
Passed it through checkdoc. Moved `provide' to the end, where it belongs.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
221 "*Current keyboard macro counter.")
|
|
46083
|
222
|
|
|
223 (defvar kmacro-counter-format "%d"
|
46099
d441fc235798
Passed it through checkdoc. Moved `provide' to the end, where it belongs.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
224 "*Current keyboard macro counter format.")
|
|
46083
|
225
|
|
|
226 (defvar kmacro-counter-format-start kmacro-counter-format
|
|
|
227 "Macro format at start of macro execution.")
|
|
|
228
|
|
46961
|
229 (defvar kmacro-counter-value-start kmacro-counter
|
|
|
230 "Macro counter at start of macro execution.")
|
|
|
231
|
46099
d441fc235798
Passed it through checkdoc. Moved `provide' to the end, where it belongs.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
232 (defvar kmacro-last-counter 0 "Last counter inserted by key macro.")
|
|
46961
|
233
|
|
|
234
|
|
|
235 (defun kmacro-insert-counter (arg)
|
|
|
236 "Insert macro counter and increment with ARG or 1 if missing.
|
|
|
237 With \\[universal-argument], insert previous kmacro-counter (but do not modify counter)."
|
|
|
238 (interactive "P")
|
|
|
239 (if (and arg (listp arg))
|
|
|
240 (insert (format kmacro-counter-format kmacro-last-counter))
|
|
|
241 (insert (format kmacro-counter-format kmacro-counter))
|
|
|
242 (kmacro-add-counter (prefix-numeric-value arg))))
|
|
|
243
|
|
|
244
|
|
|
245 (defun kmacro-set-format (format)
|
|
|
246 "Set macro counter FORMAT."
|
|
|
247 (interactive "sMacro Counter Format (printf format): ")
|
|
|
248 (setq kmacro-counter-format
|
|
|
249 (if (equal format "") "%d" format))
|
|
|
250 ;; redefine initial macro counter if we are not executing a macro.
|
|
|
251 (if (not (or defining-kbd-macro executing-kbd-macro))
|
|
|
252 (setq kmacro-counter-format-start kmacro-counter-format)))
|
|
|
253
|
|
|
254
|
|
|
255 (defun kmacro-display-counter (&optional value)
|
|
|
256 "Display current counter value."
|
|
|
257 (unless value (setq value kmacro-counter))
|
|
|
258 (message "New macro counter value: %s (%d)" (format kmacro-counter-format value) value))
|
|
|
259
|
|
|
260
|
|
|
261 (defun kmacro-set-counter (arg)
|
|
|
262 "Set kmacro-counter to ARG or prompt if missing.
|
|
|
263 With \\[universal-argument], reset counter to its value prior to this iteration of the macro."
|
|
|
264 (interactive "NMacro counter value: ")
|
|
|
265 (setq kmacro-last-counter kmacro-counter
|
|
|
266 kmacro-counter (if (and current-prefix-arg (listp current-prefix-arg))
|
|
|
267 kmacro-counter-value-start
|
|
|
268 arg))
|
|
|
269 (unless executing-kbd-macro
|
|
|
270 (kmacro-display-counter)))
|
|
|
271
|
|
|
272
|
|
|
273 (defun kmacro-add-counter (arg)
|
|
|
274 "Add numeric prefix arg (prompt if missing) to macro counter.
|
|
|
275 With \\[universal-argument], restore previous counter value."
|
|
|
276 (interactive "NAdd to macro counter: ")
|
|
|
277 (let ((last kmacro-last-counter))
|
|
|
278 (setq kmacro-last-counter kmacro-counter
|
|
|
279 kmacro-counter (if (and current-prefix-arg (listp current-prefix-arg))
|
|
|
280 last
|
|
|
281 kmacro-counter (+ kmacro-counter arg))))
|
|
|
282 (unless executing-kbd-macro
|
|
|
283 (kmacro-display-counter)))
|
|
|
284
|
|
|
285
|
|
|
286 (defun kmacro-loop-setup-function ()
|
|
|
287 "Function called prior to each iteration of macro."
|
|
|
288 ;; Restore macro counter format to initial format, so it is ok to change
|
|
|
289 ;; counter format in the macro without restoring it.
|
|
|
290 (setq kmacro-counter-format kmacro-counter-format-start)
|
|
|
291 ;; Save initial counter value so we can restore it with C-u kmacro-set-counter.
|
|
|
292 (setq kmacro-counter-value-start kmacro-counter)
|
|
|
293 ;; Return non-nil to continue execution.
|
|
|
294 t)
|
|
|
295
|
|
46083
|
296
|
|
46961
|
297 ;;; Keyboard macro ring
|
|
|
298
|
|
|
299 (defvar kmacro-ring nil
|
|
|
300 "The keyboard macro ring.
|
|
|
301 Each element is a list (MACRO COUNTER FORMAT). Actually, the head of
|
|
|
302 the macro ring (when defining or executing) is not stored in the ring;
|
|
|
303 instead it is available in the variables `last-kbd-macro', `kmacro-counter',
|
|
|
304 and `kmacro-counter-format'.")
|
|
|
305
|
|
|
306
|
|
|
307 (defun kmacro-ring-head ()
|
|
|
308 "Return pseudo head element in macro ring."
|
|
|
309 (and last-kbd-macro
|
|
|
310 (list last-kbd-macro kmacro-counter kmacro-counter-format-start)))
|
|
|
311
|
|
|
312
|
|
|
313 (defun kmacro-push-ring (&optional elt)
|
|
|
314 "Push ELT or current macro onto `kmacro-ring'."
|
|
|
315 (when (setq elt (or elt (kmacro-ring-head)))
|
|
|
316 (let ((len (length kmacro-ring)))
|
|
|
317 (setq kmacro-ring (cons elt kmacro-ring))
|
|
|
318 (if (>= len kmacro-ring-max)
|
|
|
319 (setcdr (nthcdr len kmacro-ring) nil)))))
|
|
|
320
|
|
|
321
|
|
|
322 (defun kmacro-split-ring-element (elt)
|
|
|
323 (setq last-kbd-macro (car elt)
|
|
|
324 kmacro-counter (nth 1 elt)
|
|
|
325 kmacro-counter-format-start (nth 2 elt)))
|
|
|
326
|
|
46083
|
327
|
|
46961
|
328 (defun kmacro-pop-ring1 (&optional raw)
|
|
|
329 "Pop head element off macro ring (no check).
|
|
|
330 Non-nil arg RAW means just return raw first element."
|
|
|
331 (prog1 (car kmacro-ring)
|
|
|
332 (unless raw
|
|
|
333 (kmacro-split-ring-element (car kmacro-ring)))
|
|
|
334 (setq kmacro-ring (cdr kmacro-ring))))
|
|
|
335
|
|
|
336
|
|
|
337 (defun kmacro-pop-ring (&optional raw)
|
|
|
338 "Pop head element off macro ring.
|
|
|
339 Non-nil arg RAW means just return raw first element."
|
|
|
340 (unless (kmacro-ring-empty-p)
|
|
|
341 (kmacro-pop-ring1 raw)))
|
|
49597
|
342
|
|
46961
|
343
|
|
|
344 (defun kmacro-ring-length ()
|
|
|
345 "Return length of macro ring, including pseudo head."
|
|
|
346 (+ (if last-kbd-macro 1 0) (length kmacro-ring)))
|
|
|
347
|
|
|
348
|
|
|
349 (defun kmacro-ring-empty-p (&optional none)
|
|
|
350 "Tell user and return t if `last-kbd-macro' is nil or `kmacro-ring' is empty.
|
|
|
351 Check only `last-kbd-macro' if optional arg NONE is non-nil."
|
|
|
352 (while (and (null last-kbd-macro) kmacro-ring)
|
|
|
353 (kmacro-pop-ring1))
|
|
|
354 (cond
|
|
|
355 ((null last-kbd-macro)
|
|
|
356 (message "No keyboard macro defined.")
|
|
|
357 t)
|
|
|
358 ((and (null none) (null kmacro-ring))
|
|
|
359 (message "Only one keyboard macro defined.")
|
|
|
360 t)
|
|
|
361 (t nil)))
|
|
|
362
|
|
|
363
|
|
|
364 (defun kmacro-display (macro &optional trunc descr empty )
|
46099
d441fc235798
Passed it through checkdoc. Moved `provide' to the end, where it belongs.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
365 "Display a keyboard MACRO."
|
|
46961
|
366 (if macro
|
|
|
367 (let* ((x 60)
|
|
|
368 (m (format-kbd-macro macro))
|
|
|
369 (l (length m))
|
|
|
370 (z (and nil trunc (> l x))))
|
|
49597
|
371 (message (format "%s: %s%s" (or descr "Macro")
|
|
46961
|
372 (if z (substring m 0 (1- x)) m) (if z "..." ""))))
|
|
|
373 (message (or empty "No keyboard macros defined"))))
|
|
|
374
|
|
|
375
|
|
47094
|
376 (defun kmacro-repeat-on-last-key (keys)
|
|
|
377 "Process kmacro commands keys immidiately after cycling the ring."
|
|
|
378 (setq keys (vconcat keys))
|
|
|
379 (let ((n (1- (length keys)))
|
|
|
380 cmd done repeat)
|
|
|
381 (while (and last-kbd-macro
|
|
|
382 (not done)
|
|
|
383 (aset keys n (read-event))
|
|
|
384 (setq cmd (key-binding keys t))
|
|
|
385 (setq repeat (get cmd 'kmacro-repeat)))
|
|
|
386 (clear-this-command-keys t)
|
|
|
387 (cond
|
|
|
388 ((eq repeat 'ring)
|
|
|
389 (if kmacro-ring
|
|
|
390 (let ((kmacro-repeat-no-prefix nil))
|
|
|
391 (funcall cmd nil))
|
|
|
392 (kmacro-display last-kbd-macro t)))
|
|
|
393 ((eq repeat 'head)
|
|
|
394 (let ((kmacro-repeat-no-prefix nil))
|
|
|
395 (funcall cmd nil)))
|
|
|
396 ((eq repeat 'stop)
|
|
|
397 (funcall cmd nil)
|
|
|
398 (setq done t)))
|
|
|
399 (setq last-input-event nil)))
|
|
|
400 (when last-input-event
|
|
|
401 (clear-this-command-keys t)
|
|
|
402 (setq unread-command-events (list last-input-event))))
|
|
|
403
|
|
|
404
|
|
|
405 (defun kmacro-get-repeat-prefix ()
|
|
|
406 (let (keys)
|
|
|
407 (and kmacro-repeat-no-prefix
|
|
|
408 (setq keys (this-single-command-keys))
|
|
|
409 (> (length keys) 1)
|
|
|
410 keys)))
|
|
|
411
|
|
|
412
|
|
46961
|
413 (defun kmacro-call-ring-2nd (arg)
|
|
|
414 "Execute second keyboard macro at in macro ring."
|
|
|
415 (interactive "P")
|
|
|
416 (unless (kmacro-ring-empty-p)
|
|
|
417 ;; should use counter format specific to the macro on the ring!
|
|
|
418 (let ((kmacro-counter (nth 1 (car kmacro-ring)))
|
|
|
419 (kmacro-counter-format-start (nth 2 (car kmacro-ring))))
|
|
|
420 (execute-kbd-macro (car (car kmacro-ring)) arg #'kmacro-loop-setup-function)
|
|
|
421 (setcar (cdr (car kmacro-ring)) kmacro-counter))))
|
|
|
422
|
|
|
423
|
|
47094
|
424 (defun kmacro-call-ring-2nd-repeat (arg)
|
|
|
425 "Like `kmacro-call-ring-2nd', but allow repeat without repeating prefix."
|
|
46961
|
426 (interactive "P")
|
|
47094
|
427 (let ((keys (kmacro-get-repeat-prefix)))
|
|
|
428 (kmacro-call-ring-2nd arg)
|
|
|
429 (if (and kmacro-ring keys)
|
|
|
430 (kmacro-repeat-on-last-key keys))))
|
|
46961
|
431
|
|
47094
|
432 (put 'kmacro-call-ring-2nd-repeat 'kmacro-repeat 'head)
|
|
46083
|
433
|
|
|
434
|
|
46961
|
435 (defun kmacro-view-ring-2nd ()
|
|
|
436 "Display the current head of the keyboard macro ring."
|
|
|
437 (interactive)
|
|
|
438 (unless (kmacro-ring-empty-p)
|
|
|
439 (kmacro-display (car (car kmacro-ring)) "2nd macro")))
|
|
|
440
|
|
|
441
|
|
49597
|
442
|
|
46961
|
443 (defun kmacro-cycle-ring-next (&optional arg)
|
|
|
444 "Move to next keyboard macro in keyboard macro ring.
|
|
|
445 Displays the selected macro in the echo area."
|
|
|
446 (interactive)
|
|
|
447 (unless (kmacro-ring-empty-p)
|
|
|
448 (kmacro-push-ring)
|
|
47094
|
449 (let* ((keys (kmacro-get-repeat-prefix))
|
|
|
450 (len (length kmacro-ring))
|
|
46961
|
451 (tail (nthcdr (- len 2) kmacro-ring))
|
|
|
452 (elt (car (cdr tail))))
|
|
|
453 (setcdr tail nil)
|
|
47094
|
454 (kmacro-split-ring-element elt)
|
|
|
455 (kmacro-display last-kbd-macro t)
|
|
|
456 (if keys
|
|
|
457 (kmacro-repeat-on-last-key keys)))))
|
|
46961
|
458
|
|
|
459 (put 'kmacro-cycle-ring-next 'kmacro-repeat 'ring)
|
|
|
460
|
|
|
461
|
|
|
462 (defun kmacro-cycle-ring-previous (&optional arg)
|
|
|
463 "Move to previous keyboard macro in keyboard macro ring.
|
|
|
464 Displays the selected macro in the echo area."
|
|
|
465 (interactive)
|
|
|
466 (unless (kmacro-ring-empty-p)
|
|
47094
|
467 (let ((keys (kmacro-get-repeat-prefix))
|
|
|
468 (cur (kmacro-ring-head)))
|
|
46961
|
469 (kmacro-pop-ring1)
|
|
|
470 (if kmacro-ring
|
|
|
471 (nconc kmacro-ring (list cur))
|
|
47094
|
472 (setq kmacro-ring (list cur)))
|
|
|
473 (kmacro-display last-kbd-macro t)
|
|
|
474 (if keys
|
|
|
475 (kmacro-repeat-on-last-key keys)))))
|
|
46961
|
476
|
|
|
477 (put 'kmacro-cycle-ring-previous 'kmacro-repeat 'ring)
|
|
|
478
|
|
|
479
|
|
|
480 (defun kmacro-swap-ring ()
|
|
|
481 "Swap first two elements on keyboard macro ring."
|
|
|
482 (interactive)
|
|
|
483 (unless (kmacro-ring-empty-p)
|
|
|
484 (let ((cur (kmacro-ring-head)))
|
|
|
485 (kmacro-pop-ring1)
|
|
|
486 (kmacro-push-ring cur))
|
|
|
487 (kmacro-display last-kbd-macro t)))
|
|
|
488
|
|
|
489
|
|
|
490 (defun kmacro-delete-ring-head (&optional arg)
|
|
|
491 "Delete current macro from keyboard macro ring."
|
|
|
492 (interactive)
|
|
|
493 (unless (kmacro-ring-empty-p t)
|
|
|
494 (if (null kmacro-ring)
|
|
|
495 (setq last-kbd-macro nil)
|
|
|
496 (kmacro-pop-ring))
|
|
|
497 (kmacro-display last-kbd-macro t nil "Keyboard macro ring is now empty.")))
|
|
|
498
|
|
|
499 (put 'kmacro-delete-ring-head 'kmacro-repeat 'head)
|
|
|
500
|
|
|
501 ;;; Traditional bindings:
|
|
|
502
|
|
49597
|
503
|
|
46961
|
504 ;;;###autoload
|
|
46083
|
505 (defun kmacro-start-macro (arg)
|
|
46961
|
506 "Record subsequent keyboard input, defining a keyboard macro.
|
|
|
507 The commands are recorded even as they are executed.
|
|
47051
|
508 Use \\[kmacro-end-macro] to finish recording and make the macro available.
|
|
47457
|
509 Use \\[kmacro-end-and-call-macro] to execute the macro.
|
|
46961
|
510 Use \\[name-last-kbd-macro] to give it a permanent name.
|
|
|
511 Non-nil arg (prefix arg) means append to last macro defined;
|
|
|
512
|
|
|
513 With \\[universal-argument] prefix, append to last keyboard macro
|
|
|
514 defined. Depending on `kmacro-execute-before-append', this may begin
|
|
|
515 by re-executing the last macro as if you typed it again.
|
|
|
516
|
|
|
517 Otherwise, it sets `kmacro-counter' to ARG or 0 if missing before
|
|
|
518 defining the macro.
|
|
|
519
|
|
|
520 Use \\[kmacro-insert-counter] to insert (and increment) the macro counter.
|
|
|
521 The counter value can be set or modified via \\[kmacro-set-counter] and \\[kmacro-add-counter].
|
|
|
522 The format of the counter can be modified via \\[kmacro-set-format]."
|
|
|
523 (interactive "P")
|
|
|
524 (if (or defining-kbd-macro executing-kbd-macro)
|
|
|
525 (message "Already defining keyboard macro.")
|
|
|
526 (let ((append (and arg (listp arg))))
|
|
|
527 (unless append
|
|
|
528 (if last-kbd-macro
|
|
|
529 (let ((len (length kmacro-ring)))
|
|
49597
|
530 (setq kmacro-ring
|
|
46961
|
531 (cons
|
|
|
532 (list last-kbd-macro kmacro-counter kmacro-counter-format-start)
|
|
|
533 kmacro-ring))
|
|
|
534 (if (>= len kmacro-ring-max)
|
|
|
535 (setcdr (nthcdr len kmacro-ring) nil))))
|
|
|
536 (setq kmacro-counter (if arg (prefix-numeric-value arg) 0)
|
|
|
537 kmacro-counter-value-start kmacro-counter
|
|
|
538 kmacro-last-counter kmacro-counter
|
|
|
539 kmacro-counter-format-start kmacro-counter-format))
|
|
|
540
|
|
49597
|
541 (start-kbd-macro append
|
|
46961
|
542 (and append
|
|
|
543 (if kmacro-execute-before-append
|
|
|
544 (> (car arg) 4)
|
|
|
545 (= (car arg) 4)))))))
|
|
|
546
|
|
|
547
|
|
|
548 ;;;###autoload
|
|
|
549 (defun kmacro-end-macro (arg)
|
|
|
550 "Finish defining a keyboard macro.
|
|
|
551 The definition was started by \\[kmacro-start-macro].
|
|
|
552 The macro is now available for use via \\[kmacro-call-macro],
|
|
|
553 or it can be given a name with \\[name-last-kbd-macro] and then invoked
|
|
|
554 under that name.
|
|
|
555
|
|
|
556 With numeric arg, repeat macro now that many times,
|
|
|
557 counting the definition just completed as the first repetition.
|
|
|
558 An argument of zero means repeat until error."
|
|
|
559 (interactive "P")
|
|
|
560 (end-kbd-macro arg #'kmacro-loop-setup-function)
|
|
|
561 (when (and last-kbd-macro (= (length last-kbd-macro) 0))
|
|
|
562 (message "Ignore empty macro")
|
|
|
563 (kmacro-pop-ring)))
|
|
|
564
|
|
|
565
|
|
|
566 ;;;###autoload
|
|
47094
|
567 (defun kmacro-call-macro (arg &optional no-repeat end-macro)
|
|
46961
|
568 "Call the last keyboard macro that you defined with \\[kmacro-start-macro].
|
|
|
569 A prefix argument serves as a repeat count. Zero means repeat until error.
|
|
|
570
|
|
47094
|
571 When you call the macro, you can call the macro again by repeating
|
|
|
572 just the last key in the key sequence that you used to call this
|
|
|
573 command. See `kmacro-call-repeat-key' and `kmacro-call-repeat-with-arg'
|
|
|
574 for details on how to adjust or disable this behaviour.
|
|
|
575
|
|
|
576 To make a macro permanent so you can call it even after defining
|
|
|
577 others, use M-x name-last-kbd-macro."
|
|
46961
|
578 (interactive "p")
|
|
47094
|
579 (let ((repeat-key (and (null no-repeat)
|
|
|
580 (> (length (this-single-command-keys)) 1)
|
|
|
581 last-input-event))
|
|
|
582 repeat-key-str)
|
|
|
583 (if end-macro
|
|
|
584 (kmacro-end-macro arg)
|
|
|
585 (call-last-kbd-macro arg #'kmacro-loop-setup-function))
|
|
47361
|
586 (when (consp arg)
|
|
|
587 (setq arg (car arg)))
|
|
47094
|
588 (when (and (or (null arg) (> arg 0))
|
|
|
589 (setq repeat-key
|
|
47361
|
590 (if (eq kmacro-call-repeat-key t)
|
|
|
591 repeat-key
|
|
|
592 kmacro-call-repeat-key)))
|
|
47310
|
593 (setq repeat-key-str (format-kbd-macro (vector repeat-key) nil))
|
|
47094
|
594 (while repeat-key
|
|
49597
|
595 (message "(Type %s to repeat macro%s)"
|
|
47388
|
596 repeat-key-str
|
|
47094
|
597 (if (and kmacro-call-repeat-with-arg
|
|
|
598 arg (> arg 1))
|
|
47388
|
599 (format " %d times" arg) ""))
|
|
47094
|
600 (if (equal repeat-key (read-event))
|
|
|
601 (progn
|
|
|
602 (clear-this-command-keys t)
|
|
47361
|
603 (call-last-kbd-macro (and kmacro-call-repeat-with-arg arg)
|
|
|
604 #'kmacro-loop-setup-function)
|
|
47094
|
605 (setq last-input-event nil))
|
|
|
606 (setq repeat-key nil)))
|
|
|
607 (when last-input-event
|
|
|
608 (clear-this-command-keys t)
|
|
|
609 (setq unread-command-events (list last-input-event))))))
|
|
46961
|
610
|
|
|
611
|
|
|
612 ;;; Combined function key bindings:
|
|
|
613
|
|
|
614 ;;;###autoload
|
|
|
615 (defun kmacro-start-macro-or-insert-counter (arg)
|
|
47094
|
616 "Record subsequent keyboard input, defining a keyboard macro.
|
|
|
617 The commands are recorded even as they are executed.
|
|
|
618
|
|
|
619 Sets the `kmacro-counter' to ARG (or 0 if no prefix arg) before defining the
|
|
|
620 macro.
|
|
46083
|
621
|
|
47094
|
622 With \\[universal-argument], appends to current keyboard macro (keeping
|
|
|
623 the current value of `kmacro-counter').
|
|
|
624
|
|
|
625 When defining/executing macro, inserts macro counter and increments
|
|
|
626 the counter with ARG or 1 if missing. With \\[universal-argument],
|
|
|
627 inserts previous kmacro-counter (but do not modify counter).
|
|
46083
|
628
|
|
46961
|
629 The macro counter can be modified via \\[kmacro-set-counter] and \\[kmacro-add-counter].
|
|
46083
|
630 The format of the counter can be modified via \\[kmacro-set-format]."
|
|
46961
|
631 (interactive "P")
|
|
46083
|
632 (if (or defining-kbd-macro executing-kbd-macro)
|
|
46961
|
633 (kmacro-insert-counter arg)
|
|
|
634 (kmacro-start-macro arg)))
|
|
46083
|
635
|
|
46961
|
636
|
|
|
637 ;;;###autoload
|
|
47094
|
638 (defun kmacro-end-or-call-macro (arg &optional no-repeat)
|
|
46083
|
639 "End kbd macro if currently being defined; else call last kbd macro.
|
46099
d441fc235798
Passed it through checkdoc. Moved `provide' to the end, where it belongs.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
640 With numeric prefix ARG, repeat macro that many times.
|
|
46961
|
641 With \\[universal-argument], call second macro in macro ring."
|
|
|
642 (interactive "P")
|
|
49597
|
643 (cond
|
|
46083
|
644 (defining-kbd-macro
|
|
47094
|
645 (if kmacro-call-repeat-key
|
|
|
646 (kmacro-call-macro arg no-repeat t)
|
|
|
647 (kmacro-end-macro arg)))
|
|
46961
|
648 ((and arg (listp arg))
|
|
|
649 (kmacro-call-ring-2nd 1))
|
|
46083
|
650 (t
|
|
47094
|
651 (kmacro-call-macro arg no-repeat))))
|
|
46961
|
652
|
|
46083
|
653
|
|
47094
|
654 (defun kmacro-end-or-call-macro-repeat (arg)
|
|
|
655 "As `kmacro-end-or-call-macro' but allows repeat without repeating prefix."
|
|
46961
|
656 (interactive "P")
|
|
47094
|
657 (let ((keys (kmacro-get-repeat-prefix)))
|
|
|
658 (kmacro-end-or-call-macro arg t)
|
|
|
659 (if keys
|
|
|
660 (kmacro-repeat-on-last-key keys))))
|
|
46083
|
661
|
|
47094
|
662 (put 'kmacro-end-or-call-macro-repeat 'kmacro-repeat 'head)
|
|
46961
|
663
|
|
|
664
|
|
|
665 ;;;###autoload
|
|
47310
|
666 (defun kmacro-end-and-call-macro (arg &optional no-repeat)
|
|
|
667 "Call last keyboard macro, ending it first if currently being defined.
|
|
|
668 With numeric prefix ARG, repeat macro that many times."
|
|
|
669 (interactive "P")
|
|
|
670 (if defining-kbd-macro
|
|
|
671 (kmacro-end-macro nil))
|
|
|
672 (kmacro-call-macro arg no-repeat))
|
|
|
673
|
|
|
674
|
|
|
675 ;;;###autoload
|
|
46083
|
676 (defun kmacro-end-call-mouse (event)
|
|
|
677 "Move point to the position clicked with the mouse and call last kbd macro.
|
|
|
678 If kbd macro currently being defined end it before activating it."
|
|
|
679 (interactive "e")
|
|
|
680 (when defining-kbd-macro
|
|
46961
|
681 (end-kbd-macro))
|
|
46083
|
682 (mouse-set-point event)
|
|
47094
|
683 (kmacro-call-macro nil t))
|
|
46961
|
684
|
|
46083
|
685
|
|
46961
|
686 ;;; Misc. commands
|
|
46083
|
687
|
|
46961
|
688 (defun kmacro-bind-to-key (arg)
|
|
|
689 "When not defining or executing a macro, offer to bind last macro to a key."
|
|
46083
|
690 (interactive "p")
|
|
|
691 (if (or defining-kbd-macro executing-kbd-macro)
|
|
46961
|
692 (if defining-kbd-macro
|
|
|
693 (message "Cannot save macro while defining it."))
|
|
|
694 (unless last-kbd-macro
|
|
|
695 (error "No keyboard macro defined"))
|
|
|
696 (let ((key-seq (read-key-sequence "Bind last macro to key: ")))
|
|
|
697 (unless (equal key-seq "")
|
|
|
698 (define-key global-map key-seq last-kbd-macro)))))
|
|
|
699
|
|
46083
|
700
|
|
46961
|
701 (defun kmacro-view-macro (&optional arg)
|
|
|
702 "Display the last keyboard macro."
|
|
|
703 (interactive)
|
|
|
704 (kmacro-display last-kbd-macro))
|
|
|
705
|
|
46083
|
706
|
|
47094
|
707 (defun kmacro-view-macro-repeat (&optional arg)
|
|
|
708 "Like `kmacro-view-macro', but allow repeat without repeating prefix."
|
|
46961
|
709 (interactive)
|
|
47094
|
710 (let ((keys (kmacro-get-repeat-prefix)))
|
|
|
711 (kmacro-view-macro arg)
|
|
|
712 (if (and last-kbd-macro keys)
|
|
|
713 (kmacro-repeat-on-last-key keys))))
|
|
46083
|
714
|
|
47094
|
715 (put 'kmacro-view-macro-repeat 'kmacro-repeat 'head)
|
|
46083
|
716
|
|
47094
|
717
|
|
|
718 (defun kmacro-edit-macro-repeat (&optional arg)
|
|
46961
|
719 "Edit last keyboard macro."
|
|
|
720 (interactive "P")
|
|
|
721 (edit-kbd-macro "\r" arg))
|
|
|
722
|
|
47094
|
723 (put 'kmacro-edit-macro-repeat 'kmacro-repeat 'stop)
|
|
46961
|
724
|
|
46083
|
725
|
|
47094
|
726 (defun kmacro-edit-macro (&optional arg)
|
|
46961
|
727 "As edit last keyboard macro, but without kmacro-repeat property."
|
|
|
728 (interactive "P")
|
|
47094
|
729 (edit-kbd-macro "\r" arg))
|
|
46083
|
730
|
|
|
731
|
|
46961
|
732 (defun kmacro-edit-lossage ()
|
|
|
733 "Edit most recent 100 keystrokes as a keyboard macro."
|
|
|
734 (interactive)
|
|
|
735 (kmacro-push-ring)
|
|
|
736 (edit-kbd-macro "\C-hl"))
|
|
46083
|
737
|
|
|
738
|
|
47310
|
739 ;;; Single-step editing of keyboard macros
|
|
|
740
|
|
|
741 (defvar kmacro-step-edit-active) ;; step-editing active
|
|
|
742 (defvar kmacro-step-edit-new-macro) ;; storage for new macro
|
|
|
743 (defvar kmacro-step-edit-inserting) ;; inserting into macro
|
|
|
744 (defvar kmacro-step-edit-appending) ;; append to end of macro
|
|
|
745 (defvar kmacro-step-edit-replace) ;; replace orig macro when done
|
|
|
746 (defvar kmacro-step-edit-prefix-index) ;; index of first prefix arg key
|
|
|
747 (defvar kmacro-step-edit-key-index) ;; index of current key
|
|
|
748 (defvar kmacro-step-edit-action) ;; automatic action on next pre-command hook
|
|
|
749 (defvar kmacro-step-edit-help) ;; kmacro step edit help enabled
|
|
|
750 (defvar kmacro-step-edit-num-input-keys) ;; to ignore duplicate pre-command hook
|
|
|
751
|
|
|
752 (defvar kmacro-step-edit-map (make-sparse-keymap)
|
|
|
753 "Keymap that defines the responses to questions in `kmacro-step-edit-macro'.
|
|
|
754 This keymap is an extension to the `query-replace-map', allowing the
|
|
47388
|
755 following additional answers: `insert', `insert-1', `replace', `replace-1',
|
|
|
756 `append', `append-end', `act-repeat', `skip-end', `skip-keep'.")
|
|
47310
|
757
|
|
|
758 ;; query-replace-map answers include: `act', `skip', `act-and-show',
|
|
|
759 ;; `exit', `act-and-exit', `edit', `delete-and-edit', `recenter',
|
|
|
760 ;; `automatic', `backup', `exit-prefix', and `help'.")
|
|
|
761 ;; Also: `quit', `edit-replacement'
|
|
|
762
|
|
|
763 (set-keymap-parent kmacro-step-edit-map query-replace-map)
|
|
|
764
|
|
|
765 (define-key kmacro-step-edit-map "\t" 'act-repeat)
|
|
|
766 (define-key kmacro-step-edit-map [tab] 'act-repeat)
|
|
|
767 (define-key kmacro-step-edit-map "\C-k" 'skip-rest)
|
|
|
768 (define-key kmacro-step-edit-map "c" 'automatic)
|
|
|
769 (define-key kmacro-step-edit-map "f" 'skip-keep)
|
|
|
770 (define-key kmacro-step-edit-map "q" 'quit)
|
|
|
771 (define-key kmacro-step-edit-map "d" 'skip)
|
|
47565
|
772 (define-key kmacro-step-edit-map "\C-d" 'skip)
|
|
47310
|
773 (define-key kmacro-step-edit-map "i" 'insert)
|
|
|
774 (define-key kmacro-step-edit-map "I" 'insert-1)
|
|
|
775 (define-key kmacro-step-edit-map "r" 'replace)
|
|
|
776 (define-key kmacro-step-edit-map "R" 'replace-1)
|
|
|
777 (define-key kmacro-step-edit-map "a" 'append)
|
|
47388
|
778 (define-key kmacro-step-edit-map "A" 'append-end)
|
|
47310
|
779
|
|
|
780 (defvar kmacro-step-edit-prefix-commands
|
|
|
781 '(universal-argument universal-argument-more universal-argument-minus
|
|
|
782 digit-argument negative-argument)
|
|
|
783 "Commands which builds up a prefix arg for the current command")
|
|
|
784
|
|
|
785 (defun kmacro-step-edit-prompt (macro index)
|
|
|
786 ;; Show step-edit prompt
|
|
|
787 (let ((keys (and (not kmacro-step-edit-appending)
|
|
|
788 index (substring macro index executing-macro-index)))
|
|
|
789 (future (and (not kmacro-step-edit-appending)
|
|
|
790 (substring macro executing-macro-index)))
|
|
|
791 (message-log-max nil)
|
|
|
792 (curmsg (current-message)))
|
|
|
793
|
|
|
794 ;; TODO: Scroll macro if max-mini-window-height is too small.
|
|
|
795 (message (concat
|
|
|
796 (format "Macro: %s%s%s%s%s\n"
|
|
|
797 (format-kbd-macro kmacro-step-edit-new-macro 1)
|
|
|
798 (if (and kmacro-step-edit-new-macro (> (length kmacro-step-edit-new-macro) 0)) " " "")
|
|
49597
|
799 (propertize (if keys (format-kbd-macro keys)
|
|
47310
|
800 (if kmacro-step-edit-appending "<APPEND>" "<INSERT>")) 'face 'region)
|
|
|
801 (if future " " "")
|
|
|
802 (if future (format-kbd-macro future) ""))
|
|
|
803 (cond
|
|
|
804 ((minibufferp)
|
|
|
805 (format "%s\n%s\n"
|
|
|
806 (propertize "\
|
|
|
807 minibuffer " 'face 'header-line)
|
|
|
808 (buffer-substring (point-min) (point-max))))
|
|
|
809 (curmsg
|
|
|
810 (format "%s\n%s\n"
|
|
|
811 (propertize "\
|
|
|
812 echo area " 'face 'header-line)
|
|
|
813 curmsg))
|
|
|
814 (t ""))
|
|
|
815 (if keys
|
|
49597
|
816 (format "%s\n%s%s %S [yn iIaArR C-k kq!] "
|
|
47310
|
817 (propertize "\
|
|
|
818 --------------Step Edit Keyboard Macro [?: help]---------------" 'face 'mode-line)
|
|
|
819 (if kmacro-step-edit-help "\
|
|
|
820 Step: y/SPC: execute next, d/n/DEL: skip next, f: skip but keep
|
|
|
821 TAB: execute while same, ?: toggle help
|
|
47389
|
822 Edit: i: insert, r: replace, a: append, A: append at end,
|
|
|
823 I/R: insert/replace with one sequence,
|
|
47310
|
824 End: !/c: execute rest, C-k: skip rest and save, q/C-g: quit
|
|
|
825 ----------------------------------------------------------------
|
|
|
826 " "")
|
|
|
827 (propertize "Next command:" 'face 'bold)
|
|
|
828 this-command)
|
|
49597
|
829 (propertize
|
|
47310
|
830 (format "Type key sequence%s to insert and execute%s: "
|
|
|
831 (if (numberp kmacro-step-edit-inserting) "" "s")
|
|
47388
|
832 (if (numberp kmacro-step-edit-inserting) "" " (end with C-j)"))
|
|
47310
|
833 'face 'bold))))))
|
|
|
834
|
|
|
835 (defun kmacro-step-edit-query ()
|
|
|
836 ;; Pre-command hook function for step-edit in "command" mode
|
|
|
837 (let ((resize-mini-windows t)
|
|
|
838 (max-mini-window-height kmacro-step-edit-mini-window-height)
|
|
|
839 act restore-index next-index)
|
|
|
840
|
|
|
841 ;; Handle commands which reads additional input using read-char.
|
|
|
842 (cond
|
|
|
843 ((and (eq this-command 'quoted-insert)
|
|
|
844 (not (eq kmacro-step-edit-action t)))
|
|
|
845 ;; Find the actual end of this key sequence.
|
|
|
846 ;; Must be able to backtrack in case we actually execute it.
|
|
|
847 (setq restore-index executing-macro-index)
|
|
|
848 (let (unread-command-events)
|
|
|
849 (quoted-insert 0)
|
|
|
850 (when unread-command-events
|
|
|
851 (setq executing-macro-index (- executing-macro-index (length unread-command-events))
|
|
|
852 next-index executing-macro-index)))))
|
|
|
853
|
|
|
854 ;; Query the user; stop macro exection temporarily
|
|
|
855 (let ((macro executing-kbd-macro)
|
|
|
856 (executing-kbd-macro nil)
|
|
|
857 (defining-kbd-macro nil))
|
|
|
858
|
|
|
859 ;; Any action requested by previous command
|
|
|
860 (cond
|
|
|
861 ((eq kmacro-step-edit-action t) ;; Reentry for actual command @ end of prefix arg.
|
|
|
862 (cond
|
|
|
863 ((eq this-command 'quoted-insert)
|
|
|
864 (clear-this-command-keys) ;; recent-keys actually
|
|
|
865 (let (unread-command-events)
|
|
|
866 (quoted-insert (prefix-numeric-value current-prefix-arg))
|
|
49597
|
867 (setq kmacro-step-edit-new-macro
|
|
47310
|
868 (vconcat kmacro-step-edit-new-macro (recent-keys)))
|
|
|
869 (when unread-command-events
|
|
|
870 (setq kmacro-step-edit-new-macro
|
|
|
871 (substring kmacro-step-edit-new-macro 0 (- (length unread-command-events)))
|
|
|
872 executing-macro-index (- executing-macro-index (length unread-command-events)))))
|
|
|
873 (setq current-prefix-arg nil
|
|
|
874 prefix-arg nil)
|
|
|
875 (setq act 'ignore))
|
|
|
876 (t
|
|
|
877 (setq act 'act)))
|
|
|
878 (setq kmacro-step-edit-action nil))
|
|
|
879 ((eq this-command kmacro-step-edit-action) ;; TAB -> activate while same command
|
|
|
880 (setq act 'act))
|
|
|
881 (t
|
|
|
882 (setq kmacro-step-edit-action nil)))
|
|
|
883
|
|
|
884 ;; Handle prefix arg, or query user
|
|
|
885 (cond
|
|
|
886 (act act) ;; set above
|
|
|
887 ((memq this-command kmacro-step-edit-prefix-commands)
|
|
|
888 (unless kmacro-step-edit-prefix-index
|
|
|
889 (setq kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
|
|
|
890 (setq act 'universal-argument))
|
|
|
891 ((eq this-command 'universal-argument-other-key)
|
|
|
892 (setq act 'universal-argument))
|
|
|
893 (t
|
|
|
894 (kmacro-step-edit-prompt macro (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
|
|
|
895 (setq act (lookup-key kmacro-step-edit-map
|
|
|
896 (vector (with-current-buffer (current-buffer) (read-event))))))))
|
|
|
897
|
|
|
898 ;; Resume macro execution and perform the action
|
|
|
899 (cond
|
|
|
900 ((eq act 'universal-argument)
|
|
|
901 nil)
|
|
|
902 ((cond
|
|
|
903 ((eq act 'act)
|
|
|
904 t)
|
|
|
905 ((eq act 'act-repeat)
|
|
|
906 (setq kmacro-step-edit-action this-command)
|
|
|
907 t)
|
|
|
908 ((eq act 'quit)
|
|
|
909 (setq kmacro-step-edit-replace nil)
|
|
|
910 (setq kmacro-step-edit-active 'ignore)
|
|
|
911 nil)
|
|
|
912 ((eq act 'skip)
|
|
|
913 (setq kmacro-step-edit-prefix-index nil)
|
|
|
914 nil)
|
|
|
915 ((eq act 'skip-keep)
|
|
|
916 (setq this-command 'ignore)
|
|
|
917 t)
|
|
|
918 ((eq act 'skip-rest)
|
|
|
919 (setq kmacro-step-edit-active 'ignore)
|
|
|
920 nil)
|
|
47565
|
921 ((memq act '(automatic exit))
|
|
47310
|
922 (setq kmacro-step-edit-active nil)
|
|
|
923 (setq act t)
|
|
|
924 t)
|
|
|
925 ((member act '(insert-1 insert))
|
|
|
926 (setq executing-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
|
|
|
927 (setq kmacro-step-edit-inserting (if (eq act 'insert-1) 1 t))
|
|
|
928 nil)
|
|
|
929 ((member act '(replace-1 replace))
|
|
|
930 (setq kmacro-step-edit-inserting (if (eq act 'replace-1) 1 t))
|
|
|
931 (setq kmacro-step-edit-prefix-index nil)
|
|
|
932 (if (= executing-macro-index (length executing-kbd-macro))
|
|
|
933 (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
|
|
|
934 kmacro-step-edit-appending t))
|
|
|
935 nil)
|
|
47388
|
936 ((eq act 'append)
|
|
|
937 (setq kmacro-step-edit-inserting t)
|
|
47310
|
938 (if (= executing-macro-index (length executing-kbd-macro))
|
|
|
939 (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
|
|
|
940 kmacro-step-edit-appending t))
|
|
|
941 t)
|
|
47388
|
942 ((eq act 'append-end)
|
|
|
943 (if (= executing-macro-index (length executing-kbd-macro))
|
|
|
944 (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
|
|
|
945 kmacro-step-edit-inserting t
|
|
|
946 kmacro-step-edit-appending t)
|
|
|
947 (setq kmacro-step-edit-active 'append-end))
|
|
|
948 (setq act t)
|
|
|
949 t)
|
|
47310
|
950 ((eq act 'help)
|
|
|
951 (setq executing-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
|
|
|
952 (setq kmacro-step-edit-help (not kmacro-step-edit-help))
|
|
|
953 nil)
|
|
|
954 (t ;; Ignore unknown responses
|
|
|
955 (setq executing-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
|
|
|
956 nil))
|
|
|
957 (if (> executing-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index))
|
|
|
958 (setq kmacro-step-edit-new-macro
|
|
|
959 (vconcat kmacro-step-edit-new-macro
|
|
49597
|
960 (substring executing-kbd-macro
|
|
47310
|
961 (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index)
|
|
|
962 (if (eq act t) nil executing-macro-index)))
|
|
|
963 kmacro-step-edit-prefix-index nil))
|
|
|
964 (if restore-index
|
|
|
965 (setq executing-macro-index restore-index)))
|
|
|
966 (t
|
|
|
967 (setq this-command 'ignore)))
|
|
|
968 (setq kmacro-step-edit-key-index next-index)))
|
|
|
969
|
|
|
970 (defun kmacro-step-edit-insert ()
|
|
|
971 ;; Pre-command hook function for step-edit in "insert" mode
|
|
|
972 (let ((resize-mini-windows t)
|
|
|
973 (max-mini-window-height kmacro-step-edit-mini-window-height)
|
|
|
974 (macro executing-kbd-macro)
|
|
|
975 (executing-kbd-macro nil)
|
|
|
976 (defining-kbd-macro nil)
|
|
|
977 cmd keys next-index)
|
|
|
978 (setq executing-macro-index (or kmacro-step-edit-prefix-index kmacro-step-edit-key-index)
|
|
|
979 kmacro-step-edit-prefix-index nil)
|
|
|
980 (kmacro-step-edit-prompt macro nil)
|
|
|
981 ;; Now, we have read a key sequence from the macro, but we don't want
|
|
|
982 ;; to execute it yet. So push it back and read another sequence.
|
|
|
983 (reset-this-command-lengths)
|
|
|
984 (setq keys (read-key-sequence nil nil nil nil t))
|
|
|
985 (setq cmd (key-binding keys t nil))
|
|
|
986 (if (cond
|
|
|
987 ((null cmd)
|
|
|
988 t)
|
|
|
989 ((eq cmd 'quoted-insert)
|
|
|
990 (clear-this-command-keys) ;; recent-keys actually
|
|
|
991 (quoted-insert (prefix-numeric-value current-prefix-arg))
|
|
|
992 (setq current-prefix-arg nil
|
|
|
993 prefix-arg nil)
|
|
|
994 (setq keys (vconcat keys (recent-keys)))
|
|
|
995 (when (numberp kmacro-step-edit-inserting)
|
|
|
996 (setq kmacro-step-edit-inserting nil)
|
|
|
997 (when unread-command-events
|
|
|
998 (setq keys (substring keys 0 (- (length unread-command-events)))
|
|
|
999 executing-macro-index (- executing-macro-index (length unread-command-events))
|
|
|
1000 next-index executing-macro-index
|
|
|
1001 unread-command-events nil)))
|
|
|
1002 (setq cmd 'ignore)
|
|
|
1003 nil)
|
|
|
1004 ((memq cmd kmacro-step-edit-prefix-commands)
|
|
|
1005 (setq universal-argument-num-events 0)
|
|
|
1006 (reset-this-command-lengths)
|
|
|
1007 nil)
|
|
|
1008 ((eq cmd 'universal-argument-other-key)
|
|
|
1009 (setq kmacro-step-edit-action t)
|
|
|
1010 (setq universal-argument-num-events 0)
|
|
|
1011 (reset-this-command-lengths)
|
|
|
1012 (if (numberp kmacro-step-edit-inserting)
|
|
|
1013 (setq kmacro-step-edit-inserting nil))
|
|
|
1014 nil)
|
|
|
1015 ((numberp kmacro-step-edit-inserting)
|
|
|
1016 (setq kmacro-step-edit-inserting nil)
|
|
|
1017 nil)
|
|
|
1018 ((equal keys "\C-j")
|
|
|
1019 (setq kmacro-step-edit-inserting nil)
|
|
|
1020 (setq kmacro-step-edit-action nil)
|
|
|
1021 ;; Forget any (partial) prefix arg from next command
|
|
|
1022 (setq kmacro-step-edit-prefix-index nil)
|
|
|
1023 (reset-this-command-lengths)
|
|
|
1024 (setq overriding-terminal-local-map nil)
|
|
|
1025 (setq universal-argument-num-events nil)
|
|
|
1026 (setq next-index kmacro-step-edit-key-index)
|
|
|
1027 t)
|
|
|
1028 (t nil))
|
|
|
1029 (setq this-command 'ignore)
|
|
|
1030 (setq this-command cmd)
|
|
|
1031 (if (memq this-command '(self-insert-command digit-argument))
|
|
|
1032 (setq last-command-char (aref keys (1- (length keys)))))
|
|
|
1033 (if keys
|
|
|
1034 (setq kmacro-step-edit-new-macro (vconcat kmacro-step-edit-new-macro keys))))
|
|
|
1035 (setq kmacro-step-edit-key-index next-index)))
|
|
|
1036
|
|
|
1037 (defun kmacro-step-edit-pre-command ()
|
|
|
1038 (remove-hook 'post-command-hook 'kmacro-step-edit-post-command)
|
|
|
1039 (when kmacro-step-edit-active
|
|
|
1040 (cond
|
|
|
1041 ((eq kmacro-step-edit-active 'ignore)
|
|
|
1042 (setq this-command 'ignore))
|
|
47388
|
1043 ((eq kmacro-step-edit-active 'append-end)
|
|
|
1044 (if (= executing-macro-index (length executing-kbd-macro))
|
|
|
1045 (setq executing-kbd-macro (vconcat executing-kbd-macro [nil])
|
|
|
1046 kmacro-step-edit-inserting t
|
|
|
1047 kmacro-step-edit-appending t
|
|
|
1048 kmacro-step-edit-active t)))
|
|
47310
|
1049 ((/= kmacro-step-edit-num-input-keys num-input-keys)
|
|
|
1050 (if kmacro-step-edit-inserting
|
|
|
1051 (kmacro-step-edit-insert)
|
|
|
1052 (kmacro-step-edit-query))
|
|
|
1053 (setq kmacro-step-edit-num-input-keys num-input-keys)
|
|
|
1054 (if (and kmacro-step-edit-appending (not kmacro-step-edit-inserting))
|
|
|
1055 (setq kmacro-step-edit-appending nil
|
|
|
1056 kmacro-step-edit-active 'ignore)))))
|
|
|
1057 (when (eq kmacro-step-edit-active t)
|
|
|
1058 (add-hook 'post-command-hook 'kmacro-step-edit-post-command t)))
|
|
|
1059
|
|
|
1060 (defun kmacro-step-edit-minibuf-setup ()
|
|
|
1061 (remove-hook 'pre-command-hook 'kmacro-step-edit-pre-command t)
|
|
|
1062 (when kmacro-step-edit-active
|
|
|
1063 (add-hook 'pre-command-hook 'kmacro-step-edit-pre-command nil t)))
|
|
|
1064
|
|
|
1065 (defun kmacro-step-edit-post-command ()
|
|
|
1066 (remove-hook 'pre-command-hook 'kmacro-step-edit-pre-command)
|
|
|
1067 (when kmacro-step-edit-active
|
|
|
1068 (add-hook 'pre-command-hook 'kmacro-step-edit-pre-command nil nil)
|
|
|
1069 (if kmacro-step-edit-key-index
|
|
|
1070 (setq executing-macro-index kmacro-step-edit-key-index)
|
|
49597
|
1071 (setq kmacro-step-edit-key-index executing-macro-index))))
|
|
47310
|
1072
|
|
|
1073
|
|
|
1074 (defun kmacro-step-edit-macro ()
|
|
|
1075 "Step edit and execute last keyboard macro.
|
|
|
1076
|
|
|
1077 To customize possible responses, change the \"bindings\" in `kmacro-step-edit-map'."
|
|
|
1078 (interactive)
|
|
|
1079 (let ((kmacro-step-edit-active t)
|
|
|
1080 (kmacro-step-edit-new-macro "")
|
|
|
1081 (kmacro-step-edit-inserting nil)
|
|
|
1082 (kmacro-step-edit-appending nil)
|
|
|
1083 (kmacro-step-edit-replace t)
|
|
|
1084 (kmacro-step-edit-prefix-index nil)
|
|
|
1085 (kmacro-step-edit-key-index 0)
|
|
|
1086 (kmacro-step-edit-action nil)
|
|
|
1087 (kmacro-step-edit-help nil)
|
|
|
1088 (kmacro-step-edit-num-input-keys num-input-keys)
|
|
|
1089 (pre-command-hook pre-command-hook)
|
|
|
1090 (post-command-hook post-command-hook)
|
|
|
1091 (minibuffer-setup-hook minibuffer-setup-hook))
|
|
|
1092 (add-hook 'pre-command-hook 'kmacro-step-edit-pre-command nil)
|
|
|
1093 (add-hook 'post-command-hook 'kmacro-step-edit-post-command t)
|
|
|
1094 (add-hook 'minibuffer-setup-hook 'kmacro-step-edit-minibuf-setup t)
|
|
|
1095 (call-last-kbd-macro nil nil)
|
|
47565
|
1096 (when (and kmacro-step-edit-replace
|
|
|
1097 kmacro-step-edit-new-macro
|
|
|
1098 (not (equal last-kbd-macro kmacro-step-edit-new-macro)))
|
|
|
1099 (kmacro-push-ring)
|
|
|
1100 (setq last-kbd-macro kmacro-step-edit-new-macro))))
|
|
47310
|
1101
|
46099
d441fc235798
Passed it through checkdoc. Moved `provide' to the end, where it belongs.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1102 (provide 'kmacro)
|
d441fc235798
Passed it through checkdoc. Moved `provide' to the end, where it belongs.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1103 ;;; kmacro.el ends here
|
