diff options
Diffstat (limited to 'doc/lispref/windows.texi')
| -rw-r--r-- | doc/lispref/windows.texi | 1168 |
1 files changed, 876 insertions, 292 deletions
diff --git a/doc/lispref/windows.texi b/doc/lispref/windows.texi index 13c9ca53222..1da2d1cfe7b 100644 --- a/doc/lispref/windows.texi +++ b/doc/lispref/windows.texi @@ -1,6 +1,6 @@ @c -*-texinfo-*- @c This is part of the GNU Emacs Lisp Reference Manual. -@c Copyright (C) 1990-1995, 1998-1999, 2001-2013 Free Software +@c Copyright (C) 1990-1995, 1998-1999, 2001-2015 Free Software @c Foundation, Inc. @c See the file elisp.texi for copying conditions. @node Windows @@ -16,6 +16,7 @@ is displayed in windows. * Windows and Frames:: Relating windows to the frame they appear on. * Window Sizes:: Accessing a window's size. * Resizing Windows:: Changing the sizes of windows. +* Preserving Window Sizes:: Preserving the size of windows. * Splitting Windows:: Creating a new window. * Deleting Windows:: Removing a window from its frame. * Recombining Windows:: Preserving the frame layout when splitting and @@ -137,7 +138,7 @@ window). Each window belongs to exactly one frame (@pxref{Frames}). -@defun window-frame window +@defun window-frame &optional window This function returns the frame that the window @var{window} belongs to. If @var{window} is @code{nil}, it defaults to the selected window. @@ -252,19 +253,19 @@ child windows form a horizontal combination, consisting of the live window @var{W2} and the internal window @var{W3}. The child windows of @var{W3} form a vertical combination, consisting of the live windows @var{W4} and @var{W5}. Hence, the live windows in this -window tree are @var{W2} @var{W4}, and @var{W5}. +window tree are @var{W2}, @var{W4}, and @var{W5}. The following functions can be used to retrieve a child window of an internal window, and the siblings of a child window. -@defun window-top-child window +@defun window-top-child &optional window This function returns the topmost child window of @var{window}, if @var{window} is an internal window whose children form a vertical combination. For any other type of window, the return value is @code{nil}. @end defun -@defun window-left-child window +@defun window-left-child &optional window This function returns the leftmost child window of @var{window}, if @var{window} is an internal window whose children form a horizontal combination. For any other type of window, the return value is @@ -322,7 +323,7 @@ the assumption that the frame from our canonical example is selected @end defun @cindex window in direction -@defun window-in-direction direction &optional window ignore +@defun window-in-direction direction &optional window ignore sign wrap mini This function returns the nearest live window in direction @var{direction} as seen from the position of @code{window-point} in window @var{window}. The argument @var{direction} must be one of @@ -338,6 +339,23 @@ function tries to find another window in the indicated direction whose argument @var{ignore} is non-@code{nil}, a window may be returned even if its @code{no-other-window} parameter is non-@code{nil}. +If the optional argument @var{sign} is a negative number, it means to +use the right or bottom edge of @var{window} as reference position +instead of @code{window-point}. If @var{sign} is a positive number, it +means to use the left or top edge of @var{window} as reference position. + +If the optional argument @var{wrap} is non-@code{nil}, this means to +wrap @var{direction} around frame borders. For example, if @var{window} +is at the top of the frame and @var{direction} is @code{above}, then +return the minibuffer window provided the frame has one, and a window at +the bottom of the frame otherwise. + +If the optional argument @var{mini} is @code{nil}, this means to return +the minibuffer window if and only if it is currently active. If +@var{mini} is non-@code{nil}, it returns the minibuffer window even when +it's not active. However, if @var{wrap} non-@code{nil}, it always acts +as if @var{mini} were @code{nil}. + If it doesn't find a suitable window, this function returns @code{nil}. @end defun @@ -365,6 +383,7 @@ internal window). The @var{edges} element is a list @code{(@var{left} @code{window-edges} (@pxref{Coordinates and Windows}). @end defun + @node Window Sizes @section Window Sizes @cindex window size @@ -374,18 +393,19 @@ internal window). The @var{edges} element is a list @code{(@var{left} @smallexample @group - _________________________________________ - ^ |______________ Header Line_______________| - | |LS|LF|LM| |RM|RF|RS| ^ - | | | | | | | | | | - Window | | | | Text Area | | | | Window - Total | | | | (Window Body) | | | | Body - Height | | | | | | | | Height - | | | | |<- Window Body Width ->| | | | | - | |__|__|__|_______________________|__|__|__| v - v |_______________ Mode Line _______________| - - <----------- Window Total Width --------> + ____________________________________________ + |______________ Header Line ______________|RD| ^ + ^ |LS|LM|LF| |RF|RM|RS| | | + | | | | | | | | | | | +Window | | | | Text Area | | | | | Window +Body | | | | | (Window Body) | | | | | Total +Height | | | | | | | | | Height + | | | | |<- Window Body Width ->| | | | | | + v |__|__|__|_______________________|__|__|__| | | + |_________ Horizontal Scroll Bar _________| | | + |_______________ Mode Line _______________|__| | + |_____________ Bottom Divider _______________| v + <---------- Window Total Width ------------> @end group @end smallexample @@ -394,59 +414,125 @@ internal window). The @var{edges} element is a list @code{(@var{left} @cindex text area of a window @cindex body of a window At the center of the window is the @dfn{text area}, or @dfn{body}, -where the buffer text is displayed. On each side of the text area is -a series of vertical areas; from innermost to outermost, these are the -left and right margins, denoted by LM and RM in the schematic -(@pxref{Display Margins}); the left and right fringes, denoted by LF -and RF (@pxref{Fringes}); and the left or right scroll bar, only one of -which is present at any time, denoted by LS and RS (@pxref{Scroll -Bars}). At the top of the window is an optional header line -(@pxref{Header Lines}), and at the bottom of the window is the mode -line (@pxref{Mode Line Format}). - - Emacs provides several functions for finding the height and width of -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 -font or size, the reported height and width for that window may differ -from the actual number of text lines or columns displayed within it. +where the buffer text is displayed. The text area can be surrounded by +a series of optional areas. On the left and right, from innermost to +outermost, these are the left and right fringes, denoted by LF and RF +(@pxref{Fringes}); the left and right margins, denoted by LM and RM in +the schematic (@pxref{Display Margins}); the left or right vertical +scroll bar, only one of which is present at any time, denoted by LS and +RS (@pxref{Scroll Bars}); and the right divider, denoted by RD +(@pxref{Window Dividers}). At the top of the window is the header line +(@pxref{Header Lines}). At the bottom of the window are the horizontal +scroll bar (@pxref{Scroll Bars}); the mode line (@pxref{Mode Line +Format}); and the bottom divider (@pxref{Window Dividers}). + + Emacs provides miscellaneous functions for finding the height and +width of a window. The return value of many of these functions can be +specified either in units of pixels or in units of lines and columns. +On a graphical display, the latter actually correspond to the height and +width of a default character specified by the frame's default font +as returned by @code{frame-char-height} and @code{frame-char-width} +(@pxref{Frame Font}). Thus, if a window is displaying text with a +different font or size, the reported line height and column width for +that window may differ from the actual number of text lines or columns +displayed within it. @cindex window height @cindex height of a window @cindex total height of a window + The @dfn{total height} of a window is the number of lines comprising +the window's body, the header line, the horizontal scroll bar, the mode +line and the bottom divider (if any). + +@defun window-total-height &optional window round +This function returns the total height, in lines, of the window +@var{window}. If @var{window} is omitted or @code{nil}, it defaults to +the selected window. If @var{window} is an internal window, the return +value is the total height occupied by its descendant windows. + + If a window's pixel height is not an integral multiple of its frame's +default character height, the number of lines occupied by the window is +rounded internally. This is done in a way such that, if the window is a +parent window, the sum of the total heights of all its child windows +internally equals the total height of their parent. This means that +although two windows have the same pixel height, their internal total +heights may differ by one line. This means also, that if window is +vertically combined and has a next sibling, the topmost row of that +sibling can be calculated as the sum of this window's topmost row and +total height (@pxref{Coordinates and Windows}) + + If the optional argument @var{round} is @code{ceiling}, this +function returns the smallest integer larger than @var{window}'s pixel +height divided by the character height of its frame; if it is +@code{floor}, it returns the largest integer smaller than said value; +with any other @var{round} it returns the internal value of +@var{windows}'s total height. +@end defun + @cindex window width @cindex width of a window @cindex total width of a window - The @dfn{total height} of a window is the distance between the top -and bottom of the window, including the header line (if one exists) -and the mode line. The @dfn{total width} of a window is the distance -between the left and right edges of the mode line. Note that the -height of a frame is not the same as the height of its windows, since -a frame may also contain an echo area, menu bar, and tool bar -(@pxref{Size and Position}). +The @dfn{total width} of a window is the number of lines comprising the +window's body, its margins, fringes, scroll bars and a right divider (if +any). -@defun window-total-height &optional window -This function returns the total height, in lines, of the window -@var{window}. If @var{window} is omitted or @code{nil}, it defaults -to the selected window. If @var{window} is an internal window, the -return value is the total height occupied by its descendant windows. +@defun window-total-width &optional window round +This function returns the total width, in columns, of the window +@var{window}. If @var{window} is omitted or @code{nil}, it defaults to +the selected window. If @var{window} is internal, the return value is +the total width occupied by its descendant windows. + + If a window's pixel width is not an integral multiple of its frame's +character width, the number of lines occupied by the window is rounded +internally. This is done in a way such that, if the window is a parent +window, the sum of the total widths of all its children internally +equals the total width of their parent. This means that although two +windows have the same pixel width, their internal total widths may +differ by one column. This means also, that if this window is +horizontally combined and has a next sibling, the leftmost column of +that sibling can be calculated as the sum of this window's leftmost +column and total width (@pxref{Coordinates and Windows}). The optional +argument @var{round} behaves as it does for @code{window-total-height}. @end defun -@defun window-total-width &optional window -This function returns the total width, in columns, of the window -@var{window}. If @var{window} is omitted or @code{nil}, it defaults -to the selected window. If @var{window} is internal, the return value -is the total width occupied by its descendant windows. +@defun window-total-size &optional window horizontal round +This function returns either the total height in lines or the total +width in columns of the window @var{window}. If @var{horizontal} is +omitted or @code{nil}, this is equivalent to calling +@code{window-total-height} for @var{window}; otherwise it is equivalent +to calling @code{window-total-width} for @var{window}. The optional +argument @var{round} behaves as it does for @code{window-total-height}. @end defun -@defun window-total-size &optional window horizontal -This function returns either the total height or width of the window -@var{window}. If @var{horizontal} is omitted or @code{nil}, this is -equivalent to calling @code{window-total-height} for @var{window}; -otherwise it is equivalent to calling @code{window-total-width} for -@var{window}. +The following two functions can be used to return the total size of a +window in units of pixels. + +@cindex window pixel height +@cindex pixel height of a window +@cindex total pixel height of a window + +@defun window-pixel-height &optional window +This function returns the total height of window @var{window} in pixels. +@var{window} must be a valid window and defaults to the selected one. + +The return value includes mode and header line, a horizontal scroll bar +and a bottom divider, if any. If @var{window} is an internal window, +its pixel height is the pixel height of the screen areas spanned by its +children. +@end defun + +@cindex window pixel height +@cindex pixel height of a window +@cindex total pixel height of a window + +@defun window-pixel-width &optional Lisp_Object &optional window +This function returns the width of window @var{window} in pixels. +@var{window} must be a valid window and defaults to the selected one. + +The return value includes the fringes and margins of @var{window} as +well as any vertical dividers or scroll bars belonging to @var{window}. +If @var{window} is an internal window, its pixel width is the width of +the screen areas spanned by its children. @end defun @cindex full-width window @@ -455,10 +541,12 @@ otherwise it is equivalent to calling @code{window-total-width} for window has any adjacent windows. @defun window-full-height-p &optional window -This function returns non-@code{nil} if @var{window} has no other -window above or below it in its frame, i.e., its total height equals -the total height of the root window on that frame. If @var{window} is -omitted or @code{nil}, it defaults to the selected window. +This function returns non-@code{nil} if @var{window} has no other window +above or below it in its frame. More precisely, this means that the +total height of @var{window} equals the total height of the root window +on that frame. The minibuffer window does not count in this regard. If +@var{window} is omitted or @code{nil}, it defaults to the selected +window. @end defun @defun window-full-width-p &optional window @@ -471,40 +559,52 @@ that of the root window on that frame. If @var{window} is omitted or @cindex window body height @cindex body height of a window @cindex window body width +The @dfn{body height} of a window is the height of its text area, which +does not include a mode or header line, a horizontal scroll bar, or a +bottom divider. + +@defun window-body-height &optional window pixelwise +This function returns the height, in lines, of the body of window +@var{window}. If @var{window} is omitted or @code{nil}, it defaults to +the selected window; otherwise it must be a live window. + +If the optional argument @var{pixelwise} is non-@code{nil}, this +function returns the body height of @var{window} counted in pixels. + +If @var{pixelwise} is @code{nil}, the return value is rounded down to +the nearest integer, if necessary. This means that if a line at the +bottom of the text area is only partially visible, that line is not +counted. It also means that the height of a window's body can never +exceed its total height as returned by @code{window-total-height}. +@end defun + @cindex body width of a window @cindex body size of a window @cindex window body size - The @dfn{body height} of a window is the height of its text area, -which does not include the mode or header line. Similarly, the -@dfn{body width} is the width of the text area, which does not include -the scroll bar, fringes, or margins. - -@defun window-body-height &optional window -This function returns the body height, in lines, of the window -@var{window}. If @var{window} is omitted or @code{nil}, it defaults -to the selected window; otherwise it must be a live window. - -If there is a partially-visible line at the bottom of the text area, -that counts as a whole line; to exclude such a partially-visible line, -use @code{window-text-height}, below. -@end defun - -@defun window-body-width &optional window -This function returns the body width, in columns, of the window -@var{window}. If @var{window} is omitted or @code{nil}, it defaults -to the selected window; otherwise it must be a live window. -@end defun - -@defun window-body-size &optional window horizontal -This function returns the body height or body width of @var{window}. -If @var{horizontal} is omitted or @code{nil}, it is equivalent to -calling @code{window-body-height} for @var{window}; otherwise it is -equivalent to calling @code{window-body-width}. +The @dfn{body width} of a window is the width of its text area, which +does not include the scroll bar, fringes, margins or a right divider. + +@defun window-body-width &optional window pixelwise +This function returns the width, in columns, of the body of window +@var{window}. If @var{window} is omitted or @code{nil}, it defaults to +the selected window; otherwise it must be a live window. + +If the optional argument @var{pixelwise} is non-@code{nil}, this +function returns the body width of @var{window} in units of pixels. + +If @var{pixelwise} is @code{nil}, the return value is rounded down to +the nearest integer, if necessary. This means that if a column on the +right of the text area is only partially visible, that column is not +counted. It also means that the width of a window's body can never +exceed its total width as returned by @code{window-total-width}. @end defun -@defun window-text-height &optional window -This function is like @code{window-body-height}, except that any -partially-visible line at the bottom of the text area is not counted. +@defun window-body-size &optional window horizontal pixelwise +This function returns the body height or body width of @var{window}. If +@var{horizontal} is omitted or @code{nil}, it is equivalent to calling +@code{window-body-height} for @var{window}; otherwise it is equivalent +to calling @code{window-body-width}. In either case, the optional +argument @var{pixelwise} is passed to the function called. @end defun For compatibility with previous versions of Emacs, @@ -512,47 +612,84 @@ partially-visible line at the bottom of the text area is not counted. @code{window-width} is an alias for @code{window-body-width}. These aliases are considered obsolete and will be removed in the future. + The pixel heights of a window's mode and header line can be retrieved +with the functions given below. Their return value is usually accurate +unless the window has not been displayed before: In that case, the +return value is based on an estimate of the font used for the window's +frame. + +@defun window-mode-line-height &optional window +This function returns the height in pixels of @var{window}'s mode line. +@var{window} must be a live window and defaults to the selected one. If +@var{window} has no mode line, the return value is zero. +@end defun + +@defun window-header-line-height &optional window +This function returns the height in pixels of @var{window}'s header +line. @var{window} must be a live window and defaults to the selected +one. If @var{window} has no header line, the return value is zero. +@end defun + +Functions for retrieving the height and/or width of window dividers +(@pxref{Window Dividers}), fringes (@pxref{Fringes}), scroll bars +(@pxref{Scroll Bars}), and display margins (@pxref{Display Margins}) are +described in the corresponding sections. + @cindex fixed-size window @vindex window-min-height @vindex window-min-width Commands that change the size of windows (@pxref{Resizing Windows}), or split them (@pxref{Splitting Windows}), obey the variables -@code{window-min-height} and @code{window-min-width}, which specify -the smallest allowable window height and width. @xref{Change -Window,,Deleting and Rearranging Windows, emacs, The GNU Emacs -Manual}. They also obey the variable @code{window-size-fixed}, with -which a window can be @dfn{fixed} in size: - -@defvar window-size-fixed -If this buffer-local variable is non-@code{nil}, the size of any -window displaying the buffer cannot normally be changed. Deleting a -window or changing the frame's size may still change its size, if -there is no choice. - -If the value is @code{height}, then only the window's height is fixed; -if the value is @code{width}, then only the window's width is fixed. -Any other non-@code{nil} value fixes both the width and the height. -@end defvar +@code{window-min-height} and @code{window-min-width}, which specify the +smallest allowable window height and width. They also obey the variable +@code{window-size-fixed}, with which a window can be @dfn{fixed} in +size: + +@defopt window-min-height +This option specifies the minimum total height, in lines, of any window. +Its value has to accommodate at least one text line as well as a mode +and header line, a horizontal scroll bar and a bottom divider, if +present. +@end defopt -@defun window-size-fixed-p &optional window horizontal -This function returns a non-@code{nil} value if @var{window}'s height -is fixed. If @var{window} is omitted or @code{nil}, it defaults to -the selected window. If the optional argument @var{horizontal} is -non-@code{nil}, the return value is non-@code{nil} if @var{window}'s -width is fixed. +@defopt window-min-width +This option specifies the minimum total width, in columns, of any +window. Its value has to accommodate two text columns as well as +margins, fringes, a scroll bar and a right divider, if present. +@end defopt -A @code{nil} return value does not necessarily mean that @var{window} -can be resized in the desired direction. To determine that, use the -function @code{window-resizable}. @xref{Resizing Windows}. +The following function tells how small a specific window can get taking +into account the sizes of its areas and the values of +@code{window-min-height}, @code{window-min-width} and +@code{window-size-fixed}. + +@defun window-min-size &optional window horizontal ignore pixelwise +This function returns the minimum size of @var{window}. @var{window} +must be a valid window and defaults to the selected one. The optional +argument @var{horizontal} non-@code{nil} means to return the minimum +number of columns of @var{window}; otherwise return the minimum number +of @var{window}'s lines. + +The return value makes sure that all components of @var{window} remain +fully visible if @var{window}'s size were actually set to it. With +@var{horizontal} @code{nil} it includes the mode and header line, the +horizontal scroll bar and the bottom divider. With @var{horizontal} +non-@code{nil} it includes the fringes, a scroll bar, and a right +divider, if present. It does not, however, include the space reserved +for the margins. + +The optional argument @var{ignore}, if non-@code{nil}, means ignore +restrictions imposed by fixed size windows, @code{window-min-height} or +@code{window-min-width} settings. If @var{ignore} equals @code{safe}, +live windows may get as small as @code{window-safe-min-height} lines and +@code{window-safe-min-width} columns. If @var{ignore} is a window, +ignore restrictions for that window only. Any other non-@code{nil} +value means ignore all of the above restrictions for all windows. + +The optional argument @var{pixelwise} non-@code{nil} means to return the +minimum size of @var{window} counted in pixels. @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 @cindex window resizing @@ -571,7 +708,7 @@ changed except by resizing the frame (@pxref{Size and Position}). arguments. Resizing an internal window causes its child windows to be resized to fit the same space. -@defun window-resizable window delta &optional horizontal ignore +@defun window-resizable window delta &optional horizontal ignore pixelwise This function returns @var{delta} if the size of @var{window} can be changed vertically by @var{delta} lines. If the optional argument @var{horizontal} is non-@code{nil}, it instead returns @var{delta} if @@ -587,18 +724,21 @@ lines or columns. If @var{delta} is non-zero, a return value of 0 means that the window cannot be resized. Normally, the variables @code{window-min-height} and -@code{window-min-width} specify the smallest allowable window size. -@xref{Change Window,, Deleting and Rearranging Windows, emacs, The GNU -Emacs Manual}. However, if the optional argument @var{ignore} is -non-@code{nil}, this function ignores @code{window-min-height} and -@code{window-min-width}, as well as @code{window-size-fixed}. -Instead, it considers the minimum-height window to be one consisting -of a header (if any), a mode line, plus a text area one line tall; and -a minimum-width window as one consisting of fringes, margins, and -scroll bar (if any), plus a text area two columns wide. -@end defun - -@defun window-resize window delta &optional horizontal ignore +@code{window-min-width} specify the smallest allowable window size +(@pxref{Window Sizes}). However, if the optional argument @var{ignore} +is non-@code{nil}, this function ignores @code{window-min-height} and +@code{window-min-width}, as well as @code{window-size-fixed}. Instead, +it considers the minimum-height window to be one consisting of a header +and a mode line, a horizontal scrollbar and a bottom divider (if any), +plus a text area one line tall; and a minimum-width window as one +consisting of fringes, margins, a scroll bar and a right divider (if +any), plus a text area two columns wide. + +If the optional argument @var{pixelwise} is non-@code{nil}, +@var{delta} is interpreted as pixels. +@end defun + +@defun window-resize window delta &optional horizontal ignore pixelwise This function resizes @var{window} by @var{delta} increments. If @var{horizontal} is @code{nil}, it changes the height by @var{delta} lines; otherwise, it changes the width by @var{delta} columns. A @@ -611,24 +751,30 @@ the window cannot be resized as demanded, an error is signaled. The optional argument @var{ignore} has the same meaning as for the function @code{window-resizable} above. +If the optional argument @var{pixelwise} is non-@code{nil}, +@var{delta} will be interpreted as pixels. + 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{Recombining Windows}. To resize by moving only the bottom or right edge of a window, use the function -@code{adjust-window-trailing-edge}, below. +@code{adjust-window-trailing-edge}. @end defun @c The commands enlarge-window, enlarge-window-horizontally, @c shrink-window, and shrink-window-horizontally are documented in the @c Emacs manual. They are not preferred for calling from Lisp. -@defun adjust-window-trailing-edge window delta &optional horizontal +@defun adjust-window-trailing-edge window delta &optional horizontal pixelwise This function moves @var{window}'s bottom edge by @var{delta} lines. If optional argument @var{horizontal} is non-@code{nil}, it instead moves the right edge by @var{delta} columns. If @var{window} is @code{nil}, it defaults to the selected window. +If the optional argument @var{pixelwise} is non-@code{nil}, +@var{delta} is interpreted as pixels. + A positive @var{delta} moves the edge downwards or to the right; a negative @var{delta} moves it upwards or to the left. If the edge cannot be moved as far as specified by @var{delta}, this function @@ -639,31 +785,119 @@ moved. If this is not possible for some reason (e.g., if that adjacent window is fixed-size), it may resize other windows. @end defun +@cindex pixelwise, resizing windows +@defopt window-resize-pixelwise +If the value of this option is non-@code{nil}, Emacs resizes windows in +units of pixels. This currently affects functions like +@code{split-window} (@pxref{Splitting Windows}), @code{maximize-window}, +@code{minimize-window}, @code{fit-window-to-buffer}, +@code{fit-frame-to-buffer} and +@code{shrink-window-if-larger-than-buffer} (all listed below). + +Note that when a frame's pixel size is not a multiple of its character +size, at least one window may get resized pixelwise even if this +option is @code{nil}. The default value is @code{nil}. +@end defopt + The following commands resize windows in more specific ways. When called interactively, they act on the selected window. -@deffn Command fit-window-to-buffer &optional window max-height min-height override -This command adjusts the height of @var{window} to fit the text in it. -It returns non-@code{nil} if it was able to resize @var{window}, and -@code{nil} otherwise. If @var{window} is omitted or @code{nil}, it -defaults to the selected window. Otherwise, it should be a live -window. +@deffn Command fit-window-to-buffer &optional window max-height min-height max-width min-width preserve-size +This command adjusts the height or width of @var{window} to fit the text +in it. It returns non-@code{nil} if it was able to resize @var{window}, +and @code{nil} otherwise. If @var{window} is omitted or @code{nil}, it +defaults to the selected window. Otherwise, it should be a live window. + +If @var{window} is part of a vertical combination, this function adjusts +@var{window}'s height. The new height is calculated from the actual +height of the accessible portion of its buffer. 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 non-@code{nil}, specifies the minimum total height +that it can give, which overrides the variable @code{window-min-height}. +Both @var{max-height} and @var{min-height} are specified in lines and +include mode and header line and a bottom divider, if any. + +If @var{window} is part of a horizontal combination and the value of the +option @code{fit-window-to-buffer-horizontally} (see below) is +non-@code{nil}, this function adjusts @var{window}'s height. The new +width of @var{window} is calculated from the maximum length of its +buffer's lines that follow the current start position of @var{window}. +The optional argument @var{max-width} specifies a maximum width and +defaults to the width of @var{window}'s frame. The optional argument +@var{min-width} specifies a minimum width and defaults to +@code{window-min-width}. Both @var{max-width} and @var{min-width} are +specified in columns and include fringes, margins and scrollbars, if +any. -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 non-@code{nil}, specifies -the minimum total height that it can give, which overrides the -variable @code{window-min-height}. +The optional argument @var{preserve-size}, if non-@code{nil}, will +install a parameter to preserve the size of @var{window} during future +resize operations (@pxref{Preserving Window Sizes}). -If the optional argument @var{override} is non-@code{nil}, this -function ignores any size restrictions imposed by -@code{window-min-height} and @code{window-min-width}. +If the option @code{fit-frame-to-buffer} (see below) is non-@code{nil}, +this function will try to resize the frame of @var{window} to fit its +contents by calling @code{fit-frame-to-buffer} (see below). +@end deffn -@vindex fit-frame-to-buffer -If the option @code{fit-frame-to-buffer} is non-@code{nil}, this -command may resize the frame to fit its contents. +@defopt fit-window-to-buffer-horizontally +If this is non-@code{nil}, @code{fit-window-to-buffer} can resize +windows horizontally. If this is @code{nil} (the default) +@code{fit-window-to-buffer} never resizes windows horizontally. If this +is @code{only}, it can resize windows horizontally only. Any other +value means @code{fit-window-to-buffer} can resize windows in both +dimensions. +@end defopt + +@defopt fit-frame-to-buffer +If this option is non-@code{nil}, @code{fit-window-to-buffer} can fit a +frame to its buffer. A frame is fit if and only if its root window is a +live window and this option is non-@code{nil}. If this is +@code{horizontally}, frames are fit horizontally only. If this is +@code{vertically}, frames are fit vertically only. Any other +non-@code{nil} value means frames can be resized in both dimensions. +@end defopt + +If you have a frame that displays only one window, you can fit that +frame to its buffer using the command @code{fit-frame-to-buffer}. + +@deffn Command fit-frame-to-buffer &optional frame max-height min-height max-width min-width only +This command adjusts the size of @var{frame} to display the contents of +its buffer exactly. @var{frame} can be any live frame and defaults to +the selected one. Fitting is done only if @var{frame}'s root window is +live. The arguments @var{max-height}, @var{min-height}, @var{max-width} +and @var{min-width} specify bounds on the new total size of +@var{frame}'s root window. @var{min-height} and @var{min-width} default +to the values of @code{window-min-height} and @code{window-min-width} +respectively. + +If the optional argument @var{only} is @code{vertically}, this function +may resize the frame vertically only. If @var{only} is +@code{horizontally}, it may resize the frame horizontally only. @end deffn +The behavior of @code{fit-frame-to-buffer} can be controlled with the +help of the two options listed next. + +@defopt fit-frame-to-buffer-margins +This option can be used to specify margins around frames to be fit by +@code{fit-frame-to-buffer}. Such margins can be useful to avoid, for +example, that such frames overlap the taskbar. + +It specifies the numbers of pixels to be left free on the left, above, +the right, and below a frame that shall be fit. The default specifies +@code{nil} for each which means to use no margins. The value specified +here can be overridden for a specific frame by that frame's +@code{fit-frame-to-buffer-margins} parameter, if present. +@end defopt + +@defopt fit-frame-to-buffer-sizes +This option specifies size boundaries for @code{fit-frame-to-buffer}. +It specifies the total maximum and minimum lines and maximum and minimum +columns of the root window of any frame that shall be fit to its buffer. +If any of these values is non-@code{nil}, it overrides the corresponding +argument of @code{fit-frame-to-buffer}. +@end defopt + @deffn Command shrink-window-if-larger-than-buffer &optional window This command attempts to reduce @var{window}'s height as much as possible while still showing its full buffer, but no less than @@ -675,8 +909,12 @@ it should be a live window. This command does nothing if the window is already too short to display all of its buffer, or if any of the buffer is scrolled off-screen, or if the window is the only live window in its frame. + +This command calls @code{fit-window-to-buffer} (see above) to do its +work. @end deffn + @cindex balancing window sizes @deffn Command balance-windows &optional window-or-frame This function balances windows in a way that gives more space to @@ -709,6 +947,98 @@ window. @end deffn +@node Preserving Window Sizes +@section Preserving Window Sizes +@cindex preserving window sizes + +A window can get resized explicitly by using one of the functions from +the preceding section or implicitly, for example, when resizing an +adjacent window, when splitting or deleting a window (@pxref{Splitting +Windows}, @pxref{Deleting Windows}) or when resizing the window's frame +(@pxref{Size and Position}). + + It is possible to avoid implicit resizing of a specific window when +there are one or more other resizable windows on the same frame. For +this purpose, Emacs must be advised to @dfn{preserve} the size of that +window. There are two basic ways to do that. + +@defvar window-size-fixed +If this buffer-local variable is non-@code{nil}, the size of any window +displaying the buffer cannot normally be changed. Deleting a window or +changing the frame's size may still change the window's size, if there +is no choice. + +If the value is @code{height}, then only the window's height is fixed; +if the value is @code{width}, then only the window's width is fixed. +Any other non-@code{nil} value fixes both the width and the height. + +If this variable is @code{nil}, this does not necessarily mean that any +window showing the buffer can be resized in the desired direction. To +determine that, use the function @code{window-resizable}. +@xref{Resizing Windows}. +@end defvar + +Often @code{window-size-fixed} is overly aggressive because it inhibits +any attempt to explicitly resize or split an affected window as well. +This may even happen after the window has been resized implicitly, for +example, when deleting an adjacent window or resizing the window's +frame. The following function tries hard to never disallow resizing +such a window explicitly: + +@defun window-preserve-size &optional window horizontal preserve +This function (un-)marks the height of window @var{window} as preserved +for future resize operations. @var{window} must be a live window and +defaults to the selected one. If the optional argument @var{horizontal} +is non-@code{nil}, it (un-)marks the width of @var{window} as preserved. + +If the optional argument @var{preserve} is @code{t}, this means to +preserve the current height/width of @var{window}'s body. The +height/width of @var{window} will change only if Emacs has no better +choice. Resizing a window whose height/width is preserved by this +function never throws an error. + +If @var{preserve} is @code{nil}, this means to stop preserving the +height/width of @var{window}, lifting any respective restraint induced +by a previous call of this function for @var{window}. Calling +@code{enlarge-window}, @code{shrink-window} or +@code{fit-window-to-buffer} with @var{window} as argument may also +remove the respective restraint. +@end defun + +@code{window-preserve-size} is currently invoked by the following +functions: + +@table @code +@item fit-window-to-buffer +If the optional argument @var{preserve-size} of that function +(@pxref{Resizing Windows}) is non-@code{nil}, the size established by +that function is preserved. + +@item display-buffer +If the @var{alist} argument of that function (@pxref{Choosing Window}) +contains a @code{preserve-size} entry, the size of the window produced +by that function is preserved. +@end table + + @code{window-preserve-size} installs a window parameter (@pxref{Window +Parameters}) called @code{preserved-size} which is consulted by the +window resizing functions. This parameter will not prevent resizing the +window when the window shows another buffer than the one when +@code{window-preserve-size} was invoked or if its size has changed since +then. + +The following function can be used to check whether the height of a +particular window is preserved: + +@defun window-preserved-size &optional window horizontal +This function returns the preserved height of window @var{window} in +pixels. @var{window} must be a live window and defaults to the selected +one. If the optional argument @var{horizontal} is non-@code{nil}, it +returns the preserved width of @var{window}. It returns @code{nil} if +the size of @var{window} is not preserved. +@end defun + + @node Splitting Windows @section Splitting Windows @cindex splitting windows @@ -717,10 +1047,10 @@ window. This section describes functions for creating a new window by @dfn{splitting} an existing one. -@defun split-window &optional window size side +@defun split-window &optional window size side pixelwise This function creates a new live window next to the window @var{window}. If @var{window} is omitted or @code{nil}, it defaults -to the selected window. That window is ``split'', and reduced in +to the selected window. That window is split, and reduced in size. The space is taken up by the new window, which is returned. The optional second argument @var{size} determines the sizes of @@ -732,15 +1062,25 @@ value of @var{side}). If @var{size} is a negative number, the new window is given @minus{}@var{size} lines (or columns). If @var{size} is @code{nil}, this function obeys the variables -@code{window-min-height} and @code{window-min-width}. @xref{Change -Window,,Deleting and Rearranging Windows, emacs, The GNU Emacs -Manual}. Thus, it signals an error if splitting would result in -making a window smaller than those variables specify. However, a +@code{window-min-height} and @code{window-min-width} (@pxref{Window +Sizes}). Thus, it signals an error if splitting would result in making +a window smaller than those variables specify. However, a non-@code{nil} value for @var{size} causes those variables to be -ignored; in that case, the smallest allowable window is considered to -be one that has space for a text area one line tall and/or two columns +ignored; in that case, the smallest allowable window is considered to be +one that has space for a text area one line tall and/or two columns wide. +Hence, if @var{size} is specified, it's the caller's responsibility to +check whether the emanating windows are large enough to encompass all +areas like a mode line or a scroll bar. The function +@code{window-min-size} (@pxref{Window Sizes}) can be used to determine +the minimum requirements of @var{window} in this regard. Since the new +window usually inherits areas like the mode line or the scroll bar +from @var{window}, that function is also a good guess for the minimum +size of the new window. The caller should specify a smaller size only +if it correspondingly removes an inherited area before the next +redisplay. + The optional third argument @var{side} determines the position of the new window relative to @var{window}. If it is @code{nil} or @code{below}, the new window is placed below @var{window}. If it is @@ -752,6 +1092,10 @@ the right of @var{window}. If @var{side} is @code{left}, the new window is placed on the left of @var{window}. In both these cases, @var{size} specifies a total window width, in columns. +The optional fourth argument @var{pixelwise}, if non-@code{nil}, means +to interpret @var{size} in units of pixels, instead of lines and +columns. + If @var{window} is a live window, the new window inherits various properties from it, including margins and scroll bars. If @var{window} is an internal window, the new window inherits the @@ -855,6 +1199,7 @@ point was previously on. Note that this only affects function. @end defopt + @node Deleting Windows @section Deleting Windows @cindex deleting windows @@ -947,6 +1292,8 @@ are the opposite of what they are in those other functions. @node Recombining Windows @section Recombining Windows +@cindex recombining windows +@cindex windows, recombining When deleting the last sibling of a window @var{W}, its parent window is deleted too, with @var{W} replacing it in the window tree. This @@ -1164,7 +1511,7 @@ vertical combination @var{W1}. @cindex window combination limit @defun set-window-combination-limit window limit -This functions sets the @dfn{combination limit} of the window +This function 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 @@ -1298,16 +1645,27 @@ windows. @defun select-window window &optional norecord This function makes @var{window} the selected window and the window selected within its frame (@pxref{Basic Windows}) and selects that -frame. @var{window} must be a live window. This function also makes -@var{window}'s buffer (@pxref{Buffers and Windows}) current and sets -that buffer's value of @code{point} to the value of @code{window-point} -(@pxref{Window Point}) in @var{window}. The return value is -@var{window}. +frame. It also makes @var{window}'s buffer (@pxref{Buffers and +Windows}) current and sets that buffer's value of @code{point} to the +value of @code{window-point} (@pxref{Window Point}) in @var{window}. +@var{window} must be a live window. The return value is @var{window}. By default, this function also moves @var{window}'s buffer to the front -of the buffer list (@pxref{The Buffer List}), and makes @var{window} the +of the buffer list (@pxref{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. + +This function runs @code{buffer-list-update-hook} (@pxref{Buffer List}) +unless @var{norecord} is non-@code{nil}. Note that applications and +internal routines often temporarily select a window in order to simplify +coding. As a rule, such selections (including those made by the macros +@code{save-selected-window} and @code{with-selected-window} below) are +not recorded thus avoiding to pollute @code{buffer-list-update-hook}. +Selections that really count are those causing a visible change in +the next redisplay of @var{window}'s frame and should be always +recorded. This also means that to run a function each time a window +gets selected, putting it on @code{buffer-list-update-hook} should be +the right choice. @end defun @cindex most recently selected windows @@ -1367,6 +1725,20 @@ function does not alter the list of most recently selected windows, nor the buffer list. @end defun +@cindex window use time +@cindex use time of window +@cindex window order by time of last use +@defun window-use-time &optional window +This functions returns the use time of window @var{window}. +@var{window} must be a live window and defaults to the selected one. +The @dfn{use time} of a window is not really a time value, but it does +increase monotonically with each window selection, so the window with +the lowest use time is the least recently selected one, and the +window with the highest use time is the most recently selected +one. +@end defun + + @node Cyclic Window Ordering @section Cyclic Ordering of Windows @cindex cyclic ordering of windows @@ -1393,7 +1765,7 @@ if omitted or @code{nil}, it defaults to the selected window. The optional argument @var{minibuf} specifies whether minibuffer windows 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 +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 @ref{Minibuffers}). @@ -1487,8 +1859,8 @@ criterion, without selecting it: @cindex least recently used window @defun get-lru-window &optional all-frames dedicated not-selected -This function returns a live window which is heuristically the ``least -recently used'' window. The optional argument @var{all-frames} has +This function returns a live window which is heuristically the least +recently used. The optional argument @var{all-frames} has the same meaning as in @code{next-window}. If any full-width windows are present, only those windows are @@ -1500,6 +1872,13 @@ the optional argument @var{not-selected} is non-@code{nil}, this function returns @code{nil} in that case. @end defun +@cindex most recently used window +@defun get-mru-window &optional all-frames dedicated not-selected +This function is like @code{get-lru-window}, but it returns the most +recently used window instead. The meaning of the arguments is the +same as described for @code{get-lru-window}. +@end defun + @cindex largest window @defun get-largest-window &optional all-frames dedicated not-selected This function returns the window with the largest area (height times @@ -1626,7 +2005,9 @@ to eliminate this discrepancy. This function returns a list of all windows currently displaying @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 current buffer. If the currently selected window displays +@var{buffer-or-name}, it will be the first in the list returned by +this function. The arguments @var{minibuf} and @var{all-frames} have the same meanings as in the function @code{next-window} (@pxref{Cyclic Window @@ -1676,7 +2057,7 @@ window and make it the current buffer. It is often used interactively return value is the buffer switched to. If @var{buffer-or-name} is @code{nil}, it defaults to the buffer -returned by @code{other-buffer} (@pxref{The Buffer List}). If +returned by @code{other-buffer} (@pxref{Buffer List}). If @var{buffer-or-name} is a string that is not the name of any existing buffer, this function creates a new buffer with that name; the new buffer's major mode is determined by the variable @code{major-mode} @@ -1684,19 +2065,52 @@ buffer's major mode is determined by the variable @code{major-mode} Normally, the specified buffer is put at the front of the buffer list---both the global buffer list and the selected frame's buffer -list (@pxref{The Buffer List}). However, this is not done if the +list (@pxref{Buffer List}). However, this is not done if the optional argument @var{norecord} is non-@code{nil}. -Sometimes, @code{switch-to-buffer} may be unable to display the buffer -in the selected window. This happens if the selected window is a -minibuffer window, or if the selected window is strongly dedicated to -its buffer (@pxref{Dedicated Windows}). In that case, the command -normally tries to display the buffer in some other window, by invoking -@code{pop-to-buffer} (see below). However, if the optional argument -@var{force-same-window} is non-@code{nil}, it signals an error -instead. +Sometimes, the selected window may not be suitable for displaying the +buffer. This happens if the selected window is a minibuffer window, or +if the selected window is strongly dedicated to its buffer +(@pxref{Dedicated Windows}). In such cases, the command normally tries +to display the buffer in some other window, by invoking +@code{pop-to-buffer} (see below). + +If the optional argument @var{force-same-window} is non-@code{nil} and +the selected window is not suitable for displaying the buffer, this +function always signals an error when called non-interactively. In +interactive use, if the selected window is a minibuffer window, this +function will try to use some other window instead. If the selected +window is strongly dedicated to its buffer, the option +@code{switch-to-buffer-in-dedicated-window} described next can be used +to proceed. @end deffn +@defopt switch-to-buffer-in-dedicated-window +This option, if non-@code{nil}, allows @code{switch-to-buffer} to +proceed when called interactively and the selected window is strongly +dedicated to its buffer. + +The following values are respected: + +@table @code +@item nil +Disallows switching and signals an error as in non-interactive use. + +@item prompt +Prompts the user whether to allow switching. + +@item pop +Invokes @code{pop-to-buffer} to proceed. + +@item t +Marks the selected window as non-dedicated and proceeds. +@end table + +When called non-interactively, @code{switch-to-buffer} always signals an +error when the selected window is dedicated to its buffer and +@var{force-same-window} is non-@code{nil}. +@end defopt + By default, @code{switch-to-buffer} shows the buffer at its position of @code{point}. This behavior can be tuned using the following option. @@ -1762,7 +2176,7 @@ possible (@pxref{Input Focus}). The return value is the buffer that was switched to. If @var{buffer-or-name} is @code{nil}, it defaults to the buffer -returned by @code{other-buffer} (@pxref{The Buffer List}). If +returned by @code{other-buffer} (@pxref{Buffer List}). If @var{buffer-or-name} is a string that is not the name of any existing buffer, this function creates a new buffer with that name; the new buffer's major mode is determined by the variable @code{major-mode} @@ -1842,7 +2256,10 @@ The constant @code{display-buffer-fallback-action}. @noindent Each action function is called in turn, passing the buffer as the first argument and the combined action alist as the second argument, -until one of the functions returns non-@code{nil}. +until one of the functions returns non-@code{nil}. The caller can +pass @code{(allow-no-window . t)} as an element of the action alist to +indicate its readiness to handle the case of not displaying the +buffer in a window. The argument @var{action} can also have a non-@code{nil}, non-list value. This has the special meaning that the buffer should be @@ -1876,7 +2293,7 @@ corresponding display action to display the buffer. @defopt display-buffer-base-action The value of this option should be a display action. This option can -be used to define a ``standard'' display action for calls to +be used to define a standard display action for calls to @code{display-buffer}. @end defopt @@ -1902,7 +2319,7 @@ to another buffer (@pxref{Dedicated Windows}). It also fails if @end defun @defun display-buffer-reuse-window buffer alist -This function tries to ``display'' @var{buffer} by finding a window +This function tries to display @var{buffer} by finding a window that is already displaying it. If @var{alist} has a non-@code{nil} @code{inhibit-same-window} entry, @@ -1947,6 +2364,25 @@ the function specified in @code{pop-up-frame-function} is added to the newly created frame's parameters. @end defun +@defun display-buffer-use-some-frame buffer alist +This function tries to display @var{buffer} by trying to find a +frame that meets a predicate (by default any frame other than the +current frame). + +If this function chooses a window on another frame, it makes that frame +visible and, unless @var{alist} contains an @code{inhibit-switch-frame} +entry (@pxref{Choosing Window Options}), raises that frame if necessary. + +If @var{alist} has a non-nil @code{frame-predicate} entry, its value is a +function taking one argument (a frame), returning non-nil if the +frame is a candidate; this function replaces the default predicate. + +If @var{alist} has a non-@code{nil} @code{inhibit-same-window} entry, +the selected window is used; thus if the selected frame has a single +window, it is not used. + +@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 (typically one on the selected frame). @@ -1965,7 +2401,7 @@ adjust the window's height, use an entry whose @sc{car} is @item A number specifies the desired height of the new window. An integer -number specifies the number of lines of the window. A floating point +specifies the number of lines of the window. A floating-point number gives the fraction of the window's height with respect to the height of the frame's root window. @@ -1986,7 +2422,7 @@ To adjust the window's width, use an entry whose @sc{car} is @item A number specifies the desired width of the new window. An integer -number specifies the number of columns of the window. A floating point +specifies the number of columns of the window. A floating-point number gives the fraction of the window's width with respect to the width of the frame's root window. @@ -1996,6 +2432,13 @@ argument: the new window. The function is supposed to adjust the width of the window; its return value is ignored. @end itemize +If @var{alist} contains a @code{preserve-size} entry, Emacs will try to +preserve the size of the new window during future resize operations +(@pxref{Preserving Window Sizes}). The @sc{cdr} of that entry must be a +cons cell whose @sc{car}, if non-@code{nil}, means to preserve the width +of the window and whose @sc{cdr}, if non-@code{nil}, means to preserve +the height of the window. + This function can fail if no window splitting can be performed for some reason (e.g., if the selected frame has an @code{unsplittable} frame parameter; @pxref{Buffer Parameters}). @@ -2022,12 +2465,30 @@ specified by that entry will override any other window found by the methods above, even if that window never showed @var{buffer} before. @end defun +@defun display-buffer-at-bottom buffer alist +This function tries to display @var{buffer} in a window at the bottom +of the selected frame. + +This either splits the window at the bottom of the frame or the +frame's root window, or reuses an existing window at the bottom of the +selected frame. +@end defun + @defun display-buffer-use-some-window buffer alist This function tries to display @var{buffer} by choosing an existing window and displaying the buffer in that window. It can fail if all windows are dedicated to another buffer (@pxref{Dedicated Windows}). @end defun +@defun display-buffer-no-window buffer alist +If @var{alist} has a non-@code{nil} @code{allow-no-window} entry, then +this function does not display @code{buffer}. This allows to override +the default action and avoid displaying the buffer. It is assumed that +when the caller specifies a non-@code{nil} @code{allow-no-window} value +it can handle a @code{nil} value returned from @code{display-buffer} in +this case. +@end defun + To illustrate the use of action functions, consider the following example. @@ -2056,7 +2517,7 @@ buffer there. If all these steps fail, it will proceed using whatever (provided *foo* was put by @code{display-buffer} there before) or a popped-up window as follows: If the window is part of a vertical combination, it will set its height to ten lines. Note that if, instead -of the number ``10'', we specified the function +of the number 10, we specified the function @code{fit-window-to-buffer}, @code{display-buffer} would come up with a one-line window to fit the empty buffer. If the window is part of a horizontal combination, it sets its width to 40 columns. Whether a new @@ -2066,7 +2527,7 @@ the window split and the values of and @code{split-width-threshold} (@pxref{Choosing Window Options}). Now suppose we combine this call with a preexisting setup for -`display-buffer-alist' as follows. +@code{display-buffer-alist} as follows. @example @group @@ -2097,7 +2558,7 @@ window below the selected window. selected one is dedicated to its buffer, @code{display-buffer} will proceed as described in the previous example. Note, however, that when it tries to adjust the height of any reused or popped-up window, it will -in any case try to set its number of lines to ``5'' since that value +in any case try to set its number of lines to 5 since that value overrides the corresponding specification in the @var{action} argument of @code{display-buffer}. @@ -2168,6 +2629,21 @@ least that many columns. If the value is @code{nil}, that means not to split this way. @end defopt +@defopt even-window-sizes +This variable, if non-nil, causes @code{display-buffer} to even window +sizes whenever it reuses an existing window and that window is adjacent +to the selected one. + +If its value is @code{width-only}, sizes are evened only if the reused +window is on the left or right of the selected one and the selected +window is wider than the reused one. If its value is @code{height-only} +sizes are evened only if the reused window is above or beneath the +selected window and the selected window is higher than the reused one. +Any other non-@code{nil} value means to even sizes in any of these cases +provided the selected window is larger than the reused one in the sense +of their combination. +@end defopt + @defopt pop-up-frames If the value of this variable is non-@code{nil}, that means @code{display-buffer} may display buffers by making new frames. The @@ -2306,9 +2782,9 @@ or killed, or has been already shown by a recent invocation of 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}), trying to skip buffers that are already shown in another -window on that frame. +from the buffer list of the frame @var{window} appears on (@pxref{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 @@ -2319,7 +2795,7 @@ defaults to the selected one. 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}). +of the frame @var{window} appears on (@pxref{Buffer List}). @end deffn By default @code{switch-to-prev-buffer} and @code{switch-to-next-buffer} @@ -2366,7 +2842,7 @@ called when a buffer gets killed, deletes the window in case (1) and behaves like @code{delete-windows-on} otherwise. @c FIXME: Does replace-buffer-in-windows _delete_ a window in case (1)? - When @code{bury-buffer} (@pxref{The Buffer List}) operates on the + When @code{bury-buffer} (@pxref{Buffer List}) operates on the selected window (which shows the buffer that shall be buried), it handles case (2) by calling @code{frame-auto-hide-function} (@pxref{Quitting Windows}) to deal with the selected frame. The other @@ -2405,7 +2881,7 @@ buffer is shown on a separate frame, you might want to call hand, a window has been reused for displaying the buffer, you might 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 +Finally, you might want to either bury (@pxref{Buffer List}) or kill (@pxref{Killing Buffers}) the window's buffer. The following command uses information on how the window for @@ -2487,11 +2963,12 @@ one window that should be either quit, or whose buffer should be buried. The function specified by this option is called to automatically hide 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 -to bury. It is also called by @code{quit-restore-window} (see above) -when the frame of the window to quit has been specially created for -displaying that window's buffer and the buffer is not killed. +The function specified here is called by @code{bury-buffer} +(@pxref{Buffer List}) when the selected window is dedicated and shows +the buffer to bury. It is also called by @code{quit-restore-window} +(see above) when the frame of the window to quit has been specially +created for displaying that window's buffer and the buffer is not +killed. The default is to call @code{iconify-frame} (@pxref{Visibility of Frames}). Alternatively, you may specify either @code{delete-frame} @@ -2548,7 +3025,7 @@ window's buffer) if that window were selected. The default for When @var{window} is the selected window, the value returned is the value of point in that window's buffer. Strictly speaking, it would be -more correct to return the ``top-level'' value of point, outside of any +more correct to return the top-level value of point, outside of any @code{save-excursion} forms. But that value is hard to find. @end defun @@ -2645,7 +3122,7 @@ screen. If this does place point off screen, the display routines move point to the left margin on the middle line in the window. For example, if point @w{is 1} and you set the start of the window -@w{to 37}, the start of the next line, point will be ``above'' the top +@w{to 37}, the start of the next line, point will be above the top of the window. The display routines will automatically move point if it is still 1 when redisplay occurs. Here is an example: @@ -2697,12 +3174,14 @@ position that works well with point, and thus @var{position} is not used. @defun pos-visible-in-window-p &optional position window partially This function returns non-@code{nil} if @var{position} is within the range of text currently visible on the screen in @var{window}. It -returns @code{nil} if @var{position} is scrolled vertically out of view. -Locations that are partially obscured are not considered visible unless -@var{partially} is non-@code{nil}. The argument @var{position} defaults -to the current position of point in @var{window}; @var{window}, to the -selected window. If @var{position} is @code{t}, that means to check the -last visible position in @var{window}. +returns @code{nil} if @var{position} is scrolled vertically out of +view. Locations that are partially obscured are not considered +visible unless @var{partially} is non-@code{nil}. The argument +@var{position} defaults to the current position of point in +@var{window}; @var{window} defaults to the selected window. If +@var{position} is @code{t}, that means to check either the first +visible position of the last screen line in @var{window}, or the +end-of-buffer position, whichever comes first. This function considers only vertical scrolling. If @var{position} is out of view only because @var{window} has been scrolled horizontally, @@ -2952,7 +3431,7 @@ only if point is already on that position do they signal an error. @cindex centering point This function scrolls the text in the selected window so that point is displayed at a specified vertical position within the window. It does -not ``move point'' with respect to the text. +not move point with respect to the text. If @var{count} is a non-negative number, that puts the line containing point @var{count} lines down from the top of the window. If @@ -3087,8 +3566,8 @@ times the normal character width. How many characters actually 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 @@ -3208,33 +3687,28 @@ is off the screen due to horizontal scrolling: @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 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 section describes functions that report the position of a window. +Most of these functions report positions relative to an origin at the +native position of the window's frame (@pxref{Frame Geometry}). Some +functions report positions relative to the origin of the display of the +window's frame. In any case, the origin has the coordinates (0, 0) and +X and Y coordinates increase rightward and downward +respectively. + + For the following functions, 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 the default character specified by +the frame's default font (@pxref{Frame Font}). + +@defun window-edges &optional window body absolute pixelwise 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. @@ -3246,49 +3720,78 @@ 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. -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 +Note that these are the actual outer edges of the window, including any +header line, mode line, scroll bar, fringes, window divider 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 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. +If the optional argument @var{body} is @code{nil}, this means to +return the edges corresponding to the total size of @var{window}. +@var{body} non-@code{nil} means to return the edges of @var{window}'s +body (aka text area). If @var{body} is non-@code{nil}, @var{window} +must specify a live window. + +If the optional argument @var{absolute} is @code{nil}, this means to +return edges relative to the native position of @var{window}'s frame. +@var{absolute} non-@code{nil} means to return coordinates relative to +the origin (0, 0) of @var{window}'s display. On non-graphical systems +this argument has no effect. + +If the optional argument @var{pixelwise} is @code{nil}, this means to +return the coordinates in terms of the default character width and +height of @var{window}'s frame (@pxref{Frame Font}), rounded if +necessary. @var{pixelwise} non-@code{nil} means to return the +coordinates in pixels. Note that the pixel specified by @var{right} and +@var{bottom} is immediately outside of these edges. If @var{absolute} +is non-@code{nil}, @var{pixelwise} is implicitly non-@code{nil} too. @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}. +@defun window-body-edges &optional window +This function returns the edges of @var{window}'s body (@pxref{Window +Sizes}). Calling @code{(window-body-edges window)} is equivalent to +calling @code{(window-edges window t)}, see above. @end defun +@comment The following two functions are confusing and hardly used. +@ignore @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}. +This function returns the leftmost column of @var{window}. This value +equals the @var{left} entry in the list returned by @code{(window-edges +window)} minus the number of columns occupied by the internal border of +@var{window}'s frame. +@end defun + +@defun window-top-line &optional window +This function returns the topmost row of @var{window}. This value is +equal to the @var{top} entry in the list returned by @code{(window-edges +window)} minus the number of lines occupied by the internal border of +@var{window}'s frame. @end defun +@end ignore 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 +This function returns the live window at the coordinates @var{x} and +@var{y} given in default character sizes (@pxref{Frame Font}) relative +to the native position of @var{frame} (@pxref{Frame Geometry}). + +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 @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. +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. +. @var{y})}, where @var{x} and @var{y} are given in default character +sizes (@pxref{Frame Font}) relative to the native position of +@var{window}'s frame (@pxref{Frame Geometry}). If there is no window at the specified position, the return value is @code{nil} . Otherwise, the return value is one of the following: @@ -3306,6 +3809,14 @@ The coordinates are in the mode line of @var{window}. @item header-line The coordinates are in the header line of @var{window}. +@item right-divider +The coordinates are in the divider separating @var{window} from a +window on the right. + +@item bottom-divider +The coordinates are in the divider separating @var{window} from a +window beneath. + @item vertical-line The coordinates are in the vertical line between @var{window} and its neighbor to the right. This value occurs only if the window doesn't @@ -3331,42 +3842,103 @@ argument because it always uses the frame that @var{window} is on. 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''. +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. +@var{window}. Calling @code{(window-pixel-edges window)} is equivalent +to calling @code{(window-edges window nil nil t)}, see above. +@end defun -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. +@comment The following two functions are confusing and hardly used. +@ignore +@defun window-pixel-left &optional window +This function returns the left pixel edge of window @var{window}. This +value equals the @var{left} entry in the list returned by +@code{(window-pixel-edges window)} minus the number of pixels occupied +by the internal border of @var{window}'s frame. @var{window} must be a +valid window and defaults to the selected one. +@end defun + +@defun window-pixel-top &optional window +This function returns the top pixel edge of window @var{window}. This +value is equal to the @var{top} entry in the list returned by +@code{(window-pixel-edges window)} minus the number of pixels occupied +by the internal border of @var{window}'s frame. @var{window} must be a +valid window and defaults to the selected one. @end defun +@end ignore -@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. +@defun window-body-pixel-edges &optional window +This function returns the pixel edges of @var{window}'s body. Calling +@code{(window-body-pixel-edges window)} is equivalent to calling +@code{(window-edges window t nil t)}, see above. @end defun - The following functions return window positions in pixels, relative -to the display screen rather than the frame: + The following functions return window positions in pixels, relative to +the origin of the display screen rather than that of 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. +This function returns the pixel coordinates of @var{WINDOW} relative to +an origin at (0, 0) of the display of @var{window}'s frame. Calling +@code{(window-absolute-pixel-edges)} is equivalent to calling +@code{(window-edges window nil t t)}, see above. +@end defun + +@defun window-absolute-body-pixel-edges &optional window +This function returns the pixel coordinates of @var{WINDOW}'s body +relative to an origin at (0, 0) of the display of @var{window}'s frame. +Calling @code{(window-absolute-body-pixel-edges window)} is equivalent +to calling @code{(window-edges window t t t)}, see above. + +Combined with @code{set-mouse-absolute-pixel-position}, this function +can be used to move the mouse pointer to an arbitrary buffer position +visible in some window: + +@example +@group +(let ((edges (window-absolute-body-pixel-edges)) + (position (pos-visible-in-window-p nil nil t))) + (x-set-mouse-absolute-pixel-position + (+ (nth 0 edges) (nth 0 position)) + (+ (nth 1 edges) (nth 1 position)))) +@end group +@end example + +On a graphical terminal this form ``warps'' the mouse cursor to the +upper left corner of the glyph at the selected window's point. A +position calculated this way can be also used to show a tooltip window +there. @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. +The following function returns the screen coordinates of a buffer +position visible in a window: + +@defun window-absolute-pixel-position &optional position window +If the buffer position @var{position} is visible in window @var{window}, +this function returns the display coordinates of the upper/left corner +of the glyph at @var{position}. The return value is a cons of the X- +and Y-coordinates of that corner, relative to an origin at (0, 0) of +@var{window}'s display. It returns @code{nil} if @var{position} is not +visible in @var{window}. + +@var{window} must be a live window and defaults to the selected +window. @var{position} defaults to the value of @code{window-point} +of @var{window}. + +This means that in order to move the mouse pointer to the position of +point in the selected window, it's sufficient to write: + +@example +@group +(let ((position (window-absolute-pixel-position))) + (set-mouse-absolute-pixel-position + (car position) (cdr position))) +@end group +@end example @end defun + @node Window Configurations @section Window Configurations @cindex window configurations @@ -3374,7 +3946,7 @@ the display screen. @var{window} must specify a live window. A @dfn{window configuration} records the entire layout of one frame---all windows, their sizes, which buffers they contain, how those -buffers are scrolled, and their values of point and the mark; also their +buffers are scrolled, and their value of point; also their fringes, margins, and scroll bar settings. It also includes the value of @code{minibuffer-scroll-window}. As a special exception, the window configuration does not record the value of point in the selected window @@ -3450,13 +4022,13 @@ This function returns @code{t} if @var{object} is a window configuration. @defun compare-window-configurations config1 config2 This function compares two window configurations as regards the -structure of windows, but ignores the values of point and mark and the +structure of windows, but ignores the values of point and the saved scrolling positions---it can return @code{t} even if those aspects differ. The function @code{equal} can also compare two window configurations; it regards configurations as unequal if they differ in any respect, even a -saved point or mark. +saved point. @end defun @defun window-configuration-frame config @@ -3477,6 +4049,7 @@ 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). +@cindex window state @defun window-state-get &optional window writable This function returns the state of @var{window} as a Lisp object. The argument @var{window} must be a valid window and defaults to the root @@ -3498,11 +4071,13 @@ 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{state} should be the state of a window returned by an -earlier invocation of @code{window-state-get}, see above. The optional -argument @var{window} must specify a live window and defaults to the -selected one. +This function puts the window state @var{state} into @var{window}. +The argument @var{state} should be the state of a window returned by +an earlier invocation of @code{window-state-get}, see above. The +optional argument @var{window} can be either a live window or an +internal window (@pxref{Windows and Frames}) and defaults to the +selected one. If @var{window} is not live, it is replaced by a live +window before putting @var{state} into it. If the optional argument @var{ignore} is non-@code{nil}, it means to ignore minimum window sizes and fixed-size restrictions. If @var{ignore} @@ -3622,6 +4197,15 @@ 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{preserved-size} +This parameter specifies a buffer, a direction where @code{nil} means +vertical and @code{t} horizontal, and a size in pixels. If this window +displays the specified buffer and its size in the indicated direction +equals the size specified by this parameter, then Emacs will try to +preserve the size of this window in the indicated direction. This +parameter is installed and updated by the function +@code{window-preserve-size} (@pxref{Preserving Window Sizes}). + @item @code{quit-restore} This parameter is installed by the buffer display functions (@pxref{Choosing Window}) and consulted by @code{quit-restore-window} |