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

;;; em-smart.el --- smart display of output

;; 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:

;; The best way to get a sense of what this code is trying to do is by
;; using it.  Basically, the philosophy represents a blend between the
;; ease of use of modern day shells, and the review-before-you-proceed
;; mentality of Plan 9's 9term.
;;
;; @ When you invoke a command, it is assumed that you want to read
;;   the output of that command.
;;
;; @ If the output is not what you wanted, it is assumed that you will
;;   want to edit, and then resubmit a refined version of that
;;   command.
;;
;; @ If the output is valid, pressing any self-inserting character key
;;   will jump to end of the buffer and insert that character, in
;;   order to begin entry of a new command.
;;
;; @ If you show an intention to edit the previous command -- by
;;   moving around within it -- then the next self-inserting
;;   characters will insert *there*, instead of at the bottom of the
;;   buffer.
;;
;; @ If you show an intention to review old commands, such as M-p or
;;   M-r, point will jump to the bottom of the buffer before invoking
;;   that command.
;;
;; @ If none of the above has happened yet (i.e., your point is just
;;   sitting on the previous command), you can use SPACE and BACKSPACE
;;   (or DELETE) to page forward and backward *through the output of
;;   the last command only*.  It will constrain the movement of the
;;   point and window so that the maximum amount of output is always
;;   displayed at all times.
;;
;; @ While output is being generated from a command, the window will
;;   be constantly reconfigured (until it would otherwise make no
;;   difference) in order to always show you the most output from the
;;   command possible.  This happens if you change window sizes,
;;   scroll, etc.
;;
;; @ Like I said, it's not really comprehensible until you try it! ;)
;;
;; One disadvantage of this module is that it increases Eshell's
;; memory consumption by a factor of two or more.  With small commands
;; (such as pwd), where the screen is mostly full, consumption can
;; increase by orders of magnitude.

;;; Code:

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

