Mercurial > hg > xemacs-beta
comparison lisp/packages/scroll-in-place.el @ 0:376386a54a3c r19-14
Import from CVS: tag r19-14
| author | cvs |
|---|---|
| date | Mon, 13 Aug 2007 08:45:50 +0200 |
| parents | |
| children | b82b59fe008d |
comparison
equal
deleted
inserted
replaced
| -1:000000000000 | 0:376386a54a3c |
|---|---|
| 1 | |
| 2 ;;;; -*-Emacs-Lisp-*- Improved Vertical Scrolling Commands | |
| 3 ;;;; Written by Eric Eide, last modified on 1994/11/18 21:23:01. | |
| 4 ;;;; (C) Copyright 1993, 1994, Eric Eide and the University of Utah | |
| 5 ;;;; | |
| 6 ;;;; COPYRIGHT NOTICE | |
| 7 ;;;; | |
| 8 ;;;; This program is free software; you can redistribute it and/or modify it | |
| 9 ;;;; under the terms of the GNU General Public License as published by the Free | |
| 10 ;;;; Software Foundation; either version 2 of the License, or (at your option) | |
| 11 ;;;; any later version. | |
| 12 ;;;; | |
| 13 ;;;; This program is distributed in the hope that it will be useful, but | |
| 14 ;;;; WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY | |
| 15 ;;;; or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 16 ;;;; for more details. | |
| 17 ;;;; | |
| 18 ;;;; You should have received a copy of the GNU General Public License along | |
| 19 ;;;; with GNU Emacs. If you did not, write to the Free Software Foundation, | |
| 20 ;;;; Inc., 675 Mass Ave., Cambridge, MA 02139, USA. | |
| 21 | |
| 22 ;;; Synched up with: Not in FSF. | |
| 23 | |
| 24 ;;;; AUTHORS | |
| 25 ;;;; | |
| 26 ;;;; This package was written by Eric Eide (eeide@cs.utah.edu) and was based on | |
| 27 ;;;; a very similar package ("scroll-fix") by Joe Wells. Almost all of the | |
| 28 ;;;; code in this file is original, but I owe a great debt to Mr. Wells for his | |
| 29 ;;;; ideas and his original implementation. | |
| 30 ;;;; | |
| 31 ;;;; Eric Eide (eeide@cs.utah.edu) | |
| 32 ;;;; University of Utah | |
| 33 ;;;; 3190 Merrill Engineering Building | |
| 34 ;;;; Salt Lake City, Utah 84112 | |
| 35 ;;;; | |
| 36 ;;;; Joe Wells (jbw@cs.bu.edu) | |
| 37 ;;;; | |
| 38 ;;;; Joe Wells' "scroll-fix" package is Copyright (C) 1988, 1989, and 1991 by | |
| 39 ;;;; the Free Software Foundation. It is distributed under the terms of the | |
| 40 ;;;; GNU General Public License. | |
| 41 | |
| 42 ;;;; LISP CODE DIRECTORY INFORMATION | |
| 43 ;;;; | |
| 44 ;;;; LCD Archive Entry: | |
| 45 ;;;; scroll-in-place|Eric Eide|eeide@cs.utah.edu| | |
| 46 ;;;; Improved vertical scrolling commands| | |
| 47 ;;;; 1994/11/18 21:23:01|1.3|~/misc/scroll-in-place.el.Z| | |
| 48 | |
| 49 ;;;; SUMMARY | |
| 50 ;;;; | |
| 51 ;;;; This package provides improved vertical scrolling commands for GNU Emacs. | |
| 52 ;;;; These new commands offer the following features: | |
| 53 ;;;; | |
| 54 ;;;; + When a scrolling command is executed, GNU Emacs tries to keep point as | |
| 55 ;;;; close as possible to its original window position (window line and | |
| 56 ;;;; column). This is what "scroll in place" means: point stays "in place" | |
| 57 ;;;; within the window. (There are times when point must be moved from its | |
| 58 ;;;; original window position in order to execute the scroll; see below.) | |
| 59 ;;;; | |
| 60 ;;;; The variable `scroll-in-place', which is true by default, determines | |
| 61 ;;;; whether or not the standard GNU Emacs scrolling commands (`scroll-down', | |
| 62 ;;;; `scroll-up', `scroll-other-window-down', and `scroll-other-window') use | |
| 63 ;;;; the "in place" features listed here. When `scroll-in-place' is `nil' | |
| 64 ;;;; the standard GNU Emacs scrolling commands essentially just call the | |
| 65 ;;;; original versions of themselves. (Note that even when `scroll-in-place' | |
| 66 ;;;; is `nil' the new versions of `scroll-down' and `scroll-up' have slightly | |
| 67 ;;;; different behavior when a minibuffer window is the selected window. See | |
| 68 ;;;; below.) | |
| 69 ;;;; | |
| 70 ;;;; It is possible to turn off (or turn on) "in place" scrolling for certain | |
| 71 ;;;; buffers by making buffer-local bindings of the variable `scroll-in- | |
| 72 ;;;; place' for those buffers. The variable `scroll-in-place' is not usually | |
| 73 ;;;; buffer-local, but you can make it so if you desire. | |
| 74 ;;;; | |
| 75 ;;;; + Because the improved scrolling commands keep point at its original | |
| 76 ;;;; window position, these scrolling commands are "reversible." The | |
| 77 ;;;; `scroll-up' command undoes the effect of the immediately previous | |
| 78 ;;;; `scroll-down' command (if any) and vice versa. In other words, if you | |
| 79 ;;;; scroll up and then immediately scroll back down, the window config- | |
| 80 ;;;; uration is restored to its exact original state. This allows you to | |
| 81 ;;;; browse through a buffer more easily, as you can always get back to the | |
| 82 ;;;; original configuration. | |
| 83 ;;;; | |
| 84 ;;;; Note, however, that the improved scrolling commands are guaranteed to be | |
| 85 ;;;; reversible only if there are no intervening non-scrolling commands. | |
| 86 ;;;; Also, if you give a prefix argument to a scrolling command (in order to | |
| 87 ;;;; specify the number of lines to scroll by), previous scrolling commands | |
| 88 ;;;; may no longer be reversible. More specifically, if the new prefix | |
| 89 ;;;; argument has a different magnitude than the previous scrolling distance, | |
| 90 ;;;; then any previous scrolling commands are not reversible. The new prefix | |
| 91 ;;;; argument takes precedence. | |
| 92 ;;;; | |
| 93 ;;;; You might find it useful to think of the scrolling commands as forming | |
| 94 ;;;; "chains." A scrolling command either starts or continues a chain. By | |
| 95 ;;;; issuing a non-scrolling command or by changing the number of lines to be | |
| 96 ;;;; scrolled, you break the chain. (Note that simply changing the scrolling | |
| 97 ;;;; direction won't break the chain; changing the absolute number of lines | |
| 98 ;;;; to be scrolled is what breaks the chain.) Scrolling commands are | |
| 99 ;;;; guaranteed to be reversible only within the current chain. Hopefully | |
| 100 ;;;; that's clear enough. | |
| 101 ;;;; | |
| 102 ;;;; + When a scrolling command is given a prefix argument (which specifies the | |
| 103 ;;;; number of lines to scroll by), then that argument becomes the default | |
| 104 ;;;; scrolling distance for all immediately subsequent scrolling commands. | |
| 105 ;;;; This means that you can easily set the scrolling distance for a chain | |
| 106 ;;;; of scrolling commands. Note that a new prefix argument or any non- | |
| 107 ;;;; scrolling command breaks the chain (as described above), and any further | |
| 108 ;;;; scrolling commands will use the usual defaults (or the prefix argument | |
| 109 ;;;; you specify at that time, of course). | |
| 110 ;;;; | |
| 111 ;;;; However, there are cases in which one doesn't want the current scrolling | |
| 112 ;;;; command to use the default scrolling distance that was set by the | |
| 113 ;;;; previous scrolling command. For example, suppose that you had special | |
| 114 ;;;; commands that scrolled one line up and one line down. When you invoke | |
| 115 ;;;; one of these commands, the "in place" scrolling routines set the default | |
| 116 ;;;; scrolling distance to be just one line. Now suppose that you use one of | |
| 117 ;;;; your special commands and then immediately invoke `scroll-up' (`C-v'), | |
| 118 ;;;; expecting it to scroll by a near windowful of text. You would be | |
| 119 ;;;; disappointed --- because the previous command set the default scrolling | |
| 120 ;;;; distance to be just one line, `scroll-up' just scrolls by one line. | |
| 121 ;;;; | |
| 122 ;;;; To solve this problem, "scroll-in-place" allows you to divide scrolling | |
| 123 ;;;; commands into separate "groups." Commands in a group can only form | |
| 124 ;;;; chains with (and therefore, inherit defaults from) commands in the same | |
| 125 ;;;; group. (Note that no command can be in more than one group.) If you | |
| 126 ;;;; invoke a scrolling command that is not in the same group as that of the | |
| 127 ;;;; immediately previous scrolling command, then the previous chain is | |
| 128 ;;;; broken and you start a new chain --- with a new set of defaults. | |
| 129 ;;;; | |
| 130 ;;;; So to solve the problem described above, you could put your one-line | |
| 131 ;;;; scrolling commands in their own group. Once that is done, the standard | |
| 132 ;;;; scrolling commands will not form chains with your one-line scrolling | |
| 133 ;;;; commands, and therefore will not use the default scrolling distance set | |
| 134 ;;;; by those commands. Problem solved! | |
| 135 ;;;; | |
| 136 ;;;; By default, all "in place" scrolling commands are in a single group. If | |
| 137 ;;;; you want to partition some commands into separate groups, you must do | |
| 138 ;;;; that yourself *before* any "in place" commands are invoked. For more | |
| 139 ;;;; information about grouping commands, see the documentation for the | |
| 140 ;;;; variables `scroll-command-groups' and `scroll-default-command-group'. | |
| 141 ;;;; | |
| 142 ;;;; + The improved scrolling commands will avoid displaying empty lines past | |
| 143 ;;;; the end of the buffer when possible. In other words, just as you can't | |
| 144 ;;;; see "dead space" before the beginning of the buffer text, the new | |
| 145 ;;;; scrolling commands try to avoid displaying "dead space" past the end of | |
| 146 ;;;; the buffer text. This behavior is somewhat configurable; see the | |
| 147 ;;;; documentation for the variable `scroll-allow-blank-lines-past-eob'. | |
| 148 ;;;; | |
| 149 ;;;; Dead space will be displayed if it is necessary in order to make a | |
| 150 ;;;; previous scrolling action reversible, however. | |
| 151 ;;;; | |
| 152 ;;;; + If the scrolling commands cannot keep point at its initial window | |
| 153 ;;;; position (because a buffer boundary is on screen and the window can't be | |
| 154 ;;;; scrolled as far as necessary to keep point at the right place), point is | |
| 155 ;;;; allowed to temporarily stray from its initial window position. That is, | |
| 156 ;;;; point moves the correct number of window lines, even if it means that it | |
| 157 ;;;; has to stray from its desired window position. This straying is undone | |
| 158 ;;;; when (and if) the scrolling action is reversed. | |
| 159 ;;;; | |
| 160 ;;;; + If a scrolling command tries to move point past a buffer boundary, point | |
| 161 ;;;; is instead moved to the boundary (the beginning or the end of the buffer | |
| 162 ;;;; as appropriate) and an appropriate message is displayed. This motion is | |
| 163 ;;;; reversible, of course. | |
| 164 ;;;; | |
| 165 ;;;; However, if point was already at the buffer boundary when the scrolling | |
| 166 ;;;; command was invoked, the command signals an appropriate error instead. | |
| 167 ;;;; | |
| 168 ;;;; + When a minibuffer window is the selected window, the new versions of | |
| 169 ;;;; `scroll-up' and `scroll-down' either scroll the window in the variable | |
| 170 ;;;; `minibuffer-scroll-window' (which is usually the window of completions) | |
| 171 ;;;; or the `next-window' if there is no `minibuffer-scroll-window'. This is | |
| 172 ;;;; usually much more useful than scrolling the minibuffer itself. (Note | |
| 173 ;;;; that this feature is available even when the variable `scroll-in-place' | |
| 174 ;;;; is `nil'.) | |
| 175 ;;;; | |
| 176 ;;;; + When a scrolling command is scrolling a window other than the selected | |
| 177 ;;;; window, it will signal an appropriate buffer boundary error if the | |
| 178 ;;;; window cannot be scrolled (because the appropriate buffer boundary is | |
| 179 ;;;; already visible). This means that an error is signalled even in cases | |
| 180 ;;;; that would be allowed (by "straying" point or by moving it to the buffer | |
| 181 ;;;; boundary) if the window were selected. | |
| 182 ;;;; | |
| 183 ;;;; (If an error were not signalled in these cases, then there would be many | |
| 184 ;;;; cases in which the last scroll in a particular direction would appear to | |
| 185 ;;;; do nothing because only the point position would change --- the | |
| 186 ;;;; displayed text would stay the same! To avoid these cases the scrolling | |
| 187 ;;;; commands signal boundary errors "prematurely" when the window to be | |
| 188 ;;;; scrolled is not selected.) | |
| 189 ;;;; | |
| 190 ;;;; So how is this package different than Joe Wells' "scroll-fix" package? | |
| 191 ;;;; | |
| 192 ;;;; + This package provides "in place" behavior for the standard GNU Emacs | |
| 193 ;;;; commands by default; "scroll-fix" does not. | |
| 194 ;;;; | |
| 195 ;;;; + "scroll-fix" behaves differently when the window is near a buffer | |
| 196 ;;;; boundary. Instead of allowing point to stray, "scroll-fix" first does | |
| 197 ;;;; an incomplete scroll (i.e., moves point less than the full distance in | |
| 198 ;;;; order to keep point at the desired window position) and then pops point | |
| 199 ;;;; to the buffer boundary. I think that the behavior of this package is | |
| 200 ;;;; somewhat move intuitive, especially for small scrolling distances. | |
| 201 ;;;; | |
| 202 ;;;; + The scrolling commands in this package will appropriately signal buffer | |
| 203 ;;;; boundary errors; the commands in "scroll-fix" never signal boundary | |
| 204 ;;;; errors. This makes it difficult to allow "scroll-fix" to replace the | |
| 205 ;;;; standard `scroll-down' and `scroll-up' commands because some other | |
| 206 ;;;; packages (e.g., VM and GNUS) expect the scrolling commands to signal | |
| 207 ;;;; these errors as necessary. | |
| 208 ;;;; | |
| 209 ;;;; + This package handles long lines correctly. (But see PROBLEMS, below.) | |
| 210 ;;;; | |
| 211 ;;;; + "scroll-fix" handles prefix arguments differently. In "scroll-fix", a | |
| 212 ;;;; number-containing prefix argument always breaks any running chain of | |
| 213 ;;;; scrolling commands. The prefix argument `-' (the symbol minus, | |
| 214 ;;;; generated by `C-u -') causes a temporary change in direction --- a | |
| 215 ;;;; change for only the current command. In this package, however, a | |
| 216 ;;;; number-containing prefix argument only breaks a running chain if it has | |
| 217 ;;;; a different magnitude than the default scrolling distance, and the | |
| 218 ;;;; prefix argument `-' causes a permanent change in the sign of the default | |
| 219 ;;;; scrolling distance --- a change visible to immediately subsequent | |
| 220 ;;;; scrolling commands. | |
| 221 ;;;; | |
| 222 ;;;; + This package keeps track of the set of "in place" scrolling commands | |
| 223 ;;;; dynamically, in order to detect "chains" of scrolling commands. | |
| 224 ;;;; "scroll-fix" has a fixed list of scrolling commands, so "scroll-fix" | |
| 225 ;;;; cannot keep track of some chains. (Again, "scroll-fix" interacts badly | |
| 226 ;;;; with VM and GNUS.) And because "scroll-fix" keeps a static list of | |
| 227 ;;;; scrolling commands, it is a bad idea to call its "in place" commands | |
| 228 ;;;; from a program. This package, because it maintains the information | |
| 229 ;;;; dynamically, has no such problems. | |
| 230 ;;;; | |
| 231 ;;;; + This package allows one to divide the "in place" scrolling commands into | |
| 232 ;;;; groups; a command in a group only forms chains with the members of its | |
| 233 ;;;; group. "scroll-fix" has no notion of command groups. | |
| 234 ;;;; | |
| 235 ;;;; + This package provides "in place" versions of the standard GNU Emacs | |
| 236 ;;;; commands `scroll-other-window-down' and `scroll-other-window'. | |
| 237 ;;;; | |
| 238 ;;;; + This package will refuse to scroll non-selected windows (by signalling | |
| 239 ;;;; an error) when the displayed text would not change, as described in the | |
| 240 ;;;; feature list above. | |
| 241 ;;;; | |
| 242 ;;;; + When a minibuffer window is selected, this package always scrolls a | |
| 243 ;;;; window other than the minibuffer. "scroll-fix" will scroll another | |
| 244 ;;;; window only if the entire minibuffer contents are visible. | |
| 245 ;;;; | |
| 246 ;;;; + "scroll-fix" provides a command to toggle the "in place" behavior of the | |
| 247 ;;;; standard GNU Emacs commands. This package doesn't; you'll have to set | |
| 248 ;;;; the option manually with the command `set-variable'. | |
| 249 ;;;; | |
| 250 ;;;; + This package has gratuitous variable renaming (insert smile here!): | |
| 251 ;;;; | |
| 252 ;;;; "scroll-fix" user variable Equivalent in this package | |
| 253 ;;;; ----------------------------------------------------------------------- | |
| 254 ;;;; scroll-in-place (none) | |
| 255 ;;;; scroll-in-place-replace-original scroll-in-place | |
| 256 ;;;; scroll-in-place-eob-blank-allowed scroll-allow-blank-lines-past-eob | |
| 257 ;;;; | |
| 258 ;;;; + This package allows programmers to specify the default scrolling | |
| 259 ;;;; distance (i.e., the default distance used when starting a new chain of | |
| 260 ;;;; scrolling commands) for custom scrolling commands. | |
| 261 | |
| 262 ;;;; COMMANDS AND FUNCTIONS | |
| 263 ;;;; | |
| 264 ;;;; This package provides the following "in place" versions of GNU Emacs' | |
| 265 ;;;; standard vertical scrolling commands: | |
| 266 ;;;; | |
| 267 ;;;; scroll-down-in-place | |
| 268 ;;;; scroll-up-in-place | |
| 269 ;;;; scroll-other-window-down-in-place | |
| 270 ;;;; scroll-other-window-in-place | |
| 271 ;;;; | |
| 272 ;;;; The variable `scroll-in-place', which is true by default, determines | |
| 273 ;;;; whether or not the new versions of the standard GNU Emacs scrolling | |
| 274 ;;;; commands (`scroll-down', `scroll-up', `scroll-other-window-down', and | |
| 275 ;;;; `scroll-other-window') use the "in place" features listed above. When | |
| 276 ;;;; `scroll-in-place' is `nil' the standard GNU Emacs scrolling commands | |
| 277 ;;;; essentially just call the original versions of themselves. (Note that | |
| 278 ;;;; even when `scroll-in-place' is `nil' the new versions of `scroll-down' and | |
| 279 ;;;; `scroll-up' have slightly different behavior when a minibuffer window is | |
| 280 ;;;; the selected window. See the feature list above.) | |
| 281 ;;;; | |
| 282 ;;;; NOTE that this package redefines the standard GNU Emacs commands `scroll- | |
| 283 ;;;; down', `scroll-up', `scroll-other-window-down', and `scroll-other-window' | |
| 284 ;;;; (in order to check the variable `scroll-in-place', as described above). | |
| 285 ;;;; The command `scroll-other-window-down' first appeared as a standard | |
| 286 ;;;; command in the FSF's GNU Emacs 19.26. | |
| 287 ;;;; | |
| 288 ;;;; This package also provides the following functions and variables which are | |
| 289 ;;;; of use to programmers: | |
| 290 ;;;; | |
| 291 ;;;; scroll-window | |
| 292 ;;;; scroll-window-in-place | |
| 293 ;;;; scroll-window-in-place-continue-sequence | |
| 294 ;;;; scroll-default-lines (variable) | |
| 295 ;;;; scroll-command-groups (variable) | |
| 296 ;;;; | |
| 297 ;;;; The `scroll-window-in-place' function is the heart of the "in place" | |
| 298 ;;;; scrolling commands. `scroll-window' is a function that checks the | |
| 299 ;;;; variable `scroll-in-place' and calls the appropriate scrolling function | |
| 300 ;;;; (either `scroll-window-in-place' or one of the original versions of | |
| 301 ;;;; `scroll-down' and `scroll-up'). The function `scroll-window-in-place- | |
| 302 ;;;; continue-sequence' is provided in order to preserve running "chains" of | |
| 303 ;;;; scrolling commands as described above. | |
| 304 ;;;; | |
| 305 ;;;; The variable `scroll-default-lines' determines the default scrolling | |
| 306 ;;;; distance when a new chain of "in place" scrolling commands begins. If | |
| 307 ;;;; this variable is not a number, then the default distance is the height of | |
| 308 ;;;; the window to be scrolled minus `next-screen-context-lines'. The variable | |
| 309 ;;;; `scroll-command-groups' contains the explicit groups of "in place" | |
| 310 ;;;; scrolling commands; for more information read the variable documentation. | |
| 311 | |
| 312 ;;;; YOUR .EMACS FILE | |
| 313 ;;;; | |
| 314 ;;;; To use this package, you simply need to load it from within your ".emacs" | |
| 315 ;;;; file: | |
| 316 ;;;; | |
| 317 ;;;; (require 'scroll-in-place) | |
| 318 ;;;; | |
| 319 ;;;; By default, this package provides for the standard GNU Emacs vertical | |
| 320 ;;;; scrolling commands (`scroll-down', `scroll-up', `scroll-other-window- | |
| 321 ;;;; down', and `scroll-other-window') to use the "in place" features. If you | |
| 322 ;;;; would rather not have this, set the variable `scroll-in-place' to `nil': | |
| 323 ;;;; | |
| 324 ;;;; (setq scroll-in-place nil) | |
| 325 ;;;; | |
| 326 ;;;; When `scroll-in-place' is `nil' you will have to bind keys in order to | |
| 327 ;;;; call the "in place" scrolling commands. For example, you might want to do | |
| 328 ;;;; the following: | |
| 329 ;;;; | |
| 330 ;;;; (global-set-key "\M-v" 'scroll-down-in-place) | |
| 331 ;;;; (global-set-key "\C-v" 'scroll-up-in-place) | |
| 332 ;;;; | |
| 333 ;;;; Sun users should also read the PROBLEMS section, below. | |
| 334 ;;;; | |
| 335 ;;;; ADVANCED CUSTOMIZATION | |
| 336 ;;;; | |
| 337 ;;;; If you want to partition certain "in place" scrolling commands into | |
| 338 ;;;; separate groups, you should do something like the following: | |
| 339 ;;;; | |
| 340 ;;;; ;; Make one group containing the commands `scroll-down-one-line' and | |
| 341 ;;;; ;; `scroll-up-one-line'. (These are not standard GNU Emacs commands.) | |
| 342 ;;;; (setq scroll-command-groups | |
| 343 ;;;; (list '(scroll-down-one-line scroll-up-one-line))) | |
| 344 ;;;; | |
| 345 ;;;; You could write the `scroll-down-one-line' command like this: | |
| 346 ;;;; | |
| 347 ;;;; (defun scroll-down-one-line (arg) | |
| 348 ;;;; "Scroll down one line, or number of lines specified by prefix arg." | |
| 349 ;;;; (interactive "P") | |
| 350 ;;;; (let ((scroll-default-lines 1)) | |
| 351 ;;;; (scroll-down-in-place arg))) | |
| 352 ;;;; | |
| 353 ;;;; If you want to disable "in place" scrolling for windows that display a | |
| 354 ;;;; particular buffer (while leaving it available in other windows), you can | |
| 355 ;;;; make `scroll-in-place' a buffer-local variable for that buffer and then | |
| 356 ;;;; bind that local copy of `scroll-in-place' to `nil'. This is the kind of | |
| 357 ;;;; thing that one generally does in a major mode hook. For example, you can | |
| 358 ;;;; disable "in place" scrolling of GNUS article windows with the following | |
| 359 ;;;; code: | |
| 360 ;;;; | |
| 361 ;;;; (setq gnus-article-mode-hook | |
| 362 ;;;; (function (lambda () | |
| 363 ;;;; (make-local-variable 'scroll-in-place) | |
| 364 ;;;; (setq scroll-in-place nil)))) | |
| 365 ;;;; ;; Set the variable `gnus-Article-mode-hook' instead if you are using | |
| 366 ;;;; ;; an old version of GNUS, say version 3.13 or 3.14. | |
| 367 ;;;; | |
| 368 ;;;; The variable `scroll-allow-blank-lines-past-eob' can also be made local to | |
| 369 ;;;; particular buffers, if you desire. (But why would you want to do that?) | |
| 370 | |
| 371 ;;;; PROBLEMS | |
| 372 ;;;; | |
| 373 ;;;; + It is sometimes difficult for one's eyes to follow an incomplete scroll | |
| 374 ;;;; (i.e., a scroll in which the text doesn't move as far as one expected), | |
| 375 ;;;; especially when the scrolled window is not selected (and therefore that | |
| 376 ;;;; window's point is not highlighted). One can lose one's place in the | |
| 377 ;;;; text. | |
| 378 ;;;; | |
| 379 ;;;; + The names `scroll-down-in-place' and `scroll-up-in-place' conflict with | |
| 380 ;;;; two commands in the GNU Emacs terminal-specific file "term/sun.el". | |
| 381 ;;;; This means that in order to load this package correctly, Sunterm users | |
| 382 ;;;; will have to use the hook `term-setup-hook'. For example, you might put | |
| 383 ;;;; the following form in your ".emacs" file: | |
| 384 ;;;; | |
| 385 ;;;; (setq term-setup-hook (function (lambda () (require 'scroll-in-place)))) | |
| 386 ;;;; | |
| 387 ;;;; If this is confusing, get help from your local GNU Emacs guru. | |
| 388 ;;;; | |
| 389 ;;;; + `scroll-determine-goal-column' tries to honor the variable `track-eol' | |
| 390 ;;;; if it is set. But when lines are being wrapped we can't move point past | |
| 391 ;;;; the wrap --- or else it is possible that scrolling won't work correctly. | |
| 392 ;;;; In short, this package honors `track-eol' as best it can. | |
| 393 ;;;; | |
| 394 ;;;; + `scroll-window-in-place' can become confused when something changes the | |
| 395 ;;;; window "out from under it." By "confused" I mean that it is possible | |
| 396 ;;;; for `scroll-window-in-place' to think that it should continue the | |
| 397 ;;;; running sequence of "in place" scrolls when it should really probably | |
| 398 ;;;; start a new sequence. For example, if a process filter inserts text | |
| 399 ;;;; into the buffer and moves point, `scroll-window-in-place' loses track of | |
| 400 ;;;; where point should be and where the window should start. Commands that | |
| 401 ;;;; call a "scroll in place" function and then subsequently move point can | |
| 402 ;;;; also confuse `scroll-window-in-place'. | |
| 403 ;;;; | |
| 404 ;;;; To correct some of this confusion, `scroll-window-in-place' could keep | |
| 405 ;;;; track of the final positions of `window-start' and `window-point', | |
| 406 ;;;; possibly with both markers and character positions. In my experience | |
| 407 ;;;; the "in place" scrolling commands are almost never confused (except by | |
| 408 ;;;; fancy packages that do their own fancy kinds of scrolling, as described | |
| 409 ;;;; below), so the extra sanity checking isn't worth the effort. If your | |
| 410 ;;;; mileage varies let me know. | |
| 411 ;;;; | |
| 412 ;;;; + The "in place" scrolling commands can interact poorly with packages that | |
| 413 ;;;; provide their own special scrolling commands. For example, there are | |
| 414 ;;;; varying degrees of conflict with Rmail, VM, and GNUS. | |
| 415 ;;;; | |
| 416 ;;;; RMAIL | |
| 417 ;;;; | |
| 418 ;;;; In the version of Rmail that is part of the FSF's GNU Emacs 19 (19.25 | |
| 419 ;;;; through 19.28 at least), the command `rmail-summary-scroll-msg-down' in | |
| 420 ;;;; the file "rmailsum.el" fails to work properly when "in place" scrolling | |
| 421 ;;;; is enabled for the Rmail message buffer. (The source of the conflict: | |
| 422 ;;;; the "in place" scrolling commands and Emacs' standard scrolling commands | |
| 423 ;;;; interpret the argument '- in different ways.) Fortunately it is easy to | |
| 424 ;;;; patch Rmail. Send me mail if you would like to receive a copy of these | |
| 425 ;;;; patches. | |
| 426 ;;;; | |
| 427 ;;;; I know of no conflicts between the "in place" scrolling commands and | |
| 428 ;;;; older versions of Rmail (i.e., versions that came with GNU Emacs 18). | |
| 429 ;;;; | |
| 430 ;;;; VM | |
| 431 ;;;; | |
| 432 ;;;; `scroll-window-in-place' is *very* confused by VM 5's message scrolling | |
| 433 ;;;; commands, especially because VM 5 rebuilds Emacs' window configuration | |
| 434 ;;;; from scratch so often. I have written an experimental set of patches | |
| 435 ;;;; for VM 5.70 that allows VM 5 to use the "scroll-in-place" features; send | |
| 436 ;;;; me mail if you would like to receive a copy of these patches. I hope | |
| 437 ;;;; that someday my patches will be incorporated into VM. | |
| 438 ;;;; | |
| 439 ;;;; `scroll-window-in-place' is not confused by VM 4.41's message scrolling | |
| 440 ;;;; commands, however. | |
| 441 ;;;; | |
| 442 ;;;; GNUS | |
| 443 ;;;; | |
| 444 ;;;; `scroll-window-in-place' can be *slightly* confused by GNUS' article | |
| 445 ;;;; scrolling commands because they move point to the last line of the | |
| 446 ;;;; article window and then scroll the text. (This is the case for at least | |
| 447 ;;;; GNUS versions 3.13 through 4.1, inclusive.) The potential conflict is | |
| 448 ;;;; so minor, however, that you'll probably never notice it. I never do. | |
| 449 ;;;; | |
| 450 ;;;; A severe conflict, however, exists between the "in place" scrolling | |
| 451 ;;;; commands and the add-on "gnus-hide" package. "gnus-hide" can elide | |
| 452 ;;;; signatures at the ends of articles but it does so in a way that causes | |
| 453 ;;;; `scroll-window-in-place', as invoked by the GNUS scrolling commands, not | |
| 454 ;;;; to signal end-of-buffer conditions at the right times. Someday I may | |
| 455 ;;;; write new article scrolling commands for GNUS. | |
| 456 ;;;; | |
| 457 ;;;; + Process filters that call scrolling functions can cause confusion. They | |
| 458 ;;;; may break running chains of "in place" scrolling commands and they may | |
| 459 ;;;; set up inappropriate defaults for future scrolling commands. Maybe this | |
| 460 ;;;; is a moot problem, as I am currently unaware of any process filters that | |
| 461 ;;;; invoke scrolling commands (although many filters move point around, | |
| 462 ;;;; which will also confuse `scroll-window-in-place'). | |
| 463 | |
| 464 ;; (provide 'scroll-in-place) at the end of this file. | |
| 465 | |
| 466 | |
| 467 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 468 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 469 ;;;; | |
| 470 ;;;; Here are the variable declarations, both user options and internal | |
| 471 ;;;; variables. | |
| 472 ;;;; | |
| 473 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 474 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 475 | |
| 476 (defvar scroll-in-place t | |
| 477 "*When this variable is true (i.e., non-`nil'), the standard GNU Emacs | |
| 478 vertical scrolling commands `scroll-down', `scroll-up', `scroll-other-window- | |
| 479 down', and `scroll-other-window' will attempt to keep point at its current | |
| 480 position in the window (window line and column). In other words, point stays | |
| 481 \"in place\" within the window. | |
| 482 | |
| 483 When this variable is `nil' the standard GNU Emacs vertical scrolling commands | |
| 484 behave as usual. The \"in place\" equivalents, however, are still available as | |
| 485 separate commands. | |
| 486 | |
| 487 This variable may be made buffer-local in order to disable (or enable) \"in | |
| 488 place\" scrolling in particular buffers." | |
| 489 ;; I have thought about dividing `scroll-in-place' into three variables: a | |
| 490 ;; list of commands that always scroll in place, a list of commands that | |
| 491 ;; never scroll in place, and a flag that determines the default behavior of | |
| 492 ;; other scrolling commands. This could make it easier to make "in place" | |
| 493 ;; scrolling the default because one could single out certain ill-behaved | |
| 494 ;; commands. But as of now I'm sure that the added complexity would really | |
| 495 ;; be worth it. | |
| 496 ) | |
| 497 | |
| 498 (defvar scroll-allow-blank-lines-past-eob nil | |
| 499 "*When this variable is `nil' the \"in place\" scrolling commands will avoid | |
| 500 displaying empty lines past the end of the buffer text. In other words, just | |
| 501 as you can't see \"dead space\" before the beginning of the buffer text, the | |
| 502 \"in place\" scrolling commands try to avoid displaying \"dead space\" past the | |
| 503 end of the buffer text. This helps make the most of window real estate. | |
| 504 | |
| 505 Note that sometimes it is necessary to display \"dead space\" in order to make | |
| 506 a previous scrolling action reversible. | |
| 507 | |
| 508 When this variable is non-`nil' the \"in place\" scrolling commands will always | |
| 509 allow blank lines to be shown past the end of the buffer.") | |
| 510 | |
| 511 ;;;; | |
| 512 ;;;; The following variables are not user options, but are intended to be set | |
| 513 ;;;; by code outside this package. | |
| 514 ;;;; | |
| 515 | |
| 516 (defvar scroll-default-lines nil | |
| 517 "The default number of lines to be scrolled by when a new sequence of \"in | |
| 518 place\" scrolling commands begins. Of course, when an explicit number of lines | |
| 519 is specified, that explicit number takes precedence. See the documentation for | |
| 520 the function `scroll-window-in-place' for more information. | |
| 521 | |
| 522 If this variable is not bound to a number, then the default number of lines is | |
| 523 the height of the window to be scrolled minus `next-screen-context-lines'. | |
| 524 | |
| 525 This variable should not be set globally! Commands that want to specify a | |
| 526 default scrolling distance should just bind the variable `scroll-default-lines' | |
| 527 temporarily.") | |
| 528 | |
| 529 (defvar scroll-command-groups nil | |
| 530 "The explicitly specified \"groups\" of \"in place\" scrolling commands. | |
| 531 This variable should be set before or immediately after the \"in place\" | |
| 532 scrolling package is loaded, and then not changed after that. | |
| 533 | |
| 534 Usually, \"in place\" scrolling commands share state (e.g., the number of lines | |
| 535 to scroll by) with any and all immediately previous \"in place\" scrolling | |
| 536 commands. Sometimes, however, this is undesirable. In these cases the \"in | |
| 537 place\" scrolling commands can be divided into groups. A command in a group | |
| 538 only shares state with members of its group. | |
| 539 | |
| 540 Each element of `scroll-command-groups' is a list that contains all of the | |
| 541 members of a unique command group. For example, if there were only one | |
| 542 explicit group and that group contained the commands `scroll-down-one-line' and | |
| 543 `scroll-up-one-line', then `scroll-command-groups' would be set to: | |
| 544 | |
| 545 ((scroll-down-one-line scroll-up-one-line)) | |
| 546 | |
| 547 Commands that are not in any explicitly specified group are added to a default | |
| 548 group. That group is stored in the variable `scroll-default-command-group'. | |
| 549 | |
| 550 The \"in place\" scrolling functions assume that all of the scrolling command | |
| 551 groups are nonintersecting (i.e., no command is in more than one group) and | |
| 552 only contain \"in place\" scrolling commands.") | |
| 553 | |
| 554 ;;;; | |
| 555 ;;;; The variables below this point are internal to this package. | |
| 556 ;;;; | |
| 557 | |
| 558 (defvar scroll-default-command-group nil | |
| 559 "The set of \"in place\" scrolling commands that are not members of any | |
| 560 explicitly defined group of commands. This set of commands is an implicitly | |
| 561 defined group, constructed as \"in place\" commands are invoked, and members of | |
| 562 this group share state among themselves. See the documentation for the | |
| 563 variable `scroll-command-groups' for more information.") | |
| 564 | |
| 565 (defvar scroll-initially-displayed-lines 0 | |
| 566 "The number of window lines that contained buffer text when the current | |
| 567 sequence of \"in place\" scrolling commands started. Unless the variable | |
| 568 `scroll-in-place-allow-blank-lines-past-eob' is true, the \"in place\" | |
| 569 scrolling commands ensure that at least this many text lines are visible at all | |
| 570 times.") | |
| 571 | |
| 572 (defvar scroll-previous-window nil | |
| 573 "The window that was most recently scrolled by an \"in place\" scrolling | |
| 574 command.") | |
| 575 | |
| 576 (defvar scroll-previous-lines 0 | |
| 577 "The number of window lines that the previous \"in place\" scrolling command | |
| 578 attempted to scroll.") | |
| 579 | |
| 580 (defvar scroll-goal-column 0 | |
| 581 "The desired horizontal window position for point, used by the \"in place\" | |
| 582 scrolling commands.") | |
| 583 | |
| 584 (defvar scroll-boundary-previous-point nil | |
| 585 "The value of point before point was moved to a buffer boundary.") | |
| 586 | |
| 587 (defvar scroll-boundary-previous-lines 0 | |
| 588 "The number of lines that point moved when it moved to a buffer boundary.") | |
| 589 | |
| 590 (defvar scroll-boundary-error-command nil | |
| 591 "The value of `this-command' when an \"in place\" scrolling command signalled | |
| 592 a buffer boundary error. This is used to decide how subsequent scrolling | |
| 593 commands should recover from the error.") | |
| 594 | |
| 595 (defvar scroll-boundary-error-point nil | |
| 596 "The value of point when an \"in place\" scrolling command signalled a buffer | |
| 597 boundary error. This is used to decide how subsequent scrolling commands | |
| 598 should recover from the error." | |
| 599 ;; This variable is used as a flag, indicating whether or not the previous | |
| 600 ;; "in place" scrolling command signalled an error. | |
| 601 ) | |
| 602 | |
| 603 (defvar scroll-window-debt 0 | |
| 604 "The difference between the number of lines an \"in place\" scrolling command | |
| 605 tried to scroll a window and the number of lines that the window actually | |
| 606 scrolled. This difference is the \"debt\" in the window's starting position. | |
| 607 Subsequent \"in place\" scrolling commands try to make up this debt.") | |
| 608 | |
| 609 (defconst scroll-pos-visible-bug-p | |
| 610 ;; On September 14, 1993, David Hughes <djh@Harston.CV.COM> told me that | |
| 611 ;; Lucid GNU Emacs 19.8 had inherited the bug from Epoch... sigh. | |
| 612 (let ((old-match-data (match-data))) | |
| 613 (unwind-protect | |
| 614 (or (and (boundp 'epoch::version) | |
| 615 (if (string-match "\\`4\\." emacs-version) t nil) | |
| 616 ) | |
| 617 (and (string-match "Lucid" emacs-version) | |
| 618 (if (string-match "\\`19\\.8\\." emacs-version) t nil) | |
| 619 ) | |
| 620 ) | |
| 621 (store-match-data old-match-data))) | |
| 622 "A flag, set when this version of GNU Emacs has a buggy version of the | |
| 623 function `pos-visible-in-window-p' that returns `nil' when given `(point-max)' | |
| 624 and `(point-max)' is on the last line of the window. Currently, this flag is | |
| 625 set for all versions of Epoch 4 and for Lucid GNU Emacs 19.8.") | |
| 626 | |
| 627 | |
| 628 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 629 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 630 ;;;; | |
| 631 ;;;; Here are the window-choosing auxiliary functions used by the new scrolling | |
| 632 ;;;; commands. | |
| 633 ;;;; | |
| 634 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 635 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 636 | |
| 637 (defun scroll-choose-window () | |
| 638 "Choose the window to be scrolled by the commands `scroll-down', `scroll-up', | |
| 639 `scroll-down-in-place', and `scroll-up-in-place'. | |
| 640 | |
| 641 The rules are simple. If the selected window is not a minibuffer window, then | |
| 642 just choose the selected window. | |
| 643 | |
| 644 However, when a minibuffer window is selected, look first for the `minibuffer- | |
| 645 scroll-window'. The `minibuffer-scroll-window' is usually the window that | |
| 646 displays completions. If it exists, choose it; otherwise choose the next | |
| 647 window after the selected window in the canonical ordering of windows. The | |
| 648 next window is generally the one below the selected window, or the one at the | |
| 649 top of the screen if the selected window is at the bottom of the screen." | |
| 650 (let ((selected-window (selected-window))) | |
| 651 (if (window-minibuffer-p selected-window) | |
| 652 ;; A minibuffer window is selected --- scroll some other window. | |
| 653 (if (window-live-p minibuffer-scroll-window) | |
| 654 minibuffer-scroll-window | |
| 655 ;; We know that the (selected) minibuffer is active, so `next-window' | |
| 656 ;; will examine all of the frames that share this minibuffer. | |
| 657 ;; Should we consider `other-window-scroll-buffer' here? I don't | |
| 658 ;; believe so. | |
| 659 (next-window selected-window)) | |
| 660 selected-window))) | |
| 661 | |
| 662 ;;; | |
| 663 ;;; | |
| 664 ;;; | |
| 665 | |
| 666 (defun scroll-choose-other-window () | |
| 667 "Choose the window to be scrolled by the commands `scroll-other-window-down', | |
| 668 `scroll-other-window', `scroll-other-window-down-in-place', and `scroll-other- | |
| 669 window-in-place'. | |
| 670 | |
| 671 The rules are these. If the selected window is not a minibuffer window, then | |
| 672 choose either: | |
| 673 | |
| 674 + a window that displays the `other-window-scroll-buffer', if that buffer | |
| 675 exists. Note, this function will display that buffer if necessary. | |
| 676 | |
| 677 + the next window after the selected window in the canonical ordering of | |
| 678 windows. The next window is generally the one below the selected window, | |
| 679 or the one at the top of the screen if the selected window is at the bottom | |
| 680 of the screen. | |
| 681 | |
| 682 However, when a minibuffer window is selected, look first for the `minibuffer- | |
| 683 scroll-window'. The `minibuffer-scroll-window' is usually the window that | |
| 684 displays completions. If it exists, choose it; otherwise choose the window to | |
| 685 be scrolled as described above (`other-window-scroll-buffer' or next window). | |
| 686 | |
| 687 This function is essentially a Lisp version of the function `other-window-for- | |
| 688 scrolling' which first appeared in the FSF's GNU Emacs 19.26." | |
| 689 (let* ((no-error nil) | |
| 690 (selected-window (selected-window)) | |
| 691 (other-window nil)) | |
| 692 (setq other-window | |
| 693 (cond ((and (window-minibuffer-p selected-window) | |
| 694 (window-live-p minibuffer-scroll-window)) | |
| 695 ;; Don't signal an error when `minibuffer-scroll-window' is | |
| 696 ;; the minibuffer itself --- which would be really weird, but | |
| 697 ;; isn't necessarily erroneous. | |
| 698 (setq no-error t) | |
| 699 minibuffer-scroll-window) | |
| 700 | |
| 701 ((and ;; `other-window-scroll-buffer' is an Emacs 19 invention. | |
| 702 (boundp 'other-window-scroll-buffer) | |
| 703 (bufferp other-window-scroll-buffer) | |
| 704 ;; `buffer-name' is `nil' if the buffer has been killed. | |
| 705 (buffer-name other-window-scroll-buffer)) | |
| 706 ;; This is what FSF GNU Emacs 19.26 does, but it occurred to | |
| 707 ;; me: what if one of these forms returns the selected window? | |
| 708 ;; Signalling an error would be bad news, so I added a flag. | |
| 709 (setq no-error t) | |
| 710 (or (get-buffer-window other-window-scroll-buffer) | |
| 711 (display-buffer other-window-scroll-buffer t))) | |
| 712 | |
| 713 ((let ((next-window (next-window selected-window))) | |
| 714 (if (eq next-window selected-window) | |
| 715 nil | |
| 716 next-window))) | |
| 717 | |
| 718 (t | |
| 719 ;; In Emacs 19 (FSF, Lucid, and XEmacs), look for a window on | |
| 720 ;; another visible frame. This could be written for | |
| 721 ;; Epoch, too, I suppose... | |
| 722 (condition-case nil | |
| 723 (let ((this-window (next-window selected-window nil t))) | |
| 724 (while (not (or (eq this-window selected-window) | |
| 725 (scroll-choose-window-frame-visible-p | |
| 726 this-window))) | |
| 727 (setq this-window (next-window this-window nil t))) | |
| 728 this-window) | |
| 729 ;; In older versions of Emacs, `next-window' didn't accept | |
| 730 ;; three arguments. Catch this error and then return the | |
| 731 ;; selected window --- which will cause another error to be | |
| 732 ;; signalled later on. | |
| 733 (wrong-number-of-arguments selected-window)) | |
| 734 ) | |
| 735 )) | |
| 736 | |
| 737 (if (and (not no-error) | |
| 738 (eq selected-window other-window)) | |
| 739 (error "There is no other window.")) | |
| 740 other-window)) | |
| 741 | |
| 742 ;;; | |
| 743 ;;; | |
| 744 ;;; | |
| 745 | |
| 746 (defun scroll-choose-window-frame-visible-p (window) | |
| 747 "Return a true value if the frame of the given WINDOW is visible." | |
| 748 (cond ((fboundp 'window-frame) | |
| 749 (eq t (frame-visible-p (window-frame window)))) | |
| 750 (t t))) | |
| 751 | |
| 752 | |
| 753 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 754 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 755 ;;;; | |
| 756 ;;;; Here are the "in place" scrolling commands (interactive functions) and the | |
| 757 ;;;; replacements for the standard GNU Emacs vertical scrolling commands. | |
| 758 ;;;; | |
| 759 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 760 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 761 | |
| 762 ;;;; | |
| 763 ;;;; Here are the new scroll "in place" commands. | |
| 764 ;;;; | |
| 765 | |
| 766 (defun scroll-down-in-place (&optional lines) | |
| 767 "Scroll the text of the current window downward by LINES lines, leaving point | |
| 768 as close as possible to its current window position (window line and column). | |
| 769 In other words, point is left \"in place\" within the window. As a special | |
| 770 case, when the current window is a minibuffer window, this command scrolls the | |
| 771 `minibuffer-scroll-window' (which is usually the list of completions) if it | |
| 772 exists, or otherwise the next window in the canonical ordering of windows. | |
| 773 | |
| 774 If the optional argument LINES is `nil', scroll the window by the same amount | |
| 775 it was moved by the immediately previous \"in place\" scrolling command, or by | |
| 776 the value of the variable `scroll-default-lines' (usually almost a windowful) | |
| 777 if the previous command was not an \"in place\" scrolling command (or when that | |
| 778 previous command scrolled some other window, or when other circumstances | |
| 779 prevent the previous scrolling distance from being used). If LINES is the | |
| 780 symbol `-', then the scrolling distance is determined as if LINES had been | |
| 781 `nil' and then that distance is multiplied by -1. | |
| 782 | |
| 783 If the window cannot be scrolled by the full distance, point is allowed to | |
| 784 stray from its initial position so that it can move the full number of lines. | |
| 785 If point cannot move the full number of lines, point is moved to the buffer | |
| 786 boundary. Any immediately subsequent \"in place\" scrolling commands will try | |
| 787 to restore point to its initial window position." | |
| 788 (interactive "P") | |
| 789 (scroll-window-in-place (scroll-choose-window) lines -1)) | |
| 790 | |
| 791 ;;; | |
| 792 ;;; | |
| 793 ;;; | |
| 794 | |
| 795 (defun scroll-up-in-place (&optional lines) | |
| 796 "Scroll the text of the current window upward by LINES lines, leaving point | |
| 797 as close as possible to its current window position (window line and column). | |
| 798 In other words, point is left \"in place\" within the window. As a special | |
| 799 case, when the current window is a minibuffer window, this command scrolls the | |
| 800 `minibuffer-scroll-window' (which is usually the list of completions) if it | |
| 801 exists, or otherwise the next window in the canonical ordering of windows. | |
| 802 | |
| 803 If the optional argument LINES is `nil', scroll the window by the same amount | |
| 804 it was moved by the immediately previous \"in place\" scrolling command, or by | |
| 805 the value of the variable `scroll-default-lines' (usually almost a windowful) | |
| 806 if the previous command was not an \"in place\" scrolling command (or when that | |
| 807 previous command scrolled some other window, or when other circumstances | |
| 808 prevent the previous scrolling distance from being used). If LINES is the | |
| 809 symbol `-', then the scrolling distance is determined as if LINES had been | |
| 810 `nil' and then that distance is multiplied by -1. | |
| 811 | |
| 812 If the window cannot be scrolled by the full distance, point is allowed to | |
| 813 stray from its initial position so that it can move the full number of lines. | |
| 814 If point cannot move the full number of lines, point is moved to the buffer | |
| 815 boundary. Any immediately subsequent \"in place\" scrolling commands will try | |
| 816 to restore point to its initial window position." | |
| 817 (interactive "P") | |
| 818 (scroll-window-in-place (scroll-choose-window) lines 1)) | |
| 819 | |
| 820 ;;; | |
| 821 ;;; The command `scroll-other-window-down' first appeared in FSF GNU Emacs | |
| 822 ;;; 19.26. | |
| 823 ;;; | |
| 824 | |
| 825 (defun scroll-other-window-down-in-place (&optional lines) | |
| 826 "Scroll the text of the next window downward by LINES lines, leaving point in | |
| 827 that window as close as possible to its current window position (window line | |
| 828 and column). In other words, point is left \"in place\" within the window. | |
| 829 The next window is generally the one below the current one, or the one at the | |
| 830 top of the screen if the current window is at the bottom of the screen. In | |
| 831 special circumstances this command will scroll a window other than the next | |
| 832 window. Read the documentation for the function `scroll-choose-other-window' | |
| 833 for details. | |
| 834 | |
| 835 If the optional argument LINES is `nil', scroll the window by the same amount | |
| 836 it was moved by the immediately previous \"in place\" scrolling command, or by | |
| 837 the value of the variable `scroll-default-lines' (usually almost a windowful) | |
| 838 if the previous command was not an \"in place\" scrolling command (or when that | |
| 839 previous command scrolled some other window, or when other circumstances | |
| 840 prevent the previous scrolling distance from being used). If LINES is the | |
| 841 symbol `-', then the scrolling distance is determined as if LINES had been | |
| 842 `nil' and then that distance is multiplied by -1. | |
| 843 | |
| 844 If the window cannot be scrolled by the full distance, point is allowed to | |
| 845 stray from its initial position so that it can move the full number of lines. | |
| 846 If point cannot move the full number of lines, point is moved to the buffer | |
| 847 boundary. Any immediately subsequent \"in place\" scrolling commands will try | |
| 848 to restore point to its initial window position. | |
| 849 | |
| 850 If it is impossible to scroll the text of the window at all (because a buffer | |
| 851 boundary is already visible), this command signals a buffer boundary error. | |
| 852 The error is signalled even if point could otherwise move the full number of | |
| 853 lines." | |
| 854 (interactive "P") | |
| 855 (scroll-window-in-place (scroll-choose-other-window) lines -1)) | |
| 856 | |
| 857 ;;; | |
| 858 ;;; | |
| 859 ;;; | |
| 860 | |
| 861 (defun scroll-other-window-in-place (&optional lines) | |
| 862 "Scroll the text of the next window upward by LINES lines, leaving point in | |
| 863 that window as close as possible to its current window position (window line | |
| 864 and column). In other words, point is left \"in place\" within the window. | |
| 865 The next window is generally the one below the current one, or the one at the | |
| 866 top of the screen if the current window is at the bottom of the screen. In | |
| 867 special circumstances this command will scroll a window other than the next | |
| 868 window. Read the documentation for the function `scroll-choose-other-window' | |
| 869 for details. | |
| 870 | |
| 871 If the optional argument LINES is `nil', scroll the window by the same amount | |
| 872 it was moved by the immediately previous \"in place\" scrolling command, or by | |
| 873 the value of the variable `scroll-default-lines' (usually almost a windowful) | |
| 874 if the previous command was not an \"in place\" scrolling command (or when that | |
| 875 previous command scrolled some other window, or when other circumstances | |
| 876 prevent the previous scrolling distance from being used). If LINES is the | |
| 877 symbol `-', then the scrolling distance is determined as if LINES had been | |
| 878 `nil' and then that distance is multiplied by -1. | |
| 879 | |
| 880 If the window cannot be scrolled by the full distance, point is allowed to | |
| 881 stray from its initial position so that it can move the full number of lines. | |
| 882 If point cannot move the full number of lines, point is moved to the buffer | |
| 883 boundary. Any immediately subsequent \"in place\" scrolling commands will try | |
| 884 to restore point to its initial window position. | |
| 885 | |
| 886 If it is impossible to scroll the text of the window at all (because a buffer | |
| 887 boundary is already visible), this command signals a buffer boundary error. | |
| 888 The error is signalled even if point could otherwise move the full number of | |
| 889 lines." | |
| 890 (interactive "P") | |
| 891 (scroll-window-in-place (scroll-choose-other-window) lines 1)) | |
| 892 | |
| 893 ;;;; | |
| 894 ;;;; Here are the replacements for GNU Emacs' standard vertical scrolling | |
| 895 ;;;; commands. | |
| 896 ;;;; | |
| 897 | |
| 898 (or (fboundp 'original-scroll-down) | |
| 899 (fset 'original-scroll-down (symbol-function 'scroll-down))) | |
| 900 (or (fboundp 'original-scroll-up) | |
| 901 (fset 'original-scroll-up (symbol-function 'scroll-up))) | |
| 902 (or (fboundp 'original-scroll-other-window-down) | |
| 903 ;; `scroll-other-window-down' first appeared in FSF GNU Emacs 19.26. | |
| 904 (if (fboundp 'scroll-other-window-down) | |
| 905 (fset 'original-scroll-other-window-down | |
| 906 (symbol-function 'scroll-other-window-down)) | |
| 907 )) | |
| 908 (or (fboundp 'original-scroll-other-window) | |
| 909 (fset 'original-scroll-other-window (symbol-function 'scroll-other-window)) | |
| 910 ) | |
| 911 | |
| 912 ;;; | |
| 913 ;;; | |
| 914 ;;; | |
| 915 | |
| 916 (defun scroll-down (&optional lines) | |
| 917 "Scroll the text of the current window downward by LINES lines. As a special | |
| 918 case, when the current window is a minibuffer window, this command scrolls the | |
| 919 `minibuffer-scroll-window' (which is usually the list of completions) if it | |
| 920 exists, or otherwise the next window in the canonical ordering of windows. | |
| 921 | |
| 922 The argument LINES is optional. Its meaning depends on the current value of | |
| 923 the variable `scroll-in-place'. | |
| 924 | |
| 925 When the variable `scroll-in-place' is true, this command works just like the | |
| 926 command `scroll-down-in-place', scrolling the current window and leaving point | |
| 927 \"in place\" within the window. See the documentation for the command | |
| 928 `scroll-down-in-place' for more information. | |
| 929 | |
| 930 When the variable `scroll-in-place' is `nil' this command invokes the standard | |
| 931 GNU Emacs version of `scroll-down'. In that case, when LINES is `nil' the | |
| 932 current window is scrolled by nearly a complete windowful of text. | |
| 933 | |
| 934 Note that this command correctly handles cases in which `scroll-in-place' has a | |
| 935 buffer-local value in the window to be scrolled. That value is honored." | |
| 936 (interactive "P") | |
| 937 (scroll-window (scroll-choose-window) lines -1)) | |
| 938 | |
| 939 ;;; | |
| 940 ;;; | |
| 941 ;;; | |
| 942 | |
| 943 (defun scroll-up (&optional lines) | |
| 944 "Scroll the text of the current window upward by LINES lines. As a special | |
| 945 case, when the current window is a minibuffer window, this command scrolls the | |
| 946 `minibuffer-scroll-window' (which is usually the list of completions) if it | |
| 947 exists, or otherwise the next window in the canonical ordering of windows. | |
| 948 | |
| 949 The argument LINES is optional. Its meaning depends on the current value of | |
| 950 the variable `scroll-in-place'. | |
| 951 | |
| 952 When the variable `scroll-in-place' is true, this command works just like the | |
| 953 command `scroll-up-in-place', scrolling the current window and leaving point | |
| 954 \"in place\" within the window. See the documentation for the command | |
| 955 `scroll-up-in-place' for more information. | |
| 956 | |
| 957 When the variable `scroll-in-place' is `nil' this command invokes the standard | |
| 958 GNU Emacs version of `scroll-up'. In that case, when LINES is `nil' the | |
| 959 current window is scrolled by nearly a complete windowful of text. | |
| 960 | |
| 961 Note that this command correctly handles cases in which `scroll-in-place' has a | |
| 962 buffer-local value in the window to be scrolled. That value is honored." | |
| 963 (interactive "P") | |
| 964 (scroll-window (scroll-choose-window) lines 1)) | |
| 965 | |
| 966 ;;; | |
| 967 ;;; NOTE that in the FSF GNU Emacs 19.26 version of `scroll-other-window-down', | |
| 968 ;;; the `lines' argument is required. I've left it optional in order to be | |
| 969 ;;; like `scroll-other-window'. | |
| 970 ;;; | |
| 971 | |
| 972 (defun scroll-other-window-down (&optional lines) | |
| 973 "Scroll the text of the next window downward by LINES lines. The next window | |
| 974 is generally the one below the current one, or the one at the top of the screen | |
| 975 if the current window is at the bottom of the screen. In special circumstances | |
| 976 this command will scroll a window other than the next window. Read the | |
| 977 documentation for the function `scroll-choose-other-window' for details. | |
| 978 | |
| 979 The argument LINES is optional. Its meaning depends on the current value of | |
| 980 the variable `scroll-in-place'. | |
| 981 | |
| 982 When the variable `scroll-in-place' is true, this command works just like the | |
| 983 command `scroll-other-window-down-in-place', scrolling the next window and | |
| 984 leaving point \"in place\" within that window. See the documentation for the | |
| 985 command `scroll-other-window-down-in-place' for more information. | |
| 986 | |
| 987 When the variable `scroll-in-place' is `nil' this command invokes the standard | |
| 988 GNU Emacs version of `scroll-other-window-down'. In that case, when LINES is | |
| 989 `nil' the next window is scrolled by nearly a complete windowful of text. | |
| 990 \(Note that `scroll-other-window-down' first appeared as a standard command in | |
| 991 the FSF's GNU Emacs 19.26. If the builtin version of that command is not | |
| 992 available in the current Emacs system, an equivalent action is invoked | |
| 993 instead.) | |
| 994 | |
| 995 Note that this command correctly handles cases in which `scroll-in-place' has a | |
| 996 buffer-local value in the window to be scrolled. That value is honored." | |
| 997 (interactive "P") | |
| 998 ;; This code is similar to the body of `scroll-window', below. | |
| 999 (let* ((other-window (scroll-choose-other-window)) | |
| 1000 (other-window-buffer (window-buffer other-window))) | |
| 1001 (if ;; Allow `scroll-in-place' to be a buffer-local variable. | |
| 1002 (save-excursion (set-buffer other-window-buffer) scroll-in-place) | |
| 1003 (scroll-window-in-place other-window lines -1) | |
| 1004 | |
| 1005 ;; Paranoid, we forcibly break any running sequence of "in place" | |
| 1006 ;; scrolling commands. | |
| 1007 (setq scroll-previous-window nil) | |
| 1008 ;; For XEmacs and Lucid GNU Emacs, preserve the region's state. | |
| 1009 (if (boundp 'zmacs-region-stays) | |
| 1010 (setq zmacs-region-stays t)) | |
| 1011 (if (fboundp 'original-scroll-other-window-down) | |
| 1012 (original-scroll-other-window-down lines) | |
| 1013 ;; `scroll-other-window-down' first appeared as a builtin in FSF GNU | |
| 1014 ;; Emacs 19.26, so it may not be available in the current Emacs system. | |
| 1015 ;; Do the equivalent thing. | |
| 1016 (original-scroll-other-window (cond | |
| 1017 ((null lines) '-) | |
| 1018 ((eq lines '-) nil) | |
| 1019 (t (- (prefix-numeric-value lines))) | |
| 1020 )) | |
| 1021 )) | |
| 1022 )) | |
| 1023 | |
| 1024 ;;; | |
| 1025 ;;; | |
| 1026 ;;; | |
| 1027 | |
| 1028 (defun scroll-other-window (&optional lines) | |
| 1029 "Scroll the text of the next window upward by LINES lines. The next window | |
| 1030 is generally the one below the current one, or the one at the top of the screen | |
| 1031 if the current window is at the bottom of the screen. In special circumstances | |
| 1032 this command will scroll a window other than the next window. Read the | |
| 1033 documentation for the function `scroll-choose-other-window' for details. | |
| 1034 | |
| 1035 The argument LINES is optional. Its meaning depends on the current value of | |
| 1036 the variable `scroll-in-place'. | |
| 1037 | |
| 1038 When the variable `scroll-in-place' is true, this command works just like the | |
| 1039 command `scroll-other-window-in-place', scrolling the next window and leaving | |
| 1040 point \"in place\" within that window. See the documentation for the command | |
| 1041 `scroll-other-window-in-place' for more information. | |
| 1042 | |
| 1043 When the variable `scroll-in-place' is `nil' this command invokes the standard | |
| 1044 GNU Emacs version of `scroll-other-window'. In that case, when LINES is `nil' | |
| 1045 the next window is scrolled by nearly a complete windowful of text. | |
| 1046 | |
| 1047 Note that this command correctly handles cases in which `scroll-in-place' has a | |
| 1048 buffer-local value in the window to be scrolled. That value is honored." | |
| 1049 (interactive "P") | |
| 1050 ;; This code is similar to the body of `scroll-window', below. | |
| 1051 (let* ((other-window (scroll-choose-other-window)) | |
| 1052 (other-window-buffer (window-buffer other-window))) | |
| 1053 (if ;; Allow `scroll-in-place' to be a buffer-local variable. | |
| 1054 (save-excursion (set-buffer other-window-buffer) scroll-in-place) | |
| 1055 (scroll-window-in-place other-window lines 1) | |
| 1056 | |
| 1057 ;; Paranoid, we forcibly break any running sequence of "in place" | |
| 1058 ;; scrolling commands. | |
| 1059 (setq scroll-previous-window nil) | |
| 1060 ;; For XEmacs and Lucid GNU Emacs, preserve the region's state. | |
| 1061 (if (boundp 'zmacs-region-stays) | |
| 1062 (setq zmacs-region-stays t)) | |
| 1063 (original-scroll-other-window lines)) | |
| 1064 )) | |
| 1065 | |
| 1066 | |
| 1067 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 1068 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 1069 ;;;; | |
| 1070 ;;;; Here are the new functions `scroll-window-in-place', `scroll-window', and | |
| 1071 ;;;; `scroll-window-in-place-continue-sequence'. These functions are intended | |
| 1072 ;;;; to be available to programs outside this package. | |
| 1073 ;;;; | |
| 1074 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 1075 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 1076 | |
| 1077 (defun scroll-window-in-place (window lines direction) | |
| 1078 "Scroll WINDOW vertically by the given number of window LINES in the given | |
| 1079 DIRECTION, leaving the window's point as close as possible to its original | |
| 1080 window position (window line and column). In other words, the window's point | |
| 1081 is left \"in place\" within the window. | |
| 1082 | |
| 1083 Note that the window to be scrolled does not have to be the selected window, | |
| 1084 and that this function does not change which window is selected. | |
| 1085 | |
| 1086 LINES specifies the number of window lines to scroll and is interpreted as if | |
| 1087 it were a raw prefix argument. If LINES is `nil', the window is scrolled by | |
| 1088 the amount it was moved by the immediately previous \"in place\" scrolling | |
| 1089 command, or by the value of the variable `scroll-default-lines' (by default, | |
| 1090 almost a windowful) if the previous command was not an \"in place\" scrolling | |
| 1091 command (or when WINDOW is not the previously scrolled window, or when the | |
| 1092 value of `this-command' is not in the same group as the previous scrolling | |
| 1093 command (see the documentation for the variable `scroll-command-groups'), or | |
| 1094 when other circumstances prevent the previous scrolling distance from being | |
| 1095 used). If LINES is the symbol `-', then the scrolling distance is determined | |
| 1096 as if LINES had been `nil' and then that distance is multiplied by -1. | |
| 1097 | |
| 1098 DIRECTION determines the direction of the scrolling motion. The values -1 and | |
| 1099 `down' indicate downward motion; the values 1 and `up' indicate upward motion. | |
| 1100 Any other value causes an error. | |
| 1101 | |
| 1102 If the window cannot be scrolled by the full distance (because the window hits | |
| 1103 the boundary of its buffer), the window's point is allowed to stray from its | |
| 1104 initial position so that it can move the full number of lines. If point cannot | |
| 1105 move the full number of lines, point is moved to the buffer boundary (unless it | |
| 1106 was already there, in which case a buffer boundary error is signalled instead). | |
| 1107 Any immediately subsequent \"in place\" scrolling commands will try to restore | |
| 1108 point to its initial window position. | |
| 1109 | |
| 1110 Unless the variable `scroll-allow-blank-lines-past-eob' is true, this function | |
| 1111 avoids displaying blank lines past the end of the buffer except as necessary to | |
| 1112 make a previous \"in place\" scrolling action reversible. Effectively, this | |
| 1113 means that this function will not display any more past-end-of-buffer blank | |
| 1114 lines than were visible when the current sequence of \"in place\" scrolling | |
| 1115 commands started. When the variable `scroll-allow-blank-lines-past-eob' is | |
| 1116 true, this function will display as many blank lines as is necessary to keep | |
| 1117 point \"in place\" in the window. | |
| 1118 | |
| 1119 Note that if WINDOW is not the selected window and it is impossible to scroll | |
| 1120 the text of WINDOW at all (because a buffer boundary is already visible), then | |
| 1121 this function signals a buffer boundary error. The error is signalled even if | |
| 1122 point could otherwise move the full number of lines." | |
| 1123 (let* (;; Make sure that the user doesn't quit in the middle and leave us | |
| 1124 ;; with our variables out of sync. | |
| 1125 (inhibit-quit t) | |
| 1126 (original-window (selected-window)) | |
| 1127 (original-buffer (current-buffer)) | |
| 1128 (window-height (- (window-height window) | |
| 1129 (if (window-minibuffer-p window) | |
| 1130 0 1))) | |
| 1131 (this-command-group (scroll-get-command-group this-command)) | |
| 1132 (continue-scroll-p | |
| 1133 (and ;; We're scrolling the previously scrolled window... | |
| 1134 (windowp scroll-previous-window) | |
| 1135 (eq window scroll-previous-window) | |
| 1136 ;; ...and the last command was an "in place" scrolling command | |
| 1137 ;; that can be continued by this command. | |
| 1138 (if (eq last-command t) | |
| 1139 ;; If the previous command signalled an error, the value of | |
| 1140 ;; `last-command' is `t'. Try to see if we signalled the | |
| 1141 ;; error and if point is where we left it. (NOTE that FSF | |
| 1142 ;; GNU Emacs 19.23+ no longer sets `last-command' to `t' | |
| 1143 ;; when a command signals an error. This is OK because the | |
| 1144 ;; else part of this `if' does the appropriate thing.) | |
| 1145 (and scroll-boundary-error-point | |
| 1146 (eq (window-point window) scroll-boundary-error-point) | |
| 1147 (memq scroll-boundary-error-command this-command-group) | |
| 1148 ) | |
| 1149 ;; Otherwise... | |
| 1150 (memq last-command this-command-group)) | |
| 1151 )) | |
| 1152 (lines-value (prefix-numeric-value lines)) | |
| 1153 ) | |
| 1154 | |
| 1155 ;; For XEmacs and Lucid GNU Emacs, preserve the region's state. Note that | |
| 1156 ;; these Emacsen will forcibly deactivate the region if we signal an error | |
| 1157 ;; later on. Is this bad? | |
| 1158 (if (boundp 'zmacs-region-stays) | |
| 1159 (setq zmacs-region-stays t)) | |
| 1160 ;; Parse the direction into a unit distance (1 or -1). | |
| 1161 (setq direction (scroll-parse-direction direction)) | |
| 1162 | |
| 1163 (setq scroll-previous-window window | |
| 1164 ;; `(setq scroll-boundary-error-command nil)' is not necessary. | |
| 1165 scroll-boundary-error-point nil) | |
| 1166 (unwind-protect | |
| 1167 (progn | |
| 1168 ;; `select-window' does an implicit `set-buffer'. | |
| 1169 (select-window window) | |
| 1170 | |
| 1171 (if (or ;; The current command is not a continuation of a running | |
| 1172 ;; sequence of "in place" scrolling commands... | |
| 1173 (not continue-scroll-p) | |
| 1174 ;; ...or we were given an explicit number of lines to scroll, | |
| 1175 ;; and that number has a different magnitude than the last | |
| 1176 ;; number of lines we scrolled... | |
| 1177 (and (or (numberp lines) (consp lines)) | |
| 1178 (/= scroll-previous-lines lines-value) | |
| 1179 (/= scroll-previous-lines (- lines-value))) | |
| 1180 ;; ...or the last successful scrolling command moved to a | |
| 1181 ;; buffer boundary, but the buffer is no longer in the state | |
| 1182 ;; we left it. (This can occur if, for example, we signal an | |
| 1183 ;; end-of-buffer error and something catches it and moves | |
| 1184 ;; point or renarrows. VM, for example, does this.) | |
| 1185 (and scroll-boundary-previous-point | |
| 1186 (or (not (or (bobp) (eobp))) | |
| 1187 (< scroll-boundary-previous-point (point-min)) | |
| 1188 (> scroll-boundary-previous-point (point-max)) | |
| 1189 (eq scroll-boundary-previous-point (point))))) | |
| 1190 | |
| 1191 ;; We're starting a new sequence of scrolling commands. | |
| 1192 (setq lines (if (or (numberp lines) (consp lines)) | |
| 1193 lines-value | |
| 1194 ;; The default number of lines... | |
| 1195 (* (if (eq lines '-) -1 1) | |
| 1196 (if (numberp scroll-default-lines) | |
| 1197 scroll-default-lines | |
| 1198 (max (- window-height | |
| 1199 next-screen-context-lines) | |
| 1200 1)))) | |
| 1201 scroll-previous-lines lines | |
| 1202 scroll-goal-column (scroll-determine-goal-column window) | |
| 1203 scroll-boundary-previous-point nil | |
| 1204 ;; `(setq scroll-boundary-previous-lines 0)' is not | |
| 1205 ;; necessary. | |
| 1206 scroll-window-debt 0 | |
| 1207 scroll-initially-displayed-lines | |
| 1208 (if scroll-allow-blank-lines-past-eob | |
| 1209 0 | |
| 1210 (save-excursion | |
| 1211 (goto-char (window-start window)) | |
| 1212 (vertical-motion (1- window-height))))) | |
| 1213 | |
| 1214 ;; Otherwise we want to scroll by the same number of lines (but | |
| 1215 ;; possibly in a different direction) that we scrolled in previous | |
| 1216 ;; invocations of this function. | |
| 1217 (cond ((null lines) | |
| 1218 (setq lines scroll-previous-lines)) | |
| 1219 ((eq lines '-) | |
| 1220 (setq lines (- scroll-previous-lines) | |
| 1221 scroll-previous-lines lines)) | |
| 1222 (t | |
| 1223 (setq lines lines-value | |
| 1224 scroll-previous-lines lines))) | |
| 1225 ) | |
| 1226 | |
| 1227 (setq lines (* direction lines)) | |
| 1228 | |
| 1229 ;; If point is not in the window, center window around point. We try | |
| 1230 ;; to account for a bug in `pos-visible-in-window-p' in some versions | |
| 1231 ;; of Emacs (see `scroll-pos-visible-bug-p', above). | |
| 1232 (save-excursion | |
| 1233 (if (pos-visible-in-window-p (let ((point (point))) | |
| 1234 (if (and scroll-pos-visible-bug-p | |
| 1235 (= point (point-max))) | |
| 1236 (max (1- point) (point-min)) | |
| 1237 point)) | |
| 1238 window) | |
| 1239 nil | |
| 1240 (vertical-motion (/ (- window-height) 2)) | |
| 1241 (set-window-start window (point)))) | |
| 1242 | |
| 1243 (cond ((and scroll-boundary-previous-point | |
| 1244 ;; `lines' is the same sign as the direction from point | |
| 1245 ;; to the `scroll-boundary-previous-point'. | |
| 1246 (cond ((> lines 0) | |
| 1247 (> (- scroll-boundary-previous-point (point)) 0)) | |
| 1248 ((< lines 0) | |
| 1249 (< (- scroll-boundary-previous-point (point)) 0)) | |
| 1250 (t nil))) | |
| 1251 ;; We're moving away from the buffer boundary. | |
| 1252 (goto-char scroll-boundary-previous-point) | |
| 1253 ;; Always move here (i.e., don't reject cases in which the | |
| 1254 ;; window doesn't move). | |
| 1255 (scroll-set-window-start window | |
| 1256 (- scroll-boundary-previous-lines)) | |
| 1257 ;; (message "Back, window debt is %s." scroll-window-debt) | |
| 1258 (setq scroll-boundary-previous-point nil)) | |
| 1259 | |
| 1260 ((= lines 0) | |
| 1261 ;; We're going nowhere, so save ourselves some work. | |
| 1262 ;; (message "Scrolled zero lines.") | |
| 1263 ) | |
| 1264 | |
| 1265 (t | |
| 1266 ;; Perform the scrolling motion. | |
| 1267 (let ((initial-point (point)) | |
| 1268 (moved nil)) | |
| 1269 ;; First move point and see how far it goes. | |
| 1270 (setq moved (vertical-motion lines)) | |
| 1271 (if (= moved lines) | |
| 1272 (progn | |
| 1273 ;; Point moved the full distance. Move to the desired | |
| 1274 ;; column and then try to move the window the full | |
| 1275 ;; distance, too. | |
| 1276 (move-to-column (+ (current-column) | |
| 1277 scroll-goal-column)) | |
| 1278 (or (scroll-set-window-start window moved | |
| 1279 original-window) | |
| 1280 (scroll-signal-boundary-error initial-point | |
| 1281 lines)) | |
| 1282 ;; (message "Normal, window debt is %s." | |
| 1283 ;; scroll-window-debt) | |
| 1284 ) | |
| 1285 ;; Point couldn't move all the way. Move to the buffer | |
| 1286 ;; boundary if we're not already there, or signal a buffer | |
| 1287 ;; boundary error otherwise. | |
| 1288 (let ((boundary-point (if (< lines 0) | |
| 1289 (point-min) | |
| 1290 (point-max))) | |
| 1291 (boundary-symbol (if (< lines 0) | |
| 1292 'beginning-of-buffer | |
| 1293 'end-of-buffer))) | |
| 1294 (if (= initial-point boundary-point) | |
| 1295 (scroll-signal-boundary-error initial-point lines) | |
| 1296 ;; Scroll the window by as many lines as point could | |
| 1297 ;; move. | |
| 1298 (or (scroll-set-window-start window moved | |
| 1299 original-window) | |
| 1300 (scroll-signal-boundary-error initial-point | |
| 1301 lines)) | |
| 1302 (message "%s" (get boundary-symbol 'error-message)) | |
| 1303 ;; (message "Boundary, window debt is %s." | |
| 1304 ;; scroll-window-debt) | |
| 1305 (setq scroll-boundary-previous-lines moved) | |
| 1306 (setq scroll-boundary-previous-point initial-point) | |
| 1307 (goto-char boundary-point)) | |
| 1308 ))) | |
| 1309 ))) | |
| 1310 | |
| 1311 ;; The unwind forms of the `unwind-protect', above. Restore the | |
| 1312 ;; originally selected window and current buffer. | |
| 1313 (select-window original-window) | |
| 1314 (set-buffer original-buffer))) | |
| 1315 | |
| 1316 ;; The standard GNU Emacs scrolling commands return `nil' so we do, too. | |
| 1317 nil) | |
| 1318 | |
| 1319 ;;; | |
| 1320 ;;; | |
| 1321 ;;; | |
| 1322 | |
| 1323 (defun scroll-window (window lines direction) | |
| 1324 "Scroll WINDOW vertically by the given number of window LINES in the given | |
| 1325 DIRECTION. Note that the window to be scrolled does not have to be the | |
| 1326 selected window, and that this function does not change which window is | |
| 1327 selected. | |
| 1328 | |
| 1329 When the variable `scroll-in-place' is true, this function simply invokes the | |
| 1330 function `scroll-window-in-place' to scroll the window and leave point \"in | |
| 1331 place\" within that window. See the documentation for `scroll-window-in-place' | |
| 1332 for more information. | |
| 1333 | |
| 1334 When the variable `scroll-in-place' is `nil' this function invokes the original | |
| 1335 version of the standard GNU Emacs command `scroll-down' or `scroll-up', as | |
| 1336 determined by DIRECTION, to scroll the window. If DIRECTION is -1 or `down', | |
| 1337 the original `scroll-down' is called; if DIRECTION is 1 or `up', the original | |
| 1338 `scroll-up' is called. Any other DIRECTION is an error. LINES is interpreted | |
| 1339 as if it were a raw prefix argument. If LINES is `nil', the window is scrolled | |
| 1340 by almost a complete windowful. If LINES is the symbol `-', the window is | |
| 1341 scrolled by almost a complete windowful in the opposite direction. | |
| 1342 | |
| 1343 Note that this function correctly handles cases in which `scroll-in-place' has | |
| 1344 a buffer-local value in the WINDOW's buffer. That value is honored." | |
| 1345 (let ((current-buffer (current-buffer)) | |
| 1346 (selected-window (selected-window)) | |
| 1347 (window-buffer (window-buffer window))) | |
| 1348 (if ;; Allow `scroll-in-place' to be a buffer-local variable. | |
| 1349 (if (eq current-buffer window-buffer) | |
| 1350 scroll-in-place | |
| 1351 (save-excursion (set-buffer window-buffer) scroll-in-place)) | |
| 1352 (scroll-window-in-place window lines direction) | |
| 1353 | |
| 1354 (unwind-protect | |
| 1355 (progn | |
| 1356 ;; Paranoid, we forcibly break any running sequence of "in place" | |
| 1357 ;; scrolling commands. | |
| 1358 (setq scroll-previous-window nil) | |
| 1359 ;; For XEmacs and Lucid GNU Emacs, preserve the region's state. | |
| 1360 (if (boundp 'zmacs-region-stays) | |
| 1361 (setq zmacs-region-stays t)) | |
| 1362 (select-window window) | |
| 1363 (if (= (scroll-parse-direction direction) 1) | |
| 1364 (original-scroll-up lines) | |
| 1365 (original-scroll-down lines))) | |
| 1366 (select-window selected-window) | |
| 1367 (set-buffer current-buffer)) | |
| 1368 ))) | |
| 1369 | |
| 1370 ;;; | |
| 1371 ;;; The following function is sometimes useful. For example, I call it from | |
| 1372 ;;; functions that are invoked by certain mouse button down events in order to | |
| 1373 ;;; preserve any running chain of "in place" scrolling commands. This lets me | |
| 1374 ;;; continue the sequence from my mouse button up functions. | |
| 1375 ;;; | |
| 1376 ;;; I haven't yet needed a function to purposely break a running sequence of | |
| 1377 ;;; "in place" scrolling commands. Such a function would be easy to write, | |
| 1378 ;;; however; just set the variable `scroll-previous-window' to `nil'. | |
| 1379 ;;; | |
| 1380 | |
| 1381 (defun scroll-window-in-place-continue-sequence () | |
| 1382 "If the previous command was a \"scroll in place\" command, set the variable | |
| 1383 `this-command' to the name of that previous command. This ensures that any | |
| 1384 running sequence of \"in place\" scrolling commands will not be broken by the | |
| 1385 current command. See the documentation for the commands `scroll-down-in-place' | |
| 1386 and `scroll-up-in-place' for more information about \"in place\" scrolling. | |
| 1387 | |
| 1388 NOTE that you don't need to call this function if the current command scrolls | |
| 1389 in place! You only need to call this function when the current command is not | |
| 1390 a \"scroll in place\" command but you still want to preserve any running | |
| 1391 sequence of \"in place\" commands. Such situations are rare. | |
| 1392 | |
| 1393 NOTE that this function sets `this-command' in order to trick the \"in place\" | |
| 1394 scrolling commands. If something else subsequently sets `this-command', any | |
| 1395 running sequence of scrolling commands will probably be broken anyway." | |
| 1396 (if (if (eq last-command t) | |
| 1397 ;; If `last-command' is `t', then the previous command signalled an | |
| 1398 ;; error. See if the last invocation of `scroll-window-in-place' | |
| 1399 ;; signalled an error. (NOTE that FSF GNU Emacs 19.23+ no longer | |
| 1400 ;; sets `last-command' to `t' when a command signals an error. This | |
| 1401 ;; is OK because the else part of this `if' does the appropriate | |
| 1402 ;; thing.) | |
| 1403 scroll-boundary-error-point | |
| 1404 ;; Otherwise, the value of `last-command' must belong to some group of | |
| 1405 ;; "in place" scrolling commands. | |
| 1406 (or (memq last-command scroll-default-command-group) | |
| 1407 (let ((groups scroll-command-groups) | |
| 1408 (found nil)) | |
| 1409 (while (and groups (not found)) | |
| 1410 (if (memq last-command (car groups)) | |
| 1411 (setq found t) | |
| 1412 (setq groups (cdr groups))) | |
| 1413 ) | |
| 1414 found))) | |
| 1415 (setq this-command last-command))) | |
| 1416 | |
| 1417 | |
| 1418 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 1419 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 1420 ;;;; | |
| 1421 ;;;; Here are the various auxiliary functions called by the function `scroll- | |
| 1422 ;;;; window-in-place'. None of the functions are intended to be called from | |
| 1423 ;;;; outside this package. | |
| 1424 ;;;; | |
| 1425 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 1426 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 1427 | |
| 1428 (defun scroll-get-command-group (command) | |
| 1429 "Return the group of \"in place\" scrolling commands that contains the given | |
| 1430 COMMAND. This is the list of commands with which the given command may share | |
| 1431 state and form \"chains.\" | |
| 1432 | |
| 1433 This function is an auxiliary for the function `scroll-window-in-place'. Don't | |
| 1434 call this function from other code." | |
| 1435 ;; This function assumes that the given command is an "in place" scrolling | |
| 1436 ;; command. | |
| 1437 (let ((groups scroll-command-groups) | |
| 1438 (found nil)) | |
| 1439 (while (and groups (not found)) | |
| 1440 (if (memq command (car groups)) | |
| 1441 (setq found t) | |
| 1442 (setq groups (cdr groups))) | |
| 1443 ) | |
| 1444 (if groups | |
| 1445 (car groups) | |
| 1446 ;; Otherwise return the default command group. If necessary, add the | |
| 1447 ;; given command to the default command group. | |
| 1448 (or (memq command scroll-default-command-group) | |
| 1449 (setq scroll-default-command-group | |
| 1450 (cons command scroll-default-command-group))) | |
| 1451 scroll-default-command-group) | |
| 1452 )) | |
| 1453 | |
| 1454 ;;; | |
| 1455 ;;; | |
| 1456 ;;; | |
| 1457 | |
| 1458 (defun scroll-parse-direction (direction) | |
| 1459 "Return the signed unit distance for the given DIRECTION. If DIRECTION is | |
| 1460 unacceptable, signal an error." | |
| 1461 (cond ((or (eq direction 1) (eq direction -1)) direction) | |
| 1462 ((eq direction 'up) 1) | |
| 1463 ((eq direction 'down) -1) | |
| 1464 (t (signal 'args-out-of-range (list 'direction direction))) | |
| 1465 )) | |
| 1466 | |
| 1467 ;;; | |
| 1468 ;;; | |
| 1469 ;;; | |
| 1470 | |
| 1471 (defun scroll-determine-goal-column (window) | |
| 1472 "Return the goal column for the \"in place\" vertical scrolling commands. | |
| 1473 This is the horizontal window position at which these commands try to keep | |
| 1474 point. | |
| 1475 | |
| 1476 This function is an auxiliary for the function `scroll-window-in-place'. Don't | |
| 1477 call this function from other code." | |
| 1478 ;; NOTE that `window' must be the selected window! `scroll-window-in-place' | |
| 1479 ;; ensures that this is so. | |
| 1480 (cond ((or truncate-lines | |
| 1481 (and truncate-partial-width-windows | |
| 1482 (< (window-width window) (screen-width))) | |
| 1483 (> (window-hscroll window) 0)) | |
| 1484 ;; Lines in this window are being truncated. | |
| 1485 (if (and track-eol (eolp)) | |
| 1486 9999 | |
| 1487 (current-column))) | |
| 1488 ((and track-eol (eolp)) | |
| 1489 ;; In some ways this isn't quite right, as point doesn't track the | |
| 1490 ;; ends of wrapped lines. But if it did so, point would be on the | |
| 1491 ;; wrong window line. This is the best we can do. | |
| 1492 (1- (window-width window))) | |
| 1493 (t (% (current-column) (1- (window-width window)))) | |
| 1494 )) | |
| 1495 | |
| 1496 ;;; | |
| 1497 ;;; | |
| 1498 ;;; | |
| 1499 | |
| 1500 (defun scroll-set-window-start (window lines &optional original-window) | |
| 1501 "Move the `window-start' of the given window, which must be the selected | |
| 1502 window. If the window was successfully scrolled, update the variable | |
| 1503 `scroll-window-debt' and return `t'. Otherwise return `nil'. | |
| 1504 | |
| 1505 This function is an auxiliary for the function `scroll-window-in-place'. Don't | |
| 1506 call this function from other code." | |
| 1507 (save-excursion | |
| 1508 (goto-char (window-start window)) | |
| 1509 ;; Try to move the window start by the specified number of lines. In | |
| 1510 ;; addition, try to make up any existing debt in the window start's | |
| 1511 ;; position and make sure that we don't move too close to the end of the | |
| 1512 ;; buffer. | |
| 1513 (let ((moved (+ (vertical-motion (+ lines | |
| 1514 scroll-window-debt | |
| 1515 scroll-initially-displayed-lines)) | |
| 1516 (vertical-motion (- scroll-initially-displayed-lines))))) | |
| 1517 ;; If we're not scrolling the `original-window' (i.e., the originally | |
| 1518 ;; selected window), punt if we didn't move the window start at all. | |
| 1519 (if (and original-window | |
| 1520 (not (eq window original-window)) | |
| 1521 (= moved 0)) | |
| 1522 nil | |
| 1523 ;; Otherwise update the window start and keep track of the debt in our | |
| 1524 ;; position. Return `t' to indicate success. | |
| 1525 (set-window-start window (point)) | |
| 1526 (setq scroll-window-debt (- (+ lines scroll-window-debt) moved)) | |
| 1527 t)) | |
| 1528 )) | |
| 1529 | |
| 1530 ;;; | |
| 1531 ;;; | |
| 1532 ;;; | |
| 1533 | |
| 1534 (defun scroll-signal-boundary-error (initial-point lines) | |
| 1535 "Move point to its initial location and signal an appropriate buffer boundary | |
| 1536 error. | |
| 1537 | |
| 1538 This function is an auxiliary for the function `scroll-window-in-place'. Don't | |
| 1539 call this function from other code." | |
| 1540 (goto-char initial-point) | |
| 1541 ;; Remember what we were doing and where point was when we signalled the | |
| 1542 ;; error so that subsequent "in place" scrolling commands can decide how to | |
| 1543 ;; recover. | |
| 1544 (setq scroll-boundary-error-command this-command | |
| 1545 scroll-boundary-error-point initial-point) | |
| 1546 (signal (if (< lines 0) 'beginning-of-buffer 'end-of-buffer) | |
| 1547 nil)) | |
| 1548 | |
| 1549 | |
| 1550 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 1551 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 1552 ;;;; | |
| 1553 ;;;; Finally, here is the `provide' statement. | |
| 1554 ;;;; | |
| 1555 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 1556 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 1557 | |
| 1558 (provide 'scroll-in-place) | |
| 1559 | |
| 1560 ;; End of file. | |
| 1561 |