mirror/emacs
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/emacs.git synced 2024-12-24 10:38:38 +00:00
Code Issues Releases Activity

Move keymap initialization into declaration.

Browse Source 
* lisp/textmodes/enriched.el (enriched-mode-map):
* lisp/textmodes/bib-mode.el (bib-mode-map):
* lisp/term/lk201.el (lk201-function-map):
* lisp/tar-mode.el (tar-mode-map):
* lisp/replace.el (occur-mode-map):
* lisp/progmodes/idlwave.el (idlwave-rinfo-mouse-map, idlwave-rinfo-map):
* lisp/progmodes/idlw-help.el (idlwave-help-mode-map):
* lisp/progmodes/gdb-mi.el (gdb-memory-format-menu, gdb-memory-unit-menu):
* lisp/play/solitaire.el (solitaire-mode-map):
* lisp/play/snake.el (snake-mode-map, snake-null-map):
* lisp/play/pong.el (pong-mode-map):
* lisp/play/handwrite.el (menu-bar-handwrite-map):
* lisp/play/gametree.el (gametree-mode-map):
* lisp/net/rcirc.el (rcirc-mode-map, rcirc-browse-url-map
(rcirc-multiline-minor-mode-map, rcirc-track-minor-mode-map):
* lisp/net/newst-plainview.el (newsticker-menu, newsticker-mode-map)
(newsticker--url-keymap):
* lisp/net/net-utils.el (nslookup-mode-map, ftp-mode-map):
* lisp/menu-bar.el (menu-bar-file-menu, menu-bar-i-search-menu)
(menu-bar-search-menu, menu-bar-replace-menu, menu-bar-goto-menu)
(menu-bar-edit-menu, menu-bar-custom-menu)
(menu-bar-showhide-fringe-ind-menu, menu-bar-showhide-fringe-menu)
(menu-bar-showhide-scroll-bar-menu, menu-bar-showhide-menu)
(menu-bar-line-wrapping-menu, menu-bar-options-menu)
(menu-bar-games-menu, menu-bar-encryption-decryption-menu)
(menu-bar-tools-menu, menu-bar-describe-menu)
(menu-bar-search-documentation-menu, menu-bar-manuals-menu)
(menu-bar-help-menu):
* lisp/mail/rmailsum.el (rmail-summary-mode-map):
* lisp/kmacro.el (kmacro-step-edit-map):
* lisp/ibuffer.el (ibuffer-mode-groups-popup, ibuffer-mode-map)
(ibuffer-mode-operate-map):
* lisp/hi-lock.el (hi-lock-menu, hi-lock-map):
* lisp/emulation/vip.el (vip-mode-map):
* lisp/emacs-lisp/re-builder.el (reb-lisp-mode-map):
* lisp/bookmark.el (bookmark-bmenu-mode-map):
* lisp/help-mode.el (help-mode-map):
* lisp/erc/erc-list.el (erc-list-menu-mode-map):
* lisp/org/org-remember.el (org-remember-mode-map):
* lisp/org/org-src.el (org-src-mode-map): Move initialization into declaration.
This commit is contained in:
Stefan Monnier 2011-02-10 11:56:00 -05:00
parent 1be1d1e98e
commit b016851cb1
32 changed files with 2424 additions and 2304 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
lisp/ChangeLog
View File

@ -1,3 +1,44 @@
2011-02-10 Stefan Monnier <monnier@iro.umontreal.ca>
Move keymap initialization into declaration.
* textmodes/enriched.el (enriched-mode-map):
* textmodes/bib-mode.el (bib-mode-map):
* term/lk201.el (lk201-function-map):
* tar-mode.el (tar-mode-map):
* replace.el (occur-mode-map):
* progmodes/idlwave.el (idlwave-rinfo-mouse-map, idlwave-rinfo-map):
* progmodes/idlw-help.el (idlwave-help-mode-map):
* progmodes/gdb-mi.el (gdb-memory-format-menu, gdb-memory-unit-menu):
* play/solitaire.el (solitaire-mode-map):
* play/snake.el (snake-mode-map, snake-null-map):
* play/pong.el (pong-mode-map):
* play/handwrite.el (menu-bar-handwrite-map):
* play/gametree.el (gametree-mode-map):
* net/rcirc.el (rcirc-mode-map, rcirc-browse-url-map
(rcirc-multiline-minor-mode-map, rcirc-track-minor-mode-map):
* net/newst-plainview.el (newsticker-menu, newsticker-mode-map)
(newsticker--url-keymap):
* net/net-utils.el (nslookup-mode-map, ftp-mode-map):
* menu-bar.el (menu-bar-file-menu, menu-bar-i-search-menu)
(menu-bar-search-menu, menu-bar-replace-menu, menu-bar-goto-menu)
(menu-bar-edit-menu, menu-bar-custom-menu)
(menu-bar-showhide-fringe-ind-menu, menu-bar-showhide-fringe-menu)
(menu-bar-showhide-scroll-bar-menu, menu-bar-showhide-menu)
(menu-bar-line-wrapping-menu, menu-bar-options-menu)
(menu-bar-games-menu, menu-bar-encryption-decryption-menu)
(menu-bar-tools-menu, menu-bar-describe-menu)
(menu-bar-search-documentation-menu, menu-bar-manuals-menu)
(menu-bar-help-menu):
* mail/rmailsum.el (rmail-summary-mode-map):
* kmacro.el (kmacro-step-edit-map):
* ibuffer.el (ibuffer-mode-groups-popup, ibuffer-mode-map)
(ibuffer-mode-operate-map):
* hi-lock.el (hi-lock-menu, hi-lock-map):
* emulation/vip.el (vip-mode-map):
* emacs-lisp/re-builder.el (reb-lisp-mode-map):
* bookmark.el (bookmark-bmenu-mode-map):
* help-mode.el (help-mode-map): Move initialization into declaration.
2011-02-10 Deniz Dogan <deniz.a.m.dogan@gmail.com>
* net/rcirc.el: Add PRIVMSG and CTCP functions.
@ -70,8 +111,7 @@
2011-02-07 Michael Albinus <michael.albinus@gmx.de>
* net/dbus.el (dbus-list-activatable-names): Add optional argument
BUS.
* net/dbus.el (dbus-list-activatable-names): Add optional argument BUS.
2011-02-07 Deniz Dogan <deniz.a.m.dogan@gmail.com>
@ -79,21 +119,21 @@
2011-02-06 Jay Belanger <jay.p.belanger@gmail.com>
* calc/calc.el (calc-logunits-field-reference) Renamed from
* calc/calc.el (calc-logunits-field-reference): Rename from
`calc-default-field-reference-level'.
(calc-logunits-power-reference): Renamed from
(calc-logunits-power-reference): Rename from
`calc-default-power-reference-level'
* calc/calc-units.el (math-logunits-quant): Renamed from
* calc/calc-units.el (math-logunits-quant): Rename from
`math-logunits-level'
(math-logunits-plus): Renamed from math-logcombine.
(math-logunits-plus): Rename from math-logcombine.
(calcFunc-luplus, calcFunc-luminus calc-luplus, calc-luminus): Remove.
(calcFunc-lufieldadd, calcFunc-lupoweradd, calcFunc-lufieldsub)
(calcFunc-lufieldsub,calc-logunits-add calc-logunits-sub):
New functions.
(calcFunc-fieldquant): Renamed from `calcFunc-fieldlevel'.
(calcFunc-powerquant): Renamed from `calcFunc-powerlevel'.
(calc-logunits-quantity): Renamed from `calc-level'.
(calcFunc-fieldquant): Rename from `calcFunc-fieldlevel'.
(calcFunc-powerquant): Rename from `calcFunc-powerlevel'.
(calc-logunits-quantity): Rename from `calc-level'.
(calcFunc-dbfieldlevel, calcFunc-dbpowerlevel, calcFunc-npfieldlevel)
(calcFunc-nppowerlevel,calc-logunits-dblevel, calc-logunits-nplevel)
(math-logunits-mul, calcFunc-lufieldmul, calcFunc-lupowermul)
@ -101,7 +141,7 @@
(calcFunc-lupowerdiv,calc-logunits-divide,math-logunits-level):
New functions.
* calc/calc-help.el (calc-u-prefix-help): Removed "L" reference.
* calc/calc-help.el (calc-u-prefix-help): Remove "L" reference.
(calc-ul-prefix-help): Remove.
(calc-l-prefix-help): New function.
(calc-full-help): Add reference to `calc-l-prefix-help'.

70
lisp/bookmark.el
View File

@ -1473,6 +1473,43 @@ method buffers use to resolve name collisions."
(defvar bookmark-bmenu-hidden-bookmarks ())
(defvar bookmark-bmenu-mode-map
(let ((map (make-keymap)))
(set-keymap-parent map special-mode-map)
(define-key map "v" 'bookmark-bmenu-select)
(define-key map "w" 'bookmark-bmenu-locate)
(define-key map "2" 'bookmark-bmenu-2-window)
(define-key map "1" 'bookmark-bmenu-1-window)
(define-key map "j" 'bookmark-bmenu-this-window)
(define-key map "\C-c\C-c" 'bookmark-bmenu-this-window)
(define-key map "f" 'bookmark-bmenu-this-window)
(define-key map "\C-m" 'bookmark-bmenu-this-window)
(define-key map "o" 'bookmark-bmenu-other-window)
(define-key map "\C-o" 'bookmark-bmenu-switch-other-window)
(define-key map "s" 'bookmark-bmenu-save)
(define-key map "k" 'bookmark-bmenu-delete)
(define-key map "\C-d" 'bookmark-bmenu-delete-backwards)
(define-key map "x" 'bookmark-bmenu-execute-deletions)
(define-key map "d" 'bookmark-bmenu-delete)
(define-key map " " 'next-line)
(define-key map "n" 'next-line)
(define-key map "p" 'previous-line)
(define-key map "\177" 'bookmark-bmenu-backup-unmark)
(define-key map "u" 'bookmark-bmenu-unmark)
(define-key map "m" 'bookmark-bmenu-mark)
(define-key map "l" 'bookmark-bmenu-load)
(define-key map "r" 'bookmark-bmenu-rename)
(define-key map "R" 'bookmark-bmenu-relocate)
(define-key map "t" 'bookmark-bmenu-toggle-filenames)
(define-key map "a" 'bookmark-bmenu-show-annotation)
(define-key map "A" 'bookmark-bmenu-show-all-annotations)
(define-key map "e" 'bookmark-bmenu-edit-annotation)
;; The original binding of M-g hides the M-g prefix map.
;; If someone has a better idea than M-g s, I'm open to suggestions.
(define-key map [?\M-g ?s] 'bookmark-bmenu-search)
(define-key map [mouse-2] 'bookmark-bmenu-other-window-with-mouse)
map))
;; Bookmark Buffer Menu mode is suitable only for specially formatted
;; data.
(put 'bookmark-bmenu-mode 'mode-class 'special)
@ -1583,39 +1620,6 @@ Bookmark names preceded by a \"*\" have annotations.
(setq truncate-lines t)
(setq buffer-read-only t))
(define-key bookmark-bmenu-mode-map "q" 'quit-window)
(define-key bookmark-bmenu-mode-map "v" 'bookmark-bmenu-select)
(define-key bookmark-bmenu-mode-map "w" 'bookmark-bmenu-locate)
(define-key bookmark-bmenu-mode-map "2" 'bookmark-bmenu-2-window)
(define-key bookmark-bmenu-mode-map "1" 'bookmark-bmenu-1-window)
(define-key bookmark-bmenu-mode-map "j" 'bookmark-bmenu-this-window)
(define-key bookmark-bmenu-mode-map "\C-c\C-c" 'bookmark-bmenu-this-window)
(define-key bookmark-bmenu-mode-map "f" 'bookmark-bmenu-this-window)
(define-key bookmark-bmenu-mode-map "\C-m" 'bookmark-bmenu-this-window)
(define-key bookmark-bmenu-mode-map "o" 'bookmark-bmenu-other-window)
(define-key bookmark-bmenu-mode-map "\C-o" 'bookmark-bmenu-switch-other-window)
(define-key bookmark-bmenu-mode-map "s" 'bookmark-bmenu-save)
(define-key bookmark-bmenu-mode-map "k" 'bookmark-bmenu-delete)
(define-key bookmark-bmenu-mode-map "\C-d" 'bookmark-bmenu-delete-backwards)
(define-key bookmark-bmenu-mode-map "x" 'bookmark-bmenu-execute-deletions)
(define-key bookmark-bmenu-mode-map "d" 'bookmark-bmenu-delete)
(define-key bookmark-bmenu-mode-map " " 'next-line)
(define-key bookmark-bmenu-mode-map "n" 'next-line)
(define-key bookmark-bmenu-mode-map "p" 'previous-line)
(define-key bookmark-bmenu-mode-map "\177" 'bookmark-bmenu-backup-unmark)
(define-key bookmark-bmenu-mode-map "?" 'describe-mode)
(define-key bookmark-bmenu-mode-map "u" 'bookmark-bmenu-unmark)
(define-key bookmark-bmenu-mode-map "m" 'bookmark-bmenu-mark)
(define-key bookmark-bmenu-mode-map "l" 'bookmark-bmenu-load)
(define-key bookmark-bmenu-mode-map "r" 'bookmark-bmenu-rename)
(define-key bookmark-bmenu-mode-map "R" 'bookmark-bmenu-relocate)
(define-key bookmark-bmenu-mode-map "t" 'bookmark-bmenu-toggle-filenames)
(define-key bookmark-bmenu-mode-map "a" 'bookmark-bmenu-show-annotation)
(define-key bookmark-bmenu-mode-map "A" 'bookmark-bmenu-show-all-annotations)
(define-key bookmark-bmenu-mode-map "e" 'bookmark-bmenu-edit-annotation)
;; The original binding of M-g hides the M-g prefix map.
;; If someone has a better idea than M-g s, I'm open to suggestions.
(define-key bookmark-bmenu-mode-map [?\M-g ?s] 'bookmark-bmenu-search)(define-key bookmark-bmenu-mode-map [mouse-2] 'bookmark-bmenu-other-window-with-mouse)
(defun bookmark-bmenu-toggle-filenames (&optional show)
"Toggle whether filenames are shown in the bookmark list.

12
lisp/emacs-lisp/re-builder.el
View File

@ -275,6 +275,13 @@ Except for Lisp syntax this is the same as `reb-regexp'.")
(set (make-local-variable 'blink-matching-paren) nil)
(reb-mode-common))
(defvar reb-lisp-mode-map
(let ((map (make-sparse-keymap)))
;; Use the same "\C-c" keymap as `reb-mode' and use font-locking from
;; `emacs-lisp-mode'
(define-key map "\C-c" (lookup-key reb-mode-map "\C-c"))
map))
(define-derived-mode reb-lisp-mode
emacs-lisp-mode "RE Builder Lisp"
"Major mode for interactively building symbolic Regular Expressions."
@ -283,11 +290,6 @@ Except for Lisp syntax this is the same as `reb-regexp'.")
(require 'rx))) ; require rx anyway
(reb-mode-common))
;; Use the same "\C-c" keymap as `reb-mode' and use font-locking from
;; `emacs-lisp-mode'
(define-key reb-lisp-mode-map "\C-c"
(lookup-key reb-mode-map "\C-c"))
(defvar reb-subexp-mode-map
(let ((m (make-keymap)))
(suppress-keymap m)

239
lisp/emulation/vip.el
View File

@ -164,132 +164,133 @@ If nil then it is bound to `delete-backward-char'."
;; key bindings
(defvar vip-mode-map (make-keymap))
(defvar vip-mode-map
(let ((map (make-keymap)))
(define-key map "\C-a" 'beginning-of-line)
(define-key map "\C-b" 'vip-scroll-back)
(define-key map "\C-c" 'vip-ctl-c)
(define-key map "\C-d" 'vip-scroll-up)
(define-key map "\C-e" 'vip-scroll-up-one)
(define-key map "\C-f" 'vip-scroll)
(define-key map "\C-g" 'vip-keyboard-quit)
(define-key map "\C-h" 'help-command)
(define-key map "\C-m" 'vip-scroll-back)
(define-key map "\C-n" 'vip-other-window)
(define-key map "\C-o" 'vip-open-line-at-point)
(define-key map "\C-u" 'vip-scroll-down)
(define-key map "\C-x" 'vip-ctl-x)
(define-key map "\C-y" 'vip-scroll-down-one)
(define-key map "\C-z" 'vip-change-mode-to-emacs)
(define-key map "\e" 'vip-ESC)
(define-key vip-mode-map "\C-a" 'beginning-of-line)
(define-key vip-mode-map "\C-b" 'vip-scroll-back)
(define-key vip-mode-map "\C-c" 'vip-ctl-c)
(define-key vip-mode-map "\C-d" 'vip-scroll-up)
(define-key vip-mode-map "\C-e" 'vip-scroll-up-one)
(define-key vip-mode-map "\C-f" 'vip-scroll)
(define-key vip-mode-map "\C-g" 'vip-keyboard-quit)
(define-key vip-mode-map "\C-h" 'help-command)
(define-key vip-mode-map "\C-m" 'vip-scroll-back)
(define-key vip-mode-map "\C-n" 'vip-other-window)
(define-key vip-mode-map "\C-o" 'vip-open-line-at-point)
(define-key vip-mode-map "\C-u" 'vip-scroll-down)
(define-key vip-mode-map "\C-x" 'vip-ctl-x)
(define-key vip-mode-map "\C-y" 'vip-scroll-down-one)
(define-key vip-mode-map "\C-z" 'vip-change-mode-to-emacs)
(define-key vip-mode-map "\e" 'vip-ESC)
(define-key map " " 'vip-scroll)
(define-key map "!" 'vip-command-argument)
(define-key map "\"" 'vip-command-argument)
(define-key map "#" 'vip-command-argument)
(define-key map "$" 'vip-goto-eol)
(define-key map "%" 'vip-paren-match)
(define-key map "&" 'vip-nil)
(define-key map "'" 'vip-goto-mark-and-skip-white)
(define-key map "(" 'vip-backward-sentence)
(define-key map ")" 'vip-forward-sentence)
(define-key map "*" 'call-last-kbd-macro)
(define-key map "+" 'vip-next-line-at-bol)
(define-key map "," 'vip-repeat-find-opposite)
(define-key map "-" 'vip-previous-line-at-bol)
(define-key map "." 'vip-repeat)
(define-key map "/" 'vip-search-forward)
(define-key vip-mode-map " " 'vip-scroll)
(define-key vip-mode-map "!" 'vip-command-argument)
(define-key vip-mode-map "\"" 'vip-command-argument)
(define-key vip-mode-map "#" 'vip-command-argument)
(define-key vip-mode-map "$" 'vip-goto-eol)
(define-key vip-mode-map "%" 'vip-paren-match)
(define-key vip-mode-map "&" 'vip-nil)
(define-key vip-mode-map "'" 'vip-goto-mark-and-skip-white)
(define-key vip-mode-map "(" 'vip-backward-sentence)
(define-key vip-mode-map ")" 'vip-forward-sentence)
(define-key vip-mode-map "*" 'call-last-kbd-macro)
(define-key vip-mode-map "+" 'vip-next-line-at-bol)
(define-key vip-mode-map "," 'vip-repeat-find-opposite)
(define-key vip-mode-map "-" 'vip-previous-line-at-bol)
(define-key vip-mode-map "." 'vip-repeat)
(define-key vip-mode-map "/" 'vip-search-forward)
(define-key map "0" 'vip-beginning-of-line)
(define-key map "1" 'vip-digit-argument)
(define-key map "2" 'vip-digit-argument)
(define-key map "3" 'vip-digit-argument)
(define-key map "4" 'vip-digit-argument)
(define-key map "5" 'vip-digit-argument)
(define-key map "6" 'vip-digit-argument)
(define-key map "7" 'vip-digit-argument)
(define-key map "8" 'vip-digit-argument)
(define-key map "9" 'vip-digit-argument)
(define-key vip-mode-map "0" 'vip-beginning-of-line)
(define-key vip-mode-map "1" 'vip-digit-argument)
(define-key vip-mode-map "2" 'vip-digit-argument)
(define-key vip-mode-map "3" 'vip-digit-argument)
(define-key vip-mode-map "4" 'vip-digit-argument)
(define-key vip-mode-map "5" 'vip-digit-argument)
(define-key vip-mode-map "6" 'vip-digit-argument)
(define-key vip-mode-map "7" 'vip-digit-argument)
(define-key vip-mode-map "8" 'vip-digit-argument)
(define-key vip-mode-map "9" 'vip-digit-argument)
(define-key map ":" 'vip-ex)
(define-key map ";" 'vip-repeat-find)
(define-key map "<" 'vip-command-argument)
(define-key map "=" 'vip-command-argument)
(define-key map ">" 'vip-command-argument)
(define-key map "?" 'vip-search-backward)
(define-key map "@" 'vip-nil)
(define-key vip-mode-map ":" 'vip-ex)
(define-key vip-mode-map ";" 'vip-repeat-find)
(define-key vip-mode-map "<" 'vip-command-argument)
(define-key vip-mode-map "=" 'vip-command-argument)
(define-key vip-mode-map ">" 'vip-command-argument)
(define-key vip-mode-map "?" 'vip-search-backward)
(define-key vip-mode-map "@" 'vip-nil)
(define-key map "A" 'vip-Append)
(define-key map "B" 'vip-backward-Word)
(define-key map "C" 'vip-ctl-c-equivalent)
(define-key map "D" 'vip-kill-line)
(define-key map "E" 'vip-end-of-Word)
(define-key map "F" 'vip-find-char-backward)
(define-key map "G" 'vip-goto-line)
(define-key map "H" 'vip-window-top)
(define-key map "I" 'vip-Insert)
(define-key map "J" 'vip-join-lines)
(define-key map "K" 'vip-kill-buffer)
(define-key map "L" 'vip-window-bottom)
(define-key map "M" 'vip-window-middle)
(define-key map "N" 'vip-search-Next)
(define-key map "O" 'vip-Open-line)
(define-key map "P" 'vip-Put-back)
(define-key map "Q" 'vip-query-replace)
(define-key map "R" 'vip-replace-string)
(define-key map "S" 'vip-switch-to-buffer-other-window)
(define-key map "T" 'vip-goto-char-backward)
(define-key map "U" 'vip-nil)
(define-key map "V" 'vip-find-file-other-window)
(define-key map "W" 'vip-forward-Word)
(define-key map "X" 'vip-ctl-x-equivalent)
(define-key map "Y" 'vip-yank-line)
(define-key map "ZZ" 'save-buffers-kill-emacs)
(define-key vip-mode-map "A" 'vip-Append)
(define-key vip-mode-map "B" 'vip-backward-Word)
(define-key vip-mode-map "C" 'vip-ctl-c-equivalent)
(define-key vip-mode-map "D" 'vip-kill-line)
(define-key vip-mode-map "E" 'vip-end-of-Word)
(define-key vip-mode-map "F" 'vip-find-char-backward)
(define-key vip-mode-map "G" 'vip-goto-line)
(define-key vip-mode-map "H" 'vip-window-top)
(define-key vip-mode-map "I" 'vip-Insert)
(define-key vip-mode-map "J" 'vip-join-lines)
(define-key vip-mode-map "K" 'vip-kill-buffer)
(define-key vip-mode-map "L" 'vip-window-bottom)
(define-key vip-mode-map "M" 'vip-window-middle)
(define-key vip-mode-map "N" 'vip-search-Next)
(define-key vip-mode-map "O" 'vip-Open-line)
(define-key vip-mode-map "P" 'vip-Put-back)
(define-key vip-mode-map "Q" 'vip-query-replace)
(define-key vip-mode-map "R" 'vip-replace-string)
(define-key vip-mode-map "S" 'vip-switch-to-buffer-other-window)
(define-key vip-mode-map "T" 'vip-goto-char-backward)
(define-key vip-mode-map "U" 'vip-nil)
(define-key vip-mode-map "V" 'vip-find-file-other-window)
(define-key vip-mode-map "W" 'vip-forward-Word)
(define-key vip-mode-map "X" 'vip-ctl-x-equivalent)
(define-key vip-mode-map "Y" 'vip-yank-line)
(define-key vip-mode-map "ZZ" 'save-buffers-kill-emacs)
(define-key map "[" 'vip-nil)
(define-key map "\\" 'vip-escape-to-emacs)
(define-key map "]" 'vip-nil)
(define-key map "^" 'vip-bol-and-skip-white)
(define-key map "_" 'vip-nil)
(define-key map "`" 'vip-goto-mark)
(define-key vip-mode-map "[" 'vip-nil)
(define-key vip-mode-map "\\" 'vip-escape-to-emacs)
(define-key vip-mode-map "]" 'vip-nil)
(define-key vip-mode-map "^" 'vip-bol-and-skip-white)
(define-key vip-mode-map "_" 'vip-nil)
(define-key vip-mode-map "`" 'vip-goto-mark)
(define-key map "a" 'vip-append)
(define-key map "b" 'vip-backward-word)
(define-key map "c" 'vip-command-argument)
(define-key map "d" 'vip-command-argument)
(define-key map "e" 'vip-end-of-word)
(define-key map "f" 'vip-find-char-forward)
(define-key map "g" 'vip-info-on-file)
(define-key map "h" 'vip-backward-char)
(define-key map "i" 'vip-insert)
(define-key map "j" 'vip-next-line)
(define-key map "k" 'vip-previous-line)
(define-key map "l" 'vip-forward-char)
(define-key map "m" 'vip-mark-point)
(define-key map "n" 'vip-search-next)
(define-key map "o" 'vip-open-line)
(define-key map "p" 'vip-put-back)
(define-key map "q" 'vip-nil)
(define-key map "r" 'vip-replace-char)
(define-key map "s" 'vip-switch-to-buffer)
(define-key map "t" 'vip-goto-char-forward)
(define-key map "u" 'vip-undo)
(define-key map "v" 'vip-find-file)
(define-key map "w" 'vip-forward-word)
(define-key map "x" 'vip-delete-char)
(define-key map "y" 'vip-command-argument)
(define-key map "zH" 'vip-line-to-top)
(define-key map "zM" 'vip-line-to-middle)
(define-key map "zL" 'vip-line-to-bottom)
(define-key map "z\C-m" 'vip-line-to-top)
(define-key map "z." 'vip-line-to-middle)
(define-key map "z-" 'vip-line-to-bottom)
(define-key vip-mode-map "a" 'vip-append)
(define-key vip-mode-map "b" 'vip-backward-word)
(define-key vip-mode-map "c" 'vip-command-argument)
(define-key vip-mode-map "d" 'vip-command-argument)
(define-key vip-mode-map "e" 'vip-end-of-word)
(define-key vip-mode-map "f" 'vip-find-char-forward)
(define-key vip-mode-map "g" 'vip-info-on-file)
(define-key vip-mode-map "h" 'vip-backward-char)
(define-key vip-mode-map "i" 'vip-insert)
(define-key vip-mode-map "j" 'vip-next-line)
(define-key vip-mode-map "k" 'vip-previous-line)
(define-key vip-mode-map "l" 'vip-forward-char)
(define-key vip-mode-map "m" 'vip-mark-point)
(define-key vip-mode-map "n" 'vip-search-next)
(define-key vip-mode-map "o" 'vip-open-line)
(define-key vip-mode-map "p" 'vip-put-back)
(define-key vip-mode-map "q" 'vip-nil)
(define-key vip-mode-map "r" 'vip-replace-char)
(define-key vip-mode-map "s" 'vip-switch-to-buffer)
(define-key vip-mode-map "t" 'vip-goto-char-forward)
(define-key vip-mode-map "u" 'vip-undo)
(define-key vip-mode-map "v" 'vip-find-file)
(define-key vip-mode-map "w" 'vip-forward-word)
(define-key vip-mode-map "x" 'vip-delete-char)
(define-key vip-mode-map "y" 'vip-command-argument)
(define-key vip-mode-map "zH" 'vip-line-to-top)
(define-key vip-mode-map "zM" 'vip-line-to-middle)
(define-key vip-mode-map "zL" 'vip-line-to-bottom)
(define-key vip-mode-map "z\C-m" 'vip-line-to-top)
(define-key vip-mode-map "z." 'vip-line-to-middle)
(define-key vip-mode-map "z-" 'vip-line-to-bottom)
(define-key vip-mode-map "{" 'vip-backward-paragraph)
(define-key vip-mode-map "|" 'vip-goto-col)
(define-key vip-mode-map "}" 'vip-forward-paragraph)
(define-key vip-mode-map "~" 'vip-nil)
(define-key vip-mode-map "\177" 'vip-delete-backward-char)
(define-key map "{" 'vip-backward-paragraph)
(define-key map "|" 'vip-goto-col)
(define-key map "}" 'vip-forward-paragraph)
(define-key map "~" 'vip-nil)
(define-key map "\177" 'vip-delete-backward-char)
map))
(defun vip-version ()
(interactive)

5
lisp/erc/ChangeLog
View File

@ -1,3 +1,8 @@
2011-02-10 Stefan Monnier <monnier@iro.umontreal.ca>
* erc-list.el (erc-list-menu-mode-map): Move initialization
into declaration.
2011-02-07 Julien Danjou <julien@danjou.info>
* erc-track.el (erc-window-configuration-change): New function.

17
lisp/erc/erc-list.el
View File

@ -117,6 +117,17 @@
(sort-fields col (point-min) (point-max))
(sort-numeric-fields col (point-min) (point-max))))))
(defvar erc-list-menu-mode-map
(let ((map (make-keymap)))
(set-keymap-parent map special-mode-map)
(define-key map "k" 'erc-list-kill)
(define-key map "j" 'erc-list-join)
(define-key map "g" 'erc-list-revert)
(define-key map "n" 'next-line)
(define-key map "p" 'previous-line)
map)
"Local keymap for `erc-list-mode' buffers.")
(defvar erc-list-menu-sort-button-map
(let ((map (make-sparse-keymap)))
(define-key map [header-line mouse-1] 'erc-list-menu-sort-by-column)
@ -146,12 +157,6 @@
(put 'erc-list-menu-mode 'mode-class 'special)
(define-key erc-list-menu-mode-map "k" 'erc-list-kill)
(define-key erc-list-menu-mode-map "j" 'erc-list-join)
(define-key erc-list-menu-mode-map "g" 'erc-list-revert)
(define-key erc-list-menu-mode-map "n" 'next-line)
(define-key erc-list-menu-mode-map "p" 'previous-line)
;; Handle a "322" response. This response tells us about a single
;; channel.
(defun erc-list-handle-322 (proc parsed)

21
lisp/help-mode.el
View File

@ -33,18 +33,19 @@
(require 'view)
(eval-when-compile (require 'easymenu))
(defvar help-mode-map (make-sparse-keymap)
(defvar help-mode-map
(let ((map (make-sparse-keymap)))
(set-keymap-parent map button-buffer-map)
(define-key map [mouse-2] 'help-follow-mouse)
(define-key map "\C-c\C-b" 'help-go-back)
(define-key map "\C-c\C-f" 'help-go-forward)
(define-key map "\C-c\C-c" 'help-follow-symbol)
;; Documentation only, since we use minor-mode-overriding-map-alist.
(define-key map "\r" 'help-follow)
map)
"Keymap for help mode.")
(set-keymap-parent help-mode-map button-buffer-map)
(define-key help-mode-map [mouse-2] 'help-follow-mouse)
(define-key help-mode-map "\C-c\C-b" 'help-go-back)
(define-key help-mode-map "\C-c\C-f" 'help-go-forward)
(define-key help-mode-map "\C-c\C-c" 'help-follow-symbol)
;; Documentation only, since we use minor-mode-overriding-map-alist.
(define-key help-mode-map "\r" 'help-follow)
(easy-menu-define help-mode-menu help-mode-map
"Menu for Help Mode."
'("Help-Mode"

72
lisp/hi-lock.el
View File

@ -238,45 +238,47 @@ a library is being loaded.")
(make-variable-buffer-local 'hi-lock-file-patterns)
(put 'hi-lock-file-patterns 'permanent-local t)
(defvar hi-lock-menu (make-sparse-keymap "Hi Lock")
(defvar hi-lock-menu
(let ((map (make-sparse-keymap "Hi Lock")))
(define-key-after map [highlight-regexp]
'(menu-item "Highlight Regexp..." highlight-regexp
:help "Highlight text matching PATTERN (a regexp)."))
(define-key-after map [highlight-phrase]
'(menu-item "Highlight Phrase..." highlight-phrase
:help "Highlight text matching PATTERN (a regexp processed to match phrases)."))
(define-key-after map [highlight-lines-matching-regexp]
'(menu-item "Highlight Lines..." highlight-lines-matching-regexp
:help "Highlight lines containing match of PATTERN (a regexp)."))
(define-key-after map [unhighlight-regexp]
'(menu-item "Remove Highlighting..." unhighlight-regexp
:help "Remove previously entered highlighting pattern."
:enable hi-lock-interactive-patterns))
(define-key-after map [hi-lock-write-interactive-patterns]
'(menu-item "Patterns to Buffer" hi-lock-write-interactive-patterns
:help "Insert interactively added REGEXPs into buffer at point."
:enable hi-lock-interactive-patterns))
(define-key-after map [hi-lock-find-patterns]
'(menu-item "Patterns from Buffer" hi-lock-find-patterns
:help "Use patterns (if any) near top of buffer."))
map)
"Menu for hi-lock mode.")
(define-key-after hi-lock-menu [highlight-regexp]
'(menu-item "Highlight Regexp..." highlight-regexp
:help "Highlight text matching PATTERN (a regexp)."))
(define-key-after hi-lock-menu [highlight-phrase]
'(menu-item "Highlight Phrase..." highlight-phrase
:help "Highlight text matching PATTERN (a regexp processed to match phrases)."))
(define-key-after hi-lock-menu [highlight-lines-matching-regexp]
'(menu-item "Highlight Lines..." highlight-lines-matching-regexp
:help "Highlight lines containing match of PATTERN (a regexp)."))
(define-key-after hi-lock-menu [unhighlight-regexp]
'(menu-item "Remove Highlighting..." unhighlight-regexp
:help "Remove previously entered highlighting pattern."
:enable hi-lock-interactive-patterns))
(define-key-after hi-lock-menu [hi-lock-write-interactive-patterns]
'(menu-item "Patterns to Buffer" hi-lock-write-interactive-patterns
:help "Insert interactively added REGEXPs into buffer at point."
:enable hi-lock-interactive-patterns))
(define-key-after hi-lock-menu [hi-lock-find-patterns]
'(menu-item "Patterns from Buffer" hi-lock-find-patterns
:help "Use patterns (if any) near top of buffer."))
(defvar hi-lock-map (make-sparse-keymap "Hi Lock")
(defvar hi-lock-map
(let ((map (make-sparse-keymap "Hi Lock")))
(define-key map "\C-xwi" 'hi-lock-find-patterns)
(define-key map "\C-xwl" 'highlight-lines-matching-regexp)
(define-key map "\C-xwp" 'highlight-phrase)
(define-key map "\C-xwh" 'highlight-regexp)
(define-key map "\C-xwr" 'unhighlight-regexp)
(define-key map "\C-xwb" 'hi-lock-write-interactive-patterns)
map)
"Key map for hi-lock.")
(define-key hi-lock-map "\C-xwi" 'hi-lock-find-patterns)
(define-key hi-lock-map "\C-xwl" 'highlight-lines-matching-regexp)
(define-key hi-lock-map "\C-xwp" 'highlight-phrase)
(define-key hi-lock-map "\C-xwh" 'highlight-regexp)
(define-key hi-lock-map "\C-xwr" 'unhighlight-regexp)
(define-key hi-lock-map "\C-xwb" 'hi-lock-write-interactive-patterns)
;; Visible Functions
;;;###autoload

292
lisp/ibuffer.el
View File

@ -384,14 +384,66 @@ directory, like `default-directory'."
(regexp :tag "To")))
:group 'ibuffer)
(defvar ibuffer-mode-groups-popup
(let ((groups-map (make-sparse-keymap "Filter Groups")))
;; Filter groups
(defvar ibuffer-mode-map nil)
(defvar ibuffer-mode-operate-map nil)
(defvar ibuffer-mode-groups-popup nil)
(unless ibuffer-mode-map
(let ((map (make-sparse-keymap))
(operate-map (make-sparse-keymap "Operate"))
(groups-map (make-sparse-keymap "Filter Groups")))
(define-key-after groups-map [filters-to-filter-group]
'(menu-item "Create filter group from current filters..."
ibuffer-filters-to-filter-group
:enable (and (featurep 'ibuf-ext) ibuffer-filtering-qualifiers)))
(define-key-after groups-map [forward-filter-group]
'(menu-item "Move point to the next filter group"
ibuffer-forward-filter-group))
(define-key-after groups-map [backward-filter-group]
'(menu-item "Move point to the previous filter group"
ibuffer-backward-filter-group))
(define-key-after groups-map [jump-to-filter-group]
'(menu-item "Move point to a specific filter group..."
ibuffer-jump-to-filter-group))
(define-key-after groups-map [kill-filter-group]
'(menu-item "Kill filter group named..."
ibuffer-kill-filter-group
:enable (and (featurep 'ibuf-ext) ibuffer-filter-groups)))
(define-key-after groups-map [yank-filter-group]
'(menu-item "Yank last killed filter group before..."
ibuffer-yank-filter-group
:enable (and (featurep 'ibuf-ext) ibuffer-filter-group-kill-ring)))
(define-key-after groups-map [pop-filter-group]
'(menu-item "Remove top filter group"
ibuffer-pop-filter-group
:enable (and (featurep 'ibuf-ext) ibuffer-filter-groups)))
(define-key-after groups-map [clear-filter-groups]
'(menu-item "Remove all filter groups"
ibuffer-clear-filter-groups
:enable (and (featurep 'ibuf-ext) ibuffer-filter-groups)))
(define-key-after groups-map [pop-filter-group]
'(menu-item "Decompose filter group..."
ibuffer-pop-filter-group
:help "\"Unmake\" a filter group"
:enable (and (featurep 'ibuf-ext) ibuffer-filter-groups)))
(define-key-after groups-map [save-filter-groups]
'(menu-item "Save current filter groups permanently..."
ibuffer-save-filter-groups
:enable (and (featurep 'ibuf-ext) ibuffer-filter-groups)
:help "Use a mnemnonic name to store current filter groups"))
(define-key-after groups-map [switch-to-saved-filter-groups]
'(menu-item "Restore permanently saved filters..."
ibuffer-switch-to-saved-filter-groups
:enable (and (featurep 'ibuf-ext) ibuffer-saved-filter-groups)
:help "Replace current filters with a saved stack"))
(define-key-after groups-map [delete-saved-filter-groups]
'(menu-item "Delete permanently saved filter groups..."
ibuffer-delete-saved-filter-groups
:enable (and (featurep 'ibuf-ext) ibuffer-saved-filter-groups)))
(define-key-after groups-map [set-filter-groups-by-mode]
'(menu-item "Set current filter groups to filter by mode"
ibuffer-set-filter-groups-by-mode))
groups-map))
(defvar ibuffer-mode-map
(let ((map (make-keymap)))
(define-key map (kbd "0") 'digit-argument)
(define-key map (kbd "1") 'digit-argument)
(define-key map (kbd "2") 'digit-argument)
@ -545,10 +597,10 @@ directory, like `default-directory'."
'(menu-item "View (other frame)" ibuffer-visit-buffer-other-frame))
(define-key-after map [menu-bar view ibuffer-update]
'(menu-item "Update" ibuffer-update
:help "Regenerate the list of buffers"))
:help "Regenerate the list of buffers"))
(define-key-after map [menu-bar view switch-format]
'(menu-item "Switch display format" ibuffer-switch-format
:help "Toggle between available values of `ibuffer-formats'"))
:help "Toggle between available values of `ibuffer-formats'"))
(define-key-after map [menu-bar view dashes]
'("--"))
@ -562,28 +614,29 @@ directory, like `default-directory'."
'(menu-item "Sort by buffer size" ibuffer-do-sort-by-size))
(define-key-after map [menu-bar view sort do-sort-by-alphabetic]
'(menu-item "Sort lexicographically" ibuffer-do-sort-by-alphabetic
:help "Sort by the alphabetic order of buffer name"))
:help "Sort by the alphabetic order of buffer name"))
(define-key-after map [menu-bar view sort do-sort-by-recency]
'(menu-item "Sort by view time" ibuffer-do-sort-by-recency
:help "Sort by the last time the buffer was displayed"))
:help "Sort by the last time the buffer was displayed"))
(define-key-after map [menu-bar view sort dashes]
'("--"))
(define-key-after map [menu-bar view sort invert-sorting]
'(menu-item "Reverse sorting order" ibuffer-invert-sorting))
(define-key-after map [menu-bar view sort toggle-sorting-mode]
'(menu-item "Switch sorting mode" ibuffer-toggle-sorting-mode
:help "Switch between the various sorting criteria"))
:help "Switch between the various sorting criteria"))
(define-key-after map [menu-bar view filter]
(cons "Filter" (make-sparse-keymap "Filter")))
(define-key-after map [menu-bar view filter filter-disable]
'(menu-item "Disable all filtering" ibuffer-filter-disable
:enable (and (featurep 'ibuf-ext) ibuffer-filtering-qualifiers)))
:enable (and (featurep 'ibuf-ext) ibuffer-filtering-qualifiers)))
(define-key-after map [menu-bar view filter filter-by-mode]
'(menu-item "Add filter by major mode..." ibuffer-filter-by-mode))
(define-key-after map [menu-bar view filter filter-by-mode]
'(menu-item "Add filter by major mode in use..." ibuffer-filter-by-used-mode))
'(menu-item "Add filter by major mode in use..."
ibuffer-filter-by-used-mode))
(define-key-after map [menu-bar view filter filter-by-name]
'(menu-item "Add filter by buffer name..." ibuffer-filter-by-name))
(define-key-after map [menu-bar view filter filter-by-filename]
@ -591,158 +644,112 @@ directory, like `default-directory'."
(define-key-after map [menu-bar view filter filter-by-size-lt]
'(menu-item "Add filter by size less than..." ibuffer-filter-by-size-lt))
(define-key-after map [menu-bar view filter filter-by-size-gt]
'(menu-item "Add filter by size greater than..." ibuffer-filter-by-size-gt))
'(menu-item "Add filter by size greater than..."
ibuffer-filter-by-size-gt))
(define-key-after map [menu-bar view filter filter-by-content]
'(menu-item "Add filter by content (regexp)..." ibuffer-filter-by-content))
'(menu-item "Add filter by content (regexp)..."
ibuffer-filter-by-content))
(define-key-after map [menu-bar view filter filter-by-predicate]
'(menu-item "Add filter by Lisp predicate..." ibuffer-filter-by-predicate))
'(menu-item "Add filter by Lisp predicate..."
ibuffer-filter-by-predicate))
(define-key-after map [menu-bar view filter pop-filter]
'(menu-item "Remove top filter" ibuffer-pop-filter
:enable (and (featurep 'ibuf-ext) ibuffer-filtering-qualifiers)))
:enable (and (featurep 'ibuf-ext) ibuffer-filtering-qualifiers)))
(define-key-after map [menu-bar view filter or-filter]
'(menu-item "OR top two filters" ibuffer-or-filter
:enable (and (featurep 'ibuf-ext) ibuffer-filtering-qualifiers
(cdr ibuffer-filtering-qualifiers))
:help "Create a new filter which is the logical OR of the top two filters"))
:enable (and (featurep 'ibuf-ext) ibuffer-filtering-qualifiers
(cdr ibuffer-filtering-qualifiers))
:help
"Create a new filter which is the logical OR of the top two filters"))
(define-key-after map [menu-bar view filter negate-filter]
'(menu-item "Negate top filter" ibuffer-negate-filter
:enable (and (featurep 'ibuf-ext) ibuffer-filtering-qualifiers)))
:enable (and (featurep 'ibuf-ext) ibuffer-filtering-qualifiers)))
(define-key-after map [menu-bar view filter decompose-filter]
'(menu-item "Decompose top filter" ibuffer-decompose-filter
:enable (and (featurep 'ibuf-ext) (memq (car ibuffer-filtering-qualifiers) '(or saved not)))
:help "Break down a complex filter like OR or NOT"))
:enable (and (featurep 'ibuf-ext)
(memq (car ibuffer-filtering-qualifiers) '(or saved not)))
:help "Break down a complex filter like OR or NOT"))
(define-key-after map [menu-bar view filter exchange-filters]
'(menu-item "Swap top two filters" ibuffer-exchange-filters
:enable (and (featurep 'ibuf-ext) ibuffer-filtering-qualifiers
(cdr ibuffer-filtering-qualifiers))))
:enable (and (featurep 'ibuf-ext) ibuffer-filtering-qualifiers
(cdr ibuffer-filtering-qualifiers))))
(define-key-after map [menu-bar view filter save-filters]
'(menu-item "Save current filters permanently..." ibuffer-save-filters
:enable (and (featurep 'ibuf-ext) ibuffer-filtering-qualifiers)
:help "Use a mnemnonic name to store current filter stack"))
:enable (and (featurep 'ibuf-ext) ibuffer-filtering-qualifiers)
:help "Use a mnemnonic name to store current filter stack"))
(define-key-after map [menu-bar view filter switch-to-saved-filters]
'(menu-item "Restore permanently saved filters..." ibuffer-switch-to-saved-filters
:enable (and (featurep 'ibuf-ext) ibuffer-saved-filters)
:help "Replace current filters with a saved stack"))
'(menu-item "Restore permanently saved filters..."
ibuffer-switch-to-saved-filters
:enable (and (featurep 'ibuf-ext) ibuffer-saved-filters)
:help "Replace current filters with a saved stack"))
(define-key-after map [menu-bar view filter add-saved-filters]
'(menu-item "Add to permanently saved filters..." ibuffer-add-saved-filters
:enable (and (featurep 'ibuf-ext) ibuffer-filtering-qualifiers)
:help "Include already saved stack with current filters"))
'(menu-item "Add to permanently saved filters..."
ibuffer-add-saved-filters
:enable (and (featurep 'ibuf-ext) ibuffer-filtering-qualifiers)
:help "Include already saved stack with current filters"))
(define-key-after map [menu-bar view filter delete-saved-filters]
'(menu-item "Delete permanently saved filters..."
ibuffer-delete-saved-filters
:enable (and (featurep 'ibuf-ext) ibuffer-saved-filters)))
;; Filter groups
(define-key-after groups-map [filters-to-filter-group]
'(menu-item "Create filter group from current filters..."
ibuffer-filters-to-filter-group
:enable (and (featurep 'ibuf-ext) ibuffer-filtering-qualifiers)))
(define-key-after groups-map [forward-filter-group]
'(menu-item "Move point to the next filter group"
ibuffer-forward-filter-group))
(define-key-after groups-map [backward-filter-group]
'(menu-item "Move point to the previous filter group"
ibuffer-backward-filter-group))
(define-key-after groups-map [jump-to-filter-group]
'(menu-item "Move point to a specific filter group..."
ibuffer-jump-to-filter-group))
(define-key-after groups-map [kill-filter-group]
'(menu-item "Kill filter group named..."
ibuffer-kill-filter-group
:enable (and (featurep 'ibuf-ext) ibuffer-filter-groups)))
(define-key-after groups-map [yank-filter-group]
'(menu-item "Yank last killed filter group before..."
ibuffer-yank-filter-group
:enable (and (featurep 'ibuf-ext) ibuffer-filter-group-kill-ring)))
(define-key-after groups-map [pop-filter-group]
'(menu-item "Remove top filter group"
ibuffer-pop-filter-group
:enable (and (featurep 'ibuf-ext) ibuffer-filter-groups)))
(define-key-after groups-map [clear-filter-groups]
'(menu-item "Remove all filter groups"
ibuffer-clear-filter-groups
:enable (and (featurep 'ibuf-ext) ibuffer-filter-groups)))
(define-key-after groups-map [pop-filter-group]
'(menu-item "Decompose filter group..."
ibuffer-pop-filter-group
:help "\"Unmake\" a filter group"
:enable (and (featurep 'ibuf-ext) ibuffer-filter-groups)))
(define-key-after groups-map [save-filter-groups]
'(menu-item "Save current filter groups permanently..."
ibuffer-save-filter-groups
:enable (and (featurep 'ibuf-ext) ibuffer-filter-groups)
:help "Use a mnemnonic name to store current filter groups"))
(define-key-after groups-map [switch-to-saved-filter-groups]
'(menu-item "Restore permanently saved filters..."
ibuffer-switch-to-saved-filter-groups
:enable (and (featurep 'ibuf-ext) ibuffer-saved-filter-groups)
:help "Replace current filters with a saved stack"))
(define-key-after groups-map [delete-saved-filter-groups]
'(menu-item "Delete permanently saved filter groups..."
ibuffer-delete-saved-filter-groups
:enable (and (featurep 'ibuf-ext) ibuffer-saved-filter-groups)))
(define-key-after groups-map [set-filter-groups-by-mode]
'(menu-item "Set current filter groups to filter by mode"
ibuffer-set-filter-groups-by-mode))
ibuffer-delete-saved-filters
:enable (and (featurep 'ibuf-ext) ibuffer-saved-filters)))
(define-key-after map [menu-bar view filter-groups]
(cons "Filter Groups" groups-map))
(cons "Filter Groups" ibuffer-mode-groups-popup))
(define-key-after map [menu-bar view dashes2]
'("--"))
(define-key-after map [menu-bar view diff-with-file]
'(menu-item "Diff with file" ibuffer-diff-with-file
:help "View the differences between this buffer and its file"))
:help "View the differences between this buffer and its file"))
(define-key-after map [menu-bar view auto-mode]
'(menu-item "Toggle Auto Mode" ibuffer-auto-mode
:help "Attempt to automatically update the Ibuffer buffer"))
:help "Attempt to automatically update the Ibuffer buffer"))
(define-key-after map [menu-bar view customize]
'(menu-item "Customize Ibuffer" ibuffer-customize
:help "Use Custom to customize Ibuffer"))
:help "Use Custom to customize Ibuffer"))
(define-key-after map [menu-bar mark]
(cons "Mark" (make-sparse-keymap "Mark")))
(define-key-after map [menu-bar mark toggle-marks]
'(menu-item "Toggle marks" ibuffer-toggle-marks
:help "Unmark marked buffers, and mark unmarked buffers"))
:help "Unmark marked buffers, and mark unmarked buffers"))
(define-key-after map [menu-bar mark mark-forward]
'(menu-item "Mark" ibuffer-mark-forward
:help "Mark the buffer at point"))
:help "Mark the buffer at point"))
(define-key-after map [menu-bar mark unmark-forward]
'(menu-item "Unmark" ibuffer-unmark-forward
:help "Unmark the buffer at point"))
:help "Unmark the buffer at point"))
(define-key-after map [menu-bar mark mark-by-mode]
'(menu-item "Mark by mode..." ibuffer-mark-by-mode
:help "Mark all buffers in a particular major mode"))
:help "Mark all buffers in a particular major mode"))
(define-key-after map [menu-bar mark mark-modified-buffers]
'(menu-item "Mark modified buffers" ibuffer-mark-modified-buffers
:help "Mark all buffers which have been modified"))
:help "Mark all buffers which have been modified"))
(define-key-after map [menu-bar mark mark-unsaved-buffers]
'(menu-item "Mark unsaved buffers" ibuffer-mark-unsaved-buffers
:help "Mark all buffers which have a file and are modified"))
:help "Mark all buffers which have a file and are modified"))
(define-key-after map [menu-bar mark mark-read-only-buffers]
'(menu-item "Mark read-only buffers" ibuffer-mark-read-only-buffers
:help "Mark all buffers which are read-only"))
:help "Mark all buffers which are read-only"))
(define-key-after map [menu-bar mark mark-special-buffers]
'(menu-item "Mark special buffers" ibuffer-mark-special-buffers
:help "Mark all buffers whose name begins with a *"))
:help "Mark all buffers whose name begins with a *"))
(define-key-after map [menu-bar mark mark-dired-buffers]
'(menu-item "Mark dired buffers" ibuffer-mark-dired-buffers
:help "Mark buffers in dired-mode"))
:help "Mark buffers in dired-mode"))
(define-key-after map [menu-bar mark mark-dissociated-buffers]
'(menu-item "Mark dissociated buffers" ibuffer-mark-dissociated-buffers
:help "Mark buffers with a non-existent associated file"))
:help "Mark buffers with a non-existent associated file"))
(define-key-after map [menu-bar mark mark-help-buffers]
'(menu-item "Mark help buffers" ibuffer-mark-help-buffers
:help "Mark buffers in help-mode"))
:help "Mark buffers in help-mode"))
(define-key-after map [menu-bar mark mark-compressed-file-buffers]
'(menu-item "Mark compressed file buffers" ibuffer-mark-compressed-file-buffers
:help "Mark buffers which have a file that is compressed"))
'(menu-item "Mark compressed file buffers"
ibuffer-mark-compressed-file-buffers
:help "Mark buffers which have a file that is compressed"))
(define-key-after map [menu-bar mark mark-old-buffers]
'(menu-item "Mark old buffers" ibuffer-mark-old-buffers
:help "Mark buffers which have not been viewed recently"))
:help "Mark buffers which have not been viewed recently"))
(define-key-after map [menu-bar mark unmark-all]
'(menu-item "Unmark All" ibuffer-unmark-all))
@ -751,16 +758,19 @@ directory, like `default-directory'."
(define-key-after map [menu-bar mark mark-by-name-regexp]
'(menu-item "Mark by buffer name (regexp)..." ibuffer-mark-by-name-regexp
:help "Mark buffers whose name matches a regexp"))
:help "Mark buffers whose name matches a regexp"))
(define-key-after map [menu-bar mark mark-by-mode-regexp]
'(menu-item "Mark by major mode (regexp)..." ibuffer-mark-by-mode-regexp
:help "Mark buffers whose major mode name matches a regexp"))
:help "Mark buffers whose major mode name matches a regexp"))
(define-key-after map [menu-bar mark mark-by-file-name-regexp]
'(menu-item "Mark by file name (regexp)..." ibuffer-mark-by-file-name-regexp
:help "Mark buffers whose file name matches a regexp"))
'(menu-item "Mark by file name (regexp)..."
ibuffer-mark-by-file-name-regexp
:help "Mark buffers whose file name matches a regexp"))
;; Operate map is added later
map))
(defvar ibuffer-mode-operate-map
(let ((operate-map (make-sparse-keymap "Operate")))
(define-key-after operate-map [do-view]
'(menu-item "View" ibuffer-do-view))
(define-key-after operate-map [do-view-other-frame]
@ -769,47 +779,45 @@ directory, like `default-directory'."
'(menu-item "Save" ibuffer-do-save))
(define-key-after operate-map [do-replace-regexp]
'(menu-item "Replace (regexp)..." ibuffer-do-replace-regexp
:help "Replace text inside marked buffers"))
:help "Replace text inside marked buffers"))
(define-key-after operate-map [do-query-replace]
'(menu-item "Query Replace..." ibuffer-do-query-replace
:help "Replace text in marked buffers, asking each time"))
:help "Replace text in marked buffers, asking each time"))
(define-key-after operate-map [do-query-replace-regexp]
'(menu-item "Query Replace (regexp)..." ibuffer-do-query-replace-regexp
:help "Replace text in marked buffers by regexp, asking each time"))
:help "Replace text in marked buffers by regexp, asking each time"))
(define-key-after operate-map [do-print]
'(menu-item "Print" ibuffer-do-print))
(define-key-after operate-map [do-toggle-modified]
'(menu-item "Toggle modification flag" ibuffer-do-toggle-modified))
(define-key-after operate-map [do-revert]
'(menu-item "Revert" ibuffer-do-revert
:help "Revert marked buffers to their associated file"))
:help "Revert marked buffers to their associated file"))
(define-key-after operate-map [do-rename-uniquely]
'(menu-item "Rename Uniquely" ibuffer-do-rename-uniquely
:help "Rename marked buffers to a new, unique name"))
:help "Rename marked buffers to a new, unique name"))
(define-key-after operate-map [do-delete]
'(menu-item "Kill" ibuffer-do-delete))
(define-key-after operate-map [do-occur]
'(menu-item "List lines matching..." ibuffer-do-occur
:help "View all lines in marked buffers matching a regexp"))
:help "View all lines in marked buffers matching a regexp"))
(define-key-after operate-map [do-shell-command-pipe]
'(menu-item "Pipe to shell command..." ibuffer-do-shell-command-pipe
:help "For each marked buffer, send its contents to a shell command"))
:help "For each marked buffer, send its contents to a shell command"))
(define-key-after operate-map [do-shell-command-pipe-replace]
'(menu-item "Pipe to shell command (replace)..." ibuffer-do-shell-command-pipe-replace
:help "For each marked buffer, replace its contents with output of shell command"))
:help "For each marked buffer, replace its contents with output of shell command"))
(define-key-after operate-map [do-shell-command-file]
'(menu-item "Shell command on buffer's file..." ibuffer-do-shell-command-file
:help "For each marked buffer, run a shell command with its file as argument"))
:help "For each marked buffer, run a shell command with its file as argument"))
(define-key-after operate-map [do-eval]
'(menu-item "Eval..." ibuffer-do-eval
:help "Evaluate a Lisp form in each marked buffer"))
:help "Evaluate a Lisp form in each marked buffer"))
(define-key-after operate-map [do-view-and-eval]
'(menu-item "Eval (viewing buffer)..." ibuffer-do-view-and-eval
:help "Evaluate a Lisp form in each marked buffer while viewing it"))
:help "Evaluate a Lisp form in each marked buffer while viewing it"))
(setq ibuffer-mode-map map
ibuffer-mode-operate-map operate-map
ibuffer-mode-groups-popup (copy-keymap groups-map))))
operate-map))
(define-key ibuffer-mode-groups-popup [kill-filter-group]
'(menu-item "Kill filter group"
@ -1559,9 +1567,8 @@ If point is on a group name, this function operates on that group."
from-end-p))
(setq strlen (length str))
(setq str
,(ibuffer-compile-make-eliding-form 'str
elide
from-end-p)))))
,(ibuffer-compile-make-eliding-form
'str elide from-end-p)))))
;; Now, put these forms together with the rest of the code.
(let ((callform
;; Is this an "inline" column? This means we have
@ -1575,16 +1582,18 @@ If point is on a group name, this function operates on that group."
;; You're not expected to understand this. Hell, I
;; don't even understand it, and I wrote it five
;; minutes ago.
(insertgenfn (ibuffer-aif (get sym 'ibuffer-column-summarizer)
;; I really, really wish Emacs Lisp had closures.
(lambda (arg sym)
`(insert
(let ((ret ,arg))
(put ',sym 'ibuffer-column-summary
(cons ret (get ',sym 'ibuffer-column-summary)))
ret)))
(lambda (arg sym)
`(insert ,arg))))
(insertgenfn
(ibuffer-aif (get sym 'ibuffer-column-summarizer)
;; I really, really wish Emacs Lisp had closures.
(lambda (arg sym)
`(insert
(let ((ret ,arg))
(put ',sym 'ibuffer-column-summary
(cons ret (get ',sym
'ibuffer-column-summary)))
ret)))
(lambda (arg sym)
`(insert ,arg))))
(mincompform `(< strlen ,(if (integerp min)
min
'min)))
@ -1617,7 +1626,8 @@ If point is on a group name, this function operates on that group."
`(strlen (length str))))
outforms)
(setq outforms
(append outforms (list (funcall insertgenfn 'str sym)))))
(append outforms
(list (funcall insertgenfn 'str sym)))))
;; The simple case; just insert the string.
(push (funcall insertgenfn callform sym) outforms))
;; Finally, return a `let' form which binds the

47
lisp/kmacro.el
View File

@ -916,34 +916,35 @@ without repeating the prefix."
(defvar kmacro-step-edit-help) ;; kmacro step edit help enabled
(defvar kmacro-step-edit-num-input-keys) ;; to ignore duplicate pre-command hook
(defvar kmacro-step-edit-map (make-sparse-keymap)
(defvar kmacro-step-edit-map
(let ((map (make-sparse-keymap)))
;; query-replace-map answers include: `act', `skip', `act-and-show',
;; `exit', `act-and-exit', `edit', `delete-and-edit', `recenter',
;; `automatic', `backup', `exit-prefix', and `help'.")
;; Also: `quit', `edit-replacement'
(set-keymap-parent map query-replace-map)
(define-key map "\t" 'act-repeat)
(define-key map [tab] 'act-repeat)
(define-key map "\C-k" 'skip-rest)
(define-key map "c" 'automatic)
(define-key map "f" 'skip-keep)
(define-key map "q" 'quit)
(define-key map "d" 'skip)
(define-key map "\C-d" 'skip)
(define-key map "i" 'insert)
(define-key map "I" 'insert-1)
(define-key map "r" 'replace)
(define-key map "R" 'replace-1)
(define-key map "a" 'append)
(define-key map "A" 'append-end)
map)
"Keymap that defines the responses to questions in `kmacro-step-edit-macro'.
This keymap is an extension to the `query-replace-map', allowing the
following additional answers: `insert', `insert-1', `replace', `replace-1',
`append', `append-end', `act-repeat', `skip-end', `skip-keep'.")
;; query-replace-map answers include: `act', `skip', `act-and-show',
;; `exit', `act-and-exit', `edit', `delete-and-edit', `recenter',
;; `automatic', `backup', `exit-prefix', and `help'.")
;; Also: `quit', `edit-replacement'
(set-keymap-parent kmacro-step-edit-map query-replace-map)
(define-key kmacro-step-edit-map "\t" 'act-repeat)
(define-key kmacro-step-edit-map [tab] 'act-repeat)
(define-key kmacro-step-edit-map "\C-k" 'skip-rest)
(define-key kmacro-step-edit-map "c" 'automatic)
(define-key kmacro-step-edit-map "f" 'skip-keep)
(define-key kmacro-step-edit-map "q" 'quit)
(define-key kmacro-step-edit-map "d" 'skip)
(define-key kmacro-step-edit-map "\C-d" 'skip)
(define-key kmacro-step-edit-map "i" 'insert)
(define-key kmacro-step-edit-map "I" 'insert-1)
(define-key kmacro-step-edit-map "r" 'replace)
(define-key kmacro-step-edit-map "R" 'replace-1)
(define-key kmacro-step-edit-map "a" 'append)
(define-key kmacro-step-edit-map "A" 'append-end)
(defvar kmacro-step-edit-prefix-commands
'(universal-argument universal-argument-more universal-argument-minus
digit-argument negative-argument)

2
lisp/mail/rmail.el
View File

@ -4418,7 +4418,7 @@ If prefix argument REVERSE is non-nil, sorts in reverse order.
;;;### (autoloads (rmail-summary-by-senders rmail-summary-by-topic
;;;;;; rmail-summary-by-regexp rmail-summary-by-recipients rmail-summary-by-labels
;;;;;; rmail-summary) "rmailsum" "rmailsum.el" "76a7ae570a4fa96a9233d0276f52f515")
;;;;;; rmail-summary) "rmailsum" "rmailsum.el" "adad96c9eb13cae4bae0769f731d8784")
;;; Generated autoloads from rmailsum.el
(autoload 'rmail-summary "rmailsum" "\

392
lisp/mail/rmailsum.el
View File

@ -64,7 +64,196 @@ Setting this option to nil might speed up the generation of summaries."
"Overlay used to highlight the current message in the Rmail summary.")
(put 'rmail-summary-overlay 'permanent-local t)
(defvar rmail-summary-mode-map nil
(defvar rmail-summary-mode-map
(let ((map (make-keymap)))
(suppress-keymap map)
(define-key map [mouse-2] 'rmail-summary-mouse-goto-message)
(define-key map "a" 'rmail-summary-add-label)
(define-key map "b" 'rmail-summary-bury)
(define-key map "c" 'rmail-summary-continue)
(define-key map "d" 'rmail-summary-delete-forward)
(define-key map "\C-d" 'rmail-summary-delete-backward)
(define-key map "e" 'rmail-summary-edit-current-message)
(define-key map "f" 'rmail-summary-forward)
(define-key map "g" 'rmail-summary-get-new-mail)
(define-key map "h" 'rmail-summary)
(define-key map "i" 'rmail-summary-input)
(define-key map "j" 'rmail-summary-goto-msg)
(define-key map "\C-m" 'rmail-summary-goto-msg)
(define-key map "k" 'rmail-summary-kill-label)
(define-key map "l" 'rmail-summary-by-labels)
(define-key map "\e\C-h" 'rmail-summary)
(define-key map "\e\C-l" 'rmail-summary-by-labels)
(define-key map "\e\C-r" 'rmail-summary-by-recipients)
(define-key map "\e\C-s" 'rmail-summary-by-regexp)
;; `f' for "from".
(define-key map "\e\C-f" 'rmail-summary-by-senders)
(define-key map "\e\C-t" 'rmail-summary-by-topic)
(define-key map "m" 'rmail-summary-mail)
(define-key map "\M-m" 'rmail-summary-retry-failure)
(define-key map "n" 'rmail-summary-next-msg)
(define-key map "\en" 'rmail-summary-next-all)
(define-key map "\e\C-n" 'rmail-summary-next-labeled-message)
(define-key map "o" 'rmail-summary-output)
(define-key map "\C-o" 'rmail-summary-output-as-seen)
(define-key map "p" 'rmail-summary-previous-msg)
(define-key map "\ep" 'rmail-summary-previous-all)
(define-key map "\e\C-p" 'rmail-summary-previous-labeled-message)
(define-key map "q" 'rmail-summary-quit)
(define-key map "Q" 'rmail-summary-wipe)
(define-key map "r" 'rmail-summary-reply)
(define-key map "s" 'rmail-summary-expunge-and-save)
;; See rms's comment in rmail.el
;; (define-key map "\er" 'rmail-summary-search-backward)
(define-key map "\es" 'rmail-summary-search)
(define-key map "t" 'rmail-summary-toggle-header)
(define-key map "u" 'rmail-summary-undelete)
(define-key map "\M-u" 'rmail-summary-undelete-many)
(define-key map "x" 'rmail-summary-expunge)
(define-key map "w" 'rmail-summary-output-body)
(define-key map "v" 'rmail-mime)
(define-key map "." 'rmail-summary-beginning-of-message)
(define-key map "/" 'rmail-summary-end-of-message)
(define-key map "<" 'rmail-summary-first-message)
(define-key map ">" 'rmail-summary-last-message)
(define-key map " " 'rmail-summary-scroll-msg-up)
(define-key map "\177" 'rmail-summary-scroll-msg-down)
(define-key map "?" 'describe-mode)
(define-key map "\C-c\C-n" 'rmail-summary-next-same-subject)
(define-key map "\C-c\C-p" 'rmail-summary-previous-same-subject)
(define-key map "\C-c\C-s\C-d" 'rmail-summary-sort-by-date)
(define-key map "\C-c\C-s\C-s" 'rmail-summary-sort-by-subject)
(define-key map "\C-c\C-s\C-a" 'rmail-summary-sort-by-author)
(define-key map "\C-c\C-s\C-r" 'rmail-summary-sort-by-recipient)
(define-key map "\C-c\C-s\C-c" 'rmail-summary-sort-by-correspondent)
(define-key map "\C-c\C-s\C-l" 'rmail-summary-sort-by-lines)
(define-key map "\C-c\C-s\C-k" 'rmail-summary-sort-by-labels)
(define-key map "\C-x\C-s" 'rmail-summary-save-buffer)
;; Menu bar bindings.
(define-key map [menu-bar] (make-sparse-keymap))
(define-key map [menu-bar classify]
(cons "Classify" (make-sparse-keymap "Classify")))
(define-key map [menu-bar classify output-menu]
'("Output (Rmail Menu)..." . rmail-summary-output-menu))
(define-key map [menu-bar classify input-menu]
'("Input Rmail File (menu)..." . rmail-input-menu))
(define-key map [menu-bar classify input-menu]
'(nil))
(define-key map [menu-bar classify output-menu]
'(nil))
(define-key map [menu-bar classify output-body]
'("Output body..." . rmail-summary-output-body))
(define-key map [menu-bar classify output-inbox]
'("Output..." . rmail-summary-output))
(define-key map [menu-bar classify output]
'("Output as seen..." . rmail-summary-output-as-seen))
(define-key map [menu-bar classify kill-label]
'("Kill Label..." . rmail-summary-kill-label))
(define-key map [menu-bar classify add-label]
'("Add Label..." . rmail-summary-add-label))
(define-key map [menu-bar summary]
(cons "Summary" (make-sparse-keymap "Summary")))
(define-key map [menu-bar summary senders]
'("By Senders..." . rmail-summary-by-senders))
(define-key map [menu-bar summary labels]
'("By Labels..." . rmail-summary-by-labels))
(define-key map [menu-bar summary recipients]
'("By Recipients..." . rmail-summary-by-recipients))
(define-key map [menu-bar summary topic]
'("By Topic..." . rmail-summary-by-topic))
(define-key map [menu-bar summary regexp]
'("By Regexp..." . rmail-summary-by-regexp))
(define-key map [menu-bar summary all]
'("All" . rmail-summary))
(define-key map [menu-bar mail]
(cons "Mail" (make-sparse-keymap "Mail")))
(define-key map [menu-bar mail rmail-summary-get-new-mail]
'("Get New Mail" . rmail-summary-get-new-mail))
(define-key map [menu-bar mail lambda]
'("----"))
(define-key map [menu-bar mail continue]
'("Continue" . rmail-summary-continue))
(define-key map [menu-bar mail resend]
'("Re-send..." . rmail-summary-resend))
(define-key map [menu-bar mail forward]
'("Forward" . rmail-summary-forward))
(define-key map [menu-bar mail retry]
'("Retry" . rmail-summary-retry-failure))
(define-key map [menu-bar mail reply]
'("Reply" . rmail-summary-reply))
(define-key map [menu-bar mail mail]
'("Mail" . rmail-summary-mail))
(define-key map [menu-bar delete]
(cons "Delete" (make-sparse-keymap "Delete")))
(define-key map [menu-bar delete expunge/save]
'("Expunge/Save" . rmail-summary-expunge-and-save))
(define-key map [menu-bar delete expunge]
'("Expunge" . rmail-summary-expunge))
(define-key map [menu-bar delete undelete]
'("Undelete" . rmail-summary-undelete))
(define-key map [menu-bar delete delete]
'("Delete" . rmail-summary-delete-forward))
(define-key map [menu-bar move]
(cons "Move" (make-sparse-keymap "Move")))
(define-key map [menu-bar move search-back]
'("Search Back..." . rmail-summary-search-backward))
(define-key map [menu-bar move search]
'("Search..." . rmail-summary-search))
(define-key map [menu-bar move previous]
'("Previous Nondeleted" . rmail-summary-previous-msg))
(define-key map [menu-bar move next]
'("Next Nondeleted" . rmail-summary-next-msg))
(define-key map [menu-bar move last]
'("Last" . rmail-summary-last-message))
(define-key map [menu-bar move first]
'("First" . rmail-summary-first-message))
(define-key map [menu-bar move previous]
'("Previous" . rmail-summary-previous-all))
(define-key map [menu-bar move next]
'("Next" . rmail-summary-next-all))
map)
"Keymap used in Rmail summary mode.")
;; Entry points for making a summary buffer.
@ -990,207 +1179,6 @@ Search, the `unseen' attribute is restored.")
(save-excursion
(switch-to-buffer rmail-buffer)
(save-buffer))))
(if rmail-summary-mode-map
nil
(setq rmail-summary-mode-map (make-keymap))
(suppress-keymap rmail-summary-mode-map)
(define-key rmail-summary-mode-map [mouse-2] 'rmail-summary-mouse-goto-message)
(define-key rmail-summary-mode-map "a" 'rmail-summary-add-label)
(define-key rmail-summary-mode-map "b" 'rmail-summary-bury)
(define-key rmail-summary-mode-map "c" 'rmail-summary-continue)
(define-key rmail-summary-mode-map "d" 'rmail-summary-delete-forward)
(define-key rmail-summary-mode-map "\C-d" 'rmail-summary-delete-backward)
(define-key rmail-summary-mode-map "e" 'rmail-summary-edit-current-message)
(define-key rmail-summary-mode-map "f" 'rmail-summary-forward)
(define-key rmail-summary-mode-map "g" 'rmail-summary-get-new-mail)
(define-key rmail-summary-mode-map "h" 'rmail-summary)
(define-key rmail-summary-mode-map "i" 'rmail-summary-input)
(define-key rmail-summary-mode-map "j" 'rmail-summary-goto-msg)
(define-key rmail-summary-mode-map "\C-m" 'rmail-summary-goto-msg)
(define-key rmail-summary-mode-map "k" 'rmail-summary-kill-label)
(define-key rmail-summary-mode-map "l" 'rmail-summary-by-labels)
(define-key rmail-summary-mode-map "\e\C-h" 'rmail-summary)
(define-key rmail-summary-mode-map "\e\C-l" 'rmail-summary-by-labels)
(define-key rmail-summary-mode-map "\e\C-r" 'rmail-summary-by-recipients)
(define-key rmail-summary-mode-map "\e\C-s" 'rmail-summary-by-regexp)
;; `f' for "from".
(define-key rmail-summary-mode-map "\e\C-f" 'rmail-summary-by-senders)
(define-key rmail-summary-mode-map "\e\C-t" 'rmail-summary-by-topic)
(define-key rmail-summary-mode-map "m" 'rmail-summary-mail)
(define-key rmail-summary-mode-map "\M-m" 'rmail-summary-retry-failure)
(define-key rmail-summary-mode-map "n" 'rmail-summary-next-msg)
(define-key rmail-summary-mode-map "\en" 'rmail-summary-next-all)
(define-key rmail-summary-mode-map "\e\C-n" 'rmail-summary-next-labeled-message)
(define-key rmail-summary-mode-map "o" 'rmail-summary-output)
(define-key rmail-summary-mode-map "\C-o" 'rmail-summary-output-as-seen)
(define-key rmail-summary-mode-map "p" 'rmail-summary-previous-msg)
(define-key rmail-summary-mode-map "\ep" 'rmail-summary-previous-all)
(define-key rmail-summary-mode-map "\e\C-p" 'rmail-summary-previous-labeled-message)
(define-key rmail-summary-mode-map "q" 'rmail-summary-quit)
(define-key rmail-summary-mode-map "Q" 'rmail-summary-wipe)
(define-key rmail-summary-mode-map "r" 'rmail-summary-reply)
(define-key rmail-summary-mode-map "s" 'rmail-summary-expunge-and-save)
;; See rms's comment in rmail.el
;;; (define-key rmail-summary-mode-map "\er" 'rmail-summary-search-backward)
(define-key rmail-summary-mode-map "\es" 'rmail-summary-search)
(define-key rmail-summary-mode-map "t" 'rmail-summary-toggle-header)
(define-key rmail-summary-mode-map "u" 'rmail-summary-undelete)
(define-key rmail-summary-mode-map "\M-u" 'rmail-summary-undelete-many)
(define-key rmail-summary-mode-map "x" 'rmail-summary-expunge)
(define-key rmail-summary-mode-map "w" 'rmail-summary-output-body)
(define-key rmail-summary-mode-map "v" 'rmail-mime)
(define-key rmail-summary-mode-map "." 'rmail-summary-beginning-of-message)
(define-key rmail-summary-mode-map "/" 'rmail-summary-end-of-message)
(define-key rmail-summary-mode-map "<" 'rmail-summary-first-message)
(define-key rmail-summary-mode-map ">" 'rmail-summary-last-message)
(define-key rmail-summary-mode-map " " 'rmail-summary-scroll-msg-up)
(define-key rmail-summary-mode-map "\177" 'rmail-summary-scroll-msg-down)
(define-key rmail-summary-mode-map "?" 'describe-mode)
(define-key rmail-summary-mode-map "\C-c\C-n" 'rmail-summary-next-same-subject)
(define-key rmail-summary-mode-map "\C-c\C-p" 'rmail-summary-previous-same-subject)
(define-key rmail-summary-mode-map "\C-c\C-s\C-d"
'rmail-summary-sort-by-date)
(define-key rmail-summary-mode-map "\C-c\C-s\C-s"
'rmail-summary-sort-by-subject)
(define-key rmail-summary-mode-map "\C-c\C-s\C-a"
'rmail-summary-sort-by-author)
(define-key rmail-summary-mode-map "\C-c\C-s\C-r"
'rmail-summary-sort-by-recipient)
(define-key rmail-summary-mode-map "\C-c\C-s\C-c"
'rmail-summary-sort-by-correspondent)
(define-key rmail-summary-mode-map "\C-c\C-s\C-l"
'rmail-summary-sort-by-lines)
(define-key rmail-summary-mode-map "\C-c\C-s\C-k"
'rmail-summary-sort-by-labels)
(define-key rmail-summary-mode-map "\C-x\C-s" 'rmail-summary-save-buffer)
)
;;; Menu bar bindings.
(define-key rmail-summary-mode-map [menu-bar] (make-sparse-keymap))
(define-key rmail-summary-mode-map [menu-bar classify]
(cons "Classify" (make-sparse-keymap "Classify")))
(define-key rmail-summary-mode-map [menu-bar classify output-menu]
'("Output (Rmail Menu)..." . rmail-summary-output-menu))
(define-key rmail-summary-mode-map [menu-bar classify input-menu]
'("Input Rmail File (menu)..." . rmail-input-menu))
(define-key rmail-summary-mode-map [menu-bar classify input-menu]
'(nil))
(define-key rmail-summary-mode-map [menu-bar classify output-menu]
'(nil))
(define-key rmail-summary-mode-map [menu-bar classify output-body]
'("Output body..." . rmail-summary-output-body))
(define-key rmail-summary-mode-map [menu-bar classify output-inbox]
'("Output..." . rmail-summary-output))
(define-key rmail-summary-mode-map [menu-bar classify output]
'("Output as seen..." . rmail-summary-output-as-seen))
(define-key rmail-summary-mode-map [menu-bar classify kill-label]
'("Kill Label..." . rmail-summary-kill-label))
(define-key rmail-summary-mode-map [menu-bar classify add-label]
'("Add Label..." . rmail-summary-add-label))
(define-key rmail-summary-mode-map [menu-bar summary]
(cons "Summary" (make-sparse-keymap "Summary")))
(define-key rmail-summary-mode-map [menu-bar summary senders]
'("By Senders..." . rmail-summary-by-senders))
(define-key rmail-summary-mode-map [menu-bar summary labels]
'("By Labels..." . rmail-summary-by-labels))
(define-key rmail-summary-mode-map [menu-bar summary recipients]
'("By Recipients..." . rmail-summary-by-recipients))
(define-key rmail-summary-mode-map [menu-bar summary topic]
'("By Topic..." . rmail-summary-by-topic))
(define-key rmail-summary-mode-map [menu-bar summary regexp]
'("By Regexp..." . rmail-summary-by-regexp))
(define-key rmail-summary-mode-map [menu-bar summary all]
'("All" . rmail-summary))
(define-key rmail-summary-mode-map [menu-bar mail]
(cons "Mail" (make-sparse-keymap "Mail")))
(define-key rmail-summary-mode-map [menu-bar mail rmail-summary-get-new-mail]
'("Get New Mail" . rmail-summary-get-new-mail))
(define-key rmail-summary-mode-map [menu-bar mail lambda]
'("----"))
(define-key rmail-summary-mode-map [menu-bar mail continue]
'("Continue" . rmail-summary-continue))
(define-key rmail-summary-mode-map [menu-bar mail resend]
'("Re-send..." . rmail-summary-resend))
(define-key rmail-summary-mode-map [menu-bar mail forward]
'("Forward" . rmail-summary-forward))
(define-key rmail-summary-mode-map [menu-bar mail retry]
'("Retry" . rmail-summary-retry-failure))
(define-key rmail-summary-mode-map [menu-bar mail reply]
'("Reply" . rmail-summary-reply))
(define-key rmail-summary-mode-map [menu-bar mail mail]
'("Mail" . rmail-summary-mail))
(define-key rmail-summary-mode-map [menu-bar delete]
(cons "Delete" (make-sparse-keymap "Delete")))
(define-key rmail-summary-mode-map [menu-bar delete expunge/save]
'("Expunge/Save" . rmail-summary-expunge-and-save))
(define-key rmail-summary-mode-map [menu-bar delete expunge]
'("Expunge" . rmail-summary-expunge))
(define-key rmail-summary-mode-map [menu-bar delete undelete]
'("Undelete" . rmail-summary-undelete))
(define-key rmail-summary-mode-map [menu-bar delete delete]
'("Delete" . rmail-summary-delete-forward))
(define-key rmail-summary-mode-map [menu-bar move]
(cons "Move" (make-sparse-keymap "Move")))
(define-key rmail-summary-mode-map [menu-bar move search-back]
'("Search Back..." . rmail-summary-search-backward))
(define-key rmail-summary-mode-map [menu-bar move search]
'("Search..." . rmail-summary-search))
(define-key rmail-summary-mode-map [menu-bar move previous]
'("Previous Nondeleted" . rmail-summary-previous-msg))
(define-key rmail-summary-mode-map [menu-bar move next]
'("Next Nondeleted" . rmail-summary-next-msg))
(define-key rmail-summary-mode-map [menu-bar move last]
'("Last" . rmail-summary-last-message))
(define-key rmail-summary-mode-map [menu-bar move first]
'("First" . rmail-summary-first-message))
(define-key rmail-summary-mode-map [menu-bar move previous]
'("Previous" . rmail-summary-previous-all))
(define-key rmail-summary-mode-map [menu-bar move next]
'("Next" . rmail-summary-next-all))
(defun rmail-summary-mouse-goto-message (event)
"Select the message whose summary line you click on."

2325
lisp/menu-bar.el
View File

File diff suppressed because it is too large Load Diff

16
lisp/net/net-utils.el
View File

@ -490,6 +490,11 @@ If your system's ping continues until interrupted, you can try setting
(autoload 'comint-mode "comint" nil t)
(defvar nslookup-mode-map
(let ((map (make-sparse-keymap)))
(define-key map "\t" 'comint-dynamic-complete)
map))
;; Using a derived mode gives us keymaps, hooks, etc.
(define-derived-mode nslookup-mode comint-mode "Nslookup"
"Major mode for interacting with the nslookup program."
@ -499,8 +504,6 @@ If your system's ping continues until interrupted, you can try setting
(setq comint-prompt-regexp nslookup-prompt-regexp)
(setq comint-input-autoexpand t))
(define-key nslookup-mode-map "\t" 'comint-dynamic-complete)
;;;###autoload
(defun dns-lookup-host (host)
"Lookup the DNS information for HOST (name or IP address)."
@ -556,6 +559,12 @@ If your system's ping continues until interrupted, you can try setting
(list host)))
(pop-to-buffer buf)))
(defvar ftp-mode-map
(let ((map (make-sparse-keymap)))
;; Occasionally useful
(define-key map "\t" 'comint-dynamic-complete)
map))
(define-derived-mode ftp-mode comint-mode "FTP"
"Major mode for interacting with the ftp program."
(setq comint-prompt-regexp ftp-prompt-regexp)
@ -571,9 +580,6 @@ If your system's ping continues until interrupted, you can try setting
(add-hook 'comint-output-filter-functions 'comint-watch-for-password-prompt
nil t)))
;; Occasionally useful
(define-key ftp-mode-map "\t" 'comint-dynamic-complete)
(defun smbclient (host service)
"Connect to SERVICE on HOST via SMB."
(interactive

215
lisp/net/newst-plainview.el
View File

@ -378,6 +378,107 @@ images."
;;; Newsticker mode
;; ======================================================================
;; newsticker menu
(defvar newsticker-menu
(let ((map (make-sparse-keymap "Newsticker")))
(define-key map [newsticker-browse-url]
'("Browse URL for item at point" . newsticker-browse-url))
(define-key map [newsticker-separator-1]
'("--"))
(define-key map [newsticker-buffer-update]
'("Update buffer" . newsticker-buffer-update))
(define-key map [newsticker-separator-2]
'("--"))
(define-key map [newsticker-get-all-news]
'("Get news from all feeds" . newsticker-get-all-news))
(define-key map [newsticker-get-news-at-point]
'("Get news from feed at point" . newsticker-get-news-at-point))
(define-key map [newsticker-separator-3]
'("--"))
(define-key map [newsticker-mark-all-items-as-read]
'("Mark all items as read" . newsticker-mark-all-items-as-read))
(define-key map [newsticker-mark-all-items-at-point-as-read]
'("Mark all items in feed at point as read" .
newsticker-mark-all-items-at-point-as-read))
(define-key map [newsticker-mark-item-at-point-as-read]
'("Mark item at point as read" .
newsticker-mark-item-at-point-as-read))
(define-key map [newsticker-mark-item-at-point-as-immortal]
'("Toggle immortality for item at point" .
newsticker-mark-item-at-point-as-immortal))
(define-key map [newsticker-separator-4]
'("--"))
(define-key map [newsticker-toggle-auto-narrow-to-item]
'("Narrow to single item" . newsticker-toggle-auto-narrow-to-item))
(define-key map [newsticker-toggle-auto-narrow-to-feed]
'("Narrow to single news feed" . newsticker-toggle-auto-narrow-to-feed))
(define-key map [newsticker-hide-old-items]
'("Hide old items" . newsticker-hide-old-items))
(define-key map [newsticker-show-old-items]
'("Show old items" . newsticker-show-old-items))
(define-key map [newsticker-next-item]
'("Go to next item" . newsticker-next-item))
(define-key map [newsticker-previous-item]
'("Go to previous item" . newsticker-previous-item))
map))
(defvar newsticker-mode-map
(let ((map (make-keymap)))
(define-key map "sO" 'newsticker-show-old-items)
(define-key map "hO" 'newsticker-hide-old-items)
(define-key map "sa" 'newsticker-show-all-desc)
(define-key map "ha" 'newsticker-hide-all-desc)
(define-key map "sf" 'newsticker-show-feed-desc)
(define-key map "hf" 'newsticker-hide-feed-desc)
(define-key map "so" 'newsticker-show-old-item-desc)
(define-key map "ho" 'newsticker-hide-old-item-desc)
(define-key map "sn" 'newsticker-show-new-item-desc)
(define-key map "hn" 'newsticker-hide-new-item-desc)
(define-key map "se" 'newsticker-show-entry)
(define-key map "he" 'newsticker-hide-entry)
(define-key map "sx" 'newsticker-show-extra)
(define-key map "hx" 'newsticker-hide-extra)
(define-key map " " 'scroll-up)
(define-key map "q" 'newsticker-close-buffer)
(define-key map "p" 'newsticker-previous-item)
(define-key map "P" 'newsticker-previous-new-item)
(define-key map "F" 'newsticker-previous-feed)
(define-key map "\t" 'newsticker-next-item)
(define-key map "n" 'newsticker-next-item)
(define-key map "N" 'newsticker-next-new-item)
(define-key map "f" 'newsticker-next-feed)
(define-key map "M" 'newsticker-mark-all-items-as-read)
(define-key map "m"
'newsticker-mark-all-items-at-point-as-read-and-redraw)
(define-key map "o"
'newsticker-mark-item-at-point-as-read)
(define-key map "O"
'newsticker-mark-all-items-at-point-as-read)
(define-key map "G" 'newsticker-get-all-news)
(define-key map "g" 'newsticker-get-news-at-point)
(define-key map "u" 'newsticker-buffer-update)
(define-key map "U" 'newsticker-buffer-force-update)
(define-key map "a" 'newsticker-add-url)
(define-key map "i"
'newsticker-mark-item-at-point-as-immortal)
(define-key map "xf"
'newsticker-toggle-auto-narrow-to-feed)
(define-key map "xi"
'newsticker-toggle-auto-narrow-to-item)
;; Bind menu to mouse.
(define-key map [down-mouse-3] newsticker-menu)
;; Put menu in menu-bar.
(define-key map [menu-bar Newsticker]
(cons "Newsticker" newsticker-menu))
map))
(define-derived-mode newsticker-mode fundamental-mode
"NewsTicker"
"Viewing news feeds in Emacs."
@ -414,114 +515,16 @@ images."
(add-to-invisibility-spec 'extra))
(newsticker--buffer-set-uptodate nil))
;; refine its mode-map
(define-key newsticker-mode-map "sO" 'newsticker-show-old-items)
(define-key newsticker-mode-map "hO" 'newsticker-hide-old-items)
(define-key newsticker-mode-map "sa" 'newsticker-show-all-desc)
(define-key newsticker-mode-map "ha" 'newsticker-hide-all-desc)
(define-key newsticker-mode-map "sf" 'newsticker-show-feed-desc)
(define-key newsticker-mode-map "hf" 'newsticker-hide-feed-desc)
(define-key newsticker-mode-map "so" 'newsticker-show-old-item-desc)
(define-key newsticker-mode-map "ho" 'newsticker-hide-old-item-desc)
(define-key newsticker-mode-map "sn" 'newsticker-show-new-item-desc)
(define-key newsticker-mode-map "hn" 'newsticker-hide-new-item-desc)
(define-key newsticker-mode-map "se" 'newsticker-show-entry)
(define-key newsticker-mode-map "he" 'newsticker-hide-entry)
(define-key newsticker-mode-map "sx" 'newsticker-show-extra)
(define-key newsticker-mode-map "hx" 'newsticker-hide-extra)
(define-key newsticker-mode-map " " 'scroll-up)
(define-key newsticker-mode-map "q" 'newsticker-close-buffer)
(define-key newsticker-mode-map "p" 'newsticker-previous-item)
(define-key newsticker-mode-map "P" 'newsticker-previous-new-item)
(define-key newsticker-mode-map "F" 'newsticker-previous-feed)
(define-key newsticker-mode-map "\t" 'newsticker-next-item)
(define-key newsticker-mode-map "n" 'newsticker-next-item)
(define-key newsticker-mode-map "N" 'newsticker-next-new-item)
(define-key newsticker-mode-map "f" 'newsticker-next-feed)
(define-key newsticker-mode-map "M" 'newsticker-mark-all-items-as-read)
(define-key newsticker-mode-map "m"
'newsticker-mark-all-items-at-point-as-read-and-redraw)
(define-key newsticker-mode-map "o"
'newsticker-mark-item-at-point-as-read)
(define-key newsticker-mode-map "O"
'newsticker-mark-all-items-at-point-as-read)
(define-key newsticker-mode-map "G" 'newsticker-get-all-news)
(define-key newsticker-mode-map "g" 'newsticker-get-news-at-point)
(define-key newsticker-mode-map "u" 'newsticker-buffer-update)
(define-key newsticker-mode-map "U" 'newsticker-buffer-force-update)
(define-key newsticker-mode-map "a" 'newsticker-add-url)
(define-key newsticker-mode-map "i"
'newsticker-mark-item-at-point-as-immortal)
(define-key newsticker-mode-map "xf"
'newsticker-toggle-auto-narrow-to-feed)
(define-key newsticker-mode-map "xi"
'newsticker-toggle-auto-narrow-to-item)
;; maps for the clickable portions
(defvar newsticker--url-keymap (make-sparse-keymap)
(defvar newsticker--url-keymap
(let ((map (make-sparse-keymap)))
(define-key map [mouse-1] 'newsticker-mouse-browse-url)
(define-key map [mouse-2] 'newsticker-mouse-browse-url)
(define-key map "\n" 'newsticker-browse-url)
(define-key map "\C-m" 'newsticker-browse-url)
(define-key map [(control return)] 'newsticker-handle-url)
map)
"Key map for click-able headings in the newsticker buffer.")
(define-key newsticker--url-keymap [mouse-1]
'newsticker-mouse-browse-url)
(define-key newsticker--url-keymap [mouse-2]
'newsticker-mouse-browse-url)
(define-key newsticker--url-keymap "\n"
'newsticker-browse-url)
(define-key newsticker--url-keymap "\C-m"
'newsticker-browse-url)
(define-key newsticker--url-keymap [(control return)]
'newsticker-handle-url)
;; newsticker menu
(defvar newsticker-menu (make-sparse-keymap "Newsticker"))
(define-key newsticker-menu [newsticker-browse-url]
'("Browse URL for item at point" . newsticker-browse-url))
(define-key newsticker-menu [newsticker-separator-1]
'("--"))
(define-key newsticker-menu [newsticker-buffer-update]
'("Update buffer" . newsticker-buffer-update))
(define-key newsticker-menu [newsticker-separator-2]
'("--"))
(define-key newsticker-menu [newsticker-get-all-news]
'("Get news from all feeds" . newsticker-get-all-news))
(define-key newsticker-menu [newsticker-get-news-at-point]
'("Get news from feed at point" . newsticker-get-news-at-point))
(define-key newsticker-menu [newsticker-separator-3]
'("--"))
(define-key newsticker-menu [newsticker-mark-all-items-as-read]
'("Mark all items as read" . newsticker-mark-all-items-as-read))
(define-key newsticker-menu [newsticker-mark-all-items-at-point-as-read]
'("Mark all items in feed at point as read" .
newsticker-mark-all-items-at-point-as-read))
(define-key newsticker-menu [newsticker-mark-item-at-point-as-read]
'("Mark item at point as read" .
newsticker-mark-item-at-point-as-read))
(define-key newsticker-menu [newsticker-mark-item-at-point-as-immortal]
'("Toggle immortality for item at point" .
newsticker-mark-item-at-point-as-immortal))
(define-key newsticker-menu [newsticker-separator-4]
'("--"))
(define-key newsticker-menu [newsticker-toggle-auto-narrow-to-item]
'("Narrow to single item" . newsticker-toggle-auto-narrow-to-item))
(define-key newsticker-menu [newsticker-toggle-auto-narrow-to-feed]
'("Narrow to single news feed" . newsticker-toggle-auto-narrow-to-feed))
(define-key newsticker-menu [newsticker-hide-old-items]
'("Hide old items" . newsticker-hide-old-items))
(define-key newsticker-menu [newsticker-show-old-items]
'("Show old items" . newsticker-show-old-items))
(define-key newsticker-menu [newsticker-next-item]
'("Go to next item" . newsticker-next-item))
(define-key newsticker-menu [newsticker-previous-item]
'("Go to previous item" . newsticker-previous-item))
;; bind menu to mouse
(define-key newsticker-mode-map [down-mouse-3] newsticker-menu)
;; Put menu in menu-bar
(define-key newsticker-mode-map [menu-bar Newsticker]
(cons "Newsticker" newsticker-menu))
;; ======================================================================

89
lisp/net/rcirc.el
View File

@ -861,41 +861,43 @@ IRC command completion is performed only if '/' is the first input char."
(interactive "zCoding system for outgoing messages: ")
(setq rcirc-encode-coding-system coding-system))
(defvar rcirc-mode-map (make-sparse-keymap)
(defvar rcirc-mode-map
(let ((map (make-sparse-keymap)))
(define-key map (kbd "RET") 'rcirc-send-input)
(define-key map (kbd "M-p") 'rcirc-insert-prev-input)
(define-key map (kbd "M-n") 'rcirc-insert-next-input)
(define-key map (kbd "TAB") 'rcirc-complete)
(define-key map (kbd "C-c C-b") 'rcirc-browse-url)
(define-key map (kbd "C-c C-c") 'rcirc-edit-multiline)
(define-key map (kbd "C-c C-j") 'rcirc-cmd-join)
(define-key map (kbd "C-c C-k") 'rcirc-cmd-kick)
(define-key map (kbd "C-c C-l") 'rcirc-toggle-low-priority)
(define-key map (kbd "C-c C-d") 'rcirc-cmd-mode)
(define-key map (kbd "C-c C-m") 'rcirc-cmd-msg)
(define-key map (kbd "C-c C-r") 'rcirc-cmd-nick) ; rename
(define-key map (kbd "C-c C-o") 'rcirc-omit-mode)
(define-key map (kbd "M-o") 'rcirc-omit-mode)
(define-key map (kbd "C-c C-p") 'rcirc-cmd-part)
(define-key map (kbd "C-c C-q") 'rcirc-cmd-query)
(define-key map (kbd "C-c C-t") 'rcirc-cmd-topic)
(define-key map (kbd "C-c C-n") 'rcirc-cmd-names)
(define-key map (kbd "C-c C-w") 'rcirc-cmd-whois)
(define-key map (kbd "C-c C-x") 'rcirc-cmd-quit)
(define-key map (kbd "C-c TAB") ; C-i
'rcirc-toggle-ignore-buffer-activity)
(define-key map (kbd "C-c C-s") 'rcirc-switch-to-server-buffer)
(define-key map (kbd "C-c C-a") 'rcirc-jump-to-first-unread-line)
map)
"Keymap for rcirc mode.")
(define-key rcirc-mode-map (kbd "RET") 'rcirc-send-input)
(define-key rcirc-mode-map (kbd "M-p") 'rcirc-insert-prev-input)
(define-key rcirc-mode-map (kbd "M-n") 'rcirc-insert-next-input)
(define-key rcirc-mode-map (kbd "TAB") 'rcirc-complete)
(define-key rcirc-mode-map (kbd "C-c C-b") 'rcirc-browse-url)
(define-key rcirc-mode-map (kbd "C-c C-c") 'rcirc-edit-multiline)
(define-key rcirc-mode-map (kbd "C-c C-j") 'rcirc-cmd-join)
(define-key rcirc-mode-map (kbd "C-c C-k") 'rcirc-cmd-kick)
(define-key rcirc-mode-map (kbd "C-c C-l") 'rcirc-toggle-low-priority)
(define-key rcirc-mode-map (kbd "C-c C-d") 'rcirc-cmd-mode)
(define-key rcirc-mode-map (kbd "C-c C-m") 'rcirc-cmd-msg)
(define-key rcirc-mode-map (kbd "C-c C-r") 'rcirc-cmd-nick) ; rename
(define-key rcirc-mode-map (kbd "C-c C-o") 'rcirc-omit-mode)
(define-key rcirc-mode-map (kbd "M-o") 'rcirc-omit-mode)
(define-key rcirc-mode-map (kbd "C-c C-p") 'rcirc-cmd-part)
(define-key rcirc-mode-map (kbd "C-c C-q") 'rcirc-cmd-query)
(define-key rcirc-mode-map (kbd "C-c C-t") 'rcirc-cmd-topic)
(define-key rcirc-mode-map (kbd "C-c C-n") 'rcirc-cmd-names)
(define-key rcirc-mode-map (kbd "C-c C-w") 'rcirc-cmd-whois)
(define-key rcirc-mode-map (kbd "C-c C-x") 'rcirc-cmd-quit)
(define-key rcirc-mode-map (kbd "C-c TAB") ; C-i
'rcirc-toggle-ignore-buffer-activity)
(define-key rcirc-mode-map (kbd "C-c C-s") 'rcirc-switch-to-server-buffer)
(define-key rcirc-mode-map (kbd "C-c C-a") 'rcirc-jump-to-first-unread-line)
(defvar rcirc-browse-url-map (make-sparse-keymap)
(defvar rcirc-browse-url-map
(let ((map (make-sparse-keymap)))
(define-key map (kbd "RET") 'rcirc-browse-url-at-point)
(define-key map (kbd "<mouse-2>") 'rcirc-browse-url-at-mouse)
(define-key map [follow-link] 'mouse-face)
map)
"Keymap used for browsing URLs in `rcirc-mode'.")
(define-key rcirc-browse-url-map (kbd "RET") 'rcirc-browse-url-at-point)
(define-key rcirc-browse-url-map (kbd "<mouse-2>") 'rcirc-browse-url-at-mouse)
(define-key rcirc-browse-url-map [follow-link] 'mouse-face)
(defvar rcirc-short-buffer-name nil
"Generated abbreviation to use to indicate buffer activity.")
@ -1216,16 +1218,14 @@ Create the buffer if it doesn't exist."
(and (> pos 0) (goto-char pos))
(message "Type C-c C-c to return text to %s, or C-c C-k to cancel" parent))))
(defvar rcirc-multiline-minor-mode-map (make-sparse-keymap)
(defvar rcirc-multiline-minor-mode-map
(let ((map (make-sparse-keymap)))
(define-key map (kbd "C-c C-c") 'rcirc-multiline-minor-submit)
(define-key map (kbd "C-x C-s") 'rcirc-multiline-minor-submit)
(define-key map (kbd "C-c C-k") 'rcirc-multiline-minor-cancel)
(define-key map (kbd "ESC ESC ESC") 'rcirc-multiline-minor-cancel)
map)
"Keymap for multiline mode in rcirc.")
(define-key rcirc-multiline-minor-mode-map
(kbd "C-c C-c") 'rcirc-multiline-minor-submit)
(define-key rcirc-multiline-minor-mode-map
(kbd "C-x C-s") 'rcirc-multiline-minor-submit)
(define-key rcirc-multiline-minor-mode-map
(kbd "C-c C-k") 'rcirc-multiline-minor-cancel)
(define-key rcirc-multiline-minor-mode-map
(kbd "ESC ESC ESC") 'rcirc-multiline-minor-cancel)
(define-minor-mode rcirc-multiline-minor-mode
"Minor mode for editing multiple lines in rcirc."
@ -1742,12 +1742,13 @@ This function does not alter the INPUT string."
(mapconcat 'identity sorted sep)))
;;; activity tracking
(defvar rcirc-track-minor-mode-map (make-sparse-keymap)
(defvar rcirc-track-minor-mode-map
(let ((map (make-sparse-keymap)))
(define-key map (kbd "C-c C-@") 'rcirc-next-active-buffer)
(define-key map (kbd "C-c C-SPC") 'rcirc-next-active-buffer)
map)
"Keymap for rcirc track minor mode.")
(define-key rcirc-track-minor-mode-map (kbd "C-c C-@") 'rcirc-next-active-buffer)
(define-key rcirc-track-minor-mode-map (kbd "C-c C-SPC") 'rcirc-next-active-buffer)
;;;###autoload
(define-minor-mode rcirc-track-minor-mode
"Global minor mode for tracking activity in rcirc buffers."

5
lisp/org/ChangeLog
View File

@ -1,3 +1,8 @@
2011-02-10 Stefan Monnier <monnier@iro.umontreal.ca>
* org-remember.el (org-remember-mode-map):
* org-src.el (org-src-mode-map): Move initialization into declaration.
2011-01-13 Stefan Monnier <monnier@iro.umontreal.ca>
* org-remember.el (org-remember-mode):

8
lisp/org/org-remember.el
View File

@ -214,7 +214,11 @@ The remember buffer is still current when this hook runs."
:group 'org-remember
:type 'hook)
(defvar org-remember-mode-map (make-sparse-keymap)
(defvar org-remember-mode-map
(let ((map (make-sparse-keymap)))
(define-key map "\C-c\C-c" 'org-remember-finalize)
(define-key map "\C-c\C-k" 'org-remember-kill)
map)
"Keymap for `org-remember-mode', a minor mode.
Use this map to set additional keybindings for when Org-mode is used
for a Remember buffer.")
@ -224,8 +228,6 @@ for a Remember buffer.")
(define-minor-mode org-remember-mode
"Minor mode for special key bindings in a remember buffer."
nil " Rem" org-remember-mode-map)
(define-key org-remember-mode-map "\C-c\C-c" 'org-remember-finalize)
(define-key org-remember-mode-map "\C-c\C-k" 'org-remember-kill)
(defcustom org-remember-clock-out-on-exit 'query
"Non-nil means stop the clock when exiting a clocking remember buffer.

6
lisp/org/org-src.el
View File

@ -169,8 +169,10 @@ For example, there is no ocaml-mode in Emacs, but the mode to use is
;;; Editing source examples
(defvar org-src-mode-map (make-sparse-keymap))
(define-key org-src-mode-map "\C-c'" 'org-edit-src-exit)
(defvar org-src-mode-map
(let ((map (make-sparse-keymap)))
(define-key map "\C-c'" 'org-edit-src-exit)
map))
(defvar org-edit-src-force-single-line nil)
(defvar org-edit-src-from-org-mode nil)

26
lisp/play/gametree.el
View File

@ -565,6 +565,20 @@ buffer, it is replaced by the new value. See the documentation for
(gametree-hack-file-layout))
nil)
;;;; Key bindings
(defvar gametree-mode-map
(let ((map (make-sparse-keymap)))
(define-key map "\C-c\C-j" 'gametree-break-line-here)
(define-key map "\C-c\C-v" 'gametree-insert-new-leaf)
(define-key map "\C-c\C-m" 'gametree-merge-line)
(define-key map "\C-c\C-r " 'gametree-layout-to-register)
(define-key map "\C-c\C-r/" 'gametree-layout-to-register)
(define-key map "\C-c\C-rj" 'gametree-apply-register-layout)
(define-key map "\C-c\C-y" 'gametree-save-and-hack-layout)
(define-key map "\C-c;" 'gametree-insert-score)
(define-key map "\C-c^" 'gametree-compute-and-insert-score)
map))
(define-derived-mode gametree-mode outline-mode "GameTree"
"Major mode for managing game analysis trees.
Useful to postal and email chess (and, it is hoped, also checkers, go,
@ -575,18 +589,6 @@ shogi, etc.) players, it is a slightly modified version of Outline mode.
(make-local-variable 'write-contents-hooks)
(add-hook 'write-contents-hooks 'gametree-save-and-hack-layout))
;;;; Key bindings
(define-key gametree-mode-map "\C-c\C-j" 'gametree-break-line-here)
(define-key gametree-mode-map "\C-c\C-v" 'gametree-insert-new-leaf)
(define-key gametree-mode-map "\C-c\C-m" 'gametree-merge-line)
(define-key gametree-mode-map "\C-c\C-r " 'gametree-layout-to-register)
(define-key gametree-mode-map "\C-c\C-r/" 'gametree-layout-to-register)
(define-key gametree-mode-map "\C-c\C-rj" 'gametree-apply-register-layout)
(define-key gametree-mode-map "\C-c\C-y" 'gametree-save-and-hack-layout)
(define-key gametree-mode-map "\C-c;" 'gametree-insert-score)
(define-key gametree-mode-map "\C-c^" 'gametree-compute-and-insert-score)
;;;; Goodies for mousing users
(and (fboundp 'track-mouse)
(defun gametree-mouse-break-line-here (event)

105
lisp/play/handwrite.el
View File

@ -80,8 +80,24 @@
(defvar handwrite-psindex 0
"The index of the PostScript buffer.")
(defvar menu-bar-handwrite-map (make-sparse-keymap "Handwrite functions."))
(fset 'menu-bar-handwrite-map (symbol-value 'menu-bar-handwrite-map))
(defvar menu-bar-handwrite-map
(let ((map (make-sparse-keymap "Handwrite functions.")))
(define-key map [numbering]
'(menu-item "Page numbering" handwrite-set-pagenumber
:button (:toggle . handwrite-pagenumbering)))
(define-key map [handwrite-separator2] '("----" . nil))
(define-key map [10pt] '(menu-item "10 pt" handwrite-10pt
:button (:radio . (eq handwrite-fontsize 10))))
(define-key map [11pt] '(menu-item "11 pt" handwrite-11pt
:button (:radio . (eq handwrite-fontsize 11))))
(define-key map [12pt] '(menu-item "12 pt" handwrite-12pt
:button (:radio . (eq handwrite-fontsize 12))))
(define-key map [13pt] '(menu-item "13 pt" handwrite-13pt
:button (:radio . (eq handwrite-fontsize 13))))
(define-key map [handwrite-separator1] '("----" . nil))
(define-key map [handwrite] '("Write by hand" . handwrite))
map))
(fset 'menu-bar-handwrite-map menu-bar-handwrite-map)
;; User definable variables
@ -135,10 +151,10 @@
The functions `handwrite-10pt', `handwrite-11pt', `handwrite-12pt'
and `handwrite-13pt' set up for various sizes of output.
Variables: handwrite-linespace (default 12)
handwrite-fontsize (default 11)
handwrite-numlines (default 60)
handwrite-pagenumbering (default nil)"
Variables: `handwrite-linespace' (default 12)
`handwrite-fontsize' (default 11)
`handwrite-numlines' (default 60)
`handwrite-pagenumbering' (default nil)"
(interactive)
(let
((pmin) ; thanks, Havard
@ -258,7 +274,8 @@ Variables: handwrite-linespace (default 12)
"Toggle the value of `handwrite-pagenumbering'."
(interactive)
(if handwrite-pagenumbering
(handwrite-set-pagenumber-off)(handwrite-set-pagenumber-on)))
(handwrite-set-pagenumber-off)
(handwrite-set-pagenumber-on)))
(defun handwrite-10pt ()
"Specify 10-point output for `handwrite.
@ -268,14 +285,6 @@ values for `handwrite-linespace' and `handwrite-numlines'."
(setq handwrite-fontsize 10)
(setq handwrite-linespace 11)
(setq handwrite-numlines handwrite-10pt-numlines)
(define-key menu-bar-handwrite-map [10pt]
'("10 pt *" . handwrite-10pt))
(define-key menu-bar-handwrite-map [11pt]
'("11 pt" . handwrite-11pt))
(define-key menu-bar-handwrite-map [12pt]
'("12 pt" . handwrite-12pt))
(define-key menu-bar-handwrite-map [13pt]
'("13 pt" . handwrite-13pt))
(message "Handwrite output size set to 10 points"))
@ -287,14 +296,6 @@ values for `handwrite-linespace' and `handwrite-numlines'."
(setq handwrite-fontsize 11)
(setq handwrite-linespace 12)
(setq handwrite-numlines handwrite-11pt-numlines)
(define-key menu-bar-handwrite-map [10pt]
'("10 pt" . handwrite-10pt))
(define-key menu-bar-handwrite-map [11pt]
'("11 pt *" . handwrite-11pt))
(define-key menu-bar-handwrite-map [12pt]
'("12 pt" . handwrite-12pt))
(define-key menu-bar-handwrite-map [13pt]
'("13 pt" . handwrite-13pt))
(message "Handwrite output size set to 11 points"))
(defun handwrite-12pt ()
@ -305,14 +306,6 @@ values for `handwrite-linespace' and `handwrite-numlines'."
(setq handwrite-fontsize 12)
(setq handwrite-linespace 13)
(setq handwrite-numlines handwrite-12pt-numlines)
(define-key menu-bar-handwrite-map [10pt]
'("10 pt" . handwrite-10pt))
(define-key menu-bar-handwrite-map [11pt]
'("11 pt" . handwrite-11pt))
(define-key menu-bar-handwrite-map [12pt]
'("12 pt *" . handwrite-12pt))
(define-key menu-bar-handwrite-map [13pt]
'("13 pt" . handwrite-13pt))
(message "Handwrite output size set to 12 points"))
(defun handwrite-13pt ()
@ -323,14 +316,6 @@ values for `handwrite-linespace' and `handwrite-numlines'."
(setq handwrite-fontsize 13)
(setq handwrite-linespace 14)
(setq handwrite-numlines handwrite-13pt-numlines)
(define-key menu-bar-handwrite-map [10pt]
'("10 pt" . handwrite-10pt))
(define-key menu-bar-handwrite-map [11pt]
'("11 pt" . handwrite-11pt))
(define-key menu-bar-handwrite-map [12pt]
'("12 pt" . handwrite-12pt))
(define-key menu-bar-handwrite-map [13pt]
'("13 pt *" . handwrite-13pt))
(message "Handwrite output size set to 13 points"))
@ -1263,62 +1248,24 @@ end
;;Sets page numbering off
(defun handwrite-set-pagenumber-off ()
(setq handwrite-pagenumbering nil)
(define-key menu-bar-handwrite-map
[numbering]
'("Page numbering Off" . handwrite-set-pagenumber))
(message "page numbering off"))
;;Sets page numbering on
(defun handwrite-set-pagenumber-on ()
(setq handwrite-pagenumbering t)
(define-key menu-bar-handwrite-map
[numbering]
'("Page numbering On" . handwrite-set-pagenumber))
(message "page numbering on" ))
;; Key bindings
;;; I'd rather not fill up the menu bar menus with
;;; lots of random miscellaneous features. -- rms.
;; I'd rather not fill up the menu bar menus with
;; lots of random miscellaneous features. -- rms.
;;;(define-key-after
;;; (lookup-key global-map [menu-bar edit])
;;; [handwrite]
;;; '("Write by hand" . menu-bar-handwrite-map)
;;; 'spell)
(define-key menu-bar-handwrite-map [numbering]
'("Page numbering Off" . handwrite-set-pagenumber))
(define-key menu-bar-handwrite-map [10pt]
'("10 pt" . handwrite-10pt))
(define-key menu-bar-handwrite-map [11pt]
'("11 pt *" . handwrite-11pt))
(define-key menu-bar-handwrite-map [12pt]
'("12 pt" . handwrite-12pt))
(define-key menu-bar-handwrite-map [13pt]
'("13 pt" . handwrite-13pt))
(define-key menu-bar-handwrite-map [handwrite]
'("Write by hand" . handwrite))
(define-key-after
(lookup-key menu-bar-handwrite-map [ ])
[handwrite-separator1]
'("----" . nil)
'handwrite)
(define-key-after
(lookup-key menu-bar-handwrite-map [ ])
[handwrite-separator2]
'("----" . nil)
'10pt)
(provide 'handwrite)

24
lisp/play/pong.el
View File

@ -190,21 +190,23 @@
;;; Initialize maps
(defvar pong-mode-map
(make-sparse-keymap 'pong-mode-map) "Modemap for pong-mode.")
(let ((map (make-sparse-keymap 'pong-mode-map)))
(define-key map [left] 'pong-move-left)
(define-key map [right] 'pong-move-right)
(define-key map [up] 'pong-move-up)
(define-key map [down] 'pong-move-down)
(define-key map pong-left-key 'pong-move-left)
(define-key map pong-right-key 'pong-move-right)
(define-key map pong-up-key 'pong-move-up)
(define-key map pong-down-key 'pong-move-down)
(define-key map pong-quit-key 'pong-quit)
(define-key map pong-pause-key 'pong-pause)
map)
"Modemap for pong-mode.")
(defvar pong-null-map
(make-sparse-keymap 'pong-null-map) "Null map for pong-mode.")
(define-key pong-mode-map [left] 'pong-move-left)
(define-key pong-mode-map [right] 'pong-move-right)
(define-key pong-mode-map [up] 'pong-move-up)
(define-key pong-mode-map [down] 'pong-move-down)
(define-key pong-mode-map pong-left-key 'pong-move-left)
(define-key pong-mode-map pong-right-key 'pong-move-right)
(define-key pong-mode-map pong-up-key 'pong-move-up)
(define-key pong-mode-map pong-down-key 'pong-move-down)
(define-key pong-mode-map pong-quit-key 'pong-quit)
(define-key pong-mode-map pong-pause-key 'pong-pause)
;;; Fun stuff -- The code

23
lisp/play/snake.el
View File

@ -174,21 +174,22 @@ and then start moving it leftwards.")
;; ;;;;;;;;;;;;; keymaps ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defvar snake-mode-map
(make-sparse-keymap 'snake-mode-map))
(let ((map (make-sparse-keymap 'snake-mode-map)))
(define-key snake-mode-map "n" 'snake-start-game)
(define-key snake-mode-map "q" 'snake-end-game)
(define-key snake-mode-map "p" 'snake-pause-game)
(define-key map "n" 'snake-start-game)
(define-key map "q" 'snake-end-game)
(define-key map "p" 'snake-pause-game)
(define-key snake-mode-map [left] 'snake-move-left)
(define-key snake-mode-map [right] 'snake-move-right)
(define-key snake-mode-map [up] 'snake-move-up)
(define-key snake-mode-map [down] 'snake-move-down)
(define-key map [left] 'snake-move-left)
(define-key map [right] 'snake-move-right)
(define-key map [up] 'snake-move-up)
(define-key map [down] 'snake-move-down)
map))
(defvar snake-null-map
(make-sparse-keymap 'snake-null-map))
(define-key snake-null-map "n" 'snake-start-game)
(let ((map (make-sparse-keymap 'snake-null-map)))
(define-key map "n" 'snake-start-game)
map))
;; ;;;;;;;;;;;;;;;; game functions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

78
lisp/play/solitaire.el
View File

@ -41,6 +41,49 @@
:type 'hook
:group 'solitaire)
(defvar solitaire-mode-map
(let ((map (make-sparse-keymap)))
(set-keymap-parent map special-mode-map)
(define-key map "\C-f" 'solitaire-right)
(define-key map "\C-b" 'solitaire-left)
(define-key map "\C-p" 'solitaire-up)
(define-key map "\C-n" 'solitaire-down)
(define-key map "\r" 'solitaire-move)
(define-key map [remap undo] 'solitaire-undo)
(define-key map " " 'solitaire-do-check)
(define-key map [right] 'solitaire-right)
(define-key map [left] 'solitaire-left)
(define-key map [up] 'solitaire-up)
(define-key map [down] 'solitaire-down)
(define-key map [S-right] 'solitaire-move-right)
(define-key map [S-left] 'solitaire-move-left)
(define-key map [S-up] 'solitaire-move-up)
(define-key map [S-down] 'solitaire-move-down)
(define-key map [kp-6] 'solitaire-right)
(define-key map [kp-4] 'solitaire-left)
(define-key map [kp-8] 'solitaire-up)
(define-key map [kp-2] 'solitaire-down)
(define-key map [kp-5] 'solitaire-center-point)
(define-key map [S-kp-6] 'solitaire-move-right)
(define-key map [S-kp-4] 'solitaire-move-left)
(define-key map [S-kp-8] 'solitaire-move-up)
(define-key map [S-kp-2] 'solitaire-move-down)
(define-key map [kp-enter] 'solitaire-move)
(define-key map [kp-0] 'solitaire-undo)
;; spoil it with s ;)
(define-key map [?s] 'solitaire-solve)
;; (define-key map [kp-0] 'solitaire-hint) - Not yet provided ;)
map)
"Keymap for playing Solitaire.")
;; Solitaire mode is suitable only for specially formatted data.
(put 'solitaire-mode 'mode-class 'special)
@ -54,41 +97,6 @@ The usual mnemonic keys move the cursor around the board; in addition,
(setq truncate-lines t)
(setq show-trailing-whitespace nil))
(define-key solitaire-mode-map "\C-f" 'solitaire-right)
(define-key solitaire-mode-map "\C-b" 'solitaire-left)
(define-key solitaire-mode-map "\C-p" 'solitaire-up)
(define-key solitaire-mode-map "\C-n" 'solitaire-down)
(define-key solitaire-mode-map "\r" 'solitaire-move)
(define-key solitaire-mode-map [remap undo] 'solitaire-undo)
(define-key solitaire-mode-map " " 'solitaire-do-check)
(define-key solitaire-mode-map [right] 'solitaire-right)
(define-key solitaire-mode-map [left] 'solitaire-left)
(define-key solitaire-mode-map [up] 'solitaire-up)
(define-key solitaire-mode-map [down] 'solitaire-down)
(define-key solitaire-mode-map [S-right] 'solitaire-move-right)
(define-key solitaire-mode-map [S-left] 'solitaire-move-left)
(define-key solitaire-mode-map [S-up] 'solitaire-move-up)
(define-key solitaire-mode-map [S-down] 'solitaire-move-down)
(define-key solitaire-mode-map [kp-6] 'solitaire-right)
(define-key solitaire-mode-map [kp-4] 'solitaire-left)
(define-key solitaire-mode-map [kp-8] 'solitaire-up)
(define-key solitaire-mode-map [kp-2] 'solitaire-down)
(define-key solitaire-mode-map [kp-5] 'solitaire-center-point)
(define-key solitaire-mode-map [S-kp-6] 'solitaire-move-right)
(define-key solitaire-mode-map [S-kp-4] 'solitaire-move-left)
(define-key solitaire-mode-map [S-kp-8] 'solitaire-move-up)
(define-key solitaire-mode-map [S-kp-2] 'solitaire-move-down)
(define-key solitaire-mode-map [kp-enter] 'solitaire-move)
(define-key solitaire-mode-map [kp-0] 'solitaire-undo)
;; spoil it with s ;)
(define-key solitaire-mode-map [?s] 'solitaire-solve)
;; (define-key map [kp-0] 'solitaire-hint) - Not yet provided ;)
(defvar solitaire-stones 0
"Counter for the stones that are still there.")

65
lisp/progmodes/gdb-mi.el
View File

@ -2983,24 +2983,26 @@ DOC is an optional documentation string."
map)
"Keymap to select format in the header line.")
(defvar gdb-memory-format-menu (make-sparse-keymap "Format")
"Menu of display formats in the header line.")
(defvar gdb-memory-format-menu
(let ((map (make-sparse-keymap "Format")))
(define-key gdb-memory-format-menu [binary]
'(menu-item "Binary" gdb-memory-format-binary
:button (:radio . (equal gdb-memory-format "t"))))
(define-key gdb-memory-format-menu [octal]
'(menu-item "Octal" gdb-memory-format-octal
:button (:radio . (equal gdb-memory-format "o"))))
(define-key gdb-memory-format-menu [unsigned]
'(menu-item "Unsigned Decimal" gdb-memory-format-unsigned
:button (:radio . (equal gdb-memory-format "u"))))
(define-key gdb-memory-format-menu [signed]
'(menu-item "Signed Decimal" gdb-memory-format-signed
:button (:radio . (equal gdb-memory-format "d"))))
(define-key gdb-memory-format-menu [hexadecimal]
'(menu-item "Hexadecimal" gdb-memory-format-hexadecimal
:button (:radio . (equal gdb-memory-format "x"))))
(define-key map [binary]
'(menu-item "Binary" gdb-memory-format-binary
:button (:radio . (equal gdb-memory-format "t"))))
(define-key map [octal]
'(menu-item "Octal" gdb-memory-format-octal
:button (:radio . (equal gdb-memory-format "o"))))
(define-key map [unsigned]
'(menu-item "Unsigned Decimal" gdb-memory-format-unsigned
:button (:radio . (equal gdb-memory-format "u"))))
(define-key map [signed]
'(menu-item "Signed Decimal" gdb-memory-format-signed
:button (:radio . (equal gdb-memory-format "d"))))
(define-key map [hexadecimal]
'(menu-item "Hexadecimal" gdb-memory-format-hexadecimal
:button (:radio . (equal gdb-memory-format "x"))))
map)
"Menu of display formats in the header line.")
(defun gdb-memory-format-menu (event)
(interactive "@e")
@ -3061,22 +3063,23 @@ DOC is an optional documentation string."
map)
"Keymap to select units in the header line.")
(defvar gdb-memory-unit-menu (make-sparse-keymap "Unit")
(defvar gdb-memory-unit-menu
(let ((map (make-sparse-keymap "Unit")))
(define-key map [giantwords]
'(menu-item "Giant words" gdb-memory-unit-giant
:button (:radio . (equal gdb-memory-unit 8))))
(define-key map [words]
'(menu-item "Words" gdb-memory-unit-word
:button (:radio . (equal gdb-memory-unit 4))))
(define-key map [halfwords]
'(menu-item "Halfwords" gdb-memory-unit-halfword
:button (:radio . (equal gdb-memory-unit 2))))
(define-key map [bytes]
'(menu-item "Bytes" gdb-memory-unit-byte
:button (:radio . (equal gdb-memory-unit 1))))
map)
"Menu of units in the header line.")
(define-key gdb-memory-unit-menu [giantwords]
'(menu-item "Giant words" gdb-memory-unit-giant
:button (:radio . (equal gdb-memory-unit 8))))
(define-key gdb-memory-unit-menu [words]
'(menu-item "Words" gdb-memory-unit-word
:button (:radio . (equal gdb-memory-unit 4))))
(define-key gdb-memory-unit-menu [halfwords]
'(menu-item "Halfwords" gdb-memory-unit-halfword
:button (:radio . (equal gdb-memory-unit 2))))
(define-key gdb-memory-unit-menu [bytes]
'(menu-item "Bytes" gdb-memory-unit-byte
:button (:radio . (equal gdb-memory-unit 1))))
(defun gdb-memory-unit-menu (event)
(interactive "@e")
(x-popup-menu event gdb-memory-unit-menu))

31
lisp/progmodes/idlw-help.el
View File

@ -219,23 +219,24 @@ support."
;; Define the key bindings for the Help application
(defvar idlwave-help-mode-map (make-sparse-keymap)
(defvar idlwave-help-mode-map
(let ((map (make-sparse-keymap)))
(define-key map "q" 'idlwave-help-quit)
(define-key map "w" 'widen)
(define-key map "\C-m" (lambda (arg)
(interactive "p")
(scroll-up arg)))
(define-key map " " 'scroll-up)
(define-key map [delete] 'scroll-down)
(define-key map "h" 'idlwave-help-find-header)
(define-key map "H" 'idlwave-help-find-first-header)
(define-key map "." 'idlwave-help-toggle-header-match-and-def)
(define-key map "F" 'idlwave-help-fontify)
(define-key map "\M-?" 'idlwave-help-return-to-calling-frame)
(define-key map "x" 'idlwave-help-return-to-calling-frame)
map)
"The keymap used in `idlwave-help-mode'.")
(define-key idlwave-help-mode-map "q" 'idlwave-help-quit)
(define-key idlwave-help-mode-map "w" 'widen)
(define-key idlwave-help-mode-map "\C-m" (lambda (arg)
(interactive "p")
(scroll-up arg)))
(define-key idlwave-help-mode-map " " 'scroll-up)
(define-key idlwave-help-mode-map [delete] 'scroll-down)
(define-key idlwave-help-mode-map "h" 'idlwave-help-find-header)
(define-key idlwave-help-mode-map "H" 'idlwave-help-find-first-header)
(define-key idlwave-help-mode-map "." 'idlwave-help-toggle-header-match-and-def)
(define-key idlwave-help-mode-map "F" 'idlwave-help-fontify)
(define-key idlwave-help-mode-map "\M-?" 'idlwave-help-return-to-calling-frame)
(define-key idlwave-help-mode-map "x" 'idlwave-help-return-to-calling-frame)
;; Define the menu for the Help application
(easy-menu-define

34
lisp/progmodes/idlwave.el
View File

@ -8265,20 +8265,26 @@ If we do not know about MODULE, just return KEYWORD literally."
;; keyword - return it as it is.
keyword))))
(defvar idlwave-rinfo-mouse-map (make-sparse-keymap))
(defvar idlwave-rinfo-map (make-sparse-keymap))
(define-key idlwave-rinfo-mouse-map
(if (featurep 'xemacs) [button2] [mouse-2])
'idlwave-mouse-active-rinfo)
(define-key idlwave-rinfo-mouse-map
(if (featurep 'xemacs) [(shift button2)] [(shift mouse-2)])
'idlwave-mouse-active-rinfo-shift)
(define-key idlwave-rinfo-mouse-map
(if (featurep 'xemacs) [button3] [mouse-3])
'idlwave-mouse-active-rinfo-right)
(define-key idlwave-rinfo-mouse-map " " 'idlwave-active-rinfo-space)
(define-key idlwave-rinfo-map "q" 'idlwave-quit-help)
(define-key idlwave-rinfo-mouse-map "q" 'idlwave-quit-help)
(defvar idlwave-rinfo-mouse-map
(let ((map (make-sparse-keymap)))
(define-key map
(if (featurep 'xemacs) [button2] [mouse-2])
'idlwave-mouse-active-rinfo)
(define-key map
(if (featurep 'xemacs) [(shift button2)] [(shift mouse-2)])
'idlwave-mouse-active-rinfo-shift)
(define-key map
(if (featurep 'xemacs) [button3] [mouse-3])
'idlwave-mouse-active-rinfo-right)
(define-key map " " 'idlwave-active-rinfo-space)
(define-key map "q" 'idlwave-quit-help)
map))
(defvar idlwave-rinfo-map
(let ((map (make-sparse-keymap)))
(define-key map "q" 'idlwave-quit-help)
map))
(defvar idlwave-popup-source nil)
(defvar idlwave-rinfo-marker (make-marker))

102
lisp/replace.el
View File

@ -757,6 +757,60 @@ a previously found match."
count)))
(defvar occur-mode-map
(let ((map (make-sparse-keymap)))
;; We use this alternative name, so we can use \\[occur-mode-mouse-goto].
(define-key map [mouse-2] 'occur-mode-mouse-goto)
(define-key map "\C-c\C-c" 'occur-mode-goto-occurrence)
(define-key map "\C-m" 'occur-mode-goto-occurrence)
(define-key map "o" 'occur-mode-goto-occurrence-other-window)
(define-key map "\C-o" 'occur-mode-display-occurrence)
(define-key map "\M-n" 'occur-next)
(define-key map "\M-p" 'occur-prev)
(define-key map "r" 'occur-rename-buffer)
(define-key map "c" 'clone-buffer)
(define-key map "\C-c\C-f" 'next-error-follow-minor-mode)
(define-key map [menu-bar] (make-sparse-keymap))
(define-key map [menu-bar occur]
`(cons ,(purecopy "Occur") map))
(define-key map [next-error-follow-minor-mode]
(menu-bar-make-mm-toggle next-error-follow-minor-mode
"Auto Occurrence Display"
"Display another occurrence when moving the cursor"))
(define-key map [separator-1] menu-bar-separator)
(define-key map [kill-this-buffer]
`(menu-item ,(purecopy "Kill occur buffer") kill-this-buffer
:help ,(purecopy "Kill the current *Occur* buffer")))
(define-key map [quit-window]
`(menu-item ,(purecopy "Quit occur window") quit-window
:help ,(purecopy "Quit the current *Occur* buffer. Bury it, and maybe delete the selected frame")))
(define-key map [revert-buffer]
`(menu-item ,(purecopy "Revert occur buffer") revert-buffer
:help ,(purecopy "Replace the text in the *Occur* buffer with the results of rerunning occur")))
(define-key map [clone-buffer]
`(menu-item ,(purecopy "Clone occur buffer") clone-buffer
:help ,(purecopy "Create and return a twin copy of the current *Occur* buffer")))
(define-key map [occur-rename-buffer]
`(menu-item ,(purecopy "Rename occur buffer") occur-rename-buffer
:help ,(purecopy "Rename the current *Occur* buffer to *Occur: original-buffer-name*.")))
(define-key map [separator-2] menu-bar-separator)
(define-key map [occur-mode-goto-occurrence-other-window]
`(menu-item ,(purecopy "Go To Occurrence Other Window") occur-mode-goto-occurrence-other-window
:help ,(purecopy "Go to the occurrence the current line describes, in another window")))
(define-key map [occur-mode-goto-occurrence]
`(menu-item ,(purecopy "Go To Occurrence") occur-mode-goto-occurrence
:help ,(purecopy "Go to the occurrence the current line describes")))
(define-key map [occur-mode-display-occurrence]
`(menu-item ,(purecopy "Display Occurrence") occur-mode-display-occurrence
:help ,(purecopy "Display in another window the occurrence the current line describes")))
(define-key map [occur-next]
`(menu-item ,(purecopy "Move to next match") occur-next
:help ,(purecopy "Move to the Nth (default 1) next match in an Occur mode buffer")))
(define-key map [occur-prev]
`(menu-item ,(purecopy "Move to previous match") occur-prev
:help ,(purecopy "Move to the Nth (default 1) previous match in an Occur mode buffer")))
map)
"Keymap for `occur-mode'.")
(defvar occur-revert-arguments nil
"Arguments to pass to `occur-1' to revert an Occur mode buffer.
@ -792,54 +846,6 @@ Alternatively, click \\[occur-mode-mouse-goto] on an item to go to it.
(add-hook 'change-major-mode-hook 'font-lock-defontify nil t)
(setq next-error-function 'occur-next-error))
(define-key occur-mode-map [mouse-2] 'occur-mode-mouse-goto)
(define-key occur-mode-map "\C-c\C-c" 'occur-mode-goto-occurrence)
(define-key occur-mode-map "\C-m" 'occur-mode-goto-occurrence)
(define-key occur-mode-map "o" 'occur-mode-goto-occurrence-other-window)
(define-key occur-mode-map "\C-o" 'occur-mode-display-occurrence)
(define-key occur-mode-map "\M-n" 'occur-next)
(define-key occur-mode-map "\M-p" 'occur-prev)
(define-key occur-mode-map "r" 'occur-rename-buffer)
(define-key occur-mode-map "c" 'clone-buffer)
(define-key occur-mode-map "\C-c\C-f" 'next-error-follow-minor-mode)
(define-key occur-mode-map [menu-bar] (make-sparse-keymap))
(define-key occur-mode-map [menu-bar occur] `(cons ,(purecopy "Occur") map))
(define-key occur-mode-map [next-error-follow-minor-mode]
(menu-bar-make-mm-toggle next-error-follow-minor-mode
"Auto Occurrence Display"
"Display another occurrence when moving the cursor"))
(define-key occur-mode-map [separator-1] menu-bar-separator)
(define-key occur-mode-map [kill-this-buffer]
`(menu-item ,(purecopy "Kill occur buffer") kill-this-buffer
:help ,(purecopy "Kill the current *Occur* buffer")))
(define-key occur-mode-map [quit-window]
`(menu-item ,(purecopy "Quit occur window") quit-window
:help ,(purecopy "Quit the current *Occur* buffer. Bury it, and maybe delete the selected frame")))
(define-key occur-mode-map [revert-buffer]
`(menu-item ,(purecopy "Revert occur buffer") revert-buffer
:help ,(purecopy "Replace the text in the *Occur* buffer with the results of rerunning occur")))
(define-key occur-mode-map [clone-buffer]
`(menu-item ,(purecopy "Clone occur buffer") clone-buffer
:help ,(purecopy "Create and return a twin copy of the current *Occur* buffer")))
(define-key occur-mode-map [occur-rename-buffer]
`(menu-item ,(purecopy "Rename occur buffer") occur-rename-buffer
:help ,(purecopy "Rename the current *Occur* buffer to *Occur: original-buffer-name*.")))
(define-key occur-mode-map [separator-2] menu-bar-separator)
(define-key occur-mode-map [occur-mode-goto-occurrence-other-window]
`(menu-item ,(purecopy "Go To Occurrence Other Window") occur-mode-goto-occurrence-other-window
:help ,(purecopy "Go to the occurrence the current line describes, in another window")))
(define-key occur-mode-map [occur-mode-goto-occurrence]
`(menu-item ,(purecopy "Go To Occurrence") occur-mode-goto-occurrence
:help ,(purecopy "Go to the occurrence the current line describes")))
(define-key occur-mode-map [occur-mode-display-occurrence]
`(menu-item ,(purecopy "Display Occurrence") occur-mode-display-occurrence
:help ,(purecopy "Display in another window the occurrence the current line describes")))
(define-key occur-mode-map [occur-next]
`(menu-item ,(purecopy "Move to next match") occur-next
:help ,(purecopy "Move to the Nth (default 1) next match in an Occur mode buffer")))
(define-key occur-mode-map [occur-prev]
`(menu-item ,(purecopy "Move to previous match") occur-prev
:help ,(purecopy "Move to the Nth (default 1) previous match in an Occur mode buffer")))
(defun occur-revert-function (ignore1 ignore2)
"Handle `revert-buffer' for Occur mode buffers."
(apply 'occur-1 (append occur-revert-arguments (list (buffer-name)))))

148
lisp/tar-mode.el
View File

@ -520,7 +520,84 @@ MODE should be an integer which is a file mode value."
(goto-char (point-min))
(restore-buffer-modified-p modified)))
(defvar tar-mode-map
(let ((map (make-keymap)))
(suppress-keymap map)
(define-key map " " 'tar-next-line)
(define-key map "C" 'tar-copy)
(define-key map "d" 'tar-flag-deleted)
(define-key map "\^D" 'tar-flag-deleted)
(define-key map "e" 'tar-extract)
(define-key map "f" 'tar-extract)
(define-key map "\C-m" 'tar-extract)
(define-key map [mouse-2] 'tar-mouse-extract)
(define-key map "g" 'revert-buffer)
(define-key map "n" 'tar-next-line)
(define-key map "\^N" 'tar-next-line)
(define-key map [down] 'tar-next-line)
(define-key map "o" 'tar-extract-other-window)
(define-key map "p" 'tar-previous-line)
(define-key map "\^P" 'tar-previous-line)
(define-key map [up] 'tar-previous-line)
(define-key map "R" 'tar-rename-entry)
(define-key map "u" 'tar-unflag)
(define-key map "v" 'tar-view)
(define-key map "x" 'tar-expunge)
(define-key map "\177" 'tar-unflag-backwards)
(define-key map "E" 'tar-extract-other-window)
(define-key map "M" 'tar-chmod-entry)
(define-key map "G" 'tar-chgrp-entry)
(define-key map "O" 'tar-chown-entry)
;; Let mouse-1 follow the link.
(define-key map [follow-link] 'mouse-face)
;; Make menu bar items.
;; Get rid of the Edit menu bar item to save space.
(define-key map [menu-bar edit] 'undefined)
(define-key map [menu-bar immediate]
(cons "Immediate" (make-sparse-keymap "Immediate")))
(define-key map [menu-bar immediate view]
'("View This File" . tar-view))
(define-key map [menu-bar immediate display]
'("Display in Other Window" . tar-display-other-window))
(define-key map [menu-bar immediate find-file-other-window]
'("Find in Other Window" . tar-extract-other-window))
(define-key map [menu-bar immediate find-file]
'("Find This File" . tar-extract))
(define-key map [menu-bar mark]
(cons "Mark" (make-sparse-keymap "Mark")))
(define-key map [menu-bar mark unmark-all]
'("Unmark All" . tar-clear-modification-flags))
(define-key map [menu-bar mark deletion]
'("Flag" . tar-flag-deleted))
(define-key map [menu-bar mark unmark]
'("Unflag" . tar-unflag))
(define-key map [menu-bar operate]
(cons "Operate" (make-sparse-keymap "Operate")))
(define-key map [menu-bar operate chown]
'("Change Owner..." . tar-chown-entry))
(define-key map [menu-bar operate chgrp]
'("Change Group..." . tar-chgrp-entry))
(define-key map [menu-bar operate chmod]
'("Change Mode..." . tar-chmod-entry))
(define-key map [menu-bar operate rename]
'("Rename to..." . tar-rename-entry))
(define-key map [menu-bar operate copy]
'("Copy to..." . tar-copy))
(define-key map [menu-bar operate expunge]
'("Expunge Marked Files" . tar-expunge))
map)
"Local keymap for Tar mode listings.")
;; tar mode is suitable only for specially formatted data.
(put 'tar-mode 'mode-class 'special)
(put 'tar-subfile-mode 'mode-class 'special)
@ -590,77 +667,6 @@ See also: variables `tar-update-datestamp' and `tar-anal-blocksize'.
(fundamental-mode)
(signal (car err) (cdr err)))))
(define-key tar-mode-map " " 'tar-next-line)
(define-key tar-mode-map "C" 'tar-copy)
(define-key tar-mode-map "d" 'tar-flag-deleted)
(define-key tar-mode-map "\^D" 'tar-flag-deleted)
(define-key tar-mode-map "e" 'tar-extract)
(define-key tar-mode-map "f" 'tar-extract)
(define-key tar-mode-map "\C-m" 'tar-extract)
(define-key tar-mode-map [mouse-2] 'tar-mouse-extract)
(define-key tar-mode-map "g" 'revert-buffer)
(define-key tar-mode-map "h" 'describe-mode)
(define-key tar-mode-map "n" 'tar-next-line)
(define-key tar-mode-map "\^N" 'tar-next-line)
(define-key tar-mode-map [down] 'tar-next-line)
(define-key tar-mode-map "o" 'tar-extract-other-window)
(define-key tar-mode-map "p" 'tar-previous-line)
(define-key tar-mode-map "\^P" 'tar-previous-line)
(define-key tar-mode-map [up] 'tar-previous-line)
(define-key tar-mode-map "R" 'tar-rename-entry)
(define-key tar-mode-map "u" 'tar-unflag)
(define-key tar-mode-map "v" 'tar-view)
(define-key tar-mode-map "x" 'tar-expunge)
(define-key tar-mode-map "\177" 'tar-unflag-backwards)
(define-key tar-mode-map "E" 'tar-extract-other-window)
(define-key tar-mode-map "M" 'tar-chmod-entry)
(define-key tar-mode-map "G" 'tar-chgrp-entry)
(define-key tar-mode-map "O" 'tar-chown-entry)
;; Let mouse-1 follow the link.
(define-key tar-mode-map [follow-link] 'mouse-face)
;; Make menu bar items.
;; Get rid of the Edit menu bar item to save space.
(define-key tar-mode-map [menu-bar edit] 'undefined)
(define-key tar-mode-map [menu-bar immediate]
(cons "Immediate" (make-sparse-keymap "Immediate")))
(define-key tar-mode-map [menu-bar immediate view]
'("View This File" . tar-view))
(define-key tar-mode-map [menu-bar immediate display]
'("Display in Other Window" . tar-display-other-window))
(define-key tar-mode-map [menu-bar immediate find-file-other-window]
'("Find in Other Window" . tar-extract-other-window))
(define-key tar-mode-map [menu-bar immediate find-file]
'("Find This File" . tar-extract))
(define-key tar-mode-map [menu-bar mark]
(cons "Mark" (make-sparse-keymap "Mark")))
(define-key tar-mode-map [menu-bar mark unmark-all]
'("Unmark All" . tar-clear-modification-flags))
(define-key tar-mode-map [menu-bar mark deletion]
'("Flag" . tar-flag-deleted))
(define-key tar-mode-map [menu-bar mark unmark]
'("Unflag" . tar-unflag))
(define-key tar-mode-map [menu-bar operate]
(cons "Operate" (make-sparse-keymap "Operate")))
(define-key tar-mode-map [menu-bar operate chown]
'("Change Owner..." . tar-chown-entry))
(define-key tar-mode-map [menu-bar operate chgrp]
'("Change Group..." . tar-chgrp-entry))
(define-key tar-mode-map [menu-bar operate chmod]
'("Change Mode..." . tar-chmod-entry))
(define-key tar-mode-map [menu-bar operate rename]
'("Rename to..." . tar-rename-entry))
(define-key tar-mode-map [menu-bar operate copy]
'("Copy to..." . tar-copy))
(define-key tar-mode-map [menu-bar operate expunge]
'("Expunge Marked Files" . tar-expunge))
(define-minor-mode tar-subfile-mode
"Minor mode for editing an element of a tar-file.

138
lisp/term/lk201.el
View File

@ -1,76 +1,78 @@
;; -*- no-byte-compile: t -*-
;; Define function key sequences for DEC terminals.
(defvar lk201-function-map (make-sparse-keymap)
(defvar lk201-function-map
(let ((map (make-sparse-keymap)))
;; Termcap or terminfo should set these.
;; (define-key map "\e[A" [up])
;; (define-key map "\e[B" [down])
;; (define-key map "\e[C" [right])
;; (define-key map "\e[D" [left])
(define-key map "\e[1~" [find])
(define-key map "\e[2~" [insert])
(define-key map "\e[3~" [delete])
(define-key map "\e[4~" [select])
(define-key map "\e[5~" [prior])
(define-key map "\e[6~" [next])
(define-key map "\e[11~" [f1])
(define-key map "\e[12~" [f2])
(define-key map "\e[13~" [f3])
(define-key map "\e[14~" [f4])
(define-key map "\e[15~" [f5])
(define-key map "\e[17~" [f6])
(define-key map "\e[18~" [f7])
(define-key map "\e[19~" [f8])
(define-key map "\e[20~" [f9])
(define-key map "\e[21~" [f10])
;; Customarily F11 is used as the ESC key.
;; The file that includes this one, takes care of that.
(define-key map "\e[23~" [f11])
(define-key map "\e[24~" [f12])
(define-key map "\e[25~" [f13])
(define-key map "\e[26~" [f14])
(define-key map "\e[28~" [help])
(define-key map "\e[29~" [menu])
(define-key map "\e[31~" [f17])
(define-key map "\e[32~" [f18])
(define-key map "\e[33~" [f19])
(define-key map "\e[34~" [f20])
;; Termcap or terminfo should set these.
;; (define-key map "\eOA" [up])
;; (define-key map "\eOB" [down])
;; (define-key map "\eOC" [right])
;; (define-key map "\eOD" [left])
;; Termcap or terminfo should set these, but doesn't properly.
;; Termcap sets these to k1-k4, which get mapped to f1-f4 in term.c
(define-key map "\eOP" [kp-f1])
(define-key map "\eOQ" [kp-f2])
(define-key map "\eOR" [kp-f3])
(define-key map "\eOS" [kp-f4])
(define-key map "\eOI" [kp-tab])
(define-key map "\eOj" [kp-multiply])
(define-key map "\eOk" [kp-add])
(define-key map "\eOl" [kp-separator])
(define-key map "\eOM" [kp-enter])
(define-key map "\eOm" [kp-subtract])
(define-key map "\eOn" [kp-decimal])
(define-key map "\eOo" [kp-divide])
(define-key map "\eOp" [kp-0])
(define-key map "\eOq" [kp-1])
(define-key map "\eOr" [kp-2])
(define-key map "\eOs" [kp-3])
(define-key map "\eOt" [kp-4])
(define-key map "\eOu" [kp-5])
(define-key map "\eOv" [kp-6])
(define-key map "\eOw" [kp-7])
(define-key map "\eOx" [kp-8])
(define-key map "\eOy" [kp-9])
map)
"Function key definitions for DEC terminals.")
;; Termcap or terminfo should set these.
;; (define-key lk201-function-map "\e[A" [up])
;; (define-key lk201-function-map "\e[B" [down])
;; (define-key lk201-function-map "\e[C" [right])
;; (define-key lk201-function-map "\e[D" [left])
(define-key lk201-function-map "\e[1~" [find])
(define-key lk201-function-map "\e[2~" [insert])
(define-key lk201-function-map "\e[3~" [delete])
(define-key lk201-function-map "\e[4~" [select])
(define-key lk201-function-map "\e[5~" [prior])
(define-key lk201-function-map "\e[6~" [next])
(define-key lk201-function-map "\e[11~" [f1])
(define-key lk201-function-map "\e[12~" [f2])
(define-key lk201-function-map "\e[13~" [f3])
(define-key lk201-function-map "\e[14~" [f4])
(define-key lk201-function-map "\e[15~" [f5])
(define-key lk201-function-map "\e[17~" [f6])
(define-key lk201-function-map "\e[18~" [f7])
(define-key lk201-function-map "\e[19~" [f8])
(define-key lk201-function-map "\e[20~" [f9])
(define-key lk201-function-map "\e[21~" [f10])
;; Customarily F11 is used as the ESC key.
;; The file that includes this one, takes care of that.
(define-key lk201-function-map "\e[23~" [f11])
(define-key lk201-function-map "\e[24~" [f12])
(define-key lk201-function-map "\e[25~" [f13])
(define-key lk201-function-map "\e[26~" [f14])
(define-key lk201-function-map "\e[28~" [help])
(define-key lk201-function-map "\e[29~" [menu])
(define-key lk201-function-map "\e[31~" [f17])
(define-key lk201-function-map "\e[32~" [f18])
(define-key lk201-function-map "\e[33~" [f19])
(define-key lk201-function-map "\e[34~" [f20])
;; Termcap or terminfo should set these.
;; (define-key lk201-function-map "\eOA" [up])
;; (define-key lk201-function-map "\eOB" [down])
;; (define-key lk201-function-map "\eOC" [right])
;; (define-key lk201-function-map "\eOD" [left])
;; Termcap or terminfo should set these, but doesn't properly.
;; Termcap sets these to k1-k4, which get mapped to f1-f4 in term.c
(define-key lk201-function-map "\eOP" [kp-f1])
(define-key lk201-function-map "\eOQ" [kp-f2])
(define-key lk201-function-map "\eOR" [kp-f3])
(define-key lk201-function-map "\eOS" [kp-f4])
(define-key lk201-function-map "\eOI" [kp-tab])
(define-key lk201-function-map "\eOj" [kp-multiply])
(define-key lk201-function-map "\eOk" [kp-add])
(define-key lk201-function-map "\eOl" [kp-separator])
(define-key lk201-function-map "\eOM" [kp-enter])
(define-key lk201-function-map "\eOm" [kp-subtract])
(define-key lk201-function-map "\eOn" [kp-decimal])
(define-key lk201-function-map "\eOo" [kp-divide])
(define-key lk201-function-map "\eOp" [kp-0])
(define-key lk201-function-map "\eOq" [kp-1])
(define-key lk201-function-map "\eOr" [kp-2])
(define-key lk201-function-map "\eOs" [kp-3])
(define-key lk201-function-map "\eOt" [kp-4])
(define-key lk201-function-map "\eOu" [kp-5])
(define-key lk201-function-map "\eOv" [kp-6])
(define-key lk201-function-map "\eOw" [kp-7])
(define-key lk201-function-map "\eOx" [kp-8])
(define-key lk201-function-map "\eOy" [kp-9])
(defun terminal-init-lk201 ()
;; Use inheritance to let the main keymap override these defaults.
;; This way we don't override terminfo-derived settings or settings

13
lisp/textmodes/bib-mode.el
View File

@ -47,11 +47,14 @@
:type 'file
:group 'bib)
(defvar bib-mode-map (copy-keymap text-mode-map))
(define-key bib-mode-map "\C-M" 'return-key-bib)
(define-key bib-mode-map "\C-c\C-u" 'unread-bib)
(define-key bib-mode-map "\C-c\C-@" 'mark-bib)
(define-key bib-mode-map "\e`" 'abbrev-mode)
(defvar bib-mode-map
(let ((map (make-sparse-keymap)))
(set-keymap-parent map text-mode-map)
(define-key map "\C-M" 'return-key-bib)
(define-key map "\C-c\C-u" 'unread-bib)
(define-key map "\C-c\C-@" 'mark-bib)
(define-key map "\e`" 'abbrev-mode)
map))
(defun addbib ()
"Set up editor to add to troff bibliography file specified

48
lisp/textmodes/enriched.el
View File

@ -163,6 +163,24 @@ The value is a list of \(VAR VALUE VAR VALUE...).")
;; variables and to correctly update `enriched-old-bindings'.
(defvar enriched-rerun-flag nil)
;;;
;;; Keybindings
;;;
(defvar enriched-mode-map
(let ((map (make-sparse-keymap)))
(define-key map [remap move-beginning-of-line] 'beginning-of-line-text)
(define-key map "\C-m" 'reindent-then-newline-and-indent)
(define-key map
[remap newline-and-indent] 'reindent-then-newline-and-indent)
(define-key map "\M-j" 'facemenu-justification-menu)
(define-key map "\M-S" 'set-justification-center)
(define-key map "\C-x\t" 'increase-left-margin)
(define-key map "\C-c[" 'set-left-margin)
(define-key map "\C-c]" 'set-right-margin)
map)
"Keymap for Enriched mode.")
;;;
;;; Define the mode
;;;
@ -184,6 +202,8 @@ Commands:
:group 'enriched :lighter " Enriched"
(cond ((null enriched-mode)
;; Turn mode off
(remove-hook 'change-major-mode-hook
'enriched-before-change-major-mode 'local)
(setq buffer-file-format (delq 'text/enriched buffer-file-format))
;; restore old variable values
(while enriched-old-bindings
@ -199,6 +219,8 @@ Commands:
nil)
(t ; Turn mode on
(add-hook 'change-major-mode-hook
'enriched-before-change-major-mode nil 'local)
(add-to-list 'buffer-file-format 'text/enriched)
;; Save old variable values before we change them.
;; These will be restored if we exit Enriched mode.
@ -226,8 +248,6 @@ Commands:
(while enriched-old-bindings
(set (pop enriched-old-bindings) (pop enriched-old-bindings)))))
(add-hook 'change-major-mode-hook 'enriched-before-change-major-mode)
(defun enriched-after-change-major-mode ()
(when enriched-mode
(let ((enriched-rerun-flag t))
@ -235,30 +255,8 @@ Commands:
(add-hook 'after-change-major-mode-hook 'enriched-after-change-major-mode)
;;;
;;; Keybindings
;;;
(defvar enriched-mode-map nil
"Keymap for Enriched mode.")
(if (null enriched-mode-map)
(fset 'enriched-mode-map (setq enriched-mode-map (make-sparse-keymap))))
(if (not (assq 'enriched-mode minor-mode-map-alist))
(setq minor-mode-map-alist
(cons (cons 'enriched-mode enriched-mode-map)
minor-mode-map-alist)))
(define-key enriched-mode-map [remap move-beginning-of-line] 'beginning-of-line-text)
(define-key enriched-mode-map "\C-m" 'reindent-then-newline-and-indent)
(define-key enriched-mode-map
[remap newline-and-indent] 'reindent-then-newline-and-indent)
(define-key enriched-mode-map "\M-j" 'facemenu-justification-menu)
(define-key enriched-mode-map "\M-S" 'set-justification-center)
(define-key enriched-mode-map "\C-x\t" 'increase-left-margin)
(define-key enriched-mode-map "\C-c[" 'set-left-margin)
(define-key enriched-mode-map "\C-c]" 'set-right-margin)
(fset 'enriched-mode-map enriched-mode-map)
;;;
;;; Some functions dealing with text-properties, especially indentation