;;;###autoload
(eshell-defgroup eshell-smart nil
  "This module combines the facility of normal, modern shells with
some of the edit/review concepts inherent in the design of Plan 9's
9term.  See the docs for more details.

Most likely you will have to turn this option on and play around with
it to get a real sense of how it works."
  :tag "Smart display of output"
  ;; :link '(info-link "(eshell)Smart display of output")
  :group 'eshell-module)

;;; User Variables:

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

(defcustom eshell-smart-unload-hook
  (list
   (function
    (lambda ()
      (remove-hook 'window-configuration-change-hook
		   'eshell-refresh-windows))))
  "*A hook that gets run when `eshell-smart' is unloaded."
  :type 'hook
  :group 'eshell-smart)

(defcustom eshell-review-quick-commands nil
  "*If t, always review commands.
Reviewing means keeping point on the text of the command that was just
invoked, to allow corrections to be made easily.

If set to nil, quick commands won't be reviewed.  A quick command is a
command that produces no output, and exits successfully.

If set to `not-even-short-output', then the definition of \"quick
command\" is extended to include commands that produce output, if and
only if that output can be presented in its entirely in the Eshell window."
  :type '(choice (const :tag "No" nil)
		 (const :tag "Yes" t)
		 (const :tag "Not even short output"
			not-even-short-output))
  :group 'eshell-smart)

(defcustom eshell-smart-display-navigate-list
  '(insert-parentheses
    mouse-yank-at-click
    mouse-yank-secondary
    yank-pop
    yank-rectangle
    yank)
  "*A list of commands which cause Eshell to jump to the end of buffer."
  :type '(repeat function)
  :group 'eshell-smart)

(defcustom eshell-smart-space-goes-to-end t
  "*If non-nil, space will go to end of buffer when point-max is visible.
That is, if a command is running and the user presses SPACE at a time
when the end of the buffer is visible, point will go to the end of the
buffer and smart-display will be turned off (that is, subsequently
pressing backspace will not cause the buffer to scroll down).

This feature is provided to make it very easy to watch the output of a
long-running command, such as make, where it's more desirable to see
the output go by than to review it afterward.

Setting this variable to nil means that space and backspace will
always have a consistent behavior, which is to move back and forth
through displayed output.  But it also means that enabling output
tracking requires the user to manually move point to the end of the
buffer using \\[end-of-buffer]."
  :type 'boolean
  :group 'eshell-smart)

(defcustom eshell-where-to-jump 'begin
  "*This variable indicates where point should jump to after a command.
The options are `begin', `after' or `end'."
  :type '(radio (const :tag "Beginning of command" begin)
		(const :tag "After command word" after)
		(const :tag "End of command" end))
  :group 'eshell-smart)

;;; Internal Variables:

(defvar eshell-smart-displayed nil)
(defvar eshell-smart-command-done nil)
(defvar eshell-currently-handling-window nil)

;;; Functions:

(defun eshell-smart-initialize ()
  "Setup Eshell smart display."
  (unless eshell-non-interactive-p
    ;; override a few variables, since they would interfere with the
    ;; smart display functionality.
    (set (make-local-variable 'eshell-scroll-to-bottom-on-output) nil)
    (set (make-local-variable 'eshell-scroll-to-bottom-on-input) nil)
    (set (make-local-variable 'eshell-scroll-show-maximum-output) t)

    (add-hook 'window-scroll-functions 'eshell-smart-scroll-window nil t)
    (add-hook 'window-configuration-change-hook 'eshell-refresh-windows)

    (add-hook 'eshell-output-filter-functions 'eshell-refresh-windows t t)

    (add-hook 'after-change-functions 'eshell-disable-after-change nil t)

    (add-hook 'eshell-input-filter-functions 'eshell-smart-display-setup nil t)

    (make-local-variable 'eshell-smart-command-done)
    (add-hook 'eshell-post-command-hook
	      (function
	       (lambda ()
		 (setq eshell-smart-command-done t))) t t)

    (unless (eq eshell-review-quick-commands t)
      (add-hook 'eshell-post-command-hook
		'eshell-smart-maybe-jump-to-end nil t))))

(defun eshell-smart-scroll-window (wind start)
  "Scroll the given Eshell window accordingly."
  (unless eshell-currently-handling-window
    (let ((inhibit-point-motion-hooks t)
	  (eshell-currently-handling-window t))
      (save-selected-window
	(select-window wind)
	(eshell-smart-redisplay)))))

(defun eshell-refresh-windows (&optional frame)
  "Refresh all visible Eshell buffers."
  (let (affected)
    (walk-windows
     (function
      (lambda (wind)
	(with-current-buffer (window-buffer wind)
	  (if eshell-mode
	      (let (window-scroll-functions)
		(eshell-smart-scroll-window wind (window-start))
		(setq affected t))))))
     0 frame)
    (if affected
	(let (window-scroll-functions)
	  (eshell-redisplay)))))

(defun eshell-smart-display-setup ()
  "Set the point to somewhere in the beginning of the last command."
  (cond
   ((eq eshell-where-to-jump 'begin)
    (goto-char eshell-last-input-start))
   ((eq eshell-where-to-jump 'after)
    (goto-char (next-single-property-change
		eshell-last-input-start 'arg-end))
    (if (= (point) (- eshell-last-input-end 2))
	(forward-char)))
   ((eq eshell-where-to-jump 'end)
    (goto-char (1- eshell-last-input-end)))
   (t
    (error "Invalid value for `eshell-where-to-jump'")))
  (setq eshell-smart-command-done nil)
  (add-hook 'pre-command-hook 'eshell-smart-display-move nil t)
  (eshell-refresh-windows))

(defun eshell-disable-after-change (b e l)
  "Disable smart display mode if the buffer changes in any way."
  (when eshell-smart-command-done
    (remove-hook 'pre-command-hook 'eshell-smart-display-move t)
    (setq eshell-smart-command-done nil)))

(defun eshell-smart-maybe-jump-to-end ()
  "Jump to the end of the input buffer.
This is done whenever a command exits successfully and both the command
and the end of the buffer are still visible."
  (when (and (= eshell-last-command-status 0)
	     (if (eq eshell-review-quick-commands 'not-even-short-output)
		 (and (pos-visible-in-window-p (point-max))
		      (pos-visible-in-window-p eshell-last-input-start))
	       (= (count-lines eshell-last-input-end
			       eshell-last-output-end) 0)))
    (goto-char (point-max))
    (remove-hook 'pre-command-hook 'eshell-smart-display-move t)))

(defun eshell-smart-redisplay ()
  "Display as much output as possible, smartly."
  (if (eobp)
      (save-excursion
	(recenter -1)
	;; trigger the redisplay now, so that we catch any attempted
	;; point motion; this is to cover for a redisplay bug
	(eshell-redisplay))
    (let ((top-point (point)))
      (and (memq 'eshell-smart-display-move pre-command-hook)
	   (>= (point) eshell-last-input-start)
	   (< (point) eshell-last-input-end)
	   (set-window-start (selected-window)
			     (line-beginning-position) t))
      (if (pos-visible-in-window-p (point-max))
	  (save-excursion
	    (goto-char (point-max))
	    (recenter -1)
	    (unless (pos-visible-in-window-p top-point)
	      (goto-char top-point)
	      (set-window-start (selected-window)
				(line-beginning-position) t)))))))

(defun eshell-smart-goto-end ()
  "Like `end-of-buffer', but do not push a mark."
  (interactive)
  (goto-char (point-max)))

(defun eshell-smart-display-move ()
  "Handle self-inserting or movement commands intelligently."
  (let (clear)
    (if (or current-prefix-arg
	    (and (> (point) eshell-last-input-start)
		 (< (point) eshell-last-input-end))
	    (>= (point) eshell-last-output-end))
	(setq clear t)
      (cond
       ((eq this-command 'self-insert-command)
	(if (eq last-command-event ? )
	    (if (and eshell-smart-space-goes-to-end
		     eshell-current-command)
		(if (not (pos-visible-in-window-p (point-max)))
		    (setq this-command 'scroll-up)
		  (setq this-command 'eshell-smart-goto-end))
	      (setq this-command 'scroll-up))
	  (setq clear t)
	  (goto-char (point-max))))
       ((eq this-command 'delete-backward-char)
	(setq this-command 'ignore)
	(if (< (point) eshell-last-input-start)
	    (eshell-show-output)
	  (if (pos-visible-in-window-p eshell-last-input-start)
	      (progn
		(ignore-errors
		  (scroll-down))
		(eshell-show-output))
	    (scroll-down)
	    (if (pos-visible-in-window-p eshell-last-input-end)
		(eshell-show-output)))))
       ((or (memq this-command eshell-smart-display-navigate-list)
	    (and (eq this-command 'eshell-send-input)
		 (not (and (>= (point) eshell-last-input-start)
			   (< (point) eshell-last-input-end)))))
	(setq clear t)
	(goto-char (point-max)))))
    (if clear
	(remove-hook 'pre-command-hook 'eshell-smart-display-move t))))

(provide 'em-smart)

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

;; arch-tag: 8c0112c7-379c-4d54-9a1c-204d68786a4b
;;; em-smart.el ends here
Commit	Line	Data
60370d40	1	;;; em-smart.el --- smart display of output
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
affbf647 GM	23	;;; Commentary:
	24
	25	;; The best way to get a sense of what this code is trying to do is by
	26	;; using it. Basically, the philosophy represents a blend between the
	27	;; ease of use of modern day shells, and the review-before-you-proceed
	28	;; mentality of Plan 9's 9term.
	29	;;
	30	;; @ When you invoke a command, it is assumed that you want to read
	31	;; the output of that command.
	32	;;
	33	;; @ If the output is not what you wanted, it is assumed that you will
	34	;; want to edit, and then resubmit a refined version of that
	35	;; command.
	36	;;
	37	;; @ If the output is valid, pressing any self-inserting character key
	38	;; will jump to end of the buffer and insert that character, in
	39	;; order to begin entry of a new command.
	40	;;
	41	;; @ If you show an intention to edit the previous command -- by
	42	;; moving around within it -- then the next self-inserting
	43	;; characters will insert there, instead of at the bottom of the
	44	;; buffer.
	45	;;
	46	;; @ If you show an intention to review old commands, such as M-p or
	47	;; M-r, point will jump to the bottom of the buffer before invoking
	48	;; that command.
	49	;;
	50	;; @ If none of the above has happened yet (i.e., your point is just
	51	;; sitting on the previous command), you can use SPACE and BACKSPACE
	52	;; (or DELETE) to page forward and backward *through the output of
	53	;; the last command only*. It will constrain the movement of the
	54	;; point and window so that the maximum amount of output is always
	55	;; displayed at all times.
	56	;;
	57	;; @ While output is being generated from a command, the window will
	58	;; be constantly reconfigured (until it would otherwise make no
	59	;; difference) in order to always show you the most output from the
	60	;; command possible. This happens if you change window sizes,
	61	;; scroll, etc.
	62	;;
	63	;; @ Like I said, it's not really comprehensible until you try it! ;)
dace60cf JW	64	;;
	65	;; One disadvantage of this module is that it increases Eshell's
	66	;; memory consumption by a factor of two or more. With small commands
	67	;; (such as pwd), where the screen is mostly full, consumption can
	68	;; increase by orders of magnitude.
affbf647	69
dbba8a04 GM	70	;;; Code:
	71
	72	(eval-when-compile (require 'eshell))
	73
3146b070 GM	74	;;;###autoload
3146b070 GM	75	(eshell-defgroup eshell-smart nil
dbba8a04 GM	76	"This module combines the facility of normal, modern shells with
	77	some of the edit/review concepts inherent in the design of Plan 9's
	78	9term. See the docs for more details.
	79
	80	Most likely you will have to turn this option on and play around with
	81	it to get a real sense of how it works."
	82	:tag "Smart display of output"
	83	;; :link '(info-link "(eshell)Smart display of output")
	84	:group 'eshell-module)
	85
affbf647 GM	86	;;; User Variables:
	87
	88	(defcustom eshell-smart-load-hook '(eshell-smart-initialize)
	89	"*A list of functions to call when loading `eshell-smart'."
	90	:type 'hook
	91	:group 'eshell-smart)
	92
	93	(defcustom eshell-smart-unload-hook
	94	(list
	95	(function
	96	(lambda ()
	97	(remove-hook 'window-configuration-change-hook
	98	'eshell-refresh-windows))))
	99	"*A hook that gets run when `eshell-smart' is unloaded."
	100	:type 'hook
	101	:group 'eshell-smart)
	102
	103	(defcustom eshell-review-quick-commands nil
b4bd214e JW	104	"*If t, always review commands.
	105	Reviewing means keeping point on the text of the command that was just
	106	invoked, to allow corrections to be made easily.
	107
	108	If set to nil, quick commands won't be reviewed. A quick command is a
	109	command that produces no output, and exits successfully.
	110
	111	If set to `not-even-short-output', then the definition of \"quick
bbd44006 JB	112	command\" is extended to include commands that produce output, if and
bbd44006 JB	113	only if that output can be presented in its entirely in the Eshell window."
b4bd214e JW	114	:type '(choice (const :tag "No" nil)
	115	(const :tag "Yes" t)
	116	(const :tag "Not even short output"
	117	not-even-short-output))
affbf647 GM	118	:group 'eshell-smart)
	119
	120	(defcustom eshell-smart-display-navigate-list
	121	'(insert-parentheses
	122	mouse-yank-at-click
	123	mouse-yank-secondary
	124	yank-pop
	125	yank-rectangle
	126	yank)
	127	"*A list of commands which cause Eshell to jump to the end of buffer."
	128	:type '(repeat function)
	129	:group 'eshell-smart)
	130
	131	(defcustom eshell-smart-space-goes-to-end t
	132	"*If non-nil, space will go to end of buffer when point-max is visible.
	133	That is, if a command is running and the user presses SPACE at a time
	134	when the end of the buffer is visible, point will go to the end of the
	135	buffer and smart-display will be turned off (that is, subsequently
	136	pressing backspace will not cause the buffer to scroll down).
	137
	138	This feature is provided to make it very easy to watch the output of a
	139	long-running command, such as make, where it's more desirable to see
	140	the output go by than to review it afterward.
	141
	142	Setting this variable to nil means that space and backspace will
	143	always have a consistent behavior, which is to move back and forth
	144	through displayed output. But it also means that enabling output
	145	tracking requires the user to manually move point to the end of the
	146	buffer using \\[end-of-buffer]."
	147	:type 'boolean
	148	:group 'eshell-smart)
	149
	150	(defcustom eshell-where-to-jump 'begin
	151	"*This variable indicates where point should jump to after a command.
	152	The options are `begin', `after' or `end'."
	153	:type '(radio (const :tag "Beginning of command" begin)
	154	(const :tag "After command word" after)
	155	(const :tag "End of command" end))
	156	:group 'eshell-smart)
	157
	158	;;; Internal Variables:
	159
	160	(defvar eshell-smart-displayed nil)
	161	(defvar eshell-smart-command-done nil)
dace60cf	162	(defvar eshell-currently-handling-window nil)
affbf647 GM	163
	164	;;; Functions:
	165
	166	(defun eshell-smart-initialize ()
	167	"Setup Eshell smart display."
	168	(unless eshell-non-interactive-p
	169	;; override a few variables, since they would interfere with the
	170	;; smart display functionality.
	171	(set (make-local-variable 'eshell-scroll-to-bottom-on-output) nil)
	172	(set (make-local-variable 'eshell-scroll-to-bottom-on-input) nil)
	173	(set (make-local-variable 'eshell-scroll-show-maximum-output) t)
	174
affbf647 GM	175	(add-hook 'window-scroll-functions 'eshell-smart-scroll-window nil t)
	176	(add-hook 'window-configuration-change-hook 'eshell-refresh-windows)
	177
affbf647 GM	178	(add-hook 'eshell-output-filter-functions 'eshell-refresh-windows t t)
affbf647 GM	179
dace60cf	180	(add-hook 'after-change-functions 'eshell-disable-after-change nil t)
affbf647	181
dace60cf	182	(add-hook 'eshell-input-filter-functions 'eshell-smart-display-setup nil t)
affbf647 GM	183
affbf647 GM	184	(make-local-variable 'eshell-smart-command-done)
dace60cf JW	185	(add-hook 'eshell-post-command-hook
	186	(function
	187	(lambda ()
	188	(setq eshell-smart-command-done t))) t t)
affbf647	189
b4bd214e	190	(unless (eq eshell-review-quick-commands t)
affbf647 GM	191	(add-hook 'eshell-post-command-hook
	192	'eshell-smart-maybe-jump-to-end nil t))))
	193
	194	(defun eshell-smart-scroll-window (wind start)
	195	"Scroll the given Eshell window accordingly."
	196	(unless eshell-currently-handling-window
	197	(let ((inhibit-point-motion-hooks t)
	198	(eshell-currently-handling-window t))
dace60cf JW	199	(save-selected-window
	200	(select-window wind)
	201	(eshell-smart-redisplay)))))
affbf647 GM	202
	203	(defun eshell-refresh-windows (&optional frame)
	204	"Refresh all visible Eshell buffers."
	205	(let (affected)
	206	(walk-windows
	207	(function
	208	(lambda (wind)
	209	(with-current-buffer (window-buffer wind)
dace60cf JW	210	(if eshell-mode
	211	(let (window-scroll-functions)
	212	(eshell-smart-scroll-window wind (window-start))
	213	(setq affected t))))))
affbf647 GM	214	0 frame)
	215	(if affected
	216	(let (window-scroll-functions)
	217	(eshell-redisplay)))))
	218
	219	(defun eshell-smart-display-setup ()
	220	"Set the point to somewhere in the beginning of the last command."
	221	(cond
	222	((eq eshell-where-to-jump 'begin)
	223	(goto-char eshell-last-input-start))
	224	((eq eshell-where-to-jump 'after)
	225	(goto-char (next-single-property-change
	226	eshell-last-input-start 'arg-end))
	227	(if (= (point) (- eshell-last-input-end 2))
	228	(forward-char)))
	229	((eq eshell-where-to-jump 'end)
	230	(goto-char (1- eshell-last-input-end)))
	231	(t
	232	(error "Invalid value for `eshell-where-to-jump'")))
	233	(setq eshell-smart-command-done nil)
	234	(add-hook 'pre-command-hook 'eshell-smart-display-move nil t)
	235	(eshell-refresh-windows))
	236
	237	(defun eshell-disable-after-change (b e l)
	238	"Disable smart display mode if the buffer changes in any way."
	239	(when eshell-smart-command-done
	240	(remove-hook 'pre-command-hook 'eshell-smart-display-move t)
	241	(setq eshell-smart-command-done nil)))
	242
	243	(defun eshell-smart-maybe-jump-to-end ()
	244	"Jump to the end of the input buffer.
45a87863	245	This is done whenever a command exits successfully and both the command
b4bd214e	246	and the end of the buffer are still visible."
affbf647	247	(when (and (= eshell-last-command-status 0)
b4bd214e JW	248	(if (eq eshell-review-quick-commands 'not-even-short-output)
	249	(and (pos-visible-in-window-p (point-max))
	250	(pos-visible-in-window-p eshell-last-input-start))
	251	(= (count-lines eshell-last-input-end
	252	eshell-last-output-end) 0)))
affbf647 GM	253	(goto-char (point-max))
	254	(remove-hook 'pre-command-hook 'eshell-smart-display-move t)))
	255
	256	(defun eshell-smart-redisplay ()
	257	"Display as much output as possible, smartly."
	258	(if (eobp)
157975e3 JW	259	(save-excursion
	260	(recenter -1)
	261	;; trigger the redisplay now, so that we catch any attempted
	262	;; point motion; this is to cover for a redisplay bug
	263	(eshell-redisplay))
ca7aae91 JW	264	(let ((top-point (point)))
	265	(and (memq 'eshell-smart-display-move pre-command-hook)
	266	(>= (point) eshell-last-input-start)
	267	(< (point) eshell-last-input-end)
	268	(set-window-start (selected-window)
	269	(line-beginning-position) t))
	270	(if (pos-visible-in-window-p (point-max))
	271	(save-excursion
	272	(goto-char (point-max))
	273	(recenter -1)
	274	(unless (pos-visible-in-window-p top-point)
	275	(goto-char top-point)
	276	(set-window-start (selected-window)
	277	(line-beginning-position) t)))))))
affbf647 GM	278
	279	(defun eshell-smart-goto-end ()
	280	"Like `end-of-buffer', but do not push a mark."
	281	(interactive)
	282	(goto-char (point-max)))
	283
	284	(defun eshell-smart-display-move ()
	285	"Handle self-inserting or movement commands intelligently."
	286	(let (clear)
	287	(if (or current-prefix-arg
	288	(and (> (point) eshell-last-input-start)
	289	(< (point) eshell-last-input-end))
	290	(>= (point) eshell-last-output-end))
	291	(setq clear t)
	292	(cond
	293	((eq this-command 'self-insert-command)
1ba983e8	294	(if (eq last-command-event ? )
affbf647 GM	295	(if (and eshell-smart-space-goes-to-end
	296	eshell-current-command)
	297	(if (not (pos-visible-in-window-p (point-max)))
	298	(setq this-command 'scroll-up)
	299	(setq this-command 'eshell-smart-goto-end))
	300	(setq this-command 'scroll-up))
	301	(setq clear t)
	302	(goto-char (point-max))))
	303	((eq this-command 'delete-backward-char)
	304	(setq this-command 'ignore)
	305	(if (< (point) eshell-last-input-start)
	306	(eshell-show-output)
	307	(if (pos-visible-in-window-p eshell-last-input-start)
	308	(progn
	309	(ignore-errors
	310	(scroll-down))
	311	(eshell-show-output))
	312	(scroll-down)
	313	(if (pos-visible-in-window-p eshell-last-input-end)
	314	(eshell-show-output)))))
	315	((or (memq this-command eshell-smart-display-navigate-list)
	316	(and (eq this-command 'eshell-send-input)
	317	(not (and (>= (point) eshell-last-input-start)
	318	(< (point) eshell-last-input-end)))))
	319	(setq clear t)
	320	(goto-char (point-max)))))
	321	(if clear
	322	(remove-hook 'pre-command-hook 'eshell-smart-display-move t))))
	323
dbba8a04	324	(provide 'em-smart)
affbf647	325
3146b070 GM	326	;; Local Variables:
	327	;; generated-autoload-file: "esh-groups.el"
	328	;; End:
	329
cbee283d	330	;; arch-tag: 8c0112c7-379c-4d54-9a1c-204d68786a4b
affbf647	331	;;; em-smart.el ends here