;;; window.el --- GNU Emacs window commands aside from those written in C
-;; Copyright (C) 1985, 1989, 1992, 1993, 1994, 2000, 2001, 2002,
-;; 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+;; Copyright (C) 1985, 1989, 1992-1994, 2000-2011
+;; Free Software Foundation, Inc.
;; Maintainer: FSF
;; Keywords: internal
+;; Package: emacs
;; This file is part of GNU Emacs.
its normal operation could make a different buffer current. The
order of recently selected windows and the buffer list ordering
are not altered by this macro (unless they are altered in BODY)."
+ (declare (indent 0) (debug t))
`(let ((save-selected-window-window (selected-window))
;; It is necessary to save all of these, because calling
;; select-window changes frame-selected-window for whatever
The return value does not include the mode line or the header
line, if any. If a line at the bottom of the window is only
-partially visible, that line is included in the return value. If
-you do not want to include a partially visible bottom line in the
-return value, use `window-text-height' instead."
+partially visible, that line is included in the return value.
+If you do not want to include a partially visible bottom line
+in the return value, use `window-text-height' instead."
(or window (setq window (selected-window)))
(if (window-minibuffer-p window)
(window-height window)
(if mode-line-format 1 0)
(if header-line-format 1 0))))))
+;; See discussion in bug#4543.
+(defun window-full-height-p (&optional window)
+ "Return non-nil if WINDOW is not the result of a vertical split.
+WINDOW defaults to the selected window. (This function is not
+appropriate for minibuffers.)"
+ (unless window
+ (setq window (selected-window)))
+ (= (window-height window)
+ (window-height (frame-root-window (window-frame window)))))
+
(defun one-window-p (&optional nomini all-frames)
"Return non-nil if the selected window is the only window.
Optional arg NOMINI non-nil means don't count the minibuffer
which you entered the minibuffer, as well as the minibuffer
window.
-ALL-FRAMES nil or omitted means cycle through all windows on
- WINDOW's frame, plus the minibuffer window if specified by the
+ALL-FRAMES nil or omitted means cycle through all windows on the
+ selected frame, plus the minibuffer window if specified by the
MINIBUF argument, see above. If the minibuffer counts, cycle
through all windows on all frames that share that minibuffer
too.
iconified frames.
ALL-FRAMES a frame means cycle through all windows on that frame
only.
-Anything else means cycle through all windows on WINDOW's frame
- and no others.
+Anything else means cycle through all windows on the selected
+ frame and no others.
This function changes neither the order of recently selected
windows nor the buffer list."
:group 'windows
:group 'frames)
+;;;###autoload
+(put 'special-display-buffer-names 'risky-local-variable t)
+
(defcustom special-display-regexps nil
"List of regexps saying which buffers should be displayed specially.
Displaying a buffer with `display-buffer' or `pop-to-buffer', if
`special-display-regexps' contain a list entry whose car equals
or matches BUFFER-NAME, the return value is the cdr of that
entry."
- (cond
- ((not (stringp buffer-name)))
- ((member buffer-name special-display-buffer-names) t)
- ((let ((temp (assoc buffer-name special-display-buffer-names)))
- (cdr temp)))
- ((catch 'found
- (dolist (regexp special-display-regexps)
- (cond
- ((stringp regexp)
- (when (string-match-p regexp buffer-name)
- (throw 'found t)))
- ((and (consp regexp) (stringp (car regexp))
- (string-match-p (car regexp) buffer-name))
- (throw 'found (cdr regexp)))))))))
+ (let (tmp)
+ (cond
+ ((not (stringp buffer-name)))
+ ((member buffer-name special-display-buffer-names)
+ t)
+ ((setq tmp (assoc buffer-name special-display-buffer-names))
+ (cdr tmp))
+ ((catch 'found
+ (dolist (regexp special-display-regexps)
+ (cond
+ ((stringp regexp)
+ (when (string-match-p regexp buffer-name)
+ (throw 'found t)))
+ ((and (consp regexp) (stringp (car regexp))
+ (string-match-p (car regexp) buffer-name))
+ (throw 'found (cdr regexp))))))))))
(defcustom special-display-function 'special-display-popup-frame
"Function to call for displaying special buffers.
(defcustom pop-up-frames nil
"Whether `display-buffer' should make a separate frame.
-If nil, never make a seperate frame.
+If nil, never make a separate frame.
If the value is `graphic-only', make a separate frame
on graphic displays only.
Any other non-nil value means always make a separate frame."
:type 'boolean
:group 'windows)
-(defcustom split-height-threshold 80
- "Minimum height of window to be split vertically.
-If the value is a number, `display-buffer' can split a window
-only if it has at least as many lines. If the value is nil,
-`display-buffer' cannot split a window vertically.
-
-If the window is the only window on its frame, `display-buffer'
-can split it regardless of this value."
- :type '(choice (const nil) (number :tag "lines"))
+(defcustom split-window-preferred-function 'split-window-sensibly
+ "Function called by `display-buffer' routines to split a window.
+This function is called with a window as single argument and is
+supposed to split that window and return the new window. If the
+window can (or shall) not be split, it is supposed to return nil.
+The default is to call the function `split-window-sensibly' which
+tries to split the window in a way which seems most suitable.
+You can customize the options `split-height-threshold' and/or
+`split-width-threshold' in order to have `split-window-sensibly'
+prefer either vertical or horizontal splitting.
+
+If you set this to any other function, bear in mind that the
+`display-buffer' routines may call this function two times. The
+argument of the first call is the largest window on its frame.
+If that call fails to return a live window, the function is
+called again with the least recently used window as argument. If
+that call fails too, `display-buffer' will use an existing window
+to display its buffer.
+
+The window selected at the time `display-buffer' was invoked is
+still selected when this function is called. Hence you can
+compare the window argument with the value of `selected-window'
+if you intend to split the selected window instead or if you do
+not want to split the selected window."
+ :type 'function
:version "23.1"
:group 'windows)
-(defcustom split-width-threshold 160
- "Minimum width of window to be split horizontally.
-If the value is a number, `display-buffer' can split a window
-only if it has at least as many columns. If the value is nil,
-`display-buffer' cannot split a window horizontally."
- :type '(choice (const nil) (number :tag "columns"))
+(defcustom split-height-threshold 80
+ "Minimum height for splitting windows sensibly.
+If this is an integer, `split-window-sensibly' may split a window
+vertically only if it has at least this many lines. If this is
+nil, `split-window-sensibly' is not allowed to split a window
+vertically. If, however, a window is the only window on its
+frame, `split-window-sensibly' may split it vertically
+disregarding the value of this variable."
+ :type '(choice (const nil) (integer :tag "lines"))
:version "23.1"
:group 'windows)
-(defcustom split-window-preferred-function nil
- "Function used by `display-buffer' to split windows.
-If non-nil, a function called with a window as single argument
-supposed to split that window and return the new window. If the
-function returns nil the window is not split.
-
-If nil, `display-buffer' will split the window respecting the
-values of `split-height-threshold' and `split-width-threshold'."
- :type '(choice (const nil) (function :tag "Function"))
+(defcustom split-width-threshold 160
+ "Minimum width for splitting windows sensibly.
+If this is an integer, `split-window-sensibly' may split a window
+horizontally only if it has at least this many columns. If this
+is nil, `split-window-sensibly' is not allowed to split a window
+horizontally."
+ :type '(choice (const nil) (integer :tag "columns"))
:version "23.1"
:group 'windows)
-(defun window--splittable-p (window &optional horizontal)
- "Return non-nil if WINDOW can be split evenly.
-Optional argument HORIZONTAL non-nil means check whether WINDOW
-can be split horizontally.
+(defun window-splittable-p (window &optional horizontal)
+ "Return non-nil if `split-window-sensibly' may split WINDOW.
+Optional argument HORIZONTAL nil or omitted means check whether
+`split-window-sensibly' may split WINDOW vertically. HORIZONTAL
+non-nil means check whether WINDOW may be split horizontally.
-WINDOW can be split vertically when the following conditions
+WINDOW may be split vertically when the following conditions
hold:
-
- `window-size-fixed' is either nil or equals `width' for the
buffer of WINDOW.
-
-- `split-height-threshold' is a number and WINDOW is at least as
+- `split-height-threshold' is an integer and WINDOW is at least as
high as `split-height-threshold'.
-
- When WINDOW is split evenly, the emanating windows are at least
`window-min-height' lines tall and can accommodate at least one
line plus - if WINDOW has one - a mode line.
-WINDOW can be split horizontally when the following conditions
+WINDOW may be split horizontally when the following conditions
hold:
-
- `window-size-fixed' is either nil or equals `height' for the
buffer of WINDOW.
-
-- `split-width-threshold' is a number and WINDOW is at least as
+- `split-width-threshold' is an integer and WINDOW is at least as
wide as `split-width-threshold'.
-
- When WINDOW is split evenly, the emanating windows are at least
`window-min-width' or two (whichever is larger) columns wide."
(when (window-live-p window)
(* 2 (max window-min-height
(if mode-line-format 2 1))))))))))
+(defun split-window-sensibly (window)
+ "Split WINDOW in a way suitable for `display-buffer'.
+If `split-height-threshold' specifies an integer, WINDOW is at
+least `split-height-threshold' lines tall and can be split
+vertically, split WINDOW into two windows one above the other and
+return the lower window. Otherwise, if `split-width-threshold'
+specifies an integer, WINDOW is at least `split-width-threshold'
+columns wide and can be split horizontally, split WINDOW into two
+windows side by side and return the window on the right. If this
+can't be done either and WINDOW is the only window on its frame,
+try to split WINDOW vertically disregarding any value specified
+by `split-height-threshold'. If that succeeds, return the lower
+window. Return nil otherwise.
+
+By default `display-buffer' routines call this function to split
+the largest or least recently used window. To change the default
+customize the option `split-window-preferred-function'.
+
+You can enforce this function to not split WINDOW horizontally,
+by setting \(or binding) the variable `split-width-threshold' to
+nil. If, in addition, you set `split-height-threshold' to zero,
+chances increase that this function does split WINDOW vertically.
+
+In order to not split WINDOW vertically, set \(or bind) the
+variable `split-height-threshold' to nil. Additionally, you can
+set `split-width-threshold' to zero to make a horizontal split
+more likely to occur.
+
+Have a look at the function `window-splittable-p' if you want to
+know how `split-window-sensibly' determines whether WINDOW can be
+split."
+ (or (and (window-splittable-p window)
+ ;; Split window vertically.
+ (with-selected-window window
+ (split-window-vertically)))
+ (and (window-splittable-p window t)
+ ;; Split window horizontally.
+ (with-selected-window window
+ (split-window-horizontally)))
+ (and (eq window (frame-root-window (window-frame window)))
+ (not (window-minibuffer-p window))
+ ;; If WINDOW is the only window on its frame and is not the
+ ;; minibuffer window, try to split it vertically disregarding
+ ;; the value of `split-height-threshold'.
+ (let ((split-height-threshold 0))
+ (when (window-splittable-p window)
+ (with-selected-window window
+ (split-window-vertically)))))))
+
(defun window--try-to-split-window (window)
- "Split WINDOW if it is splittable.
-See `window--splittable-p' for how to determine whether a window
-is splittable. If WINDOW can be split, return the value returned
-by `split-window' (or `split-window-preferred-function')."
- (when (and (window-live-p window)
- (not (frame-parameter (window-frame window) 'unsplittable)))
- (if (functionp split-window-preferred-function)
- ;; `split-window-preferred-function' is specified, so use it.
- (funcall split-window-preferred-function window)
- (or (and (window--splittable-p window)
- ;; Split window vertically.
- (split-window window))
- (and (window--splittable-p window t)
- ;; Split window horizontally.
- (split-window window nil t))
- (and (eq window (frame-root-window (window-frame window)))
- (not (window-minibuffer-p window))
- ;; If WINDOW is the only window on its frame and not the
- ;; minibuffer window, attempt to split it vertically
- ;; disregarding the value of `split-height-threshold'.
- (let ((split-height-threshold 0))
- (and (window--splittable-p window)
- (split-window window))))))))
+ "Try to split WINDOW.
+Return value returned by `split-window-preferred-function' if it
+represents a live window, nil otherwise."
+ (and (window-live-p window)
+ (not (frame-parameter (window-frame window) 'unsplittable))
+ (let ((new-window
+ ;; Since `split-window-preferred-function' might
+ ;; throw an error use `condition-case'.
+ (condition-case nil
+ (funcall split-window-preferred-function window)
+ (error nil))))
+ (and (window-live-p new-window) new-window))))
(defun window--frame-usable-p (frame)
"Return FRAME if it can be used to display a buffer."
(not (eq window (selected-window)))
;; Don't resize minibuffer windows.
(not (window-minibuffer-p (selected-window)))
- (> (window-height (selected-window)) (window-height window))
+ (> (window-height (selected-window)) (window-height window))
(eq (window-frame window) (window-frame (selected-window)))
(let ((sel-edges (window-edges (selected-window)))
(win-edges (window-edges window)))
(raise-frame frame))
window))
-(defun window--display-buffer-2 (buffer window)
+(defun window--display-buffer-2 (buffer window &optional dedicated)
"Display BUFFER in WINDOW and make its frame visible.
+Set `window-dedicated-p' to DEDICATED if non-nil.
Return WINDOW."
(when (and (buffer-live-p buffer) (window-live-p window))
(set-window-buffer window buffer)
+ (when dedicated
+ (set-window-dedicated-p window dedicated))
(window--display-buffer-1 window)))
+(defvar display-buffer-mark-dedicated nil
+ "If non-nil, `display-buffer' marks the windows it creates as dedicated.
+The actual non-nil value of this variable will be copied to the
+`window-dedicated-p' flag.")
+
(defun display-buffer (buffer-or-name &optional not-this-window frame)
"Make buffer BUFFER-OR-NAME appear in some window but don't select it.
BUFFER-OR-NAME must be a buffer or the name of an existing
buffer (if (listp pars) pars))))))
((or use-pop-up-frames (not frame-to-use))
;; We want or need a new frame.
- (window--display-buffer-2
- buffer (frame-selected-window (funcall pop-up-frame-function))))
+ (let ((win (frame-selected-window (funcall pop-up-frame-function))))
+ (window--display-buffer-2 buffer win display-buffer-mark-dedicated)))
((and pop-up-windows
;; Make a new window.
(or (not (frame-parameter frame-to-use 'unsplittable))
(or (window--try-to-split-window
(get-largest-window frame-to-use t))
(window--try-to-split-window
- (get-lru-window frame-to-use t))))
- (window--display-buffer-2 buffer window-to-use)))
+ (get-lru-window frame-to-use t)))))
+ (window--display-buffer-2 buffer window-to-use
+ display-buffer-mark-dedicated))
((let ((window-to-undedicate
;; When NOT-THIS-WINDOW is non-nil, temporarily dedicate
;; the selected window to its buffer, to avoid that some of
(let ((buf (get-buffer-create buffer-or-name)))
(set-buffer-major-mode buf)
buf))))
- (old-window (selected-window))
(old-frame (selected-frame))
new-window new-frame)
(set-buffer buffer)
(setq new-window (display-buffer buffer other-window))
- (unless (eq new-window old-window)
- ;; `display-buffer' has chosen another window, select it.
- (select-window new-window norecord)
- (setq new-frame (window-frame new-window))
- (unless (eq new-frame old-frame)
- ;; `display-buffer' has chosen another frame, make sure it gets
- ;; input focus and is risen.
- (select-frame-set-input-focus new-frame)))
+ (select-window new-window norecord)
+ (setq new-frame (window-frame new-window))
+ (unless (eq new-frame old-frame)
+ ;; `display-buffer' has chosen another frame, make sure it gets
+ ;; input focus and is risen.
+ (select-frame-set-input-focus new-frame))
buffer))
;; I think this should be the default; I think people will prefer it--rms.
(setq size (+ (window-height) size)))
(setq new-window (split-window nil size))
(unless split-window-keep-point
- (save-excursion
- (set-buffer (window-buffer))
+ (with-current-buffer (window-buffer)
(goto-char (window-start))
(setq moved (vertical-motion (window-height)))
(set-window-start new-window (point))
(kill-buffer buffer)
(bury-buffer buffer))))
+\f
(defvar recenter-last-op nil
"Indicates the last recenter operation performed.
-Possible values: `top', `middle', `bottom'.")
+Possible values: `top', `middle', `bottom', integer or float numbers.")
+
+(defcustom recenter-positions '(middle top bottom)
+ "Cycling order for `recenter-top-bottom'.
+A list of elements with possible values `top', `middle', `bottom',
+integer or float numbers that define the cycling order for
+the command `recenter-top-bottom'.
+
+Top and bottom destinations are `scroll-margin' lines the from true
+window top and bottom. Middle redraws the frame and centers point
+vertically within the window. Integer number moves current line to
+the specified absolute window-line. Float number between 0.0 and 1.0
+means the percentage of the screen space from the top. The default
+cycling order is middle -> top -> bottom."
+ :type '(repeat (choice
+ (const :tag "Top" top)
+ (const :tag "Middle" middle)
+ (const :tag "Bottom" bottom)
+ (integer :tag "Line number")
+ (float :tag "Percentage")))
+ :version "23.2"
+ :group 'windows)
(defun recenter-top-bottom (&optional arg)
- "Move current line to window center, top, and bottom, successively.
-With no prefix argument, the first call redraws the frame and
- centers point vertically within the window. Successive calls
- scroll the window, placing point on the top, bottom, and middle
- consecutively. The cycling order is middle -> top -> bottom.
+ "Move current buffer line to the specified window line.
+With no prefix argument, successive calls place point according
+to the cycling order defined by `recenter-positions'.
A prefix argument is handled like `recenter':
With numeric prefix ARG, move current line to window-line ARG.
- With plain `C-u', move current line to window center.
-
-Top and bottom destinations are actually `scroll-margin' lines
- the from true window top and bottom."
+ With plain `C-u', move current line to window center."
(interactive "P")
(cond
- (arg (recenter arg)) ; Always respect ARG.
- ((or (not (eq this-command last-command))
- (eq recenter-last-op 'bottom))
- (setq recenter-last-op 'middle)
- (recenter))
+ (arg (recenter arg)) ; Always respect ARG.
(t
+ (setq recenter-last-op
+ (if (eq this-command last-command)
+ (car (or (cdr (member recenter-last-op recenter-positions))
+ recenter-positions))
+ (car recenter-positions)))
(let ((this-scroll-margin
(min (max 0 scroll-margin)
(truncate (/ (window-body-height) 4.0)))))
(cond ((eq recenter-last-op 'middle)
- (setq recenter-last-op 'top)
- (recenter this-scroll-margin))
+ (recenter))
((eq recenter-last-op 'top)
- (setq recenter-last-op 'bottom)
- (recenter (- -1 this-scroll-margin))))))))
+ (recenter this-scroll-margin))
+ ((eq recenter-last-op 'bottom)
+ (recenter (- -1 this-scroll-margin)))
+ ((integerp recenter-last-op)
+ (recenter recenter-last-op))
+ ((floatp recenter-last-op)
+ (recenter (round (* recenter-last-op (window-height))))))))))
(define-key global-map [?\C-l] 'recenter-top-bottom)
+
+(defun move-to-window-line-top-bottom (&optional arg)
+ "Position point relative to window.
+
+With a prefix argument ARG, acts like `move-to-window-line'.
+
+With no argument, positions point at center of window.
+Successive calls position point at positions defined
+by `recenter-positions'."
+ (interactive "P")
+ (cond
+ (arg (move-to-window-line arg)) ; Always respect ARG.
+ (t
+ (setq recenter-last-op
+ (if (eq this-command last-command)
+ (car (or (cdr (member recenter-last-op recenter-positions))
+ recenter-positions))
+ (car recenter-positions)))
+ (let ((this-scroll-margin
+ (min (max 0 scroll-margin)
+ (truncate (/ (window-body-height) 4.0)))))
+ (cond ((eq recenter-last-op 'middle)
+ (call-interactively 'move-to-window-line))
+ ((eq recenter-last-op 'top)
+ (move-to-window-line this-scroll-margin))
+ ((eq recenter-last-op 'bottom)
+ (move-to-window-line (- -1 this-scroll-margin)))
+ ((integerp recenter-last-op)
+ (move-to-window-line recenter-last-op))
+ ((floatp recenter-last-op)
+ (move-to-window-line (round (* recenter-last-op (window-height))))))))))
+
+(define-key global-map [?\M-r] 'move-to-window-line-top-bottom)
+
+\f
+;;; Scrolling commands.
+
+;;; Scrolling commands which does not signal errors at top/bottom
+;;; of buffer at first key-press (instead moves to top/bottom
+;;; of buffer).
+
+(defcustom scroll-error-top-bottom nil
+ "Move point to top/bottom of buffer before signalling a scrolling error.
+A value of nil means just signal an error if no more scrolling possible.
+A value of t means point moves to the beginning or the end of the buffer
+\(depending on scrolling direction) when no more scrolling possible.
+When point is already on that position, then signal an error."
+ :type 'boolean
+ :group 'scrolling
+ :version "24.1")
+
+(defun scroll-up-command (&optional arg)
+ "Scroll text of selected window upward ARG lines; or near full screen if no ARG.
+If `scroll-error-top-bottom' is non-nil and `scroll-up' cannot
+scroll window further, move cursor to the bottom line.
+When point is already on that position, then signal an error.
+A near full screen is `next-screen-context-lines' less than a full screen.
+Negative ARG means scroll downward.
+If ARG is the atom `-', scroll downward by nearly full screen."
+ (interactive "^P")
+ (cond
+ ((null scroll-error-top-bottom)
+ (scroll-up arg))
+ ((eq arg '-)
+ (scroll-down-command nil))
+ ((< (prefix-numeric-value arg) 0)
+ (scroll-down-command (- (prefix-numeric-value arg))))
+ ((eobp)
+ (scroll-up arg)) ; signal error
+ (t
+ (condition-case nil
+ (scroll-up arg)
+ (end-of-buffer
+ (if arg
+ ;; When scrolling by ARG lines can't be done,
+ ;; move by ARG lines instead.
+ (forward-line arg)
+ ;; When ARG is nil for full-screen scrolling,
+ ;; move to the bottom of the buffer.
+ (goto-char (point-max))))))))
+
+(put 'scroll-up-command 'scroll-command t)
+
+(defun scroll-down-command (&optional arg)
+ "Scroll text of selected window down ARG lines; or near full screen if no ARG.
+If `scroll-error-top-bottom' is non-nil and `scroll-down' cannot
+scroll window further, move cursor to the top line.
+When point is already on that position, then signal an error.
+A near full screen is `next-screen-context-lines' less than a full screen.
+Negative ARG means scroll upward.
+If ARG is the atom `-', scroll upward by nearly full screen."
+ (interactive "^P")
+ (cond
+ ((null scroll-error-top-bottom)
+ (scroll-down arg))
+ ((eq arg '-)
+ (scroll-up-command nil))
+ ((< (prefix-numeric-value arg) 0)
+ (scroll-up-command (- (prefix-numeric-value arg))))
+ ((bobp)
+ (scroll-down arg)) ; signal error
+ (t
+ (condition-case nil
+ (scroll-down arg)
+ (beginning-of-buffer
+ (if arg
+ ;; When scrolling by ARG lines can't be done,
+ ;; move by ARG lines instead.
+ (forward-line (- arg))
+ ;; When ARG is nil for full-screen scrolling,
+ ;; move to the top of the buffer.
+ (goto-char (point-min))))))))
+
+(put 'scroll-down-command 'scroll-command t)
+
+;;; Scrolling commands which scroll a line instead of full screen.
+
+(defun scroll-up-line (&optional arg)
+ "Scroll text of selected window upward ARG lines; or one line if no ARG.
+If ARG is omitted or nil, scroll upward by one line.
+This is different from `scroll-up-command' that scrolls a full screen."
+ (interactive "p")
+ (scroll-up (or arg 1)))
+
+(put 'scroll-up-line 'scroll-command t)
+
+(defun scroll-down-line (&optional arg)
+ "Scroll text of selected window down ARG lines; or one line if no ARG.
+If ARG is omitted or nil, scroll down by one line.
+This is different from `scroll-down-command' that scrolls a full screen."
+ (interactive "p")
+ (scroll-down (or arg 1)))
+
+(put 'scroll-down-line 'scroll-command t)
+
+\f
+(defun scroll-other-window-down (lines)
+ "Scroll the \"other window\" down.
+For more details, see the documentation for `scroll-other-window'."
+ (interactive "P")
+ (scroll-other-window
+ ;; Just invert the argument's meaning.
+ ;; We can do that without knowing which window it will be.
+ (if (eq lines '-) nil
+ (if (null lines) '-
+ (- (prefix-numeric-value lines))))))
+
+(defun beginning-of-buffer-other-window (arg)
+ "Move point to the beginning of the buffer in the other window.
+Leave mark at previous position.
+With arg N, put point N/10 of the way from the true beginning."
+ (interactive "P")
+ (let ((orig-window (selected-window))
+ (window (other-window-for-scrolling)))
+ ;; We use unwind-protect rather than save-window-excursion
+ ;; because the latter would preserve the things we want to change.
+ (unwind-protect
+ (progn
+ (select-window window)
+ ;; Set point and mark in that window's buffer.
+ (with-no-warnings
+ (beginning-of-buffer arg))
+ ;; Set point accordingly.
+ (recenter '(t)))
+ (select-window orig-window))))
+
+(defun end-of-buffer-other-window (arg)
+ "Move point to the end of the buffer in the other window.
+Leave mark at previous position.
+With arg N, put point N/10 of the way from the true end."
+ (interactive "P")
+ ;; See beginning-of-buffer-other-window for comments.
+ (let ((orig-window (selected-window))
+ (window (other-window-for-scrolling)))
+ (unwind-protect
+ (progn
+ (select-window window)
+ (with-no-warnings
+ (end-of-buffer arg))
+ (recenter '(t)))
+ (select-window orig-window))))
+
\f
(defvar mouse-autoselect-window-timer nil
"Timer used by delayed window autoselection.")
(define-key ctl-x-map "+" 'balance-windows)
(define-key ctl-x-4-map "0" 'kill-buffer-and-window)
-;; arch-tag: b508dfcc-c353-4c37-89fa-e773fe10cea9
;;; window.el ends here
HCoop / bpt / emacs.git / blobdiff