[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 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))

(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)

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