--- /dev/null
+;;; follow.el --- Minor mode, Synchronize windows showing the same buffer.
+
+;; Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+
+;; Author: Anders Lindgren <andersl@csd.uu.se>
+;; Maintainer: Anders Lindgren <andersl@csd.uu.se>
+;; Created: 25 May 1995
+;; Version: 1.5
+;; Keywords: display, window, minor-mode
+;; Date: 22 Jan 1996
+
+;; This program 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 2, or (at your option)
+;; any later version.
+
+;; This program 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 this program; see the file COPYING. If not, write to
+;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+;;; Commentary:
+
+;;{{{ Documentation
+
+;; `Follow mode' is a minor mode for Emacs 19 and XEmacs which
+;; combines windows into one tall virtual window.
+;;
+;; The feeling of a "virtual window" has been accomplished by the use
+;; of two major techniques:
+;;
+;; * The windows always displays adjacent sections of the buffer.
+;; This means that whenever one window is moved, all the
+;; others will follow. (Hence the name Follow Mode.)
+;;
+;; * Should the point (cursor) end up outside a window, another
+;; window displaying that point is selected, if possible. This
+;; makes it possible to walk between windows using normal cursor
+;; movement commands.
+;;
+;; Follow mode comes to its prime when used on a large screen and two
+;; side-by-side window are used. The user can, with the help of Follow
+;; mode, use two full-height windows as though they would have been
+;; one. Imagine yourself editing a large function, or section of text,
+;; and beeing able to use 144 lines instead of the normal 72... (your
+;; mileage may vary).
+
+;; The latest version, and a demonstration, are avaiable at:
+;;
+;; ftp://ftp.csd.uu.se/pub/users/andersl/emacs/follow.el
+;; http://www.csd.uu.se/~andersl/follow.shtml
+
+;; `Follow mode' can be used together with Emacs 19 and XEmacs.
+;; It has been tested together with Emacs 19.27, 19.28, 19.29,
+;; 19.30, XEmacs 19.12, and 19.13.
+
+
+;; To test this package, make sure `follow' is loaded, or will be
+;; autoloaded when activated (see below). Then do the following:
+;;
+;; * Find your favorite file (preferably a long one.)
+;;
+;; * Resize Emacs so that it will be wide enough for two full sized
+;; columns. Delete the other windows and split with the commands
+;; `C-x 1 C-x 3'.
+;;
+;; * Give the command:
+;; M-x follow-mode <RETURN>
+;;
+;; * Now the display should look something like (assuming the text "71"
+;; is on line 71):
+;;
+;; +----------+----------+
+;; |1 |73 |
+;; |2 |74 |
+;; |3 |75 |
+;; ... ...
+;; |71 |143 |
+;; |72 |144 |
+;; +----------+----------+
+;;
+;; As you can see, the right-hand window starts at line 73, the line
+;; immediately below the end of the left-hand window. As long as
+;; `follow-mode' is active, the two windows will follow eachother!
+;;
+;; * Play around and enjoy! Scroll one window and watch the other.
+;; Jump to the beginning or end. Press `Cursor down' at the last
+;; line of the left-hand window. Enter new lines into the
+;; text. Enter long lines spanning several lines, or several
+;; windows.
+;;
+;; * Should you find `Follow' mode annoying, just type
+;; M-x follow-mode <RETURN>
+;; to turn it off.
+
+
+;; Installation:
+;;
+;; To fully install this, add this file to your Emacs Lisp directory and
+;; compile it with M-x byte-compile-file. Then add the following to the
+;; appropriate init file (normally your `~/.emacs' file):
+;;
+;; (autoload 'follow-mode "follow"
+;; "Synchronize windows showing the same buffer, minor mode." t)
+
+
+;; The command `follow-delete-other-windows-and-split' maximises the
+;; visible area of the current buffer.
+;;
+;; I recommend adding it, and `follow-mode', to hotkeys in the global
+;; key map. To do so, add the following lines (replacing `[f7]' and
+;; `[f8]' with your favorite keys) to the init file:
+;;
+;; (autoload 'follow-mode "follow"
+;; "Synchronize windows showing the same buffer, minor mode." t)
+;; (global-set-key [f8] 'follow-mode)
+;;
+;; (autoload 'follow-delete-other-windows-and-split "follow"
+;; "Delete other windows, split the frame in two, and enter Follow Mode." t)
+;; (global-set-key [f7] 'follow-delete-other-windows-and-split)
+
+
+;; There exists two system variables which controls the appearence of
+;; lines which are wider than the window containing them. The default
+;; is to truncate long lines if a window isn't as wide as the frame.
+;;
+;; To make sure lines are never truncated, please place the following
+;; lines in your init file:
+;;
+;; (setq truncate-lines nil)
+;; (setq truncate-partial-width-windows nil)
+
+
+;; The correct way to cofigurate Follow mode, or any other mode for
+;; that matter, is to create one (or more) function which does
+;; whatever you would like to do. The function is then added to
+;; a hook.
+;;
+;; When `Follow' mode is activated, functions stored in the hook
+;; `follow-mode-hook' are called. When it is deactivated
+;; `follow-mode-off-hook' is runed.
+;;
+;; The keymap `follow-key-map' contains key bindings activated by
+;; `follow-mode'.
+;;
+;; Example:
+;; (add-hook 'follow-mode-hook 'my-follow-mode-hook)
+;;
+;; (defun my-follow-mode-hook ()
+;; (define-key follow-mode-map "\C-ca" 'your-favorite-function)
+;; (define-key follow-mode-map "\C-cb" 'another-function))
+
+
+;; Usage:
+;;
+;; To activate give the command: M-x follow-mode
+;; and press return. To deactivate, do it again.
+;;
+;; Some special commands have been developed to make life even easier:
+;; follow-scroll-up C-c . C-v
+;; Scroll text in a Follow Mode window chain up.
+;;
+;; follow-scroll-down C-c . v
+;; Like `follow-scroll-up', but in the other direction.
+;;
+;; follow-delete-other-windows-and-split C-c . 1
+;; Maximise the visible area of the current buffer,
+;; and enter Follow Mode. This is a very convenient
+;; way to start Follow Mode, hence it is recomended
+;; that this command is added to the global keymap.
+;;
+;; follow-recenter C-c . C-l
+;; Place the point in the center of the middle window,
+;; or a specified number of lines from either top or bottom.
+;;
+;; follow-switch-to-buffer C-c . b
+;; Switch buffer in all windows displaying the current buffer
+;; in this frame.
+;;
+;; follow-switch-to-buffer-all C-c . C-b
+;; Switch buffer in all windows in the active frame.
+;;
+;; follow-switch-to-current-buffer-all
+;; Show the current buffer in all windows on the current
+;; frame and turn on `follow-mode'.
+;;
+;; follow-first-window C-c . <
+;; Select the first window in the frame showing the same buffer.
+;;
+;; follow-last-window C-c . >
+;; Select the last window in the frame showing the same buffer.
+;;
+;; follow-next-window C-c . n
+;; Select the next window in the frame showing the same buffer.
+;;
+;; follow-previous-window C-c . p
+;; Select the previous window showing the same buffer.
+
+
+;; Well, it seems ok, but what if I really want to look at two different
+;; positions in the text? Here are two simple methods to use:
+;;
+;; 1) Use multiple frames; `follow' mode only affects windows displayed
+;; in the same frame. (My apoligies to you who can't use frames.)
+;;
+;; 2) Bind `follow-mode' to key so you can turn it off whenever
+;; you want to view two locations. Of course, `follow' mode can
+;; be reactivated by hitting the same key again.
+;;
+;; Example from my ~/.emacs:
+;; (global-set-key [f8] 'follow-mode)
+
+
+;; Implementation:
+;;
+;; In an ideal world, follow mode would have been implemented in the
+;; kernal of the display routines, making sure that the windows (in
+;; follow mode) ALWAYS are aligned. On planet earth, however, we must
+;; accept a solution where we ALMOST ALWAYS can make sure that the
+;; windows are aligned.
+;;
+;; Follow mode does this in three places:
+;; 1) After each user command.
+;; 2) After a process output has been perfomed.
+;; 3) When a scrollbar has been moved.
+;;
+;; This will cover most situations. (Let me know if there are other
+;; situations which should be covered.)
+;;
+;; However, only the selected window is checked, for the reason of
+;; efficiency and code complexity. (i.e. it is possible to make a
+;; non-selected windows unaligned. It will, however, pop right back
+;; when it is selected.)
+
+;;}}}
+;;{{{ Change Log
+
+;;; Change log:
+;; 25-May-95 andersl * File created.
+;; 26-May-95 andersl * It works!
+;; 27-May-95 andersl * Avoids hitting the head in the roof.
+;; * follow-scroll-up, -scroll-down, and -recenter.
+;; * V0.1 Sent to Ohio.
+;; 28-May-95 andersl * Scroll-bar support added.
+;; 30-May-95 andersl * Code adopted to standard style.
+;; * Minor mode keymap.
+;; 2-Jun-95 andersl * Processor output.
+;; 3-Jun-95 andersl * V0.4
+;; 5-Jun-95 andersl * V0.5. Copyright notice corrected.
+;; (The old one stated that I had copyright, but
+;; that Emacs could be freely distributed ;-) )
+;; 6-Jun-95 andersl * Lucid support added. (no longer valid.)
+;; 7-Jun-95 andersl * Menu bar added.
+;; * Bug fix, (at-window 0 0) => (frame-first-window)
+;; 15-Jun-95 andersl * 0.8 Major rework. looong lines and outline mode.
+;; 18-Jun-95 andersl * 0.9 Allow a tail window to be selected, but pick
+;; a better one when edited.
+;; 26-Jun-95 andersl * Inlineing.
+;; 02-Jul-95 andersl * compute-motion imitated with a ugly workaround,
+;; Works with XEmacs again!
+;; 15-Jul-95 andersl * find-file hook.
+;; * submit-feedback.
+;; * Survives major mode changes.
+;; * Region spanning multiple windows looks
+;; resonabely good.
+;; 19-Jul-95 andersl * New process-filter handling.
+;; 1-Aug-95 andersl * XEmacs scrollbar support.
+;; * Emacs 19 `window-size-change' support.
+;; * `save-window-excursion' removed, it triggered
+;; a redraw!
+;; 5-Aug-95 andersl * `follow-switch-to-current-buffer-all' added.
+;; 16-Nov-95 andersl * V1.0 released!
+;; 17-Nov-95 andersl * Byte compiler silencer for XEmacs broken.
+;; * fkey-end-of-buffer treated the same way
+;; end-of-buffer is.
+;; * follow-mode-off-hook added.
+;; (Suggested by David Hughes, thanks!)
+;; 20-Nov-95 andersl * Bug in menu code corrected.
+;; (Reported by Robert E. Brown, thanks!)
+;; 5-Dec-95 andersl * `follow-avoid-tail-recenter' added to the
+;; post-command-idle-hook to avoid recentering
+;; caused by `paren' et. al.
+;; 7-Dec-95 andersl * `follow-avoid-tail-recenter' called by
+;; `window-scroll-functions'.
+;; 18-Dec-95 andersl * All processes intercepted.
+;; 20-Dec-95 andersl * `follow-recenter' accepts arguments.
+;; * `move-overlay' advices, drag-region works.
+;; 2-Jan-96 andersl * XEmacs: isearch fixed.
+;; * `follow-calc-win-end' created.
+;; 8-Jan-96 andersl * XEmacs: `window-end' with `guarantee'
+;; argument used in `follow-calc-win-end'.
+;; 9-Jan-96 andersl * `follow-end-of-buffer' added.
+;; Code in post hook removed.
+;; * XEmacs: Post hook is always executed
+;; after a mouse button event.
+;; 22-Jan-95 andersl * 1.5 released.
+;;
+
+;;}}}
+;;{{{ LCD Entry
+
+;;; LCD Archive Entry:
+;; follow|Anders Lindgren|andersl@csd.uu.se|
+;; Combines windows into tall virtual window, minor mode.
+;; 22-Jan-1996|1.5|~/modes/follow.el.Z|
+
+;;}}}
+
+;;; Code:
+
+;;{{{ Preliminaries
+
+;; Make the compiler shut up!
+;; There are two strategies:
+;; 1) Shut warnings off completely.
+;; 2) Handle each warning separately.
+;;
+;; Since I would like to see real errors, I've selected the latter
+;; method.
+;;
+;; The problem with undefined variables and functions has been solved
+;; by using `set', `symbol-value' and `symbol-function' rather than
+;; `setq' and direct references to variables and functions.
+;;
+;; For example:
+;; (if (boundp 'foo) ... (symbol-value 'foo) )
+;; (set 'foo ...) <-- XEmacs doesn't fall for this one.
+;; (funcall (symbol-function 'set) 'bar ...)
+;;
+;; Note: When this file is interpreted, `eval-when-compile' is
+;; evaluted (really smart...) Since it doesn't hurt to evaluate it,
+;; but it is a bit annoying, we test if the byte-compiler has been
+;; loaded. This can, of course, lead to some occasional unintended
+;; evaluation...
+;;
+;; Should someone come up with a better solution, please let me
+;; know.
+
+(eval-when-compile
+ (if (or (featurep 'bytecomp)
+ (featurep 'byte-compile))
+ (cond ((string-match "XEmacs" emacs-version)
+ ;; Make XEmacs shut up! I'm using standard Emacs
+ ;; functions, they are NOT obsolete!
+ (if (eq (get 'force-mode-line-update 'byte-compile)
+ 'byte-compile-obsolete)
+ (put 'force-mode-line-update 'byte-compile 'nil))
+ (if (eq (get 'frame-first-window 'byte-compile)
+ 'byte-compile-obsolete)
+ (put 'frame-first-window 'byte-compile 'nil))))))
+
+;;}}}
+;;{{{ Variables
+
+(defvar follow-mode nil
+ "Variable indicating if Follow mode is active.")
+
+(defvar follow-mode-hook nil
+ "*Hooks to run when follow-mode is turned on.")
+
+(defvar follow-mode-off-hook nil
+ "*Hooks to run when follow-mode is turned off.")
+
+(defvar follow-mode-version "follow.el (Release 1.5)"
+ "The current version of Follow mode.")
+
+(defvar follow-mode-map nil
+ "Minor mode keymap for Follow mode.")
+
+(defvar follow-mode-line-text " Follow"
+ "*Text shown in the mode line when Follow mode is active.
+Defaults to \" Follow\". Examples of other values
+are \" Fw\", or simply \"\".")
+
+(defvar follow-auto nil
+ "*Non-nil activates Follow mode whenever a file is loaded.")
+
+(defvar follow-mode-prefix "\C-c."
+ "*Prefix key to use for follow commands in Follow mode.
+The value of this variable is checked as part of loading Follow mode.
+After that, changing the prefix key requires manipulating keymaps.")
+
+(defvar follow-intercept-processes t
+ "*When non-nil, Follow Mode will monitor process output.")
+
+(defvar follow-emacs-version-xemacs-p
+ (string-match "XEmacs" emacs-version)
+ "Non-nil when running under XEmacs.")
+
+(defvar follow-avoid-tail-recenter-p
+ (not follow-emacs-version-xemacs-p)
+ "*When non-nil, patch emacs so that tail windows won't be recentered.
+
+A \"tail window\" is a window which displays only the end of
+the buffer. Normally it is practical for the user that empty
+windows are recentered automatically. However, when using
+Follow Mode it breaks the display when the end is displayed
+in a window \"above\" the last window. This is for
+example the case when displaying short files.
+
+Must be set before Follow Mode is loaded.
+
+Please note that it is not possible to fully prevent Emacs from
+recentering empty windows. Please report if you find a repeatable
+situation in which Emacs recenters empty windows.
+
+XEmacs, as of 19.12, does not recenter windows, good!")
+
+(defvar follow-debug nil
+ "*Non-nil when debugging Follow mode.")
+
+
+;;; Internal variables
+
+(defvar follow-internal-force-redisplay nil
+ "True when Follow mode should redisplay the windows.")
+
+(defvar follow-process-filter-alist '()
+ "The original filters for processes intercepted by Follow mode.")
+
+(defvar follow-active-menu nil
+ "The menu visible when Follow mode is active.")
+
+(defvar follow-deactive-menu nil
+ "The menu visible when Follow mode is deactivated.")
+
+(defvar follow-inside-post-command-hook nil
+ "Non-nil when inside Follow modes `post-command-hook'.
+Used by `follow-window-size-change'.")
+
+;;}}}
+;;{{{ Bug report
+
+(eval-when-compile (require 'reporter))
+
+(defun follow-submit-feedback ()
+ "Sumbit feedback on Follow mode to the author: andersl@csd.uu.se"
+ (interactive)
+ (require 'reporter)
+ (and (y-or-n-p "Do you really want to submit a report on Follow mode? ")
+ (reporter-submit-bug-report
+ "Anders Lindgren <andersl@csd.uu.se>"
+ follow-mode-version
+ '(post-command-hook
+ post-command-idle-hook
+ pre-command-hook
+ window-size-change-functions
+ window-scroll-functions
+ follow-mode-hook
+ follow-mode-off-hook
+ follow-auto
+ follow-intercept-processes
+ follow-avoid-tail-recenter-p
+ follow-process-filter-alist)
+ nil
+ nil
+ (concat
+ "Hi Anders!\n\n"
+ "(I have read the section on how to report bugs in the "
+ "Emacs manual.)\n\n"
+ "Even though I know you are busy, I thought you might "
+ "want to know...\n\n"))))
+
+;;}}}
+;;{{{ Debug messages
+
+;; This inline function must be as small as possible!
+;; Maybe we should define a macro which expands to nil if
+;; the varible is not set.
+
+(defsubst follow-debug-message (&rest args)
+ "Like message, but only active when `follow-debug' is non-nil."
+ (if (and (boundp 'follow-debug) follow-debug)
+ (apply 'message args)))
+
+;;}}}
+
+;;{{{ Keymap/Menu
+
+;;; Define keys for the follow-mode minor mode map and replace some
+;;; functions in the global map. All `follow' mode special functions
+;;; can be found on (the somewhat cumbersome) "C-c . <key>"
+;;; (Control-C dot <key>). (As of Emacs 19.29 the keys
+;;; C-c <punctuation character> are reserved for minor modes.)
+;;;
+;;; To change the prefix, redefine `follow-mode-prefix' before
+;;; `follow' is loaded, or see the section on `follow-mode-hook'
+;;; above for an example of how to bind the keys the way you like.
+;;;
+;;; Please note that the keymap is defined the first time this file is
+;;; loaded. Also note that the only legal way to manipulate the
+;;; keymap is to use `define-key'. Don't change it using `setq' or
+;;; similar!
+
+
+(if follow-mode-map
+ nil
+ (setq follow-mode-map (make-sparse-keymap))
+ (let ((map (make-sparse-keymap)))
+ (define-key map "\C-v" 'follow-scroll-up)
+ (define-key map "\M-v" 'follow-scroll-down)
+ (define-key map "v" 'follow-scroll-down)
+ (define-key map "1" 'follow-delete-other-windows-and-split)
+ (define-key map "b" 'follow-switch-to-buffer)
+ (define-key map "\C-b" 'follow-switch-to-buffer-all)
+ (define-key map "\C-l" 'follow-recenter)
+ (define-key map "<" 'follow-first-window)
+ (define-key map ">" 'follow-last-window)
+ (define-key map "n" 'follow-next-window)
+ (define-key map "p" 'follow-previous-window)
+
+ (define-key follow-mode-map follow-mode-prefix map)
+
+ ;; Replace the standard `end-of-buffer', when in Follow Mode. (I
+ ;; don't see the point in trying to replace every function which
+ ;; could be enhanced in Follow mode. End-of-buffer is a special
+ ;; case since it is very simple to define and it greatly enhances
+ ;; the look and feel of Follow mode.)
+ ;;
+ ;; (The function `substitute-key-definition' does not work
+ ;; in all versions of Emacs.)
+ (mapcar
+ (function
+ (lambda (pair)
+ (let ((old (car pair))
+ (new (cdr pair)))
+ (mapcar (function (lambda (key)
+ (define-key follow-mode-map key new)))
+ (where-is-internal old global-map)))))
+ '((end-of-buffer . follow-end-of-buffer)
+ (fkey-end-of-buffer . follow-end-of-buffer)))
+
+ ;;;
+ ;;; The menu.
+ ;;;
+
+ (if (not follow-emacs-version-xemacs-p)
+
+ ;;
+ ;; Emacs 19
+ ;;
+ (let ((menumap (funcall (symbol-function 'make-sparse-keymap)
+ "Follow"))
+ (count 0)
+ id)
+ (mapcar
+ (function
+ (lambda (item)
+ (setq id
+ (or (cdr item)
+ (progn
+ (setq count (+ count 1))
+ (intern (format "separator-%d" count)))))
+ (define-key menumap (vector id) item)
+ (or (eq id 'follow-mode)
+ (put id 'menu-enable 'follow-mode))))
+ ;; In reverse order:
+ '(("Toggle Follow mode" . follow-mode)
+ ("--")
+ ("Recenter" . follow-recenter)
+ ("--")
+ ("Previous Window" . follow-previous-window)
+ ("Next Windows" . follow-next-window)
+ ("Last Window" . follow-last-window)
+ ("First Window" . follow-first-window)
+ ("--")
+ ("Switch To Buffer (all windows)"
+ . follow-switch-to-buffer-all)
+ ("Switch To Buffer" . follow-switch-to-buffer)
+ ("--")
+ ("Delete Other Windows and Split"
+ . follow-delete-other-windows-and-split)
+ ("--")
+ ("Scroll Down" . follow-scroll-down)
+ ("Scroll Up" . follow-scroll-up)))
+
+ ;; If there is a `tools' meny, we use it. However, we can't add a
+ ;; minor-mode specific item to it (it's broken), so we make the
+ ;; contents ghosted when not in use, and add ourselves to the
+ ;; global map. If no `tools' menu is present, just make a
+ ;; top-level menu visible when the mode is activated.
+
+ (let ((tools-map (lookup-key (current-global-map) [menu-bar tools]))
+ (last nil))
+ (if (sequencep tools-map)
+ (progn
+ ;; Find the last entry in the menu and store it in `last'.
+ (mapcar (function
+ (lambda (x)
+ (setq last (or (cdr-safe
+ (cdr-safe
+ (cdr-safe x)))
+ last))))
+ tools-map)
+ (if last
+ (progn
+ (funcall (symbol-function 'define-key-after)
+ tools-map [separator-follow] '("--") last)
+ (funcall (symbol-function 'define-key-after)
+ tools-map [follow] (cons "Follow" menumap)
+ 'separator-follow))
+ ;; Didn't find the last item, Adding to the top of
+ ;; tools. (This will probably never happend...)
+ (define-key (current-global-map) [menu-bar tools follow]
+ (cons "Follow" menumap))))
+ ;; No tools menu, add "Follow" to the menubar.
+ (define-key follow-mode-map [menu-bar follow]
+ (cons "Follow" menumap)))))
+
+ ;;
+ ;; XEmacs.
+ ;;
+
+ ;; place the menu in the `Tools' menu.
+ (let ((menu '("Follow"
+ :filter follow-menu-filter
+ ["Scroll Up" follow-scroll-up t]
+ ["Scroll Down" follow-scroll-down t]
+ ["Delete Other Windows and Split"
+ follow-delete-other-windows-and-split t]
+ ["Switch To Buffer" follow-switch-to-buffer t]
+ ["Switch To Buffer (all windows)"
+ follow-switch-to-buffer-all t]
+ ["First Window" follow-first-window t]
+ ["Last Window" follow-last-window t]
+ ["Next Windows" follow-next-window t]
+ ["Previous Window" follow-previous-window t]
+ ["Recenter" follow-recenter t]
+ ["Deactivate" follow-mode t])))
+
+ ;; Why not just `(set-buffer-menubar current-menubar)'? The
+ ;; question is a very good question. The reason is that under
+ ;; Emacs 19, neither `set-buffer-menubar' nor
+ ;; `current-menubar' is defined, hence the byte-compiler will
+ ;; warn.
+ (funcall (symbol-function 'set-buffer-menubar)
+ (symbol-value 'current-menubar))
+ (funcall (symbol-function 'add-submenu) '("Tools") menu))
+
+ ;; When the mode is not activated, only one item is visible:
+ ;; "Activate".
+ (defun follow-menu-filter (menu)
+ (if follow-mode
+ menu
+ '(["Activate " follow-mode t]))))))
+
+
+;;; Register the follow mode keymap.
+(or (assq 'follow-mode minor-mode-map-alist)
+ (setq minor-mode-map-alist
+ (cons (cons 'follow-mode follow-mode-map) minor-mode-map-alist)))
+
+;;}}}
+
+;;{{{ The mode
+
+;;;###autoload
+(defun turn-on-follow-mode ()
+ "Turn on Follow mode. Please see the function `follow-mode'."
+ (interactive)
+ (follow-mode 1))
+
+
+;;;###autoload
+(defun turn-off-follow-mode ()
+ "Turn off Follow mode. Please see the function `follow-mode'."
+ (interactive)
+ (follow-mode -1))
+
+
+;;;###autoload
+(defun follow-mode (arg)
+ "Minor mode which combines windows into one tall virtual window.
+
+The feeling of a \"virtual window\" has been accomplished by the use
+of two major techniques:
+
+* The windows always displays adjacent sections of the buffer.
+ This means that whenever one window is moved, all the
+ others will follow. (Hence the name Follow Mode.)
+
+* Should the point (cursor) end up outside a window, another
+ window displaying that point is selected, if possible. This
+ makes it possible to walk between windows using normal cursor
+ movement commands.
+
+Follow mode comes to its prime when used on a large screen and two
+side-by-side window are used. The user can, with the help of Follow
+mode, use two full-height windows as though they would have been
+one. Imagine yourself editing a large function, or section of text,
+and beeing able to use 144 lines instead of the normal 72... (your
+mileage may vary).
+
+To split one large window into two side-by-side windows, the commands
+`\\[split-window-horizontally]' or \
+`M-x follow-delete-other-windows-and-split' can be used.
+
+Only windows displayed in the same frame follow each-other.
+
+If the variable `follow-intercept-processes' is non-nil, Follow mode
+will listen to the output of processes and redisplay accordingly.
+\(This is the default.)
+
+When Follow mode is switched on, the hook `follow-mode-hook'
+is called. When turned off, `follow-mode-off-hook' is called.
+
+Keys specific to Follow mode:
+\\{follow-mode-map}"
+ (interactive "P")
+ (make-local-variable 'follow-mode)
+ (put 'follow-mode 'permanent-local t)
+ (let ((follow-mode-orig follow-mode))
+ (setq follow-mode
+ (if (null arg)
+ (not follow-mode)
+ (> (prefix-numeric-value arg) 0)))
+ (if (and follow-mode follow-intercept-processes)
+ (follow-intercept-process-output))
+ (cond ((and follow-mode (not follow-mode-orig)) ; On
+ ;; XEmacs: If this is non-nil, the window will scroll before
+ ;; the point will have a chance to get into the next window.
+ (if (boundp 'scroll-on-clipped-lines)
+ (set 'scroll-on-clipped-lines nil))
+ (force-mode-line-update)
+ (add-hook 'post-command-hook 'follow-post-command-hook t)
+ (if (boundp 'post-command-idle-hook)
+ (add-hook 'post-command-idle-hook
+ 'follow-avoid-tail-recenter t))
+ (run-hooks 'follow-mode-hook))
+
+ ((and (not follow-mode) follow-mode-orig) ; Off
+ (force-mode-line-update)
+ (run-hooks 'follow-mode-off-hook)))))
+
+
+;; Register follow-mode as a minor mode.
+
+(or (assq 'follow-mode minor-mode-alist)
+ (setq minor-mode-alist
+ (cons '(follow-mode follow-mode-line-text) minor-mode-alist)))
+
+;;}}}
+;;{{{ Find file hook
+
+;; This will start follow-mode whenever a new file is loaded, if
+;; the variable `follow-auto' is non-nil.
+
+(add-hook 'find-file-hooks 'follow-find-file-hook t)
+
+(defun follow-find-file-hook ()
+ "Find-file hook for Follow Mode. See the variable `follow-auto'."
+ (if follow-auto (follow-mode t)))
+
+;;}}}
+
+;;{{{ User functions
+
+;;;
+;;; User functions usable when in Follow mode.
+;;;
+
+;;{{{ Scroll
+
+;; `scroll-up' and `-down', but for windows in Follow Mode.
+;;
+;; Almost like the real thing, excpet when the cursor ends up outside
+;; the top or bottom... In our case however, we end up outside the
+;; window and hence we are recenterd. Should we let `recenter' handle
+;; the point position we would never leave the selected window. To do
+;; it ourselves we would need to do our own redisplay, which is easier
+;; said than done. (Why didn't I do a real display abstraction from
+;; the beginning?)
+;;
+;; We must sometimes set `follow-internal-force-redisplay', otherwise
+;; our post-command-hook will move our windows back into the old
+;; position... (This would also be corrected if we would have had a
+;; good redisplay abstraction.)
+
+(defun follow-scroll-up (&optional arg)
+ "Scroll text in a Follow Mode window chain up.
+
+If called with no ARG, the `next-screen-context-lines' last lines of
+the bottom window in the chain will be visible in the top window.
+
+If called with an argument, scroll ARG lines up.
+Negative ARG means scroll downward.
+
+Works like `scroll-up' when not in Follow Mode."
+ (interactive "P")
+ (cond ((not (and (boundp 'follow-mode) follow-mode))
+ (scroll-up arg))
+ (arg
+ (save-excursion (scroll-up arg))
+ (setq follow-internal-force-redisplay t))
+ (t
+ (let* ((windows (follow-all-followers))
+ (end (window-end (car (reverse windows)))))
+ (if (eq end (point-max))
+ (signal 'end-of-buffer nil)
+ (select-window (car windows))
+ (goto-char end)
+ (vertical-motion (- next-screen-context-lines))
+ (set-window-start (car windows) (point)))))))
+
+
+(defun follow-scroll-down (&optional arg)
+ "Scroll text in a Follow Mode window chain down.
+
+If called with no ARG, the `next-screen-context-lines' top lines of
+the top window in the chain will be visible in the bottom window.
+
+If called with an argument, scroll ARG lines down.
+Negative ARG means scroll upward.
+
+Works like `scroll-up' when not in Follow Mode."
+ (interactive "P")
+ (cond ((not (and (boundp 'follow-mode) follow-mode))
+ (scroll-up arg))
+ (arg
+ (save-excursion (scroll-down arg)))
+ (t
+ (let* ((windows (follow-all-followers))
+ (win (car (reverse windows)))
+ (start (window-start (car windows))))
+ (if (eq start (point-min))
+ (signal 'beginning-of-buffer nil)
+ (select-window win)
+ (goto-char start)
+ (vertical-motion (- (- (window-height win)
+ 1
+ next-screen-context-lines)))
+ (set-window-start win (point))
+ (goto-char start)
+ (vertical-motion (- next-screen-context-lines 1))
+ (setq follow-internal-force-redisplay t))))))
+
+;;}}}
+;;{{{ Buffer
+
+;;;###autoload
+(defun follow-delete-other-windows-and-split (&optional arg)
+ "Create two side by side windows and enter Follow Mode.
+
+Execute this command to display as much as possible of the text
+in the selected window. All other windows, in the current
+frame, are deleted and the selected window is split in two
+side-by-side windows. Follow Mode is activated, hence the
+two windows always will display two successive pages.
+\(If one window is moved, the other one will follow.)
+
+If ARG is positive, the leftmost window is selected. If it negative,
+the rightmost is selected. If ARG is nil, the leftmost window is
+selected if the original window is the first one in the frame.
+
+To bind this command to a hotkey, place the following line
+in your `~/.emacs' file, replacing [f7] by your favourite key:
+ (global-set-key [f7] 'follow-delete-other-windows-and-split)"
+ (interactive "P")
+ (let ((other (or (and (null arg)
+ (not (eq (selected-window)
+ (frame-first-window (selected-frame)))))
+ (and arg
+ (< (prefix-numeric-value arg) 0))))
+ (start (window-start)))
+ (delete-other-windows)
+ (split-window-horizontally)
+ (if other
+ (progn
+ (other-window 1)
+ (set-window-start (selected-window) start)
+ (setq follow-internal-force-redisplay t)))
+ (follow-mode 1)))
+
+(defun follow-switch-to-buffer (buffer)
+ "Show BUFFER in all windows in the current Follow Mode window chain."
+ (interactive "BSwitch to Buffer: ")
+ (let ((orig-window (selected-window))
+ (windows (follow-all-followers)))
+ (while windows
+ (select-window (car windows))
+ (switch-to-buffer buffer)
+ (setq windows (cdr windows)))
+ (select-window orig-window)))
+
+
+(defun follow-switch-to-buffer-all (&optional buffer)
+ "Show BUFFER in all windows on this frame.
+Defaults to current buffer."
+ (interactive (list (read-buffer "Switch to Buffer: "
+ (current-buffer))))
+ (or buffer (setq buffer (current-buffer)))
+ (let ((orig-window (selected-window)))
+ (walk-windows
+ (function
+ (lambda (win)
+ (select-window win)
+ (switch-to-buffer buffer))))
+ (select-window orig-window)
+ (follow-redisplay)))
+
+
+(defun follow-switch-to-current-buffer-all ()
+ "Show current buffer in all windows on this frame, and enter Follow Mode.
+
+To bind this command to a hotkey place the following line
+in your `~/.emacs' file:
+ (global-set-key [f7] 'follow-switch-to-current-buffer-all)"
+ (interactive)
+ (or (and (boundp 'follow-mode) follow-mode)
+ (follow-mode 1))
+ (follow-switch-to-buffer-all))
+
+;;}}}
+;;{{{ Movement
+
+;; Note, these functions are not very useful, atleast not unless you
+;; rebind the rather cumbersome key sequence `C-c . p'.
+
+(defun follow-next-window ()
+ "Select the next window showing the same buffer."
+ (interactive)
+ (let ((succ (cdr (follow-split-followers (follow-all-followers)))))
+ (if succ
+ (select-window (car succ))
+ (error "%s" "No more windows"))))
+
+
+(defun follow-previous-window ()
+ "Select the previous window showing the same buffer."
+ (interactive)
+ (let ((pred (car (follow-split-followers (follow-all-followers)))))
+ (if pred
+ (select-window (car pred))
+ (error "%s" "No more windows"))))
+
+
+(defun follow-first-window ()
+ "Select the first window in the frame showing the same buffer."
+ (interactive)
+ (select-window (car (follow-all-followers))))
+
+
+(defun follow-last-window ()
+ "Select the last window in the frame showing the same buffer."
+ (interactive)
+ (select-window (car (reverse (follow-all-followers)))))
+
+;;}}}
+;;{{{ Redraw
+
+(defun follow-recenter (&optional arg)
+ "Recenter the middle window around the point,
+and rearrange all other windows around the middle window.
+
+With a positive argument, place the current line ARG lines
+from the top. With a negative, place it -ARG lines from the
+bottom."
+ (interactive "P")
+ (if arg
+ (let ((p (point))
+ (arg (prefix-numeric-value arg)))
+ (if (>= arg 0)
+ ;; Recenter relative to the top.
+ (progn
+ (follow-first-window)
+ (goto-char p)
+ (recenter arg))
+ ;; Recenter relative to the bottom.
+ (follow-last-window)
+ (goto-char p)
+ (recenter arg)
+ ;; Otherwise, our post-command-hook will move the window
+ ;; right back.
+ (setq follow-internal-force-redisplay t)))
+ ;; Recenter in the middle.
+ (let* ((dest (point))
+ (windows (follow-all-followers))
+ (win (nth (/ (- (length windows) 1) 2) windows)))
+ (select-window win)
+ (goto-char dest)
+ (recenter)
+ ;;(setq follow-internal-force-redisplay t)
+ )))
+
+
+(defun follow-redraw ()
+ "Arrange windows displaying the same buffer in successor order.
+This function can be called even if the buffer is not in Follow mode.
+
+Hopefully, there should be no reason to call this function when in
+Follow mode since the windows should always be aligned."
+ (interactive)
+ (sit-for 0)
+ (follow-redisplay))
+
+;;}}}
+;;{{{ End of buffer
+
+(defun follow-end-of-buffer (&optional arg)
+ "Move point to the end of the buffer. Follow Mode style.
+
+If the end is not visible, it will be displayed in the last possible
+window in the Follow Mode window chain.
+
+The mark is left at the previous position. With arg N, put point N/10
+of the way from the true end."
+ (interactive "P")
+ (let ((followers (follow-all-followers))
+ (pos (point)))
+ (cond (arg
+ (select-window (car (reverse followers))))
+ ((follow-select-if-end-visible
+ (follow-windows-start-end followers)))
+ (t
+ (select-window (car (reverse followers)))))
+ (goto-char pos)
+ (end-of-buffer arg)))
+
+;;}}}
+
+;;}}}
+
+;;{{{ Display
+
+;;;; The display routines
+
+;;{{{ Information gathering functions
+
+(defun follow-all-followers (&optional testwin)
+ "Return all windows displaying the same buffer as the TESTWIN.
+The list contains only windows displayed in the same frame as TESTWIN.
+If TESTWIN is nil the selected window is used."
+ (or (and testwin (window-live-p testwin))
+ (setq testwin (selected-window)))
+ (let* ((top (frame-first-window (window-frame testwin)))
+ (win top)
+ (done nil)
+ (windows '())
+ (buffer (window-buffer testwin)))
+ (while (and (not done) win)
+ (if (eq (window-buffer win) buffer)
+ (setq windows (cons win windows)))
+ (setq win (next-window win 'not))
+ (if (eq win top)
+ (setq done t)))
+ (nreverse windows)))
+
+
+(defun follow-split-followers (windows &optional win)
+ "Split the WINDOWS into the sets: predecessors and successors.
+Return `(PRED . SUCC)' where `PRED' and `SUCC' are ordered starting
+from the selected window."
+ (or win
+ (setq win (selected-window)))
+ (let ((pred '()))
+ (while (not (eq (car windows) win))
+ (setq pred (cons (car windows) pred))
+ (setq windows (cdr windows)))
+ (cons pred (cdr windows))))
+
+
+;; Try to optimize this function for speed!
+
+(defun follow-calc-win-end (&optional win)
+ "Calculate the presumed window end for WIN.
+
+Actually, the position returned is the start of the next
+window, normally is the end plus one.
+
+If WIN is nil, the selected window is used.
+
+Returns (end-pos end-of-buffer-p)"
+ (if follow-emacs-version-xemacs-p
+ ;; XEmacs can calculate the end of the window by using
+ ;; the 'guarantee options. GOOD!
+ (let ((end (window-end win t)))
+ (if (= end (funcall (symbol-function 'point-max)
+ (window-buffer win)))
+ (list end t)
+ (list (+ end 1) nil)))
+ ;; Emacs 19: We have to calculate the end by ourselves.
+ ;; This code works on both XEmacs and Emacs 19, but now
+ ;; that XEmacs has got custom-written code, this could
+ ;; be optimized for Emacs 19.
+ (let ((orig-win (and win (selected-window)))
+ height
+ buffer-end-p)
+ (if win (select-window win))
+ (prog1
+ (save-excursion
+ (goto-char (window-start))
+ (setq height (- (window-height) 1))
+ (setq buffer-end-p
+ (if (bolp)
+ (not (= height (vertical-motion height)))
+ (save-restriction
+ ;; Fix a mis-feature in `vertical-motion':
+ ;; The start of the window is assumed to
+ ;; coinside with the start of a line.
+ (narrow-to-region (point) (point-max))
+ (not (= height (vertical-motion height))))))
+ (list (point) buffer-end-p))
+ (if orig-win
+ (select-window orig-win))))))
+
+
+;; Can't use `save-window-excursion' since it triggers a redraw.
+(defun follow-calc-win-start (windows pos win)
+ "Calculate where WIN will start if the first in WINDOWS start at POS.
+
+If WIN is nil the point below all windows is returned."
+ (let (start)
+ (while (and windows (not (eq (car windows) win)))
+ (setq start (window-start (car windows)))
+ (set-window-start (car windows) pos 'noforce)
+ (setq pos (car (inline (follow-calc-win-end (car windows)))))
+ (set-window-start (car windows) start 'noforce)
+ (setq windows (cdr windows)))
+ pos))
+
+
+;; Build a list of windows and their start and end positions.
+;; Useful to avoid calculating start/end position whenever they are needed.
+;; The list has the format:
+;; ((Win Start End End-of-buffer-visible-p) ...)
+
+;; Used to have a `save-window-excursion', but it obviously triggered
+;; redraws of the display. Check if I used it for anything.
+
+
+(defun follow-windows-start-end (windows)
+ "Builds a list of (WIN START END BUFFER-END-P) for every window in WINDOWS."
+ (let ((win-start-end '())
+ (orig-win (selected-window)))
+ (while windows
+ (select-window (car windows))
+ (setq win-start-end
+ (cons (cons (car windows)
+ (cons (window-start)
+ (follow-calc-win-end)))
+ win-start-end))
+ (setq windows (cdr windows)))
+ (select-window orig-win)
+ (nreverse win-start-end)))
+
+
+(defun follow-pos-visible (pos win win-start-end)
+ "Non-nil when POS is visible in WIN."
+ (let ((wstart-wend-bend (cdr (assq win win-start-end))))
+ (and (>= pos (car wstart-wend-bend))
+ (or (< pos (car (cdr wstart-wend-bend)))
+ (nth 2 wstart-wend-bend)))))
+
+
+;; By `aligned' we mean that for all adjecent windows, the end of the
+;; first is equal with the start of the successor. The first window
+;; should start at a full screen line.
+
+(defun follow-windows-aligned-p (win-start-end)
+ "Non-nil if the follower WINDOWS are alinged."
+ (let ((res t))
+ (save-excursion
+ (goto-char (window-start (car (car win-start-end))))
+ (if (bolp)
+ nil
+ (vertical-motion 0 (car (car win-start-end)))
+ (setq res (eq (point) (window-start (car (car win-start-end)))))))
+ (while (and res (cdr win-start-end))
+ ;; At least two followers left
+ (setq res (eq (nth 2 (car win-start-end))
+ (nth 1 (car (cdr win-start-end)))))
+ (setq win-start-end (cdr win-start-end)))
+ res))
+
+
+;; Check if the point is visible in all windows. (So that
+;; no one will be recentered.)
+
+(defun follow-point-visible-all-windows-p (win-start-end)
+ "Non-nil when the window-point is visible in all windows."
+ (let ((res t))
+ (while (and res win-start-end)
+ (setq res (inline
+ (follow-pos-visible (window-point (car (car win-start-end)))
+ (car (car win-start-end))
+ win-start-end)))
+ (setq win-start-end (cdr win-start-end)))
+ res))
+
+
+;; Make sure WIN always starts at the beginning of an whole screen
+;; line. If WIN is not aligned the start is updated which probably
+;; will lead to a redisplay of the screen later on.
+;;
+;; This is used with the first window in a follow chain. The reason
+;; is that we want to detect that the point is outside the window.
+;; (Without the update, the start of the window will move as the
+;; user presses BackSpace, and the other window redisplay routines
+;; will move the start of the window in the wrong direction.)
+
+(defun follow-update-window-start (win)
+ "Make sure that the start of WIN starts at a full screen line."
+ (save-excursion
+ (goto-char (window-start win))
+ (if (bolp)
+ nil
+ (vertical-motion 0 win)
+ (if (eq (point) (window-start win))
+ nil
+ (vertical-motion 1 win)
+ (set-window-start win (point) 'noforce)))))
+
+;;}}}
+;;{{{ Selection functions
+
+;; Make a window in WINDOWS selected if it currently
+;; is displaying the position DEST.
+;;
+;; We don't select a window if it just has been moved.
+
+(defun follow-select-if-visible (dest win-start-end)
+ "Select and return a window, if DEST is visible in it.
+Return the selected window."
+ (let ((win nil))
+ (while (and (not win) win-start-end)
+ ;; Don't select a window which was just moved. This makes it
+ ;; possible to later select the last window after a `end-of-buffer'
+ ;; command.
+ (if (follow-pos-visible dest (car (car win-start-end)) win-start-end)
+ (progn
+ (setq win (car (car win-start-end)))
+ (select-window win)))
+ (setq win-start-end (cdr win-start-end)))
+ win))
+
+
+;; Lets select a window showing the end. Make sure we only select it if it
+;; it wasn't just moved here. (i.e. M-> shall not unconditionally place
+;; the point in the selected window.)
+;;
+;; (Compability cludge: in Emacs 19 `window-end' is equal to `point-max';
+;; in XEmacs, it is equal to `point-max + 1'. Should I really bother
+;; checking `window-end' now when I check `end-of-buffer' explicitylt?)
+
+(defun follow-select-if-end-visible (win-start-end)
+ "Select and return a window, if end is visible in it."
+ (let ((win nil))
+ (while (and (not win) win-start-end)
+ ;; Don't select a window which was just moved. This makes it
+ ;; possible to later select the last window after a `end-of-buffer'
+ ;; command.
+ (if (and (eq (point-max) (nth 2 (car win-start-end)))
+ (nth 3 (car win-start-end))
+ (eq (point-max) (min (point-max)
+ (window-end (car (car win-start-end))))))
+ (progn
+ (setq win (car (car win-start-end)))
+ (select-window win)))
+ (setq win-start-end (cdr win-start-end)))
+ win))
+
+
+;; Select a window which will display the point if the windows would
+;; be redisplayed with the first window fixed. This is useful for
+;; example when the user has pressed return at the bottom of a window
+;; as the point is not visible in any window.
+
+(defun follow-select-if-visible-from-first (dest windows)
+ "Select and return a window with DEST, if WINDOWS are redrawn from top."
+ (let ((win nil)
+ end-pos-end-p)
+ (save-excursion
+ (goto-char (window-start (car windows)))
+ ;; Make sure the line start in the beginning of a real screen
+ ;; line.
+ (vertical-motion 0 (car windows))
+ (if (< dest (point))
+ ;; Above the start, not visible.
+ nil
+ ;; At or below the start. Check the windows.
+ (save-window-excursion
+ (while (and (not win) windows)
+ (set-window-start (car windows) (point) 'noforce)
+ (setq end-pos-end-p (follow-calc-win-end (car windows)))
+ (goto-char (car end-pos-end-p))
+ ;; Visible, if dest above end, or if eob is visible inside
+ ;; the window.
+ (if (or (car (cdr end-pos-end-p))
+ (< dest (point)))
+ (setq win (car windows))
+ (setq windows (cdr windows)))))))
+ (if win
+ (select-window win))
+ win))
+
+
+;;}}}
+;;{{{ Redisplay
+
+;; Redraw all the windows on the screen, starting with the top window.
+;; The window used as as marker is WIN, or the selcted window if WIN
+;; is nil.
+
+(defun follow-redisplay (&optional windows win)
+ "Reposition the WINDOWS around WIN.
+Should the point be too close to the roof we redisplay everything
+from the top. WINDOWS should contain a list of windows to
+redisplay, it is assumed that WIN is a member of the list.
+Should WINDOWS be nil, the windows displaying the
+same buffer as WIN, in the current frame, are used.
+Should WIN be nil, the selected window is used."
+ (or win
+ (setq win (selected-window)))
+ (or windows
+ (setq windows (follow-all-followers win)))
+ (follow-downward windows (follow-calculate-first-window-start windows win)))
+
+
+;; Redisplay a chain of windows. Start every window directly after the
+;; end of the previous window, to make sure long lines are displayed
+;; correctly.
+
+(defun follow-downward (windows pos)
+ "Redisplay all WINDOWS starting at POS."
+ (while windows
+ (set-window-start (car windows) pos)
+ (setq pos (car (follow-calc-win-end (car windows))))
+ (setq windows (cdr windows))))
+
+
+;;(defun follow-downward (windows pos)
+;; "Redisplay all WINDOWS starting at POS."
+;; (let (p)
+;; (while windows
+;; (setq p (window-point (car windows)))
+;; (set-window-start (car windows) pos)
+;; (set-window-point (car windows) (max p pos))
+;; (setq pos (car (follow-calc-win-end (car windows))))
+;; (setq windows (cdr windows)))))
+
+
+;; Return the start of the first window.
+;;
+;; First, estimate the position. It the value is not perfect (i.e. we
+;; have somewhere splited a line between windows) we try to enhance
+;; the value.
+;;
+;; The guess is always perfect if no long lines is split between
+;; windows.
+;;
+;; The worst case peformace of probably very bad, but it is very
+;; unlikely that we ever will miss the correct start by more than one
+;; or two lines.
+
+(defun follow-calculate-first-window-start (windows &optional win start)
+ "Calculate the start of the first window.
+
+WINDOWS is a chain of windows to work with. WIN is the window
+to recenter around. It is assumed that WIN starts at position
+START."
+ (or win
+ (setq win (selected-window)))
+ (or start
+ (setq start (window-start win)))
+ (let ((guess (follow-estimate-first-window-start windows win start)))
+ (if (car guess)
+ (cdr guess)
+ ;; The guess wasn't exact, try to enhance it.
+ (let ((win-start (follow-calc-win-start windows (cdr guess) win)))
+ (cond ((= win-start start)
+ (follow-debug-message "exact")
+ (cdr guess))
+ ((< win-start start)
+ (follow-debug-message "above")
+ (follow-calculate-first-window-start-from-above
+ windows (cdr guess) win start))
+ (t
+ (follow-debug-message "below")
+ (follow-calculate-first-window-start-from-below
+ windows (cdr guess) win start)))))))
+
+
+;; `exact' is disabled due to XEmacs and fonts of variable
+;; height.
+(defun follow-estimate-first-window-start (windows win start)
+ "Estimate the position of the first window.
+
+Returns (EXACT . POS). If EXACT is non-nil, POS is the starting
+position of the first window. Otherwise it is a good guess."
+ (let ((pred (car (follow-split-followers windows win)))
+ (exact nil))
+ (save-excursion
+ (goto-char start)
+ ;(setq exact (bolp))
+ (vertical-motion 0 win)
+ (while pred
+ (vertical-motion (- 1 (window-height (car pred))) (car pred))
+ (if (not (bolp))
+ (setq exact nil))
+ (setq pred (cdr pred)))
+ (cons exact (point)))))
+
+
+;; Find the starting point, start at GUESS and search downward.
+;; The returned point is always a point below GUESS.
+
+(defun follow-calculate-first-window-start-from-above
+ (windows guess win start)
+ (save-excursion
+ (let ((done nil)
+ win-start
+ res)
+ (goto-char guess)
+ (while (not done)
+ (if (not (= (vertical-motion 1 (car windows)) 1))
+ ;; Hit bottom! (Can we really do this?)
+ ;; We'll keep it, since it ensures termination.
+ (progn
+ (setq done t)
+ (setq res (point-max)))
+ (setq win-start (follow-calc-win-start windows (point) win))
+ (if (>= win-start start)
+ (progn
+ (setq done t)
+ (setq res (point))))))
+ res)))
+
+
+;; Find the starting point, start at GUESS and search upward. Return
+;; a point on the same line as GUESS, or above.
+;;
+;; (Is this ever used? I must make sure it works just in case it is
+;; ever called.)
+
+(defun follow-calculate-first-window-start-from-below
+ (windows guess &optional win start)
+ (setq win (or win (selected-window)))
+ (setq start (or start (window-start win)))
+ (save-excursion
+ (let ((done nil)
+ win-start
+ res)
+ ;; Always calculate what happend when no line is displayed in the first
+ ;; window. (The `previous' res is needed below!)
+ (goto-char guess)
+ (vertical-motion 0 (car windows))
+ (setq res (point))
+ (while (not done)
+ (if (not (= (vertical-motion -1 (car windows)) -1))
+ ;; Hit roof!
+ (progn
+ (setq done t)
+ (setq res (point-min)))
+ (setq win-start (follow-calc-win-start windows (point) win))
+ (cond ((= win-start start) ; Perfect match, use this value
+ (setq done t)
+ (setq res (point)))
+ ((< win-start start) ; Walked to far, use preious result
+ (setq done t))
+ (t ; Store result for next iteration
+ (setq res (point))))))
+ res)))
+
+;;}}}
+;;{{{ Avoid tail recenter
+
+;; This sets the window internal flag `force_start'. The effect is that
+;; windows only displaying the tail isn't recentered.
+;; Has to be called before every redisplay... (Great isn't it?)
+;;
+;; XEmacs doesn't recenter the tail, GOOD!
+;;
+;; A window displaying only the tail, is a windows whose
+;; window-start position is equal to (point-max) of the buffer it
+;; displays.
+;;
+;; This function is also added to `post-command-idle-hook', introduced
+;; in Emacs 19.30. This is needed since the vaccine injected by the
+;; call from `post-command-hook' only works until the next redisplay.
+;; It is possible that the functions in the `post-command-idle-hook'
+;; can cause a redisplay, and hence a new vaccine is needed.
+;;
+;; Sometimes, calling this function could actually cause a redisplay,
+;; especially if it is placed in the debug filter section. I must
+;; investigate this further...
+
+(defun follow-avoid-tail-recenter (&rest rest)
+ "Make sure windows displaying the end of a buffer aren't recentered.
+
+This is done by reading and rewriting the start positon of
+non-first windows in Follow Mode."
+ (if follow-avoid-tail-recenter-p
+ (let* ((orig-buffer (current-buffer))
+ (top (frame-first-window (selected-frame)))
+ (win top)
+ (who '()) ; list of (buffer . frame)
+ start
+ pair) ; (buffer . frame)
+ (while ;; look, no body!
+ (progn
+ (setq start (window-start win))
+ (set-buffer (window-buffer win))
+ (setq pair (cons (window-buffer win) (window-frame win)))
+ (if (member pair who)
+ (if (and (boundp 'follow-mode) follow-mode
+ (eq (point-max) start))
+ ;; Write the same window start back, but don't
+ ;; set the NOFORCE flag.
+ (set-window-start win start))
+ (setq who (cons pair who)))
+ (setq win (next-window win 'not t))
+ (not (eq win top)))) ;; Loop while this is true.
+ (set-buffer orig-buffer))))
+
+;;}}}
+
+;;}}}
+;;{{{ Post Command Hook
+
+;;; The magic little box. This function is called after every command.
+
+;; This is not as complicated as it seems. It is simply a list of common
+;; display situations and the actions to take, plus commands for redrawing
+;; the screen if it should be unaligned.
+;;
+;; We divide the check into two parts; whether we are at the end or not.
+;; This is due to the fact that the end can actaually be visible
+;; in several window even though they are aligned.
+
+(defun follow-post-command-hook ()
+ "Ensure that the windows in Follow mode are adjecent after each command."
+ (setq follow-inside-post-command-hook t)
+ (if (or (not (input-pending-p))
+ ;; Sometimes, in XEmacs, mouse events are not handled
+ ;; properly by `input-pending-p'. A typical example is
+ ;; when clicking on a node in `info'.
+ (and (boundp 'current-mouse-event)
+ (symbol-value 'current-mouse-event)
+ (fboundp 'button-event-p)
+ (funcall (symbol-function 'button-event-p)
+ (symbol-value 'current-mouse-event))))
+ ;; Work in the selected window, not in the current buffer.
+ (let ((orig-buffer (current-buffer))
+ (win (selected-window)))
+ (set-buffer (window-buffer win))
+ (if (and (boundp 'follow-mode) follow-mode
+ (not (window-minibuffer-p win)))
+ ;; The buffer shown in the selected window is in follow
+ ;; mode, lets find the current state of the display and
+ ;; cache the result for speed (i.e. `aligned' and `visible'.)
+ (let* ((windows (inline (follow-all-followers win)))
+ (dest (point))
+ (win-start-end (progn
+ (follow-update-window-start (car windows))
+ (follow-windows-start-end windows)))
+ (aligned (follow-windows-aligned-p win-start-end))
+ (visible (follow-pos-visible dest win win-start-end)))
+ (follow-avoid-tail-recenter)
+ ;; Select a window to display the point.
+ (or follow-internal-force-redisplay
+ (progn
+ (if (eq dest (point-max))
+ ;; We're at the end, we have be be careful since
+ ;; the display can be aligned while `dest' can
+ ;; be visible in several windows.
+ (cond
+ ;; Select the current window, but only when
+ ;; the display is correct. (When inserting
+ ;; character in a tail window, the display is
+ ;; not correct, as they are shown twice.)
+ ;;
+ ;; Never stick to the current window after a
+ ;; deletion. The reason is cosmetic, when
+ ;; typing `DEL' in a window showing only the
+ ;; end of the file, character are removed
+ ;; from the window above, which is very
+ ;; unintuitive.
+ ((and visible
+ aligned
+ (not (memq this-command
+ '(backward-delete-char
+ delete-backward-char
+ backward-delete-char-untabify
+ kill-region))))
+ (follow-debug-message "Max: same"))
+ ;; If the end is visible, and the window
+ ;; doesn't seems like it just has been moved,
+ ;; select it.
+ ((follow-select-if-end-visible win-start-end)
+ (follow-debug-message "Max: end visible")
+ (setq visible t)
+ (setq aligned nil)
+ (goto-char dest))
+ ;; Just show the end...
+ (t
+ (follow-debug-message "Max: default")
+ (select-window (car (reverse windows)))
+ (goto-char dest)
+ (setq visible nil)
+ (setq aligned nil)))
+
+ ;; We're not at the end, here life is much simpler.
+ (cond
+ ;; This is the normal case!
+ ;; It should be optimized for speed.
+ ((and visible aligned)
+ (follow-debug-message "same"))
+ ;; Pick a position in any window. If the
+ ;; display is ok, this will pick the `correct'
+ ;; window. If the display is wierd do this
+ ;; anyway, this will be the case after a delete
+ ;; at the beginning of the window.
+ ((follow-select-if-visible dest win-start-end)
+ (follow-debug-message "visible")
+ (setq visible t)
+ (goto-char dest))
+ ;; Not visible anywhere else, lets pick this one.
+ ;; (Is this case used?)
+ (visible
+ (follow-debug-message "visible in selected."))
+ ;; Far out!
+ ((eq dest (point-min))
+ (follow-debug-message "min")
+ (select-window (car windows))
+ (goto-char dest)
+ (set-window-start (selected-window) (point-min))
+ (setq win-start-end (follow-windows-start-end windows))
+ (setq visible t)
+ (setq aligned nil))
+ ;; If we can position the cursor without moving the first
+ ;; window, do it. This is the case which catches `RET'
+ ;; at the bottom of a window.
+ ((follow-select-if-visible-from-first dest windows)
+ (follow-debug-message "Below first")
+ (setq visible t)
+ (setq aligned t)
+ (follow-redisplay windows (car windows))
+ (goto-char dest))
+ ;; None of the above. For simplicity, we stick to the
+ ;; selected window.
+ (t
+ (follow-debug-message "None")
+ (setq visible nil)
+ (setq aligned nil))))
+ ;; If a new window has been selected, make sure that the
+ ;; old is not scrolled when the point is outside the
+ ;; window.
+ (or (eq win (selected-window))
+ (let ((p (window-point win)))
+ (set-window-start win (window-start win) nil)
+ (set-window-point win p)))))
+ ;; Make sure the point is visible in the selected window.
+ ;; (This could lead to a scroll.)
+ (if (or visible
+ (follow-pos-visible dest win win-start-end))
+ nil
+ (sit-for 0)
+ (follow-avoid-tail-recenter)
+ (setq win-start-end (follow-windows-start-end windows))
+ (setq aligned nil))
+ ;; Redraw the windows whenever needed.
+ (if (or follow-internal-force-redisplay
+ (not (or aligned
+ (follow-windows-aligned-p win-start-end)))
+ (not (inline (follow-point-visible-all-windows-p
+ win-start-end))))
+ (progn
+ (setq follow-internal-force-redisplay nil)
+ (follow-redisplay windows (selected-window))
+ (setq win-start-end (follow-windows-start-end windows))
+ ;; When the point ends up in another window. This
+ ;; happends when dest is in the beginning of the
+ ;; file and the selected window is not the first.
+ ;; It can also, in rare situations happend when
+ ;; long lines are used and there is a big
+ ;; difference between the width of the windows.
+ ;; (When scrolling one line in a wide window which
+ ;; will cause a move larger that an entire small
+ ;; window.)
+ (if (follow-pos-visible dest win win-start-end)
+ nil
+ (follow-select-if-visible dest win-start-end)
+ (goto-char dest))))
+
+ ;; If the region is visible, make it look good when spanning
+ ;; multiple windows.
+ (if (or (and (boundp 'mark-active) (symbol-value 'mark-active))
+ (and (fboundp 'region-active-p)
+ (funcall (symbol-function 'region-active-p))))
+ (follow-maximize-region
+ (selected-window) windows win-start-end))
+
+ (follow-avoid-tail-recenter)
+ ;; DEBUG
+ ;;(if (not (follow-windows-aligned-p
+ ;; (follow-windows-start-end windows)))
+ ;; (message "follow-mode: windows still unaligend!"))
+ ;; END OF DEBUG
+ ) ; Matches (let*
+ ;; Buffer not in follow mode:
+ ;; We still must update the windows displaying the tail so that
+ ;; Emacs won't recenter them.
+ (follow-avoid-tail-recenter))
+ (set-buffer orig-buffer)))
+ (setq follow-inside-post-command-hook nil))
+
+;;}}}
+;;{{{ The region
+
+;; Tries to make the highlighted area representing the region look
+;; good when spanning several windows.
+;;
+;; Not perfect, as the point can't be placed at window end, only at
+;; end-1. Whis will highlight a little bit in windows above
+;; the current.
+
+(defun follow-maximize-region (win windows win-start-end)
+ "Make a highlighted region stretching multiple windows look good
+when in Follow mode."
+ (let* ((all (follow-split-followers windows win))
+ (pred (car all))
+ (succ (cdr all))
+ data)
+ (while pred
+ (setq data (assq (car pred) win-start-end))
+ (set-window-point (car pred) (max (nth 1 data) (- (nth 2 data) 1)))
+ (setq pred (cdr pred)))
+ (while succ
+ (set-window-point (car succ) (nth 1 (assq (car succ) win-start-end)))
+ (setq succ (cdr succ)))))
+
+;;}}}
+;;{{{ Scroll bar
+
+;;;; Scroll-bar support code.
+
+;;; Why is it needed? Well, if the selected window is in follow mode,
+;;; all its follower stick to it blindly. If one of them is scrolled,
+;;; it immediately returns to the original position when the mouse is
+;;; released. If the selected window is not a follower of the dragged
+;;; window the windows will be unaligned.
+
+;;; The advices doesn't get compiled. Aestetically, this might be a
+;;; problem but in practical life it isn't.
+
+;;; Discussion: Now when the other windows in the chain follow the
+;;; dragged, should we really select it?
+
+(cond ((fboundp 'scroll-bar-drag)
+ ;;;
+ ;;; Emacs 19 style scrollbars.
+ ;;;
+
+ ;; Select the dragged window if it is a follower of the
+ ;; selected window.
+ ;;
+ ;; Generate advices of the form:
+ ;; (defadvice scroll-bar-drag (after follow-scroll-bar-drag activate)
+ ;; "Adviced by `follow-mode'."
+ ;; (follow-redraw-after-event (ad-get-arg 0)))
+ (let ((cmds '(scroll-bar-drag
+ scroll-bar-drag-1 ; Executed at every move.
+ scroll-bar-scroll-down
+ scroll-bar-scroll-up
+ scroll-bar-set-window-start)))
+ (while cmds
+ (eval
+ (` (defadvice (, (intern (symbol-name (car cmds))))
+ (after
+ (, (intern (concat "follow-" (symbol-name (car cmds)))))
+ activate)
+ "Adviced by Follow Mode."
+ (follow-redraw-after-event (ad-get-arg 0)))))
+ (setq cmds (cdr cmds))))
+
+
+ (defun follow-redraw-after-event (event)
+ "Adviced by Follow mode."
+ (condition-case nil
+ (let* ((orig-win (selected-window))
+ (win (nth 0 (funcall
+ (symbol-function 'event-start) event)))
+ (fmode (assq 'follow-mode
+ (buffer-local-variables
+ (window-buffer win)))))
+ (if (and fmode (cdr fmode))
+ ;; The selected window is in follow-mode
+ (progn
+ ;; Recenter around the dragged window.
+ (select-window win)
+ (follow-redisplay)
+ (select-window orig-win))))
+ (error nil))))
+
+
+ ((fboundp 'scrollbar-vertical-drag)
+ ;;;
+ ;;; XEmacs style scrollbars.
+ ;;;
+
+ ;; Advice all scrollbar functions on the form:
+ ;;
+ ;; (defadvice scrollbar-line-down
+ ;; (after follow-scrollbar-line-down activate)
+ ;; (follow-xemacs-scrollbar-support (ad-get-arg 0)))
+
+ (let ((cmds '(scrollbar-line-down ; Window
+ scrollbar-line-up
+ scrollbar-page-down ; Object
+ scrollbar-page-up
+ scrollbar-to-bottom ; Window
+ scrollbar-to-top
+ scrollbar-vertical-drag ; Object
+ )))
+
+ (while cmds
+ (eval
+ (` (defadvice (, (intern (symbol-name (car cmds))))
+ (after
+ (, (intern (concat "follow-" (symbol-name (car cmds)))))
+ activate)
+ "Adviced by `follow-mode'."
+ (follow-xemacs-scrollbar-support (ad-get-arg 0)))))
+ (setq cmds (cdr cmds))))
+
+
+ (defun follow-xemacs-scrollbar-support (window)
+ "Redraw windows showing the same buffer as shown in WINDOW.
+WINDOW is either the dragged window, or a cons containing the
+window as its first element. This is called while the user drags
+the scrollbar.
+
+WINDOW can be an object or a window."
+ (condition-case nil
+ (progn
+ (if (consp window)
+ (setq window (car window)))
+ (let ((fmode (assq 'follow-mode
+ (buffer-local-variables
+ (window-buffer window))))
+ (orig-win (selected-window)))
+ (if (and fmode (cdr fmode))
+ (progn
+ ;; Recenter around the dragged window.
+ (select-window window)
+ (follow-redisplay)
+ (select-window orig-win)))))
+ (error nil)))))
+
+;;}}}
+;;{{{ Process output
+
+;;; The following sections installs a spy which listens to process
+;;; output and tries to reposition the windows whose buffers are in
+;;; Follow mode. We play safe as much as possible...
+;;;
+;;; When follow-mode is activated all active processes are
+;;; intercepted. All new processes which change their filter function
+;;; using `set-process-filter' are also intercepted. The reason is
+;;; that a process can cause a redisplay recentering "tail" windows.
+;;; Note that it doesn't hurt to spy on more processes than needed.
+;;;
+;;; Technically, we set the process filter to `follow-generic-filter'.
+;;; The original filter is stored in `follow-process-filter-alist'.
+;;; Our generic filter calls the original filter, or inserts the
+;;; output into the buffer, if the buffer originally didn't have an
+;;; output filter. It also makes sure that the windows connected to
+;;; the buffer are aligned.
+;;;
+;;; Discussion: How to we find processes which doesn't call
+;;; `set-process-filter'? (How often are processes created in a
+;;; buffer after Follow mode are activated?)
+;;;
+;;; Discussion: Should we also advice `process-filter' to make our
+;;; filter invisible to others?
+
+;;{{{ Advice for `set-process-filter'
+
+;; Do not call this with 'follow-generic-filter as the name of the
+;; filter...
+
+(defadvice set-process-filter (before follow-set-process-filter activate)
+ "Follow Mode listens to calls to this function to make
+sure process output will be displayed correctly in buffers
+in which the mode is activated.
+
+Follow Mode inserts it's own process filter to do it's
+magic stuff before the real process filter is called."
+ (if follow-intercept-processes
+ (progn
+ (setq follow-process-filter-alist
+ (delq (assq (ad-get-arg 0) follow-process-filter-alist)
+ follow-process-filter-alist))
+ (follow-tidy-process-filter-alist)
+ (cond ((eq (ad-get-arg 1) t))
+ ((eq (ad-get-arg 1) nil)
+ (ad-set-arg 1 'follow-generic-filter))
+ (t
+ (setq follow-process-filter-alist
+ (cons (cons (ad-get-arg 0) (ad-get-arg 1))
+ follow-process-filter-alist))
+ (ad-set-arg 1 'follow-generic-filter))))))
+
+
+(defun follow-call-set-process-filter (proc filter)
+ "Call original `set-process-filter' without the Follow mode advice."
+ (ad-disable-advice 'set-process-filter 'before
+ 'follow-set-process-filter)
+ (ad-activate 'set-process-filter)
+ (prog1
+ (set-process-filter proc filter)
+ (ad-enable-advice 'set-process-filter 'before
+ 'follow-set-process-filter)
+ (ad-activate 'set-process-filter)))
+
+
+(defadvice process-filter (after follow-process-filter activate)
+ "Normally when Follow mode is activated all processes has the
+process filter set to `follow-generic-filter'. With this advice,
+the original process filter is returned."
+ (cond ((eq ad-return-value 'follow-generic-filter)
+ (setq ad-return-value
+ (cdr-safe (assq (ad-get-arg 0)
+ follow-process-filter-alist))))))
+
+
+(defun follow-call-process-filter (proc)
+ "Call original `process-filter' without the Follow mode advice."
+ (ad-disable-advice 'process-filter 'after
+ 'follow-process-filter)
+ (ad-activate 'process-filter)
+ (prog1
+ (process-filter proc)
+ (ad-enable-advice 'process-filter 'after
+ 'follow-process-filter)
+ (ad-activate 'process-filter)))
+
+
+(defun follow-tidy-process-filter-alist ()
+ "Remove old processes from `follow-process-filter-alist'."
+ (let ((alist follow-process-filter-alist)
+ (ps (process-list))
+ (new ()))
+ (while alist
+ (if (and (not (memq (process-status (car (car alist)))
+ '(exit signal closed nil)))
+ (memq (car (car alist)) ps))
+ (setq new (cons (car alist) new)))
+ (setq alist (cdr alist)))
+ (setq follow-process-filter-alist new)))
+
+;;}}}
+;;{{{ Start/stop interception of processes.
+
+;; Normally, all new processed are intercepted by our `set-process-filter'.
+;; This is needed to intercept old processed which were started before we were
+;; loaded, and processes we have forgotten by calling
+;; `follow-stop-intercept-process-output'.
+
+(defun follow-intercept-process-output ()
+ "Intercept all active processes.
+
+This is needed so that Follow Mode can track all display events in the
+system. (See `follow-mode')"
+ (interactive)
+ (let ((list (process-list)))
+ (while list
+ (if (eq (process-filter (car list)) 'follow-generic-filter)
+ nil
+ ;; The custom `set-process-filter' defined above.
+ (set-process-filter (car list) (process-filter (car list))))
+ (setq list (cdr list))))
+ (setq follow-intercept-processes t))
+
+
+(defun follow-stop-intercept-process-output ()
+ "Stop Follow Mode from spying on processes.
+
+All current spypoints are removed and no new will be added.
+
+The effect is that Follow mode won't be able to handle buffers
+connected to processes.
+
+The only reason to call this function is if the Follow mode spy filter
+would interfere with some other package. If this happens, please
+report this using the `follow-submit-feedback' function."
+ (interactive)
+ (follow-tidy-process-filter-alist)
+ (let ((list (process-list)))
+ (while list
+ (if (eq (process-filter (car list)) 'follow-generic-filter)
+ (progn
+ (follow-call-set-process-filter
+ (car list)
+ (cdr-safe (assq (car list) follow-process-filter-alist)))
+ (setq follow-process-filter-alist
+ (delq (assq (car list) follow-process-filter-alist)
+ follow-process-filter-alist))))
+ (setq list (cdr list))))
+ (setq follow-intercept-processes nil))
+
+;;}}}
+;;{{{ The filter
+
+;;; The following section is a naive method to make buffers with
+;;; process output to work with Follow mode. Whenever the start of the
+;;; window displaying the buffer is moved, we moves it back to it's
+;;; original position and try to select a new window. (If we fail,
+;;; the normal redisplay functions of Emacs will scroll it right
+;;; back!)
+
+(defun follow-generic-filter (proc output)
+ "Process output filter for process connected to buffers in Follow mode."
+ (let* ((old-buffer (current-buffer))
+ (orig-win (selected-window))
+ (buf (process-buffer proc))
+ (win (and buf (if (eq buf (window-buffer orig-win))
+ orig-win
+ (get-buffer-window buf t))))
+ (return-to-orig-win (and win (not (eq win orig-win))))
+ (orig-window-start (and win (window-start win))))
+
+ ;; If input is pending, the `sit-for' below won't redraw the
+ ;; display. In that case, calling `follow-avoid-tail-recenter' may
+ ;; provoke the process hadnling code to sceduling a redisplay.
+ ;(or (input-pending-p)
+ ; (follow-avoid-tail-recenter))
+
+ ;; Output the `output'.
+ (let ((filter (cdr-safe (assq proc follow-process-filter-alist))))
+ (cond
+ ;; Call the original filter function
+ (filter
+ (funcall filter proc output))
+
+ ;; No filter, but we've got a buffer. Just output into it.
+ (buf
+ (set-buffer buf)
+ (if (not (marker-buffer (process-mark proc)))
+ (set-marker (process-mark proc) (point-max)))
+ (let ((moving (= (point) (process-mark proc)))
+ (odeactivate (and (boundp 'deactivate-mark)
+ (symbol-value 'deactivate-mark)))
+ (old-buffer-read-only buffer-read-only))
+ (setq buffer-read-only nil)
+ (save-excursion
+ (goto-char (process-mark proc))
+ ;; `insert-before-markers' just in case the users next
+ ;; command is M-y.
+ (insert-before-markers output)
+ (set-marker (process-mark proc) (point)))
+ (if moving (goto-char (process-mark proc)))
+ (if (boundp 'deactivate-mark)
+ ;; This could really be
+ ;; (setq deactivate-mark odeactivate)
+ ;; but this raises an error when compiling on XEmacs.
+ (funcall (symbol-function 'set)
+ 'deactivate-mark odeactivate))
+ (setq buffer-read-only old-buffer-read-only)))))
+
+ ;; If we're in follow mode, do our stuff. Select a new window and
+ ;; redisplay. (Actually, it is redundant to check `buf', but I
+ ;; feel it's more correct.)
+ (if (and buf win (window-live-p win))
+ (progn
+ (set-buffer buf)
+ (if (and (boundp 'follow-mode) follow-mode)
+ (progn
+ (select-window win)
+ (let* ((windows (follow-all-followers win))
+ (win-start-end (follow-windows-start-end windows))
+ (new-window-start (window-start win))
+ (new-window-point (window-point win)))
+ (cond
+ ;; The window was moved. Move it back and
+ ;; select a new. If no better could be found,
+ ;; we stick the the new start position. This
+ ;; is used when the original process filter
+ ;; tries to position the cursor at the bottom
+ ;; of the window. Example: `lyskom'.
+ ((not (eq orig-window-start new-window-start))
+ (follow-debug-message "filter: Moved")
+ (set-window-start win orig-window-start)
+ (follow-redisplay windows win)
+ (setq win-start-end (follow-windows-start-end windows))
+ (follow-select-if-visible new-window-point
+ win-start-end)
+ (goto-char new-window-point)
+ (if (eq win (selected-window))
+ (set-window-start win new-window-start))
+ (setq win-start-end (follow-windows-start-end windows)))
+ ;; Stick to this window, if point is visible in it.
+ ((pos-visible-in-window-p new-window-point)
+ (follow-debug-message "filter: Visible in window"))
+ ;; Avoid redisplaying the first window. If the
+ ;; point is visible at a window below,
+ ;; redisplay and select it.
+ ((follow-select-if-visible-from-first
+ new-window-point windows)
+ (follow-debug-message "filter: Seen from first")
+ (follow-redisplay windows (car windows))
+ (goto-char new-window-point)
+ (setq win-start-end
+ (follow-windows-start-end windows)))
+ ;; None of the above. We stick to the current window.
+ (t
+ (follow-debug-message "filter: nothing")))
+
+ ;; Here we have slected a window. Make sure the
+ ;; windows are aligned and the point is visible
+ ;; in the selected window.
+ (if (and (not (follow-pos-visible
+ (point) (selected-window) win-start-end))
+ (not return-to-orig-win))
+ (progn
+ (sit-for 0)
+ (setq win-start-end
+ (follow-windows-start-end windows))))
+
+ (if (or follow-internal-force-redisplay
+ (not (follow-windows-aligned-p win-start-end)))
+ (follow-redisplay windows)))))))
+
+ ;; return to the original window.
+ (if return-to-orig-win
+ (select-window orig-win))
+ (set-buffer old-buffer))
+
+ ;; Normally, if the display has been changed, it is redrawn. All
+ ;; windows showing only the end of a buffer is unconditionally
+ ;; recentered, we can't prevent it by calling
+ ;; `follow-avoid-tail-recenter'.
+ ;;
+ ;; By performing a redisplay on our own, Emacs need not perform
+ ;; the above described redisplay. (However, bu performing it when
+ ;; there are input available just seems to make things worse.)
+ (if (and follow-avoid-tail-recenter-p
+ (not (input-pending-p)))
+ (sit-for 0)))
+
+;;}}}
+
+;;}}}
+;;{{{ Window size change
+
+;; In Emacs 19.29, the functions in `window-size-change-functions' are
+;; called every time a window in a frame changes size. Most notably, it
+;; is called after the frame has been resized.
+;;
+;; We basically call our post-command-hook for every buffer which is
+;; visible in any window in the resized frame, which is in follow-mode.
+;;
+;; Since this function can be called indirectly from
+;; `follow-post-command-hook' we have a potential infinite loop. We
+;; handle this problem by simply not doing anything at all in this
+;; situation. The variable `follow-inside-post-command-hook' contains
+;; information about whether the execution actually is inside the
+;; post-command-hook or not.
+
+(if (boundp 'window-size-change-functions)
+ (add-hook 'window-size-change-functions 'follow-window-size-change))
+
+
+(defun follow-window-size-change (frame)
+ "Redraw all windows in FRAME, when in Follow mode."
+ ;; Below, we call `post-command-hook'. This makes sure that we
+ ;; doesn't start a mutally recursive endless loop.
+ (if follow-inside-post-command-hook
+ nil
+ (let ((buffers '())
+ (orig-window (selected-window))
+ (orig-buffer (current-buffer))
+ (orig-frame (selected-frame))
+ windows
+ buf)
+ (select-frame frame)
+ (unwind-protect
+ (walk-windows
+ (function
+ (lambda (win)
+ (setq buf (window-buffer win))
+ (if (memq buf buffers)
+ nil
+ (set-buffer buf)
+ (if (and (boundp 'follow-mode)
+ follow-mode)
+ (progn
+ (setq windows (follow-all-followers win))
+ (if (memq orig-window windows)
+ (progn
+ ;; Make sure we're redrawing around the
+ ;; selected window.
+ ;;
+ ;; We must be really careful not to do this
+ ;; when we are (indirectly) called by
+ ;; `post-command-hook'.
+ (select-window orig-window)
+ (follow-post-command-hook)
+ (setq orig-window (selected-window)))
+ (follow-redisplay windows win))
+ (setq buffers (cons buf buffers))))))))
+ (select-frame orig-frame)
+ (set-buffer orig-buffer)
+ (select-window orig-window)))))
+
+;;}}}
+
+;;{{{ XEmacs isearch
+
+;; In XEmacs, isearch often finds matches in other windows than the
+;; currently selected. However, when exiting the old window
+;; configuration is restored, with the exception of the beginning of
+;; the start of the window for the selected window. This is not much
+;; help for us.
+;;
+;; We overwrite the stored window configuration with the current,
+;; unless we are in `slow-search-mode', i.e. only a few lines
+;; of text is visible.
+
+(if follow-emacs-version-xemacs-p
+ (defadvice isearch-done (before follow-isearch-done activate)
+ (if (and (boundp 'follow-mode)
+ follow-mode
+ (boundp 'isearch-window-configuration)
+ isearch-window-configuration
+ (boundp 'isearch-slow-terminal-mode)
+ (not isearch-slow-terminal-mode))
+ (let ((buf (current-buffer)))
+ (setq isearch-window-configuration
+ (current-window-configuration))
+ (set-buffer buf)))))
+
+;;}}}
+;;{{{ Tail window handling
+
+;;; In Emacs (not XEmacs) windows showing nothing are sometimes
+;;; recentered. When in Follow Mode, this is not desireable for
+;;; non-first windows in the window chain. This section tries to
+;;; make the windows stay where they should be.
+;;;
+;;; If the display is updated, all windows starting at (point-max) are
+;;; going to be recentered at the next redisplay, unless we do a
+;;; read-and-write cycle to update the `force' flag inside the windows.
+;;;
+;;; In 19.30, a new varible `window-scroll-functions' is called every
+;;; time a window is recentered. It is not perfect for our situation,
+;;; since when it is called for a tail window, it is to late. However,
+;;; if it is called for another window, we can try to update our
+;;; windows.
+;;;
+;;; By patching `sit-for' we can make sure that to catch all explicit
+;;; updates initiated by lisp programs. Internal calls, on the other
+;;; hand, are not handled.
+;;;
+;;; Please note that the function `follow-avoid-tail-recenter' is also
+;;; called from other places, e.g. `post-command-hook' and
+;;; `post-command-idle-hook'.
+
+;; If this function is called it is to late for this window, but
+;; we might save other windows from beeing recentered.
+
+(if (and follow-avoid-tail-recenter-p (boundp 'window-scroll-functions))
+ (add-hook 'window-scroll-functions 'follow-avoid-tail-recenter t))
+
+
+;; This prevents all packages which calls `sit-for' directly
+;; to recenter tail windows.
+
+(if follow-avoid-tail-recenter-p
+ (defadvice sit-for (before follow-sit-for activate)
+ "Adviced by Follow Mode.
+
+Avoid to recenter windows displaying only the end of a file as when
+displaying a short file in two windows, using Follow Mode."
+ (follow-avoid-tail-recenter)))
+
+
+;; Without this advice, `mouse-drag-region' would start to recenter
+;; tail windows.
+
+(if (and follow-avoid-tail-recenter-p
+ (fboundp 'move-overlay))
+ (defadvice move-overlay (before follow-move-overlay activate)
+ "Adviced by Follow Mode. Don't recenter windows showing only
+the end of a buffer. This prevents `mouse-drag-region' from
+messing things up."
+ (follow-avoid-tail-recenter)))
+
+;;}}}
+;;{{{ profile support
+
+;; The following (non-evaluated) section can be used to
+;; profile this package using `elp'.
+;;
+;; Invalid indentation on purpose!
+
+(cond (nil
+(setq elp-function-list
+ '(window-end
+ vertical-motion
+ ; sit-for ;; elp can't handle advices...
+ follow-mode
+ follow-all-followers
+ follow-split-followers
+ follow-redisplay
+ follow-downward
+ follow-calculate-first-window-start
+ follow-estimate-first-window-start
+ follow-calculate-first-window-start-from-above
+ follow-calculate-first-window-start-from-below
+ follow-calc-win-end
+ follow-calc-win-start
+ follow-pos-visible
+ follow-windows-start-end
+ follow-select-if-visible
+ follow-select-if-visible-from-first
+ follow-windows-aligned-p
+ follow-point-visible-all-windows-p
+ follow-avoid-tail-recenter
+ follow-update-window-start
+ follow-post-command-hook
+ ))))
+
+;;}}}
+
+;;{{{ The end
+
+;;;
+;;; We're done!
+;;;
+
+(provide 'follow)
+
+;;}}}
+
+;; /------------------------------------------------------------------------\
+;; | "I [..] am rarely happier then when spending an entire day programming |
+;; | my computer to perform automatically a task that it would otherwise |
+;; | take me a good ten seconds to do by hand. Ten seconds, I tell myself, |
+;; | is ten seconds. Time is valuable and ten seconds' worth of it is well |
+;; | worth the investment of a day's happy activity working out a way to |
+;; | save it". -- Douglas Adams, "Last Chance to See" |
+;; \------------------------------------------------------------------------/
+
+;;; follow.el ends here
HCoop / bpt / emacs.git / commitdiff