[bpt/emacs.git] / lisp / eshell / em-rebind.el

;;; em-rebind.el --- rebind keys when point is at current input

;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
;;   2008, 2009, 2010, 2011, 2012  Free Software Foundation, Inc.

;; Author: John Wiegley <johnw@gnu.org>

;; This file is part of GNU Emacs.

;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.

;;; Commentary:

;;; Code:

(eval-when-compile (require 'eshell))

;;;###autoload
(eshell-defgroup eshell-rebind nil
  "This module allows for special keybindings that only take effect
while the point is in a region of input text.  By default, it binds
C-a to move to the beginning of the input text (rather than just the
beginning of the line), and C-p and C-n to move through the input
history, C-u kills the current input text, etc.  It also, if
`eshell-confine-point-to-input' is non-nil, does not allow certain
commands to cause the point to leave the input area, such as
`backward-word', `previous-line', etc.  This module intends to mimic
the behavior of normal shells while the user editing new input text."
  :tag "Rebind keys at input"
  :group 'eshell-module)

;;; User Variables:

(defcustom eshell-rebind-load-hook '(eshell-rebind-initialize)
  "*A list of functions to call when loading `eshell-rebind'."
  :type 'hook
  :group 'eshell-rebind)

(defcustom eshell-rebind-keys-alist
  '(([(control ?a)] . eshell-bol)
    ([home]         . eshell-bol)
    ([(control ?d)] . eshell-delchar-or-maybe-eof)
    ([backspace]    . eshell-delete-backward-char)
    ([delete]       . eshell-delete-backward-char)
    ([(control ?w)] . backward-kill-word)
    ([(control ?u)] . eshell-kill-input))
  "*Bind some keys differently if point is in input text."
  :type '(repeat (cons (vector :tag "Keys to bind"
			       (repeat :inline t sexp))
		       (function :tag "Command")))
  :group 'eshell-rebind)

(defcustom eshell-confine-point-to-input t
  "*If non-nil, do not allow the point to leave the current input.
This is more difficult to do nicely in Emacs than one might think.
Basically, the `point-left' attribute is added to the input text, and
a function is placed on that hook to take the point back to
`eshell-last-output-end' every time the user tries to move away.  But
since there are many cases in which the point _ought_ to move away
\(for programmatic reasons), the variable
`eshell-cannot-leave-input-list' defines commands which are affected
from this rule.  However, this list is by no means as complete as it
probably should be, so basically all one can hope for is that other
people will left the point alone in the Eshell buffer.  Sigh."
  :type 'boolean
  :group 'eshell-rebind)

(defcustom eshell-error-if-move-away t
  "*If non-nil, consider it an error to try to move outside current input.
This is default behavior of shells like bash."
  :type 'boolean
  :group 'eshell-rebind)

(defcustom eshell-remap-previous-input t
  "*If non-nil, remap input keybindings on previous prompts as well."
  :type 'boolean
  :group 'eshell-rebind)

(defcustom eshell-cannot-leave-input-list
  '(beginning-of-line-text
    beginning-of-line
    move-to-column
    move-to-column-force
    move-to-left-margin
    move-to-tab-stop
    forward-char
    backward-char
    delete-char
    delete-backward-char
    backward-delete-char
    backward-delete-char-untabify
    kill-paragraph
    backward-kill-paragraph
    kill-sentence
    backward-kill-sentence
    kill-sexp
    backward-kill-sexp
    kill-word
    backward-kill-word
    kill-region
    forward-list
    backward-list
    forward-page
    backward-page
    forward-point
    forward-paragraph
    backward-paragraph
    backward-prefix-chars
    forward-sentence
    backward-sentence
    forward-sexp
    backward-sexp
    forward-to-indentation
    backward-to-indentation
    backward-up-list
    forward-word
    backward-word
    forward-line
    previous-line
    next-line
    forward-visible-line
    forward-comment
    forward-thing)
  "*A list of commands that cannot leave the input area."
  :type '(repeat function)
  :group 'eshell-rebind)

;; Internal Variables:

(defvar eshell-input-keymap)
(defvar eshell-previous-point)
(defvar eshell-lock-keymap)

;;; Functions:

(defun eshell-rebind-initialize ()
  "Initialize the inputing code."
  (unless eshell-non-interactive-p
    (add-hook 'eshell-mode-hook 'eshell-setup-input-keymap nil t)
    (make-local-variable 'eshell-previous-point)
    (add-hook 'pre-command-hook 'eshell-save-previous-point nil t)
    (make-local-variable 'overriding-local-map)
    (add-hook 'post-command-hook 'eshell-rebind-input-map nil t)
    (set (make-local-variable 'eshell-lock-keymap) nil)
    (define-key eshell-command-map [(meta ?l)] 'eshell-lock-local-map)))

(defun eshell-lock-local-map (&optional arg)
  "Lock or unlock the current local keymap.
Within a prefix arg, set the local keymap to its normal value, and
lock it at that."
  (interactive "P")
  (if (or arg (not eshell-lock-keymap))
      (progn
	(use-local-map eshell-mode-map)
	(setq eshell-lock-keymap t)
	(message "Local keymap locked in normal mode"))
    (use-local-map eshell-input-keymap)
    (setq eshell-lock-keymap nil)
    (message "Local keymap unlocked: obey context")))

(defun eshell-save-previous-point ()
  "Save the location of point before the next command is run."
  (setq eshell-previous-point (point)))

(defsubst eshell-point-within-input-p (pos)
  "Test whether POS is within an input range."
  (let (begin)
    (or (and (>= pos eshell-last-output-end)
	     eshell-last-output-end)
	(and eshell-remap-previous-input
	     (setq begin
		   (save-excursion
		     (eshell-bol)
		     (and (not (bolp)) (point))))
	     (>= pos begin)
	     (<= pos (line-end-position))
	     begin))))

(defun eshell-rebind-input-map ()
  "Rebind the input keymap based on the location of the cursor."
  (ignore-errors
    (unless eshell-lock-keymap
      (if (eshell-point-within-input-p (point))
	  (use-local-map eshell-input-keymap)
	(let (begin)
	  (if (and eshell-confine-point-to-input
		   (setq begin
			 (eshell-point-within-input-p eshell-previous-point))
		   (memq this-command eshell-cannot-leave-input-list))
	      (progn
		(use-local-map eshell-input-keymap)
		(goto-char begin)
		(if (and eshell-error-if-move-away
			 (not (eq this-command 'kill-region)))
		    (beep)))
	    (use-local-map eshell-mode-map)))))))

(defun eshell-setup-input-keymap ()
  "Setup the input keymap to be used during input editing."
  (make-local-variable 'eshell-input-keymap)
  (setq eshell-input-keymap (make-sparse-keymap))
  (set-keymap-parent eshell-input-keymap eshell-mode-map)
  (let ((bindings eshell-rebind-keys-alist))
    (while bindings
      (define-key eshell-input-keymap (caar bindings)
	(cdar bindings))
      (setq bindings (cdr bindings)))))

(defun eshell-delete-backward-char (n &optional killflag)
  "Delete the last character, unless it's part of the output."
  (interactive "P")
  (let ((count (prefix-numeric-value n)))
    (if (eshell-point-within-input-p (- (point) count))
	(delete-backward-char count n)
      (beep))))

(defun eshell-delchar-or-maybe-eof (arg)
  "Delete ARG characters forward or send an EOF to subprocess.
Sends an EOF only if point is at the end of the buffer and there is no
input."
  (interactive "p")
  (let ((proc (eshell-interactive-process)))
    (if (eobp)
	(cond
	 ((/= (point) eshell-last-output-end)
	  (beep))
	 (proc
	  (process-send-eof))
	 (t
	  (eshell-life-is-too-much)))
      (eshell-delete-backward-char (- arg)))))

(provide 'em-rebind)

;; Local Variables:
;; generated-autoload-file: "esh-groups.el"
;; End:

;; arch-tag: 76d84f12-cc56-4d67-9b7d-c6b44ad20530
;;; em-rebind.el ends here
Commit	Line	Data
60370d40	1	;;; em-rebind.el --- rebind keys when point is at current input
affbf647	2
3146b070	3	;; Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
49f70d46	4	;; 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
affbf647	5
7de5b421 GM	6	;; Author: John Wiegley <johnw@gnu.org>
7de5b421 GM	7
affbf647 GM	8	;; This file is part of GNU Emacs.
affbf647 GM	9
4ee57b2a	10	;; GNU Emacs is free software: you can redistribute it and/or modify
affbf647	11	;; it under the terms of the GNU General Public License as published by
4ee57b2a GM	12	;; the Free Software Foundation, either version 3 of the License, or
4ee57b2a GM	13	;; (at your option) any later version.
affbf647 GM	14
	15	;; GNU Emacs is distributed in the hope that it will be useful,
	16	;; but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	;; GNU General Public License for more details.
	19
	20	;; You should have received a copy of the GNU General Public License
4ee57b2a	21	;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
affbf647	22
dbba8a04 GM	23	;;; Commentary:
	24
	25	;;; Code:
affbf647	26
dbba8a04	27	(eval-when-compile (require 'eshell))
affbf647	28
3146b070 GM	29	;;;###autoload
3146b070 GM	30	(eshell-defgroup eshell-rebind nil
affbf647 GM	31	"This module allows for special keybindings that only take effect
	32	while the point is in a region of input text. By default, it binds
	33	C-a to move to the beginning of the input text (rather than just the
	34	beginning of the line), and C-p and C-n to move through the input
	35	history, C-u kills the current input text, etc. It also, if
	36	`eshell-confine-point-to-input' is non-nil, does not allow certain
	37	commands to cause the point to leave the input area, such as
	38	`backward-word', `previous-line', etc. This module intends to mimic
	39	the behavior of normal shells while the user editing new input text."
	40	:tag "Rebind keys at input"
	41	:group 'eshell-module)
	42
affbf647 GM	43	;;; User Variables:
	44
	45	(defcustom eshell-rebind-load-hook '(eshell-rebind-initialize)
	46	"*A list of functions to call when loading `eshell-rebind'."
	47	:type 'hook
	48	:group 'eshell-rebind)
	49
	50	(defcustom eshell-rebind-keys-alist
	51	'(([(control ?a)] . eshell-bol)
	52	([home] . eshell-bol)
	53	([(control ?d)] . eshell-delchar-or-maybe-eof)
	54	([backspace] . eshell-delete-backward-char)
	55	([delete] . eshell-delete-backward-char)
	56	([(control ?w)] . backward-kill-word)
	57	([(control ?u)] . eshell-kill-input))
	58	"*Bind some keys differently if point is in input text."
	59	:type '(repeat (cons (vector :tag "Keys to bind"
	60	(repeat :inline t sexp))
	61	(function :tag "Command")))
	62	:group 'eshell-rebind)
	63
	64	(defcustom eshell-confine-point-to-input t
	65	"*If non-nil, do not allow the point to leave the current input.
	66	This is more difficult to do nicely in Emacs than one might think.
	67	Basically, the `point-left' attribute is added to the input text, and
	68	a function is placed on that hook to take the point back to
	69	`eshell-last-output-end' every time the user tries to move away. But
	70	since there are many cases in which the point _ought_ to move away
	71	\(for programmatic reasons), the variable
	72	`eshell-cannot-leave-input-list' defines commands which are affected
	73	from this rule. However, this list is by no means as complete as it
	74	probably should be, so basically all one can hope for is that other
	75	people will left the point alone in the Eshell buffer. Sigh."
	76	:type 'boolean
	77	:group 'eshell-rebind)
	78
	79	(defcustom eshell-error-if-move-away t
	80	"*If non-nil, consider it an error to try to move outside current input.
	81	This is default behavior of shells like bash."
	82	:type 'boolean
	83	:group 'eshell-rebind)
	84
	85	(defcustom eshell-remap-previous-input t
	86	"*If non-nil, remap input keybindings on previous prompts as well."
	87	:type 'boolean
	88	:group 'eshell-rebind)
	89
	90	(defcustom eshell-cannot-leave-input-list
	91	'(beginning-of-line-text
	92	beginning-of-line
	93	move-to-column
	94	move-to-column-force
	95	move-to-left-margin
	96	move-to-tab-stop
	97	forward-char
	98	backward-char
	99	delete-char
	100	delete-backward-char
	101	backward-delete-char
	102	backward-delete-char-untabify
	103	kill-paragraph
	104	backward-kill-paragraph
	105	kill-sentence
	106	backward-kill-sentence
107	kill-sexp
108	backward-kill-sexp
109	kill-word
110	backward-kill-word
111	kill-region
112	forward-list
113	backward-list
114	forward-page
115	backward-page
116	forward-point
117	forward-paragraph
118	backward-paragraph
119	backward-prefix-chars
120	forward-sentence
121	backward-sentence
122	forward-sexp
123	backward-sexp
124	forward-to-indentation
125	backward-to-indentation
126	backward-up-list
127	forward-word
128	backward-word
129	forward-line
affbf647 GM	130	previous-line
	131	next-line
	132	forward-visible-line
	133	forward-comment
	134	forward-thing)
	135	"*A list of commands that cannot leave the input area."
	136	:type '(repeat function)
	137	:group 'eshell-rebind)
	138
	139	;; Internal Variables:
	140
	141	(defvar eshell-input-keymap)
	142	(defvar eshell-previous-point)
	143	(defvar eshell-lock-keymap)
	144
	145	;;; Functions:
	146
	147	(defun eshell-rebind-initialize ()
	148	"Initialize the inputing code."
	149	(unless eshell-non-interactive-p
affbf647	150	(add-hook 'eshell-mode-hook 'eshell-setup-input-keymap nil t)
affbf647 GM	151	(make-local-variable 'eshell-previous-point)
affbf647 GM	152	(add-hook 'pre-command-hook 'eshell-save-previous-point nil t)
affbf647 GM	153	(make-local-variable 'overriding-local-map)
	154	(add-hook 'post-command-hook 'eshell-rebind-input-map nil t)
	155	(set (make-local-variable 'eshell-lock-keymap) nil)
	156	(define-key eshell-command-map [(meta ?l)] 'eshell-lock-local-map)))
	157
	158	(defun eshell-lock-local-map (&optional arg)
	159	"Lock or unlock the current local keymap.
	160	Within a prefix arg, set the local keymap to its normal value, and
	161	lock it at that."
	162	(interactive "P")
	163	(if (or arg (not eshell-lock-keymap))
	164	(progn
	165	(use-local-map eshell-mode-map)
	166	(setq eshell-lock-keymap t)
	167	(message "Local keymap locked in normal mode"))
	168	(use-local-map eshell-input-keymap)
	169	(setq eshell-lock-keymap nil)
	170	(message "Local keymap unlocked: obey context")))
	171
	172	(defun eshell-save-previous-point ()
	173	"Save the location of point before the next command is run."
	174	(setq eshell-previous-point (point)))
	175
	176	(defsubst eshell-point-within-input-p (pos)
	177	"Test whether POS is within an input range."
	178	(let (begin)
	179	(or (and (>= pos eshell-last-output-end)
	180	eshell-last-output-end)
	181	(and eshell-remap-previous-input
	182	(setq begin
	183	(save-excursion
	184	(eshell-bol)
	185	(and (not (bolp)) (point))))
	186	(>= pos begin)
	187	(<= pos (line-end-position))
	188	begin))))
	189
	190	(defun eshell-rebind-input-map ()
	191	"Rebind the input keymap based on the location of the cursor."
	192	(ignore-errors
	193	(unless eshell-lock-keymap
	194	(if (eshell-point-within-input-p (point))
	195	(use-local-map eshell-input-keymap)
	196	(let (begin)
	197	(if (and eshell-confine-point-to-input
	198	(setq begin
	199	(eshell-point-within-input-p eshell-previous-point))
	200	(memq this-command eshell-cannot-leave-input-list))
	201	(progn
	202	(use-local-map eshell-input-keymap)
	203	(goto-char begin)
	204	(if (and eshell-error-if-move-away
	205	(not (eq this-command 'kill-region)))
	206	(beep)))
	207	(use-local-map eshell-mode-map)))))))
	208
	209	(defun eshell-setup-input-keymap ()
	210	"Setup the input keymap to be used during input editing."
	211	(make-local-variable 'eshell-input-keymap)
	212	(setq eshell-input-keymap (make-sparse-keymap))
	213	(set-keymap-parent eshell-input-keymap eshell-mode-map)
	214	(let ((bindings eshell-rebind-keys-alist))
	215	(while bindings
	216	(define-key eshell-input-keymap (caar bindings)
217	(cdar bindings))
218	(setq bindings (cdr bindings)))))
219
220	(defun eshell-delete-backward-char (n &optional killflag)
221	"Delete the last character, unless it's part of the output."
222	(interactive "P")
223	(let ((count (prefix-numeric-value n)))
224	(if (eshell-point-within-input-p (- (point) count))
225	(delete-backward-char count n)
226	(beep))))
227
228	(defun eshell-delchar-or-maybe-eof (arg)
229	"Delete ARG characters forward or send an EOF to subprocess.
230	Sends an EOF only if point is at the end of the buffer and there is no
231	input."
232	(interactive "p")
8c6b1d83	233	(let ((proc (eshell-interactive-process)))
affbf647 GM	234	(if (eobp)
affbf647 GM	235	(cond
ca7aae91	236	((/= (point) eshell-last-output-end)
affbf647 GM	237	(beep))
	238	(proc
	239	(process-send-eof))
	240	(t
	241	(eshell-life-is-too-much)))
	242	(eshell-delete-backward-char (- arg)))))
	243
dbba8a04	244	(provide 'em-rebind)
affbf647	245
3146b070 GM	246	;; Local Variables:
	247	;; generated-autoload-file: "esh-groups.el"
	248	;; End:
	249
cbee283d	250	;; arch-tag: 76d84f12-cc56-4d67-9b7d-c6b44ad20530
affbf647	251	;;; em-rebind.el ends here