@c -*-texinfo-*-
@c This is part of the GNU Emacs Lisp Reference Manual.
-@c Copyright (C) 1990-1995, 1998-1999, 2001-2011
+@c Copyright (C) 1990-1995, 1998-1999, 2001-2012
@c Free Software Foundation, Inc.
@c See the file elisp.texi for copying conditions.
-@setfilename ../../info/windows
@node Windows, Frames, Buffers, Top
@chapter Windows
@section Basic Concepts of Emacs Windows
@cindex window
-A @dfn{window} is a area of the screen which is used to display a
+A @dfn{window} is a area of the screen that is used to display a
buffer (@pxref{Buffers}). In Emacs Lisp, windows are represented by a
special Lisp object type.
graphical desktop environments and window systems, such as the X
Window System. When Emacs is run on X, each of its graphical X
windows is an Emacs frame (containing one or more Emacs windows).
-When Emacs is run on a text-only terminal, the frame fills the entire
+When Emacs is run on a text terminal, the frame fills the entire
terminal screen.
@cindex tiled windows
@end defun
@cindex selected window
+@cindex window selected within a frame
In each frame, at any time, exactly one Emacs window is designated
as @dfn{selected within the frame}. For the selected frame, that
window is called the @dfn{selected window}---the one in which most
active. If @var{minibuffer} is neither @code{nil} nor @code{t}, the
minibuffer window is never included.
-The optional argument @var{window}, if non-@code{nil}, should be a
-live window on the specified frame; then @var{window} will be the
-first element in the returned list. If @var{window} is omitted or
-@code{nil}, the window selected within the frame is first element.
+The optional argument @var{window}, if non-@code{nil}, should be a live
+window on the specified frame; then @var{window} will be the first
+element in the returned list. If @var{window} is omitted or @code{nil},
+the window selected within the frame is the first element.
@end defun
@cindex window tree
The functions @code{window-next-sibling} and
@code{window-prev-sibling} should not be confused with the functions
-@code{next-window} and @code{previous-window} which respectively
-return the next and previous window in the cyclic ordering of windows
+@code{next-window} and @code{previous-window}, which return the next
+and previous window, respectively, in the cyclic ordering of windows
(@pxref{Cyclic Window Ordering}).
You can use the following functions to find the first live window on
line (@pxref{Mode Line Format}).
Emacs provides several functions for finding the height and width of
-a window. Except where noted, these heights and widths are reported
-as integer numbers of lines and columns respectively. On a graphical
+a window. Except where noted, Emacs reports window heights and widths
+as integer numbers of lines and columns, respectively. On a graphical
display, each ``line'' and ``column'' actually corresponds to the
height and width of a ``default'' character specified by the frame's
default font. Thus, if a window is displaying text with a different
@code{nil}, it defaults to the selected window.
@end defun
-@cindex window position
- The following functions can be used to determine the position of a
-window relative to the window area of its frame:
-
-@defun window-top-line &optional window
-This function returns the distance, in lines, between the top of
-@var{window} and the top of the frame's window area. For instance,
-the return value is 0 if there is no window above @var{window}. If
-@var{window} is omitted or @code{nil}, it defaults to the selected
-window.
-@end defun
-
-@defun window-left-column &optional window
-This function returns the distance, in columns, between the left edge
-of @var{window} and the left edge of the frame's window area. For
-instance, the return value is 0 if there is no window to the left of
-@var{window}. If @var{window} is omitted or @code{nil}, it defaults
-to the selected window.
-@end defun
-
@cindex window body height
@cindex body height of a window
@cindex window body width
@end defun
For compatibility with previous versions of Emacs,
-@code{window-height} is an alias for @code{window-body-height}, and
+@code{window-height} is an alias for @code{window-total-height}, and
@code{window-width} is an alias for @code{window-body-width}. These
aliases are considered obsolete and will be removed in the future.
function @code{window-resizable}. @xref{Resizing Windows}.
@end defun
- The following functions can be used to find a window's size and
-position in pixels. Though mostly useful on graphical displays, they
-can also be called on text-only terminals, where the screen area of
-each text character is taken to be ``one pixel''.
-
-@defun window-pixel-edges &optional window
-This function return a list of pixel coordinates for the edges of
-@var{window}. If @var{window} is omitted or @code{nil}, it defaults
-to the selected window.
-
-The return value has the form @code{(@var{left} @var{top} @var{right}
-@var{bottom})}. The list elements are, respectively, the X coordinate
-of the left window edge, the Y coordinate of the top edge, one more
-than the X coordinate of the right edge, and one more than the Y
-coordinate of the bottom edge. The origin coordinate @samp{(0,0)} is
-taken to be the top left corner of the frame's window area.
-
-These edge values include the space used by the window's scroll bar,
-margins, fringes, header line, and mode line, if any.
-@end defun
-
-@defun window-inside-pixel-edges &optional window
-This function is like @code{window-pixel-edges}, except that it
-returns the edge coordinates for the window's text area, rather than
-the edge coordinates for the window itself. @var{window} must specify
-a live window.
-@end defun
-
-@defun window-absolute-pixel-edges &optional window
-This function is like @code{window-pixel-edges}, except that it
-returns the edge coordinates relative to the top left corner of the
-display screen.
-@end defun
-
-@defun window-inside-absolute-pixel-edges &optional window
-This function is like @code{window-inside-pixel-edges}, except that it
-returns the edge coordinates relative to the top left corner of the
-display screen. @var{window} must specify a live window.
-@end defun
+ @xref{Coordinates and Windows}, for more functions that report the
+positions of various parts of a window relative to the frame, from
+which you can calculate its size. In particular, you can use the
+functions @code{window-pixel-edges} and
+@code{window-inside-pixel-edges} to find the size in pixels, for
+graphical displays.
@node Resizing Windows
@section Resizing Windows
The optional argument @var{ignore} has the same meaning as for the
function @code{window-resizable} above.
-The choice of which window edge this function alters depends on the
-splitting and nesting status of the involved windows; in some cases,
-it may alter both edges. @xref{Splitting Windows}. To resize by
-moving only the bottom or right edge of a window, use the function
+The choice of which window edges this function alters depends on the
+values of the option @code{window-combination-resize} and the
+combination limits of the involved windows; in some cases, it may alter
+both edges. @xref{Splitting Windows}. To resize by moving only the
+bottom or right edge of a window, use the function
@code{adjust-window-trailing-edge}, below.
@end defun
The optional argument @var{max-height}, if non-@code{nil}, specifies
the maximum total height that this function can give @var{window}.
-The optional argument @var{min-height}, if no-@code{nil}, specifies
+The optional argument @var{min-height}, if non-@code{nil}, specifies
the minimum total height that it can give, which overrides the
variable @code{window-min-height}.
@var{window} is an internal window, the new window inherits the
properties of the window selected within @var{window}'s frame.
-If the variable @code{ignore-window-parameters} is non-@code{nil}
-(@pxref{Window Parameters}), this function ignores window parameters.
-Otherwise, it consults the @code{split-window} parameter of
-@var{window}; if this is @code{t}, it splits the window disregarding
-any other window parameters. If the @code{split-window} parameter
-specifies a function, that function is called with the arguments
-@var{window}, @var{size}, and @var{side} to split @var{window}, in
-lieu of the usual action of @code{split-window}.
+The behavior of this function may be altered by the window parameters
+of @var{window}, so long as the variable
+@code{ignore-window-parameters} is @code{nil}. If the value of
+the @code{split-window} window parameter is @code{t}, this function
+ignores all other window parameters. Otherwise, if the value of the
+@code{split-window} window parameter is a function, that function is
+called with the arguments @var{window}, @var{size}, and @var{side}, in
+lieu of the usual action of @code{split-window}. Otherwise, this
+function obeys the @code{window-atom} or @code{window-side} window
+parameter, if any. @xref{Window Parameters}.
@end deffn
- As an example, we show a combination of @code{split-window} calls
-that yields the window configuration discussed in @ref{Windows and
-Frames}. This example demonstrates splitting a live window as well as
-splitting an internal window. We begin with a frame containing a
-single window (a live root window), which we denote by @var{W4}.
-Calling @code{(split-window W3)} yields this window configuration:
+ As an example, here is a sequence of @code{split-window} calls that
+yields the window configuration discussed in @ref{Windows and Frames}.
+This example demonstrates splitting a live window as well as splitting
+an internal window. We begin with a frame containing a single window
+(a live root window), which we denote by @var{W4}. Calling
+@code{(split-window W4)} yields this window configuration:
@smallexample
@group
window @var{W3}. A new internal window @var{W1} is created, becoming
the new root window.
- The following two options can be used to modify the operation of
-@code{split-window}.
-
-@defopt window-splits
+@defopt window-combination-resize
If this variable is @code{nil}, @code{split-window} can only split a
-window (denoted by @var{window}) if @var{window}'s screen area is
-large enough to accommodate both itself and the new window. This is
-the default.
-
-If this variable is non-@code{nil}, @code{split-window} tries to
-resize all windows that are part of the same combination as
-@var{window}, in order to accommodate the new window. In particular,
-this may allow @code{split-window} to succeed even if @var{window} is
-a fixed-size window or too small to ordinarily split.
-
-In any case, the value of this variable is assigned to the splits status
-of the new window and, provided old and new window form a new
-combination, of the old window as well. The splits status of a window
-can be retrieved by invoking the function @code{window-splits} and
-altered by the function @code{set-window-splits} described next.
-
-If @code{window-nest} (see below) is non-@code{nil}, the space for the
-new window is exclusively taken from the old window, but the splits
-status of the involved windows is nevertheless set as described here.
-@end defopt
-
-@defun window-splits &optional window
-This function returns the splits status of @var{window}. The argument
-@var{window} can be any window and defaults to the selected one.
-
-@cindex splits status
-The @dfn{splits status} of a window specifies how resizing and deleting
-that window may affect the size of other windows in the same window
-combination. More precisely, if @var{window}'s splits status is
-@code{nil} and @var{window} is resized, the corresponding space is
-preferably taken from (or given to) @var{window}'s right sibling. When
-@var{window} is deleted, its space is given to its left sibling. If
-@var{window}'s splits status is non-@code{nil}, resizing and deleting
-@var{window} may resize @emph{all} windows in @var{window}'s
+window (denoted by @var{window}) if @var{window}'s screen area is large
+enough to accommodate both itself and the new window.
+
+If this variable is @code{t}, @code{split-window} tries to resize all
+windows that are part of the same combination as @var{window}, in order
+to accommodate the new window. In particular, this may allow
+@code{split-window} to succeed even if @var{window} is a fixed-size
+window or too small to ordinarily split. Furthermore, subsequently
+resizing or deleting @var{window} may resize all other windows in its
combination.
-The splits status is initially set by @code{split-window}
-from the current value of the variable @code{window-splits} (see above)
-and can be reset by the function @code{set-window-splits} (see below).
-@end defun
+The default is @code{nil}. Other values are reserved for future use.
+The value of this variable is ignored when
+@code{window-combination-limit} is non-@code{nil} (see below).
+@end defopt
-@defun set-window-splits window &optional status
-This function sets the splits status (see above) of @var{window} to
-@var{status}. The argument @var{window} can be any window and defaults
-to the selected one. The return value is @var{status}.
-@end defun
+ To illustrate the effect of @code{window-combination-resize},
+consider the following window configuration:
-To illustrate the use of @code{window-splits} consider the following
-window configuration:
@smallexample
@group
______________________________________
@end group
@end smallexample
-Splitting window @code{W3} with @code{window-splits} @code{nil}
-produces a configuration where the size of @code{W2} remains unchanged:
+@noindent
+If @code{window-combination-resize} is @code{nil}, splitting window
+@code{W3} leaves the size of @code{W2} unchanged:
+
@smallexample
@group
______________________________________
@end group
@end smallexample
-Splitting @code{W3} with @code{window-splits} non-@code{nil} instead
-produces a configuration where all windows have approximately the same
+@noindent
+If @code{window-combination-resize} is @code{t}, splitting @code{W3}
+instead leaves all three live windows with approximately the same
height:
@smallexample
@end group
@end smallexample
-@defopt window-nest
-If this variable is @code{nil}, @code{split-window} creates a new parent
-window if and only if the old window has no parent window or shall be
-split orthogonally to the combination it is part of. If this variable
-is non-@code{nil}, @code{split-window} always creates a new parent
-window. If this variable is always non-@code{nil}, a frame's window
-tree is a binary tree so every window but the frame's root window has
-exactly one sibling.
-
-The value of this variable is also assigned to the nest status of the
-new parent window. The nest status of any window can be retrieved via
-the function @code{window-nest} and altered by the function
-@code{set-window-nest}, see below.
+@defopt window-combination-limit
+If the value of this variable is @code{t}, the @code{split-window}
+function always creates a new internal window. If the value is
+@code{nil}, the new live window is allowed to share the existing
+parent window, if one exists, provided the split occurs in the same
+direction as the existing window combination (otherwise, a new
+internal window is created anyway). The default is @code{nil}. Other
+values are reserved for future use.
+
+Thus, if the value of this variable is at all times @code{t}, then at
+all times every window tree is a binary tree (a tree where each window
+except the root window has exactly one sibling).
+
+Furthermore, @code{split-window} calls
+@code{set-window-combination-limit} on the newly-created internal
+window, recording the current value of this variable. This affects
+how the window tree is rearranged when the child windows are deleted
+(see below).
@end defopt
-@defun window-nest &optional window
-This function returns the nest status of @var{window}. The argument
-@var{window} can be any window and defaults to the selected one. Note,
-however, that the nest status is currently meaningful for internal
-windows only.
+@cindex window combination limit
+@defun set-window-combination-limit window limit
+This functions sets the @dfn{combination limit} of the window
+@var{window} to @var{limit}. This value can be retrieved via the
+function @code{window-combination-limit}. See below for its effects;
+note that it is only meaningful for internal windows. The
+@code{split-window} function automatically calls this function, passing
+the value of the variable @code{window-combination-limit} as
+@var{limit}.
+@end defun
-@cindex nest status
-The @dfn{nest status} of a window specifies whether that window may be
-removed and its child windows recombined with that window's siblings
-when such a sibling's child window is deleted. The nest status is
-initially assigned by @code{split-window} from the current value of the
-variable @code{window-nest} (see above) and can be reset by the function
-@code{set-window-nest} (see below).
+@defun window-combination-limit window
+This function returns the combination limit for @var{window}.
-If the return value is @code{nil}, child windows of @var{window} may be
-recombined with @var{window}'s siblings when a window gets deleted. A
-return value of @code{nil} means that child windows of @var{window} are
-never (re-)combined with @var{window}'s siblings in such a case.
+The combination limit is meaningful only for an internal window. If
+it is @code{nil}, then Emacs is allowed to automatically delete
+@var{window}, in response to a window deletion, in order to group the
+child windows of @var{window} with its sibling windows to form a new
+window combination. If the combination limit is @code{t}, the child
+windows of @var{window} are never automatically re-combined with its
+siblings.
@end defun
-@defun set-window-nest window &optional status
-This functions sets the nest status (see above) of @var{window} to
-@var{status}. The argument @var{window} can be any window and defaults
-to the selected one. Note that setting the nest status is meaningful
-for internal windows only. The return value is @var{status}.
-@end defun
+ To illustrate the effect of @code{window-combination-limit},
+consider the following configuration (throughout this example, we will
+assume that @code{window-combination-resize} is @code{nil}):
-To illustrate the use of @code{window-nest} consider the following
-configuration (throughout the following examples we shall assume that
-@code{window-splits} invariantly is @code{nil}).
@smallexample
@group
______________________________________
@end group
@end smallexample
-Splitting @code{W2} into two windows above each other with
-@code{window-nest} equal @code{nil} will get you a configuration like:
-@smallexample
-@group
- ______________________________________
- | ____________________________________ |
- || ||
- || ||
- ||_________________W2_________________||
- | ____________________________________ |
- || ||
- || ||
- ||_________________W4_________________||
- | ____________________________________ |
- || ||
- || ||
- ||_________________W3_________________||
- |__________________W1__________________|
-
-@end group
-@end smallexample
+@noindent
+If @code{window-combination-limit} is @code{nil}, splitting @code{W2}
+into two windows, one above the other, yields
-If you now enlarge window @code{W4}, Emacs steals the necessary space
-from window @code{W3} resulting in a configuration like:
@smallexample
@group
______________________________________
| ____________________________________ |
|| ||
|| ||
- || ||
||_________________W4_________________||
| ____________________________________ |
|| ||
+ || ||
||_________________W3_________________||
|__________________W1__________________|
@end group
@end smallexample
-Deleting window @code{W4}, will return its space to @code{W2} as
-follows:
-@smallexample
-@group
- ______________________________________
- | ____________________________________ |
- || ||
- || ||
- || ||
- || ||
- || ||
- || ||
- || ||
- ||_________________W2_________________||
- | ____________________________________ |
- || ||
- ||_________________W3_________________||
- |__________________W1__________________|
+@noindent
+The newly-created window, @code{W4}, shares the same internal window
+@code{W1}. If @code{W4} is resized, it is allowed to resize the other
+live window, @code{W3}.
-@end group
-@end smallexample
+ If @code{window-combination-limit} is @code{t}, splitting @code{W2}
+in the initial configuration would instead have produced this:
-Hence, with respect to the initial configuration, window @code{W2} has
-grown at the expense of window @code{W3}. If, however, in the initial
-configuration you had split @code{W2} with @code{window-nest} bound to
-@code{t}, a new internal window @code{W5} would have been created as
-depicted below.
@smallexample
@group
______________________________________
@end group
@end smallexample
-Enlarging @code{W4} would now have stolen the necessary space from
-@code{W2} instead of @code{W3} as
-@smallexample
-@group
- ______________________________________
- | ____________________________________ |
- || __________________________________ ||
- |||________________W2________________|||
- || __________________________________ ||
- ||| |||
- ||| |||
- |||________________W4________________|||
- ||_________________W5_________________||
- | ____________________________________ |
- || ||
- || ||
- ||_________________W3_________________||
- |__________________W1__________________|
-
-@end group
-@end smallexample
+@noindent
+A new internal window @code{W5} has been created; its children are
+@code{W2} and the new live window @code{W4}. Now, @code{W2} is the
+only sibling of @code{W4}, so resizing @code{W4} will resize
+@code{W2}, leaving @code{W3} unaffected.
-and the subsequent deletion of @code{W4} would have restored the initial
-configuration.
+ For interactive use, Emacs provides two commands which always split
+the selected window. These call @code{split-window} internally.
-For interactive use, Emacs provides two commands which always split the
-selected window.
+@deffn Command split-window-right &optional size
+This function splits the selected window into two side-by-side
+windows, putting the selected window on the left. If @var{size} is
+positive, the left window gets @var{size} columns; if @var{size} is
+negative, the right window gets @minus{}@var{size} columns.
+@end deffn
@deffn Command split-window-below &optional size
-This function splits the selected window into two windows, one above the
-other, leaving the upper of the two windows selected, with @var{size}
-lines. (If @var{size} is negative, then the lower of the two windows
-gets @minus{}@var{size} lines and the upper window gets the rest, but
-the upper window is still the one selected.) However, if
-@code{split-window-keep-point} (see below) is @code{nil}, then either
-window can be selected.
-
- In other respects, this function is similar to @code{split-window}.
-In particular, the upper window is the original one and the return value
-is the new, lower window.
+This function splits the selected window into two windows, one above
+the other, leaving the upper window selected. If @var{size} is
+positive, the upper window gets @var{size} lines; if @var{size} is
+negative, the lower window gets @minus{}@var{size} lines.
@end deffn
@defopt split-window-keep-point
-If this variable is non-@code{nil} (the default), then
+If the value of this variable is non-@code{nil} (the default),
@code{split-window-below} behaves as described above.
- If it is @code{nil}, then @code{split-window-below} adjusts point
-in each of the two windows to avoid scrolling. (This is useful on
-slow terminals.) It selects whichever window contains the screen line
-that point was previously on. Other functions are not affected by
-this variable.
+If it is @code{nil}, @code{split-window-below} adjusts point in each
+of the two windows to minimize redisplay. (This is useful on slow
+terminals.) It selects whichever window contains the screen line that
+point was previously on. Note that this only affects
+@code{split-window-below}, not the lower-level @code{split-window}
+function.
@end defopt
-@deffn Command split-window-right &optional size
-This function splits the selected window into two windows
-side-by-side, leaving the selected window on the left with @var{size}
-columns. If @var{size} is negative, the rightmost window gets
-@minus{}@var{size} columns, but the leftmost window still remains
-selected.
-@end deffn
-
-
@node Deleting Windows
@section Deleting Windows
@cindex deleting windows
-A window remains visible on its frame unless you @dfn{delete} it by
-calling certain functions that delete windows. A deleted window cannot
-appear on the screen, but continues to exist as a Lisp object until
-there are no references to it. There is no way to cancel the deletion
-of a window aside from restoring a saved window configuration
-(@pxref{Window Configurations}). Restoring a window configuration also
-deletes any windows that aren't part of that configuration. Erroneous
-information may result from using a deleted window as if it were live.
+ @dfn{Deleting} a window removes it from the frame's window tree. If
+the window is a live window, it disappears from the screen. If the
+window is an internal window, its child windows are deleted too.
-@deffn Command delete-window &optional window
-This function removes @var{window} from display and returns @code{nil}.
-The argument @var{window} can denote any window and defaults to the
-selected one. An error is signaled if @var{window} is the only window
-on its frame. Hence @var{window} must have at least one sibling window
-(@pxref{Windows and Frames}) in order to get deleted. If @var{window}
-is the selected window on its frame, this function selects the most
-recently selected live window on that frame instead.
-
-If the variable @code{ignore-window-parameters} (@pxref{Window
-Parameters}) is non-@code{nil}, this function ignores all parameters of
-@var{window}. Otherwise, if the @code{delete-window} parameter of
-@var{window} is @code{t}, it deletes the window disregarding other
-window parameters. If the @code{delete-window} parameter specifies a
-function, that function is called with @var{window} as its sole
-argument.
+ Even after a window is deleted, it continues to exist as a Lisp
+object, until there are no more references to it. Window deletion can
+be reversed, by restoring a saved window configuration (@pxref{Window
+Configurations}).
-If the splits status of @var{window} (@pxref{Splitting Windows}) is
-@code{nil}, the space @var{window} took up is given to its left sibling
-if such a window exists and to its right sibling otherwise. If the
-splits status of @var{window} is non-@code{nil}, its space is
-proportionally distributed among the remaining windows in the same
-combination.
+@deffn Command delete-window &optional window
+This function removes @var{window} from display and returns
+@code{nil}. If @var{window} is omitted or @code{nil}, it defaults to
+the selected window. If deleting the window would leave no more
+windows in the window tree (e.g. if it is the only live window in the
+frame), an error is signaled.
+
+By default, the space taken up by @var{window} is given to one of its
+adjacent sibling windows, if any. However, if the variable
+@code{window-combination-resize} is non-@code{nil}, the space is
+proportionally distributed among any remaining windows in the window
+combination. @xref{Splitting Windows}.
+
+The behavior of this function may be altered by the window parameters
+of @var{window}, so long as the variable
+@code{ignore-window-parameters} is @code{nil}. If the value of
+the @code{delete-window} window parameter is @code{t}, this function
+ignores all other window parameters. Otherwise, if the value of the
+@code{delete-window} window parameter is a function, that function is
+called with the argument @var{window}, in lieu of the usual action of
+@code{delete-window}. Otherwise, this function obeys the
+@code{window-atom} or @code{window-side} window parameter, if any.
+@xref{Window Parameters}.
@end deffn
@deffn Command delete-other-windows &optional window
-This function makes @var{window} fill its frame and returns @code{nil}.
-The argument @var{window} can denote an arbitrary window and defaults to
-the selected one. Upon exit, @var{window} will be the selected window
-on its frame.
-
-If the variable @code{ignore-window-parameters} (@pxref{Window
-Parameters}) is non-@code{nil}, this function ignores all parameters of
-@var{window}. Otherwise, if the @code{delete-other-windows} parameter
-of @var{window} equals @code{t}, it deletes all other windows
-disregarding any remaining window parameters. If the
-@code{delete-other-windows} parameter of @var{window} specifies a
-function, it calls that function with @var{window} as its sole argument.
+This function makes @var{window} fill its frame, by deleting other
+windows as necessary. If @var{window} is omitted or @code{nil}, it
+defaults to the selected window. The return value is @code{nil}.
+
+The behavior of this function may be altered by the window parameters
+of @var{window}, so long as the variable
+@code{ignore-window-parameters} is @code{nil}. If the value of
+the @code{delete-other-windows} window parameter is @code{t}, this
+function ignores all other window parameters. Otherwise, if the value
+of the @code{delete-other-windows} window parameter is a function,
+that function is called with the argument @var{window}, in lieu of the
+usual action of @code{delete-other-windows}. Otherwise, this function
+obeys the @code{window-atom} or @code{window-side} window parameter,
+if any. @xref{Window Parameters}.
@end deffn
@deffn Command delete-windows-on &optional buffer-or-name frame
-This function deletes all windows showing @var{buffer-or-name}. If
-there are no windows showing @var{buffer-or-name}, it does nothing.
-The optional argument @var{buffer-or-name} may be a buffer or the name
-of an existing buffer and defaults to the current buffer. Invoking
-this command on a minibuffer signals an error.
-
-The function @code{delete-windows-on} operates by calling
-@code{delete-window} for each window showing @var{buffer-or-name}. If a
-frame has several windows showing different buffers, then those showing
-@var{buffer-or-name} are removed, and the other windows expand to fill
-the space.
-
-If all windows in some frame are showing @var{buffer-or-name} (including
-the case where there is only one window), then that frame is deleted
-provided there are other frames left.
-
-The optional argument @var{frame} specifies which frames to operate on.
-This function does not use it in quite the same way as the other
-functions which scan all live windows (@pxref{Cyclic Window Ordering});
-specifically, the values @code{t} and @code{nil} have the opposite of
-their meanings in the other functions. Here are the full details:
+This function deletes all windows showing @var{buffer-or-name}, by
+calling @code{delete-window} on those windows. @var{buffer-or-name}
+should be a buffer, or the name of a buffer; if omitted or @code{nil},
+it defaults to the current buffer. If there are no windows showing
+the specified buffer, this function does nothing. If the specified
+buffer is a minibuffer, an error is signaled.
+
+If there is a dedicated window showing the buffer, and that window is
+the only one on its frame, this function also deletes that frame if it
+is not the only frame on the terminal.
+
+The optional argument @var{frame} specifies which frames to operate
+on:
@itemize @bullet
@item @code{nil}
@item A frame
means operate on that frame.
@end itemize
-@end deffn
+Note that this argument does not have the same meaning as in other
+functions which scan all live windows (@pxref{Cyclic Window
+Ordering}). Specifically, the meanings of @code{t} and @code{nil} here
+are the opposite of what they are in those other functions.
+@end deffn
@node Selecting Windows
@section Selecting Windows
@cindex selecting a window
@defun select-window window &optional norecord
-This function makes @var{window} the selected window, see @ref{Basic
-Windows}. Unless @var{window} already is the selected window, this also
-makes @var{window}'s buffer (@pxref{Buffers and Windows}) the current
-buffer. Moreover, the cursor for selected windows will be displayed in
-@var{window} after the next redisplay. This function returns
-@var{window}.
+This function makes @var{window} the selected window, as well as the
+window selected within its frame (@pxref{Basic Windows}).
+@var{window} must be a live window. Unless @var{window} already is the
+selected window, its buffer becomes the current buffer (@pxref{Buffers
+and Windows}). The return value is @var{window}.
-Normally, @var{window}'s selected buffer is moved to the front of the
-buffer list (@pxref{The Buffer List}) and @var{window} becomes the most
-recently selected window. But if the optional argument @var{norecord}
-is non-@code{nil}, the buffer list remains unchanged and @var{window}
-does not become the most recently selected one.
+By default, this function also moves @var{window}'s selected buffer to
+the front of the buffer list (@pxref{The Buffer List}), and makes
+@var{window} the most recently selected window. However, if the
+optional argument @var{norecord} is non-@code{nil}, these additional
+actions are omitted.
@end defun
@cindex most recently selected windows
-The sequence of calls to @code{select-window} with a non-@code{nil}
+ The sequence of calls to @code{select-window} with a non-@code{nil}
@var{norecord} argument determines an ordering of windows by their
selection time. The function @code{get-lru-window} can be used to
-retrieve the least recently selected live window in this ordering, see
-@ref{Cyclic Window Ordering}.
+retrieve the least recently selected live window (@pxref{Cyclic Window
+Ordering}).
@defmac save-selected-window forms@dots{}
This macro records the selected frame, as well as the selected window
This macro selects @var{window}, executes @var{forms} in sequence, then
restores the previously selected window and current buffer. The ordering
of recently selected windows and the buffer list remain unchanged unless
-you deliberately change them within @var{forms}, for example, by calling
+you deliberately change them within @var{forms}; for example, by calling
@code{select-window} with argument @var{norecord} @code{nil}.
-The order of recently selected windows and the buffer list are not
-changed by this macro.
+This macro does not change the order of recently selected windows or
+the buffer list.
@end defmac
-@cindex frame selected window
-@cindex window selected within frame
-Earlier (@pxref{Basic Windows}) we mentioned that at any time, exactly
-one window on any frame is selected within the frame. The significance
-of this designation is that selecting the frame also selects this
-window. Conversely, selecting a window for Emacs with
-@code{select-window} also makes that window selected within its frame.
-
-@defun frame-selected-window &optional frame
-This function returns the window on @var{frame} that is selected within
-@var{frame}. The optional argument @var{frame} must denote a live frame
-and defaults to the selected one.
+@defun frame-selected-window &optional frame
+This function returns the window on @var{frame} that is selected
+within that frame. @var{frame} should be a live frame; if omitted or
+@code{nil}, it defaults to the selected frame.
@end defun
@defun set-frame-selected-window frame window &optional norecord
-This function sets the selected window of frame @var{frame} to
-@var{window}. The argument @var{frame} must denote a live frame and
-defaults to the selected one. If @var{frame} is the selected frame,
-this also makes @var{window} the selected window. The argument
-@var{window} must denote a live window. This function returns
-@var{window}.
+This function makes @var{window} the window selected within the frame
+@var{frame}. @var{frame} should be a live frame; if omitted or
+@code{nil}, it defaults to the selected frame. @var{window} should be
+a live window; if omitted or @code{nil}, it defaults to the selected
+window.
-Optional argument @var{norecord} non-@code{nil} means to neither change
-the list of most recently selected windows (@pxref{Selecting Windows})
-nor the buffer list (@pxref{The Buffer List}).
-@end defun
+If @var{frame} is the selected frame, this makes @var{window} the
+selected window.
+If the optional argument @var{norecord} is non-@code{nil}, this
+function does not alter the list of most recently selected windows,
+nor the buffer list.
+@end defun
@node Cyclic Window Ordering
@section Cyclic Ordering of Windows
@cindex ordering of windows, cyclic
@cindex window ordering, cyclic
-When you use the command @kbd{C-x o} (@code{other-window}) to select
+ When you use the command @kbd{C-x o} (@code{other-window}) to select
some other window, it moves through live windows in a specific order.
-For any given configuration of windows, this order never varies. It is
-called the @dfn{cyclic ordering of windows}.
-
- For a particular frame, this ordering is determined by the window
-tree of that frame, see @ref{Windows and Frames}. More precisely, the
-ordering is obtained by a depth-first traversal of the frame's window
-tree supplemented, if requested, by the frame's minibuffer window.
+For any given configuration of windows, this order never varies. It
+is called the @dfn{cyclic ordering of windows}.
- If there's just one live frame, the cyclic ordering is the ordering
-for that frame. Otherwise, the cyclic ordering is obtained by appending
-the orderings for individual frames in order of the list of all live
-frames, @ref{Finding All Frames}. In any case, the ordering is made
-``cyclic'' by having the last window precede the first window in the
-ordering.
+ The ordering is determined by a depth-first traversal of the frame's
+window tree, retrieving the live windows which are the leaf nodes of
+the tree (@pxref{Windows and Frames}). If the minibuffer is active,
+the minibuffer window is included too. The ordering is cyclic, so the
+last window in the sequence is followed by the first one.
@defun next-window &optional window minibuf all-frames
@cindex minibuffer window, and @code{next-window}
-This function returns the window following @var{window} in the cyclic
-ordering of windows. The argument @var{window} must specify a live
-window and defaults to the selected one.
+This function returns a live window, the one following @var{window} in
+the cyclic ordering of windows. @var{window} should be a live window;
+if omitted or @code{nil}, it defaults to the selected window.
The optional argument @var{minibuf} specifies whether minibuffer windows
-shall be included in the cyclic ordering. Normally, when @var{minibuf}
+should be included in the cyclic ordering. Normally, when @var{minibuf}
is @code{nil}, a minibuffer window is included only if it is currently
``active''; this matches the behavior of @kbd{C-x o}. (Note that a
minibuffer window is active as long as its minibuffer is in use; see
@code{nil}, minibuffer windows are not included even if they are active.
The optional argument @var{all-frames} specifies which frames to
-consider. Here are the possible values and their meanings:
+consider:
@itemize @bullet
@item @code{nil}
-means consider all windows on @var{window}'s frame, plus the minibuffer
-window used by that frame even if it lies in some other frame. If the
-minibuffer counts (as determined by @var{minibuf}), then all windows on
-all frames that share that minibuffer count too.
+means to consider windows on @var{window}'s frame. If the minibuffer
+window is considered (as specified by the @var{minibuf} argument),
+then frames that share the minibuffer window are considered too.
@item @code{t}
-means consider all windows on all existing frames.
+means to consider windows on all existing frames.
@item @code{visible}
-means consider all windows on all visible frames. (To get useful
-results, ensure that @var{window} is on a visible frame.)
+means to consider windows on all visible frames.
@item 0
-means consider all windows on all visible or iconified frames.
+means to consider windows on all visible or iconified frames.
@item A frame
-means consider all windows on that frame.
+means to consider windows on that specific frame.
@item Anything else
-means consider the windows on @var{window}'s frame, and no others.
+means to consider windows on @var{window}'s frame, and no others.
@end itemize
-This example assumes there are two windows, both displaying the
-buffer @samp{windows.texi}:
-
-@example
-@group
-(selected-window)
- @result{} #<window 56 on windows.texi>
-@end group
-@group
-(next-window (selected-window))
- @result{} #<window 52 on windows.texi>
-@end group
-@group
-(next-window (next-window (selected-window)))
- @result{} #<window 56 on windows.texi>
-@end group
-@end example
+If more than one frame is considered, the cyclic ordering is obtained
+by appending the orderings for those frames, in the same order as the
+list of all live frames (@pxref{Finding All Frames}).
@end defun
@defun previous-window &optional window minibuf all-frames
-This function returns the window preceding @var{window} in the cyclic
-ordering of windows. The other arguments specify which windows to
-consider as in @code{next-window}.
+This function returns a live window, the one preceding @var{window} in
+the cyclic ordering of windows. The other arguments are handled like
+in @code{next-window}.
@end defun
@deffn Command other-window count &optional all-frames
-This function selects another window in the cyclic ordering of windows.
-@var{count} specifies the number of windows to skip in the ordering,
-starting with the selected window, before making the selection. If
-@var{count} is a positive number, it skips @var{count} windows forwards.
-@var{count} negative means skip @minus{}@var{count} windows backwards.
-If @var{count} is zero, it does not skip any window, thus re-selecting
-the selected window. In an interactive call, @var{count} is the numeric
-prefix argument.
+This function selects a live window, one @var{count} places from the
+selected window in the cyclic ordering of windows. If @var{count} is
+a positive number, it skips @var{count} windows forwards; if
+@var{count} is negative, it skips @minus{}@var{count} windows
+backwards; if @var{count} is zero, that simply re-selects the selected
+window. When called interactively, @var{count} is the numeric prefix
+argument.
The optional argument @var{all-frames} has the same meaning as in
-@code{next-window}, but the @var{minibuf} argument of @code{next-window}
-is always effectively @code{nil}. This function returns @code{nil}.
+@code{next-window}, like a @code{nil} @var{minibuf} argument to
+@code{next-window}.
This function does not select a window that has a non-@code{nil}
@code{no-other-window} window parameter (@pxref{Window Parameters}).
@end deffn
-The following function returns a copy of the list of windows in the
-cyclic ordering.
-
-@defun window-list-1 &optional window &optional minibuf &optional all_frames
-This function returns a list of live windows. The optional arguments
-@var{minibuf} and @var{all-frames} specify the set of windows to include
-in the list. See the description of @code{next-window} for details.
-
-The optional argument @var{window} specifies the first window to list
-and defaults to the selected window. If @var{window} is not on the list
-of windows returned, some other window will be listed first but no error
-is signaled.
-@end defun
-
-The functions described below use @code{window-list-1} for generating a
-copy of the list of all relevant windows. Hence, any change of the
-window configuration that occurs while one of these functions is
-executed is @emph{not} reflected in the list of windows investigated.
-
-@defun walk-windows proc &optional minibuf all-frames
-This function cycles through live windows. It calls the function
-@var{proc} once for each window, with the window as its sole argument.
+@defun walk-windows fun &optional minibuf all-frames
+This function calls the function @var{fun} once for each live window,
+with the window as the argument.
-The optional arguments @var{minibuf} and @var{all-frames} specify the
-set of windows to include in the walk, see @code{next-window} above. If
-@var{all-frames} specifies a frame, the first window walked is the first
-window on that frame as returned by @code{frame-first-window} and not
-necessarily the selected window.
+It follows the cyclic ordering of windows. The optional arguments
+@var{minibuf} and @var{all-frames} specify the set of windows
+included; these have the same arguments as in @code{next-window}. If
+@var{all-frames} specifies a frame, the first window walked is the
+first window on that frame (the one returned by
+@code{frame-first-window}), not necessarily the selected window.
-If @var{proc} changes the window configuration by splitting or deleting
-windows, that change is not reflected in the set of windows walked.
-That set is determined entirely by the set of live windows at the time
-this function was invoked.
+If @var{fun} changes the window configuration by splitting or deleting
+windows, that does not alter the set of windows walked, which is
+determined prior to calling @var{fun} for the first time.
@end defun
-The following function allows to determine whether a specific window is
-the only live window.
-
@defun one-window-p &optional no-mini all-frames
-This function returns non-@code{nil} if the selected window is the only
-window.
+This function returns @code{t} if the selected window is the only live
+window, and @code{nil} otherwise.
-The optional argument @var{no-mini}, if non-@code{nil}, means don't
-count the minibuffer even if it is active; otherwise, the minibuffer
-window is counted when it is active. The optional argument
-@var{all-frames} has the same meaning as for @code{next-window}, see
-above.
+If the minibuffer window is active, it is normally considered (so that
+this function returns @code{nil}). However, if the optional argument
+@var{no-mini} is non-@code{nil}, the minibuffer window is ignored even
+if active. The optional argument @var{all-frames} has the same
+meaning as for @code{next-window}.
@end defun
@cindex finding windows
- The following functions choose (but do not select) one of the windows
-on the screen, offering various criteria for the choice.
+ The following functions return a window which satisfies some
+criterion, without selecting it:
@cindex least recently used window
@defun get-lru-window &optional all-frames dedicated
-This function returns the window least recently ``used'' (that is,
-selected). If any full-width windows are present, it only considers
-these. The optional argument @var{all-frames} has the same meaning as
-in @code{next-window}.
+This function returns a live window which is heuristically the ``least
+recently used'' window. The optional argument @var{all-frames} has
+the same meaning as in @code{next-window}.
-The selected window is returned if it is the only candidate. A
-minibuffer window is never a candidate. A dedicated window
-(@pxref{Dedicated Windows}) is never a candidate unless the optional
-argument @var{dedicated} is non-@code{nil}.
+If any full-width windows are present, only those windows are
+considered. The selected window is never returned, unless it is the
+only candidate. A minibuffer window is never a candidate. A
+dedicated window (@pxref{Dedicated Windows}) is never a candidate
+unless the optional argument @var{dedicated} is non-@code{nil}.
@end defun
@cindex largest window
prefers the one that comes first in the cyclic ordering of windows,
starting from the selected window.
-The optional argument @var{all-frames} specifies which set of windows to
-consider as with @code{next-window}, see above.
+The optional argument @var{all-frames} specifies the windows to
+search, and has the same meaning as in @code{next-window}.
@end defun
@cindex window that satisfies a predicate
@cindex conditional selection of windows
@defun get-window-with-predicate predicate &optional minibuf all-frames default
-This function returns a window satisfying @var{predicate}. It cycles
-through all visible windows calling @var{predicate} on each one of them
-with that window as its argument. The function returns the first window
-for which @var{predicate} returns a non-@code{nil} value; if that never
-happens, it returns @var{default} (which defaults to @code{nil}).
+This function calls the function @var{predicate} for each of the
+windows in the cyclic order of windows in turn, passing it the window
+as an argument. If the predicate returns non-@code{nil} for any
+window, this function stops and returns that window. If no such
+window is found, the return value is @var{default} (which defaults to
+@code{nil}).
The optional arguments @var{minibuf} and @var{all-frames} specify the
-set of windows to investigate. See the description of
-@code{next-window} for details.
+windows to search, and have the same meanings as in
+@code{next-window}.
@end defun
@node Buffers and Windows
@cindex windows, controlling precisely
@cindex buffers, controlled in windows
-To find out which buffer is displayed in a given window the following
-function is used.
+ This section describes low-level functions for examining and setting
+the contents of windows. @xref{Switching Buffers}, for higher-level
+functions for displaying a specific buffer in a window.
@defun window-buffer &optional window
-This function returns the buffer that @var{window} is displaying. The
-argument @var{window} can be any window and defaults to the selected
-one. If @var{window} is an internal window, this function returns
+This function returns the buffer that @var{window} is displaying. If
+@var{window} is omitted or @code{nil} it defaults to the selected
+window. If @var{window} is an internal window, this function returns
@code{nil}.
@end defun
-The basic, low-level function to associate a window with a buffer is
-@code{set-window-buffer}. Higher-level functions like
-@code{switch-to-buffer} and @code{display-buffer} try to obey a number
-of user customizations regulating which windows are supposed to
-display which buffers. @xref{Switching Buffers}. When writing an
-application, you should avoid using @code{set-window-buffer} unless
-you are sure you need it.
-
@defun set-window-buffer window buffer-or-name &optional keep-margins
-This function makes @var{window} display @var{buffer-or-name} and
-returns @code{nil}. The argument @var{window} has to denote a live
-window and defaults to the selected one. The argument
-@var{buffer-or-name} must specify a buffer or the name of an existing
-buffer. An error is signaled when @var{window} is @dfn{strongly}
-dedicated to its buffer (@pxref{Dedicated Windows}) and does not already
-display @var{buffer-or-name}.
-
-Normally, displaying @var{buffer-or-name} in @var{window} resets the
-window's position, display margins, fringe widths, and scroll bar
-settings based on the local variables of the specified buffer. However,
-if the optional argument @var{keep-margins} is non-@code{nil}, display
-margins and fringe widths of @var{window} remain unchanged.
-@xref{Fringes}.
-
-This function is the fundamental primitive for changing which buffer is
-displayed in a window, and all ways of doing that call this function.
-Neither the selected window nor the current buffer are changed by this
-function.
+This function makes @var{window} display @var{buffer-or-name}.
+@var{window} should be a live window; if @code{nil}, it defaults to
+the selected window. @var{buffer-or-name} should be a buffer, or the
+name of an existing buffer. This function does not change which
+window is selected, nor does it directly change which buffer is
+current (@pxref{Current Buffer}). Its return value is @code{nil}.
+
+If @var{window} is @dfn{strongly dedicated} to a buffer and
+@var{buffer-or-name} does not specify that buffer, this function
+signals an error. @xref{Dedicated Windows}.
-This function runs @code{window-scroll-functions} before running
-@code{window-configuration-change-hook}, see @ref{Window Hooks}.
+By default, this function resets @var{window}'s position, display
+margins, fringe widths, and scroll bar settings, based on the local
+variables in the specified buffer. However, if the optional argument
+@var{keep-margins} is non-@code{nil}, it leaves the display margins
+and fringe widths unchanged.
+
+When writing an application, you should normally use the higher-level
+functions described in @ref{Switching Buffers}, instead of calling
+@code{set-window-buffer} directly.
+
+This function runs @code{window-scroll-functions}, followed by
+@code{window-configuration-change-hook}. @xref{Window Hooks}.
@end defun
@defvar buffer-display-count
@end defvar
@defvar buffer-display-time
-This variable records the time at which a buffer was last made visible
-in a window. It is always local in each buffer; each time
-@code{set-window-buffer} is called, it sets this variable to
-@code{(current-time)} in the specified buffer (@pxref{Time of Day}).
-When a buffer is first created, @code{buffer-display-time} starts out
-with the value @code{nil}.
+This buffer-local variable records the time at which a buffer was last
+displayed in a window. The value is @code{nil} if the buffer has
+never been displayed. It is updated each time
+@code{set-window-buffer} is called for the buffer, with the value
+returned by @code{current-time} (@pxref{Time of Day}).
@end defvar
@defun get-buffer-window &optional buffer-or-name all-frames
-This function returns a window displaying @var{buffer-or-name}, or
-@code{nil} if there is none. If there are several such windows, then
-the function returns the first one in the cyclic ordering of windows,
-starting from the selected window, @xref{Cyclic Window Ordering}.
+This function returns the first window displaying @var{buffer-or-name}
+in the cyclic ordering of windows, starting from the selected window
+(@pxref{Cyclic Window Ordering}). If no such window exists, the
+return value is @code{nil}.
-The argument @var{buffer-or-name} may be a buffer or a buffer name and
-defaults to the current buffer. The optional argument @var{all-frames}
-specifies which windows to consider:
+@var{buffer-or-name} should be a buffer or the name of a buffer; if
+omitted or @code{nil}, it defaults to the current buffer. The
+optional argument @var{all-frames} specifies which windows to
+consider:
@itemize @bullet
@item
-@code{nil} means consider windows on the selected frame.
-@item
@code{t} means consider windows on all existing frames.
@item
@code{visible} means consider windows on all visible frames.
0 means consider windows on all visible or iconified frames.
@item
A frame means consider windows on that frame only.
+@item
+Any other value means consider windows on the selected frame.
@end itemize
-Observe that the behavior of @code{get-buffer-window} may differ from
-that of @code{next-window} (@pxref{Cyclic Window Ordering}) when
-@var{all-frames} equals @code{nil} or any value not listed here.
-Perhaps we will change @code{get-buffer-window} in the future to make it
-compatible with the other functions.
+Note that these meanings differ slightly from those of the
+@var{all-frames} argument to @code{next-window} (@pxref{Cyclic Window
+Ordering}). This function may be changed in a future version of Emacs
+to eliminate this discrepancy.
@end defun
@defun get-buffer-window-list &optional buffer-or-name minibuf all-frames
This function returns a list of all windows currently displaying
-@var{buffer-or-name}. The argument @var{buffer-or-name} may be a buffer
-or the name of an existing buffer and defaults to the current buffer.
+@var{buffer-or-name}. @var{buffer-or-name} should be a buffer or the
+name of an existing buffer. If omitted or @code{nil}, it defaults to
+the current buffer.
-The two remaining arguments work like the same-named arguments of
-@code{next-window} (@pxref{Cyclic Window Ordering}); they are @emph{not}
-like the optional arguments of @code{get-buffer-window}.
+The arguments @var{minibuf} and @var{all-frames} have the same
+meanings as in the function @code{next-window} (@pxref{Cyclic Window
+Ordering}). Note that the @var{all-frames} argument does @emph{not}
+behave exactly like in @code{get-buffer-window}.
@end defun
@deffn Command replace-buffer-in-windows &optional buffer-or-name
This command replaces @var{buffer-or-name} with some other buffer, in
-all windows displaying it. For each such window, it choose another
-buffer using @code{switch-to-prev-buffer} (@pxref{Window History}).
-
-The argument @var{buffer-or-name} may be a buffer, or the name of an
-existing buffer; it defaults to the current buffer.
-
-If a window displaying @var{buffer-or-name} is dedicated
-(@pxref{Dedicated Windows}) and is not the only window on its frame,
-that window is deleted. If that window is the only window on its frame
-and there are other frames on the frame's terminal, that frame is dealt
-with by the function specified by @code{frame-auto-hide-function}
-(@pxref{Quitting Windows}). Otherwise, the buffer provided by the
-function @code{switch-to-prev-buffer} (@pxref{Window History}) is
-displayed in the window instead.
+all windows displaying it. @var{buffer-or-name} should be a buffer,
+or the name of an existing buffer; if omitted or @code{nil}, it
+defaults to the current buffer.
+
+The replacement buffer in each window is chosen via
+@code{switch-to-prev-buffer} (@pxref{Window History}). Any dedicated
+window displaying @var{buffer-or-name} is deleted (@pxref{Dedicated
+Windows}), unless it is the only window on its frame---if it is the
+only window, and that frame is not the only frame on its terminal, the
+frame is ``dismissed'' by calling the function specified by
+@code{frame-auto-hide-function} (@pxref{Quitting Windows}). If the
+dedicated window is the only window on the only frame on its terminal,
+the buffer is replaced anyway.
@end deffn
-
@node Switching Buffers
@section Switching to a Buffer in a Window
@cindex switching to a buffer
meanings as in @code{switch-to-buffer}.
@end deffn
-The above commands use @code{pop-to-buffer}, which is the function
-used by Lisp programs to flexibly display a buffer in some window and
-select that window for editing:
+The above commands use the function @code{pop-to-buffer}, which
+flexibly displays a buffer in some window and selects that window for
+editing. In turn, @code{pop-to-buffer} uses @code{display-buffer} for
+displaying the buffer. Hence, all the variables affecting
+@code{display-buffer} will affect it as well. @xref{Choosing Window},
+for the documentation of @code{display-buffer}.
@defun pop-to-buffer buffer-or-name &optional action norecord
This function makes @var{buffer-or-name} the current buffer and
possible (@pxref{Input Focus}). The return value is the buffer that
was switched to.
-This function uses @code{display-buffer} to display the buffer, so all
-the variables affecting @code{display-buffer} will affect it as well.
-@xref{Choosing Window}.
-
If @var{buffer-or-name} is @code{nil}, it defaults to the buffer
returned by @code{other-buffer} (@pxref{The Buffer List}). If
@var{buffer-or-name} is a string that is not the name of any existing
Buffers}).
@cindex display action
-@cindex action function, for display-buffer
-@cindex action alist, for display-buffer
+@cindex action function, for @code{display-buffer}
+@cindex action alist, for @code{display-buffer}
This command performs several complex steps to find a window to
display in. These steps are described by means of @dfn{display
actions}, which have the form @code{(@var{function} . @var{alist})}.
@item
The user option @code{display-buffer-alist}.
+@item
+A special action for handling @code{special-display-buffer-names} and
+@code{special-display-regexps}, if either of those variables is
+non-@code{nil}. @xref{Choosing Window Options}.
+
@item
The @var{action} argument.
that is already displaying it.
If @var{alist} has a non-@code{nil} @code{inhibit-same-window} entry,
-the selected window is not eligible for reuse.
-
-If @var{alist} contains a @code{reusable-frames} entry, its value
-determines which frames to search for a reusable window:
+the selected window is not eligible for reuse. If @var{alist}
+contains a @code{reusable-frames} entry, its value determines which
+frames to search for a reusable window:
@itemize @bullet
@item
variable @code{display-buffer-reuse-frames} or the variable
@code{pop-up-frames} is non-@code{nil}, it searches all frames on the
current terminal. @xref{Choosing Window Options}.
+
+If this function chooses a window on another frame, it makes that
+frame visible and raises it if necessary.
@end defun
@defun display-buffer-pop-up-frame buffer alist
This function creates a new frame, and displays the buffer in that
-frame's window.
+frame's window. It actually performs the frame creation by calling
+the function specified in @code{pop-up-frame-function}
+(@pxref{Choosing Window Options}).
@end defun
@defun display-buffer-pop-up-window buffer alist
This function tries to display @var{buffer} by splitting the largest
-or least recently-used window. It uses @code{split-window-sensibly}
-as a subroutine (@pxref{Choosing Window Options}).
+or least recently-used window (typically one on the selected frame).
+It actually performs the split by calling the function specified in
+@code{split-window-preferred-function} (@pxref{Choosing Window
+Options}).
+
+It can fail if no window splitting can be performed for some reason
+(e.g. if there is just one frame and it has an @code{unsplittable}
+frame parameter; @pxref{Buffer Parameters}).
@end defun
@defun display-buffer-use-some-window buffer alist
options.
@defopt display-buffer-reuse-frames
-If this variable is non-@code{nil}, @code{display-buffer} searches
-visible and iconified frames for a window displaying
-@var{buffer-or-name}. If there is such a window, @code{display-buffer}
-makes that window's frame visible and raises it if necessary, and
-returns the window. If there is no such window or
-@code{display-buffer-reuse-frames} is @code{nil}, the behavior of
-@code{display-buffer} is determined by the variables described next.
+If the value of this variable is non-@code{nil}, @code{display-buffer}
+may search all frames on the current terminal when looking for a
+window already displaying the specified buffer. The default is
+@code{nil}. This variable is consulted by the action function
+@code{display-buffer-reuse-window} (@pxref{Display Action Functions}).
@end defopt
@defopt pop-up-windows
-This variable specifies whether @code{display-buffer} is allowed to
-split (@pxref{Splitting Windows}) an existing window. If this variable
-is non-@code{nil}, @code{display-buffer} tries to split the largest or
-least recently used window on the selected frame. (If the selected
-frame is a minibuffer-only frame, @code{display-buffer} tries to split a
-window on another frame instead.) If this variable is @code{nil} or the
-variable @code{pop-up-frames} (see below) is non-@code{nil},
-@code{display-buffer} does not split any window.
+If the value of this variable is non-@code{nil}, @code{display-buffer}
+is allowed to split an existing window to make a new window for
+displaying in. This is the default.
+
+This variable is provided mainly for backward compatibility. It is
+obeyed by @code{display-buffer} via a special mechanism in
+@code{display-buffer-fallback-action}, which only calls the action
+function @code{display-buffer-pop-up-window} (@pxref{Display Action
+Functions}) when the value is @code{nil}. It is not consulted by
+@code{display-buffer-pop-up-window} itself, which the user may specify
+directly in @code{display-buffer-alist} etc.
@end defopt
@defopt split-window-preferred-function
-This variable must specify a function with one argument, which is a
-window. The @code{display-buffer} routines will call this function with
-one or more candidate windows when they look for a window to split. The
-function is expected to split that window and return the new window. If
-the function returns @code{nil}, this means that the argument window
-cannot (or shall not) be split.
-
-The default value of @code{split-window-preferred-function} is the
-function @code{split-window-sensibly} described below. If you
-customize this option, bear in mind that the @code{display-buffer}
-routines may call your function up to two times when trying to split a
-window. The argument of the first call is the largest window on the
-chosen frame (as returned by @code{get-largest-window}). If that call
-fails to return a live window, your function is called a second time
-with the least recently used window on that frame (as returned by
-@code{get-lru-window}).
-
-The function specified by this option may try to split any other window
-instead of the argument window. Note that the window selected at the
-time @code{display-buffer} was invoked is still selected when your
-function is called. Hence, you can split the selected window (instead
-of the largest or least recently used one) by simply ignoring the window
-argument in the body of your function. You can even choose to not split
-any window as long as the return value of your function specifies a live
-window or @code{nil}, but you are not encouraged to do so
-unconditionally. If you want @code{display-buffer} to never split any
-windows, set @code{pop-up-windows} to @code{nil}.
+This variable specifies a function for splitting a window, in order to
+make a new window for displaying a buffer. It is used by the
+@code{display-buffer-pop-up-window} action function to actually split
+the window (@pxref{Display Action Functions}).
+
+The default value is @code{split-window-sensibly}, which is documented
+below. The value must be a function that takes one argument, a
+window, and return either a new window (which is used to display the
+desired buffer) or @code{nil} (which means the splitting failed).
@end defopt
@defun split-window-sensibly window
-This function takes a window as argument and tries to split that window
-in a suitable way. The two variables described next are useful for
-tuning the behavior of this function.
+This function tries to split @var{window}, and return the newly
+created window. If @var{window} cannot be split, it returns
+@code{nil}.
+
+This function obeys the usual rules that determine when a window may
+be split (@pxref{Splitting Windows}). It first tries to split by
+placing the new window below, subject to the restriction imposed by
+@code{split-height-threshold} (see below), in addition to any other
+restrictions. If that fails, it tries to split by placing the new
+window to the right, subject to @code{split-width-threshold} (see
+below). If that fails, and the window is the only window on its
+frame, this function again tries to split and place the new window
+below, disregarding @code{split-height-threshold}. If this fails as
+well, this function gives up and returns @code{nil}.
@end defun
@defopt split-height-threshold
-This variable specifies whether @code{split-window-sensibly} may split
-windows vertically. If it is an integer, @code{split-window-sensibly}
-tries to vertically split a window only if it has at least this many
-lines. If the window has less lines, splitting fails, or the value of
-this variable is @code{nil}, @code{split-window-sensibly} will try to
-split the window horizontally, subject to restrictions of
-@code{split-width-threshold} (see below). If splitting horizontally
-fails too and the window is the only window on its frame,
-@code{split-window-sensibly} will try to split the window vertically
-disregarding the value of @code{split-height-threshold}. If this fails
-as well, @code{split-window-sensibly} returns @code{nil}.
-
-@code{split-window-sensibly} does not split vertically a window whose
-height is fixed (@pxref{Resizing Windows}). Also, it vertically splits
-a window only if the space taken up by that window can accommodate two
-windows one above the other that are both at least
-@code{window-min-height} lines tall. Moreover, if the window that shall
-be split has a mode line, @code{split-window-sensibly} does not split
-the window unless the new window can accommodate a mode line too.
+This variable, used by @code{split-window-sensibly}, specifies whether
+to split the window placing the new window below. If it is an
+integer, that means to split only if the original window has at least
+that many lines. If it is @code{nil}, that means not to split this
+way.
@end defopt
@defopt split-width-threshold
-This variable specifies whether @code{split-window-sensibly} may split
-windows horizontally. If it is an integer, @code{split-window-sensibly}
-tries to horizontally split a window only if it has at least this many
-columns. If it is @code{nil}, @code{split-window-sensibly} will not
-split the window horizontally. (It still might split the window
-vertically, though, see above.)
-
-@code{split-window-sensibly} does not split horizontally a window if
-that window's width is fixed (@pxref{Resizing Windows}). Also, it
-horizontally splits a window only if the space that window takes up can
-accommodate two windows side by side that are both at least
-@code{window-min-width} columns wide.
-@end defopt
-
-@defopt even-window-heights
-This variable specifies whether @code{display-buffer} should even out
-window heights if the buffer gets displayed in an existing window, above
-or beneath another window. If @code{even-window-heights} is
-non-@code{nil}, the default, window heights will be evened out. If
-either of the involved window has fixed height (@pxref{Resizing
-Windows}) or @code{even-window-heights} is @code{nil}, the original
-window heights will be left alone.
+This variable, used by @code{split-window-sensibly}, specifies whether
+to split the window placing the new window to the right. If the value
+is an integer, that means to split only if the original window has at
+least that many columns. If the value is @code{nil}, that means not
+to split this way.
@end defopt
-@c Emacs 19 feature
@defopt pop-up-frames
-This variable specifies whether @code{display-buffer} should make new
-frames. If it is non-@code{nil}, @code{display-buffer} looks for a
-window already displaying @var{buffer-or-name} on any visible or
-iconified frame. If it finds such a window, it makes that window's
-frame visible and raises it if necessary, and returns the window.
-Otherwise it makes a new frame, unless the variable's value is
-@code{graphic-only} and the selected frame is not on a graphic display.
-@xref{Frames}, for more information.
-
-Note that the value of @code{pop-up-windows} does not matter if
-@code{pop-up-frames} is non-@code{nil}. If @code{pop-up-frames} is
-@code{nil}, then @code{display-buffer} either splits a window or reuses
-one.
+If the value of this variable is non-@code{nil}, that means
+@code{display-buffer} may display buffers by making new frames. The
+default is @code{nil}.
+
+A non-@code{nil} value also means that when @code{display-buffer} is
+looking for a window already displaying @var{buffer-or-name}, it can
+search any visible or iconified frame, not just the selected frame.
+
+This variable is provided mainly for backward compatibility. It is
+obeyed by @code{display-buffer} via a special mechanism in
+@code{display-buffer-fallback-action}, which calls the action function
+@code{display-buffer-pop-up-frame} (@pxref{Display Action Functions})
+if the value is non-@code{nil}. (This is done before attempting to
+split a window.) This variable is not consulted by
+@code{display-buffer-pop-up-frame} itself, which the user may specify
+directly in @code{display-buffer-alist} etc.
@end defopt
-@c Emacs 19 feature
@defopt pop-up-frame-function
-This variable specifies how to make a new frame if @code{pop-up-frames}
-is non-@code{nil}.
-
-The value of this variable must be a function of no arguments. When
-@code{display-buffer} makes a new frame, it does so by calling that
-function, which should return a frame. The default value of this
-variable is a function that creates a frame using the parameters
-specified by @code{pop-up-frame-alist} described next.
+This variable specifies a function for creating a new frame, in order
+to make a new window for displaying a buffer. It is used by the
+@code{display-buffer-pop-up-frame} action function (@pxref{Display
+Action Functions}).
+
+The value should be a function that takes no arguments and returns a
+frame, or @code{nil} if no frame could be created. The default value
+is a function that creates a frame using the parameters specified by
+@code{pop-up-frame-alist} (see below).
@end defopt
@defopt pop-up-frame-alist
-This variable holds an alist specifying frame parameters used by the
-default value of @code{pop-up-frame-function} for making new frames.
-@xref{Frame Parameters}, for more information about frame parameters.
+This variable holds an alist of frame parameters (@pxref{Frame
+Parameters}), which is used by the default function in
+@code{pop-up-frame-function} to make a new frame. The default is
+@code{nil}.
@end defopt
@defopt special-display-buffer-names
If @var{args} is an alist, it specifies frame parameters for the new
frame. If @var{args} is a list whose @sc{car} is a symbol, then
-@code{(car @var{args})} is called as a function to actually create and
+@code{(car @var{args})} is a function to actually create and
set up the frame; it is called with @var{buffer} as first argument, and
@code{(cdr @var{args})} as additional arguments.
@defopt same-window-buffer-names
A list of buffer names for buffers that should be displayed in the
-selected window. If the buffer's name is in this list,
+selected window. If a buffer's name is in this list,
@code{display-buffer} handles the buffer by switching to it in the
selected window.
@end defopt
above.
@end defopt
-If all options described above fail to produce a suitable window,
-@code{display-buffer} tries to reuse an existing window. As a last
-resort, it will try to display @var{buffer-or-name} on a separate frame.
-In that case, the value of @code{pop-up-frames} is disregarded.
-
-
@node Window History
@section Window History
@cindex window history
-Each window remembers the buffers it has displayed earlier and the order
-in which these buffers have been removed from it. This history is used,
+Each window remembers the buffers it has previously displayed, and the order
+in which these buffers were removed from it. This history is used,
for example, by @code{replace-buffer-in-windows} (@pxref{Buffers and
Windows}). This list is automatically maintained by Emacs, but you can
use the following functions to explicitly inspect or alter it:
argument @var{window} should be a live window or @code{nil} (meaning
the selected window). If the optional argument @var{bury-or-kill} is
non-@code{nil}, this means that the buffer currently shown in
-@var{window} is about to be buried or killed and consequently shall
+@var{window} is about to be buried or killed and consequently should
not be switched to in future invocations of this command.
The previous buffer is usually the buffer shown before the buffer
currently shown in @var{window}. However, a buffer that has been buried
-or killed or has been already shown by a recent invocation of
-@code{switch-to-prev-buffer} does not qualify as previous buffer.
+or killed, or has been already shown by a recent invocation of
+@code{switch-to-prev-buffer}, does not qualify as previous buffer.
If repeated invocations of this command have already shown all buffers
previously shown in @var{window}, further invocations will show buffers
from the buffer list of the frame @var{window} appears on (@pxref{The
-Buffer List}).
+Buffer List}), trying to skip buffers that are already shown in another
+window on that frame.
@end deffn
@deffn Command switch-to-next-buffer &optional window
-This command switches to the next buffer in @var{window} thus undoing
+This command switches to the next buffer in @var{window}, thus undoing
the effect of the last @code{switch-to-prev-buffer} command in
@var{window}. The argument @var{window} must be a live window and
defaults to the selected one.
-If there is no recent invocation of a @code{switch-to-prev-buffer} that
+If there is no recent invocation of @code{switch-to-prev-buffer} that
can be undone, this function tries to show a buffer from the buffer list
of the frame @var{window} appears on (@pxref{The Buffer List}).
@end deffn
+By default @code{switch-to-prev-buffer} and @code{switch-to-next-buffer}
+can switch to a buffer that is already shown in another window on the
+same frame. The following option can be used to override this behavior.
+
+@defopt switch-to-visible-buffer
+If this variable is non-@code{nil}, @code{switch-to-prev-buffer} and
+@code{switch-to-next-buffer} may switch to a buffer that is already
+visible on the same frame, provided the buffer was shown in the relevant
+window before. If it is @code{nil}, @code{switch-to-prev-buffer} and
+@code{switch-to-next-buffer} always try to avoid switching to a buffer
+that is already visible in another window on the same frame.
+@end defopt
+
@node Dedicated Windows
@section Dedicated Windows
This function returns non-@code{nil} if @var{window} is dedicated to its
buffer and @code{nil} otherwise. More precisely, the return value is
the value assigned by the last call of @code{set-window-dedicated-p} for
-@var{window} or @code{nil} if that function was never called with
+@var{window}, or @code{nil} if that function was never called with
@var{window} as its argument. The default for @var{window} is the
selected window.
@end defun
@node Quitting Windows
@section Quitting Windows
-When you want to get rid of a window used for displaying a buffer you
+When you want to get rid of a window used for displaying a buffer, you
can call @code{delete-window} or @code{delete-windows-on}
(@pxref{Deleting Windows}) to remove that window from its frame. If the
buffer is shown on a separate frame, you might want to call
@code{delete-frame} (@pxref{Deleting Frames}) instead. If, on the other
hand, a window has been reused for displaying the buffer, you might
-prefer showing the buffer previously shown in that window by calling the
+prefer showing the buffer previously shown in that window, by calling the
function @code{switch-to-prev-buffer} (@pxref{Window History}).
Finally, you might want to either bury (@pxref{The Buffer List}) or kill
(@pxref{Killing Buffers}) the window's buffer.
The following function uses information on how the window for
-displaying the buffer was obtained in the first place thus attempting to
-automatize the above decisions for you.
+displaying the buffer was obtained in the first place, thus attempting to
+automate the above decisions for you.
@deffn Command quit-window &optional kill window
This command quits @var{window} and buries its buffer. The argument
The three cases described so far require that the buffer shown in
@var{window} is still the buffer displayed by the last buffer display
function for this window. If another buffer has been shown in the
-meantime or the buffer previously shown no longer exists, this command
+meantime, or the buffer previously shown no longer exists, this command
calls @code{switch-to-prev-buffer} (@pxref{Window History}) to show some
other buffer instead.
@end deffn
The function @code{quit-window} bases its decisions on information
stored in @var{window}'s @code{quit-restore} window parameter
-(@pxref{Window Parameters}) and resets that parameter to @code{nil}
+(@pxref{Window Parameters}), and resets that parameter to @code{nil}
after it's done.
The following option specifies how to deal with a frame containing just
-one window that shall be either quit or whose buffer shall be buried.
+one window that should be either quit, or whose buffer should be buried.
@defopt frame-auto-hide-function
The function specified by this option is called to automatically hide
-frames. This function is called with one argument - a frame.
+frames. This function is called with one argument---a frame.
The function specified here is called by @code{bury-buffer} (@pxref{The
Buffer List}) when the selected window is dedicated and shows the buffer
-that shall be buried. It is also called by @code{quit-window} (see
-above) when the frame of the window that shall be quit has been
+that should be buried. It is also called by @code{quit-window} (see
+above) when the frame of the window that should be quit has been
specially created for displaying that window's buffer and the buffer
-shall be buried.
+should be buried.
The default is to call @code{iconify-frame} (@pxref{Visibility of
-Frames}). Alternatively, you may either specify @code{delete-frame}
+Frames}). Alternatively, you may specify either @code{delete-frame}
(@pxref{Deleting Frames}) to remove the frame from its display,
@code{ignore} to leave the frame unchanged, or any other function that
can take a frame as its sole argument.
Note that the function specified by this option is called if and only if
-there's at least one other frame on the terminal of the frame it's
-supposed to handle and that frame contains only one live window.
+there is at least one other frame on the terminal of the frame it's
+supposed to handle, and that frame contains only one live window.
@end defopt
@cindex window top line
This function returns the display-start position of window
@var{window}. If @var{window} is @code{nil}, the selected window is
-used. For example,
-
-@example
-@group
-(window-start)
- @result{} 7058
-@end group
-@end example
+used.
When you create a window, or display a different buffer in it, the
display-start position is set to a display-start position recently used
on the screen. Nothing except redisplay automatically changes the
window-start position; if you move point, do not expect the window-start
position to change in response until after the next redisplay.
-
-For a realistic example of using @code{window-start}, see the
-description of @code{count-lines}. @xref{Definition of count-lines}.
@end defun
@cindex window end position
middle of a buffer and repeatedly call @code{scroll-down}, you will
eventually see the beginning of the buffer.
- Some people have urged that the opposite convention be used: they
+ Unfortunately, this sometimes causes confusion, because some people
+tend to think in terms of the opposite convention: they
imagine the window moving over text that remains in place, so that
``down'' commands take you to the end of the buffer. This convention
is consistent with fact that such a command is bound to a key named
-@key{PageDown} on modern keyboards. We have not switched to this
-convention as that is likely to break existing Emacs Lisp code.
+@key{PageDown} on modern keyboards.
+@ignore
+We have not switched to this convention as that is likely to break
+existing Emacs Lisp code.
+@end ignore
Textual scrolling functions (aside from @code{scroll-other-window})
have unpredictable results if the current buffer is not the one
This function scrolls backward by @var{count} lines in the selected
window.
-If @var{count} is negative, it scrolls forward instead. If
-@var{count} is omitted or @code{nil}, the distance scrolled is
-@code{next-screen-context-lines} lines less than the height of the
-window's text area.
-
-If the selected window cannot be scrolled any further, this function
-signals an error. Otherwise, it returns @code{nil}.
+If @var{count} is negative, it scrolls forward instead. In other
+respects, it behaves the same way as @code{scroll-up} does.
@end deffn
@deffn Command scroll-up-command &optional count
window.
When the selected window is the minibuffer, the next window is normally
-the one at the top left corner. You can specify a different window to
-scroll, when the minibuffer is selected, by setting the variable
+the leftmost one immediately above it. You can specify a different
+window to scroll, when the minibuffer is selected, by setting the variable
@code{minibuffer-scroll-window}. This variable has no effect when any
other window is selected. When it is non-@code{nil} and the
minibuffer is selected, it takes precedence over
@code{scroll-other-window} attempts to scroll the minibuffer. If the
minibuffer contains just one line, it has nowhere to scroll to, so the
line reappears after the echo area momentarily displays the message
-@samp{Beginning of buffer}.
+@samp{End of buffer}.
@end deffn
@defvar other-window-scroll-buffer
point @var{count} lines down from the top of the window. If
@var{count} is a negative number, then it counts upward from the
bottom of the window, so that @minus{}1 stands for the last usable
-line in the window. If @var{count} is a non-@code{nil} list, then it
-stands for the line in the middle of the window.
+line in the window.
-If @var{count} is @code{nil}, @code{recenter} puts the line containing
-point in the middle of the window, then clears and redisplays the entire
-selected frame.
+If @var{count} is @code{nil} (or a non-@code{nil} list),
+@code{recenter} puts the line containing point in the middle of the
+window. If @var{count} is @code{nil}, this function may redraw the
+frame, according to the value of @code{recenter-redisplay}.
When @code{recenter} is called interactively, @var{count} is the raw
prefix argument. Thus, typing @kbd{C-u} as the prefix sets the
top.
With an argument of zero, @code{recenter} positions the current line at
-the top of the window. This action is so handy that some people make a
-separate key binding to do this. For example,
+the top of the window. The command @code{recenter-top-bottom} offers
+a more convenient way to achieve this.
+@end deffn
-@example
-@group
-(defun line-to-top-of-window ()
- "Scroll current line to top of window.
-Replaces three keystroke sequence C-u 0 C-l."
- (interactive)
- (recenter 0))
+@defopt recenter-redisplay
+If this variable is non-@code{nil}, calling @code{recenter} with a
+@code{nil} argument redraws the frame. The default value is
+@code{tty}, which means only redraw the frame if it is a tty frame.
+@end defopt
-(global-set-key [kp-multiply] 'line-to-top-of-window)
-@end group
-@end example
+@deffn Command recenter-top-bottom &optional count
+This command, which is the default binding for @kbd{C-l}, acts like
+@code{recenter}, except if called with no argument. In that case,
+successive calls place point according to the cycling order defined
+by the variable @code{recenter-positions}.
@end deffn
+@defopt recenter-positions
+This variable controls how @code{recenter-top-bottom} behaves when
+called with no argument. The default value is @code{(middle top
+bottom)}, which means that successive calls of
+@code{recenter-top-bottom} with no argument cycle between placing
+point at the middle, top, and bottom of the window.
+@end defopt
+
+
@node Vertical Scrolling
@section Vertical Fractional Scrolling
@cindex vertical fractional scrolling
disappear off to the left depends on their width, and could vary from
line to line.
- Because we read from side to side in the ``inner loop,'' and from top
-to bottom in the ``outer loop,'' the effect of horizontal scrolling is
+ Because we read from side to side in the ``inner loop'', and from top
+to bottom in the ``outer loop'', the effect of horizontal scrolling is
not like that of textual or vertical scrolling. Textual scrolling
involves selection of a portion of text to display, and vertical
scrolling moves the window contents contiguously; but horizontal
@end group
@end example
-
@node Coordinates and Windows
@section Coordinates and Windows
+@cindex frame-relative coordinate
+@cindex coordinate, relative to frame
+@cindex window position
-This section describes how to relate screen coordinates to windows.
+ This section describes functions that report the position of a
+window. Most of these functions report positions relative to the
+window's frame. In this case, the coordinate origin @samp{(0,0)} lies
+near the upper left corner of the frame. For technical reasons, on
+graphical displays the origin is not located at the exact corner of
+the graphical window as it appears on the screen. If Emacs is built
+with the GTK+ toolkit, the origin is at the upper left corner of the
+frame area used for displaying Emacs windows, below the title-bar,
+GTK+ menu bar, and tool bar (since these are drawn by the window
+manager and/or GTK+, not by Emacs). But if Emacs is not built with
+GTK+, the origin is at the upper left corner of the tool bar (since in
+this case Emacs itself draws the tool bar). In both cases, the X and
+Y coordinates increase rightward and downward respectively.
+
+ Except where noted, X and Y coordinates are reported in integer
+character units, i.e. numbers of lines and columns respectively. On a
+graphical display, each ``line'' and ``column'' corresponds to the
+height and width of a default character specified by the frame's
+default font.
+
+@defun window-edges &optional window
+This function returns a list of the edge coordinates of @var{window}.
+If @var{window} is omitted or @code{nil}, it defaults to the selected
+window.
-@defun window-at x y &optional frame
-This function returns the window containing the specified cursor
-position in the frame @var{frame}. The coordinates @var{x} and @var{y}
-are measured in characters and count from the top left corner of the
-frame. If they are out of range, @code{window-at} returns @code{nil}.
+The return value has the form @code{(@var{left} @var{top} @var{right}
+@var{bottom})}. These list elements are, respectively, the X
+coordinate of the leftmost column occupied by the window, the Y
+coordinate of the topmost row, the X coordinate one column to the
+right of the rightmost column, and the Y coordinate one row down from
+the bottommost row.
-If you omit @var{frame}, the selected frame is used.
+Note that these are the actual outer edges of the window, including
+any header line, mode line, scroll bar, fringes, and display margins.
+On a text terminal, if the window has a neighbor on its right, its
+right edge includes the separator line between the window and its
+neighbor.
@end defun
-@defun coordinates-in-window-p coordinates window
-This function checks whether a particular frame position falls within
-the window @var{window}.
+@defun window-inside-edges &optional window
+This function is similar to @code{window-edges}, but the returned edge
+values are for the text area of the window. They exclude any header
+line, mode line, scroll bar, fringes, display margins, and vertical
+separator.
+@end defun
+
+@defun window-top-line &optional window
+This function returns the Y coordinate of the topmost row of
+@var{window}, equivalent to the @var{top} entry in the list returned
+by @code{window-edges}.
+@end defun
+
+@defun window-left-column &optional window
+This function returns the X coordinate of the leftmost column of
+@var{window}, equivalent to the @var{left} entry in the list returned
+by @code{window-edges}.
+@end defun
+
+ The following functions can be used to relate a set of
+frame-relative coordinates to a window:
+
+@defun window-at x y &optional frame
+This function returns the live window at the frame-relative
+coordinates @var{x} and @var{y}, on frame @var{frame}. If there is no
+window at that position, the return value is @code{nil}. If
+@var{frame} is omitted or @code{nil}, it defaults to the selected
+frame.
+@end defun
-The argument @var{coordinates} is a cons cell of the form @code{(@var{x}
-. @var{y})}. The coordinates @var{x} and @var{y} are measured in
-characters, and count from the top left corner of the screen or frame.
+@defun coordinates-in-window-p coordinates window
+This function checks whether a window @var{window} occupies the
+frame-relative coordinates @var{coordinates}, and if so, which part of
+the window that is. @var{window} should be a live window.
+@var{coordinates} should be a cons cell of the form @code{(@var{x}
+. @var{y})}, where @var{x} and @var{y} are frame-relative coordinates.
-The value returned by @code{coordinates-in-window-p} is non-@code{nil}
-if the coordinates are inside @var{window}. The value also indicates
-what part of the window the position is in, as follows:
+If there is no window at the specified position, the return value is
+@code{nil} . Otherwise, the return value is one of the following:
@table @code
@item (@var{relx} . @var{rely})
argument because it always uses the frame that @var{window} is on.
@end defun
+ The following functions return window positions in pixels, rather
+than character units. Though mostly useful on graphical displays,
+they can also be called on text terminals, where the screen area of
+each text character is taken to be ``one pixel''.
+
+@defun window-pixel-edges &optional window
+This function returns a list of pixel coordinates for the edges of
+@var{window}. If @var{window} is omitted or @code{nil}, it defaults
+to the selected window.
+
+The return value has the form @code{(@var{left} @var{top} @var{right}
+@var{bottom})}. The list elements are, respectively, the X pixel
+coordinate of the left window edge, the Y pixel coordinate of the top
+edge, one more than the X pixel coordinate of the right edge, and one
+more than the Y pixel coordinate of the bottom edge.
+@end defun
+
+@defun window-inside-pixel-edges &optional window
+This function is like @code{window-pixel-edges}, except that it
+returns the pixel coordinates for the edges of the window's text area,
+rather than the pixel coordinates for the edges of the window itself.
+@var{window} must specify a live window.
+@end defun
+
+ The following functions return window positions in pixels, relative
+to the display screen rather than the frame:
+
+@defun window-absolute-pixel-edges &optional window
+This function is like @code{window-pixel-edges}, except that it
+returns the edge pixel coordinates relative to the top left corner of
+the display screen.
+@end defun
+
+@defun window-inside-absolute-pixel-edges &optional window
+This function is like @code{window-inside-pixel-edges}, except that it
+returns the edge pixel coordinates relative to the top left corner of
+the display screen. @var{window} must specify a live window.
+@end defun
@node Window Configurations
@section Window Configurations
You can bring back an entire frame layout by restoring a previously
saved window configuration. If you want to record the layout of all
frames instead of just one, use a frame configuration instead of a
-window configuration; see @ref{Frame Configurations}.
+window configuration. @xref{Frame Configurations}.
@defun current-window-configuration &optional frame
This function returns a new object representing @var{frame}'s current
window configuration. The default for @var{frame} is the selected
-frame.
+frame. The variable @code{window-persistent-parameters} specifies
+which window parameters (if any) are saved by this function.
+@xref{Window Parameters}.
@end defun
@defun set-window-configuration configuration
know how to tell whether the new configuration actually differs from the
old one.
-If the frame which @var{configuration} was saved from is dead, all this
+If the frame from which @var{configuration} was saved is dead, all this
function does is restore the three variables @code{window-min-height},
-@code{window-min-width} and @code{minibuffer-scroll-window}. In this
+@code{window-min-width} and @code{minibuffer-scroll-window}. In this
case, the function returns @code{nil}. Otherwise, it returns @code{t}.
Here is a way of using this function to get the same effect
@end example
@end defun
-@defspec save-window-excursion forms@dots{}
+@defmac save-window-excursion forms@dots{}
This special form records the window configuration, executes @var{forms}
in sequence, then restores the earlier window configuration. The window
configuration includes, for each window, the value of point and the
;; @r{The screen is now split again.}
@end group
@end example
-@end defspec
+@end defmac
@defun window-configuration-p object
This function returns @code{t} if @var{object} is a window configuration.
The objects returned by @code{current-window-configuration} die
together with the Emacs process. In order to store a window
-configuration on disk and read it back in another Emacs session the
-following two functions can be used.
+configuration on disk and read it back in another Emacs session, you
+can use the functions described next. These functions are also useful
+to clone the state of a frame into an arbitrary live window
+(@code{set-window-configuration} effectively clones the windows of a
+frame into the root window of that very frame only).
-@defun window-state-get &optional window markers
+@defun window-state-get &optional window writable
This function returns the state of @var{window} as a Lisp object. The
argument @var{window} can be any window and defaults to the root window
of the selected frame.
-The optional argument @var{markers} non-@code{nil} means to use markers
-for sampling positions like @code{window-point} or @code{window-start}.
-This argument should be non-@code{nil} only if the value is used for
-putting the state back in the same session since markers slow down
-processing.
+If the optional argument @var{writable} is non-@code{nil}, this means to
+not use markers for sampling positions like @code{window-point} or
+@code{window-start}. This argument should be non-@code{nil} when the
+state will be written to disk and read back in another session.
+
+Together, the argument @var{writable} and the variable
+@code{window-persistent-parameters} specify which window parameters are
+saved by this function. @xref{Window Parameters}.
@end defun
-The value returned by @code{window-state-get} can be converted by using
-one of the functions defined by Desktop Save Mode (@pxref{Desktop Save
-Mode}) to an object that can be written to a file. Such objects can be
-read back and converted to a Lisp object representing the state of the
-window. That Lisp object can be used as argument for the following
-function in order to restore the state window in another window.
+The value returned by @code{window-state-get} can be used in the same
+session to make a clone of a window in another window. It can be also
+written to disk and read back in another session. In either case, use
+the following function to restore the state of the window.
@defun window-state-put state &optional window ignore
This function puts the window state @var{state} into @var{window}. The
argument @var{window} must specify a live window and defaults to the
selected one.
-The optional argument @var{ignore} non-@code{nil} means to ignore
-minimum window sizes and fixed size restrictions. If @var{ignore}
-equals @code{safe}, this means windows can get as small as one line
+If the optional argument @var{ignore} is non-@code{nil}, it means to ignore
+minimum window sizes and fixed-size restrictions. If @var{ignore}
+is @code{safe}, this means windows can get as small as one line
and/or two columns.
@end defun
@defun window-parameters &optional window
This function returns all parameters of @var{window} and their values.
-The default for @var{window} is the selected window. The return value,
-if non-@code{nil} is an association list whose elements have the form
+The default for @var{window} is the selected window. The return value
+is either @code{nil}, or an association list whose elements have the form
@code{(@var{parameter} . @var{value})}.
@end defun
is the selected window.
@end defun
-Some functions, notably @code{delete-window},
-@code{delete-other-windows} and @code{split-window} may behave specially
+By default, the functions that save and restore window configurations or the
+states of windows (@pxref{Window Configurations}) do not care about
+window parameters. This means that when you change the value of a
+parameter within the body of a @code{save-window-excursion}, the
+previous value is not restored when that macro exits. It also means
+that when you restore via @code{window-state-put} a window state saved
+earlier by @code{window-state-get}, all cloned windows have their
+parameters reset to @code{nil}. The following variable allows you to
+override the standard behavior:
+
+@defvar window-persistent-parameters
+This variable is an alist specifying which parameters get saved by
+@code{current-window-configuration} and @code{window-state-get}, and
+subsequently restored by @code{set-window-configuration} and
+@code{window-state-put}. @xref{Window Configurations}.
+
+The @sc{car} of each entry of this alist is a symbol specifying the
+parameter. The @sc{cdr} should be one of the following:
+
+@table @asis
+@item @code{nil}
+This value means the parameter is saved neither by
+@code{window-state-get} nor by @code{current-window-configuration}.
+
+@item @code{t}
+This value specifies that the parameter is saved by
+@code{current-window-configuration} and (provided its @var{writable}
+argument is @code{nil}) by @code{window-state-get}.
+
+@item @code{writable}
+This means that the parameter is saved unconditionally by both
+@code{current-window-configuration} and @code{window-state-get}. This
+value should not be used for parameters whose values do not have a read
+syntax. Otherwise, invoking @code{window-state-put} in another session
+may fail with an @code{invalid-read-syntax} error.
+@end table
+@end defvar
+
+Some functions (notably @code{delete-window},
+@code{delete-other-windows} and @code{split-window}), may behave specially
when their @var{window} argument has a parameter set. You can override
such special behavior by binding the following variable to a
non-@code{nil} value:
@defvar ignore-window-parameters
If this variable is non-@code{nil}, some standard functions do not
process window parameters. The functions currently affected by this are
-@code{split-window}, @code{delete-window}, @code{delete-other-windows}
+@code{split-window}, @code{delete-window}, @code{delete-other-windows},
and @code{other-window}.
An application can bind this variable to a non-@code{nil} value around
@end defvar
The following parameters are currently used by the window management
-code.
+code:
@table @asis
@item @code{delete-window}
@item @code{no-other-window}
This parameter marks the window as not selectable by @code{other-window}
(@pxref{Cyclic Window Ordering}).
+
+@item @code{clone-of}
+This parameter specifies the window that this one has been cloned
+from. It is installed by @code{window-state-get} (@pxref{Window
+Configurations}).
+
+@item @code{quit-restore}
+This parameter specifies what to do with a window when the buffer it
+shows is not needed any more. It is installed by the buffer display
+functions (@pxref{Choosing Window}), and consulted by the function
+@code{quit-window} (@pxref{Quitting Windows}).
@end table
-In addition, the parameters @code{window-atom} and @code{window-side}
-are reserved and should not be used by applications. The
-@code{quit-restore} parameter tells how to proceed with a window when
-the buffer it shows is no more needed. This parameter is installed by
-the buffer display functions (@pxref{Choosing Window}) and consulted by
-the function @code{quit-window} (@pxref{Quitting Windows}).
+There are additional parameters @code{window-atom} and @code{window-side};
+these are reserved and should not be used by applications.
@node Window Hooks
This variable is not a normal hook, because each function is called with
two arguments: the window, and its new display-start position.
-These functions must be careful in using @code{window-end}
+These functions must take care when using @code{window-end}
(@pxref{Window Start and End}); if you need an up-to-date value, you
must use the @var{update} argument to ensure you get it.
changing the sizes of windows, or displaying a different buffer in a
window.
-The buffer-local part of this hook is run once per each window on the
+The buffer-local part of this hook is run once for each window on the
affected frame, with the relevant window selected and its buffer
current. The global part is run once for the modified frame, with that
frame selected.
HCoop / bpt / emacs.git / blobdiff