-;;; window.el --- GNU Emacs window commands aside from those written in C.
+;;; window.el --- GNU Emacs window commands aside from those written in C
-;; Copyright (C) 1985, 1989, 1992, 1993, 1994, 2000
+;; Copyright (C) 1985, 1989, 1992, 1993, 1994, 2000, 2001, 2002, 2004, 2005
;; Free Software Foundation, Inc.
;; Maintainer: FSF
+;; Keywords: internal
;; This file is part of GNU Emacs.
;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.
-
;;; Commentary:
;; Window tree functions.
;;; Code:
+(defvar window-size-fixed nil
+ "*Non-nil in a buffer means windows displaying the buffer are fixed-size.
+If the value is `height', then only the window's height is fixed.
+If the value is `width', then only the window's width is fixed.
+Any other non-nil value fixes both the width and the height.
+Emacs won't change the size of any window displaying that buffer,
+unless you explicitly change the size, or Emacs has no other choice.")
+(make-variable-buffer-local 'window-size-fixed)
+
+(defmacro save-selected-window (&rest body)
+ "Execute BODY, then select the window that was selected before BODY.
+Also restore the selected window of each frame as it was at the start
+of this construct.
+However, if a window has become dead, don't get an error,
+just refrain from reselecting it.
+Return the value of the last form in BODY."
+ `(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
+ ;; frame that window is in.
+ (save-selected-window-alist
+ (mapcar (lambda (frame) (list frame (frame-selected-window frame)))
+ (frame-list))))
+ (unwind-protect
+ (progn ,@body)
+ (dolist (elt save-selected-window-alist)
+ (and (frame-live-p (car elt))
+ (window-live-p (cadr elt))
+ (set-frame-selected-window (car elt) (cadr elt))))
+ (if (window-live-p save-selected-window-window)
+ (select-window save-selected-window-window)))))
+
+(defun window-body-height (&optional window)
+ "Return number of lines in window WINDOW for actual buffer text.
+This does not include the mode line (if any) or the header line (if any)."
+ (or window (setq window (selected-window)))
+ (if (window-minibuffer-p window)
+ (window-height window)
+ (with-current-buffer (window-buffer window)
+ (max 1 (- (window-height window)
+ (if mode-line-format 1 0)
+ (if header-line-format 1 0))))))
+
(defun one-window-p (&optional nomini all-frames)
- "Return non-nil if the selected window is the only window (in its frame).
+ "Return non-nil if the selected window is the only window.
Optional arg NOMINI non-nil means don't count the minibuffer
-even if it is active.
+even if it is active. Otherwise, the minibuffer is counted
+when it is active.
The optional arg ALL-FRAMES t means count windows on all frames.
If it is `visible', count windows on all visible frames.
ALL-FRAMES nil or omitted means count only the selected frame,
plus the minibuffer it uses (which may be on another frame).
-If ALL-FRAMES is neither nil nor t, count only the selected frame."
+ALL-FRAMES 0 means count all windows in all visible or iconified frames.
+If ALL-FRAMES is anything else, count only the selected frame."
(let ((base-window (selected-window)))
(if (and nomini (eq base-window (minibuffer-window)))
(setq base-window (next-window base-window)))
(eq base-window
(next-window base-window (if nomini 'arg) all-frames))))
+(defun window-current-scroll-bars (&optional window)
+ "Return the current scroll-bar settings in window WINDOW.
+Value is a cons (VERTICAL . HORIZONTAL) where VERTICAL specifies the
+current location of the vertical scroll-bars (left, right, or nil),
+and HORIZONTAL specifies the current location of the horizontal scroll
+bars (top, bottom, or nil)."
+ (let ((vert (nth 2 (window-scroll-bars window)))
+ (hor nil))
+ (when (or (eq vert t) (eq hor t))
+ (let ((fcsb (frame-current-scroll-bars
+ (window-frame (or window (selected-window))))))
+ (if (eq vert t)
+ (setq vert (car fcsb)))
+ (if (eq hor t)
+ (setq hor (cdr fcsb)))))
+ (cons vert hor)))
+
(defun walk-windows (proc &optional minibuf all-frames)
"Cycle through all visible windows, calling PROC for each one.
PROC is called with a window as argument.
(cons walk-windows-current walk-windows-already-seen))
(funcall proc walk-windows-current)))))
-(defun some-window (predicate &optional minibuf all-frames default)
+(defun get-window-with-predicate (predicate &optional minibuf
+ all-frames default)
"Return a window satisfying PREDICATE.
This function cycles through all visible windows using `walk-windows',
minibuf all-frames)
default))
+(defalias 'some-window 'get-window-with-predicate)
+
(defun minibuffer-window-active-p (window)
"Return t if WINDOW (a minibuffer window) is now active."
(eq window (active-minibuffer-window)))
-
-(defmacro save-selected-window (&rest body)
- "Execute BODY, then select the window that was selected before BODY."
- `(let ((save-selected-window-window (selected-window)))
- (unwind-protect
- (progn ,@body)
- (select-window save-selected-window-window))))
\f
(defun count-windows (&optional minibuf)
"Return the number of visible windows.
count))
(defun window-safely-shrinkable-p (&optional window)
- "Non-nil if the WINDOW can be shrunk without shrinking other windows."
- (save-selected-window
- (when window (select-window window))
- (or (and (not (eq window (frame-first-window)))
- (= (car (window-edges))
- (car (window-edges (previous-window)))))
- (= (car (window-edges))
- (car (window-edges (next-window)))))))
+ "Non-nil if the WINDOW can be shrunk without shrinking other windows.
+If WINDOW is nil or omitted, it defaults to the currently selected window."
+ (with-selected-window (or window (selected-window))
+ (let ((edges (window-edges)))
+ (or (= (nth 2 edges) (nth 2 (window-edges (previous-window))))
+ (= (nth 0 edges) (nth 0 (window-edges (next-window))))))))
+
(defun balance-windows ()
"Make all visible windows the same height (approximately)."
(interactive)
- (let ((count -1) levels newsizes size
+ (let ((count -1) levels newsizes level-size
;; Don't count the lines that are above the uppermost windows.
;; (These are the menu bar lines, if any.)
- (mbl (nth 1 (window-edges (frame-first-window (selected-frame))))))
+ (mbl (nth 1 (window-edges (frame-first-window (selected-frame)))))
+ (last-window (previous-window (frame-first-window (selected-frame))))
+ ;; Don't count the lines that are past the lowest main window.
+ total)
+ ;; Bottom edge of last window determines what size we have to work with.
+ (setq total
+ (+ (window-height last-window)
+ (nth 1 (window-edges last-window))))
+
;; Find all the different vpos's at which windows start,
;; then count them. But ignore levels that differ by only 1.
- (save-window-excursion
- (let (tops (prev-top -2))
- (walk-windows (function (lambda (w)
- (setq tops (cons (nth 1 (window-edges w))
- tops))))
- 'nomini)
- (setq tops (sort tops '<))
- (while tops
- (if (> (car tops) (1+ prev-top))
- (setq prev-top (car tops)
- count (1+ count)))
- (setq levels (cons (cons (car tops) count) levels))
- (setq tops (cdr tops)))
- (setq count (1+ count))))
- ;; Subdivide the frame into that many vertical levels.
- (setq size (/ (- (frame-height) mbl) count))
- (walk-windows (function
- (lambda (w)
- (select-window w)
- (let ((newtop (cdr (assq (nth 1 (window-edges))
- levels)))
- (newbot (or (cdr (assq (+ (window-height)
- (nth 1 (window-edges)))
- levels))
- count)))
- (setq newsizes
- (cons (cons w (* size (- newbot newtop)))
- newsizes)))))
- 'nomini)
- (walk-windows (function (lambda (w)
- (select-window w)
- (let ((newsize (cdr (assq w newsizes))))
- (enlarge-window (- newsize
- (window-height))))))
- 'nomini)))
+ (let (tops (prev-top -2))
+ (walk-windows (function (lambda (w)
+ (setq tops (cons (nth 1 (window-edges w))
+ tops))))
+ 'nomini)
+ (setq tops (sort tops '<))
+ (while tops
+ (if (> (car tops) (1+ prev-top))
+ (setq prev-top (car tops)
+ count (1+ count)))
+ (setq levels (cons (cons (car tops) count) levels))
+ (setq tops (cdr tops)))
+ (setq count (1+ count)))
+ ;; Subdivide the frame into desired number of vertical levels.
+ (setq level-size (/ (- total mbl) count))
+ (save-selected-window
+ ;; Set up NEWSIZES to map windows to their desired sizes.
+ ;; If a window ends at the bottom level, don't include
+ ;; it in NEWSIZES. Those windows get the right sizes
+ ;; by adjusting the ones above them.
+ (walk-windows (function
+ (lambda (w)
+ (let ((newtop (cdr (assq (nth 1 (window-edges w))
+ levels)))
+ (newbot (cdr (assq (+ (window-height w)
+ (nth 1 (window-edges w)))
+ levels))))
+ (if newbot
+ (setq newsizes
+ (cons (cons w (* level-size (- newbot newtop)))
+ newsizes))))))
+ 'nomini)
+ ;; Make walk-windows start with the topmost window.
+ (select-window (previous-window (frame-first-window (selected-frame))))
+ (let (done (count 0))
+ ;; Give each window its precomputed size, or at least try.
+ ;; Keep trying until they all get the intended sizes,
+ ;; but not more than 3 times (to prevent infinite loop).
+ (while (and (not done) (< count 3))
+ (setq done t)
+ (setq count (1+ count))
+ (walk-windows (function (lambda (w)
+ (select-window w)
+ (let ((newsize (cdr (assq w newsizes))))
+ (when newsize
+ (enlarge-window (- newsize
+ (window-height))
+ nil t)
+ (unless (= (window-height) newsize)
+ (setq done nil))))))
+ 'nomini))))))
\f
-;;; I think this should be the default; I think people will prefer it--rms.
+;; I think this should be the default; I think people will prefer it--rms.
(defcustom split-window-keep-point t
- "*If non-nil, split windows keeps the original point in both children.
+ "*If non-nil, \\[split-window-vertically] keeps the original point \
+in both children.
This is often more convenient for editing.
If nil, adjust point in each of the two windows to minimize redisplay.
-This is convenient on slow terminals, but point can move strangely."
+This is convenient on slow terminals, but point can move strangely.
+
+This option applies only to `split-window-vertically' and
+functions that call it. `split-window' always keeps the original
+point in both children,"
:type 'boolean
:group 'windows)
(defun split-window-vertically (&optional arg)
"Split current window into two windows, one above the other.
The uppermost window gets ARG lines and the other gets the rest.
-Negative arg means select the size of the lowermost window instead.
+Negative ARG means select the size of the lowermost window instead.
With no argument, split equally or close to it.
Both windows display the same buffer now current.
If the variable `split-window-keep-point' is non-nil, both new windows
will get the same value of point as the current window. This is often
-more convenient for editing.
+more convenient for editing. The upper window is the selected window.
-Otherwise, we chose window starts so as to minimize the amount of
+Otherwise, we choose window starts so as to minimize the amount of
redisplay; this is convenient on slow terminals. The new selected
window is the one that the current value of point appears in. The
value of point can change if the text around point is hidden by the
-new mode line."
+new mode line.
+
+Regardless of the value of `split-window-keep-point', the upper
+window is the original one and the return value is the new, lower
+window."
(interactive "P")
(let ((old-w (selected-window))
(old-point (point))
(defvar view-return-to-alist)
(defun split-window-save-restore-data (new-w old-w)
- (save-excursion
- (set-buffer (window-buffer))
+ (with-current-buffer (window-buffer)
(if view-mode
(let ((old-info (assq old-w view-return-to-alist)))
- (setq view-return-to-alist
- (cons (cons new-w (cons (and old-info (car (cdr old-info))) t))
- view-return-to-alist))))
+ (if old-info
+ (push (cons new-w (cons (car (cdr old-info)) t))
+ view-return-to-alist))))
new-w))
(defun split-window-horizontally (&optional arg)
"Split current window into two windows side by side.
This window becomes the leftmost of the two, and gets ARG columns.
-Negative arg means select the size of the rightmost window instead.
+Negative ARG means select the size of the rightmost window instead.
The argument includes the width of the window's scroll bar; if there
are no scroll bars, it includes the width of the divider column
-to the window's right, if any. No arg means split equally."
+to the window's right, if any. No ARG means split equally.
+
+The original, leftmost window remains selected.
+The return value is the new, rightmost window."
(interactive "P")
(let ((old-w (selected-window))
(size (and arg (prefix-numeric-value arg))))
(and size (< size 0)
(setq size (+ (window-width) size)))
(split-window-save-restore-data (split-window nil size t) old-w)))
-\f
-(defcustom mode-line-window-height-fudge nil
- "*Fudge factor returned by `mode-line-window-height-fudge' on graphic displays.
-If non-nil, it should be the number of lines to add to the sizes of
-windows to compensate for the extra height of the mode-line, so it
-doesn't't obscure the last line of text.
-
-If nil, an attempt is made to calculate reasonable value.
-
-This is a kluge."
- :type '(choice (const :tag "Guess" nil)
- (integer :tag "Extra lines" :value 1))
- :group 'windows)
-
-;; List of face attributes that might change a face's height
-(defconst height-affecting-face-attributes
- '(:family :height :box :font :inherit))
-
-(defsubst mode-line-window-height-fudge (&optional face)
- "Return a fudge factor to compensate for the extra height of graphic mode-lines.
-On a non-graphic display, return 0.
-
-FACE is the face used to display the mode-line; it defaults to `mode-line'.
-
-If the variable `mode-line-window-height-fudge' has a non-nil value, it
-is returned. Otherwise, the `mode-line' face is checked to see if it
-contains any attributes that might affect its height; if it does, 1 is
-returned, otherwise 0.
-
-\[Because mode-lines on a graphics capable display may have a height
-larger than a normal text line, a window who's size is calculated to
-exactly show some text, including 1 line for the mode-line, may be
-displayed with the last text line obscured by the mode-line.
-
-To work-around this problem, call `mode-line-window-height-fudge', and
-add the return value to the requested window size.]
-
-This is a kluge."
- (if (display-graphic-p)
- (or
- ;; Return user-specified value
- mode-line-window-height-fudge
- ;; Try and detect whether mode-line face has any attributes that
- ;; could make it bigger than a default text line, and return a
- ;; fudge factor of 1 if so.
- (let ((attrs height-affecting-face-attributes)
- (fudge 0))
- (while attrs
- (let ((val (face-attribute (or face 'mode-line) (pop attrs))))
- (unless (or (null val) (eq val 'unspecified))
- (setq fudge 1 attrs nil))))
- fudge))
- 0))
\f
-;;; These functions should eventually be replaced with versions that
-;;; really do the job (instead of using the kludgey mode-line face
-;;; hacking junk).
-
-(defun window-text-height (&optional window)
- "Return the height in lines of the text display area of WINDOW.
-This doesn't include the mode-line (or header-line if any) or any
-partial-height lines in the text display area.
-
-Note that the current implementation of this function may sometimes
-return an inaccurate value, but attempts to be conservative, by
-returning fewer lines than actually exist in the case where the real
-value cannot be determined."
- (with-current-buffer (window-buffer window)
- (- (window-height window)
- (if (and (not (window-minibuffer-p window))
- mode-line-format)
- (1+ (mode-line-window-height-fudge))
- 0)
- (if header-line-format
- (1+ (mode-line-window-height-fudge 'header-line))
- 0))))
-
(defun set-window-text-height (window height)
"Sets the height in lines of the text display area of WINDOW to HEIGHT.
This doesn't include the mode-line (or header-line if any) or any
(defun window-buffer-height (window)
"Return the height (in screen lines) of the buffer that WINDOW is displaying."
- (save-excursion
- (set-buffer (window-buffer window))
- (goto-char (point-min))
- (let ((ignore-final-newline
- ;; If buffer ends with a newline, ignore it when counting height
- ;; unless point is after it.
- (and (not (eobp)) (eq ?\n (char-after (1- (point-max)))))))
- (+ 1 (nth 2 (compute-motion (point-min)
- '(0 . 0)
- (- (point-max) (if ignore-final-newline 1 0))
- (cons 0 100000000)
- (window-width window)
- nil
- window))))))
+ (with-current-buffer (window-buffer window)
+ (max 1
+ (count-screen-lines (point-min) (point-max)
+ ;; If buffer ends with a newline, ignore it when
+ ;; counting height unless point is after it.
+ (eobp)
+ window))))
(defun count-screen-lines (&optional beg end count-final-newline window)
"Return the number of screen lines in the region.
(defun fit-window-to-buffer (&optional window max-height min-height)
"Make WINDOW the right size to display its contents exactly.
+If WINDOW is omitted or nil, it defaults to the selected window.
If the optional argument MAX-HEIGHT is supplied, it is the maximum height
the window is allowed to be, defaulting to the frame height.
If the optional argument MIN-HEIGHT is supplied, it is the minimum
(defun shrink-window-if-larger-than-buffer (&optional window)
"Shrink the WINDOW to be as small as possible to display its contents.
+If WINDOW is omitted or nil, it defaults to the selected window.
Do not shrink to less than `window-min-height' lines.
Do nothing if the buffer contains more lines than the present window height,
or if some of the window's contents are scrolled out of view,
-or if shrinking this window would also shrink another window.
-or if the window is the only window of its frame.
-Return non-nil if the window was shrunk."
+or if shrinking this window would also shrink another window,
+or if the window is the only window of its frame."
(interactive)
(when (null window)
(setq window (selected-window)))
(pos-visible-in-window-p (point-min) window)
(not (eq mini 'only))
(or (not mini)
- (< (nth 3 edges) (nth 1 (window-edges mini)))
- (> (nth 1 edges) (frame-parameter frame 'menu-bar-lines))))
+ (let ((mini-window (minibuffer-window frame)))
+ (or (null mini-window)
+ (not (eq frame (window-frame mini-window)))
+ (< (nth 3 edges)
+ (nth 1 (window-edges mini-window)))
+ (> (nth 1 edges)
+ (frame-parameter frame 'menu-bar-lines))))))
(fit-window-to-buffer window (window-height window)))))
(defun kill-buffer-and-window ()
"Kill the current buffer and delete the selected window."
(interactive)
- (if (yes-or-no-p (format "Kill buffer `%s'? " (buffer-name)))
- (let ((buffer (current-buffer)))
- (delete-window (selected-window))
- (kill-buffer buffer))
- (error "Aborted")))
+ (let ((window-to-delete (selected-window))
+ (delete-window-hook (lambda ()
+ (condition-case nil
+ (delete-window)
+ (error nil)))))
+ (add-hook 'kill-buffer-hook delete-window-hook t t)
+ (if (kill-buffer (current-buffer))
+ ;; If `delete-window' failed before, we rerun it to regenerate
+ ;; the error so it can be seen in the minibuffer.
+ (when (eq (selected-window) window-to-delete)
+ (delete-window))
+ (remove-hook 'kill-buffer-hook delete-window-hook t))))
(defun quit-window (&optional kill window)
"Quit the current buffer. Bury it, and maybe delete the selected frame.
-\(The frame is deleted if it is contains a dedicated window for the buffer.)
+\(The frame is deleted if it contains a dedicated window for the buffer.)
With a prefix argument, kill the buffer instead.
Noninteractively, if KILL is non-nil, then kill the current buffer,
(and window (not window-handled) (not window-solitary)
(delete-window window))))
+(defun handle-select-window (event)
+ "Handle select-window events."
+ (interactive "e")
+ (let ((window (posn-window (event-start event))))
+ (if (and (window-live-p window)
+ ;; Don't switch if we're currently in the minibuffer.
+ ;; This tries to work around problems where the minibuffer gets
+ ;; unselected unexpectedly, and where you then have to move
+ ;; your mouse all the way down to the minibuffer to select it.
+ (not (window-minibuffer-p (selected-window)))
+ ;; Don't switch to a minibuffer window unless it's active.
+ (or (not (window-minibuffer-p window))
+ (minibuffer-window-active-p window)))
+ (select-window window))))
+
(define-key ctl-x-map "2" 'split-window-vertically)
(define-key ctl-x-map "3" 'split-window-horizontally)
(define-key ctl-x-map "}" 'enlarge-window-horizontally)
(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