view lispref/windows.texi @ 10235:ff7189e5e459

(byte-compile-dest-file): New variable. (byte-compile-file): Bind that var, early on. (byte-compile-dynamic): New variable. (byte-compile-dynamic-docstrings): New variable. (byte-compile-close-variables): Bind byte-compile-dynamic, byte-compile-dynamic-docstrings, and byte-compiler-compatibility. (byte-compile-file): Call normal-mode, not set-auto-mode. (byte-compile-output-docform): New arguments PREFACE, NAME, SPECINDEX, QUOTED. Callers changed. Output doc strings as references to the .elc file itself, using #@ and #$ constructs. (byte-compile-output-as-comment): New function. (byte-compile-insert-header): Don't save-excursion. Insert at point, and move point. Insert extra newline at end. (byte-compile-from-buffer): Insert the header before compilation.

+
鐃緒申��申鐃緒申@c -*-texinfo-*-
+
鐃緒申��申鐃緒申@c This is part of the GNU Emacs Lisp Reference Manual.
+
鐃緒申��申鐃緒申@c Copyright (C) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc. 
+
鐃緒申��申鐃緒申@c See the file elisp.texi for copying conditions.
+
鐃緒申��申鐃緒申@setfilename ../info/windows
+
鐃緒申��申鐃緒申@node Windows, Frames, Buffers, Top
+
鐃緒申��申鐃緒申@chapter Windows
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  This chapter describes most of the functions and variables related to
+
鐃緒申��申鐃緒申Emacs windows.  See @ref{Display}, for information on how text is
+
鐃緒申��申鐃緒申displayed in windows.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@menu
+
鐃緒申��申鐃緒申* Basic Windows::          Basic information on using windows.
+
鐃緒申��申鐃緒申* Splitting Windows::      Splitting one window into two windows.
+
鐃緒申��申鐃緒申* Deleting Windows::       Deleting a window gives its space to other windows.
+
鐃緒申��申鐃緒申* Selecting Windows::      The selected window is the one that you edit in.
+
鐃緒申��申鐃緒申* Cyclic Window Ordering:: Moving around the existing windows.
+
鐃緒申��申鐃緒申* Buffers and Windows::    Each window displays the contents of a buffer.
+
鐃緒申��申鐃緒申* Displaying Buffers::     Higher-lever functions for displaying a buffer
+
鐃緒申��申鐃緒申                             and choosing a window for it.
+
鐃緒申��申鐃緒申* Choosing Window::	   How to choose a window for displaying a buffer.
+
鐃緒申��申鐃緒申* Window Point::           Each window has its own location of point.
+
鐃緒申��申鐃緒申* Window Start::           The display-start position controls which text
+
鐃緒申��申鐃緒申                             is on-screen in the window. 
+
鐃緒申��申鐃緒申* Vertical Scrolling::     Moving text up and down in the window.
+
鐃緒申��申鐃緒申* Horizontal Scrolling::   Moving text sideways on the window.
+
鐃緒申��申鐃緒申* Size of Window::         Accessing the size of a window.
+
鐃緒申��申鐃緒申* Resizing Windows::       Changing the size of a window.
+
鐃緒申��申鐃緒申* Coordinates and Windows::Converting coordinates to windows.
+
鐃緒申��申鐃緒申* Window Configurations::  Saving and restoring the state of the screen.
+
鐃緒申��申鐃緒申@end menu
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@node Basic Windows
+
鐃緒申��申鐃緒申@section Basic Concepts of Emacs Windows
+
鐃緒申��申鐃緒申@cindex window
+
鐃緒申��申鐃緒申@cindex selected window
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  A @dfn{window} is the physical area of the screen in which a buffer is
+
鐃緒申��申鐃緒申displayed.  The term is also used to refer to a Lisp object that
+
鐃緒申��申鐃緒申represents that screen area in Emacs Lisp.  It should be
+
鐃緒申��申鐃緒申clear from the context which is meant.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  There is always at least one window in any frame.  In each frame, at
+
鐃緒申��申鐃緒申any time, one and only one window is designated as @dfn{selected within
+
鐃緒申��申鐃緒申the frame}.  The frame's cursor appears in that window.  There is also
+
鐃緒申��申鐃緒申one selected frame; and the window selected within that frame is
+
鐃緒申��申鐃緒申@dfn{the selected window}.  The selected window's buffer is usually the
+
鐃緒申��申鐃緒申current buffer (except when @code{set-buffer} has been used).
+
鐃緒申��申鐃緒申@xref{Current Buffer}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  For practical purposes, a window exists only while it is displayed on the
+
鐃緒申��申鐃緒申terminal.  Once removed from the display, the window is effectively
+
鐃緒申��申鐃緒申deleted and should not be used, @emph{even though there may still be
+
鐃緒申��申鐃緒申references to it} from other Lisp objects.  Restoring a saved window
+
鐃緒申��申鐃緒申configuration is the only way for a window no longer on the screen to
+
鐃緒申��申鐃緒申come back to life.  (@xref{Deleting Windows}.)
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  Each window has the following attributes:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@itemize @bullet
+
鐃緒申��申鐃緒申@item
+
鐃緒申��申鐃緒申containing frame
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@item 
+
鐃緒申��申鐃緒申window height
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@item 
+
鐃緒申��申鐃緒申window width
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@item 
+
鐃緒申��申鐃緒申window edges with respect to the screen or frame
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@item 
+
鐃緒申��申鐃緒申the buffer it displays
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@item 
+
鐃緒申��申鐃緒申position within the buffer at the upper left of the window
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@item 
+
鐃緒申��申鐃緒申amount of horizontal scrolling, in columns
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@item 
+
鐃緒申��申鐃緒申point
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@item 
+
鐃緒申��申鐃緒申the mark
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@item 
+
鐃緒申��申鐃緒申how recently the window was selected
+
鐃緒申��申鐃緒申@end itemize
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@cindex multiple windows
+
鐃緒申��申鐃緒申  Users create multiple windows so they can look at several buffers at
+
鐃緒申��申鐃緒申once.  Lisp libraries use multiple windows for a variety of reasons, but
+
鐃緒申��申鐃緒申most often to give different views of the same information.  In Rmail,
+
鐃緒申��申鐃緒申for example, you can move through a summary buffer in one window while
+
鐃緒申��申鐃緒申the other window shows messages one at a time as they are reached.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  The meaning of ``window'' in Emacs is similar to what it means in the
+
鐃緒申��申鐃緒申context of general-purpose window systems such as X, but not identical.
+
鐃緒申��申鐃緒申The X Window System subdivides the screen into X windows; Emacs uses one
+
鐃緒申��申鐃緒申or more X windows, called @dfn{frames} in Emacs terminology, and
+
鐃緒申��申鐃緒申subdivides each of them into (nonoverlapping) Emacs windows.  When you
+
鐃緒申��申鐃緒申use Emacs on an ordinary display terminal, Emacs subdivides the terminal
+
鐃緒申��申鐃緒申screen into Emacs windows.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@cindex terminal screen
+
鐃緒申��申鐃緒申@cindex screen of terminal
+
鐃緒申��申鐃緒申@cindex tiled windows
+
鐃緒申��申鐃緒申  Most window systems support arbitrarily located overlapping windows.
+
鐃緒申��申鐃緒申In contrast, Emacs windows are @dfn{tiled}; they never overlap, and
+
鐃緒申��申鐃緒申together they fill the whole screen or frame.  Because of the way
+
鐃緒申��申鐃緒申in which Emacs creates new windows and resizes them, you can't create
+
鐃緒申��申鐃緒申every conceivable tiling of windows on an Emacs frame.  @xref{Splitting
+
鐃緒申��申鐃緒申Windows}, and @ref{Size of Window}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  @xref{Display}, for information on how the contents of the
+
鐃緒申��申鐃緒申window's buffer are displayed in the window.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun windowp object
+
鐃緒申��申鐃緒申  This function returns @code{t} if @var{object} is a window.
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@node Splitting Windows
+
鐃緒申��申鐃緒申@section Splitting Windows
+
鐃緒申��申鐃緒申@cindex splitting windows
+
鐃緒申��申鐃緒申@cindex window splitting
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  The functions described here are the primitives used to split a window
+
鐃緒申��申鐃緒申into two windows.  Two higher level functions sometimes split a window,
+
鐃緒申��申鐃緒申but not always: @code{pop-to-buffer} and @code{display-buffer}
+
鐃緒申��申鐃緒申(@pxref{Displaying Buffers}).
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  The functions described here do not accept a buffer as an argument.
+
鐃緒申��申鐃緒申The two ``halves'' of the split window initially display the same buffer
+
鐃緒申��申鐃緒申previously visible in the window that was split.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@deffn Command split-window &optional window size horizontal
+
鐃緒申��申鐃緒申This function splits @var{window} into two windows.  The original
+
鐃緒申��申鐃緒申window @var{window} remains the selected window, but occupies only
+
鐃緒申��申鐃緒申part of its former screen area.  The rest is occupied by a newly created
+
鐃緒申��申鐃緒申window which is returned as the value of this function.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  If @var{horizontal} is non-@code{nil}, then @var{window} splits into
+
鐃緒申��申鐃緒申two side by side windows.  The original window @var{window} keeps the
+
鐃緒申��申鐃緒申leftmost @var{size} columns, and gives the rest of the columns to the
+
鐃緒申��申鐃緒申new window.  Otherwise, it splits into windows one above the other, and
+
鐃緒申��申鐃緒申@var{window} keeps the upper @var{size} lines and gives the rest of the
+
鐃緒申��申鐃緒申lines to the new window.  The original window is therefore the
+
鐃緒申��申鐃緒申left-hand or upper of the two, and the new window is the right-hand or
+
鐃緒申��申鐃緒申lower.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  If @var{window} is omitted or @code{nil}, then the selected window is
+
鐃緒申��申鐃緒申split.  If @var{size} is omitted or @code{nil}, then @var{window} is
+
鐃緒申��申鐃緒申divided evenly into two parts.  (If there is an odd line, it is
+
鐃緒申��申鐃緒申allocated to the new window.)  When @code{split-window} is called
+
鐃緒申��申鐃緒申interactively, all its arguments are @code{nil}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  The following example starts with one window on a screen that is 50
+
鐃緒申��申鐃緒申lines high by 80 columns wide; then the window is split.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@smallexample
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(setq w (selected-window))
+
鐃緒申��申鐃緒申     @result{} #<window 8 on windows.texi>
+
鐃緒申��申鐃緒申(window-edges)          ; @r{Edges in order:}
+
鐃緒申��申鐃緒申     @result{} (0 0 80 50)     ;   @r{left--top--right--bottom}
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申;; @r{Returns window created}
+
鐃緒申��申鐃緒申(setq w2 (split-window w 15))   
+
鐃緒申��申鐃緒申     @result{} #<window 28 on windows.texi>
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(window-edges w2)
+
鐃緒申��申鐃緒申     @result{} (0 15 80 50)    ; @r{Bottom window;}
+
鐃緒申��申鐃緒申                        ;   @r{top is line 15}
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(window-edges w)
+
鐃緒申��申鐃緒申     @result{} (0 0 80 15)     ; @r{Top window}
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end smallexample
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The screen looks like this:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@smallexample
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申         __________ 
+
鐃緒申��申鐃緒申        |          |  line 0  
+
鐃緒申��申鐃緒申        |    w     |
+
鐃緒申��申鐃緒申        |__________|
+
鐃緒申��申鐃緒申        |          |  line 15
+
鐃緒申��申鐃緒申        |    w2    |
+
鐃緒申��申鐃緒申        |__________|
+
鐃緒申��申鐃緒申                      line 50
+
鐃緒申��申鐃緒申 column 0   column 80
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end smallexample
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申Next, the top window is split horizontally:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@smallexample
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(setq w3 (split-window w 35 t))
+
鐃緒申��申鐃緒申     @result{} #<window 32 on windows.texi>
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(window-edges w3)
+
鐃緒申��申鐃緒申     @result{} (35 0 80 15)  ; @r{Left edge at column 35}
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(window-edges w)
+
鐃緒申��申鐃緒申     @result{} (0 0 35 15)   ; @r{Right edge at column 35}
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(window-edges w2)
+
鐃緒申��申鐃緒申     @result{} (0 15 80 50)  ; @r{Bottom window unchanged}
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end smallexample
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申Now, the screen looks like this:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@smallexample
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申     column 35
+
鐃緒申��申鐃緒申         __________ 
+
鐃緒申��申鐃緒申        |   |      |  line 0  
+
鐃緒申��申鐃緒申        | w |  w3  |
+
鐃緒申��申鐃緒申        |___|______|
+
鐃緒申��申鐃緒申        |          |  line 15
+
鐃緒申��申鐃緒申        |    w2    |
+
鐃緒申��申鐃緒申        |__________|
+
鐃緒申��申鐃緒申                      line 50
+
鐃緒申��申鐃緒申 column 0   column 80
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end smallexample
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申Normally, Emacs indicates the border between two side-by-side windows
+
鐃緒申��申鐃緒申with a scroll bar (@pxref{X Frame Parameters,Scroll Bars}) or @samp{|}
+
鐃緒申��申鐃緒申characters.  The display table can specify alternative border
+
鐃緒申��申鐃緒申characters; see @ref{Display Tables}.
+
鐃緒申��申鐃緒申@end deffn
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@deffn Command split-window-vertically size
+
鐃緒申��申鐃緒申This function splits the selected window into two windows, one above
+
鐃緒申��申鐃緒申the other, leaving the selected window with @var{size} lines.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申This function is simply an interface to @code{split-windows}.
+
鐃緒申��申鐃緒申Here is the complete function definition for it:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@smallexample
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(defun split-window-vertically (&optional arg)
+
鐃緒申��申鐃緒申  "Split current window into two windows, one above the other."
+
鐃緒申��申鐃緒申  (interactive "P")
+
鐃緒申��申鐃緒申  (split-window nil (and arg (prefix-numeric-value arg))))
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end smallexample
+
鐃緒申��申鐃緒申@end deffn
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@deffn Command split-window-horizontally size
+
鐃緒申��申鐃緒申This function splits the selected window into two windows
+
鐃緒申��申鐃緒申side-by-side, leaving the selected window with @var{size} columns.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申This function is simply an interface to @code{split-windows}.  Here is
+
鐃緒申��申鐃緒申the complete definition for @code{split-window-horizontally} (except for
+
鐃緒申��申鐃緒申part of the documentation string):
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@smallexample
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(defun split-window-horizontally (&optional arg)
+
鐃緒申��申鐃緒申  "Split selected window into two windows, side by side..."
+
鐃緒申��申鐃緒申  (interactive "P")
+
鐃緒申��申鐃緒申  (split-window nil (and arg (prefix-numeric-value arg)) t))
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end smallexample
+
鐃緒申��申鐃緒申@end deffn
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun one-window-p &optional no-mini all-frames
+
鐃緒申��申鐃緒申This function returns non-@code{nil} if there is only one window.  The
+
鐃緒申��申鐃緒申argument @var{no-mini}, if non-@code{nil}, means don't count the
+
鐃緒申��申鐃緒申minibuffer even if it is active; otherwise, the minibuffer window is
+
鐃緒申��申鐃緒申included, if active, in the total number of windows,  which is compared
+
鐃緒申��申鐃緒申against one.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The argument @var{all-frames} specifies which frames to consider.  Here
+
鐃緒申��申鐃緒申are the possible values and their meanings:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@table @asis
+
鐃緒申��申鐃緒申@item @code{nil}
+
鐃緒申��申鐃緒申Count the windows in the selected frame, plus the minibuffer used
+
鐃緒申��申鐃緒申by that frame even if it lies in some other frame.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@item @code{t}
+
鐃緒申��申鐃緒申Count all windows in all existing frames.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@item @code{visible}
+
鐃緒申��申鐃緒申Count all windows in all visible frames.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@item anything else
+
鐃緒申��申鐃緒申Count precisely the windows in the selected frame, and no others.
+
鐃緒申��申鐃緒申@end table
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@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.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  When you delete a window, the space it took up is given to one
+
鐃緒申��申鐃緒申adjacent sibling.  (In Emacs version 18, the space was divided evenly
+
鐃緒申��申鐃緒申among all the siblings.)
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@c Emacs 19 feature
+
鐃緒申��申鐃緒申@defun window-live-p window
+
鐃緒申��申鐃緒申This function returns @code{nil} if @var{window} is deleted, and
+
鐃緒申��申鐃緒申@code{t} otherwise.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@strong{Warning:} Erroneous information or fatal errors may result from
+
鐃緒申��申鐃緒申using a deleted window as if it were live.
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@deffn Command delete-window &optional window
+
鐃緒申��申鐃緒申This function removes @var{window} from the display.  If @var{window}
+
鐃緒申��申鐃緒申is omitted, then the selected window is deleted.  An error is signaled
+
鐃緒申��申鐃緒申if there is only one window when @code{delete-window} is called.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申This function returns @code{nil}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申When @code{delete-window} is called interactively, @var{window}
+
鐃緒申��申鐃緒申defaults to the selected window.
+
鐃緒申��申鐃緒申@end deffn
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@deffn Command delete-other-windows &optional window
+
鐃緒申��申鐃緒申This function makes @var{window} the only window on its frame, by
+
鐃緒申��申鐃緒申deleting the other windows in that frame.  If @var{window} is omitted or
+
鐃緒申��申鐃緒申@code{nil}, then the selected window is used by default.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The result is @code{nil}.
+
鐃緒申��申鐃緒申@end deffn
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@deffn Command delete-windows-on buffer &optional frame
+
鐃緒申��申鐃緒申This function deletes all windows showing @var{buffer}.  If there are
+
鐃緒申��申鐃緒申no windows showing @var{buffer}, it does nothing.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@code{delete-windows-on} operates frame by frame.  If a frame has
+
鐃緒申��申鐃緒申several windows showing different buffers, then those showing
+
鐃緒申��申鐃緒申@var{buffer} are removed, and the others expand to fill the space.  If
+
鐃緒申��申鐃緒申all windows in some frame are showing @var{buffer} (including the case
+
鐃緒申��申鐃緒申where there is only one window), then the frame reverts to having a
+
鐃緒申��申鐃緒申single window showing another buffer chosen with @code{other-buffer}.
+
鐃緒申��申鐃緒申@xref{The Buffer List}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The argument @var{frame} controls which frames to operate on:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@itemize @bullet
+
鐃緒申��申鐃緒申@item
+
鐃緒申��申鐃緒申If it is @code{nil}, operate on the selected frame.
+
鐃緒申��申鐃緒申@item
+
鐃緒申��申鐃緒申If it is @code{t}, operate on all frames.
+
鐃緒申��申鐃緒申@item
+
鐃緒申��申鐃緒申If it is @code{visible}, operate on all visible frames.
+
鐃緒申��申鐃緒申@item
+
鐃緒申��申鐃緒申If it is a frame, operate on that frame.
+
鐃緒申��申鐃緒申@end itemize
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申This function always returns @code{nil}.
+
鐃緒申��申鐃緒申@end deffn
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@node Selecting Windows
+
鐃緒申��申鐃緒申@section Selecting Windows
+
鐃緒申��申鐃緒申@cindex selecting windows
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  When a window is selected, the buffer in the window becomes the current
+
鐃緒申��申鐃緒申buffer, and the cursor will appear in it.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun selected-window
+
鐃緒申��申鐃緒申This function returns the selected window.  This is the window in
+
鐃緒申��申鐃緒申which the cursor appears and to which many commands apply.
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun select-window window
+
鐃緒申��申鐃緒申This function makes @var{window} the selected window.  The cursor then
+
鐃緒申��申鐃緒申appears in @var{window} (on redisplay).  The buffer being displayed in
+
鐃緒申��申鐃緒申@var{window} is immediately designated the current buffer.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The return value is @var{window}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@example
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(setq w (next-window))
+
鐃緒申��申鐃緒申(select-window w)
+
鐃緒申��申鐃緒申     @result{} #<window 65 on windows.texi>
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end example
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@cindex finding windows
+
鐃緒申��申鐃緒申  The following functions choose one of the windows on the screen,
+
鐃緒申��申鐃緒申offering various criteria for the choice.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun get-lru-window &optional frame
+
鐃緒申��申鐃緒申This function returns the window least recently ``used'' (that is,
+
鐃緒申��申鐃緒申selected).  The selected window is always the most recently used window.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The selected window can be the least recently used window if it is the
+
鐃緒申��申鐃緒申only window.  A newly created window becomes the least recently used
+
鐃緒申��申鐃緒申window until it is selected.  A minibuffer window is never a candidate.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The argument @var{frame} controls which windows are considered.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@itemize @bullet
+
鐃緒申��申鐃緒申@item
+
鐃緒申��申鐃緒申If it is @code{nil}, consider windows on the selected frame.
+
鐃緒申��申鐃緒申@item
+
鐃緒申��申鐃緒申If it is @code{t}, consider windows on all frames.
+
鐃緒申��申鐃緒申@item
+
鐃緒申��申鐃緒申If it is @code{visible}, consider windows on all visible frames.
+
鐃緒申��申鐃緒申@item
+
鐃緒申��申鐃緒申If it is a frame, consider windows on that frame.
+
鐃緒申��申鐃緒申@end itemize
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun get-largest-window &optional frame
+
鐃緒申��申鐃緒申This function returns the window with the largest area (height times
+
鐃緒申��申鐃緒申width).  If there are no side-by-side windows, then this is the window
+
鐃緒申��申鐃緒申with the most lines.  A minibuffer window is never a candidate.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If there are two windows of the same size, then the function returns
+
鐃緒申��申鐃緒申the window that is first in the cyclic ordering of windows (see
+
鐃緒申��申鐃緒申following section), starting from the selected window.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The argument @var{frame} controls which set of windows are
+
鐃緒申��申鐃緒申considered.  See @code{get-lru-window}, above.
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@node Cyclic Window Ordering
+
鐃緒申��申鐃緒申@comment  node-name,  next,  previous,  up
+
鐃緒申��申鐃緒申@section Cyclic Ordering of Windows
+
鐃緒申��申鐃緒申@cindex 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
+
鐃緒申��申鐃緒申the next window, it moves through all the windows on the screen in a
+
鐃緒申��申鐃緒申specific cyclic order.  For any given configuration of windows, this
+
鐃緒申��申鐃緒申order never varies.  It is called the @dfn{cyclic ordering of windows}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  This ordering generally goes from top to bottom, and from left to
+
鐃緒申��申鐃緒申right.  But it may go down first or go right first, depending on the
+
鐃緒申��申鐃緒申order in which the windows were split.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  If the first split was vertical (into windows one above each other),
+
鐃緒申��申鐃緒申and then the subwindows were split horizontally, then the ordering is
+
鐃緒申��申鐃緒申left to right in the top of the frame, and then left to right in the
+
鐃緒申��申鐃緒申next lower part of the frame, and so on.  If the first split was
+
鐃緒申��申鐃緒申horizontal, the ordering is top to bottom in the left part, and so on.
+
鐃緒申��申鐃緒申In general, within each set of siblings at any level in the window tree,
+
鐃緒申��申鐃緒申the order is left to right, or top to bottom.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun next-window &optional window minibuf all-frames
+
鐃緒申��申鐃緒申@cindex minibuffer window
+
鐃緒申��申鐃緒申This function returns the window following @var{window} in the cyclic
+
鐃緒申��申鐃緒申ordering of windows.  This is the window that @kbd{C-x o} would select
+
鐃緒申��申鐃緒申if typed when @var{window} is selected.  If @var{window} is the only
+
鐃緒申��申鐃緒申window visible, then this function returns @var{window}.  If omitted,
+
鐃緒申��申鐃緒申@var{window} defaults to the selected window.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The value of the argument @var{minibuf} determines whether the
+
鐃緒申��申鐃緒申minibuffer is included in the window order.  Normally, when
+
鐃緒申��申鐃緒申@var{minibuf} is @code{nil}, the minibuffer is included if it is
+
鐃緒申��申鐃緒申currently active; this is the behavior of @kbd{C-x o}.  (The minibuffer
+
鐃緒申��申鐃緒申window is active while the minibuffer is in use.  @xref{Minibuffers}.)
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If @var{minibuf} is @code{t}, then the cyclic ordering includes the
+
鐃緒申��申鐃緒申minibuffer window even if it is not active.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If @var{minibuf} is neither @code{t} nor @code{nil}, then the minibuffer
+
鐃緒申��申鐃緒申window is not included even if it is active.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The argument @var{all-frames} specifies which frames to consider.  Here
+
鐃緒申��申鐃緒申are the possible values and their meanings:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@table @asis
+
鐃緒申��申鐃緒申@item @code{nil}
+
鐃緒申��申鐃緒申Consider all the windows in @var{window}'s frame, plus the minibuffer
+
鐃緒申��申鐃緒申used by that frame even if it lies in some other frame.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@item @code{t}
+
鐃緒申��申鐃緒申Consider all windows in all existing frames.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@item @code{visible}
+
鐃緒申��申鐃緒申Consider all windows in all visible frames.  (To get useful results, you
+
鐃緒申��申鐃緒申must ensure @var{window} is in a visible frame.)
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@item anything else
+
鐃緒申��申鐃緒申Consider precisely the windows in @var{window}'s frame, and no others.
+
鐃緒申��申鐃緒申@end table
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申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
+
鐃緒申��申鐃緒申@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
+
鐃緒申��申鐃緒申include in the cycle, as in @code{next-window}.
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@deffn Command other-window count
+
鐃緒申��申鐃緒申This function selects the @var{count}th following window in the cyclic
+
鐃緒申��申鐃緒申order.  If count is negative, then it selects the @minus{}@var{count}th
+
鐃緒申��申鐃緒申preceding window.  It returns @code{nil}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申In an interactive call, @var{count} is the numeric prefix argument.
+
鐃緒申��申鐃緒申@end deffn
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@c Emacs 19 feature
+
鐃緒申��申鐃緒申@defun walk-windows proc &optional minibuf all-frames
+
鐃緒申��申鐃緒申This function cycles through all windows, calling @code{proc}
+
鐃緒申��申鐃緒申once for each window with the window as its sole argument.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The optional arguments @var{minibuf} and @var{all-frames} specify the
+
鐃緒申��申鐃緒申set of windows to include in the scan.  See @code{next-window}, above,
+
鐃緒申��申鐃緒申for details.
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@node Buffers and Windows
+
鐃緒申��申鐃緒申@section Buffers and Windows
+
鐃緒申��申鐃緒申@cindex examining windows
+
鐃緒申��申鐃緒申@cindex windows, controlling precisely
+
鐃緒申��申鐃緒申@cindex buffers, controlled in windows
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  This section describes low-level functions to examine windows or to
+
鐃緒申��申鐃緒申display buffers in windows in a precisely controlled fashion.
+
鐃緒申��申鐃緒申@iftex
+
鐃緒申��申鐃緒申See the following section for
+
鐃緒申��申鐃緒申@end iftex
+
鐃緒申��申鐃緒申@ifinfo
+
鐃緒申��申鐃緒申@xref{Displaying Buffers}, for
+
鐃緒申��申鐃緒申@end ifinfo
+
鐃緒申��申鐃緒申related functions that find a window to use and specify a buffer for it.
+
鐃緒申��申鐃緒申The functions described there are easier to use than these, but they
+
鐃緒申��申鐃緒申employ heuristics in choosing or creating a window; use these functions
+
鐃緒申��申鐃緒申when you need complete control.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun set-window-buffer window buffer-or-name
+
鐃緒申��申鐃緒申This function makes @var{window} display @var{buffer-or-name} as its
+
鐃緒申��申鐃緒申contents.  It returns @code{nil}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@example
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(set-window-buffer (selected-window) "foo")
+
鐃緒申��申鐃緒申     @result{} nil
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end example
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun window-buffer &optional window
+
鐃緒申��申鐃緒申This function returns the buffer that @var{window} is displaying.  If
+
鐃緒申��申鐃緒申@var{window} is omitted, this function returns the buffer for the
+
鐃緒申��申鐃緒申selected window.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@example
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(window-buffer)
+
鐃緒申��申鐃緒申     @result{} #<buffer windows.texi>
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end example
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun get-buffer-window buffer-or-name &optional all-frames
+
鐃緒申��申鐃緒申This function returns a window currently 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}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The argument @var{all-frames} controls which windows to consider.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@itemize @bullet
+
鐃緒申��申鐃緒申@item
+
鐃緒申��申鐃緒申If it is @code{nil}, consider windows on the selected frame.
+
鐃緒申��申鐃緒申@item
+
鐃緒申��申鐃緒申If it is @code{t}, consider windows on all frames.
+
鐃緒申��申鐃緒申@item
+
鐃緒申��申鐃緒申If it is @code{visible}, consider windows on all visible frames.
+
鐃緒申��申鐃緒申@item
+
鐃緒申��申鐃緒申If it is a frame, consider windows on that frame.
+
鐃緒申��申鐃緒申@end itemize
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@deffn Command replace-buffer-in-windows buffer
+
鐃緒申��申鐃緒申This function replaces @var{buffer} with some other buffer in all
+
鐃緒申��申鐃緒申windows displaying it.  The other buffer used is chosen with
+
鐃緒申��申鐃緒申@code{other-buffer}.  In the usual applications of this function, you
+
鐃緒申��申鐃緒申don't care which other buffer is used; you just want to make sure that
+
鐃緒申��申鐃緒申@var{buffer} is no longer displayed.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申This function returns @code{nil}.
+
鐃緒申��申鐃緒申@end deffn
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@node Displaying Buffers
+
鐃緒申��申鐃緒申@section Displaying Buffers in Windows
+
鐃緒申��申鐃緒申@cindex switching to a buffer
+
鐃緒申��申鐃緒申@cindex displaying a buffer
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  In this section we describe convenient functions that choose a window
+
鐃緒申��申鐃緒申automatically and use it to display a specified buffer.  These functions
+
鐃緒申��申鐃緒申can also split an existing window in certain circumstances.  We also
+
鐃緒申��申鐃緒申describe variables that parameterize the heuristics used for choosing a
+
鐃緒申��申鐃緒申window.
+
鐃緒申��申鐃緒申@iftex
+
鐃緒申��申鐃緒申See the preceding section for
+
鐃緒申��申鐃緒申@end iftex
+
鐃緒申��申鐃緒申@ifinfo
+
鐃緒申��申鐃緒申@xref{Buffers and Windows}, for
+
鐃緒申��申鐃緒申@end ifinfo
+
鐃緒申��申鐃緒申low-level functions that give you more precise control.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  Do not use the functions in this section in order to make a buffer
+
鐃緒申��申鐃緒申current so that a Lisp program can access or modify it; they are too
+
鐃緒申��申鐃緒申drastic for that purpose, since they change the display of buffers in
+
鐃緒申��申鐃緒申windows, which is gratuitous and will surprise the user.  Instead, use
+
鐃緒申��申鐃緒申@code{set-buffer} (@pxref{Current Buffer}) and @code{save-excursion}
+
鐃緒申��申鐃緒申(@pxref{Excursions}), which designate buffers as current for programmed
+
鐃緒申��申鐃緒申access without affecting the display of buffers in windows.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@deffn Command switch-to-buffer buffer-or-name &optional norecord
+
鐃緒申��申鐃緒申This function makes @var{buffer-or-name} the current buffer, and also
+
鐃緒申��申鐃緒申displays the buffer in the selected window.  This means that a human can
+
鐃緒申��申鐃緒申see the buffer and subsequent keyboard commands will apply to it.
+
鐃緒申��申鐃緒申Contrast this with @code{set-buffer}, which makes @var{buffer-or-name}
+
鐃緒申��申鐃緒申the current buffer but does not display it in the selected window.
+
鐃緒申��申鐃緒申@xref{Current Buffer}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If @var{buffer-or-name} does not identify an existing buffer, then
+
鐃緒申��申鐃緒申a new buffer by that name is created.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申Normally the specified buffer is put at the front of the buffer list.
+
鐃緒申��申鐃緒申This affects the operation of @code{other-buffer}.  However, if
+
鐃緒申��申鐃緒申@var{norecord} is non-@code{nil}, this is not done.  @xref{The Buffer
+
鐃緒申��申鐃緒申List}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The @code{switch-to-buffer} function is often used interactively, as
+
鐃緒申��申鐃緒申the binding of @kbd{C-x b}.  It is also used frequently in programs.  It
+
鐃緒申��申鐃緒申always returns @code{nil}.
+
鐃緒申��申鐃緒申@end deffn
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@deffn Command switch-to-buffer-other-window buffer-or-name
+
鐃緒申��申鐃緒申This function makes @var{buffer-or-name} the current buffer and
+
鐃緒申��申鐃緒申displays it in a window not currently selected.  It then selects that
+
鐃緒申��申鐃緒申window.  The handling of the buffer is the same as in
+
鐃緒申��申鐃緒申@code{switch-to-buffer}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The currently selected window is absolutely never used to do the job.
+
鐃緒申��申鐃緒申If it is the only window, then it is split to make a distinct window for
+
鐃緒申��申鐃緒申this purpose.  If the selected window is already displaying the buffer,
+
鐃緒申��申鐃緒申then it continues to do so, but another window is nonetheless found to
+
鐃緒申��申鐃緒申display it in as well.
+
鐃緒申��申鐃緒申@end deffn
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun pop-to-buffer buffer-or-name &optional other-window
+
鐃緒申��申鐃緒申This function makes @var{buffer-or-name} the current buffer and
+
鐃緒申��申鐃緒申switches to it in some window, preferably not the window previously
+
鐃緒申��申鐃緒申selected.  The ``popped-to'' window becomes the selected window within
+
鐃緒申��申鐃緒申its frame.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If the variable @code{pop-up-frames} is non-@code{nil},
+
鐃緒申��申鐃緒申@code{pop-to-buffer} looks for a window in any visible frame already
+
鐃緒申��申鐃緒申displaying the buffer; if there is one, it returns that window and makes
+
鐃緒申��申鐃緒申it be selected within its frame.  If there is none, it creates a new
+
鐃緒申��申鐃緒申frame and displays the buffer in it.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If @code{pop-up-frames} is @code{nil}, then @code{pop-to-buffer}
+
鐃緒申��申鐃緒申operates entirely within the selected frame.  (If the selected frame has
+
鐃緒申��申鐃緒申just a minibuffer, @code{pop-to-buffer} operates within the most
+
鐃緒申��申鐃緒申recently selected frame that was not just a minibuffer.)
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If the variable @code{pop-up-windows} is non-@code{nil}, windows may
+
鐃緒申��申鐃緒申be split to create a new window that is different from the original
+
鐃緒申��申鐃緒申window.  For details, see @ref{Choosing Window}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If @var{other-window} is non-@code{nil}, @code{pop-to-buffer} finds or
+
鐃緒申��申鐃緒申creates another window even if @var{buffer-or-name} is already visible
+
鐃緒申��申鐃緒申in the selected window.  Thus @var{buffer-or-name} could end up
+
鐃緒申��申鐃緒申displayed in two windows.  On the other hand, if @var{buffer-or-name} is
+
鐃緒申��申鐃緒申already displayed in the selected window and @var{other-window} is
+
鐃緒申��申鐃緒申@code{nil}, then the selected window is considered sufficient display
+
鐃緒申��申鐃緒申for @var{buffer-or-name}, so that nothing needs to be done.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If @var{buffer-or-name} is a string that does not name an existing
+
鐃緒申��申鐃緒申buffer, a buffer by that name is created.
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@node Choosing Window
+
鐃緒申��申鐃緒申@section Choosing a Window for Display
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  This section describes the basic facility that chooses a window to
+
鐃緒申��申鐃緒申display a buffer in---@code{display-buffer}.  All the higher-level
+
鐃緒申��申鐃緒申functions and commands use this subroutine.  Here we describe how to use
+
鐃緒申��申鐃緒申@code{display-buffer} and how to customize it.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@deffn Command display-buffer buffer-or-name &optional not-this-window
+
鐃緒申��申鐃緒申This command makes @var{buffer-or-name} appear in some window, like
+
鐃緒申��申鐃緒申@code{pop-to-buffer}, but it does not select that window and does not
+
鐃緒申��申鐃緒申make the buffer current.  The identity of the selected window is
+
鐃緒申��申鐃緒申unaltered by this function.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If @var{not-this-window} is non-@code{nil}, it means to display the
+
鐃緒申��申鐃緒申specified buffer in a window other than the selected one, even if it is
+
鐃緒申��申鐃緒申already on display in the selected window.  This can cause the buffer to
+
鐃緒申��申鐃緒申appear in two windows at once.  Otherwise, if @var{buffer-or-name} is
+
鐃緒申��申鐃緒申already being displayed in any window, that is good enough, so this
+
鐃緒申��申鐃緒申function does nothing.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@code{display-buffer} returns the window chosen to display
+
鐃緒申��申鐃緒申@var{buffer-or-name}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申Precisely how @code{display-buffer} finds or creates a window depends on
+
鐃緒申��申鐃緒申the variables described below.
+
鐃緒申��申鐃緒申@end deffn
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defopt pop-up-windows
+
鐃緒申��申鐃緒申This variable controls whether @code{display-buffer} makes new windows.
+
鐃緒申��申鐃緒申If it is non-@code{nil} and there is only one window, then that window
+
鐃緒申��申鐃緒申is split.  If it is @code{nil}, then @code{display-buffer} does not
+
鐃緒申��申鐃緒申split the single window, but uses it whole.
+
鐃緒申��申鐃緒申@end defopt
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defopt split-height-threshold
+
鐃緒申��申鐃緒申This variable determines when @code{display-buffer} may split a window,
+
鐃緒申��申鐃緒申if there are multiple windows.  @code{display-buffer} always splits the
+
鐃緒申��申鐃緒申largest window if it has at least this many lines.  If the largest
+
鐃緒申��申鐃緒申window is not this tall, it is split only if it is the sole window and
+
鐃緒申��申鐃緒申@code{pop-up-windows} is non-@code{nil}.
+
鐃緒申��申鐃緒申@end defopt
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@c Emacs 19 feature
+
鐃緒申��申鐃緒申@defopt pop-up-frames
+
鐃緒申��申鐃緒申This variable controls whether @code{display-buffer} makes new frames.
+
鐃緒申��申鐃緒申If it is non-@code{nil}, @code{display-buffer} looks for an existing
+
鐃緒申��申鐃緒申window already displaying the desired buffer, on any visible frame.  If
+
鐃緒申��申鐃緒申it finds one, it returns that window.  Otherwise it makes a new frame.
+
鐃緒申��申鐃緒申The variables @code{pop-up-windows} and @code{split-height-threshold} do
+
鐃緒申��申鐃緒申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.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@xref{Frames}, for more information.
+
鐃緒申��申鐃緒申@end defopt
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@c Emacs 19 feature
+
鐃緒申��申鐃緒申@defvar pop-up-frame-function
+
鐃緒申��申鐃緒申This variable specifies how to make a new frame if @code{pop-up-frames}
+
鐃緒申��申鐃緒申is non-@code{nil}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申Its value should 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 the
+
鐃緒申��申鐃緒申variable is a function that creates a frame using parameters from
+
鐃緒申��申鐃緒申@code{pop-up-frame-alist}.
+
鐃緒申��申鐃緒申@end defvar
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defvar pop-up-frame-alist
+
鐃緒申��申鐃緒申This variable holds an alist specifying frame parameters used when
+
鐃緒申��申鐃緒申@code{display-buffer} makes a new frame.  @xref{Frame Parameters}, for
+
鐃緒申��申鐃緒申more information about frame parameters.
+
鐃緒申��申鐃緒申@end defvar
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defvar special-display-buffer-names
+
鐃緒申��申鐃緒申A list of buffer names for buffers that should be displayed specially.
+
鐃緒申��申鐃緒申If the buffer's name is in this list, @code{display-buffer} handles the
+
鐃緒申��申鐃緒申buffer specially.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申By default, special display means to give the buffer a dedicated frame.
+
鐃緒申��申鐃緒申@end defvar
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defvar special-display-regexps
+
鐃緒申��申鐃緒申A list of regular expressions that specify buffers that should be
+
鐃緒申��申鐃緒申displayed specially.  If the buffer's name matches any of the regular
+
鐃緒申��申鐃緒申expressions in this list, @code{display-buffer} handles the buffer
+
鐃緒申��申鐃緒申specially.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申By default, special display means to give the buffer a dedicated frame.
+
鐃緒申��申鐃緒申@end defvar
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defvar special-display-function
+
鐃緒申��申鐃緒申This variable holds the function to call to display a buffer specially.
+
鐃緒申��申鐃緒申It receives the buffer as an argument, and should return the window in
+
鐃緒申��申鐃緒申which it is displayed.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The default value of this variable is
+
鐃緒申��申鐃緒申@code{special-display-popup-frame}.
+
鐃緒申��申鐃緒申@end defvar
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun special-display-popup-frame buffer
+
鐃緒申��申鐃緒申This function makes @var{buffer} visible in a frame of its own.  If
+
鐃緒申��申鐃緒申@var{buffer} is already displayed in a window in some frame, it makes
+
鐃緒申��申鐃緒申the frame visible and raises it, to use that window.  Otherwise, it
+
鐃緒申��申鐃緒申creates a frame that will be dedicated to @var{buffer}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申This function uses an existing window displaying @var{buffer} whether or
+
鐃緒申��申鐃緒申not it is in a frame of its own; but if you set up the above variables
+
鐃緒申��申鐃緒申in your init file, before @var{buffer} was created, then presumably the
+
鐃緒申��申鐃緒申window was previously made by this function.
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defopt special-display-frame-alist
+
鐃緒申��申鐃緒申This variable holds frame parameters for
+
鐃緒申��申鐃緒申@code{special-display-popup-frame} to use when it creates a frame.
+
鐃緒申��申鐃緒申@end defopt
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@c Emacs 19 feature
+
鐃緒申��申鐃緒申@defvar display-buffer-function
+
鐃緒申��申鐃緒申This variable is the most flexible way to customize the behavior of
+
鐃緒申��申鐃緒申@code{display-buffer}.  If it is non-@code{nil}, it should be a function
+
鐃緒申��申鐃緒申that @code{display-buffer} calls to do the work.  The function should
+
鐃緒申��申鐃緒申accept two arguments, the same two arguments that @code{display-buffer}
+
鐃緒申��申鐃緒申received.  It should choose or create a window, display the specified
+
鐃緒申��申鐃緒申buffer, and then return the window.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申This hook takes precedence over all the other options and hooks
+
鐃緒申��申鐃緒申described above.
+
鐃緒申��申鐃緒申@end defvar
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@c Emacs 19 feature
+
鐃緒申��申鐃緒申@cindex dedicated window
+
鐃緒申��申鐃緒申A window can be marked as ``dedicated'' to its buffer.  Then
+
鐃緒申��申鐃緒申@code{display-buffer} does not try to use that window.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun window-dedicated-p window
+
鐃緒申��申鐃緒申This function returns @code{t} if @var{window} is marked as dedicated;
+
鐃緒申��申鐃緒申otherwise @code{nil}.
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun set-window-dedicated-p window flag
+
鐃緒申��申鐃緒申This function marks @var{window} as dedicated if @var{flag} is
+
鐃緒申��申鐃緒申non-@code{nil}, and nondedicated otherwise.
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@node Window Point
+
鐃緒申��申鐃緒申@section Windows and Point
+
鐃緒申��申鐃緒申@cindex window position
+
鐃緒申��申鐃緒申@cindex window point
+
鐃緒申��申鐃緒申@cindex position in window
+
鐃緒申��申鐃緒申@cindex point in window
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  Each window has its own value of point, independent of the value of
+
鐃緒申��申鐃緒申point in other windows displaying the same buffer.  This makes it useful
+
鐃緒申��申鐃緒申to have multiple windows showing one buffer.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@itemize @bullet
+
鐃緒申��申鐃緒申@item
+
鐃緒申��申鐃緒申The window point is established when a window is first created; it is
+
鐃緒申��申鐃緒申initialized from the buffer's point, or from the window point of another
+
鐃緒申��申鐃緒申window opened on the buffer if such a window exists.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@item
+
鐃緒申��申鐃緒申Selecting a window sets the value of point in its buffer to the window's
+
鐃緒申��申鐃緒申value of point.  Conversely, deselecting a window sets the window's
+
鐃緒申��申鐃緒申value of point from that of the buffer.  Thus, when you switch between
+
鐃緒申��申鐃緒申windows that display a given buffer, the point value for the selected
+
鐃緒申��申鐃緒申window is in effect in the buffer, while the point values for the other
+
鐃緒申��申鐃緒申windows are stored in those windows.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@item
+
鐃緒申��申鐃緒申As long as the selected window displays the current buffer, the window's
+
鐃緒申��申鐃緒申point and the buffer's point always move together; they remain equal.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@item
+
鐃緒申��申鐃緒申@xref{Positions}, for more details on buffer positions.
+
鐃緒申��申鐃緒申@end itemize
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  As far as the user is concerned, point is where the cursor is, and
+
鐃緒申��申鐃緒申when the user switches to another buffer, the cursor jumps to the
+
鐃緒申��申鐃緒申position of point in that buffer.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun window-point window
+
鐃緒申��申鐃緒申This function returns the current position of point in @var{window}.
+
鐃緒申��申鐃緒申For a nonselected window, this is the value point would have (in that
+
鐃緒申��申鐃緒申window's buffer) if that window were selected.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申When @var{window} is the selected window and its buffer is also the
+
鐃緒申��申鐃緒申current buffer, the value returned is the same as point in that buffer.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申Strictly speaking, it would be 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
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun set-window-point window position
+
鐃緒申��申鐃緒申This function positions point in @var{window} at position
+
鐃緒申��申鐃緒申@var{position} in @var{window}'s buffer.
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@node Window Start
+
鐃緒申��申鐃緒申@section The Window Start Position
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  Each window contains a marker used to keep track of a buffer position
+
鐃緒申��申鐃緒申that specifies where in the buffer display should start.  This position
+
鐃緒申��申鐃緒申is called the @dfn{display-start} position of the window (or just the
+
鐃緒申��申鐃緒申@dfn{start}).  The character after this position is the one that appears
+
鐃緒申��申鐃緒申at the upper left corner of the window.  It is usually, but not
+
鐃緒申��申鐃緒申inevitably, at the beginning of a text line.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun window-start &optional window
+
鐃緒申��申鐃緒申@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
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申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
+
鐃緒申��申鐃緒申for the same buffer, or 1 if the buffer doesn't have any.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申For a realistic example, see the description of @code{count-lines} in
+
鐃緒申��申鐃緒申@ref{Text Lines}.
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun window-end &optional window
+
鐃緒申��申鐃緒申This function returns the position of the end of the display in window
+
鐃緒申��申鐃緒申@var{window}.  If @var{window} is @code{nil}, the selected window is
+
鐃緒申��申鐃緒申used.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If the last redisplay of @var{window} was preempted, and did not finish,
+
鐃緒申��申鐃緒申Emacs does not know the position of the end of display in that window.
+
鐃緒申��申鐃緒申In that case, this function returns a value that is not correct.  In a
+
鐃緒申��申鐃緒申future version, @code{window-end} will return @code{nil} in that case.
+
鐃緒申��申鐃緒申@ignore
+
鐃緒申��申鐃緒申in that case, this function returns @code{nil}.  You can compute where
+
鐃緒申��申鐃緒申the end of the window @emph{would} have been, if redisplay had finished,
+
鐃緒申��申鐃緒申like this:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@example
+
鐃緒申��申鐃緒申(save-excursion
+
鐃緒申��申鐃緒申  (goto-char (window-start window))
+
鐃緒申��申鐃緒申  (vertical-motion (1- (window-height window))
+
鐃緒申��申鐃緒申                   window)
+
鐃緒申��申鐃緒申  (point))
+
鐃緒申��申鐃緒申@end example
+
鐃緒申��申鐃緒申@end ignore
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun set-window-start window position &optional noforce
+
鐃緒申��申鐃緒申This function sets the display-start position of @var{window} to
+
鐃緒申��申鐃緒申@var{position} in @var{window}'s buffer.  It returns @var{position}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The display routines insist that the position of point be visible when a
+
鐃緒申��申鐃緒申buffer is displayed.  Normally, they change the display-start position
+
鐃緒申��申鐃緒申(that is, scroll the window) whenever necessary to make point visible.
+
鐃緒申��申鐃緒申However, if you specify the start position with this function using
+
鐃緒申��申鐃緒申@code{nil} for @var{noforce}, it means you want display to start at
+
鐃緒申��申鐃緒申@var{position} even if that would put the location of point off the
+
鐃緒申��申鐃緒申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
+
鐃緒申��申鐃緒申2}, then point would 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:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@example
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申;; @r{Here is what @samp{foo} looks like before executing}
+
鐃緒申��申鐃緒申;;   @r{the @code{set-window-start} expression.}
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申---------- Buffer: foo ----------
+
鐃緒申��申鐃緒申@point{}This is the contents of buffer foo.
+
鐃緒申��申鐃緒申2
+
鐃緒申��申鐃緒申3
+
鐃緒申��申鐃緒申4
+
鐃緒申��申鐃緒申5
+
鐃緒申��申鐃緒申6
+
鐃緒申��申鐃緒申---------- Buffer: foo ----------
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(set-window-start
+
鐃緒申��申鐃緒申 (selected-window)
+
鐃緒申��申鐃緒申 (1+ (window-start)))
+
鐃緒申��申鐃緒申@result{} 2
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申;; @r{Here is what @samp{foo} looks like after executing}
+
鐃緒申��申鐃緒申;;   @r{the @code{set-window-start} expression.}
+
鐃緒申��申鐃緒申---------- Buffer: foo ----------
+
鐃緒申��申鐃緒申his is the contents of buffer foo.
+
鐃緒申��申鐃緒申2
+
鐃緒申��申鐃緒申3
+
鐃緒申��申鐃緒申@point{}4
+
鐃緒申��申鐃緒申5
+
鐃緒申��申鐃緒申6
+
鐃緒申��申鐃緒申---------- Buffer: foo ----------
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end example
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If @var{noforce} is non-@code{nil}, and @var{position} would place point
+
鐃緒申��申鐃緒申off screen at the next redisplay, then redisplay computes a new window-start
+
鐃緒申��申鐃緒申position that works well with point, and thus @var{position} is not used.
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun pos-visible-in-window-p &optional position window
+
鐃緒申��申鐃緒申This function returns @code{t} 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.  The
+
鐃緒申��申鐃緒申argument @var{position} defaults to the current position of point;
+
鐃緒申��申鐃緒申@var{window}, to the selected window.  Here is an example:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@example
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(or (pos-visible-in-window-p
+
鐃緒申��申鐃緒申     (point) (selected-window))
+
鐃緒申��申鐃緒申    (recenter 0))
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end example
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The @code{pos-visible-in-window-p} function considers only vertical
+
鐃緒申��申鐃緒申scrolling.  If @var{position} is out of view only because @var{window}
+
鐃緒申��申鐃緒申has been scrolled horizontally, @code{pos-visible-in-window-p} returns
+
鐃緒申��申鐃緒申@code{t}.  @xref{Horizontal Scrolling}.
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@node Vertical Scrolling
+
鐃緒申��申鐃緒申@section Vertical Scrolling
+
鐃緒申��申鐃緒申@cindex vertical scrolling
+
鐃緒申��申鐃緒申@cindex scrolling vertically
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  Vertical scrolling means moving the text up or down in a window.  It
+
鐃緒申��申鐃緒申works by changing the value of the window's display-start location.  It
+
鐃緒申��申鐃緒申may also change the value of @code{window-point} to keep it on the
+
鐃緒申��申鐃緒申screen.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  In the commands @code{scroll-up} and @code{scroll-down}, the directions
+
鐃緒申��申鐃緒申``up'' and ``down'' refer to the motion of the text in the buffer at which
+
鐃緒申��申鐃緒申you are looking through the window.  Imagine that the text is
+
鐃緒申��申鐃緒申written on a long roll of paper and that the scrolling commands move the
+
鐃緒申��申鐃緒申paper up and down.  Thus, if you are looking at text in the 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
+
鐃緒申��申鐃緒申imagine that the window moves over text that remains in place.  Then
+
鐃緒申��申鐃緒申``down'' commands would take you to the end of the buffer.  This view is
+
鐃緒申��申鐃緒申more consistent with the actual relationship between windows and the
+
鐃緒申��申鐃緒申text in the buffer, but it is less like what the user sees.  The
+
鐃緒申��申鐃緒申position of a window on the terminal does not move, and short scrolling
+
鐃緒申��申鐃緒申commands clearly move the text up or down on the screen.  We have chosen
+
鐃緒申��申鐃緒申names that fit the user's point of view.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  The scrolling functions (aside from @code{scroll-other-window}) have
+
鐃緒申��申鐃緒申unpredictable results if the current buffer is different from the buffer
+
鐃緒申��申鐃緒申that is displayed in the selected window.  @xref{Current Buffer}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@deffn Command scroll-up &optional count
+
鐃緒申��申鐃緒申This function scrolls the text in the selected window upward
+
鐃緒申��申鐃緒申@var{count} lines.  If @var{count} is negative, scrolling is actually
+
鐃緒申��申鐃緒申downward.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If @var{count} is @code{nil} (or omitted), then the length of scroll
+
鐃緒申��申鐃緒申is @code{next-screen-context-lines} lines less than the usable height of
+
鐃緒申��申鐃緒申the window (not counting its mode line).
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@code{scroll-up} returns @code{nil}.
+
鐃緒申��申鐃緒申@end deffn
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@deffn Command scroll-down &optional count
+
鐃緒申��申鐃緒申This function scrolls the text in the selected window downward
+
鐃緒申��申鐃緒申@var{count} lines.  If @var{count} is negative, scrolling is actually
+
鐃緒申��申鐃緒申upward.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If @var{count} is omitted or @code{nil}, then the length of the scroll
+
鐃緒申��申鐃緒申is @code{next-screen-context-lines} lines less than the usable height of
+
鐃緒申��申鐃緒申the window (not counting its mode line).
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@code{scroll-down} returns @code{nil}.
+
鐃緒申��申鐃緒申@end deffn
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@deffn Command scroll-other-window &optional count
+
鐃緒申��申鐃緒申This function scrolls the text in another window upward @var{count}
+
鐃緒申��申鐃緒申lines.  Negative values of @var{count}, or @code{nil}, are handled
+
鐃緒申��申鐃緒申as in @code{scroll-up}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The window that is scrolled is normally the one following the selected
+
鐃緒申��申鐃緒申window in the cyclic ordering of windows---the window that
+
鐃緒申��申鐃緒申@code{next-window} would return.  @xref{Cyclic Window Ordering}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申You can specify a buffer to scroll with the variable
+
鐃緒申��申鐃緒申@code{other-window-scroll-buffer}.  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 with the variable
+
鐃緒申��申鐃緒申@code{minibuffer-scroll-window}.  This variable has no effect when any
+
鐃緒申��申鐃緒申other window is selected.  @xref{Minibuffer Misc}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申When the minibuffer is active, it is the next window if the selected
+
鐃緒申��申鐃緒申window is the one at the bottom right corner.  In this case,
+
鐃緒申��申鐃緒申@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
+
鐃緒申��申鐃緒申``Beginning of buffer''.
+
鐃緒申��申鐃緒申@end deffn
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@c Emacs 19 feature
+
鐃緒申��申鐃緒申@defvar other-window-scroll-buffer
+
鐃緒申��申鐃緒申If this variable is non-@code{nil}, it tells @code{scroll-other-window}
+
鐃緒申��申鐃緒申which buffer to scroll.
+
鐃緒申��申鐃緒申@end defvar
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defopt scroll-step
+
鐃緒申��申鐃緒申This variable controls how scrolling is done automatically when point
+
鐃緒申��申鐃緒申moves off the screen.  If the value is zero, then redisplay scrolls the
+
鐃緒申��申鐃緒申text to center point vertically in the window.  If the value is a
+
鐃緒申��申鐃緒申positive integer @var{n}, then redisplay brings point back on screen by
+
鐃緒申��申鐃緒申scrolling @var{n} lines in either direction, if possible; otherwise, it
+
鐃緒申��申鐃緒申centers point.  The default value is zero.
+
鐃緒申��申鐃緒申@end defopt
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defopt next-screen-context-lines
+
鐃緒申��申鐃緒申The value of this variable is the number of lines of continuity to
+
鐃緒申��申鐃緒申retain when scrolling by full screens.  For example, @code{scroll-up}
+
鐃緒申��申鐃緒申with an argument of @code{nil} scrolls so that this many lines at the
+
鐃緒申��申鐃緒申bottom of the window appear instead at the top.  The default value is
+
鐃緒申��申鐃緒申@code{2}.
+
鐃緒申��申鐃緒申@end defopt
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@deffn Command recenter &optional count
+
鐃緒申��申鐃緒申@cindex centering point
+
鐃緒申��申鐃緒申This function scrolls the selected window to put the text where point
+
鐃緒申��申鐃緒申is located at a specified vertical position within the window.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If @var{count} is a nonnegative number, it puts the line containing
+
鐃緒申��申鐃緒申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.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申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.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申When @code{recenter} is called interactively, @var{count} is the raw
+
鐃緒申��申鐃緒申prefix argument.  Thus, typing @kbd{C-u} as the prefix sets the
+
鐃緒申��申鐃緒申@var{count} to a non-@code{nil} list, while typing @kbd{C-u 4} sets
+
鐃緒申��申鐃緒申@var{count} to 4, which positions the current line four lines from 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,
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@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))
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申(global-set-key [kp-multiply] 'line-to-top-of-window)  
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end example
+
鐃緒申��申鐃緒申@end deffn
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@node Horizontal Scrolling
+
鐃緒申��申鐃緒申@section Horizontal Scrolling
+
鐃緒申��申鐃緒申@cindex horizontal scrolling
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  Because we read English first from top to bottom and second from left
+
鐃緒申��申鐃緒申to right, horizontal scrolling is not like vertical scrolling.  Vertical
+
鐃緒申��申鐃緒申scrolling involves selection of a contiguous portion of text to display.
+
鐃緒申��申鐃緒申Horizontal scrolling causes part of each line to go off screen.  The
+
鐃緒申��申鐃緒申amount of horizontal scrolling is therefore specified as a number of
+
鐃緒申��申鐃緒申columns rather than as a position in the buffer.  It has nothing to do
+
鐃緒申��申鐃緒申with the display-start position returned by @code{window-start}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  Usually, no horizontal scrolling is in effect; then the leftmost
+
鐃緒申��申鐃緒申column is at the left edge of the window.  In this state, scrolling to
+
鐃緒申��申鐃緒申the right is meaningless, since there is no data to the left of the
+
鐃緒申��申鐃緒申screen to be revealed by it; so this is not allowed.  Scrolling to the
+
鐃緒申��申鐃緒申left is allowed; it scrolls the first columns of text off the edge of
+
鐃緒申��申鐃緒申the window and can reveal additional columns on the right that were
+
鐃緒申��申鐃緒申truncated before.  Once a window has a nonzero amount of leftward
+
鐃緒申��申鐃緒申horizontal scrolling, you can scroll it back to the right, but only so
+
鐃緒申��申鐃緒申far as to reduce the net horizontal scroll to zero.  There is no limit
+
鐃緒申��申鐃緒申to how far left you can scroll, but eventually all the text will
+
鐃緒申��申鐃緒申disappear off the left edge.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@deffn Command scroll-left count
+
鐃緒申��申鐃緒申This function scrolls the selected window @var{count} columns to the
+
鐃緒申��申鐃緒申left (or to the right if @var{count} is negative).  The return value is
+
鐃緒申��申鐃緒申the total amount of leftward horizontal scrolling in effect after the
+
鐃緒申��申鐃緒申change---just like the value returned by @code{window-hscroll} (below).
+
鐃緒申��申鐃緒申@end deffn
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@deffn Command scroll-right count
+
鐃緒申��申鐃緒申This function scrolls the selected window @var{count} columns to the
+
鐃緒申��申鐃緒申right (or to the left if @var{count} is negative).  The return value is
+
鐃緒申��申鐃緒申the total amount of leftward horizontal scrolling in effect after the
+
鐃緒申��申鐃緒申change---just like the value returned by @code{window-hscroll} (below).
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申Once you scroll a window as far right as it can go, back to its normal
+
鐃緒申��申鐃緒申position where the total leftward scrolling is zero, attempts to scroll
+
鐃緒申��申鐃緒申any farther right have no effect.
+
鐃緒申��申鐃緒申@end deffn
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun window-hscroll &optional window
+
鐃緒申��申鐃緒申This function returns the total leftward horizontal scrolling of
+
鐃緒申��申鐃緒申@var{window}---the number of columns by which the text in @var{window}
+
鐃緒申��申鐃緒申is scrolled left past the left margin.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The value is never negative.  It is zero when no horizontal scrolling
+
鐃緒申��申鐃緒申has been done in @var{window} (which is usually the case).
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If @var{window} is @code{nil}, the selected window is used.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@example
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(window-hscroll)
+
鐃緒申��申鐃緒申     @result{} 0
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(scroll-left 5)
+
鐃緒申��申鐃緒申     @result{} 5
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(window-hscroll)
+
鐃緒申��申鐃緒申     @result{} 5
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end example
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun set-window-hscroll window columns
+
鐃緒申��申鐃緒申This function sets the number of columns from the left margin that
+
鐃緒申��申鐃緒申@var{window} is scrolled to the value of @var{columns}.  The argument
+
鐃緒申��申鐃緒申@var{columns} should be zero or positive; if not, it is taken as zero.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The value returned is @var{columns}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@example
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(set-window-hscroll (selected-window) 10)
+
鐃緒申��申鐃緒申     @result{} 10
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end example
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  Here is how you can determine whether a given position @var{position}
+
鐃緒申��申鐃緒申is off the screen due to horizontal scrolling:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@example
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(defun hscroll-on-screen (window position)
+
鐃緒申��申鐃緒申  (save-excursion 
+
鐃緒申��申鐃緒申    (goto-char position)
+
鐃緒申��申鐃緒申    (and 
+
鐃緒申��申鐃緒申     (>= (- (current-column) (window-hscroll window)) 0)
+
鐃緒申��申鐃緒申     (< (- (current-column) (window-hscroll window))
+
鐃緒申��申鐃緒申        (window-width window)))))
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end example
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@node Size of Window
+
鐃緒申��申鐃緒申@section The Size of a Window
+
鐃緒申��申鐃緒申@cindex window size
+
鐃緒申��申鐃緒申@cindex size of window
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  An Emacs window is rectangular, and its size information consists of
+
鐃緒申��申鐃緒申the height (the number of lines) and the width (the number of character
+
鐃緒申��申鐃緒申positions in each line).  The mode line is included in the height.  But
+
鐃緒申��申鐃緒申the width does not count the scroll bar or the column of @samp{|}
+
鐃緒申��申鐃緒申characters that separates side-by-side windows.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  The following three functions return size information about a window:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun window-height &optional window
+
鐃緒申��申鐃緒申This function returns the number of lines in @var{window}, including
+
鐃緒申��申鐃緒申its mode line.  If @var{window} fills its entire frame, this is one less
+
鐃緒申��申鐃緒申than the value of @code{frame-height} on that frame (since the last line
+
鐃緒申��申鐃緒申is always reserved for the minibuffer).
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If @var{window} is @code{nil}, the function uses the selected window.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@example
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(window-height)
+
鐃緒申��申鐃緒申     @result{} 23
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(split-window-vertically)
+
鐃緒申��申鐃緒申     @result{} #<window 4 on windows.texi>
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(window-height)
+
鐃緒申��申鐃緒申     @result{} 11
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end example
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun window-width &optional window
+
鐃緒申��申鐃緒申This function returns the number of columns in @var{window}.  If
+
鐃緒申��申鐃緒申@var{window} fills its entire frame, this is the same as the value of
+
鐃緒申��申鐃緒申@code{frame-width} on that frame.  The width does not include the
+
鐃緒申��申鐃緒申window's scroll bar or the column of @samp{|} characters that separates
+
鐃緒申��申鐃緒申side-by-side windows.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If @var{window} is @code{nil}, the function uses the selected window.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@example
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(window-width)
+
鐃緒申��申鐃緒申     @result{} 80
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end example
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun window-edges &optional window
+
鐃緒申��申鐃緒申This function returns a list of the edge coordinates of @var{window}.
+
鐃緒申��申鐃緒申If @var{window} is @code{nil}, the selected window is used.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The order of the list is @code{(@var{left} @var{top} @var{right}
+
鐃緒申��申鐃緒申@var{bottom})}, all elements relative to 0, 0 at the top left corner of
+
鐃緒申��申鐃緒申the frame.  The element @var{right} of the value is one more than the
+
鐃緒申��申鐃緒申rightmost column used by @var{window}, and @var{bottom} is one more than
+
鐃緒申��申鐃緒申the bottommost row used by @var{window} and its mode-line.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申When you have side-by-side windows, the right edge value for a window
+
鐃緒申��申鐃緒申with a neighbor on the right includes the width of the separator between
+
鐃緒申��申鐃緒申the window and that neighbor.  This separator may be a column of
+
鐃緒申��申鐃緒申@samp{|} characters or it may be a scroll bar.  Since the width of the
+
鐃緒申��申鐃緒申window does not include this separator, the width does not equal the
+
鐃緒申��申鐃緒申difference between the right and left edges in this case.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申Here is the result obtained on a typical 24-line terminal with just one
+
鐃緒申��申鐃緒申window:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@example
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(window-edges (selected-window))
+
鐃緒申��申鐃緒申     @result{} (0 0 80 23)
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end example
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@noindent
+
鐃緒申��申鐃緒申The bottom edge is at line 23 because the last line is the echo area.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If @var{window} is at the upper left corner of its frame, @var{right}
+
鐃緒申��申鐃緒申and @var{bottom} are the same as the values returned by
+
鐃緒申��申鐃緒申@code{(window-width)} and @code{(window-height)} respectively, and
+
鐃緒申��申鐃緒申@var{top} and @var{bottom} are zero.  For example, the edges of the
+
鐃緒申��申鐃緒申following window are @w{@samp{0 0 5 8}}.  Assuming that the frame has
+
鐃緒申��申鐃緒申more than 8 columns, the last column of the window (column 7) holds a
+
鐃緒申��申鐃緒申border rather than text.  The last row (row 4) holds the mode line,
+
鐃緒申��申鐃緒申shown here with @samp{xxxxxxxxx}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@example
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申           0    
+
鐃緒申��申鐃緒申           _______
+
鐃緒申��申鐃緒申        0 |       | 
+
鐃緒申��申鐃緒申          |       |   
+
鐃緒申��申鐃緒申          |       | 
+
鐃緒申��申鐃緒申          |       | 
+
鐃緒申��申鐃緒申          xxxxxxxxx  4
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申                  7  
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end example
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申When there are side-by-side windows, any window not at the right edge of
+
鐃緒申��申鐃緒申its frame has a separator in its last column or columns.  The separator
+
鐃緒申��申鐃緒申counts as one or two columns in the width of the window.  A window never
+
鐃緒申��申鐃緒申includes a separator on its left, since that belongs to the window to
+
鐃緒申��申鐃緒申the left.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申In the following example, let's suppose that the frame is 7
+
鐃緒申��申鐃緒申columns wide.  Then the edges of the left window are @w{@samp{0 0 4 3}}
+
鐃緒申��申鐃緒申and the edges of the right window are @w{@samp{4 0 7 3}}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@example
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申           ___ ___
+
鐃緒申��申鐃緒申          |   |   |    
+
鐃緒申��申鐃緒申          |   |   |    
+
鐃緒申��申鐃緒申          xxxxxxxxx 
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申           0  34  7
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end example
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@node Resizing Windows
+
鐃緒申��申鐃緒申@section Changing the Size of a Window
+
鐃緒申��申鐃緒申@cindex window resizing
+
鐃緒申��申鐃緒申@cindex changing window size
+
鐃緒申��申鐃緒申@cindex window size, changing
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  The window size functions fall into two classes: high-level commands
+
鐃緒申��申鐃緒申that change the size of windows and low-level functions that access
+
鐃緒申��申鐃緒申window size.  Emacs does not permit overlapping windows or gaps between
+
鐃緒申��申鐃緒申windows, so resizing one window affects other windows.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@deffn Command enlarge-window size &optional horizontal
+
鐃緒申��申鐃緒申This function makes the selected window @var{size} lines taller,
+
鐃緒申��申鐃緒申stealing lines from neighboring windows.  It takes the lines from one
+
鐃緒申��申鐃緒申window at a time until that window is used up, then takes from another.
+
鐃緒申��申鐃緒申If a window from which lines are stolen shrinks below
+
鐃緒申��申鐃緒申@code{window-min-height} lines, that window disappears.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If @var{horizontal} is non-@code{nil}, this function makes
+
鐃緒申��申鐃緒申@var{window} wider by @var{size} columns, stealing columns instead of
+
鐃緒申��申鐃緒申lines.  If a window from which columns are stolen shrinks below
+
鐃緒申��申鐃緒申@code{window-min-width} columns, that window disappears.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If the requested size would exceed that of the window's frame, then the
+
鐃緒申��申鐃緒申function makes the window occupy the entire height (or width) of the
+
鐃緒申��申鐃緒申frame.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If @var{size} is negative, this function shrinks the window by
+
鐃緒申��申鐃緒申@minus{}@var{size} lines or columns.  If that makes the window smaller
+
鐃緒申��申鐃緒申than the minimum size (@code{window-min-height} and
+
鐃緒申��申鐃緒申@code{window-min-width}), @code{enlarge-window} deletes the window.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@code{enlarge-window} returns @code{nil}.  
+
鐃緒申��申鐃緒申@end deffn
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@deffn Command enlarge-window-horizontally columns
+
鐃緒申��申鐃緒申This function makes the selected window @var{columns} wider.
+
鐃緒申��申鐃緒申It could be defined as follows:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@example
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(defun enlarge-window-horizontally (columns)
+
鐃緒申��申鐃緒申  (enlarge-window columns t))
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end example
+
鐃緒申��申鐃緒申@end deffn
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@deffn Command shrink-window size &optional horizontal
+
鐃緒申��申鐃緒申This function is like @code{enlarge-window} but negates the argument
+
鐃緒申��申鐃緒申@var{size}, making the selected window smaller by giving lines (or
+
鐃緒申��申鐃緒申columns) to the other windows.  If the window shrinks below
+
鐃緒申��申鐃緒申@code{window-min-height} or @code{window-min-width}, then it disappears.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If @var{size} is negative, the window is enlarged by @minus{}@var{size}
+
鐃緒申��申鐃緒申lines or columns.
+
鐃緒申��申鐃緒申@end deffn
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@deffn Command shrink-window-horizontally columns
+
鐃緒申��申鐃緒申This function makes the selected window @var{columns} narrower.
+
鐃緒申��申鐃緒申It could be defined as follows:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@example
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(defun shrink-window-horizontally (columns)
+
鐃緒申��申鐃緒申  (shrink-window columns t))
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end example
+
鐃緒申��申鐃緒申@end deffn
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@cindex minimum window size
+
鐃緒申��申鐃緒申  The following two variables constrain the window-size-changing
+
鐃緒申��申鐃緒申functions to a minimum height and width.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defopt window-min-height
+
鐃緒申��申鐃緒申The value of this variable determines how short a window may become
+
鐃緒申��申鐃緒申before it is automatically deleted.  Making a window smaller than
+
鐃緒申��申鐃緒申@code{window-min-height} automatically deletes it, and no window may be
+
鐃緒申��申鐃緒申created shorter than this.  The absolute minimum height is two (allowing
+
鐃緒申��申鐃緒申one line for the mode line, and one line for the buffer display).
+
鐃緒申��申鐃緒申Actions that change window sizes reset this variable to two if it is
+
鐃緒申��申鐃緒申less than two.  The default value is 4.
+
鐃緒申��申鐃緒申@end defopt
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defopt window-min-width
+
鐃緒申��申鐃緒申The value of this variable determines how narrow a window may become
+
鐃緒申��申鐃緒申before it automatically deleted.  Making a window smaller than
+
鐃緒申��申鐃緒申@code{window-min-width} automatically deletes it, and no window may be
+
鐃緒申��申鐃緒申created narrower than this.  The absolute minimum width is one; any
+
鐃緒申��申鐃緒申value below that is ignored.  The default value is 10.
+
鐃緒申��申鐃緒申@end defopt
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@node Coordinates and Windows
+
鐃緒申��申鐃緒申@section Coordinates and Windows
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申This section describes how to relate screen coordinates to windows.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@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}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申If you omit @var{frame}, the selected frame is used.
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun coordinates-in-window-p coordinates window
+
鐃緒申��申鐃緒申This function checks whether a particular frame position falls within
+
鐃緒申��申鐃緒申the window @var{window}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The argument @var{coordinates} is a cons cell of this form:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@example
+
鐃緒申��申鐃緒申(@var{x} . @var{y})
+
鐃緒申��申鐃緒申@end example
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@noindent
+
鐃緒申��申鐃緒申The coordinates @var{x} and @var{y} are measured in characters, and
+
鐃緒申��申鐃緒申count from the top left corner of the screen or frame.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The value of @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:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@table @code
+
鐃緒申��申鐃緒申@item (@var{relx} . @var{rely})
+
鐃緒申��申鐃緒申The coordinates are inside @var{window}.  The numbers @var{relx} and
+
鐃緒申��申鐃緒申@var{rely} are the equivalent window-relative coordinates for the
+
鐃緒申��申鐃緒申specified position, counting from 0 at the top left corner of the
+
鐃緒申��申鐃緒申window.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@item mode-line
+
鐃緒申��申鐃緒申The coordinates are in the mode line of @var{window}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@item vertical-split
+
鐃緒申��申鐃緒申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 
+
鐃緒申��申鐃緒申have a scroll bar; positions in a scroll bar are considered outside the
+
鐃緒申��申鐃緒申window.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@item nil
+
鐃緒申��申鐃緒申The coordinates are not in any part of @var{window}.
+
鐃緒申��申鐃緒申@end table
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The function @code{coordinates-in-window-p} does not require a frame as
+
鐃緒申��申鐃緒申argument because it always uses the frame that @var{window} is on.
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@node Window Configurations
+
鐃緒申��申鐃緒申@section Window Configurations
+
鐃緒申��申鐃緒申@cindex window configurations
+
鐃緒申��申鐃緒申@cindex saving window information
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  A @dfn{window configuration} records the entire layout of a
+
鐃緒申��申鐃緒申frame---all windows, their sizes, which buffers they contain, what part
+
鐃緒申��申鐃緒申of each buffer is displayed, and the values of point and the mark.  You
+
鐃緒申��申鐃緒申can bring back an entire previous layout by restoring a window
+
鐃緒申��申鐃緒申configuration previously saved.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  If you want to record all frames instead of just one, use a frame
+
鐃緒申��申鐃緒申configuration instead of a window configuration.  @xref{Frame
+
鐃緒申��申鐃緒申Configurations}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun current-window-configuration
+
鐃緒申��申鐃緒申This function returns a new object representing Emacs's current window
+
鐃緒申��申鐃緒申configuration, namely the number of windows, their sizes and current
+
鐃緒申��申鐃緒申buffers, which window is the selected window, and for each window the
+
鐃緒申��申鐃緒申displayed buffer, the display-start position, and the positions of point
+
鐃緒申��申鐃緒申and the mark.  An exception is made for point in the current buffer,
+
鐃緒申��申鐃緒申whose value is not saved.
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun set-window-configuration configuration
+
鐃緒申��申鐃緒申This function restores the configuration of Emacs's windows and
+
鐃緒申��申鐃緒申buffers to the state specified by @var{configuration}.  The argument
+
鐃緒申��申鐃緒申@var{configuration} must be a value that was previously returned by
+
鐃緒申��申鐃緒申@code{current-window-configuration}.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申Here is a way of using this function to get the same effect
+
鐃緒申��申鐃緒申as @code{save-window-excursion}:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@example
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(let ((config (current-window-configuration)))
+
鐃緒申��申鐃緒申  (unwind-protect
+
鐃緒申��申鐃緒申      (progn (split-window-vertically nil)
+
鐃緒申��申鐃緒申             @dots{})
+
鐃緒申��申鐃緒申    (set-window-configuration config)))
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end example
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defspec 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 the value of point and the portion of the buffer
+
鐃緒申��申鐃緒申that is visible.  It also includes the choice of selected window.
+
鐃緒申��申鐃緒申However, it does not include the value of point in the current buffer;
+
鐃緒申��申鐃緒申use @code{save-excursion} if you wish to preserve that.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申The return value is the value of the final form in @var{forms}.
+
鐃緒申��申鐃緒申For example:
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@example
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(split-window)
+
鐃緒申��申鐃緒申     @result{} #<window 25 on control.texi>
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(setq w (selected-window))
+
鐃緒申��申鐃緒申     @result{} #<window 19 on control.texi>
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@group
+
鐃緒申��申鐃緒申(save-window-excursion
+
鐃緒申��申鐃緒申  (delete-other-windows w)
+
鐃緒申��申鐃緒申  (switch-to-buffer "foo")
+
鐃緒申��申鐃緒申  'do-something)
+
鐃緒申��申鐃緒申     @result{} do-something
+
鐃緒申��申鐃緒申     ;; @r{The screen is now split again.}
+
鐃緒申��申鐃緒申@end group
+
鐃緒申��申鐃緒申@end example
+
鐃緒申��申鐃緒申@end defspec
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申@defun window-configuration-p object
+
鐃緒申��申鐃緒申This function returns @code{t} if @var{object} is a window configuration.
+
鐃緒申��申鐃緒申@end defun
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  Primitives to look inside of window configurations would make sense,
+
鐃緒申��申鐃緒申but none are implemented.  It is not clear they are useful enough to be
+
鐃緒申��申鐃緒申worth implementing.